baychat 0.8.2 → 0.9.0

package/dist/relay/types.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Shared types for the relay daemon.
+ *
+ * The relay's job is narrow: hold `/updates`, decide which local session an
+ * event belongs to, and wake that session — once, never twice concurrently.
+ * It deliberately does NOT decide whether the session should reply. That
+ * judgement is the server's (`shouldRespond`) and the woken session's; the
+ * relay only carries the message across the process boundary.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/relay/updates.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpdatesLoop = runUpdatesLoop;
+const api_1 = require("../api");
+/** Server clamps `wait` into [1s, 30s]; 25s stays under the usual 60s proxy idle timeout. */
+const WAIT_SECONDS = 25;
+/** Backoff bounds for transient failures (5xx, 429, network). */
+const BACKOFF_MIN_MS = 1_000;
+const BACKOFF_MAX_MS = 30_000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Transient failures are ridden out, not surfaced. A 502 while the api
+ * container restarts, a network throw, a 429 — all mean "later", not "stop".
+ * Real 4xx (401 expired device credential, 403) are terminal: they need a
+ * human, and retrying them forever would hide that.
+ *
+ * 409 is deliberately NOT here — it has its own recovery path and must never
+ * be treated as a generic hiccup, because backing off on it would leave the
+ * cursor permanently unusable and the relay silently deaf.
+ */
+function isTransient(err) {
+    if (err instanceof api_1.ApiError)
+        return err.status >= 500 || err.status === 429;
+    return err instanceof TypeError; // fetch rejects with TypeError on network failure
+}
+/**
+ * Holds `GET /api/device-api/updates` and calls `onEvents` for every batch,
+ * until `signal` aborts.
+ *
+ * The credential is the machine's DEVICE credential, not an agent token. A
+ * laptop has one device login and its sessions mint their own agents when they
+ * join, so no single agent token can see them all — the server fans out across
+ * the device's live sessions and tags each event with the session it belongs to.
+ *
+ * Cursor discipline: the cursor is an opaque blob (really one cursor per session
+ * agent, encoded server-side) and advances only after a batch has been handed to
+ * `onEvents`. The caller queues synchronously, so a crash between poll and queue
+ * costs a re-read — harmless, ids de-dupe — rather than a lost message.
+ *
+ * On 409 `cursor_expired` recovery is ours: the server holds no record of what
+ * this client consumed. We re-read each watched conversation from our own
+ * watermark, then poll again with no cursor.
+ */
+async function runUpdatesLoop(opts) {
+    const { auth, watermarks, onEvents, onSessions, onPoll, onError, signal, request = api_1.apiRequest } = opts;
+    let cursor;
+    let backoff = BACKOFF_MIN_MS;
+    while (!signal.aborted) {
+        try {
+            const q = new URLSearchParams({ wait: String(WAIT_SECONDS) });
+            if (cursor)
+                q.set("cursor", cursor);
+            const res = await request(auth, "GET", `/api/device-api/updates?${q.toString()}`);
+            onSessions?.(res.sessions ?? []);
+            if (res.events.length > 0) {
+                onEvents(res.events.map((e) => ({
+                    conversationId: e.conversationId,
+                    sessionName: e.sessionName,
+                    message: { ...e.message, conversationId: e.conversationId },
+                })));
+            }
+            cursor = res.cursor;
+            onPoll?.(res.cursor);
+            backoff = BACKOFF_MIN_MS; // a clean poll resets the ladder
+        }
+        catch (err) {
+            if (signal.aborted)
+                return;
+            if (err instanceof api_1.ApiError && err.status === 409) {
+                onError?.(err, true);
+                try {
+                    const recovered = await catchUp(auth, watermarks, request);
+                    if (recovered.length > 0)
+                        onEvents(recovered);
+                }
+                catch (catchUpErr) {
+                    // Catch-up itself failed. Do NOT clear the cursor and carry on as if
+                    // recovered — that is the silent-gap case. Back off and let the next
+                    // 409 retry the whole recovery.
+                    onError?.(catchUpErr, true);
+                    await sleep(backoff);
+                    backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+                    continue;
+                }
+                cursor = undefined;
+                continue;
+            }
+            if (!isTransient(err)) {
+                onError?.(err, false);
+                throw err; // terminal — an expired device credential needs `npx baychat login`
+            }
+            onError?.(err, true);
+            await sleep(backoff);
+            backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+        }
+    }
+}
+/**
+ * Re-read each watched conversation from its watermark. Used only on 409
+ * recovery. Messages we already delivered come back here; the caller's
+ * per-session queue de-dupes them by id, so a replay is cheap rather than
+ * duplicated into the room.
+ *
+ * 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.
+ */
+async function catchUp(auth, watermarks, request) {
+    const events = [];
+    for (const [conversationId, since] of watermarks) {
+        let res;
+        try {
+            res = await request(auth, "GET", `/api/device-api/conversations/${conversationId}/messages?since=${encodeURIComponent(since)}`);
+        }
+        catch (err) {
+            if (err instanceof api_1.ApiError && err.status === 404)
+                continue;
+            throw err;
+        }
+        for (const m of res.messages) {
+            if (m.deletedAt)
+                continue;
+            events.push({
+                conversationId,
+                sessionName: res.sessionName,
+                message: { ...m, conversationId },
+            });
+        }
+    }
+    return events;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "baychat",
-  "version": "0.8.2",
-  "description": "BayChat connector CLI \u2014 pair an agent session (Claude Code, Codex) with BayChat and chat in groups",
+  "version": "0.9.0",
+  "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex) with BayChat and chat in groups",
   "bin": {
     "baychat": "dist/index.js"
   },