excaliagent 0.2.0 → 0.4.0

package/dist/server/sources/opencode-live.js

@@ -0,0 +1,144 @@
+// Which OpenCode sessions are running, and in which process. OpenCode
+// (verified on 1.19.3, Linux) keeps no session registry, lock or port file:
+// the TUI is one process (the server runs in a worker thread, no listener
+// unless --port is given) and the session it shows lives only in its memory.
+// What is visible from outside: the TUI's argv (`-s/--session <id>` when it was
+// started on a session) and its working directory (= the session's
+// `directory` for sessions it creates). So:
+//
+// 1. a TUI started with `-s <id>` (not `--fork`) shows that session;
+// 2. any other TUI shows the most recently updated root session of its
+//    directory, if that session was updated after the TUI started (a TUI on
+//    its home screen, or idle on an older session, claims nothing).
+//
+// This is a heuristic; docs/design.md "OpenCode data" lists where it is wrong.
+// Only rule 1 is exact; only exact matches may be stopped from the board.
+// Pure matching lives in `assignOpenCodeLive`; the /proc reading is Linux-only
+// and takes a proc root, so tests read a synthetic tree.
+import { readlink } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { createProcessTable } from "../desktop/process-table.js";
+import { bootTime, startedAt } from "./proc.js";
+/** OpenCode session ids: `ses_` + 12 hex (time) + 14 base62. */
+export const OPENCODE_ID = /^ses_[0-9a-zA-Z]{26}$/;
+/** The native binary (`opencode`, nix `.opencode-wrapped`), or the npm shim (`node …/bin/opencode`). */
+export function looksLikeOpenCode(argv, exe) {
+    const names = [argv?.[0], exe].filter((n) => !!n).map((n) => basename(n));
+    if (names.some((n) => /^\.?opencode(-wrapped)?(\.exe)?$/.test(n)))
+        return true;
+    const script = argv?.[1] ? basename(argv[1]) : "";
+    return names.some((n) => /^(node|bun)(\.exe)?$/.test(n)) && (script === "opencode" || script === "opencode.js");
+}
+const VALUE_FLAGS = new Set([
+    "--log-level", "--port", "--hostname", "--mdns-domain", "--cors", "-m", "--model", "-s", "--session", "--prompt",
+    "--agent", "--replay-limit",
+]);
+// Subcommands that are not the interactive TUI (`opencode [project]`, `opencode pr <n>`).
+const NOT_TUI = new Set([
+    "completion", "acp", "mcp", "attach", "run", "debug", "providers", "auth", "agent", "upgrade", "uninstall", "serve",
+    "web", "models", "stats", "export", "import", "github", "session", "plugin", "plug", "db",
+]);
+function args(argv) {
+    const shim = /^(node|bun)(\.exe)?$/.test(basename(argv[0] ?? ""));
+    return argv.slice(shim ? 2 : 1);
+}
+/** First positional word: a subcommand, a project dir, or undefined. */
+export function openCodeSubcommand(argv) {
+    const a = args(argv);
+    for (let i = 0; i < a.length; i++) {
+        const w = a[i];
+        if (w === "--")
+            return a[i + 1];
+        if (w.startsWith("-")) {
+            if (VALUE_FLAGS.has(w))
+                i++;
+            continue;
+        }
+        return w;
+    }
+    return undefined;
+}
+export const isOpenCodeTui = (argv) => {
+    const sub = openCodeSubcommand(argv);
+    return sub === undefined || !NOT_TUI.has(sub);
+};
+/** `-s <id>`, `--session <id>`, `--session=<id>`; undefined with `--fork` (that makes a new session). */
+export function argvSessionId(argv) {
+    const a = args(argv);
+    if (a.includes("--fork"))
+        return undefined;
+    for (let i = 0; i < a.length; i++) {
+        const w = a[i];
+        const v = w === "-s" || w === "--session" ? a[i + 1] : w.startsWith("--session=") ? w.slice(10) : undefined;
+        if (v && OPENCODE_ID.test(v))
+            return v;
+    }
+    return undefined;
+}
+/**
+ * Pure. `byId` finds a root, unarchived session by id; `inDir` lists the root,
+ * unarchived sessions whose directory is `dir`.
+ */
+export function assignOpenCodeLive(procs, byId, inDir) {
+    const pids = new Set(procs.map((p) => p.pid));
+    // The npm shim and its native child count once, as the shim (the pane's foreground).
+    // Newest first: a later TUI is more likely on the newest session of a directory.
+    const tuis = procs
+        .filter((p) => isOpenCodeTui(p.argv) && !pids.has(p.ppid))
+        .sort((a, b) => b.startedAt - a.startedAt || b.pid - a.pid);
+    const out = [];
+    const taken = new Set();
+    const rest = [];
+    for (const t of tuis) {
+        const id = argvSessionId(t.argv);
+        // A TUI that names its session never guesses another one.
+        if (!id) {
+            rest.push(t);
+            continue;
+        }
+        const s = byId(id);
+        if (s && !taken.has(s.id)) {
+            taken.add(s.id);
+            out.push({ id: s.id, pid: t.pid, since: t.startedAt, exact: true });
+        }
+    }
+    for (const t of rest) {
+        if (!t.cwd)
+            continue;
+        const best = inDir(t.cwd)
+            .filter((s) => !taken.has(s.id) && s.updatedAt >= t.startedAt)
+            .sort((a, b) => b.updatedAt - a.updatedAt)[0];
+        if (!best)
+            continue;
+        taken.add(best.id);
+        out.push({ id: best.id, pid: t.pid, since: t.startedAt, exact: false });
+    }
+    return out;
+}
+/**
+ * Running OpenCode processes with argv, cwd and start time, read from
+ * `procRoot`. Undefined when it has no boot time (not Linux): liveness unknown.
+ */
+export async function scanOpenCodeProcesses(procRoot = "/proc") {
+    const btime = await bootTime(procRoot);
+    if (btime === undefined)
+        return undefined;
+    const table = createProcessTable({ platform: "linux", procRoot });
+    const out = [];
+    for (const p of await table.list()) {
+        // Cheap filter before reading argv: the binary, the nix wrapper, or a shim.
+        if (!/opencode|node|bun|MainThread/i.test(p.comm))
+            continue;
+        const [argv, exe] = await Promise.all([table.argv(p.pid), table.exe(p.pid)]);
+        if (!argv || !looksLikeOpenCode(argv, exe))
+            continue;
+        const [cwd, started] = await Promise.all([
+            readlink(join(procRoot, String(p.pid), "cwd")).catch(() => undefined),
+            startedAt(procRoot, p.pid, btime),
+        ]);
+        if (!started)
+            continue;
+        out.push({ pid: p.pid, ppid: p.ppid, argv, ...(cwd ? { cwd } : {}), startedAt: started });
+    }
+    return out;
+}

package/dist/server/sources/opencode.js

@@ -0,0 +1,265 @@
+// OpenCode source: sessions from OpenCode's SQLite database
+// ($XDG_DATA_HOME/opencode/opencode.db), read-only through `node:sqlite`
+// (Node 22.13+; without it the source logs once and shows nothing). Live
+// sessions come from the running TUI processes (opencode-live.ts); status from
+// the newest message since the TUI started: busy while a reply is unfinished.
+// Permission prompts are not stored, so they show as busy.
+// Formats: docs/design.md "OpenCode data".
+import { stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { createProcessTable } from "../desktop/process-table.js";
+import { GitReader } from "./git.js";
+import { onceLogger } from "./log.js";
+import { assignOpenCodeLive, isOpenCodeTui, looksLikeOpenCode, OPENCODE_ID, scanOpenCodeProcesses, } from "./opencode-live.js";
+export const openCodeResumeCommand = (id) => `opencode -s ${id}`;
+export function defaultOpenCodeDataDir(env = process.env) {
+    return join(env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "opencode");
+}
+export function defaultOpenCodeDbPath(dataDir, env = process.env) {
+    const override = env.OPENCODE_DB;
+    if (override && override !== ":memory:")
+        return override.startsWith("/") ? override : join(dataDir, override);
+    return join(dataDir, "opencode.db");
+}
+/** Default titles OpenCode gives before it has generated one. */
+export function isDefaultTitle(title) {
+    return /^(New session|Child session) - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/.test(title);
+}
+const COLS = "id, directory, title, time_updated, time_created, parent_id, time_archived";
+const ROOT = "parent_id IS NULL AND time_archived IS NULL";
+/** node:sqlite, read-only. */
+export async function openOpenCodeDb(path) {
+    if (!(await stat(path).catch(() => undefined)))
+        return undefined;
+    const { DatabaseSync } = await import("node:sqlite");
+    const db = new DatabaseSync(path, { readOnly: true });
+    // OpenCode writes all the time (WAL); wait briefly instead of failing a poll.
+    db.exec("PRAGMA busy_timeout = 250");
+    const placeholders = (n) => Array(n).fill("?").join(",");
+    return {
+        recent: (limit) => db.prepare(`SELECT ${COLS} FROM session WHERE ${ROOT} ORDER BY time_updated DESC LIMIT ?`).all(limit),
+        byIds: (ids) => ids.length ? db.prepare(`SELECT ${COLS} FROM session WHERE id IN (${placeholders(ids.length)})`).all(...ids) : [],
+        inDirs: (dirs) => dirs.length
+            ? db.prepare(`SELECT ${COLS} FROM session WHERE ${ROOT} AND directory IN (${placeholders(dirs.length)})`).all(...dirs)
+            : [],
+        lastMessage: (id) => db
+            .prepare(`SELECT json_extract(data, '$.role') AS role, json_extract(data, '$.time.completed') AS completed, time_created AS created
+           FROM message WHERE session_id = ? ORDER BY time_created DESC, id DESC LIMIT 1`)
+            .get(id),
+        close: () => db.close(),
+    };
+}
+function defaultIsOpenCodeTui(procRoot) {
+    const table = procRoot ? createProcessTable({ platform: "linux", procRoot }) : createProcessTable();
+    return async (pid) => {
+        const argv = await table.argv(pid);
+        return !!argv && looksLikeOpenCode(argv, await table.exe(pid)) && isOpenCodeTui(argv);
+    };
+}
+/** Busy while the newest message since the TUI started is a prompt or an unfinished reply. */
+export function openCodeStatus(last, since) {
+    if (!last || last.created < since)
+        return "idle";
+    if (last.role === "user")
+        return "busy";
+    return last.role === "assistant" && last.completed == null ? "busy" : "idle";
+}
+const epochMs = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0);
+export function openCodeSession(row, opts) {
+    const s = {
+        id: row.id,
+        source: "opencode",
+        cwd: row.directory,
+        repo: basename(row.directory),
+        status: opts.live ? (opts.status ?? "idle") : "dormant",
+        // A missing or odd value never becomes a number the board would date from 1970 (it shows no age for 0).
+        lastActivityAt: epochMs(row.time_updated) || epochMs(row.time_created),
+        cacheTtlMs: 0,
+        cacheExpiresAt: 0,
+        live: !!opts.live,
+        prLinks: [],
+        resumeCommand: openCodeResumeCommand(row.id),
+    };
+    if (opts.live)
+        s.pid = opts.live.pid;
+    // Stop only for a TUI started on exactly this session, never a directory guess.
+    if (opts.live?.exact)
+        s.canEnd = true;
+    if (row.title && !isDefaultTitle(row.title))
+        s.title = row.title;
+    if (opts.git) {
+        s.repo = basename(opts.git.root);
+        s.repoRoot = opts.git.root;
+        s.branch = opts.git.branch;
+    }
+    return s;
+}
+const candidate = (r) => ({ id: r.id, directory: r.directory, updatedAt: r.time_updated });
+/** Rows whose id is not a valid OpenCode id never become a session (or a command). */
+const valid = (rows) => rows.filter((r) => typeof r.id === "string" && OPENCODE_ID.test(r.id));
+export function createOpenCodeSource(opts = {}) {
+    const dataDir = opts.dataDir ?? defaultOpenCodeDataDir();
+    const dbPath = opts.dbPath ?? defaultOpenCodeDbPath(dataDir);
+    const openDb = opts.openDb ?? openOpenCodeDb;
+    const scan = opts.scan ?? (() => scanOpenCodeProcesses(opts.procRoot));
+    const pollMs = opts.pollMs ?? 2000;
+    const cacheMs = opts.cacheMs ?? pollMs;
+    const maxDormant = opts.maxDormant ?? 200;
+    const warn = onceLogger(opts.log ?? console.warn);
+    const git = new GitReader({ ttlMs: opts.gitTtlMs ?? 2000 });
+    const isTui = opts.isOpenCodeTui ?? defaultIsOpenCodeTui(opts.procRoot);
+    const kill = opts.kill ?? ((pid, signal) => process.kill(pid, signal));
+    let db;
+    let opening;
+    async function database() {
+        if (db)
+            return db;
+        opening ??= openDb(dbPath)
+            .catch((e) => {
+            warn(`excaliagent: cannot open the OpenCode database ${dbPath}: ${e.message}`, "opencode-db");
+            return undefined;
+        })
+            .finally(() => (opening = undefined));
+        db = await opening;
+        return db;
+    }
+    /** Runs a query; on failure (schema change, file replaced) reopens next time. */
+    async function query(fn, fallback) {
+        const d = await database();
+        if (!d)
+            return fallback;
+        try {
+            return fn(d);
+        }
+        catch (e) {
+            warn(`excaliagent: reading the OpenCode database failed: ${e.message}`, "opencode-query");
+            db = undefined;
+            try {
+                d.close();
+            }
+            catch {
+                // already closed
+            }
+            return fallback;
+        }
+    }
+    async function live() {
+        const procs = await scan().catch(() => undefined);
+        if (!procs?.length)
+            return [];
+        const ids = procs.map((p) => p.argv).flatMap((a) => a.filter((w) => OPENCODE_ID.test(w) || w.startsWith("--session=")).map((w) => w.replace(/^--session=/, "")));
+        const dirs = [...new Set(procs.map((p) => p.cwd).filter((c) => !!c))];
+        const rows = new Map();
+        for (const r of valid(await query((d) => [...d.byIds(ids), ...d.inDirs(dirs)], [])))
+            rows.set(r.id, r);
+        const usable = [...rows.values()].filter((r) => r.parent_id == null && r.time_archived == null);
+        const assigned = assignOpenCodeLive(procs, (id) => {
+            const r = rows.get(id);
+            return r && usable.includes(r) ? candidate(r) : undefined;
+        }, (dir) => usable.filter((r) => r.directory === dir).map(candidate));
+        return assigned.map((l) => ({ row: rows.get(l.id), live: l }));
+    }
+    let look;
+    let looking;
+    async function current(fresh = false) {
+        if (!fresh && look && Date.now() - look.at < cacheMs)
+            return look;
+        looking ??= (async () => {
+            const found = await live();
+            look = { at: Date.now(), live: found, sessions: await build(found) };
+            return look;
+        })().finally(() => (looking = undefined));
+        return looking;
+    }
+    async function list() {
+        return (await current()).sessions;
+    }
+    async function build(found) {
+        const out = [];
+        for (const { row, live: l } of found) {
+            const last = await query((d) => d.lastMessage(row.id), undefined);
+            out.push(openCodeSession(row, { live: l, status: openCodeStatus(last, l.since), git: await git.get(row.directory) }));
+        }
+        return out.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    }
+    async function listDormant() {
+        const liveIds = new Set((await current()).live.map((l) => l.row.id));
+        const rows = valid(await query((d) => d.recent(maxDormant + liveIds.size), [])).filter((r) => !liveIds.has(r.id));
+        const out = [];
+        for (const r of rows.slice(0, maxDormant))
+            out.push(openCodeSession(r, { git: await git.get(r.directory) }));
+        return out;
+    }
+    async function get(id) {
+        if (!OPENCODE_ID.test(id))
+            return undefined;
+        const running = (await list()).find((s) => s.id === id);
+        if (running)
+            return running;
+        const [row] = valid(await query((d) => d.byIds([id]), []));
+        return row ? openCodeSession(row, { git: await git.get(row.directory) }) : undefined;
+    }
+    function watch(cb) {
+        let closed = false;
+        let running = false;
+        let last;
+        // No file to watch tells more than a poll: the db changes on every token.
+        const refresh = async () => {
+            if (running || closed)
+                return;
+            running = true;
+            try {
+                const sessions = (await current(true)).sessions;
+                const key = JSON.stringify(sessions);
+                if (!closed && key !== last) {
+                    last = key;
+                    try {
+                        cb(sessions);
+                    }
+                    catch (e) {
+                        warn(`excaliagent: session watcher callback threw: ${e.message}`, "opencode-watch-callback");
+                    }
+                }
+            }
+            catch (e) {
+                warn(`excaliagent: refreshing OpenCode sessions failed: ${e.message}`, "opencode-refresh");
+            }
+            finally {
+                running = false;
+            }
+        };
+        const poll = setInterval(() => void refresh(), pollMs);
+        void refresh();
+        return () => {
+            closed = true;
+            clearInterval(poll);
+            db?.close();
+            db = undefined;
+        };
+    }
+    /**
+     * SIGTERM to the TUI: OpenCode closes the reply, restores the terminal and
+     * exits. Only for a TUI started with `-s <id>`: a session matched by
+     * directory is "unsupported", so a guess never ends a process.
+     */
+    async function end(id) {
+        if (!OPENCODE_ID.test(id))
+            return "not-live";
+        const l = (await current()).live.find((x) => x.row.id === id);
+        if (!l)
+            return "not-live";
+        if (!l.live.exact)
+            return "unsupported";
+        if (!(await isTui(l.live.pid).catch(() => false)))
+            return "not-live";
+        try {
+            kill(l.live.pid, "SIGTERM");
+        }
+        catch {
+            return "not-live";
+        }
+        return "ended";
+    }
+    return { list, listDormant, get, watch, end };
+}

package/dist/server/sources/proc.js

@@ -0,0 +1,34 @@
+// Small /proc helpers shared by the adapters that find their sessions among
+// running processes (Codex, OpenCode). Every reader takes the proc root, so
+// tests and the demo point it at a synthetic tree (EXCALIAGENT_PROC_ROOT) and
+// never read the machine's real processes.
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+/** Where the server reads processes from: the real /proc unless overridden (tests, demo). */
+export function procRootFromEnv(env = process.env) {
+    return env.EXCALIAGENT_PROC_ROOT || undefined;
+}
+/** Field 22 of /proc/<pid>/stat: start time in clock ticks since boot. */
+export function parseStartTicks(stat) {
+    const close = stat.lastIndexOf(")");
+    const ticks = Number(stat.slice(close + 1).trim().split(/\s+/)[19]);
+    return close > 0 && Number.isFinite(ticks) ? ticks : undefined;
+}
+/** Linux clock ticks per second (USER_HZ); 100 on every mainstream architecture. */
+export const USER_HZ = 100;
+/** Boot time (epoch s) from <procRoot>/stat, or undefined (not Linux). */
+export async function bootTime(procRoot) {
+    const stat = await readFile(join(procRoot, "stat"), "utf8").catch(() => undefined);
+    const btime = stat ? Number(/^btime (\d+)$/m.exec(stat)?.[1]) : NaN;
+    return Number.isFinite(btime) && btime > 0 ? btime : undefined;
+}
+/**
+ * Epoch ms a process started (btime is whole seconds, so this can be up to 1 s
+ * early), or 0 when unknown.
+ */
+export async function startedAt(procRoot, pid, btime) {
+    if (btime === undefined)
+        return 0;
+    const ticks = parseStartTicks(await readFile(join(procRoot, String(pid), "stat"), "utf8").catch(() => ""));
+    return ticks === undefined ? 0 : Math.floor((btime + ticks / USER_HZ) * 1000);
+}

package/dist/server/sources/transcript.js

@@ -1,12 +1,9 @@
 // Incremental scanner for Claude Code transcripts
 // (<claudeDir>/projects/<slug>/<sessionId>.jsonl). Keeps a byte offset per file
 // and parses only appended bytes. Never keeps message content.
-import { open, stat } from "node:fs/promises";
-import { onceLogger } from "./log.js";
+import { JsonlScanner } from "./jsonl.js";
 export const TTL_1H = 3600_000;
 export const TTL_5M = 300_000;
-const CHUNK = 1 << 20;
-const NL = 0x0a;
 // Cheap prefilter; the parsed top-level `type` is still checked.
 const INTERESTING = /"type":"(?:ai-title|agent-name|pr-link|continued-in|user|assistant|api-request)"/;
 const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
@@ -100,105 +97,14 @@ function snapshot(acc) {
         out.gitBranch = acc.gitBranch;
     return out;
 }
-export class TranscriptScanner {
-    files = new Map();
-    inflight = new Map();
-    warn;
+const fold = {
+    empty: emptyAcc,
+    interesting: (line) => INTERESTING.test(line),
+    apply: applyLine,
+    snapshot,
+};
+export class TranscriptScanner extends JsonlScanner {
     constructor(opts = {}) {
-        this.warn = opts.warn ?? onceLogger(opts.log ?? console.warn);
-    }
-    /** Scans new bytes of `path` and returns the folded info, or undefined if the file is gone. */
-    scan(path) {
-        const running = this.inflight.get(path);
-        if (running)
-            return running;
-        const p = this.doScan(path).finally(() => this.inflight.delete(path));
-        this.inflight.set(path, p);
-        return p;
-    }
-    /** Read bookkeeping, for tests. */
-    stats(path) {
-        const s = this.files.get(path);
-        return s && { offset: s.offset, bytesRead: s.bytesRead };
-    }
-    forget(path) {
-        this.files.delete(path);
-    }
-    async doScan(path) {
-        let st;
-        try {
-            st = await stat(path);
-        }
-        catch {
-            this.files.delete(path);
-            return undefined;
-        }
-        let s = this.files.get(path);
-        const replaced = !s || s.ino !== st.ino || s.dev !== st.dev;
-        const shrunk = !!s && st.size < s.offset;
-        // Same size but touched: rewritten in place (appends always grow the file).
-        const rewritten = !!s && st.size === s.offset && st.mtimeMs !== s.mtimeMs;
-        if (!s || replaced || shrunk || rewritten) {
-            s = { ino: st.ino, dev: st.dev, mtimeMs: st.mtimeMs, offset: 0, bytesRead: s?.bytesRead ?? 0, partial: Buffer.alloc(0), acc: emptyAcc() };
-            this.files.set(path, s);
-        }
-        if (st.size > s.offset) {
-            try {
-                await this.readFrom(path, s, st.size);
-            }
-            catch (e) {
-                this.warn(`excaliagent: cannot read transcript ${path}: ${e.message}`, path);
-            }
-        }
-        s.mtimeMs = st.mtimeMs;
-        return snapshot(s.acc);
-    }
-    async readFrom(path, s, end) {
-        const fh = await open(path, "r");
-        try {
-            const buf = Buffer.allocUnsafe(Math.min(CHUNK, end - s.offset));
-            while (s.offset < end) {
-                const { bytesRead } = await fh.read(buf, 0, Math.min(buf.length, end - s.offset), s.offset);
-                if (bytesRead === 0)
-                    break;
-                s.offset += bytesRead;
-                s.bytesRead += bytesRead;
-                this.consume(path, s, buf.subarray(0, bytesRead));
-            }
-        }
-        finally {
-            await fh.close();
-        }
-    }
-    consume(path, s, chunk) {
-        let start = 0;
-        let nl = chunk.indexOf(NL, start);
-        while (nl !== -1) {
-            const piece = chunk.subarray(start, nl);
-            const line = s.partial.length ? Buffer.concat([s.partial, piece]) : piece;
-            s.partial = Buffer.alloc(0);
-            this.parseLine(path, s.acc, line);
-            start = nl + 1;
-            nl = chunk.indexOf(NL, start);
-        }
-        if (start < chunk.length)
-            s.partial = Buffer.concat([s.partial, chunk.subarray(start)]);
-    }
-    parseLine(path, acc, line) {
-        if (line.length === 0)
-            return;
-        const text = line.toString("utf8");
-        if (!INTERESTING.test(text))
-            return;
-        let o;
-        try {
-            o = JSON.parse(text);
-        }
-        catch {
-            this.warn(`excaliagent: skipping malformed line(s) in ${path}`, path);
-            return;
-        }
-        if (o && typeof o === "object" && !Array.isArray(o))
-            applyLine(acc, o);
+        super(fold, { ...opts, noun: "transcript" });
     }
 }

package/dist/server/token.js

@@ -0,0 +1,23 @@
+// The access token: created once per state dir and reused, so the browser's
+// cookie (and a bookmark of the board) survives restarts. The file is 0600;
+// whatever can read it could read ~/.claude too.
+import { randomBytes } from "node:crypto";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const VALID = /^[A-Za-z0-9_-]{32,}$/;
+export async function loadOrCreateToken(stateDir) {
+    const path = join(stateDir, "token");
+    try {
+        const t = (await readFile(path, "utf8")).trim();
+        if (VALID.test(t))
+            return t;
+    }
+    catch {
+        // missing: create it
+    }
+    await mkdir(stateDir, { recursive: true });
+    const token = randomBytes(24).toString("base64url");
+    await writeFile(path, `${token}\n`, { mode: 0o600 });
+    await chmod(path, 0o600); // mode only applies when the file is created
+    return token;
+}

package/dist/shared/packs.js

@@ -0,0 +1,62 @@
+// Character packs (docs/design.md "Characters"): shared by the server (which
+// lists, validates and stores them) and the board (which assigns and draws them).
+//
+// A pack is an ordered list of characters. Built-in packs are Unicode emoji,
+// drawn by the system's emoji font; their ids start with "@", a character that
+// custom pack names (folder names under <stateDir>/packs/) cannot contain, so
+// the two never collide. Custom packs hold emoji and/or image files.
+export const DEFAULT_PACK = "@animals";
+/** Custom pack names: a folder name that can never escape `<stateDir>/packs/`. */
+export const PACK_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$/;
+/** Characters per pack beyond this are ignored (and refused on add). */
+export const MAX_PACK_CHARACTERS = 200;
+/** `excaliagent-emoji-1f431`: the file id encodes the emoji, so the board can redraw it from the id alone. */
+export function emojiFileId(emoji) {
+    return `excaliagent-emoji-${[...emoji].map((c) => c.codePointAt(0).toString(16)).join("-")}`;
+}
+/** The emoji an `emojiFileId` encodes, or undefined. */
+export function emojiFromFileId(fileId) {
+    const m = /^excaliagent-emoji-([0-9a-f]{1,6}(?:-[0-9a-f]{1,6}){0,15})$/.exec(fileId);
+    if (!m)
+        return undefined;
+    try {
+        const emoji = String.fromCodePoint(...m[1].split("-").map((h) => parseInt(h, 16)));
+        return validEmoji(emoji) ? emoji : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+/**
+ * One emoji: a single grapheme (ZWJ sequences, skin tones and flags included),
+ * at most 32 UTF-16 units, with a pictographic or regional-indicator character
+ * and no control characters or whitespace.
+ */
+export function validEmoji(s) {
+    if (typeof s !== "string" || s.length === 0 || s.length > 32)
+        return false;
+    if (/[\p{Cc}\s]/u.test(s))
+        return false;
+    if (!/\p{Extended_Pictographic}|\p{Regional_Indicator}/u.test(s))
+        return false;
+    return [...segmenter.segment(s)].length === 1;
+}
+const emojiPack = (id, name, emoji) => ({
+    id,
+    name,
+    builtIn: true,
+    characters: emoji
+        .split(" ")
+        .filter(Boolean)
+        .map((e) => ({ id: e, kind: "emoji", fileId: emojiFileId(e) })),
+});
+// Emoji from Unicode ≤ 12 without ZWJ sequences or variation selectors, so
+// every common emoji font (Noto Color Emoji, Apple, Segoe UI) has them.
+export const BUILT_IN_PACKS = [
+    emojiPack("@animals", "Animals", "🐶 🐱 🐭 🐹 🐰 🦊 🐻 🐼 🐨 🐯 🦁 🐮 🐷 🐸 🐵 🐔 🐧 🦆 🦅 🦉 🐺 🐗 🐴 🦄 🐝 🐞 🦋 🐌 🐢 🐍 🦎 🦒 🦓 🐘 🦔 🦘"),
+    emojiPack("@cats", "Cats & friends", "😺 😸 😹 😻 😼 😽 🙀 😿 😾 🐱 🐈 🐯 🐅 🐆 🦁 🐶 🐕 🐩 🐹 🐰 🐇 🐭 🐁 🦔 🐤 🐥 🐣 🐦"),
+    emojiPack("@sea", "Sea", "🐙 🦑 🦐 🦞 🦀 🐡 🐠 🐟 🐬 🐳 🐋 🦈 🐊 🐢 🐚 🦦 🐧 🦢 🦆 🦪 ⛵ 🚤 🛶 🚢 ⚓ 🏄 🌊 🧜 🌴"),
+    emojiPack("@fantasy", "Fantasy", "🐉 🐲 🦄 🧙 🧚 🧛 🧜 🧝 🧞 🧟 🦸 🦹 👻 👽 👾 🤖 👹 👺 💀 🎃 🦖 🦕 🔮 🗿 🏰 🛸 🌋 🌈 🍄"),
+    emojiPack("@food", "Food", "🍎 🍐 🍊 🍋 🍌 🍉 🍇 🍓 🍒 🍑 🍍 🥥 🥝 🍅 🍆 🥑 🥦 🌽 🥕 🥐 🥖 🥨 🧀 🥚 🥞 🥓 🍔 🍟 🍕 🌭 🥪 🌮 🌯 🍣 🍜 🍩 🍪 🍰 🍫 🍿"),
+];

package/dist/web/assets/{abnfDiagram-VCTEODGH-tmjYj3VY.js → abnfDiagram-VCTEODGH-BxrKsDoB.js}

@@ -1 +1 @@
-import{n as e}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import{m as t}from"./src-BWF7jMDv.js";import"./chunk-DU6HZSFF-DYHa8ENH.js";import"./dist-D-3cz42D.js";import{n,r,t as i}from"./chunk-SVP7TREG-CaeKcCSu.js";import{t as a}from"./chunk-JWPE2WC7-DVXcaiue.js";import{E as o,t as s}from"./mermaid-parser.core-Da_XEVmR.js";var c=o().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{a(e,i),e.title&&i.setTitle(e.title),e.rules.map(e=>i.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{i.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let n=c.parse(e);if(n.lexerErrors.length>0||n.parserErrors.length>0)throw new s(n);let r=n.value;t.debug(`[ABNF Parser] Parsed rules:`,r.rules.length),h(r),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:i}},db:i,renderer:r,styles:n};export{g as diagram};
+import{n as e}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import{m as t}from"./src-BWF7jMDv.js";import"./chunk-DU6HZSFF-SqE0xdu5.js";import"./dist-DcwmvBdV.js";import{n,r,t as i}from"./chunk-SVP7TREG-DkRJF9jr.js";import{t as a}from"./chunk-JWPE2WC7-DVXcaiue.js";import{E as o,t as s}from"./mermaid-parser.core-Dbqkvrw-.js";var c=o().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{a(e,i),e.title&&i.setTitle(e.title),e.rules.map(e=>i.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{i.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let n=c.parse(e);if(n.lexerErrors.length>0||n.parserErrors.length>0)throw new s(n);let r=n.value;t.debug(`[ABNF Parser] Parsed rules:`,r.rules.length),h(r),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:i}},db:i,renderer:r,styles:n};export{g as diagram};