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

package/lib/capabilities.mjs

@@ -0,0 +1,121 @@
+/* What this server can do on this machine, decided once on the backend and used everywhere: the editor
+   (status), the API (refusals before any side effect), the CLI (its error text) and the assistant's system prompt.
+
+   macOS: everything, as before. Linux (beta): editing, the chat, live reload and the PowerPoint import;
+   pictures of PDF pages with Poppler, pictures of PowerPoint slides with LibreOffice and Poppler, and
+   waveforms of non-WAV audio with ffmpeg, each when installed, else off with a reason. Chrome features (screenshots, headless
+   layout, PDF export) work on Linux as on macOS when Chrome or Chromium is found; PINDECK_LINUX_CHROME=0
+   turns them off. Each entry is { available, reason }: reason says why not, in plain words. */
+
+import fs from "node:fs";
+import path from "node:path";
+
+export const SUPPORTED_PLATFORMS = ["darwin", "linux"];
+export const isSupportedPlatform = (platform) => SUPPORTED_PLATFORMS.includes(platform);
+export const platformLabel = (platform) => ({ darwin: "macOS", linux: "Linux (beta)" }[platform] || platform);
+
+const CHROME_PATHS = {
+  darwin: ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"],
+  linux: ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser",
+    "/snap/bin/chromium"],
+};
+const OFFICE_APPS = ["/Applications/Microsoft PowerPoint.app", "/Applications/Keynote.app"];
+
+const isExecutable = (p) => {
+  try { return fs.statSync(p).isFile() && (fs.accessSync(p, fs.constants.X_OK), true); } catch { return false; }
+};
+
+/* An executable by path, or by name on PATH. Never runs it. Returns { path } or { path: null, reason }. */
+export function findExecutable(name, { env = process.env } = {}) {
+  if (name.includes("/")) {
+    if (isExecutable(name)) return { path: name };
+    return { path: null, reason: fs.existsSync(name) ? `${name} is not an executable file` : `${name} does not exist` };
+  }
+  for (const dir of String(env.PATH || "").split(path.delimiter).filter(Boolean)) {
+    const p = path.join(dir, name);
+    if (isExecutable(p)) return { path: p };
+  }
+  return { path: null, reason: `no "${name}" command on the PATH` };
+}
+
+const on = () => ({ available: true, reason: "" });
+const off = (reason) => ({ available: false, reason });
+
+export function detectCapabilities({ platform = process.platform, env = process.env } = {}) {
+  const mac = platform === "darwin";
+  const caps = { platform, label: platformLabel(platform) };
+
+  const claudeBin = env.CLAUDE_BIN || "claude";
+  const claude = findExecutable(claudeBin, { env });
+  caps.claude = claude.path ? on() : off(`Claude Code is not available on the server (${claude.reason}). ` +
+    `Install and log in to the claude CLI there, or set CLAUDE_BIN. Editing by hand still works.`);
+  const codex = findExecutable(env.CODEX_BIN || "codex", { env });
+  caps.codex = codex.path ? on() : off(`OpenAI Codex is not available on the server (${codex.reason}). ` +
+    `Install and log in to the codex CLI there, or set CODEX_BIN. Editing by hand still works.`);
+
+  let chrome = null, chromeWhy = "";
+  if (env.CHROME_BIN) {
+    const c = findExecutable(env.CHROME_BIN, { env });
+    chrome = c.path;
+    chromeWhy = c.reason ? `CHROME_BIN: ${c.reason}` : "";
+  } else {
+    chrome = (CHROME_PATHS[platform] || []).find(isExecutable) || null;
+    chromeWhy = chrome ? "" : "no Chrome or Chromium found (set CHROME_BIN)";
+  }
+  if (chrome && platform === "linux" && env.PINDECK_LINUX_CHROME === "0") {
+    chrome = null;
+    chromeWhy = "Chrome features are turned off (PINDECK_LINUX_CHROME=0)";
+  }
+  const chromeCap = chrome ? on() : off(chromeWhy);
+  caps.chromePath = chrome;
+  caps.screenshot = chromeCap;
+  caps.headlessLayout = chromeCap;
+  caps.pdfExport = chromeCap;
+
+  // Linux: Poppler renders PDF pages, LibreOffice exports PowerPoint slides to PDF, ffmpeg decodes audio
+  const has = (name) => !!findExecutable(name, { env }).path;
+  const poppler = has("pdftoppm") && has("pdfinfo"), soffice = has("soffice") || has("libreoffice");
+  caps.pdfPages = mac || poppler ? on()
+    : off("Pictures of PDF pages need Poppler on the server (pdftoppm and pdfinfo; install poppler-utils). Attached PDFs can still be read.");
+  caps.pptxImport = on();   // the import itself reads the .pptx file: no other program needed
+  caps.pptxPictures = mac ? (OFFICE_APPS.some((a) => fs.existsSync(a)) ? on() : off("Pictures of PowerPoint slides need PowerPoint or Keynote."))
+    : soffice && poppler ? on()
+    : off("Pictures of PowerPoint slides need LibreOffice (soffice) and Poppler (pdftoppm, pdfinfo) on the server.");
+  caps.audioConvert = mac || has("ffmpeg") ? on() : off("Waveforms for audio other than WAV need ffmpeg on the server.");
+  return caps;
+}
+
+/* The capabilities for the editor and the status API: no executable paths. */
+export const publicCapabilities = ({ chromePath, ...caps }) => caps;
+
+/* The lines of Claude's system prompt about what this server cannot do. Empty on a full macOS setup. */
+export function capabilityPrompt(caps, cli) {
+  const lines = [];
+  if (!caps.screenshot.available)
+    lines.push(`- \`${cli} shot\` does not work here: ${caps.screenshot.reason}. Use \`${cli} layout\` to check slides; ` +
+      `it works while the editor is open in the user's browser.`);
+  if (!caps.pdfExport.available) lines.push(`- \`${cli} pdf\` does not work here: ${caps.pdfExport.reason}.`);
+  if (!caps.pdfPages.available) lines.push(`- \`${cli} pdf-figure\` does not work here: ${caps.pdfPages.reason}`);
+  if (!lines.length) return "";
+  return `\n\n## This PinDeck server (${caps.label})\nSome commands are not available, so do not try them:\n${lines.join("\n")}\n`;
+}
+
+/* --port / PORT: an integer 0–65535 (0: any free port, for tests). null if invalid. */
+export function parsePort(value) {
+  const s = String(value ?? "").trim();
+  if (!/^\d+$/.test(s)) return null;
+  const n = Number(s);
+  return n <= 65535 ? n : null;
+}
+
+/* The command Claude runs for the CLI, quoted for the shell. The Bash permission is this exact prefix, so
+   it must be one fixed string; double quotes as before, single quotes when the path has characters that
+   double quotes do not protect. */
+export function cliCommand(rel) {
+  if (/^[\w./@%+=:,-]+$/.test(rel)) return `node ${rel}`;
+  if (!/["$`\\!]/.test(rel)) return `node "${rel}"`;
+  return `node '${rel.replaceAll("'", `'\\''`)}'`;
+}

package/lib/claude.mjs

@@ -3,19 +3,22 @@ import { promisify } from 'node:util';
 const exec = promisify(execFile);
 import { AgentProcess } from './agent-process.mjs';
 import { normalizeModels } from './models.mjs';
+/* A long-running Claude Code process in stream-json mode. One process serves the whole chat; it runs under
+   the user's normal Claude login. env may be a function: the server's address is known only once it listens. */
 export class ClaudeSession {
   constructor(options) { Object.assign(this, options); this.transport = null; this.sessionId = null; }
   get running() { return !!this.transport && !this.transport.closed; }
   async start(resumeId) {
     if (this.running) return;
     this.stopped = false;
+    const env = typeof this.env === 'function' ? this.env() : this.env;
     try {
       const { stdout } = await exec(process.env.CLAUDE_BIN || 'claude', ['auth', 'status', '--json'],
-        { env: { ...process.env, ...this.env }, timeout: 15000, maxBuffer: 65536 });
+        { env: { ...process.env, ...env }, timeout: 15000, maxBuffer: 65536 });
       if (!JSON.parse(stdout).loggedIn) throw new Error('Not signed in.');
     } catch (e) { throw new Error(e.code === 'ENOENT' ? 'Claude CLI is not installed (or set CLAUDE_BIN).' : 'Claude is not signed in. Run claude auth login, then refresh models.'); }
     if (this.stopped) throw new Error('Agent stopped.');
-    const transport = new AgentProcess({ binary: process.env.CLAUDE_BIN || 'claude', cwd: this.cwd, env: this.env,
+    const transport = new AgentProcess({ binary: process.env.CLAUDE_BIN || 'claude', cwd: this.cwd, env,
       args: ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',
         ...(typeof this.args === 'function' ? this.args() : this.args || []), ...(resumeId ? ['--resume', resumeId] : [])],
       onStderr: this.onStderr,
@@ -34,5 +37,6 @@ export class ClaudeSession {
   }
   async send(content) { this.transport.write({ type: 'user', message: { role: 'user', content } }); }
   async interrupt() { if (this.running) await this.transport.request('interrupt', {}, { claude: true, timeout: 5000 }); }
-  stop() { this.stopped = true; const t = this.transport; this.transport = null; t?.stop(); }
+  /* Resolves once the process has exited, so shutdown can wait for it. */
+  stop() { this.stopped = true; const t = this.transport; this.transport = null; return t ? t.stop() : Promise.resolve(); }
 }

package/lib/codex.mjs

@@ -1,6 +1,8 @@
+import fs from 'node:fs';
 import { AgentProcess } from './agent-process.mjs';
 import { normalizeModels } from './models.mjs';
 import { deckTools } from './agent-tools.mjs';
+const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 export const CODEX_CONFIG = {
   'features.shell_tool': false, 'features.unified_exec': false, 'features.js_repl': false,
   'features.apps': false, 'features.plugins': false, 'features.multi_agent': false,
@@ -23,7 +25,7 @@ export class CodexSession {
     });
     this.transport = transport;
     try {
-      await transport.request('initialize', { clientInfo: { name: 'pindeck', version: '3.0.0-beta.1' }, capabilities: { experimentalApi: true } });
+      await transport.request('initialize', { clientInfo: { name: 'pindeck', version: VERSION }, capabilities: { experimentalApi: true } });
       transport.write({ method: 'initialized', params: {} });
       const auth = await transport.request('account/read', { refreshToken: false });
       if (auth.requiresOpenaiAuth && !auth.account) throw new Error('Codex is not signed in. Run codex login, then refresh models.');
@@ -100,5 +102,5 @@ export class CodexSession {
     this.cancelRequested = true; this.controller?.abort();
     if (this.turnId && this.running) await this.transport.request('turn/interrupt', { threadId: this.sessionId, turnId: this.turnId });
   }
-  stop() { this.controller?.abort(); this.controller = null; const t = this.transport; this.transport = null; t?.stop(); }
+  stop() { this.controller?.abort(); this.controller = null; const t = this.transport; this.transport = null; return t ? t.stop() : Promise.resolve(); }
 }

package/lib/deck-files.mjs

@@ -0,0 +1,94 @@
+/* Writing deck files safely, and telling whether they changed.
+
+   writeAtomic: the new content goes to a temporary file next to the target, is flushed, gets the target's
+   permissions and then replaces the target with one rename. A reader (the browser, Claude, an editor, the
+   watcher) sees the old file or the new one, never half of it. A symlinked target is written where the link
+   points, so the link stays a link. Each file is atomic on its own; a set of files is not one transaction.
+
+   revision: a hash of the deck's editable files as they are now. The editor sends the revision it shows
+   with each change; a different one means someone else changed the files in between (409, nothing written).
+   This catches stale edits from the editor. It is not a lock: a program that writes between PinDeck's check
+   and its write can still lose its change, so only one writer (PinDeck, Claude, or another tool) at a time. */
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+export function writeAtomic(file, data) {
+  let target = file, mode = null;
+  try {
+    if (fs.lstatSync(file).isSymbolicLink()) target = fs.realpathSync(file);
+    mode = fs.statSync(target).mode & 0o7777;
+  } catch (e) { if (e.code !== "ENOENT") throw e; }
+  const tmp = path.join(path.dirname(target), `.${path.basename(target)}.pindeck-${crypto.randomBytes(6).toString("hex")}.tmp`);
+  let fd = null;
+  try {
+    fd = fs.openSync(tmp, "wx", mode ?? 0o666);   // wx: never reuse an existing file
+    fs.writeFileSync(fd, data);
+    fs.fsyncSync(fd);
+    if (mode != null) fs.fchmodSync(fd, mode);   // the umask must not change the file's permissions
+    fs.closeSync(fd);
+    fd = null;
+    fs.renameSync(tmp, target);
+  } catch (e) {
+    if (fd != null) try { fs.closeSync(fd); } catch {}
+    try { fs.rmSync(tmp, { force: true }); } catch {}
+    throw new Error(`Could not save ${path.basename(file)}: ${e.message}`);
+  }
+}
+
+/* Same bytes? (a missing file is null) */
+export function sameContent(file, data) {
+  let now;
+  try { now = fs.readFileSync(file); } catch (e) { if (e.code === "ENOENT") return data == null; throw e; }
+  return data != null && now.equals(Buffer.isBuffer(data) ? data : Buffer.from(data));
+}
+
+export function revision(dir, files) {
+  const h = crypto.createHash("sha256");
+  for (const f of files) {
+    let c = null;
+    try { c = fs.readFileSync(path.join(dir, f)); } catch {}
+    h.update(f + (c == null ? "\0-" : `\0${c.length}\0`));
+    if (c) h.update(c);
+  }
+  return h.digest("hex").slice(0, 16);
+}
+
+/* The deck's files for undo: every file a turn may change, with its content (bigger files: only size and
+   time, too large to keep a copy of). Hidden files and folders (.git), node_modules, and the vendor/ and
+   export/ folders are left out; so are symlinks, which point elsewhere. */
+const SKIP_TOP = new Set(["vendor", "export", "node_modules"]);
+export const KEEP_BYTES = 2 * 1024 * 1024;
+export function scanFiles(dir, maxBytes = KEEP_BYTES) {
+  const files = new Map();
+  const walk = (rel) => {
+    let entries = [];
+    try { entries = fs.readdirSync(path.join(dir, rel), { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.name.startsWith(".") || e.name === "node_modules") continue;
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) { if (rel || !SKIP_TOP.has(e.name)) walk(r); continue; }
+      if (!e.isFile()) continue;
+      try {
+        const st = fs.statSync(path.join(dir, r));
+        files.set(r, { size: st.size, mtimeMs: st.mtimeMs, data: st.size <= maxBytes ? fs.readFileSync(path.join(dir, r)) : null });
+      } catch {}
+    }
+  };
+  walk("");
+  return files;
+}
+
+/* What changed between two scans: { rel: { before, after } } with the content on each side (null: the
+   file did not exist), and the files that changed but are too large to keep a copy of. */
+export function scanChanges(before, after) {
+  const changed = {}, tooLarge = [];
+  for (const rel of new Set([...before.keys(), ...after.keys()])) {
+    const b = before.get(rel), a = after.get(rel);
+    if (b && a && b.size === a.size && (b.data && a.data ? b.data.equals(a.data) : b.mtimeMs === a.mtimeMs)) continue;
+    if ((b && !b.data) || (a && !a.data)) { tooLarge.push(rel); continue; }
+    changed[rel] = { before: b ? b.data : null, after: a ? a.data : null };
+  }
+  return { changed, tooLarge };
+}

package/lib/frameworks.mjs

@@ -0,0 +1,41 @@
+/* Which slide framework a deck uses. PinDeck edits reveal.js decks: <section> slides inside an element
+   with class "slides" (inside <div class="reveal">). Other frameworks are recognised by their markup and
+   scripts, so the user gets a clear "not supported (yet)" before PinDeck changes anything, instead of an
+   editor without slides. Only tags and scripts are looked at, never the slides' text, so a talk that
+   mentions "impress.js" is not taken for one. */
+
+import { parse, findSlides } from "./eids.mjs";
+
+const OTHERS = [   // name, markers; the first match wins (Marp before bespoke.js, which it is built on)
+  ["Marp", /\bmarpit\b|bespoke-marp|data-marpit|marp-cli/i],
+  ["Slidev", /slidev/i],
+  ["impress.js", /id=["']impress["']|impress(\.min)?\.js/i],
+  ["remark", /remark(-latest)?(\.min)?\.js|remark\.create\s*\(/i],
+  ["Spectacle", /<script[^>]+src=["'][^"']*spectacle/i],
+  ["Shower", /class=["'][^"']*\bshower\b|shower-core/i],
+  ["deck.js", /deck-container|deck\.core(\.min)?\.js/i],
+  ["bespoke.js", /bespoke(\.min)?\.js|bespoke\.from\s*\(/i],
+];
+
+/* Tags and script contents only: the slides' text could name any framework */
+const markup = (html) => [...String(html).matchAll(/<script\b[^>]*>[\s\S]*?<\/script>|<[^>]+>/gi)].map((m) => m[0]).join("\n");
+
+/* { name, supported }: reveal.js decks are supported, including one without slides yet */
+export function detectFramework(html) {
+  if (findSlides(parse(html)).length) return { name: "reveal.js", supported: true };
+  const tags = markup(html);
+  const other = OTHERS.find(([, re]) => re.test(tags));
+  if (other) return { name: other[0], supported: false };
+  if (/class=["'][^"']*\breveal\b/i.test(tags) || /Reveal\.initialize\s*\(/.test(tags)) return { name: "reveal.js", supported: true };
+  return { name: null, supported: false };
+}
+
+/* The message for a deck PinDeck cannot edit, or null */
+export function unsupportedMessage(html, file) {
+  const fw = detectFramework(html);
+  if (fw.supported) return null;
+  const what = fw.name ? `${file} is a ${fw.name} deck.` :
+    `${file} has no reveal.js slides (a <div class="reveal"> with <div class="slides"> holding <section> slides).`;
+  return `${what} PinDeck works with reveal.js decks only for now; other frameworks may follow. ` +
+    `Nothing was changed.`;
+}

package/lib/instructions.mjs

@@ -0,0 +1,74 @@
+/* The deck's own instructions for Claude (CLAUDE.md, AGENTS.md), with @path imports expanded.
+
+   PinDeck does not load CLAUDE.md files from parent folders the way Claude Code does: those are usually
+   written for coding work PinDeck's Claude cannot do (tests, commits, package managers), they change
+   with where the deck happens to sit, and on a shared server a parent folder may be writable by others.
+   A deck pulls in shared rules explicitly instead: "Follow @../shared/STYLE.md" includes that file.
+
+   An import is "@" followed by a path (relative to the file it is in, absolute, or ~/...), at the start
+   of a line or after a space or "(". It is expanded only when that path is a text file: an e-mail address
+   or an @mention stays as it is. Imports in code spans and code blocks are left alone. Included files may
+   import others, up to 5 levels deep; each file is included once (no cycles), and all included text
+   together is limited to 200 KB. The imported text follows the file that imports it. */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const MAX_DEPTH = 5, MAX_BYTES = 200_000;
+
+/* Apply fn to the text outside code: fenced blocks (``` or ~~~) and `code spans` stay as they are */
+function outsideCode(text, fn) {
+  let fence = null;
+  return text.split("\n").map((line) => {
+    const f = /^\s*(```|~~~)/.exec(line);
+    if (f) { fence = fence ? (fence === f[1] ? null : fence) : f[1]; return line; }
+    if (fence) return line;
+    return line.split(/(`+[^`]*`+)/).map((part, i) => (i % 2 ? part : fn(part))).join("");
+  }).join("\n");
+}
+
+const resolveRef = (ref, dir) => (ref === "~" || ref.startsWith("~/") ? path.join(os.homedir(), ref.slice(1))
+  : path.resolve(dir, ref));
+
+function readText(file) {
+  try {
+    if (!fs.statSync(file).isFile()) return null;
+    const buf = fs.readFileSync(file);
+    return buf.includes(0) ? null : buf.toString("utf8");
+  } catch { return null; }
+}
+
+function expand(file, text, depth, seen, budget) {
+  const dir = path.dirname(file), found = [];
+  const body = outsideCode(text, (part) => part.replace(/(^|[\s(])@([^\s`()<>"']+)/g, (m, pre, raw) => {
+    const ref = raw.replace(/[.,:;!?]+$/, ""), tail = raw.slice(ref.length);   // "see @STYLE.md." ends a sentence
+    const abs = resolveRef(ref, dir);
+    const content = readText(abs);
+    if (content == null) return m;   // not a file: an e-mail address, an @mention, a typo
+    let real = abs;
+    try { real = fs.realpathSync(abs); } catch {}
+    const note = (why) => `${pre}${ref} (${why})${tail}`;
+    if (seen.has(real)) return note("included once, above or below");
+    if (depth >= MAX_DEPTH) return note("not included: imports nested too deep");
+    if (Buffer.byteLength(content) > budget.left) return note("not included: imported files over 200 KB in all");
+    budget.left -= Buffer.byteLength(content);
+    seen.add(real);
+    found.push({ ref, abs, content });
+    return note("included below");
+  }));
+  const parts = [body.trim()];
+  for (const imp of found) {
+    parts.push(`### ${imp.ref} (included by ${path.basename(file)})\n` + expand(imp.abs, imp.content, depth + 1, seen, budget));
+  }
+  return parts.filter(Boolean).join("\n\n");
+}
+
+/* A deck instruction file with its imports, or null when it is missing or empty */
+export function readInstructions(file) {
+  const text = readText(file);
+  if (text == null || !text.trim()) return null;
+  let real = file;
+  try { real = fs.realpathSync(file); } catch {}
+  return expand(file, text, 0, new Set([real]), { left: MAX_BYTES });
+}

package/lib/models.mjs

@@ -22,7 +22,8 @@ export function selectModel(catalog, current, requested, preferences = {}) {
   const provider = requested.provider ?? current.provider;
   if (!PROVIDERS.includes(provider)) throw new Error('Unknown provider.');
   const models = catalog[provider]?.models || [];
-  const id = requested.model ?? (provider === current.provider ? current.model : models.find(m => m.isDefault)?.id || models[0]?.id);
+  // no model chosen yet (a provider picked on the command line, before discovery): the backend's default
+  const id = requested.model ?? ((provider === current.provider && current.model) || models.find(m => m.isDefault)?.id || models[0]?.id);
   const model = models.find(m => m.id === id);
   if (!model) throw new Error(catalog[provider]?.error || 'This model is not available. Refresh the model list.');
   const sameModel = provider === current.provider && id === current.model;

package/lib/pdf-render.jxa.js

@@ -39,10 +39,12 @@ function run(argv) {
       null, w, h, 8, 4, true, false, $.NSDeviceRGBColorSpace, 0, 0);
     const ctx = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(rep);
     $.NSGraphicsContext.saveGraphicsState;
-    $.NSGraphicsContext.currentContext = ctx;
-    $.NSColor.whiteColor.setFill;
-    $.NSRectFill($.NSMakeRect(0, 0, w, h));
+    $.NSGraphicsContext.setCurrentContext(ctx);
     const cg = ctx.CGContext;
+    // a white page, as in a PDF viewer (and as Poppler renders on Linux): most PDFs paint no background,
+    // and a transparent picture would show dark text on a dark slide
+    $.CGContextSetRGBFillColor(cg, 1, 1, 1, 1);
+    $.CGContextFillRect(cg, $.CGRectMake(0, 0, w, h));
     $.CGContextScaleCTM(cg, scale, scale);
     $.CGContextTranslateCTM(cg, tx, ty);
     page.drawWithBoxToContext($.kPDFDisplayBoxMediaBox, cg);

package/lib/pdf.mjs

@@ -46,7 +46,8 @@ function chromeRun(chrome, args, profile, done, timeout) {
     proc.stdout.on("data", (d) => { out += d; check(); });
     proc.stderr.on("data", (d) => { err += d; check(); });
     proc.on("error", (e) => finish(e));
-    proc.on("exit", () => (done(out, err) ? finish(null, out) : finish(new Error("Chrome exited early."))));
+    // "close", not "exit": at exit Chrome's last output (the line saying the file is written) may still be unread
+    proc.on("close", () => (done(out, err) ? finish(null, out) : finish(new Error("Chrome exited early."))));
   });
 }
 
@@ -61,7 +62,8 @@ export async function printLayout(chrome, url, profile) {
 /* Step 2: print a (static) page to a PDF file. */
 export async function printPdf(chrome, url, out, profile) {
   try { fs.rmSync(out, { force: true }); } catch {}
-  await chromeRun(chrome, ["--no-pdf-header-footer", `--print-to-pdf=${out}`, url], profile,
+  // the virtual-time budget lets Chrome follow PinDeck's login start page to the print page before printing
+  await chromeRun(chrome, ["--virtual-time-budget=5000", "--no-pdf-header-footer", `--print-to-pdf=${out}`, url], profile,
     (_o, e) => /bytes written to file/.test(e), 90000);
   if (!fs.existsSync(out)) throw new Error("Chrome did not write the PDF.");
   return out;

package/lib/platform-notice.mjs

@@ -2,13 +2,13 @@ import http from 'node:http';
 
 export function createPlatformNoticeServer(platform) {
   const windows = platform === 'win32';
-  const heading = windows ? 'Windows support is on the roadmap' : 'PinDeck currently requires macOS';
+  const heading = windows ? 'Windows support is on the roadmap' : 'PinDeck runs on macOS and Linux';
   const explanation = windows
-    ? 'PinDeck is currently available for macOS only. Windows support is planned for a future version; there is no release date yet.'
-    : 'This version of PinDeck supports macOS only. Linux and other operating systems are not supported yet.';
-  const html = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>PinDeck · macOS required</title><style>
+    ? 'PinDeck runs on macOS and, as a beta, on Linux. Windows support is planned for a future version; there is no release date yet.'
+    : 'This version of PinDeck runs on macOS and, as a beta, on Linux. This operating system is not supported.';
+  const html = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>PinDeck · system not supported</title><style>
   :root{font-family:system-ui,sans-serif;color:#243348;background:#f4f6f8;color-scheme:light}*{box-sizing:border-box}body{margin:0;min-height:100vh;display:grid;place-items:center;padding:24px}main{width:min(100%,620px);padding:40px;background:white;border:1px solid #dde3ea;border-radius:18px;box-shadow:0 12px 40px #20334d0a}.brand{font-weight:700;color:#c36516;margin:0 0 32px}h1{font-size:clamp(26px,5vw,36px);line-height:1.2;margin:0 0 20px}p{line-height:1.65}a{color:#945012}footer{margin-top:28px;font-size:14px;color:#596577}
-  </style></head><body><main><p class="brand">PinDeck</p><h1>${heading}</h1><p>${explanation}</p><p>Your deck has not been opened or changed, and no AI backend has been started.</p><p>You can use PinDeck on a Mac or follow updates on <a href="https://github.com/ehabets/PinDeck">GitHub</a>.</p><footer>Close this tab and press Ctrl+C in the terminal to stop this notice.</footer></main></body></html>`;
+  </style></head><body><main><p class="brand">PinDeck</p><h1>${heading}</h1><p>${explanation}</p><p>Your deck has not been opened or changed, and no AI backend has been started.</p><p>You can run PinDeck on a Mac or a Linux machine (and use it from this browser through an SSH tunnel), or follow updates on <a href="https://github.com/ehabets/PinDeck">GitHub</a>.</p><footer>Close this tab and press Ctrl+C in the terminal to stop this notice.</footer></main></body></html>`;
   return http.createServer((req, res) => {
     if (req.method !== 'GET' && req.method !== 'HEAD') { res.writeHead(405, { Allow: 'GET, HEAD' }); return res.end(); }
     res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store',
@@ -28,7 +28,7 @@ export async function showPlatformNotice(port, platform = process.platform) {
     });
     server.listen(port, '127.0.0.1', () => {
       process.once('SIGINT', stop); process.once('SIGTERM', stop);
-      console.log(`PinDeck requires macOS. Open http://127.0.0.1:${server.address().port}/ for details. Press Ctrl+C to stop.`);
+      console.log(`PinDeck runs on macOS and Linux only. Open http://127.0.0.1:${server.address().port}/ for details. Press Ctrl+C to stop.`);
     });
   });
 }

package/lib/pptx-render.mjs

@@ -1,6 +1,10 @@
-/* Pictures of PowerPoint slides (macOS): PowerPoint, or else Keynote, exports the deck as a PDF with one
-   page per slide, hidden slides included; macOS PDFKit (pdf-render.jxa.js) then renders whole pages
-   (thumbnails, references for Claude) and regions (diagrams) to PNG.
+/* Pictures of PowerPoint slides, and of PDF pages.
+
+   macOS: PowerPoint, or else Keynote, exports the deck as a PDF with one page per slide, hidden slides
+   included; macOS PDFKit (pdf-render.jxa.js) then renders whole pages (thumbnails, references for Claude)
+   and regions (diagrams, PDF figures) to PNG.
+   Linux: LibreOffice (soffice --headless) exports the PDF, and Poppler (pdfinfo, pdftoppm) renders it.
+   Both are optional; lib/capabilities.mjs turns the features on when they are found.
 
    Both apps are sandboxed, so the files go through a folder inside the app's own container, which
    needs no permission dialog. macOS asks once whether PinDeck may control the app. An app that was
@@ -11,7 +15,8 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { findExecutable } from "./capabilities.mjs";
 
 const JXA = path.join(path.dirname(fileURLToPath(import.meta.url)), "pdf-render.jxa.js");
 const APPS = [
@@ -24,8 +29,16 @@ const osa = (args, timeout = 240000) => new Promise((resolve, reject) =>
     err ? reject(new Error((errOut || err.message).trim().split("\n").pop())) : resolve(out.trim())));
 const q = (s) => JSON.stringify(s);   // AppleScript string literal (same quoting rules for paths)
 
+const mac = () => process.platform === "darwin";
+const tool = (...names) => names.map((n) => findExecutable(n).path).find(Boolean) || null;
+const run = (cmd, args, timeout = 120000) => new Promise((resolve, reject) =>
+  execFile(cmd, args, { timeout, maxBuffer: 1e7 }, (err, out, errOut) =>
+    err ? reject(new Error(String(errOut || err.message).trim().split("\n").pop())) : resolve(String(out))));
+export const popplerAvailable = () => !!(tool("pdftoppm") && tool("pdfinfo"));
+export const sofficePath = () => tool("soffice", "libreoffice");
+
 export function renderAvailable() {
-  return process.platform === "darwin" && APPS.some((a) => fs.existsSync(a.bundle));
+  return mac() ? APPS.some((a) => fs.existsSync(a.bundle)) : !!(sofficePath() && popplerAvailable());
 }
 
 function exportScript(app, pptx, pdf) {
@@ -58,7 +71,7 @@ return "ok"`;
 
 /* Exports the deck to <workDir>/deck.pdf. Returns { pdf, app }. */
 export async function exportPdf(pptxPath, workDir) {
-  if (process.platform !== "darwin") throw new Error("Slide pictures need macOS with PowerPoint or Keynote.");
+  if (!mac()) return exportPdfLibreOffice(pptxPath, workDir);
   const errors = [];
   for (const app of APPS) {
     if (!fs.existsSync(app.bundle)) continue;
@@ -81,17 +94,73 @@ export async function exportPdf(pptxPath, workDir) {
   throw new Error(errors.length ? errors.join("; ") : "Neither PowerPoint nor Keynote is installed.");
 }
 
-/* Renders pages or regions (see pdf-render.jxa.js). Returns the page count. Boxes are in slide px of a
-   page slideWidth wide; with slideWidth = the page width in points, they are in PDF points. */
+/* Linux: LibreOffice exports the deck, hidden slides included (so page n is slide n). Its own profile in
+   the work folder, so a LibreOffice the user has open, or a stale lock, does not get in the way. */
+async function exportPdfLibreOffice(pptxPath, workDir) {
+  const soffice = sofficePath();
+  if (!soffice) throw new Error("LibreOffice (soffice) is not installed.");
+  const dir = fs.mkdtempSync(path.join(workDir, "libreoffice-"));
+  try {
+    const inFile = path.join(dir, "deck.pptx");
+    fs.copyFileSync(pptxPath, inFile);
+    await run(soffice, ["--headless", "--norestore", `-env:UserInstallation=${pathToFileURL(path.join(dir, "profile")).href}`,
+      "--convert-to", 'pdf:impress_pdf_Export:{"ExportHiddenSlides":{"type":"boolean","value":"true"}}',
+      "--outdir", dir, inFile], 240000);
+    const out = path.join(dir, "deck.pdf");
+    if (!fs.existsSync(out)) throw new Error("LibreOffice wrote no PDF.");
+    const pdf = path.join(workDir, "deck.pdf");
+    fs.copyFileSync(out, pdf);
+    return { pdf, app: "LibreOffice" };
+  } finally {
+    fs.rm(dir, { recursive: true, force: true }, () => {});
+  }
+}
+
+/* Renders pages or regions (see pdf-render.jxa.js for the jobs). Returns the page count. Boxes are in
+   slide px of a page slideWidth wide; with slideWidth = the page width in points, they are in PDF points. */
 export async function renderJobs(pdf, jobs, workDir, { slideWidth = 1280 } = {}) {
+  if (!mac()) return renderPoppler(pdf, jobs, slideWidth);
   return +(await runJxa({ pdf, slideWidth, jobs }, workDir));
 }
 
-/* Page count and page sizes in points: { pages, sizes: [[w, h], ...] } (macOS only, no other app needed) */
+/* Page count and page sizes in points: { pages, sizes: [[w, h], ...] } (PDFKit or Poppler, no other app) */
 export async function pdfInfo(pdf, workDir) {
+  if (!mac()) return popplerInfo(pdf);
   return JSON.parse(await runJxa({ pdf, info: true }, workDir));
 }
 
+async function popplerInfo(pdf, exact = false) {
+  const pages = +(/^Pages:\s+(\d+)/m.exec(await run(tool("pdfinfo"), [pdf])) || [])[1];
+  if (!pages) throw new Error("pdfinfo could not read the PDF.");
+  const out = await run(tool("pdfinfo"), ["-f", "1", "-l", String(pages), pdf]);
+  const sizes = [...out.matchAll(/^Page\s+(\d+)\s+size:\s+([\d.]+) x ([\d.]+)/gm)]
+    .sort((a, b) => a[1] - b[1]).map((m) => (exact ? [+m[2], +m[3]] : [Math.round(+m[2]), Math.round(+m[3])]));
+  return { pages, sizes };
+}
+
+/* The same jobs as pdf-render.jxa.js, with pdftoppm: whole pages scaled to a width, or a box of the page
+   (in slide px) at job.scale output px per slide px. White background, as PDFKit's. */
+async function renderPoppler(pdf, jobs, slideWidth) {
+  const info = await popplerInfo(pdf, true);
+  for (const job of jobs) {
+    const size = info.sizes[job.page - 1];
+    if (!size) continue;
+    const [pw, ph] = size;
+    const args = ["-f", String(job.page), "-l", String(job.page), "-png", "-singlefile"];
+    if (job.box) {
+      const [x, y, bw, bh] = job.box, s = job.scale || 2, f = pw / (slideWidth || 1280);   // PDF points per slide px
+      args.push("-r", String((s / f) * 72), "-x", String(Math.round(x * s)), "-y", String(Math.round(y * s)),
+        "-W", String(Math.max(1, Math.round(bw * s))), "-H", String(Math.max(1, Math.round(bh * s))));
+    } else {
+      const scale = (job.width || 1280) / pw;
+      args.push("-scale-to-x", String(Math.round(pw * scale)), "-scale-to-y", String(Math.round(ph * scale)));
+    }
+    const prefix = job.out.replace(/\.png$/i, "");   // pdftoppm adds .png
+    await run(tool("pdftoppm"), [...args, pdf, prefix]);
+  }
+  return info.pages;
+}
+
 async function runJxa(spec, workDir) {
   const file = path.join(workDir, `jobs-${crypto.randomBytes(4).toString("hex")}.json`);
   fs.writeFileSync(file, JSON.stringify(spec));

package/lib/system-prompt.md

@@ -12,7 +12,9 @@ Each user message may start with an <editor-context> block:
 - sometimes the path of a screenshot of the slide with the pin markers drawn on it.
 
 ## Files
-- index.html: the slides. theme.css: the styles. Edit these.
+- {{DECK}}: the slides. theme.css: the styles. Edit these. You may also edit or create other files in the
+  deck folder when a request needs it (a script such as deck.js, a style sheet, the deck's notes), but not
+  vendor/ (third-party libraries). The user can undo everything a turn changed in one step.
 - brand.css is LOCKED (logos, footer, brand colours). Never edit it. If a request needs a brand
   change, say so instead. Elements marked brand-locked are positioned by brand.css.
 - Follow the deck's CLAUDE.md (at the end of these instructions) and README.md for the template's
@@ -37,7 +39,7 @@ in the editor. Do not delete hidden slides, and do not unhide them unless asked.
 
 ## Attached files
 The user can attach figures and audio to a message. PinDeck has already saved them in the deck's
-`figures/` folder; <editor-context> lists their paths (relative to index.html), size and, for audio,
+`figures/` folder; <editor-context> lists their paths (relative to {{DECK}}), size and, for audio,
 the duration and a generated waveform SVG. If a file was dropped onto a slide, the drop position is
 given too. Put them on slides with the deck's existing patterns: a figure like the other `figure.fig`
 blocks, audio like the deck's audio demo (audio element, play button, waveform). Read an image
@@ -84,7 +86,7 @@ If the user asks for a PDF, run `{{CLI}} pdf handout` (one page per slide, build
 
 ## Hand edits
 The user can also select, move and resize elements in the editor. Those changes are written as
-inline styles on the element in index.html: `translate: Xpx Ypx` for moves, `width`/`height` (and
+inline styles on the element in {{DECK}}: `translate: Xpx Ypx` for moves, `width`/`height` (and
 `max-width`/`max-height: none`) for sizes. You get a note about each one. Treat them as intended;
 keep them unless asked. If the user asks to clean up, move them into proper CSS rules.
 The user can also edit text in place (double-click); you get a note with the new text. Keep their