pindeck 3.0.0-beta.2 → 3.1.0-beta.1

package/server.mjs

@@ -24,7 +24,7 @@ import path from "node:path";
 import crypto from "node:crypto";
 import { spawn, execFile } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { assignEids, parse, findSlides, setStyles, getInner, setInner, insertAfter, removeElement, deleteTarget, fileRefs, insertSlide, moveSlide, getNotes, setNotes, setAttr, elementEnd } from "./lib/eids.mjs";
+import { assignEids, parse, findSlides, slideSelector, deckSize, setStyles, getInner, setInner, insertAfter, removeElement, deleteTarget, fileRefs, insertSlide, moveSlide, getNotes, setNotes, setAttr, elementEnd } from "./lib/eids.mjs";
 import { unifiedDiff } from "./lib/diff.mjs";
 import { ClaudeSession } from "./lib/claude.mjs";
 import { CodexSession } from "./lib/codex.mjs";
@@ -39,18 +39,14 @@ import { isSupportedPlatform, detectCapabilities, publicCapabilities, capability
 import { unsupportedMessage } from "./lib/frameworks.mjs";
 import { readInstructions } from "./lib/instructions.mjs";
 import { writeAtomic, sameContent, revision, scanFiles, scanChanges } from "./lib/deck-files.mjs";
+import { deckTarget, homeDir } from "./lib/deck-target.mjs";
+import { goodHost, LOGIN_PAGE, createLogin } from "./lib/login.mjs";
+import { USAGE } from "./lib/usage.mjs";
 
 /* ---- Config ------------------------------------------------------------------ */
-const USAGE = `Usage: pindeck [deck-folder | deck-file.html] [--port 5180] [--provider claude|codex] [--model <name>] [--asset-root <folder>]...
-       pindeck login [deck-folder | deck-file.html]
-
-Opens a reveal.js deck in PinDeck: a deck file such as talk.html, or a folder (default: the current
-folder), which then opens its index.html.
-login prints a new one-time login link for the PinDeck running for that deck
-(without a deck: for the PinDeck started last).
---asset-root lets the deck use files outside its folder: a folder that contains the deck (paths such as
-../shared/style.css then work), or one that symlinks in the deck may point to. Repeatable; also
-"assetRoots" in ~/.pindeck-v3/config.json.`;
+/* Started by the front (pindeck, front.mjs) for one of the decks it serves: the front logs browsers in,
+   prints the links and owns ~/.pindeck-v3/server.json; this server tells it its address over IPC. */
+const FRONT = !!process.env.PINDECK_FRONT && !!process.send;
 const EDITOR_DIR = path.dirname(fileURLToPath(import.meta.url));
 const argv = process.argv.slice(2);
 if (argv.includes("--help") || argv.includes("-h")) { console.log(USAGE); process.exit(0); }
@@ -69,23 +65,14 @@ const LOGIN = argv[0] === "login";
 if (LOGIN) argv.shift();
 const PROVIDER = opt("--provider", "");
 const MODEL = opt("--model", "");
-/* The deck: a file (talk.html), or a folder, which means its index.html. A path ending in .html or .htm
-   that is not a folder is a file, so a missing file gets a clear message. */
-const TARGET = path.resolve(argv[0] || process.cwd());
-const isFolder = (() => { try { return fs.statSync(TARGET).isDirectory(); } catch { return false; } })();
-const DECK_DIR = isFolder || !/\.html?$/i.test(TARGET) ? TARGET : path.dirname(TARGET);
-const DECK_FILE = DECK_DIR === TARGET ? "index.html" : path.basename(TARGET);
-const NAMED = DECK_FILE !== "index.html";             // a deck file with its own name; several can share a folder
-const DECK_NAME = NAMED ? DECK_FILE.replace(/\.html?$/i, "") : path.basename(DECK_DIR);   // for exports and titles
+/* The deck: a file (talk.html), or a folder, which means its index.html (see lib/deck-target.mjs) */
+const { dir: DECK_DIR, file: DECK_FILE, named: NAMED, name: DECK_NAME, key: deckKey } = deckTarget(argv[0] || process.cwd());
 const EDITABLE = [DECK_FILE, "theme.css"];         // both backends may edit these
 const LOCKED = ["brand.css"];                      // never, enforced twice
-const HOME_DIR = process.env.PINDECK_HOME || path.join(os.homedir(), ".pindeck-v3");
-/* State per deck file. A folder's index.html keeps the key it always had, so existing chats and undo
-   histories stay; a named file gets its own, so two decks in one folder never share chat or undo. */
-const deckKey = (NAMED ? `${path.basename(DECK_DIR)}-${DECK_NAME}` : path.basename(DECK_DIR)).replace(/[^\w.-]+/g, "_") + "-" +
-  crypto.createHash("sha1").update(NAMED ? path.join(DECK_DIR, DECK_FILE) : DECK_DIR).digest("hex").slice(0, 8);
+const HOME_DIR = homeDir();
 const STATE_DIR = path.join(HOME_DIR, "decks", deckKey);
 const SHOT_DIR = path.join(STATE_DIR, "shots");
+const SHOT_NAME = /^[\w-][\w.-]*\.png$/;   // a file name in SHOT_DIR, as the editor may ask for it
 const PDF_DIR = path.join(STATE_DIR, "attachments");   // attached PDFs: reading material, not part of the deck
 /* pindeck login: a new one-time login link from the running server, asked with the token in its server
    file (readable only by this user) */
@@ -126,15 +113,18 @@ if (deckProblem) {
   console.error(`${deckProblem}\n\n${USAGE}`);
   process.exit(1);
 }
-// only reveal.js for now: another framework's deck is left exactly as it is (no ids, no state)
-const frameworkProblem = unsupportedMessage(fs.readFileSync(path.join(DECK_DIR, DECK_FILE), "utf8"), DECK_FILE);
+// reveal.js, or a deck that names its slides: another framework's deck is left exactly as it is (no ids, no state)
+const deckAtStart = fs.readFileSync(path.join(DECK_DIR, DECK_FILE), "utf8");
+const frameworkProblem = unsupportedMessage(deckAtStart, DECK_FILE);
 if (frameworkProblem) {
   console.error(frameworkProblem);
   process.exit(1);
 }
 /* Runtime files hold the token, the chat and attachments: private to the user. Written only after the
    port is bound (see Start), so a failed start leaves no state behind. */
-const SERVER_FILES = [path.join(STATE_DIR, "server.json"), path.join(HOME_DIR, "server.json")];   // the second: the CLI's fallback
+// the second: the CLI's fallback. Behind the front none: its own server.json leads pindeck login to the front
+// (a deck server's port is no use to a browser behind a tunnel), and the assistant's CLI gets this server's address.
+const SERVER_FILES = FRONT ? [] : [path.join(STATE_DIR, "server.json"), path.join(HOME_DIR, "server.json")];
 function writeServerInfo() {
   for (const d of [HOME_DIR, STATE_DIR, SHOT_DIR]) fs.mkdirSync(d, { recursive: true, mode: 0o700 });
   const info = JSON.stringify({ url: ORIGIN, token: TOKEN, deckDir: DECK_DIR, pid: process.pid }, null, 2);
@@ -159,6 +149,22 @@ const MIME = { html: "text/html; charset=utf-8", css: "text/css; charset=utf-8",
   mp4: "video/mp4", webm: "video/webm", mov: "video/quicktime", pdf: "application/pdf", md: "text/plain; charset=utf-8" };
 const hash = (s) => crypto.createHash("sha1").update(s).digest("hex");
 const readDeck = (f) => { try { return fs.readFileSync(path.join(DECK_DIR, f), "utf8"); } catch { return null; } };
+/* A deck made without reveal.js names its slides with <meta name="pindeck:slides"> (null for reveal.js) and
+   their size with <meta name="pindeck:size">. Read from the deck as it is now, so a changed tag counts from
+   the next headless run or Claude session. Headless Chrome opens such a deck at the slide size, so a
+   screenshot is the slide itself. */
+function deckSlides() {
+  const tree = parse(readDeck(DECK_FILE) || "");
+  const selector = slideSelector(tree);
+  return { selector, size: (selector && deckSize(tree)) || { width: 1280, height: 720 } };
+}
+/* Why the deck no longer names slides PinDeck can use (a tag changed while PinDeck runs), or null: the
+   start-up check's message, which the editor shows and Claude is told */
+function deckProblemNow() {
+  const html = readDeck(DECK_FILE);
+  return (html != null && unsupportedMessage(html, DECK_FILE)?.replace(/ Nothing was changed\.$/, "")) || null;
+}
+let deckNow = { selector: deckSlides().selector, problem: null };   // for the editor; kept current by scheduleFlush
 const ourWrites = new Map(); // file -> { hash, manual } of what we wrote, to tell our writes from others
 function writeDeck(f, content, manual = false) {
   ourWrites.set(f, { hash: hash(content), manual });
@@ -283,15 +289,25 @@ const CHROME = CAPS.chromePath;   // null when Chrome features are unavailable (
 /* Headless Chrome on macOS often lingers long after it has written its output, so we
    watch the output and stop Chrome as soon as `done(stdout, stderr)` says we have it. */
 let chromeSeq = 0;
+/* The page gets the window's size too. Chrome lays it out about 87 px shorter than the window (room for
+   a toolbar it does not draw) and grows it only for the screenshot itself, too late for some versions
+   to lay the slide out again, so shot and dump lay the deck out for this size (see bridge.js). */
+function sized(url, size) {
+  const u = new URL(url);
+  u.searchParams.set("width", size.width);
+  u.searchParams.set("height", size.height);
+  return u.href;
+}
 function chrome(args, done) {
   if (!CHROME) return Promise.reject(new Error(`Screenshots are not available: ${CAPS.screenshot.reason}.`));
   return new Promise((resolve, reject) => {
     // a profile per run: concurrent runs must not share one
     const profile = path.join(STATE_DIR, "chrome", `p${process.pid}-${++chromeSeq}`);
+    const { size } = deckSlides();
     const proc = spawn(CHROME, ["--headless=new", "--disable-gpu", "--hide-scrollbars", "--no-first-run",
       "--no-default-browser-check", "--disable-extensions", "--mute-audio", `--user-data-dir=${profile}`,
-      "--window-size=1280,720", "--force-device-scale-factor=1", "--virtual-time-budget=5000",
-      ...args.map((a) => a.startsWith(ORIGIN + "/") ? chromeStart(profile, a) : a)]);
+      `--window-size=${size.width},${size.height}`, "--force-device-scale-factor=1", "--virtual-time-budget=5000",
+      ...args.map((a) => a.startsWith(ORIGIN + "/") ? chromeStart(profile, sized(a, size)) : a)]);
     let out = "", err = "", finished = false;
     const finish = (fn, v) => {
       if (finished) return;
@@ -372,7 +388,7 @@ function exportPdf(kind, includeHidden = false) {
     try { await printPdf(CHROME, chromeStart(printProfile, `${ORIGIN}${DECK_BASE}__pindeck-print-${id}.html`), out, printProfile); }
     finally { snapshots.delete(id); }
     return { kind: split ? "presentation" : "handout", path: out, rel: path.relative(DECK_DIR, out),
-      url: `/deck/export/${encodeURIComponent(name)}`, bytes: fs.statSync(out).size };
+      url: `deck/export/${encodeURIComponent(name)}`, bytes: fs.statSync(out).size };
   };
   const job = exportQueue.then(run, run);
   exportQueue = job.catch(() => {});
@@ -467,7 +483,8 @@ let catalog = { claude: { models: [] }, codex: { models: [] } }, discovering = n
 let session = null, starting = null;
 const status = () => ({ busy: state.busy, switching: state.switching, model: state.model, sessionId: state.sessionId, settings: { ...settings },
   running: !!session?.running, provider: settings.provider, models: catalog, deck: DECK_DIR, deckFile: DECK_FILE,
-  chrome: CAPS.screenshot.available, capabilities: publicCapabilities(CAPS), rev: deckRev(),
+  chrome: CAPS.screenshot.available, slideSelector: deckNow.selector, deckProblem: deckNow.problem,
+  capabilities: publicCapabilities(CAPS), rev: deckRev(),
   undo: changeLabel(liveTurns().at(-1)), redo: changeLabel(state.redo.at(-1)) });
 const pushStatus = () => broadcast("status", status());
 
@@ -479,6 +496,15 @@ const systemPrompt = fs.readFileSync(path.join(EDITOR_DIR, "lib/system-prompt.md
   (ASSET_ROOTS.length ? `\n\n## Files outside the deck folder\nThe deck may use files in ${ASSET_ROOTS.join(", ")}: refer to ` +
     `them with paths relative to ${DECK_FILE} (such as ../shared/style.css). You can read them; do not edit them, ` +
     `other decks may use them too.\n` : "");
+/* For a deck made without reveal.js: what its slides are, from its selector as it is at each session start */
+function slidesInstructions() {
+  const { selector } = deckSlides();
+  return selector ? `\n\n## Slides of this deck\nThis deck is not made with reveal.js: its slides are the elements matching the ` +
+    `CSS selector \`${selector}\` (<meta name="pindeck:slides">), and the deck's own script shows them. Where these ` +
+    `instructions say <section> or reveal.js, read an element matching that selector, and that script. A new slide is ` +
+    `a new such element next to the others; keep the pindeck meta tags. Hidden slides (data-visibility="hidden") are ` +
+    `left out of PinDeck's PDF exports; whether presenting skips them depends on the deck's script.\n` : "";
+}
 /* What Claude may never change, whatever the edit rules allow: the locked brand files, vendored libraries,
    git's own files, and other decks in this folder (a named deck shares its folder with them). Deny rules
    win over allow rules; a locked file changed anyway is restored after the turn (lock 2 in finishTurn). */
@@ -515,7 +541,7 @@ When context mentions Read, use pindeck_read. Read screenshots with pindeck_read
 Read README.md and the deck instructions below for conventions. Use layout after every visual change.
 PDF tables should be reconstructed as HTML; pdf-figure renders figures. Audio is embedded by path.
 
-## Hand edits`) + deckInstructions();
+## Hand edits`) + slidesInstructions() + deckInstructions();
 function makeSession(choice) {
   let initial = null;
   const options = {
@@ -535,7 +561,7 @@ function makeSession(choice) {
      explicit), PinDeck's own commands, never the locked paths. Deny rules win over allow rules. */
   const agent = choice.provider === "codex" ? new CodexSession({ ...options, settings: choice,
     instructions: codexInstructions(), tools: agentTools }) : new ClaudeSession({ ...options,
-    args: () => ["--append-system-prompt", systemPrompt + deckInstructions(),
+    args: () => ["--append-system-prompt", systemPrompt + slidesInstructions() + deckInstructions(),
       "--setting-sources", "", "--strict-mcp-config", "--safe-mode", "--disable-slash-commands",   // no settings files, no MCP servers or connectors
       "--permission-mode", "default", "--tools", "Read,Glob,Grep,Edit,Write,Bash",
       "--allowedTools", "Read", "Glob", "Grep", "Edit(./**)", "Write(./**)",
@@ -628,11 +654,13 @@ function toolSummary(name, input = {}) {
     const r = path.relative(DECK_DIR, p);
     return !r || r.startsWith("..") ? path.basename(p) : r;
   };
+  // a picture in the screenshots folder: the chat shows it
+  const shotOf = (p) => (p && realOr(path.dirname(path.resolve(p))) === realOr(SHOT_DIR) && SHOT_NAME.test(path.basename(p)) ? { shot: path.basename(p) } : {});
   switch (name) {
-    case "pindeck_read": return { name: "Read", detail: base(input.path) };
+    case "pindeck_read": return { name: "Read", detail: base(input.path), ...shotOf(input.path) };
     case "pindeck_edit": case "pindeck_write": return { name: "Edit", detail: base(input.path) };
     case "pindeck_command": return { name: input.command || "Command", detail: (input.args || []).join(" ") };
-    case "Read": return { name: "Read", detail: base(input.file_path) };
+    case "Read": return { name: "Read", detail: base(input.file_path), ...shotOf(input.file_path) };
     case "Edit": case "MultiEdit": case "Write": return { name: "Edit", detail: base(input.file_path) };
     case "Bash": {
       // a PinDeck command only when the whole command is one: a script that ends in `cli.mjs layout`
@@ -867,6 +895,14 @@ function scheduleFlush() {
       };
       eidTimer = setTimeout(pass, 800);
     }
+    if (files.includes(DECK_FILE)) {   // the slide tags, by hand or by Claude: tell both when they stop working
+      const now = { selector: deckSlides().selector, problem: deckProblemNow() };
+      if (now.selector !== deckNow.selector || now.problem !== deckNow.problem) {
+        if (now.problem) state.notes = [...new Set([...state.notes, `PinDeck cannot use the deck's slides now: ${now.problem}`])];
+        deckNow = now;
+        pushStatus();
+      }
+    }
     // manual: only drag/resize writes, which the browser already shows; no reload of the visible slide
     broadcast("files", { files, manual, rev: deckRev() });
   }, 120);
@@ -1115,57 +1151,9 @@ async function refineImport(imp, pdf, plans, eids, first) {
 
 /* ---- HTTP ------------------------------------------------------------------------------------- */
 const BRIDGE_TAG = `<script src="/editor/bridge.js"></script>\n</body>`;
-/* Pages opened as 127.0.0.1 or localhost only, on any port: an SSH tunnel may use another local port.
-   Another site's name pointed at 127.0.0.1 (DNS rebinding) must not read the editor page, its token or the deck. */
-const goodHost = (h) => /^(127\.0\.0\.1|localhost)(:\d{1,5})?$/.test(h);
-
-/* Who may read the editor, the deck and the API. The token never appears in a page or on a command line,
-   where other users of a shared server could read it (ps, curl). A browser logs in once with a one-time
-   code (printed at start, or by `pindeck login`) and then holds the token in an HttpOnly cookie; the CLI
-   and Claude send it in a header. Browsers share cookies across all ports of a host, so the cookie name
-   carries this server's port. */
-const loginCodes = new Map();   // code -> expiry (ms)
-function loginCode(ttl) {
-  const now = Date.now();
-  for (const [c, exp] of loginCodes) if (exp < now) loginCodes.delete(c);
-  const code = crypto.randomBytes(16).toString("hex");
-  loginCodes.set(code, now + ttl);
-  return code;
-}
-const loginUrl = (code, next = "/") => `${ORIGIN}/login?` + new URLSearchParams({ code, ...(next !== "/" ? { next } : {}) });
-const cookieName = () => `pindeck-${PORT}`;
-const sameSecret = (a) => typeof a === "string" && a.length === TOKEN.length &&
-  crypto.timingSafeEqual(Buffer.from(a), Buffer.from(TOKEN));
-function cookie(req, name) {
-  for (const part of String(req.headers.cookie || "").split(";")) {
-    const i = part.indexOf("=");
-    if (i > 0 && part.slice(0, i).trim() === name) return part.slice(i + 1).trim();
-  }
-  return null;
-}
-const authed = (req) => sameSecret(req.headers["x-editor-token"]) || sameSecret(cookie(req, cookieName()));
-const LOGIN_PAGE = `<!doctype html><meta charset="utf-8"><title>PinDeck</title>
-<body style="font:16px system-ui,sans-serif;max-width:36em;margin:4em auto;padding:0 1em">
-<h1>Log in to PinDeck</h1><p>Open the login link that PinDeck printed when it started. Links work once;
-for a new one, run <code>pindeck login</code> in the deck folder (or <code>node server.mjs login</code> in a
-PinDeck checkout).</p>`;
-/* A one-time code: set the cookie, then go on with a same-origin navigation (a redirect from a cross-site
-   start, such as a file:// page or a link in a terminal, would not carry a SameSite=Strict cookie). */
-function login(res, url) {
-  const code = url.searchParams.get("code") || "";
-  const exp = loginCodes.get(code);
-  loginCodes.delete(code);
-  if (!exp || exp < Date.now()) {
-    res.writeHead(403, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
-    return res.end(LOGIN_PAGE.replace("<p>", "<p>This login link has expired or was used already. "));
-  }
-  let next = url.searchParams.get("next") || "/";
-  if (!next.startsWith("/") || next.startsWith("//") || next.includes("\\")) next = "/";
-  res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store",
-    "set-cookie": `${cookieName()}=${TOKEN}; HttpOnly; SameSite=Strict; Path=/` });
-  const to = JSON.stringify(next).replace(/</g, "\\u003c");
-  res.end(`<!doctype html><meta charset="utf-8"><title>PinDeck</title><script>location.replace(${to})</script>`);
-}
+/* Who may read the editor, the deck and the API: see lib/login.mjs. Behind the front, browsers log in
+   there, and the front sends this server's token in a header. */
+const { loginCode, loginUrl, authed, login } = createLogin({ token: TOKEN, port: () => PORT, origin: () => ORIGIN });
 /* Headless Chrome gets a start page in its own profile folder (0700) instead of a URL with a secret on
    its command line: the page sends it to a one-time login code, which leads on to the target. */
 function chromeStart(profile, target) {
@@ -1239,9 +1227,10 @@ const server = http.createServer(async (req, res) => {
       return res.end(html);
     }
     // /deck/: the deck folder; /deck/ alone is the deck page. With an asset root the page lives under
-    // /files/, so that ../ paths reach the root: /deck/ alone redirects there.
+    // /files/, so that ../ paths reach the root: /deck/ alone redirects there (a relative redirect, which
+    // stays under the front's /d/<deck>/).
     if (req.method === "GET" && p === "/deck/" && SERVE_ROOT) {
-      res.writeHead(302, { location: DECK_PAGE + url.search, "cache-control": "no-store" });
+      res.writeHead(302, { location: ".." + DECK_PAGE + url.search, "cache-control": "no-store" });
       return res.end();
     }
     const deckPath = req.method === "GET" && (p.startsWith("/deck/") ? servable(DECK_DIR, p.slice(6) || DECK_FILE)
@@ -1254,11 +1243,26 @@ const server = http.createServer(async (req, res) => {
       return serveFile(res, f, (s) => {
         // headless runs must not stream media, or Chrome never finishes the page
         if (mode === "shot" || mode === "dump" || mode === "pdf") s = s.replace(/\bpreload="(auto|metadata)"/g, 'preload="none"');
-        if (mode === "pdf") return s.replace(/<\/head>/i, PDF_HEAD_TAG).replace(/<\/body>/i, PDF_PAGE_TAG);
+        if (mode === "pdf") {
+          s = s.replace(/<\/head>/i, PDF_HEAD_TAG).replace(/<\/body>/i, PDF_PAGE_TAG);
+          // a deck that names its slides (in the file as it is now) is laid out by the bridge; reveal.js lays out its own
+          return slideSelector(parse(s)) ? s.replace(/<\/body>/i, BRIDGE_TAG) : s;
+        }
         return s.replace(/<\/body>/i, BRIDGE_TAG);
       });
     }
 
+    // /shots/: a screenshot for the chat, a PNG directly in the screenshots folder (no subfolder, no symlink out)
+    if (req.method === "GET" && p.startsWith("/shots/")) {
+      if (!ok) return text(res, 403, "Not logged in");
+      const name = decodeURIComponent(p.slice(7));
+      if (!SHOT_NAME.test(name)) return text(res, 403, "Forbidden");
+      const f = path.join(SHOT_DIR, name);
+      let real;
+      try { real = fs.realpathSync(f); } catch { return text(res, 404, "Not found"); }
+      return path.dirname(real) === realOr(SHOT_DIR) ? serveFile(res, f, null, req) : text(res, 403, "Forbidden");
+    }
+
     // API: token required (header or login cookie); POSTs must come from the editor page itself
     if (!p.startsWith("/api/")) return text(res, 404, "Not found");
     if (!ok) return text(res, 403, "Bad token");
@@ -1315,7 +1319,8 @@ const server = http.createServer(async (req, res) => {
         // only files PinDeck itself stored can be attached
         b.attachments = (b.attachments || []).filter((a) => a && state.uploads.has(a.path) && fs.existsSync(uploadFile(a.path)));
         b.attachments.forEach((a) => { state.uploads.delete(a.path); if (a.waveform) state.uploads.delete(a.waveform); });
-        const entry = addEntry({ kind: "user", text: b.text, screenshot: !!screenshot,
+        const entry = addEntry({ kind: "user", text: b.text,
+          screenshot: screenshot && { file: path.basename(screenshot.path), slide: screenshot.slide },
           attachments: b.attachments.map((a) => ({ path: a.path, kind: a.kind, name: a.name })),
           selection: b.selection ? { eid: b.selection.eid, label: b.selection.eid.replace(/^[^/]+\//, ""), slide: b.selection.slide.index + 1 } : null,
           pins: (b.pins || []).map((p) => ({ n: p.n, eid: p.eid, label: label(p), slide: p.slide.index + 1 })) });
@@ -1348,7 +1353,7 @@ const server = http.createServer(async (req, res) => {
       const rel = attachPath(original);
       writeDeckFile(rel, buf);
       state.uploads.add(rel);
-      return json(res, 200, { path: rel, kind, bytes: buf.length, url: `/deck/${rel}` });
+      return json(res, 200, { path: rel, kind, bytes: buf.length, url: `deck/${rel}` });
     }
     if (p === "/api/upload-remove" && req.method === "POST") {
       const b = await body(req);
@@ -1371,14 +1376,16 @@ const server = http.createServer(async (req, res) => {
       const b = await body(req);
       if (staleEdit(res, b)) return;
       const before = snapshot(EDITABLE);
-      const slides = findSlides(parse(before[DECK_FILE]));
+      const tree = parse(before[DECK_FILE]), slides = findSlides(tree);
       const index = slides.findIndex((s) => s.attrs["data-eid"]?.value === b.eid);
       if (index < 0) return json(res, 404, { error: "Slide not found in the file." });
       const r = setAttr(before[DECK_FILE], b.eid, "data-visibility", b.hidden ? "hidden" : null);
       if (!r.changed) return json(res, 200, { unchanged: true });
+      const skipped = slideSelector(tree) ? "left out of PDF exports (whether presenting skips them depends on the deck's script)"
+        : "skipped when presenting and in PDF exports";
       const turnId = recordHandEdit(before, r.html, `${b.hidden ? "Hid" : "Showed"} slide ${index + 1}`,
         `The user ${b.hidden ? "hid" : "showed again"} slide ${index + 1} (${b.eid}). Hidden slides carry ` +
-        `data-visibility="hidden": they stay in the file but are skipped when presenting and in PDF exports.`,
+        `data-visibility="hidden": they stay in the file but are ${skipped}.`,
         { manual: true, chat: false });   // the editor reloads the slide itself; undo is in the toolbar
       return json(res, 200, { turnId, index });
     }
@@ -1624,11 +1631,13 @@ const server = http.createServer(async (req, res) => {
       return text(res, r.status || 200, r.text);
     }
     if (p === "/api/slides") {
-      return text(res, 200, slideList().map((s) => `${String(s.index + 1).padStart(2)}  ${s.eid}`).join("\n"));
+      const list = slideList(), why = !list.length && deckProblemNow();
+      if (why) return text(res, 409, why);
+      return text(res, 200, list.map((s) => `${String(s.index + 1).padStart(2)}  ${s.eid}`).join("\n"));
     }
     if (p === "/api/layout" || p === "/api/shot") {
       const slide = resolveSlide(url.searchParams.get("slide"));
-      if (!slide) return text(res, 404, `No slide "${url.searchParams.get("slide")}". Use \`${CLI_CMD} slides\`.`);
+      if (!slide) return text(res, 404, deckProblemNow() || `No slide "${url.searchParams.get("slide")}". Use \`${CLI_CMD} slides\`.`);
       if (!slide.eid) runEidPass();
       const s2 = slide.eid ? slide : resolveSlide(String(slide.index + 1));
       if (p === "/api/shot") {
@@ -1673,12 +1682,18 @@ server.listen(PORT, "127.0.0.1", () => {
     process.exit(1);
   }
   ready = true;
-  console.log(`PinDeck: ${loginUrl(loginCode(3600000))}`);
-  console.log("  (a one-time login link, valid for an hour; for a new one: pindeck login)");
-  console.log(`Deck: ${DECK_DIR}`);
-  console.log(`Server: ${CAPS.label}`);
-  for (const [name, c] of Object.entries(publicCapabilities(CAPS)))
-    if (c && c.available === false) console.log(`  ${name}: off (${c.reason})`);
+  if (FRONT) {
+    // the front prints the login link and the capabilities; it ends this server when it goes, even killed
+    process.send({ ready: { url: ORIGIN, token: TOKEN } });
+    process.on("disconnect", () => { if (!quitting) quit(); });   // a second quit() would exit at once
+  } else {
+    console.log(`PinDeck: ${loginUrl(loginCode(3600000))}`);
+    console.log("  (a one-time login link, valid for an hour; for a new one: pindeck login)");
+    console.log(`Deck: ${DECK_DIR}`);
+    console.log(`Server: ${CAPS.label}`);
+    for (const [name, c] of Object.entries(publicCapabilities(CAPS)))
+      if (c && c.available === false) console.log(`  ${name}: off (${c.reason})`);
+  }
   discoverModels().then(() => {
     if (!settings.model) {
       const models = catalog[settings.provider].models;