baychat 0.33.2 → 0.34.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.33.2",
+  "version": "0.34.0",
   "displayName": "BayChat",
   "description": "Wakes this Claude Code session the moment a BayChat message arrives: no Monitor, no 30-minute deadline. Uses the baychat CLI already on this computer (npm install -g baychat, then baychat login).",
   "author": {

package/dist/auto-update/policy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HELD_FRESH_MS = exports.QUIET_MS = exports.CARD_POLL_MS = exports.ASK_AGAIN_MS = exports.HINT_COOLDOWN_MS = exports.HINT_SPREAD_MS = exports.HINT_MIN_MS = exports.CHECK_INTERVAL_MS = exports.AUTO_UPDATE_ENV = void 0;
+exports.HELD_FRESH_MS = exports.QUIET_MS = exports.CARD_POLL_MS = exports.ASK_AGAIN_MS = exports.HINT_RECHECK_MS = exports.HINT_COOLDOWN_MS = exports.HINT_SPREAD_MS = exports.HINT_MIN_MS = exports.CHECK_INTERVAL_MS = exports.AUTO_UPDATE_ENV = void 0;
 exports.planUpdate = planUpdate;
 exports.autoUpdateOffReason = autoUpdateOffReason;
 exports.nextCheckAt = nextCheckAt;
@@ -54,9 +54,12 @@ const FIRST_CHECK_SPREAD_MS = 10 * MINUTE;
  *  1–5 minutes — spread so a fleet that hears the same frame never asks npm together. */
 exports.HINT_MIN_MS = MINUTE;
 exports.HINT_SPREAD_MS = 4 * MINUTE;
-/** A hint right after a check is not taken: a server that names a release on every reconnect
- *  must not become an npm query on every reconnect. */
+/** A hint never brings a check closer than this to the last one: a server that names a release
+ *  on every reconnect must not become an npm query on every reconnect. */
 exports.HINT_COOLDOWN_MS = 15 * MINUTE;
+/** The server can name a release before npm has it (deployed first, published after): npm is
+ *  asked again this long after each answer that is still older, then the hint is given up. */
+exports.HINT_RECHECK_MS = [15 * MINUTE, 30 * MINUTE, HOUR];
 /** A check that failed (offline, npm down) is tried again sooner than a day, then backs off. */
 const CHECK_RETRY_MS = HOUR;
 /** A failed install of one version waits a day, then two, … up to a week. A newer version resets it. */

package/dist/auto-update/updater.js

@@ -17,10 +17,6 @@ class AutoUpdater {
     running = false;
     stopped = false;
     lastCardPoll = 0;
-    /** A release the server named (hint.ts), and when npm is asked about it. In memory only: a
-     *  restarted relay hears the next `ready` frame anyway. */
-    hinted;
-    hintCheckAt;
     constructor(deps) {
         this.deps = deps;
         this.startedAt = deps.now();
@@ -28,6 +24,7 @@ class AutoUpdater {
     }
     /** Finish an update the previous relay installed, then look at the state once a minute. */
     start() {
+        this.freshStart();
         void this.runExclusive(() => this.finishPendingUpdate());
         this.timer = setInterval(() => void this.tick(), exports.TICK_MS);
         this.timer.unref();
@@ -50,34 +47,86 @@ class AutoUpdater {
             failure: state.failure?.reason,
         };
     }
+    /**
+     * New code is a new chance. Check failures recorded by ANOTHER version say nothing about this
+     * one — the failure may be the very bug this version fixes. Real case, 2026-10-21: relays that
+     * failed 11 times on 0.33.0 ("npm was not found on PATH") carried that backoff into 0.33.1, which
+     * fixed it, and would not have asked npm again for a day. So the schedule starts over, and the
+     * first check comes 5–15 minutes after this start.
+     */
+    freshStart() {
+        const state = this.deps.loadState();
+        if (!state.current || state.current === this.deps.current)
+            return;
+        if (state.lastCheckAt === undefined && !state.checkFailures)
+            return;
+        const was = state.current;
+        state.lastCheckAt = undefined;
+        state.checkFailures = undefined;
+        state.lastCheckError = undefined;
+        state.current = this.deps.current;
+        this.deps.saveState(state);
+        this.deps.log(`auto-update: now running ${this.deps.current} (checks were recorded by ${was}); asking npm afresh`);
+    }
     /**
      * The server's feed named `version` as the newest BayChat (hint.ts). Newer than this copy, and
      * newer than what npm last said: ask npm in 1–5 minutes instead of at the daily check. Only the
      * moment moves — npm still names the version, and planUpdate still decides what happens.
      *
-     * The moment never moves earlier than the backoff allows: not within HINT_COOLDOWN_MS of the
-     * last check, and not while a failed check waits out its retry (npm down stays npm down,
-     * however often the server reconnects).
+     * The moment never moves earlier than the backoff allows (`hintDue`): not within
+     * HINT_COOLDOWN_MS of the last check, not before a failed check's retry. The hint is kept, on
+     * disk, rather than dropped: a server deployed before the npm publish names a version npm does
+     * not have yet (2026-10-21, 0.33.2: the hint's check came 1 minute before the publish), so npm
+     * is asked again after each HINT_RECHECK_MS step until it names that version, then given up.
      */
     hint(version) {
         const { mode } = this.mode();
         if (mode === "off" || mode === "none")
             return;
         const ahead = (0, self_upgrade_1.compareVersions)(version, this.deps.current);
-        if (ahead === undefined || ahead <= 0 || this.hinted === version)
+        if (ahead === undefined || ahead <= 0)
             return;
         const state = this.deps.loadState();
         const known = state.latest ? (0, self_upgrade_1.compareVersions)(state.latest, version) : undefined;
         if (known !== undefined && known >= 0)
             return; // npm already named it (or newer)
-        const now = this.deps.now();
-        if (state.lastCheckAt !== undefined && now - state.lastCheckAt < policy_1.HINT_COOLDOWN_MS)
+        if (validHint(state.hint)?.version === version)
+            return; // waiting on it, or gave up on it
+        const nextAt = this.hintDue(state, this.deps.now() + policy_1.HINT_MIN_MS + this.deps.random() * policy_1.HINT_SPREAD_MS);
+        state.hint = { version, attempts: 0, nextAt };
+        this.deps.saveState(state);
+        this.deps.log(`auto-update: the server names ${version}; asking npm in ${Math.ceil((nextAt - this.deps.now()) / 60_000)} min`);
+    }
+    /** The earliest a hinted check may run: `wanted`, or later if the backoff says so. */
+    hintDue(state, wanted) {
+        let at = wanted;
+        if (state.lastCheckAt !== undefined)
+            at = Math.max(at, state.lastCheckAt + policy_1.HINT_COOLDOWN_MS);
+        if ((state.checkFailures ?? 0) > 0)
+            at = Math.max(at, (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread));
+        return at;
+    }
+    /** After a check: the hint is answered (npm names it, or this copy has it), retried, or given up. */
+    settleHint(state, now, wasDue) {
+        const hint = validHint(state.hint);
+        if (!hint)
+            return void (state.hint = undefined);
+        const latest = state.latest ? (0, self_upgrade_1.compareVersions)(state.latest, hint.version) : undefined;
+        if ((latest !== undefined && latest >= 0) || (0, self_upgrade_1.compareVersions)(hint.version, this.deps.current) !== 1) {
+            state.hint = undefined;
+            return;
+        }
+        if (!wasDue || hint.nextAt === undefined)
             return;
-        if ((state.checkFailures ?? 0) > 0 && now < (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread))
+        const attempts = hint.attempts + 1;
+        const wait = policy_1.HINT_RECHECK_MS[attempts - 1];
+        if (wait === undefined) {
+            state.hint = { version: hint.version, attempts };
+            this.deps.log(`auto-update: npm still does not have ${hint.version}; the daily check takes over`);
             return;
-        this.hinted = version;
-        this.hintCheckAt = now + policy_1.HINT_MIN_MS + this.deps.random() * policy_1.HINT_SPREAD_MS;
-        this.deps.log(`auto-update: the server names ${version}; asking npm within minutes`);
+        }
+        state.hint = { version: hint.version, attempts, nextAt: now + wait };
+        this.deps.log(`auto-update: npm does not have ${hint.version} yet; asking again in ${wait / 60_000} min`);
     }
     /** One look at the state. Never throws; never runs twice at once. */
     async tick() {
@@ -97,11 +146,10 @@ class AutoUpdater {
             if (mode === "off" || mode === "none")
                 return;
             const now = this.deps.now();
-            const hinted = this.hintCheckAt !== undefined && now >= this.hintCheckAt;
-            if (hinted || now >= (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread)) {
-                this.hintCheckAt = undefined;
-                await this.check(state, mode);
-            }
+            const hintAt = validHint(state.hint)?.nextAt;
+            const hinted = hintAt !== undefined && now >= hintAt;
+            if (hinted || now >= (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread))
+                await this.check(state, mode, hinted);
             if (mode !== "auto")
                 return;
             if (state.card?.requestId && now - this.lastCardPoll >= policy_1.CARD_POLL_MS)
@@ -129,20 +177,25 @@ class AutoUpdater {
             return { mode: "notify", reason: "for a relay started by hand (install with `baychat update`)" };
         return { mode: "auto" };
     }
-    /** Ask npm, and decide. */
-    async check(state, mode) {
+    /** Ask npm, and decide. `hinted`: the check a server's hint asked for (counts as a hint attempt). */
+    async check(state, mode, hinted = false) {
         const looked = await this.deps.lookupLatest();
-        state.lastCheckAt = this.deps.now();
+        const now = this.deps.now();
+        state.lastCheckAt = now;
         if (!looked.ok) {
-            // Offline, npm down: quiet. Tried again within the hour, then less often.
+            // Offline, npm down: quiet. Tried again within the hour, then less often — a waiting hint too.
             state.checkFailures = (state.checkFailures ?? 0) + 1;
             state.lastCheckError = looked.reason;
+            const hint = validHint(state.hint);
+            if (hint?.nextAt !== undefined)
+                state.hint = { ...hint, nextAt: this.hintDue(state, now) };
             this.deps.log(`auto-update: could not ask npm (${looked.reason})`);
             return this.deps.saveState(state);
         }
         state.checkFailures = 0;
         state.lastCheckError = undefined;
         state.latest = looked.release.version;
+        this.settleHint(state, now, hinted);
         const plan = (0, policy_1.planUpdate)(this.deps.current, looked.release);
         if (plan.kind === "current") {
             // Updated some other way (`baychat update`), or nothing new: nothing may stay on the phone.
@@ -355,6 +408,15 @@ class AutoUpdater {
     }
 }
 exports.AutoUpdater = AutoUpdater;
+/** The persisted hint, if it is one: the state file is ours, but a hand edit or an older shape must
+ *  not stop the updater. */
+function validHint(raw) {
+    if (!raw || typeof raw !== "object" || typeof raw.version !== "string" || typeof raw.attempts !== "number")
+        return undefined;
+    if (raw.nextAt !== undefined && typeof raw.nextAt !== "number")
+        return undefined;
+    return raw;
+}
 function errText(err) {
     return err instanceof Error ? err.message : String(err);
 }

package/dist/channel/relay-link.js

@@ -155,6 +155,7 @@ class RelayLink {
                 runtime: "claude",
                 ...(this.opts.pane ? { pane: this.opts.pane } : {}),
                 ...(this.opts.ownerPid !== undefined ? { ownerPid: this.opts.ownerPid } : {}),
+                ...(this.opts.cwd ? { cwd: this.opts.cwd } : {}),
             };
             (0, socket_1.writeFrame)(socket, frame);
         });

package/dist/channel/server.js

@@ -107,7 +107,7 @@ const LISTEN_TOOL = {
  * parent are the session's (owner-pid.ts walks the live process tree to prove the latter).
  */
 function realCommandLink(log) {
-    return (session, bay, hooks) => new relay_link_1.RelayLink({ socketPath: relaySocketFor(bay), session, pane: (0, terminal_pane_1.detectPane)(), ownerPid: (0, owner_pid_1.currentOwnerPid)("claude"), ...hooks, log });
+    return (session, bay, hooks) => new relay_link_1.RelayLink({ socketPath: relaySocketFor(bay), session, pane: (0, terminal_pane_1.detectPane)(), ownerPid: (0, owner_pid_1.currentOwnerPid)("claude"), cwd: process.cwd(), ...hooks, log });
 }
 /** The relay that serves a Bay's sessions: the default relay, or that Bay's own (relay/bay-relays.ts). */
 function relaySocketFor(bay) {

package/dist/launch/command.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trustByHand = exports.APPROVALS_NOTICE = exports.LAUNCH_USAGE = void 0;
+exports.trustByHand = exports.CODEX_UNATTENDED_NOTICE = exports.APPROVALS_NOTICE = exports.LAUNCH_USAGE = void 0;
 exports.cmdLaunch = cmdLaunch;
 const path = __importStar(require("path"));
 const args_1 = require("../args");
@@ -41,12 +41,16 @@ const multiplexer_launch_1 = require("../multiplexer-launch");
 const policy_1 = require("../relay/acp/policy");
 const claude_trust_1 = require("./claude-trust");
 const policy_2 = require("./policy");
-exports.LAUNCH_USAGE = `Usage: baychat launch add <folder> [--label <label>] [--runtime claude,codex] [--max <n>]
+exports.LAUNCH_USAGE = `Usage: baychat launch add <folder> [--label <label>] [--runtime claude,codex] [--max <n>] [--unattended]
                                   Let BayChat start sessions in <folder> from the app
+                                  (--unattended: also let it start Codex there, which then never asks)
        baychat launch list         The folders BayChat may start sessions in
        baychat launch remove <id>  Stop offering one of them`;
 /** Printed by every `add`: the one thing a person must know before saying yes. */
-exports.APPROVALS_NOTICE = "Sessions started here from BayChat ask for approvals in BayChat.";
+exports.APPROVALS_NOTICE = "Claude Code sessions started here from BayChat ask for approvals in BayChat.";
+/** Printed when Codex is offered: it has no BayChat approvals, so what it does is decided up front. */
+exports.CODEX_UNATTENDED_NOTICE = "Codex started here from BayChat does NOT ask for approvals: it runs --ask-for-approval never inside its workspace sandbox, with no network. " +
+    "It can change files in this folder, and anyone who may wake it in the chat can ask it to. MCP servers in its own config run as usual.";
 const realDeps = () => {
     const file = (0, claude_trust_1.claudeConfigPath)();
     return {
@@ -81,8 +85,13 @@ async function addSpot(args, deps) {
     const label = (0, args_1.flag)(args, "--label");
     const runtimeList = (0, args_1.flag)(args, "--runtime");
     const maxRaw = (0, args_1.flag)(args, "--max");
+    const unattended = args.includes("--unattended");
     const valued = new Set([label, runtimeList, maxRaw].filter((v) => v !== undefined));
     const folderArg = args.find((a) => !a.startsWith("--") && !valued.has(a));
+    if (unattended && !(runtimeList ?? "").split(",").map((r) => r.trim()).includes("codex")) {
+        deps.print("--unattended is for Codex: add it with --runtime including codex.");
+        return 1;
+    }
     if (!folderArg)
         throw new Error(exports.LAUNCH_USAGE);
     const folder = (0, policy_1.validateNewRoot)(folderArg);
@@ -114,11 +123,17 @@ async function addSpot(args, deps) {
         path: folder.path,
         runtimes: [...new Set(requested)],
         maxSessions,
+        ...(unattended ? { unattendedCodex: true } : {}),
     };
     (0, policy_2.saveLaunchPolicy)((0, policy_2.upsertSpot)(policy, spot), deps.policyFile);
     deps.print(`${existing ? "Updated" : "Added"} "${spot.label}" (${spot.id}): ${spot.path}`);
     deps.print(`  Agents: ${spot.runtimes.join(", ")} · at most ${spot.maxSessions} at once`);
     deps.print(`  ${exports.APPROVALS_NOTICE}`);
+    if (spot.runtimes.includes("codex")) {
+        deps.print(spot.unattendedCodex
+            ? `  ${exports.CODEX_UNATTENDED_NOTICE}`
+            : "  Codex is listed but not allowed to start unattended here; add --unattended (read what it means first) to start it from BayChat.");
+    }
     if (spot.runtimes.includes("claude"))
         await offerClaudeTrust(spot.path, deps);
     return 0;

package/dist/launch/policy.js

@@ -136,7 +136,7 @@ function resolveSpotFolder(spot) {
 function parseSpot(entry) {
     if (!entry || typeof entry !== "object")
         return null;
-    const { id, label, path: p, runtimes, maxSessions } = entry;
+    const { id, label, path: p, runtimes, maxSessions, unattendedCodex } = entry;
     if (typeof id !== "string" || !exports.SPOT_ID_RE.test(id))
         return null;
     if (typeof label !== "string" || label.trim().length === 0 || label.length > exports.SPOT_LABEL_MAX)
@@ -148,5 +148,7 @@ function parseSpot(entry) {
         return null;
     if (typeof maxSessions !== "number" || !Number.isInteger(maxSessions) || maxSessions < 1 || maxSessions > exports.MAX_SESSIONS_PER_COMPUTER)
         return null;
-    return { id, label, path: p, runtimes: [...new Set(runtimes)], maxSessions };
+    if (unattendedCodex !== undefined && unattendedCodex !== true)
+        return null;
+    return { id, label, path: p, runtimes: [...new Set(runtimes)], maxSessions, ...(unattendedCodex ? { unattendedCodex } : {}) };
 }

package/dist/multiplexer-launch.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TMUX_SESSION_VAR = void 0;
 exports.launchAgent = launchAgent;
 exports.runHere = runHere;
 exports.multiplexerArgv = multiplexerArgv;
@@ -75,6 +76,8 @@ const readline = __importStar(require("readline"));
 const config_1 = require("./config");
 const terminal_pane_1 = require("./relay/terminal-pane");
 const runtime_binary_1 = require("./runtime-binary");
+/** Set in the agent's environment to the tmux session our CLI created for it (read by detectPane). */
+exports.TMUX_SESSION_VAR = "BAYCHAT_TMUX_SESSION";
 /**
  * Start `program` where session commands can reach it — inside tmux or screen when possible —
  * and return its exit status. Never refuses to start the agent: every failure on the way falls
@@ -119,20 +122,29 @@ function runHere(program, deps = realLaunchDeps()) {
 function multiplexerArgv(multiplexer, naming, program, 
 /** Needed only for a `fresh` name (its pid suffix and the tmux uniqueness check). */
 deps) {
-    const vars = Object.entries(program.env).map(([k, v]) => `${k}=${v}`);
-    const command = vars.length ? ["env", ...vars, program.binary, ...program.args] : [program.binary, ...program.args];
+    const commandWith = (extra) => {
+        const vars = Object.entries({ ...program.env, ...extra }).map(([k, v]) => `${k}=${v}`);
+        return vars.length ? ["env", ...vars, program.binary, ...program.args] : [program.binary, ...program.args];
+    };
+    // The tmux session's exact name rides into the agent as BAYCHAT_TMUX_SESSION, so the relay can
+    // tell later that a pane is in the session OUR CLI made, not one of the person's own that happens
+    // to share the name (an End from the app closes only the former: stop-registered.ts).
+    const tmuxCommand = (session) => commandWith({ [exports.TMUX_SESSION_VAR]: session });
     if (naming.kind === "detached") {
-        return multiplexer === "tmux" ? ["new", "-d", "-s", naming.name, "-c", naming.cwd, ...command] : ["-dmS", naming.name, ...command];
+        return multiplexer === "tmux" ? ["new", "-d", "-s", naming.name, "-c", naming.cwd, ...tmuxCommand(naming.name)] : ["-dmS", naming.name, ...commandWith({})];
     }
     if (!deps)
         throw new Error("multiplexerArgv: a fresh or reattached session needs the launch deps");
     if (multiplexer === "tmux") {
-        return naming.kind === "reattach"
-            ? // `-A` attaches to an existing session of that name instead of failing, so running this
-                // twice returns you to your agent rather than erroring at you.
-                ["new", "-A", "-s", naming.name, ...command]
-            : ["new", "-s", uniqueTmuxName(naming.prefix, deps), ...command];
+        if (naming.kind === "reattach") {
+            // `-A` attaches to an existing session of that name instead of failing, so running this
+            // twice returns you to your agent rather than erroring at you.
+            return ["new", "-A", "-s", naming.name, ...tmuxCommand(naming.name)];
+        }
+        const name = uniqueTmuxName(naming.prefix, deps);
+        return ["new", "-s", name, ...tmuxCommand(name)];
     }
+    const command = commandWith({});
     // screen tells same-named sessions apart by pid, so a fresh one needs no uniqueness check.
     return naming.kind === "reattach" ? ["-S", naming.name, "-R", ...command] : ["-S", `${naming.prefix}-${deps.pid}`, ...command];
 }