baychat 0.11.2 → 0.11.4

package/dist/relay/resume.js

@@ -0,0 +1,615 @@
+"use strict";
+/**
+ * Resume-id discovery.
+ *
+ * A detached session with no resume id is the relay's worst failure mode: the
+ * message reaches the box, `canResume` says no, and the delivery is recorded
+ * `pending` until a human re-attaches by hand. Every other delay in the system
+ * is measured in seconds; that one is unbounded.
+ *
+ * This module answers one question — *which runtime session is this BayChat
+ * session?* — and it is allowed to answer "I don't know". Resuming the wrong
+ * session is strictly worse than reporting pending: it answers a room from a
+ * process with no memory of it, or hijacks an unrelated piece of work. So
+ * every method here either **identifies** a session or refuses.
+ *
+ * Three methods, in descending order of trust:
+ *
+ *  1. `flag`        — a human passed `--resume-id`. We take their word for it.
+ *  2. `session-env` — the attaching session read its OWN id out of the
+ *                     environment its runtime gave it. Self-identification, so
+ *                     it cannot name someone else's session.
+ *  3. `transcript`  — the relay found, in the runtime's own on-disk state, a
+ *                     session whose transcript records *this BayChat session
+ *                     name being attached*. That is evidence of identity, not a
+ *                     heuristic about recency.
+ *
+ * Deliberately NOT implemented: `claude --continue` and `codex exec resume
+ * --last`. Both mean "the most recent session in this directory", which is a
+ * statement about who ran last, not about who attached. On the machine this was
+ * written on, `/var/www/baychat` holds ten Claude transcripts and five Codex
+ * conversations, two of the latter started two seconds apart in the same
+ * directory — and Codex's newest rollout there is a *subagent* thread. A
+ * `--last` wake would have resumed a stranger. See ADR note in
+ * docs/features/AGENT_RELAY.md.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_ID_ENV = void 0;
+exports.isUuid = isUuid;
+exports.attachMarker = attachMarker;
+exports.commandAttaches = commandAttaches;
+exports.resumeIdFromSessionEnv = resumeIdFromSessionEnv;
+exports.discoverClaudeResume = discoverClaudeResume;
+exports.discoverCodexResume = discoverCodexResume;
+exports.discoverResume = discoverResume;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60_000;
+const DEFAULT_MAX_FILES = 200;
+const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
+/**
+ * The env var each runtime exports to processes it spawns, if any.
+ *
+ * `CLAUDE_CODE_SESSION_ID` is verified: it is present in the environment of
+ * every Bash tool call and equals the id of the transcript the session is
+ * writing (a subagent inherits its parent's, which is the id you want — the
+ * parent is what `--resume` reopens).
+ *
+ * `CODEX_THREAD_ID` is a name found in the Codex binary next to its
+ * `exec_command` plumbing and is NOT verified to be exported. It is read
+ * opportunistically and then **corroborated against on-disk rollouts** before
+ * being trusted, because an unverified variable could name a subagent thread —
+ * exactly the kind of wrong session this module exists to refuse.
+ *
+ * Cursor and Hermes export nothing we can verify, and neither can be resumed
+ * headlessly anyway: for them "no session id" is the permanent, correct answer
+ * rather than a gap to be closed. They are woken while attached instead.
+ */
+exports.SESSION_ID_ENV = {
+    claude: "CLAUDE_CODE_SESSION_ID",
+    codex: "CODEX_THREAD_ID",
+    cursor: null,
+    hermes: null,
+};
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+    return UUID_RE.test(value);
+}
+/**
+ * Build the matcher for "this command attached THIS BayChat session".
+ *
+ * Three things have to be true at once, and each one closes a real false
+ * positive found while writing this:
+ *
+ *  - the **BayChat CLI** is what runs, not any command containing the words.
+ *    `grep -r 'relay attach --session codex-vps' src/` is a session reading
+ *    about another session, and the machine this was written on is full of them.
+ *  - the session name follows `--session` **directly**, so the usage line
+ *    (`--session <name>`) matches nothing and `codex-vps` never claims
+ *    `codex-vps-2`.
+ *  - the invocation is not itself inside a quoted argument — see
+ *    `commandAttaches`, which is the predicate you should actually call.
+ */
+function attachMarker(sessionName) {
+    const name = sessionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(
+    // an argv-position CLI token: `baychat`, `npx baychat`, `node dist/index.js`
+    `(?:^|[\\s;&|(])(?:[^\\s'"]*[\\\\/])?(?:baychat|index\\.js)\\s+relay\\s+attach\\b` +
+        `[^\\n]{0,400}?--session[=\\s]+(?:["'])?${name}(?:["']|\\s|$)`);
+}
+/**
+ * Did this recorded command actually attach that session?
+ *
+ * The quoting check is the last gate. A session that greps for
+ * `'baychat relay attach --session codex-vps'` runs a command that contains a
+ * perfectly good invocation — inside single quotes, as data. Resuming on that
+ * evidence would wake the session that read about the room instead of the one
+ * that joined it.
+ */
+function commandAttaches(command, sessionName) {
+    for (const text of [command, ...unwrapShellC(command)]) {
+        const match = attachMarker(sessionName).exec(text);
+        if (match && !isQuotedAt(text, match.index))
+            return true;
+    }
+    return false;
+}
+/**
+ * `bash -lc "…"` one level down — there the quoted argument IS the command.
+ *
+ * Without this, an agent that wraps its attach in a login shell (a common habit)
+ * would look exactly like one grepping for the string, and its session would
+ * stay undiscoverable. Inside the unwrapped text the quoting rule still applies,
+ * so `bash -lc "grep 'baychat relay attach …' ."` is still refused.
+ */
+function unwrapShellC(command) {
+    const m = /^\s*(?:\S*\/)?(?:ba|z|da|k)?sh\s+(?:-\S+\s+)*?-\S*c\S*\s+(['"])([\s\S]*)\1\s*$/.exec(command);
+    if (!m)
+        return [];
+    return [m[2].replace(/\\(["'\\$`])/g, "$1")];
+}
+/** Is offset `index` inside a single- or double-quoted run of shell text? */
+function isQuotedAt(text, index) {
+    let single = false;
+    let double = false;
+    for (let i = 0; i < index; i++) {
+        const ch = text[i];
+        if (ch === "\\") {
+            i += 1;
+            continue;
+        }
+        if (ch === "'" && !double)
+            single = !single;
+        else if (ch === '"' && !single)
+            double = !double;
+    }
+    return single || double;
+}
+// ---------------------------------------------------------------------------
+// (2) self-identification from the runtime's environment
+// ---------------------------------------------------------------------------
+/**
+ * Read this session's own id out of the environment its runtime gave it.
+ *
+ * Called by `relay attach`, in the session's own process tree, so the answer
+ * can only ever be *this* session. That is what makes it the preferred method:
+ * no search, no ranking, nothing to mistake for a sibling.
+ */
+async function resumeIdFromSessionEnv(runtime, opts = {}) {
+    const env = opts.env ?? process.env;
+    const varName = exports.SESSION_ID_ENV[runtime];
+    if (!varName) {
+        return { ok: false, reason: `${runtime} exports no session id to the processes it spawns` };
+    }
+    const raw = (env[varName] ?? "").trim();
+    if (!raw) {
+        return { ok: false, reason: `$${varName} is not set — this process was not spawned by a ${runtime} session` };
+    }
+    if (!isUuid(raw)) {
+        // A non-uuid here means the variable does not mean what we think it means.
+        // Recording it would produce a resume that fails, or worse, one that hits
+        // something else entirely.
+        return { ok: false, reason: `$${varName} is not a session uuid (${truncate(raw, 40)}) — refusing to record it` };
+    }
+    if (runtime === "claude") {
+        // The transcript is not required — the variable is authoritative — but
+        // finding it gives us the session's own cwd for the headless spawn.
+        const found = await claudeTranscriptById(raw, opts);
+        return {
+            ok: true,
+            resumeId: raw,
+            source: "session-env",
+            evidence: `recorded at attach from $${varName}`,
+            cwd: found?.cwd,
+        };
+    }
+    // Codex: corroborate before trusting. `CODEX_THREAD_ID` is undocumented, and
+    // a value naming a subagent thread would resume a helper, not the session
+    // that joined the room.
+    const roll = await codexRolloutById(raw, opts);
+    if (!roll) {
+        return {
+            ok: false,
+            reason: `$${varName} names ${truncate(raw, 40)} but no top-level Codex rollout under ${codexRoot(opts)} has that id — refusing to record an id we cannot corroborate`,
+        };
+    }
+    return {
+        ok: true,
+        resumeId: roll.resumeId,
+        source: "session-env",
+        evidence: `recorded at attach from $${varName}, corroborated by ${short(roll.file)}`,
+        cwd: roll.cwd,
+    };
+}
+// ---------------------------------------------------------------------------
+// (3) discovery from the runtime's on-disk state
+// ---------------------------------------------------------------------------
+/**
+ * Find the Claude Code session that attached under this BayChat session name.
+ *
+ * Transcripts live at `~/.claude/projects/<slug>/<session-uuid>.jsonl`, so the
+ * file name IS the id `--resume` wants. We do not rank by recency: we look for
+ * the transcript that records the attach command naming this session, which is
+ * proof of identity rather than a guess. Sub-agent transcripts
+ * (`<uuid>/subagents/agent-*.jsonl`) are skipped — they are not resumable and
+ * they mirror the parent's shell activity, so they would double every match.
+ */
+async function discoverClaudeResume(sessionName, opts = {}) {
+    const root = claudeRoot(opts);
+    const files = listClaudeTranscripts(root, opts);
+    if (files.length === 0) {
+        return { ok: false, reason: `no Claude Code transcripts under ${short(root)} to search` };
+    }
+    const hits = [];
+    for (const { file, id } of files) {
+        const scan = await scanTranscript(file, sessionName, opts, (line) => claudeEvidence(line, sessionName));
+        if (scan.evidence)
+            hits.push({ id, file, cwd: scan.cwd, command: scan.evidence });
+    }
+    return oneOrRefuse(hits.map((h) => ({ resumeId: h.id, file: h.file, cwd: h.cwd })), sessionName, "Claude Code", root);
+}
+/**
+ * Find the Codex conversation that attached under this BayChat session name.
+ *
+ * Codex writes `~/.codex/sessions/<y>/<m>/<d>/rollout-<ts>-<id>.jsonl`, whose
+ * first line is a `session_meta` carrying `session_id` (the conversation),
+ * `id` (this rollout), `cwd` and `source`.
+ *
+ * Two filters matter, and both were found by looking at real files:
+ *  - `source` distinguishes a real session (`"cli"`) from a **subagent** thread
+ *    (`{subagent:{…}}`). The subagent rollout mirrors the parent's shell calls,
+ *    so it carries the same attach command — resuming it would resume a helper.
+ *  - resuming a conversation appends a NEW rollout that keeps the original
+ *    `session_id`, so candidates are collapsed on `session_id`. Without that a
+ *    session resumed twice looks like three different sessions and discovery
+ *    would refuse itself into permanent pending.
+ */
+async function discoverCodexResume(sessionName, opts = {}) {
+    const root = codexRoot(opts);
+    const files = listCodexRollouts(root, opts);
+    if (files.length === 0) {
+        return { ok: false, reason: `no Codex rollouts under ${short(root)} to search` };
+    }
+    const byConversation = new Map();
+    for (const file of files) {
+        const meta = await readCodexMeta(file);
+        if (!meta || !meta.resumeId)
+            continue;
+        if (meta.isSubagent)
+            continue; // a helper thread, not the session that joined the room
+        const scan = await scanTranscript(file, sessionName, opts, (line) => codexEvidence(line, sessionName));
+        if (!scan.evidence)
+            continue;
+        if (!byConversation.has(meta.resumeId)) {
+            byConversation.set(meta.resumeId, { resumeId: meta.resumeId, file, cwd: meta.cwd });
+        }
+    }
+    return oneOrRefuse([...byConversation.values()], sessionName, "Codex", root);
+}
+/** Route to the runtime's discovery, or say the runtime has none. */
+async function discoverResume(target, opts = {}) {
+    if (target.runtime === "claude")
+        return discoverClaudeResume(target.name, opts);
+    if (target.runtime === "codex")
+        return discoverCodexResume(target.name, opts);
+    return { ok: false, reason: `${target.runtime} keeps no local session state to discover a resume id from` };
+}
+/**
+ * Exactly one candidate, or nothing.
+ *
+ * Two transcripts that both attached under one name means two terminals once
+ * claimed it and we cannot see which is live. Picking the newer one would be
+ * the recency guess this module exists to avoid, so it refuses and names both
+ * ids — a human reading `relay status` can then attach the right one.
+ */
+function oneOrRefuse(hits, sessionName, label, root) {
+    if (hits.length === 0) {
+        return {
+            ok: false,
+            reason: `no ${label} session under ${short(root)} records \`relay attach --session ${sessionName}\` — nothing on disk identifies which session this is`,
+        };
+    }
+    if (hits.length > 1) {
+        return {
+            ok: false,
+            reason: `${hits.length} ${label} sessions record \`relay attach --session ${sessionName}\` (${hits
+                .map((h) => h.resumeId)
+                .join(", ")}) — refusing to guess which one is live`,
+        };
+    }
+    const hit = hits[0];
+    return {
+        ok: true,
+        resumeId: hit.resumeId,
+        source: "transcript",
+        evidence: `discovered from ${short(hit.file)} (it ran \`relay attach --session ${sessionName}\`)`,
+        cwd: hit.cwd,
+    };
+}
+// ---------------------------------------------------------------------------
+// evidence extractors
+// ---------------------------------------------------------------------------
+/**
+ * A Claude transcript line is evidence only when it is a recorded **tool call**
+ * whose command attached this session. Matching raw text would fire on the
+ * usage string, on this file's own source, and on any conversation that merely
+ * mentions the session name.
+ */
+function claudeEvidence(line, sessionName) {
+    const parsed = safeParse(line);
+    const content = parsed?.message?.content;
+    if (!Array.isArray(content))
+        return undefined;
+    for (const item of content) {
+        if (item?.type !== "tool_use")
+            continue;
+        const cmd = item?.input?.command;
+        if (typeof cmd === "string" && commandAttaches(cmd, sessionName))
+            return cmd;
+    }
+    return undefined;
+}
+/**
+ * Codex records shell work as `custom_tool_call` (newer, `input` is a JS
+ * snippet calling `tools.exec_command({cmd:"…"})`) or `function_call` (older,
+ * `arguments` is JSON). Either way the *shell command* has to be dug out before
+ * the predicate can run: applied to the raw JS snippet, every command would
+ * look quoted and nothing would ever match.
+ */
+function codexEvidence(line, sessionName) {
+    const parsed = safeParse(line);
+    const payload = parsed?.payload;
+    if (!payload)
+        return undefined;
+    if (payload.type !== "custom_tool_call" && payload.type !== "function_call")
+        return undefined;
+    for (const raw of [payload.input, payload.arguments]) {
+        if (typeof raw !== "string")
+            continue;
+        for (const cmd of codexCommands(raw)) {
+            if (commandAttaches(cmd, sessionName))
+                return cmd;
+        }
+    }
+    return undefined;
+}
+/** Every shell command embedded in a Codex tool call payload. */
+function codexCommands(raw) {
+    const out = [];
+    // Newer: `tools.exec_command({cmd:"…", workdir:"…"})`.
+    for (const m of raw.matchAll(/\bcmd\s*:\s*("(?:[^"\\]|\\.)*")/g)) {
+        try {
+            const cmd = JSON.parse(m[1]);
+            if (typeof cmd === "string")
+                out.push(cmd);
+        }
+        catch {
+            // Not a JSON string literal after all — not a command we can read.
+        }
+    }
+    // Older: `{"command":["bash","-lc","…"]}`.
+    const args = safeParse(raw);
+    if (typeof args?.command === "string")
+        out.push(args.command);
+    if (Array.isArray(args?.command))
+        out.push(args.command.filter((p) => typeof p === "string").join(" "));
+    return out;
+}
+// ---------------------------------------------------------------------------
+// file plumbing
+// ---------------------------------------------------------------------------
+function claudeRoot(opts) {
+    return opts.claudeProjectsDir ?? path.join(os.homedir(), ".claude", "projects");
+}
+function codexRoot(opts) {
+    return opts.codexSessionsDir ?? path.join(os.homedir(), ".codex", "sessions");
+}
+/** `~/.claude/projects/<slug>/<uuid>.jsonl`, newest first, bounded. */
+function listClaudeTranscripts(root, opts) {
+    const cutoff = Date.now() - (opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS);
+    const out = [];
+    for (const project of readDirSafe(root)) {
+        if (!project.isDirectory())
+            continue;
+        const dir = path.join(root, project.name);
+        for (const entry of readDirSafe(dir)) {
+            // Only top-level transcripts: `<uuid>/subagents/agent-*.jsonl` are helper
+            // threads that mirror the parent's tool calls and cannot be resumed.
+            if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+                continue;
+            const id = entry.name.slice(0, -".jsonl".length);
+            if (!isUuid(id))
+                continue;
+            const file = path.join(dir, entry.name);
+            const mtimeMs = mtimeOf(file);
+            if (mtimeMs < cutoff)
+                continue;
+            out.push({ file, id, mtimeMs });
+        }
+    }
+    return out.sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, opts.maxFiles ?? DEFAULT_MAX_FILES);
+}
+/** `~/.codex/sessions/**\/rollout-*.jsonl`, newest first, bounded. */
+function listCodexRollouts(root, opts) {
+    const cutoff = Date.now() - (opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS);
+    const found = [];
+    const walk = (dir, depth) => {
+        if (depth > 6)
+            return;
+        for (const entry of readDirSafe(dir)) {
+            const p = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(p, depth + 1);
+                continue;
+            }
+            if (!entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl"))
+                continue;
+            const mtimeMs = mtimeOf(p);
+            if (mtimeMs < cutoff)
+                continue;
+            found.push({ file: p, mtimeMs });
+        }
+    };
+    walk(root, 0);
+    return found
+        .sort((a, b) => b.mtimeMs - a.mtimeMs)
+        .slice(0, opts.maxFiles ?? DEFAULT_MAX_FILES)
+        .map((f) => f.file);
+}
+/** Parse the `session_meta` first line of a rollout. */
+async function readCodexMeta(file) {
+    const head = await readHead(file, 256 * 1024);
+    const firstLine = head.split("\n", 1)[0];
+    const parsed = safeParse(firstLine);
+    if (!parsed || parsed.type !== "session_meta" || !parsed.payload)
+        return undefined;
+    const p = parsed.payload;
+    // `session_id` is the conversation; `id` is this rollout. They are equal for a
+    // first run and diverge once the conversation is resumed or forked, so the
+    // conversation id is the stable handle to hand `codex exec resume`.
+    const resumeId = str(p.session_id) ?? str(p.id);
+    const source = p.source;
+    const isSubagent = (typeof source === "object" && source !== null && "subagent" in source) || p.parent_thread_id != null;
+    return { resumeId, cwd: str(p.cwd), isSubagent };
+}
+/** Locate a Codex rollout by conversation id, ignoring subagent threads. */
+async function codexRolloutById(id, opts) {
+    for (const file of listCodexRollouts(codexRoot(opts), opts)) {
+        const meta = await readCodexMeta(file);
+        if (!meta || meta.isSubagent)
+            continue;
+        if (meta.resumeId === id)
+            return { resumeId: meta.resumeId, file, cwd: meta.cwd };
+    }
+    return undefined;
+}
+/** Locate a Claude transcript by session id and read the cwd it started in. */
+async function claudeTranscriptById(id, opts) {
+    for (const { file, id: candidate } of listClaudeTranscripts(claudeRoot(opts), opts)) {
+        if (candidate !== id)
+            continue;
+        const head = await readHead(file, 512 * 1024);
+        for (const line of head.split("\n")) {
+            const cwd = str(safeParse(line)?.cwd);
+            if (cwd)
+                return { file, cwd };
+        }
+        return { file };
+    }
+    return undefined;
+}
+/**
+ * Stream one transcript looking for evidence, and pick up the session's own cwd
+ * on the way past.
+ *
+ * The cheap raw-substring pre-filter matters: these files run to several
+ * megabytes and `JSON.parse` on every line of every transcript would make a
+ * detached wake noticeably slow. A line that does not contain the session name
+ * at all cannot be evidence.
+ */
+async function scanTranscript(file, sessionName, opts, extract) {
+    let evidence;
+    let cwd;
+    const limit = opts.maxBytesPerFile ?? DEFAULT_MAX_BYTES;
+    let handle;
+    try {
+        handle = await fs.promises.open(file, "r");
+        const buf = Buffer.alloc(1 << 20);
+        let rest = "";
+        let read = 0;
+        for (;;) {
+            const { bytesRead } = await handle.read(buf, 0, buf.length, null);
+            if (bytesRead <= 0)
+                break;
+            read += bytesRead;
+            const parts = (rest + buf.toString("utf8", 0, bytesRead)).split("\n");
+            rest = parts.pop() ?? "";
+            for (const line of parts) {
+                if (!cwd && line.includes('"cwd"'))
+                    cwd = str(safeParse(line)?.cwd);
+                if (!evidence && line.includes("relay") && line.includes(sessionName))
+                    evidence = extract(line);
+            }
+            if (evidence && cwd)
+                break;
+            if (read >= limit)
+                break;
+        }
+        if (!evidence && rest.includes("relay") && rest.includes(sessionName))
+            evidence = extract(rest);
+    }
+    catch {
+        // An unreadable transcript is not evidence. Refusing the whole search
+        // because one file is locked would turn a readable answer into pending.
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    return { evidence, cwd };
+}
+async function readHead(file, bytes) {
+    let handle;
+    try {
+        handle = await fs.promises.open(file, "r");
+        const buf = Buffer.alloc(bytes);
+        const { bytesRead } = await handle.read(buf, 0, bytes, 0);
+        return buf.toString("utf8", 0, bytesRead);
+    }
+    catch {
+        return "";
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function readDirSafe(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function mtimeOf(file) {
+    try {
+        return fs.statSync(file).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+function safeParse(line) {
+    if (!line || line[0] !== "{")
+        return undefined;
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+function str(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max)}…` : value;
+}
+/** Shorten a path for display: `$HOME` back to `~`. */
+function short(file) {
+    const home = os.homedir();
+    return file.startsWith(home) ? `~${file.slice(home.length)}` : file;
+}

package/dist/relay/updates.js

@@ -97,22 +97,36 @@ async function runUpdatesLoop(opts) {
     }
 }
 /**
- * Re-read each watched conversation from its watermark. Used on 409 recovery
- * and on the WebSocket's `{"t":"reset"}`, which is the same condition in frame
- * form — one recovery, so the two transports cannot drift apart. Messages we
- * already delivered come back here; the caller de-dupes them by id, so a replay
- * is cheap rather than duplicated into the room.
+ * Re-read what an expired cursor swallowed, for EVERY live session on this
+ * device. Used by 409 recovery and by the WebSocket's `{"t":"reset"}`, which is
+ * the same condition in frame form — one recovery, so the two transports cannot
+ * drift apart.
  *
- * A 404 for one conversation is skipped rather than fatal: a session may have
- * ended or left the room between the poll and the recovery, and one dead room
- * must not strand the catch-up for every other.
+ * **One read per (session, conversation), naming the session.** The endpoint
+ * answers as *a* session that participates, so a read with no `session=` is
+ * answered by whichever of this device's sessions happens to be tried first.
+ * That is correct for that session and silently nothing for its siblings: two
+ * sessions in one shared room, one recovered, one re-baselined at the moment of
+ * the 409 with the missed window unreachable. Naming the session is what makes
+ * recovery cover the device rather than one arbitrary member of it.
+ *
+ * Messages already delivered come back here; the caller de-dupes on (session,
+ * message id), so a replay is free and a sibling's copy of one message is never
+ * mistaken for a duplicate.
+ *
+ * A 404 for one pair is skipped rather than fatal — that session is simply not
+ * in that room, which is the expected answer for most pairs the plan contains,
+ * and a room that has gone away must not strand the catch-up for every other.
+ * Anything else throws: a partial recovery reported as a complete one is the
+ * silent gap this endpoint exists to prevent.
  */
 async function catchUpFromWatermarks(auth, watermarks, request) {
     const events = [];
-    for (const [conversationId, since] of watermarks) {
+    for (const { sessionName, conversationId, since } of watermarks.catchUpPlan()) {
+        const query = new URLSearchParams({ since, session: sessionName });
         let res;
         try {
-            res = await request(auth, "GET", `/api/device-api/conversations/${conversationId}/messages?since=${encodeURIComponent(since)}`);
+            res = await request(auth, "GET", `/api/device-api/conversations/${encodeURIComponent(conversationId)}/messages?${query.toString()}`);
         }
         catch (err) {
             if (err instanceof api_1.ApiError && err.status === 404)
@@ -123,8 +137,11 @@ async function catchUpFromWatermarks(auth, watermarks, request) {
             if (m.deletedAt)
                 continue;
             events.push({
+                // The server's answer, not the name we asked with: a server too old to
+                // honour `session=` answers as someone else, and tagging its messages
+                // with the session we wanted would wake that session with another's view.
                 conversationId,
-                sessionName: res.sessionName,
+                sessionName: res.sessionName ?? sessionName,
                 message: { ...m, conversationId },
             });
         }