baychat 0.11.2 → 0.12.0

package/dist/relay/daemon.js

@@ -42,14 +42,23 @@ const queue_1 = require("./queue");
 const registry_1 = require("./registry");
 const socket_1 = require("./socket");
 const transport_1 = require("./transport");
+const watermarks_1 = require("./watermarks");
+/**
+ * How long a failed resume-id discovery is believed before it is retried.
+ *
+ * A session whose runtime left no identifying trace stays undiscoverable, so
+ * re-scanning every transcript on the box per message would make an
+ * unanswerable delivery expensive as well as pending.
+ */
+const DISCOVERY_INTERVAL_MS = 10 * 60_000;
 class RelayDaemon {
     registry = new registry_1.SessionRegistry();
     queue;
     abort = new AbortController();
     /** Live attach sockets by session name. */
     attached = new Map();
-    /** Per-conversation delivery watermark — the 409 catch-up baseline. */
-    watermarks = new Map();
+    /** Per (session, conversation) delivery positions — the 409 catch-up baseline. */
+    watermarks = new watermarks_1.Watermarks();
     pending = [];
     server;
     startedAt = new Date().toISOString();
@@ -62,9 +71,15 @@ class RelayDaemon {
     transportDetail = "starting";
     /** Live session names from the last poll, for pruning and for `relay status`. */
     liveSessions = [];
+    /** Why discovery last refused, per session, and when — throttles the rescan. */
+    discoveryReasons = new Map();
+    discovery;
+    spawnHeadless;
     log;
     constructor(opts = {}) {
         this.log = opts.log ?? ((line) => console.log(`[relay] ${line}`));
+        this.discovery = opts.discovery ?? {};
+        this.spawnHeadless = opts.spawnHeadless ?? adapters_1.runHeadless;
         this.queue = new queue_1.SessionQueue((session, batch) => this.deliver(session, batch), (session, err) => {
             this.lastError = `delivery failed for ${session}: ${errText(err)}`;
             this.log(this.lastError);
@@ -119,6 +134,9 @@ class RelayDaemon {
             },
             onSessions: (names) => {
                 this.liveSessions = names;
+                // A recovery must cover every live session, including one this relay has
+                // never had to route an event to — skipping it re-baselines it at "now".
+                this.watermarks.noteLiveSessions(names);
                 const dropped = this.registry.pruneToLive(names);
                 for (const name of dropped)
                     this.log(`session ended server-side, dropped: ${name}`);
@@ -140,7 +158,7 @@ class RelayDaemon {
         });
     }
     /**
-     * Route one event and record the conversation watermark.
+     * Route one event and record this session's position in that conversation.
      *
      * Routing is the SERVER's answer (`sessionName`), not a local guess: the
      * device poll already knows which session agent each event was queued for.
@@ -150,9 +168,10 @@ class RelayDaemon {
      */
     onEvent(event) {
         const { conversationId, sessionName, message } = event;
-        const prior = this.watermarks.get(conversationId);
-        if (!prior || message.createdAt > prior)
-            this.watermarks.set(conversationId, message.createdAt);
+        // Per SESSION, not per conversation: a sibling in the same room that was
+        // behind must not have its recovery window truncated by a session that was
+        // ahead. An event with no session still registers the room — see Watermarks.
+        this.watermarks.record(sessionName, conversationId, message.createdAt);
         if (!sessionName) {
             this.log(`event ${message.id} carries no session (renamed or ended mid-poll) — ignoring`);
             return;
@@ -183,15 +202,25 @@ class RelayDaemon {
             return;
         }
         const adapter = (0, adapters_1.adapterFor)(target.runtime);
-        const check = adapter.canResume(target);
+        // A target with no resume id is the unbounded failure this whole path
+        // exists to close: without one, `canResume` says no and the message waits
+        // for a human. Ask the runtime's own on-disk state who this session is
+        // before accepting that answer.
+        const resolved = await this.resolveResume(target);
+        const check = adapter.canResume(resolved);
         if (!check.ok) {
             // The honest outcome: it reached this box, and nothing answered it.
-            this.record({ kind: "pending", session, reason: check.reason ?? "cannot resume" }, session, batch);
+            const why = this.discoveryReasons.get(session)?.reason;
+            const reason = why ? `${check.reason ?? "cannot resume"}; discovery: ${why}` : (check.reason ?? "cannot resume");
+            this.record({ kind: "pending", session, reason }, session, batch);
             return;
         }
         const prompt = (0, adapters_1.buildWakePrompt)(session, batch[0].conversationId, batch);
-        const { file, args } = adapter.headlessCommand(target, prompt);
-        const { exitCode, stderr } = await (0, adapters_1.runHeadless)(file, args, { cwd: target.cwd });
+        const { file, args } = adapter.headlessCommand(resolved, prompt);
+        // The session's own directory when we know it: `cwd` is only where the
+        // attach process ran, and `codex exec` refuses to start outside a trusted
+        // directory at all.
+        const { exitCode, stderr } = await this.spawnHeadless(file, args, { cwd: resolved.resumeCwd ?? resolved.cwd });
         if (exitCode !== 0) {
             // A non-zero headless turn did not necessarily reply. Recording it as
             // delivered would claim an answer we cannot evidence.
@@ -200,6 +229,43 @@ class RelayDaemon {
         }
         this.record({ kind: "woken", via: "headless", session, exitCode }, session, batch);
     }
+    /**
+     * Fill in a missing resume id from the runtime's on-disk state, at most once
+     * every `DISCOVERY_INTERVAL_MS` per session.
+     *
+     * Throttled because a refusal is the common steady state — a session whose
+     * runtime left no trace will never become discoverable — and re-reading every
+     * transcript on the box for each arriving message would make an unanswerable
+     * delivery expensive as well as pending.
+     *
+     * A discovered id is persisted with its provenance, so the search happens
+     * once per session rather than once per wake, and `relay status` can show a
+     * human where the id came from.
+     */
+    async resolveResume(target) {
+        if (target.resumeId)
+            return target;
+        const last = this.discoveryReasons.get(target.name);
+        if (last && Date.now() - last.at < DISCOVERY_INTERVAL_MS)
+            return target;
+        const result = await (0, adapters_1.adapterFor)(target.runtime).discoverResume(target, this.discovery);
+        if (!result.ok) {
+            this.discoveryReasons.set(target.name, { at: Date.now(), reason: result.reason });
+            this.log(`no resume id for ${target.name}: ${result.reason}`);
+            return target;
+        }
+        this.discoveryReasons.delete(target.name);
+        const updated = this.registry.upsert({
+            name: target.name,
+            runtime: target.runtime,
+            resumeId: result.resumeId,
+            resumeSource: result.source,
+            resumeEvidence: result.evidence,
+            resumeCwd: result.cwd,
+        });
+        this.log(`resume id for ${target.name}: ${result.resumeId} (${result.evidence})`);
+        return updated;
+    }
     record(outcome, session, batch) {
         if (outcome.kind === "woken") {
             this.delivered += batch.length;
@@ -233,8 +299,15 @@ class RelayDaemon {
                     name: frame.session,
                     runtime: frame.runtime,
                     resumeId: frame.resumeId,
+                    resumeSource: frame.resumeSource,
+                    resumeEvidence: frame.resumeEvidence,
+                    resumeCwd: frame.resumeCwd,
                     cwd: frame.cwd,
                 });
+                // A session that names itself supersedes anything discovery guessed
+                // for it, so drop the throttle and let the next wake use the new id.
+                if (frame.resumeId)
+                    this.discoveryReasons.delete(frame.session);
                 this.attached.set(frame.session, sock);
                 this.registry.setAttached(frame.session, true);
                 (0, socket_1.writeFrame)(sock, { type: "attached", session: frame.session });