replica-bridge 0.3.14 → 0.3.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replica-bridge",
-  "version": "0.3.14",
+  "version": "0.3.17",
   "description": "Lets the ChatReplica iPhone app use Codex on this computer through a relay, end-to-end encrypted.",
   "type": "module",
   "bin": {

package/src/bridge/board.js

@@ -23,7 +23,14 @@ const CATCH_UP_PAGES = 1000;
 /** More changed tasks than this in one event, and the phone reads the whole board instead. */
 export const CHANGED_ITEMS_MAX = 200;
 /** What this bridge can do beyond reading, for board/state (PROTOCOL.md "看板"). */
-export const BOARD_CAPS = ["post", "delta"]         ;
+export const BOARD_CAPS = ["post", "delta", "items", "tasks"]         ;
+/** Up to this many changed tasks in one event come with their contents (`task`); past it the phone reads them itself. */
+export const CARRIED_TASKS_MAX = 50;
+/** A task bigger than this is left for the phone to read. */
+const CARRIED_TASK_MAX_BYTES = 256 * 1024;
+
+/** What the backend says a changed task now is: its view, or gone (404). Missing when the read failed. */
+                                                  
 
 /** The backend's own cap on a request body (agens-backend src/http.mjs BODY_MAX). */
 export const POST_BODY_MAX_BYTES = 16 * 1024;
@@ -31,10 +38,11 @@ const REC = "[A-Za-z0-9_.:-]+";
 
 /**
  * GETs (#367). /session also writes TASK.md in the task's working folder, which is what 开工 asks for; /share and /me
- * only read. Not /assist, /mcp, /search, /changes (the bridge's own poll) or anything under /ui.
+ * only read. From 0.3.16 also one item, a task's source (`?offset=` pages its text), as the backend's own page opens it.
+ * Not /assist, /mcp, /search, /context, /changes (the bridge's own poll) or anything under /ui.
  */
 const READS = [/^\/v1\/status$/, /^\/v1\/today$/, /^\/v1\/recommendations$/, new RegExp(`^/v1/recommendations/${REC}$`),
-  new RegExp(`^/v1/recommendations/${REC}/(share|session)$`), /^\/v1\/me$/];
+  new RegExp(`^/v1/recommendations/${REC}/(share|session)$`), /^\/v1\/me$/, new RegExp(`^/v1/items/${REC}$`)];
 
 /** POSTs (#367): a task's follow-up actions, cancelling its preparation note, and muting a conversation. Nothing else. */
 const WRITES = [new RegExp(`^/v1/recommendations/${REC}/actions$`), new RegExp(`^/v1/recommendations/${REC}/prep/cancel$`), /^\/v1\/me\/muted$/];
@@ -87,8 +95,16 @@ export function boardPortFrom(env                    = process.env)         {
                                
                 
                        
+                                                                                                                
+                             
+                                                                                                                         
+                              
  
 
+/** Three missed heartbeats. */
+const DEFAULT_STREAM_IDLE_SECONDS = 45;
+const DEFAULT_STREAM_RETRY_SECONDS = 30;
+
                                             
 
 /** One subscriber and how far through the change log it has been told. */
@@ -102,10 +118,17 @@ export function boardPortFrom(env                    = process.env)         {
  
 
 /** Changes as a phone gets them: one per task, the latest, or a reset when there are too many. */
-function changedEvent(items               )             {
+/** The latest change of each task, in the order they last changed. */
+function latestOf(items               )                {
   const latest = new Map                     ();
   for (const item of items) { latest.delete(item.recId); latest.set(item.recId, item); }
-  return latest.size > CHANGED_ITEMS_MAX ? { t: "board/changed", reset: true } : { t: "board/changed", items: [...latest.values()] };
+  return [...latest.values()];
+}
+
+function changedEvent(items               , carried = new Map                 ())             {
+  const latest = latestOf(items);
+  if (latest.length > CHANGED_ITEMS_MAX) return { t: "board/changed", reset: true };
+  return { t: "board/changed", items: latest.map((item) => ({ ...item, ...carried.get(item.recId) })) };
 }
 
 function changeOf(value         )                     {
@@ -127,11 +150,19 @@ export class BoardReader {
           round = 0;
   /** The backend's push stream: open, unknown (try it), or not there (an older backend answers 404). */
           stream                         = null;
+  /** Changes go out one batch at a time and in order, each after its tasks were read. */
+          delivery                = Promise.resolve();
           streamSupported                 = null;
+  /** Not before this time (ms) after the backend refused a stream for a passing reason. */
+          streamRetryAt = 0;
+                   streamIdleMs        ;
+                   streamRetryMs        ;
 
   constructor(options               = {}) {
     this.port = options.port ?? boardPortFrom();
     this.pollMs = (options.pollSeconds ?? DEFAULT_POLL_SECONDS) * 1000;
+    this.streamIdleMs = (options.streamIdleSeconds ?? DEFAULT_STREAM_IDLE_SECONDS) * 1000;
+    this.streamRetryMs = (options.streamRetrySeconds ?? DEFAULT_STREAM_RETRY_SECONDS) * 1000;
   }
 
   /** How many phones are subscribed. */
@@ -197,9 +228,11 @@ export class BoardReader {
     this.stream?.abort();
     this.stream = null;
     this.streamSupported = null;
+    this.streamRetryAt = 0;
     this.end = null;
     this.up = null;
     this.polling = false;
+    this.delivery = Promise.resolve();
     this.round++;
   }
 
@@ -237,24 +270,70 @@ export class BoardReader {
         cursor = next;
       }
     } catch {
-      sub.admitting = false; // the next read of the log tries again
+      sub.admitting = false;
+      // Try again shortly. Polling would admit it on its next read, but while the backend pushes nothing polls.
+      const retry = setTimeout(() => { if (round === this.round && this.subs.has(sub)) void this.admit(sub); }, this.pollMs);
+      retry.unref();
       return;
     }
     if (round !== this.round || !this.subs.has(sub)) return;
+    // What changed comes with the tasks as they are now; reading them takes a moment, in which more may change, so
+    // read the log again up to where the shared reader got before this subscriber starts hearing from it.
+    let carried = new Map                 ();
+    if (!reset && missed.length) {
+      carried = await this.carry(missed);
+      try {
+        for (let page = 0; cursor !== null && cursor < this.end  && page < CATCH_UP_PAGES; page++) {
+          const { items, next } = await this.changes(cursor);
+          missed.push(...items);
+          if (next === cursor && items.length === 0) break;
+          cursor = next;
+        }
+      } catch { /* the late ones go without contents; the phone reads them */ }
+      if (round !== this.round || !this.subs.has(sub)) return;
+    }
     sub.admitting = false;
     sub.cursor = Math.max(cursor ?? this.end , this.end );
     sub.listener(this.state(true, sub.cursor));
     if (reset) sub.listener({ t: "board/changed", reset: true });
-    else if (missed.length) sub.listener(changedEvent(missed));
+    else if (missed.length) sub.listener(changedEvent(missed, carried));
+  }
+
+  /**
+   * Reads each changed task (its latest change only) from the backend, so the phone needs no read of its own. Only while
+   * a phone is subscribed, which is while its 任务 page is on screen, so marking them seen is what the phone's own read
+   * did before. Too many at once, and the phone reads them (or the whole board) itself.
+   */
+          async carry(items               )                                {
+    const carried = new Map                 ();
+    const latest = latestOf(items);
+    if (latest.length > CARRIED_TASKS_MAX) return carried;
+    await Promise.all(latest.map(async ({ recId }) => {
+      const answer = await this.answer(`/v1/recommendations/${encodeURIComponent(recId)}`);
+      if ("error" in answer) return;
+      if (answer.status === 404) { carried.set(recId, { gone: true }); return; }
+      if (answer.status !== 200 || Buffer.byteLength(answer.body, "utf8") > CARRIED_TASK_MAX_BYTES) return;
+      try { carried.set(recId, { task: JSON.parse(answer.body) }); } catch { /* the phone reads it */ }
+    }));
+    return carried;
+  }
+
+  /** Reads the changed tasks, then tells each subscriber; batches stay in order. */
+          send(items               , end        ) {
+    const round = this.round;
+    this.delivery = this.delivery.then(async () => {
+      const carried = await this.carry(items);
+      if (round === this.round) this.deliver(items, end, carried);
+    });
   }
 
   /** New changes up to `end`: each subscriber gets those past its own place. */
-          deliver(items               , end        ) {
+          deliver(items               , end        , carried = new Map                 ()) {
     for (const sub of this.subs) {
       if (sub.cursor === null) continue;
       const fresh = items.filter((item) => item.seq > sub.cursor );
       sub.cursor = Math.max(sub.cursor, end);
-      if (fresh.length) sub.listener(changedEvent(fresh));
+      if (fresh.length) sub.listener(changedEvent(fresh, carried));
     }
   }
 
@@ -294,9 +373,9 @@ export class BoardReader {
     if (up) this.end = end;
     this.setUp(up);
     if (!up) return;
-    if (items.length) this.deliver(items, end );
+    if (items.length) this.send(items, end );
     for (const sub of this.subs) if (sub.cursor === null) void this.admit(sub);
-    if (this.streamSupported !== false) void this.openStream(round);
+    if (this.streamSupported !== false && Date.now() >= this.streamRetryAt) void this.openStream(round);
   }
 
   /**
@@ -307,21 +386,36 @@ export class BoardReader {
     if (this.stream || this.end === null) return;
     const controller = new AbortController();
     this.stream = controller;
+    // A backend that takes the connection and then says nothing must not hold the bridge: while a stream is open
+    // nothing polls, so silence would also hide the backend going away. Its heartbeat keeps this from firing.
+    let idle = setTimeout(() => controller.abort(), READ_TIMEOUT_MS);
+    idle.unref();
+    const heard = () => {
+      clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), this.streamIdleMs);
+      idle.unref();
+    };
     let response          ;
     try {
       response = await this.fetch(`/v1/changes/stream?after=${this.end}`, undefined, controller.signal);
     } catch {
+      clearTimeout(idle);
       if (this.stream === controller) this.stream = null;
       return;
     }
-    if (round !== this.round || this.stream !== controller) { controller.abort(); return; }
-    if (!response.ok || !(response.headers.get("content-type") ?? "").startsWith("text/event-stream") || !response.body) {
-      this.streamSupported = false;
+    if (round !== this.round || this.stream !== controller) { clearTimeout(idle); controller.abort(); return; }
+    const eventStream = (response.headers.get("content-type") ?? "").startsWith("text/event-stream");
+    if (!response.ok || !eventStream || !response.body) {
+      clearTimeout(idle);
+      // Only an older backend lacks it (404, or a 200 that is not an event stream); busy (429) or starting (5xx) passes.
+      if (response.status === 404 || (response.ok && !eventStream)) this.streamSupported = false;
+      else this.streamRetryAt = Date.now() + this.streamRetryMs;
       this.stream = null;
       controller.abort();
       return;
     }
     this.streamSupported = true;
+    heard();
     let buffer = "", pending                = [], flush                        = null;
     const send = () => {
       flush = null;
@@ -330,11 +424,12 @@ export class BoardReader {
       pending = [];
       const end = Math.max(this.end ?? 0, ...batch.map((item) => item.seq));
       this.end = end;
-      this.deliver(batch, end);
+      this.send(batch, end);
     };
     try {
       const decoder = new TextDecoder();
       for await (const chunk of response.body                                        ) {
+        heard();
         buffer += decoder.decode(chunk, { stream: true });
         let split        ;
         while ((split = buffer.search(/\r?\n\r?\n/)) >= 0) {
@@ -351,6 +446,7 @@ export class BoardReader {
         }
       }
     } catch { /* aborted, or the backend went away */ }
+    clearTimeout(idle);
     if (flush) { clearTimeout(flush); send(); }
     if (this.stream === controller) this.stream = null;
   }

package/src/protocol.js

@@ -249,13 +249,15 @@ export class FrameCipher {
                                                                                                                               
 /** One task that changed, from agens-backend's change log (0.3.14). */
                                                                        
+/** As a phone gets it from 0.3.17 on: the task as the backend now has it (`GET /v1/recommendations/:id`), or gone. */
+                                                                           
 /**
  * What a subscriber hears. From 0.3.14 a board/state that says up also gives `seq` (where in the change log the phone
  * starts), `caps` and the bridge's version, and board/changed names the tasks, or says `reset` when there are too many.
  */
                         
                                                                                      
-                                                                
+                                                                   
 
                                                                  
 /** One segment of a long line: `data` is base64 of bytes [segment * chunk size, …) of the payload, `size` its length. */