excaliagent 0.3.0 → 0.4.0

package/dist/server/sources/multi.js

@@ -0,0 +1,53 @@
+const byId = (a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+/** Fail soft: one broken adapter must not take the others down. */
+async function settle(work, warn, what) {
+    try {
+        return await work;
+    }
+    catch (e) {
+        warn(`excaliagent: ${what} failed: ${e.message}`);
+        return [];
+    }
+}
+export function combineSources(sources, warn = console.warn) {
+    if (sources.length === 1)
+        return sources[0];
+    return {
+        async list() {
+            const lists = await Promise.all(sources.map((s) => settle(s.list(), warn, "listing sessions")));
+            return lists.flat().sort(byId);
+        },
+        watch(cb) {
+            const latest = sources.map(() => undefined);
+            const emit = () => cb(latest.flatMap((l) => l ?? []).sort(byId));
+            const offs = sources.map((s, i) => s.watch((sessions) => {
+                latest[i] = sessions;
+                emit();
+            }));
+            return () => {
+                for (const off of offs)
+                    off();
+            };
+        },
+        async listDormant() {
+            const lists = await Promise.all(sources.map((s) => settle(s.listDormant(), warn, "listing dormant sessions")));
+            return lists.flat().sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+        },
+        async get(id) {
+            for (const s of sources) {
+                const found = await s.get(id).catch(() => undefined);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        },
+        async end(id) {
+            for (const s of sources) {
+                const found = await s.get(id).catch(() => undefined);
+                if (found)
+                    return s.end ? s.end(id) : "unsupported";
+            }
+            return "not-live";
+        },
+    };
+}

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" });
     }
 }