replica-bridge 0.3.12 → 0.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replica-bridge",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "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

@@ -1,7 +1,9 @@
 // The optional 任务 board (PROTOCOL.md "看板"): reads AgensWork's agens-backend, which only listens on this computer, for
 // a phone that asked. The bridge does not start the backend or care how it started: it knows a port, and a computer
-// where nothing answers there simply has no board. Reads are a short allowlist, and the only background traffic is one
-// poll of /v1/changes while a phone is subscribed, because reading the lists counts as the user having seen them.
+// where nothing answers there simply has no board. Reads and writes are short allowlists, and the only background traffic
+// is one poll of /v1/changes while a phone is subscribed, because reading the lists counts as the user having seen them.
+// The bridge stays thin: it checks the shape of a write and leaves what it means to the backend, whose status and body
+// (REC_NOT_FOUND, REC_STATE_CONFLICT, …) go back to the phone unchanged.
                                                               
 
 /** agens-backend's default port, which its own AGENS_BACKEND_PORT changes. */
@@ -16,18 +18,59 @@ const CHANGES_PAGE = 100;
 /** Stops a catch-up on a change log that never ends; the backend keeps 30 days of it. */
 const CATCH_UP_PAGES = 1000;
 
-/** Read-only, and none of them does work on the backend. Not /session, /share, /actions, /assist, /mcp or /search. */
-const READS = [/^\/v1\/status$/, /^\/v1\/today$/, /^\/v1\/recommendations$/, /^\/v1\/recommendations\/[A-Za-z0-9_.:-]+$/];
+/** The backend's own cap on a request body (agens-backend src/http.mjs BODY_MAX). */
+export const POST_BODY_MAX_BYTES = 16 * 1024;
+const REC = "[A-Za-z0-9_.:-]+";
 
-/** The path and query to read, or null when it is not on the allowlist. */
-export function allowedBoardPath(path         )                {
+/**
+ * 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.
+ */
+const READS = [/^\/v1\/status$/, /^\/v1\/today$/, /^\/v1\/recommendations$/, new RegExp(`^/v1/recommendations/${REC}$`),
+  new RegExp(`^/v1/recommendations/${REC}/(share|session)$`), /^\/v1\/me$/];
+
+/** 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$/];
+/** agens-backend src/recs.mjs ACTIONS. */
+export const BOARD_ACTIONS = ["accept", "snooze", "delegate", "dismiss", "done", "reopen"]         ;
+
+function localTarget(path         )             {
   if (typeof path !== "string" || !path.startsWith("/") || path.startsWith("//") || path.includes("\\")) return null;
   let target     ;
   try { target = new URL(path, "http://board.invalid"); } catch { return null; }
-  if (target.origin !== "http://board.invalid" || !READS.some((read) => read.test(target.pathname))) return null;
+  return target.origin === "http://board.invalid" ? target : null;
+}
+
+/** The path and query to read, or null when it is not on the allowlist. */
+export function allowedBoardPath(path         )                {
+  const target = localTarget(path);
+  if (!target || !READS.some((read) => read.test(target.pathname))) return null;
   return target.pathname + target.search;
 }
 
+/**
+ * The path and body to POST, or why not. The path is one of WRITES with no query; the body is JSON text of an object
+ * within the backend's size cap (absent or empty means `{}`, for prep/cancel), and on /actions names a known action.
+ */
+export function allowedBoardPost(path         , body         )                                                                                       {
+  const target = localTarget(path);
+  if (!target || target.search || !WRITES.some((write) => write.test(target.pathname))) return { error: "not_allowed" };
+  if (body === undefined || body === "") body = "{}";
+  if (typeof body !== "string") return { error: "bad_body" };
+  if (Buffer.byteLength(body, "utf8") > POST_BODY_MAX_BYTES) return { error: "too_large" };
+  let value         ;
+  try { value = JSON.parse(body); } catch { return { error: "bad_body" }; }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { error: "bad_body" };
+  if (target.pathname.endsWith("/actions")) {
+    const action = (value                        ).action;
+    if (typeof action !== "string" || !(BOARD_ACTIONS                     ).includes(action)) return { error: "not_allowed" };
+  }
+  const sent = JSON.stringify(value);
+  // Rewriting can lengthen it (1e5 becomes 100000), and the backend counts what it receives.
+  if (Buffer.byteLength(sent, "utf8") > POST_BODY_MAX_BYTES) return { error: "too_large" };
+  return { path: target.pathname, body: sent };
+}
+
 /** The port from AGENS_BACKEND_PORT, the backend's own setting, when it names a real one. */
 export function boardPortFrom(env                    = process.env)         {
   const port = Number(env.AGENS_BACKEND_PORT);
@@ -57,15 +100,28 @@ export class BoardReader {
   }
 
   /** The fetch adds the Host header the backend insists on (127.0.0.1:<port>) and no Origin, as a local caller. */
-          fetch(pathAndQuery        )                    {
-    return fetch(`http://127.0.0.1:${this.port}${pathAndQuery}`, { redirect: "error", signal: AbortSignal.timeout(READ_TIMEOUT_MS) });
+          fetch(pathAndQuery        , post         )                    {
+    return fetch(`http://127.0.0.1:${this.port}${pathAndQuery}`, {
+      redirect: "error", signal: AbortSignal.timeout(READ_TIMEOUT_MS),
+      ...(post === undefined ? {} : { method: "POST", headers: { "content-type": "application/json" }, body: post }),
+    });
   }
 
-  async read(path         )                       {
+  read(path         )                       {
     const allowed = allowedBoardPath(path);
-    if (!allowed) return { error: "not_allowed" };
+    return allowed ? this.answer(allowed) : Promise.resolve({ error: "not_allowed" });
+  }
+
+  /** Sent once and never retried: a write that timed out may still have happened, so the phone reads the task again. */
+  post(path         , body         )                       {
+    const allowed = allowedBoardPost(path, body);
+    return "error" in allowed ? Promise.resolve(allowed) : this.answer(allowed.path, allowed.body);
+  }
+
+  /** The backend's status and body as they are, errors included. */
+          async answer(pathAndQuery        , post         )                       {
     try {
-      const response = await this.fetch(allowed);
+      const response = await this.fetch(pathAndQuery, post);
       const body = await response.text();
       if (Buffer.byteLength(body, "utf8") > BODY_MAX_BYTES) return { error: "too_large" };
       return { status: response.status, body };

package/src/bridge/service.js

@@ -269,6 +269,8 @@ export class BridgeService {
     } else if (message.t === "board/get") {
       // Not awaited: a slow backend should not hold up the frames behind this one.
       void this.board.read(message.path).then((answer) => this.sendInner(conn, { t: "board/res", id: message.id, ...answer }));
+    } else if (message.t === "board/post") {
+      void this.board.post(message.path, message.body).then((answer) => this.sendInner(conn, { t: "board/res", id: message.id, ...answer }));
     } else if (message.t === "board/sub") {
       conn.boardUnsubscribe ??= this.board.subscribe((event) => this.sendInner(conn, event));
     } else if (message.t === "board/unsub") {

package/src/protocol.js

@@ -239,13 +239,14 @@ export class FrameCipher {
                              
                                    
                                                 
+                                                                
                                                   
                       
                         
                
 
-/** A read of the optional board: the backend's status and body, or why there is none (PROTOCOL.md "看板"). */
-                                                                                                                 
+/** A read or write of the optional board: the backend's status and body, or why there is none (PROTOCOL.md "看板"). */
+