jelq

<!DOCTYPE html>

<html>

<head>

<meta charset="utf-8">

<title>jelqd</title>

<style>

.frame { border: 2px inset; background: #fff; height: 85vh; overflow: scroll; padding: 4px; }

#log { white-space: pre-wrap; margin: 0; }

pre, li, p, td, label { overflow-wrap: anywhere; }

</style>

</head>

<body>

<h1>jelqd</h1>

<p>A roguelike played over HTTP. Pick a resource, pick a method, send it. The log on the right is everything the server has said to you.

Language <select id="locale"><option>en-GB</option><option>en-US</option><option>en-AU</option></select></p>

<table width="100%" cellspacing="6">

<tr>

<td width="45%" valign="top">

<div class="frame">

<div id="alerts"></div>

<form id="form">

<h3>Method</h3>

<div id="methods"></div>

<h3>Request</h3>

<table id="fields" cellpadding="2"></table>

<p><input type="submit" id="send" value="Send" style="font-size: 1.3em"></p>

<h3>Stats</h3>

<table id="stats" border="1" cellspacing="0" cellpadding="3"></table>

<h3>Resource</h3>

<div id="targets"></div>

</form>

<p><small>Every request goes through <code>/ui/send</code>, which replays it inside the server, so the page can show redirects and send methods and headers that browsers refuse.</small></p>

</div>

</td>

<td valign="top">

<div class="frame" id="frame"><pre id="log"></pre></div>

</td>

</tr>

</table>

<script>

const REL = "https://jelq.dev/rels/";

const METHODS = ["JELQ", "GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "TRACE"];

const LUBES = ["", "application/baby-oil", "application/coconut-oil", "application/lotion", "application/vaseline", "text/plain; charset=spit", "image/jpeg"];

const DEATHS = ["vascular-event", "caught", "opened", "banned", "degloved", "zip", "run-ended"];

const STATS = [

  ["x-floor", "Floor"],

  ["x-self-reported-length", "Self-reported length"],

  ["x-girth", "Girth"],

  ["x-foreskin", "Foreskin"],

  ["x-eq", "EQ (aim for 50 to 70)"],

  ["x-stamina", "Stamina"],

  ["x-suspicion", "Suspicion"],

  ["x-shame", "Shame"],

  ["x-cash", "Cash"],

];

const MEASURED = ["x-length", "Length"];

const QUIET = new Set(["link", "set-cookie", "server", "x-powered-by", "cache-control", "content-length", "content-type", "date"].concat(STATS.map(s => s[0]), MEASURED[0]));

const FIELDS = {

  seed: { label: "seed (unranked)", kind: "text" },

  technique: { label: "technique", kind: "select" },

  also: { label: "combo with", kind: "select" },

  intensity: { label: "intensity, 1 to 10", kind: "number", value: "5" },

  lube: { label: "Content-Type", header: "Content-Type", kind: "select" },

  patch: { label: "body", kind: "textarea", value: '[{"op": "test", "path": "/length", "value": 6}]' },

  range: { label: "Range", header: "Range", kind: "text", placeholder: "inches=0-2" },

  ifMatch: { label: "If-Match", header: "If-Match", kind: "text" },

  ifNoneMatch: { label: "If-None-Match", header: "If-None-Match", kind: "text" },

  ifModifiedSince: { label: "If-Modified-Since", header: "If-Modified-Since", kind: "text", placeholder: "an HTTP-date" },

  proxy: { label: "Proxy-Authorization", header: "Proxy-Authorization", kind: "text", placeholder: "Ruler 5.4" },

  upgrade: { label: "Upgrade", header: "Upgrade", kind: "select", options: ["", "underhand", "overhand"] },

  authorization: { label: "Authorization", header: "Authorization", kind: "text", placeholder: 'Excuse "homework"' },

  extra: { label: "other headers, one per line", kind: "textarea", placeholder: "Expect: gains" },

};

const BY_TARGET = {

  "runs POST": ["seed"],

  "run PATCH": ["patch"],

  "length GET": ["range"],

  "length HEAD": ["range"],

  "foreskin DELETE": ["ifMatch"],

  "elder GET": ["proxy", "ifModifiedSince"],

  "grip GET": ["upgrade"],

  "diagnosis GET": ["authorization", "ifNoneMatch"],

};

const GROUPS = [

  ["play", "Play"],

  ["you", "You"],

  ["said", "From the last response"],

  ["reading", "Reading"],

  ["meta", "Meta"],

];

const GROUP_OF = { run: "play", floor: "play", drawer: "play", shop: "play", portal: "play", elder: "play", diagnosis: "play", length: "you", foreskin: "you", grip: "you", inventory: "you", footage: "you", techniques: "reading", thread: "reading" };

const NAMES = { run: "the run", thread: "the 2009 forum thread" };

const GLOBALS = [

  { key: "runs", group: "play", name: "start a new run", path: "/runs", methods: ["POST"] },

  { key: "global", group: "meta", name: "leaderboard", path: "/leaderboard", methods: ["GET", "HEAD", "OPTIONS"] },

  { key: "global", group: "meta", name: "graveyard", path: "/graveyard", methods: ["GET", "HEAD", "OPTIONS"] },

];

let run = null;

let linked = [];

let techniques = [];

let offered = [];

let challenged = false;

let target = "/runs";

let method = "POST";

const values = {};

const $ = id => document.getElementById(id);

function short(path) {

  return path.replace(/[0-9a-f]{32}/, id => id.slice(0, 6) + "…");

}

function el(tag, props, ...children) {

  const node = Object.assign(document.createElement(tag), props || {});

  for (const child of children) node.append(child);

  return node;

}

function titled(text) {

  return text.charAt(0).toUpperCase() + text.slice(1);

}

function technique(name) {

  return techniques.find(t => t.name === name);

}

function clashes(a, b) {

  const rules = [a.lubricant, b.lubricant];

  return rules.includes("required") && rules.includes("forbidden");

}

// The options a field can take right now, or null for free text.

function options(name) {

  if (name === "technique") return techniques.map(t => t.name);

  if (name === "also") {

    const first = technique(fieldValue("technique"));

    if (!first || !first.lubricant) return [""];

    const partners = techniques.filter(t => t.lubricant && t.name !== first.name && !clashes(first, t));

    return [""].concat(partners.map(t => t.name));

  }

  if (name === "lube") return lubeRule() === "required" ? LUBES.filter(Boolean) : LUBES;

  return FIELDS[name].options || null;

}

function raw(name) {

  return values[name] ?? FIELDS[name].value ?? "";

}

function fieldValue(name) {

  const allowed = options(name);

  const value = raw(name);

  if (allowed && !allowed.includes(value)) return allowed[0] ?? "";

  return value;

}

function lubeRule() {

  const picked = [technique(fieldValue("technique")), technique(fieldValue("also"))].filter(Boolean);

  if (!picked.length || !picked[0].lubricant) return "none";

  for (const rule of ["forbidden", "required"]) {

    if (picked.some(t => t.lubricant === rule)) return rule;

  }

  return "optional";

}

function allowedMethods(t) {

  return t.key === "run" && !techniques.length ? t.methods.filter(m => m !== "JELQ") : t.methods;

}

function targets() {

  const listed = run ? linked : [];

  const known = new Set(listed.concat(GLOBALS).map(t => t.path));

  const fresh = offered.filter((t, i) => !known.has(t.path) && offered.findIndex(o => o.path === t.path) === i);

  return listed.concat(fresh, GLOBALS);

}

function current() {

  return targets().find(t => t.path === target) || GLOBALS[0];

}

function chooseTarget(t) {

  const allowed = allowedMethods(t);

  target = t.path;

  method = allowed.includes("JELQ") ? "JELQ" : allowed.find(m => m !== "HEAD" && m !== "OPTIONS") || allowed[0];

  render();

}

function renderStats(headers) {

  const table = $("stats");

  table.replaceChildren();

  const stats = STATS.map(s => s[0] === "x-self-reported-length" && headers && MEASURED[0] in headers ? MEASURED : s);

  for (let i = 0; i < stats.length; i += 2) {

    const row = el("tr");

    for (const [name, label] of stats.slice(i, i + 2)) {

      const value = headers ? headers[name] : undefined;

      row.append(el("th", { align: "left", textContent: label }), el("td", { textContent: value === undefined ? "—" : value }));

    }

    table.append(row);

  }

}

function renderAlerts(list) {

  const box = $("alerts");

  box.replaceChildren();

  const alerts = [];

  for (const [name, value] of list || []) {

    if (name === "via") alerts.push(titled(value.split(" ").pop()) + " is at the door.");

    if (name === "x-observed-by") alerts.push((value === "cat" ? "The cat" : titled(value)) + " is watching.");

    if (name === "warning") {

      const text = (value.match(/"([^"]*)"/) || [, value])[1];

      alerts.push(titled(text) + ".");

    }

  }

  const stamina = (list || []).find(([name]) => name === "x-stamina");

  if (stamina && stamina[1].startsWith("0/")) alerts.push("Exhausted. Wait out the refractory period, then GET the run.");

  for (const alert of alerts) box.append(el("h2", { textContent: alert }));

}

function renderTargets() {

  const box = $("targets");

  box.replaceChildren();

  const all = targets();

  for (const [group, title] of GROUPS) {

    const members = all.filter(t => t.group === group);

    if (!members.length) continue;

    box.append(el("h4", { textContent: title }));

    for (const t of members) {

      const radio = el("input", { type: "radio", name: "target", checked: t.path === target, onchange: () => chooseTarget(t) });

      box.append(el("label", {}, radio, " " + t.name + " ", el("small", { textContent: short(t.path) })), el("br"));

    }

  }

}

function renderMethods() {

  const box = $("methods");

  box.replaceChildren();

  const allowed = allowedMethods(current());

  for (const m of METHODS.filter(m => allowed.includes(m))) {

    const radio = el("input", { type: "radio", name: "method", checked: m === method, onchange: () => { method = m; render(); } });

    const label = el("label", {}, radio, " ");

    label.append(m === "JELQ" ? el("big", {}, el("b", { textContent: "JELQ" })) : m);

    box.append(label, " ");

  }

}

function fieldNames() {

  const t = current();

  const key = t.key + " " + method;

  let names = BY_TARGET[key] || [];

  if (key === "run JELQ") {

    const chosen = technique(fieldValue("technique"));

    names = ["technique"];

    if (options("also").length > 1) names.push("also");

    if (chosen && chosen.lubricant) names.push("intensity");

    if (["required", "optional"].includes(lubeRule())) names.push("lube");

  }

  const scoped = run && !["runs", "global"].includes(t.key);

  const asked = challenged && scoped && !names.includes("authorization");

  return (asked ? ["authorization"] : []).concat(names);

}

function renderFields() {

  const table = $("fields");

  table.replaceChildren();

  for (const name of fieldNames()) {

    const f = FIELDS[name];

    const value = fieldValue(name);

    const choices = options(name);

    let input;

    if (choices) {

      input = el("select", {}, ...choices.map(o => el("option", { value: o, textContent: o || "(none)", selected: o === value })));

    } else if (f.kind === "textarea") {

      input = el("textarea", { rows: 3, cols: 40, value, placeholder: f.placeholder || "" });

    } else {

      input = el("input", { type: f.kind, value, placeholder: f.placeholder || "", size: 30 });

    }

    input.oninput = () => { values[name] = input.value; };

    input.onchange = () => { values[name] = input.value; if (choices) renderFields(); };

    table.append(el("tr", {}, el("td", { align: "right", valign: "top", textContent: f.label }), el("td", {}, input)));

  }

  const extra = el("textarea", { rows: 3, cols: 40, value: raw("extra"), placeholder: FIELDS.extra.placeholder });

  extra.oninput = () => { values.extra = extra.value; };

  const more = el("details", { open: Boolean(values.extra) }, el("summary", { textContent: "more headers" }), extra);

  table.append(el("tr", {}, el("td"), el("td", {}, more)));

  $("send").value = method + " " + short(current().path);

}

function render() {

  if (!allowedMethods(current()).includes(method)) return chooseTarget(current());

  renderTargets();

  renderMethods();

  renderFields();

}

function parseLinks(header) {

  const resources = [];

  const moves = [];

  for (const match of header.matchAll(/<([^>]*)>((?:\s*;\s*[a-z-]+="[^"]*")*)/g)) {

    const params = Object.fromEntries([...match[2].matchAll(/([a-z-]+)="([^"]*)"/g)].map(p => [p[1], p[2]]));

    const name = (params.rel || "").replace(REL, "");

    if (name === "technique") {

      moves.push({ name: params.title, lubricant: params.lubricant || null });

      continue;

    }

    const methods = (params.allow || "GET").split(",").map(s => s.trim());

    resources.push({ key: name, group: GROUP_OF[name] || "play", name: NAMES[name] || params.title || name, path: match[1], methods });

  }

  return [resources, moves];

}

function hrefs(value, found) {

  if (value && typeof value === "object") {

    if (typeof value.href === "string") {

      const name = value.title || value.item || value.name || value.href.split("/").pop();

      found.push({ key: "offered", group: "said", name, path: value.href, methods: [value.method || "GET"] });

    }

    for (const key in value) hrefs(value[key], found);

  }

  return found;

}

function log(text) {

  $("log").prepend(text + "\n\n");

  $("frame").scrollTop = 0;

}

function describe(r) {

  const lines = ["< " + r.status + " " + r.reason];

  for (const [name, value] of r.headers) {

    if (!QUIET.has(name)) lines.push("< " + name + ": " + short(value));

  }

  let body = null;

  try { body = JSON.parse(r.body); } catch (e) {}

  if (body && typeof body === "object") {

    const rest = Object.assign({}, body);

    if (rest.detail) lines.push("  " + rest.detail);

    for (const key of ["type", "title", "status", "detail"]) delete rest[key];

    if (Object.keys(rest).length) lines.push(short(JSON.stringify(rest, null, 2)).replace(/^/gm, "  "));

  } else if (r.body) {

    const range = (r.headers.find(h => h[0] === "content-range") || [])[1] || "";

    const partial = r.status === 206 && range.match(/^bytes (\d+)-(\d+)\/(\d+)$/);

    lines.push("  " + r.body);

    if (partial) lines.push("  [bytes " + partial[1] + "-" + partial[2] + " of " + partial[3] + ". A 206 carries only part of the representation, as RFC 9110 requires.]");

  }

  return lines.join("\n");

}

function absorb(r, sentMethod, sentPath) {

  const headers = Object.fromEntries(r.headers.map(([n, v]) => [n.toLowerCase(), v]));

  let body = null;

  try { body = JSON.parse(r.body); } catch (e) {}

  const problem = body && typeof body.type === "string" ? body.type.split("/").pop() : null;

  const started = r.status === 201 && (sentPath === "/runs" || sentPath.startsWith("/runs?"));

  if (started) {

    run = headers.location;

    log("--- a new run has started at " + short(run) + " ---");

  }

  if ("x-eq" in headers) {

    renderStats(headers);

    renderAlerts(r.headers);

    challenged = r.status === 401 || "via" in headers;

  }

  if (headers.link) [linked, techniques] = parseLinks(headers.link);

  offered = body ? hrefs(body, []) : [];

  if (headers.location && !started) {

    offered.unshift({ key: "offered", group: "said", name: short(headers.location).split("/").pop() + " (Location)", path: headers.location, methods: ["GET"] });

  }

  const abandoned = sentMethod === "DELETE" && sentPath === run && r.status === 204;

  if (run && (abandoned || DEATHS.includes(problem))) {

    log("--- the run has ended ---");

    renderAlerts(null);

    challenged = false;

    run = null;

    linked = [];

    techniques = [];

  }

  if (started || !targets().some(t => t.path === target)) {

    const home = linked.find(t => t.key === "run");

    chooseTarget(home || GLOBALS[0]);

  } else {

    render();

  }

}

async function go(event) {

  event.preventDefault();

  const t = current();

  const key = t.key + " " + method;

  const value = name => fieldValue(name).trim();

  const headers = [];

  let path = t.path;

  let body = "";

  for (const name of fieldNames()) {

    const f = FIELDS[name];

    if (f.header && value(name)) headers.push([f.header, value(name)]);

  }

  if (fieldNames().includes("upgrade") && value("upgrade")) headers.push(["Connection", "upgrade"]);

  for (const line of raw("extra").split("\n")) {

    const at = line.indexOf(":");

    if (at > 0) headers.push([line.slice(0, at).trim(), line.slice(at + 1).trim()]);

  }

  if (key === "run JELQ") {

    const names = fieldNames();

    const chosen = [value("technique")].concat(names.includes("also") && value("also") ? [value("also")] : []);

    path += "?technique=" + encodeURIComponent(chosen.join(","));

    if (names.includes("intensity")) path += "&intensity=" + encodeURIComponent(value("intensity"));

  }

  if (key === "runs POST" && value("seed")) path += "?seed=" + encodeURIComponent(value("seed"));

  if (method === "PATCH") {

    headers.push(["Content-Type", "application/json-patch+json"]);

    body = value("patch");

  }

  const sent = ["> " + method + " " + short(path)].concat(headers.map(([name, v]) => "> " + name + ": " + v)).join("\n");

  headers.push(["Accept-Language", $("locale").value]);

  let r;

  try {

    const response = await fetch("/ui/send", {

      method: "POST",

      headers: { "Content-Type": "application/json" },

      body: JSON.stringify({ method, path, headers, body }),

    });

    r = await response.json();

  } catch (error) {

    log(sent + "\n! The server did not answer. Is jelqd still running? (" + error.message + ")");

    return;

  }

  if (!Array.isArray(r.headers)) {

    log(sent + "\n! The page could not read that reply:\n  " + JSON.stringify(r));

    return;

  }

  log(sent + "\n" + describe(r));

  absorb(r, method, path);

}

$("form").onsubmit = go;

$("locale").value = localStorage.getItem("locale") || "en-GB";

$("locale").onchange = () => localStorage.setItem("locale", $("locale").value);

renderStats(null);

render();

log("Welcome. Choose \"start a new run\" and send POST to begin. The newest turn is always at the top.");

</script>

</body>

</html>