baychat 0.34.1 → 0.34.2

package/dist/relay/acp/approval.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.askPhone = askPhone;
+exports.askPhoneChoice = askPhoneChoice;
 const api_1 = require("../../api");
 const approve_hook_1 = require("../../approve-hook");
+const waiting_cards_1 = require("../../waiting-cards");
 const HOLD_SECONDS = 25; // under the usual 60s proxy idle timeout — same as approve-hook
 const MAX_CONSECUTIVE_FAILURES = 3;
 const RETRY_DELAY_MS = 2_000;
@@ -13,53 +15,120 @@ const ALLOW_INDEX = 0; // the ONLY index that means yes
  * NEVER THROWS, and every path that is not an explicit "Allow this once" is a refusal: an
  * unreachable server, a status we do not know, a withdrawn card, the deadline. The card itself
  * never expires server-side; our deadline exists so a turn cannot hold a process forever, and
- * reaching it REFUSES. Silence is never a yes.
+ * reaching it REFUSES — and now also takes the card back, so a late tap on it answers nothing.
+ * Silence is never a yes.
  */
 async function askPhone(params, deps = {}) {
+    const answer = await askPhoneChoice({ ...params, options: approve_hook_1.APPROVE_OPTIONS }, deps);
+    return { allowed: answer.index === ALLOW_INDEX, reason: answer.reason };
+}
+/**
+ * A decision card with the caller's own buttons. Resolves the tapped index, or `index: null` with
+ * the reason nobody's answer counts — the deadline, an abort, a withdrawn card, an unreachable or
+ * confused server. What an index MEANS is the caller's; `null` must always be read as a refusal.
+ *
+ * NEVER THROWS. When it gives up on a card it created (the deadline, or `signal`), it withdraws
+ * it (`POST /approvals/:id/withdraw`, best effort), so the phone stops offering a question whose
+ * answer would reach nobody.
+ */
+async function askPhoneChoice(params, deps = {}) {
     const request = deps.request ?? api_1.apiRequest;
     const now = deps.now ?? Date.now;
     const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const markWaiting = deps.markWaiting ?? waiting_cards_1.markWaitingCard;
     const waitSeconds = params.waitSeconds ?? approve_hook_1.DEFAULT_WAIT_SECONDS;
     const deadline = now() + waitSeconds * 1000;
     const hold = () => Math.max(1, Math.min(HOLD_SECONDS, Math.ceil((deadline - now()) / 1000)));
-    const no = (reason) => ({ allowed: false, reason });
+    const no = (reason) => ({ index: null, reason });
+    const label = (index, answer) => answer ?? (typeof index === "number" ? params.options[index] : undefined) ?? "no answer";
+    const withdraw = async (requestId) => {
+        try {
+            await request(params.auth, "POST", `/api/device-api/approvals/${encodeURIComponent(requestId)}/withdraw`, {});
+        }
+        catch {
+            // A card left pending is harmless — its answer reaches nobody. Nothing to do but move on.
+        }
+    };
+    /** The next reply, or "aborted" the moment `signal` fires — a long-poll is not waited out. */
+    const orAbort = (pending) => {
+        const signal = params.signal;
+        if (!signal)
+            return pending;
+        if (signal.aborted)
+            return Promise.resolve("aborted");
+        return new Promise((resolve, reject) => {
+            const onAbort = () => resolve("aborted");
+            signal.addEventListener("abort", onAbort, { once: true });
+            pending.then((value) => {
+                signal.removeEventListener("abort", onAbort);
+                resolve(value);
+            }, (err) => {
+                signal.removeEventListener("abort", onAbort);
+                reject(err);
+            });
+        });
+    };
+    if (params.signal?.aborted)
+        return no("nobody needed the answer any more");
     try {
-        let reply = await request(params.auth, "POST", "/api/device-api/approvals", {
+        // With a signal the first hold is ONE second, so a stop that lands while the card is being
+        // created is seen at once — never after a 25-second hold.
+        const creating = request(params.auth, "POST", "/api/device-api/approvals", {
             session: params.session,
-            conversationId: params.conversationId,
+            ...(params.direct ? { direct: true } : { conversationId: params.conversationId }),
             question: params.question,
-            options: [...approve_hook_1.APPROVE_OPTIONS],
-            wait: hold(),
+            options: [...params.options],
+            ...(params.guardedOptions?.length ? { guardedOptions: params.guardedOptions } : {}),
+            wait: params.signal ? 1 : hold(),
         });
+        let reply = await orAbort(creating);
+        if (reply === "aborted") {
+            // The card is (being) created and nobody wants its answer: take it back the moment its id is known.
+            void creating.then((created) => (typeof created.requestId === "string" && created.requestId ? withdraw(created.requestId) : undefined)).catch(() => undefined);
+            return no("nobody needed the answer any more — the card was withdrawn");
+        }
         const requestId = typeof reply.requestId === "string" ? reply.requestId : "";
         if (!requestId)
             return no("BayChat did not return an approval id");
-        let failures = 0;
-        for (;;) {
-            if (reply.status === "answered") {
-                return reply.answerIndex === ALLOW_INDEX
-                    ? { allowed: true, reason: "approved in BayChat" }
-                    : no(`answered "${reply.answer ?? approve_hook_1.APPROVE_OPTIONS[1]}" in BayChat`);
-            }
-            if (reply.status === "cancelled")
-                return no("the decision was withdrawn in BayChat");
-            if (reply.status !== "waiting")
-                return no(`BayChat answered with a status this relay does not understand ("${String(reply.status)}")`);
-            if (deadline - now() <= 0)
-                return no(`nobody answered within ${waitSeconds}s — the card is still in BayChat, and this request was refused`);
-            try {
-                reply = await request(params.auth, "GET", `/api/device-api/approvals/${encodeURIComponent(requestId)}?wait=${hold()}`);
-                failures = 0;
-            }
-            catch (err) {
-                if (err instanceof api_1.ApiError && err.status < 500 && err.status !== 429)
-                    return no(`BayChat refused the wait — ${err.message}`);
-                failures += 1;
-                if (failures >= MAX_CONSECUTIVE_FAILURES)
-                    return no(`BayChat became unreachable while waiting — ${err instanceof Error ? err.message : String(err)}`);
-                await sleep(RETRY_DELAY_MS);
+        const unmark = markWaiting(requestId);
+        try {
+            let failures = 0;
+            for (;;) {
+                if (params.signal?.aborted)
+                    reply = "aborted";
+                if (reply === "aborted") {
+                    await withdraw(requestId);
+                    return no("nobody needed the answer any more — the card was withdrawn");
+                }
+                if (reply.status === "answered") {
+                    const index = typeof reply.answerIndex === "number" ? reply.answerIndex : null;
+                    return { index, reason: `answered "${label(index, reply.answer)}" in BayChat` };
+                }
+                if (reply.status === "cancelled")
+                    return no("the decision was withdrawn in BayChat");
+                if (reply.status !== "waiting")
+                    return no(`BayChat answered with a status this relay does not understand ("${String(reply.status)}")`);
+                if (deadline - now() <= 0) {
+                    await withdraw(requestId);
+                    return no(`nobody answered within ${waitSeconds}s — the card was withdrawn, and this request was refused`);
+                }
+                try {
+                    reply = await orAbort(request(params.auth, "GET", `/api/device-api/approvals/${encodeURIComponent(requestId)}?wait=${hold()}`));
+                    failures = 0;
+                }
+                catch (err) {
+                    if (err instanceof api_1.ApiError && err.status < 500 && err.status !== 429)
+                        return no(`BayChat refused the wait — ${err.message}`);
+                    failures += 1;
+                    if (failures >= MAX_CONSECUTIVE_FAILURES)
+                        return no(`BayChat became unreachable while waiting — ${err instanceof Error ? err.message : String(err)}`);
+                    await sleep(RETRY_DELAY_MS);
+                }
             }
         }
+        finally {
+            unmark();
+        }
     }
     catch (err) {
         return no(`BayChat could not be asked — ${err instanceof Error ? err.message : String(err)}`);

package/dist/relay/acp/daemon-glue.js

@@ -193,7 +193,8 @@ function registerAcpFrame(frame, deps) {
  * ever. `upsert` merges, so an attach over it would keep `acp` and give the name two drivers.
  */
 function acpAttachRefusal(registry, session) {
-    return registry.get(session)?.acp
+    const target = registry.get(session);
+    return target?.acp || target?.codex
         ? `"${session}" is run by the relay on this computer; attach a terminal under a different session name.`
         : undefined;
 }

package/dist/relay/adapters.js

@@ -196,7 +196,7 @@ const codexAdapter = {
      * interface is marked `[experimental]` by OpenAI and its shape is not frozen,
      * so there has to be a way back that does not require a new release.
      */
-    async runTurn({ binaryPath, target, prompt }) {
+    async runTurn({ binaryPath, target, prompt, policy, onApproval, onNotification, log }) {
         if (process.env.BAYCHAT_CODEX_TRANSPORT === "exec") {
             return {
                 kind: "failed",
@@ -209,6 +209,10 @@ const codexAdapter = {
             threadId: target.resumeId,
             prompt,
             cwd: target.resumeCwd ?? target.cwd,
+            ...(policy ? { policy } : {}),
+            ...(onApproval ? { onApproval } : {}),
+            ...(onNotification ? { onNotification } : {}),
+            ...(log ? { log } : {}),
         }, { spawn: child_process_1.spawn });
     },
 };

package/dist/relay/bay-relays.js

@@ -55,17 +55,22 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BayRelaySupervisor = exports.BAY_RELAY_PARENT_ENV = exports.BAY_RELAY_CHILD_ENV = void 0;
+exports.BayRelaySupervisor = exports.BAY_RELAY_PARENT_ENV = exports.BAY_RELAY_MCP_ENTRY_ENV = exports.BAY_RELAY_CHILD_ENV = void 0;
 exports.bayRelayScope = bayRelayScope;
 exports.bayClientEnv = bayClientEnv;
 exports.bayRelayEnv = bayRelayEnv;
+exports.relayMcpEntry = relayMcpEntry;
 exports.isBayRelayChild = isBayRelayChild;
 const node_child_process_1 = require("node:child_process");
 const path = __importStar(require("node:path"));
+const bays_1 = require("../bays");
 const socket_1 = require("./socket");
 const log_line_1 = require("./log-line");
 /** Set in a per-Bay child relay: it must never supervise children of its own. */
 exports.BAY_RELAY_CHILD_ENV = "BAYCHAT_RELAY_BAY";
+/** The MCP entry name this child's Bay has in the computer's client configs (`baychat-<bay>`):
+ *  a child cannot work it out itself — its credentials hold only its own Bay's token. */
+exports.BAY_RELAY_MCP_ENTRY_ENV = "BAYCHAT_RELAY_MCP_ENTRY";
 /** The supervising relay's pid, so an orphaned child can stop itself. */
 exports.BAY_RELAY_PARENT_ENV = "BAYCHAT_RELAY_PARENT_PID";
 /** What a Bay id may contribute to a path or pipe name. */
@@ -97,8 +102,11 @@ function bayClientEnv(scope) {
     };
 }
 /** The environment a per-Bay CHILD relay runs with. Holds the Bay's token: never logged. */
-function bayRelayEnv(bay, baseUrl, scope, parentPid) {
+function bayRelayEnv(bay, baseUrl, scope, parentPid, 
+/** The Bay's MCP entry name among the computer's Bays (`bayEntryName`). */
+mcpEntry) {
     return {
+        ...(mcpEntry ? { [exports.BAY_RELAY_MCP_ENTRY_ENV]: mcpEntry } : {}),
         ...bayClientEnv(scope),
         BAYCHAT_DEVICE_TOKEN: bay.token,
         BAYCHAT_API_URL: baseUrl,
@@ -107,6 +115,11 @@ function bayRelayEnv(bay, baseUrl, scope, parentPid) {
         [exports.BAY_RELAY_PARENT_ENV]: String(parentPid),
     };
 }
+/** The MCP entry this relay's Bay has in Codex's and the other clients' configs: the default
+ *  Bay's is `baychat`, a per-Bay child's the name its parent gave it. */
+function relayMcpEntry(env = process.env) {
+    return env[exports.BAY_RELAY_MCP_ENTRY_ENV] || bays_1.DEFAULT_MCP_ENTRY;
+}
 /** Is THIS process a per-Bay child relay? */
 function isBayRelayChild(env = process.env) {
     return Boolean(env[exports.BAY_RELAY_CHILD_ENV]);
@@ -164,14 +177,14 @@ class BayRelaySupervisor {
             const exited = this.lastExit.get(bayId);
             if (exited !== undefined && this.now() - exited < (this.deps.restartDelayMs ?? 10_000))
                 continue;
-            this.startChild(bay, baseUrl);
+            this.startChild(bay, baseUrl, (0, bays_1.bayEntryName)(bay, bays));
         }
     }
-    startChild(bay, baseUrl) {
+    startChild(bay, baseUrl, mcpEntry) {
         const scope = bayRelayScope(bay.bayId, this.deps.baseConfigDir, this.deps.baseSocket);
         let child;
         try {
-            child = this.spawnChild(bayRelayEnv(bay, baseUrl, scope, process.pid));
+            child = this.spawnChild(bayRelayEnv(bay, baseUrl, scope, process.pid, mcpEntry));
         }
         catch (err) {
             this.lastExit.set(bay.bayId, this.now());

package/dist/relay/codex-allowances.js

@@ -0,0 +1,113 @@
+"use strict";
+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.CodexAllowances = void 0;
+exports.completedFileChangePaths = completedFileChangePaths;
+const path = __importStar(require("path"));
+const codex_approvals_1 = require("./codex-approvals");
+/**
+ * "Allow for this session" answers, per BayChat session AND per Codex thread (review 2026-10-23).
+ *
+ * Codex's own `acceptForSession` dies with the per-turn `codex app-server` process, so the relay
+ * remembers the answer for later turns — in memory only, never on disk. A remembered answer
+ * belongs to ONE conversation: when the session's thread changes (`/new`, a fresh start, a
+ * terminal Codex that registered a new thread) the answers are gone, and they are forgotten
+ * outright whenever the relay forgets or re-registers the session (End, a dead-session sweep, a
+ * new attach or registration, `/clear`).
+ *
+ * "This exact command" is not "this exact effect": a remembered command runs whatever its scripts
+ * contain when it runs. So a file change Codex completes under a remembered command's folder drops
+ * every command remembered there, and the next run is asked again.
+ */
+class CodexAllowances {
+    bySession = new Map();
+    /** The answers for this session's current thread (a new, empty set when the thread changed). */
+    for(session, thread) {
+        const held = this.bySession.get(session);
+        if (held && held.thread === thread)
+            return held.keys;
+        const fresh = { thread, keys: new Set() };
+        this.bySession.set(session, fresh);
+        return fresh.keys;
+    }
+    /** A thread that had no id yet (a new one) now has one: its answers move with it. */
+    rebind(session, from, to) {
+        const held = this.bySession.get(session);
+        if (held && held.thread === from)
+            held.thread = to;
+    }
+    forget(session) {
+        this.bySession.delete(session);
+    }
+    count(session) {
+        return this.bySession.get(session)?.keys.size ?? 0;
+    }
+    /** Files changed: drop the commands remembered in any folder they are under. Returns how many. */
+    noteFileChanges(session, paths) {
+        const held = this.bySession.get(session);
+        if (!held || paths.length === 0)
+            return 0;
+        let dropped = 0;
+        for (const key of [...held.keys]) {
+            const cwd = (0, codex_approvals_1.commandKeyCwd)(key);
+            if (cwd === undefined)
+                continue;
+            const under = paths.some((p) => {
+                const abs = path.resolve(cwd || "/", p);
+                const rel = path.relative(cwd || "/", abs);
+                return !cwd || rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+            });
+            if (under) {
+                held.keys.delete(key);
+                dropped += 1;
+            }
+        }
+        return dropped;
+    }
+}
+exports.CodexAllowances = CodexAllowances;
+/** The paths of a completed file change, from an `item/completed` notification; [] for anything else. */
+function completedFileChangePaths(method, params) {
+    if (method !== "item/completed")
+        return [];
+    const item = (params.item ?? {});
+    if (item.type !== "fileChange" || item.status !== "completed" || !Array.isArray(item.changes))
+        return [];
+    return item.changes.flatMap((c) => {
+        const change = (c ?? {});
+        const kind = (change.kind ?? {});
+        return [change.path, kind.move_path].filter((p) => typeof p === "string" && p !== "");
+    });
+}