baychat 0.34.1 → 0.34.2

package/dist/relay/codex-runner.js

@@ -0,0 +1,505 @@
+"use strict";
+// Codex run by the relay itself, with its approvals as BayChat cards (2026-10-23).
+//
+// WHAT CHANGED. A Codex started from the app used to be a TUI in a detached tmux pane, run with
+// `--ask-for-approval never` because nobody sits at that keyboard: whatever the sandbox did not
+// allow simply failed. Now the relay runs such a session the way it runs an ACP agent
+// (acp/runner.ts): one `codex app-server` process per turn (codex-app-server.ts), the turn's
+// messages from a persisted queue, and — the point of it — every approval Codex asks for put on
+// the owner's phone as a decision card: "Allow once", "Allow for this session" (Face ID), "Deny".
+//
+// WHO GETS TO BE ASKED. A turn's power depends on who woke it, exactly as an ACP turn's mode
+// does (`effectiveMode`): when EVERY addressed message is from someone with command access to the
+// session (the owner, or a grantee — `senderIsOwner` / `commandAuthorized`), the turn runs
+// `on-request` in a workspace-write sandbox with no network, and asks. One message from anybody
+// else makes the whole turn `never` + read-only: it may read and answer, nothing more, and no
+// card is ever raised on its behalf (a person without command access must not be able to put a
+// "run this?" question on the owner's phone).
+//
+// "ALLOW FOR THIS SESSION" OUTLIVES THE PROCESS HERE. Codex's own `acceptForSession` is held by
+// the app-server process, which ends with the turn — so the next turn would ask again. The runner
+// therefore keeps its own allow-list per session: an exact command in an exact folder, or an exact
+// set of file paths (codex-approvals.ts `sessionAllowKey`), answered `accept` without a card in
+// later turns (and logged). It is forgotten on `/new`, on End, on a fresh start, and when the
+// relay restarts — never written to disk, so it can never outlive the session it was given for.
+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.CodexSessionRunner = exports.DEFAULT_CODEX_MCP_ENTRY = void 0;
+exports.codexQueuePath = codexQueuePath;
+exports.codexPowerDescription = codexPowerDescription;
+exports.codexTurnPolicyFor = codexTurnPolicyFor;
+exports.codexApprovalHandler = codexApprovalHandler;
+exports.codexTurnQueue = codexTurnQueue;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../config");
+const approval_1 = require("./acp/approval");
+const presence_1 = require("./acp/presence");
+const prompt_1 = require("./acp/prompt");
+const turn_queue_1 = require("./acp/turn-queue");
+const codex_app_server_1 = require("./codex-app-server");
+const codex_approvals_1 = require("./codex-approvals");
+const codex_allowances_1 = require("./codex-allowances");
+const codex_log_1 = require("./codex-log");
+const codex_launch_1 = require("./launcher/codex-launch");
+const fresh_start_1 = require("./fresh-start");
+/** Where a relay-run Codex session's waiting messages are kept (its own file, beside ACP's). */
+function codexQueuePath() {
+    return path.join((0, config_1.configDir)(), "codex-turn-queue.json");
+}
+/** The BayChat MCP entry Codex knows BayChat under (`[mcp_servers.baychat]`). */
+exports.DEFAULT_CODEX_MCP_ENTRY = "baychat";
+/** The allow-list key of a thread that has no id yet (its first turn starts it). */
+const NEW_THREAD = "(new thread)";
+const errText = (err) => (err instanceof Error ? err.message : String(err));
+/** What the setup text tells Codex it may do, for the policy this turn runs under. */
+function codexPowerDescription(policy) {
+    return policy.approvalPolicy === "on-request"
+        ? "you may edit files in this folder; there is no network. Anything else — a command outside the sandbox, network access, files elsewhere — is asked of the session's owner on their phone, so ask only when you need it."
+        : "read only. You may read files here and answer in the chat; nothing you run may change anything, and nobody will be asked to allow more.";
+}
+/**
+ * How much ONE turn may do, from who woke it: every addressed message from someone with command
+ * access → it asks (`askingPolicy`); anyone else among them → read only, never asks.
+ */
+function codexTurnPolicyFor(addressed, entry, 
+/** Is `entry` a server in Codex's config? Only then may a read-only turn set its approval mode. */
+entryConfigured = (e) => (0, codex_launch_1.codexConfigHasEntry)((0, codex_launch_1.readCodexConfig)(), e)) {
+    const allAuthorized = addressed.length > 0 && addressed.every((m) => m.senderIsOwner === true || m.commandAuthorized === true);
+    if (allAuthorized)
+        return { allAuthorized, policy: (0, codex_app_server_1.askingPolicy)() };
+    return { allAuthorized, policy: (0, codex_app_server_1.readOnlyPolicy)(entryConfigured(entry) ? entry : undefined) };
+}
+/**
+ * `onApproval` for a Codex turn (codex-app-server.ts): BayChat's own tools pass, other
+ * elicitations are declined unseen, a turn woken by someone without command access never asks,
+ * an exact request allowed for the session passes, and everything else is a card on the phone.
+ */
+function codexApprovalHandler(c) {
+    const tag = `codex: ${c.session}`;
+    return async (req, signal, hooks) => {
+        if (req.method === "mcpServer/elicitation/request") {
+            // BayChat's own tools are the session's voice in the room: no card. Anything else that
+            // asks through an elicitation (a form, another server) is declined, never shown.
+            if ((0, codex_approvals_1.isBayChatMcpApproval)(req.params, c.entry)) {
+                c.log(`${tag} BayChat tool call allowed without asking`);
+                return (0, codex_approvals_1.decisionFor)(req, "once");
+            }
+            c.log(`${tag} ${(0, codex_approvals_1.describeForLog)(req)} — declined (not asked)`);
+            return (0, codex_approvals_1.decisionFor)(req, null);
+        }
+        if (!c.allAuthorized) {
+            // Unreachable under `never`, and refused if Codex ever asks anyway.
+            c.log(`${tag} ${(0, codex_approvals_1.describeForLog)(req)} — refused (woken by someone without command access)`);
+            return (0, codex_approvals_1.decisionFor)(req, null);
+        }
+        const key = (0, codex_approvals_1.sessionAllowKey)(req, c.cwd);
+        if (key && c.allow.has(key)) {
+            c.log(`${tag} ${(0, codex_approvals_1.describeForLog)(req)} — allowed for this session earlier, not asked again`);
+            return (0, codex_approvals_1.decisionFor)(req, "once");
+        }
+        const plan = (0, codex_approvals_1.planCodexCard)(req, { host: c.host, session: c.session });
+        if (plan.kind === "refuse") {
+            c.log(`${tag} ${(0, codex_approvals_1.describeForLog)(req)} — refused without asking: ${plan.reason}`);
+            return (0, codex_approvals_1.decisionFor)(req, null);
+        }
+        const { card } = plan;
+        hooks?.personAsked();
+        c.typing?.()?.pause(); // the card is the signal while a person decides
+        c.log(`${tag} card asked — ${(0, codex_approvals_1.describeForLog)(req)}`);
+        const answer = await (c.ask ?? approval_1.askPhoneChoice)({
+            auth: c.auth,
+            session: c.session,
+            conversationId: c.room,
+            // The private chat between the session and its owner, never a group room: the card can show
+            // a command, paths and file contents, and only the owner may answer it anyway.
+            direct: true,
+            question: card.question,
+            options: card.labels,
+            guardedOptions: card.guardedOptions,
+            waitSeconds: codex_approvals_1.CODEX_CARD_WAIT_SECONDS,
+            signal,
+        });
+        c.typing?.()?.resume();
+        const choice = (0, codex_approvals_1.choiceAt)(card, answer.index);
+        if (choice === "session" && key && card.rememberable)
+            c.allow.add(key);
+        c.log(`${tag} card ${choice === null ? "not answered" : `answered "${card.labels[answer.index]}"`} — ${answer.reason}`);
+        return (0, codex_approvals_1.decisionFor)(req, choice);
+    };
+}
+/**
+ * Runs relay-run Codex sessions' turns ONE AT A TIME per session, in arrival order. `handle` never
+ * blocks: it files the batch and makes sure a drain loop is running, so `/stop` during a long turn
+ * is processed at once.
+ */
+class CodexSessionRunner {
+    deps;
+    running = new Map();
+    loops = new Map();
+    said = new Map();
+    /** "Allow for this session" answers, per session. Memory only — see the file header. */
+    allowances = new codex_allowances_1.CodexAllowances();
+    /** Bumped by every reset: a turn records its thread only if no reset happened while it ran. */
+    generation = new Map();
+    /** A `/compact` asked for, by session → the room to answer in. Run between turns. */
+    compacts = new Map();
+    /** A fresh start's first prompt, run as the session's next turn, alone. */
+    freshTurns = new Map();
+    /** Sessions whose running turn a fresh start stopped: its messages wait, they are not lost. */
+    requeueOnStop = new Map();
+    logs = new Map();
+    closed = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    handle(session, batch) {
+        const { dropped } = this.deps.queue.add(session, batch);
+        if (dropped > 0)
+            this.deps.log(`codex: ${session} has too many messages waiting — ${dropped} not queued`);
+        this.kick(session);
+    }
+    /** `/stop`: interrupt the running turn. False when none is running. */
+    stop(session) {
+        const turn = this.running.get(session);
+        if (!turn)
+            return false;
+        turn.abort();
+        return true;
+    }
+    /** `/new`: the next turn starts a new thread, and nothing allowed before carries over. */
+    reset(session) {
+        // A turn that finishes after this must not write its (old) thread back.
+        this.generation.set(session, (this.generation.get(session) ?? 0) + 1);
+        this.deps.registry.setCodexThread(session, undefined);
+        this.allowances.forget(session);
+    }
+    /** End: stop what runs and forget everything this runner held for the session. */
+    end(session) {
+        this.stop(session);
+        this.allowances.forget(session);
+        this.compacts.delete(session);
+        this.freshTurns.delete(session);
+        this.deps.queue.clear(session);
+    }
+    /** The session's "Allow for this session" answers — shared with the headless rung (daemon.ts). */
+    allowListFor(session, thread) {
+        return this.allowances.for(session, thread);
+    }
+    /** Forget every "Allow for this session" answer the session holds (the daemon calls this whenever
+     *  it forgets or re-registers a session). */
+    forgetAllowances(session) {
+        this.allowances.forget(session);
+    }
+    /** A notification from a turn: a completed file change under a remembered command's folder
+     *  drops that command. Returns the number dropped. */
+    noteNotification(session, method, params) {
+        return this.allowances.noteFileChanges(session, (0, codex_allowances_1.completedFileChangePaths)(method, params));
+    }
+    /** How many "Allow for this session" answers the session holds (for `/status`). */
+    allowedCount(session) {
+        return this.allowances.count(session);
+    }
+    /**
+     * `/compact`: tidy the thread's memory, BETWEEN turns — one asked for during a turn runs when it
+     * ends. The answer is said in `conversationId`. False when there is nothing to compact.
+     */
+    compact(session, conversationId) {
+        if (!this.deps.registry.get(session)?.codex?.threadId)
+            return false;
+        this.compacts.set(session, conversationId);
+        this.kick(session);
+        return true;
+    }
+    /** A fresh start (fresh-start.ts): a new thread, with the handoff note as its first prompt. */
+    freshStart(session, first, handoffId) {
+        this.deps.queue.discard(session, (m) => (0, fresh_start_1.isNoteRequestFor)(m, handoffId));
+        this.freshTurns.set(session, first);
+        this.compacts.delete(session);
+        const running = this.running.get(session);
+        if (running) {
+            this.requeueOnStop.set(session, handoffId);
+            running.abort();
+        }
+        this.reset(session);
+        this.kick(session);
+    }
+    status(session) {
+        return { running: this.running.has(session), queued: this.deps.queue.depth(session) };
+    }
+    activeSessions() {
+        return [...this.loops.keys()];
+    }
+    async idle() {
+        while (this.loops.size > 0)
+            await Promise.all([...this.loops.values()]);
+    }
+    shutdown() {
+        this.closed = true;
+        for (const turn of this.running.values())
+            turn.abort();
+    }
+    kick(session) {
+        if (this.closed || this.loops.has(session))
+            return;
+        const loop = this.drain(session)
+            .catch((err) => {
+            this.deps.log(`codex: ${session} drain failed — ${errText(err)}`);
+        })
+            .then(() => {
+            this.loops.delete(session);
+            // A `handle` that landed after the drain saw an empty queue found this loop still
+            // registered and did not start one; pick its batch up now.
+            if (!this.closed && (this.deps.queue.depth(session) > 0 || this.compacts.has(session) || this.freshTurns.has(session)))
+                this.kick(session);
+        });
+        this.loops.set(session, loop);
+    }
+    async drain(session) {
+        for (;;) {
+            if (this.closed)
+                return;
+            const room = this.compacts.get(session);
+            if (room !== undefined) {
+                this.compacts.delete(session);
+                await this.runCompact(session, room);
+                continue;
+            }
+            const first = this.freshTurns.get(session);
+            if (first)
+                this.freshTurns.delete(session);
+            const turn = first ? { addressed: [first], digest: { messages: [], omitted: 0 } } : this.deps.queue.take(session);
+            if (!turn)
+                return;
+            try {
+                await this.runOne(session, turn);
+            }
+            catch (err) {
+                // A bug or a disk error, not an outcome. Recorded pending, never silently lost.
+                this.deps.log(`codex: ${session} turn failed unexpectedly — ${errText(err)}`);
+                this.deps.onPending(session, turn.addressed, "the relay failed while running this turn");
+            }
+        }
+    }
+    /** The session's log, made once. */
+    logFor(session) {
+        if (!this.logs.has(session))
+            this.logs.set(session, this.deps.sessionLog ? this.deps.sessionLog(session) : new codex_log_1.CodexSessionLog(session));
+        return this.logs.get(session);
+    }
+    async sayOnce(session, key, conversationId, text) {
+        const seen = this.said.get(session) ?? new Set();
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        this.said.set(session, seen);
+        await this.tell(session, conversationId, text);
+    }
+    async tell(session, conversationId, text) {
+        try {
+            await this.deps.say(conversationId, session, text);
+        }
+        catch (err) {
+            this.deps.log(`codex: could not tell the room about ${session} — ${errText(err)}`);
+        }
+    }
+    async runCompact(session, room) {
+        const { deps } = this;
+        const codex = deps.registry.get(session)?.codex;
+        const bin = deps.binary();
+        if (!codex?.threadId || !bin.ok) {
+            await this.tell(session, room, `"${session}" has nothing to compact yet.`);
+            return;
+        }
+        deps.log(`codex: ${session} compacting thread ${codex.threadId}`);
+        const slog = this.logFor(session);
+        slog?.line("── /compact");
+        // Registered as the running work, so /stop, End and shutdown end a compaction too.
+        const abort = new AbortController();
+        this.running.set(session, abort);
+        let outcome;
+        try {
+            outcome = await (deps.runCompact ?? codex_app_server_1.runCodexCompact)({ binaryPath: bin.path, threadId: codex.threadId, cwd: codex.cwd, policy: (0, codex_app_server_1.readOnlyPolicy)(), onNotification: (method, params) => slog?.notification(method, params), signal: abort.signal }, { spawn: deps.spawn ?? child_process_1.spawn });
+        }
+        finally {
+            this.running.delete(session);
+        }
+        if (outcome.kind === "failed" && outcome.stopped) {
+            slog?.line("── compaction stopped");
+            if (!this.closed)
+                await this.tell(session, room, `Stopped compacting "${session}".`);
+            return;
+        }
+        slog?.line(outcome.kind === "completed" ? "── compacted" : `── compaction failed: ${outcome.reason}`);
+        if (outcome.kind === "completed") {
+            deps.log(`codex: ${session} compacted`);
+            await this.tell(session, room, `"${session}" compacted its memory.`);
+            return;
+        }
+        deps.log(`codex: ${session} could not compact — ${outcome.reason}`);
+        await this.tell(session, room, `"${session}" could not compact its memory this time. The details are in the relay's log on that computer.`);
+    }
+    async runOne(session, turn, retried = false) {
+        const { deps } = this;
+        const room = turn.addressed.at(-1).conversationId;
+        const drop = async (key, reason) => {
+            deps.onPending(session, turn.addressed, reason);
+            await this.sayOnce(session, key, room, reason);
+        };
+        const target = deps.registry.get(session);
+        const codex = target?.codex;
+        if (!target || !codex)
+            return drop("setup", `"${session}" is not set up on that computer any more. Start it again from BayChat.`);
+        const auth = deps.auth();
+        if (!auth)
+            return drop("setup", "The relay on that computer is not logged in to BayChat. Run `baychat login` there.");
+        const bin = deps.binary();
+        if (!bin.ok)
+            return drop("spawn", `Codex is not installed where the relay can find it (${bin.reason}).`);
+        // Every turn: the recorded binary may have been replaced, or downgraded, since the launch.
+        const ready = await deps.ready?.(bin.path);
+        if (ready && !ready.ok)
+            return drop("spawn", ready.reason);
+        const entry = deps.mcpEntry ?? exports.DEFAULT_CODEX_MCP_ENTRY;
+        const { allAuthorized, policy } = codexTurnPolicyFor(turn.addressed, entry, deps.entryConfigured);
+        const fresh = !codex.threadId || !codex.primed;
+        const prompt = `${fresh ? `${(0, prompt_1.setupPreamble)(session, codexPowerDescription(policy))}\n\n` : ""}${(0, prompt_1.turnPrompt)(turn)}`;
+        const caller = (deps.caller ?? presence_1.deviceMcpCaller)(auth);
+        const host = (deps.hostname ?? os.hostname)();
+        const thread = codex.threadId ?? NEW_THREAD;
+        const generation = this.generation.get(session) ?? 0;
+        const allow = this.allowListFor(session, thread);
+        const slog = this.logFor(session);
+        const prefix = `codex: ${session} `;
+        const both = (line) => {
+            deps.log(line);
+            slog?.line(line.startsWith(prefix) ? line.slice(prefix.length) : line);
+        };
+        let typing;
+        const onApproval = codexApprovalHandler({
+            auth,
+            session,
+            room,
+            allAuthorized,
+            entry,
+            host,
+            allow,
+            cwd: codex.cwd,
+            log: both,
+            ask: deps.askPhoneChoice,
+            typing: () => typing,
+        });
+        const abort = new AbortController();
+        let outcome;
+        try {
+            this.running.set(session, abort);
+            typing = (0, presence_1.startTyping)(caller, session, room, { log: deps.log });
+            slog?.turnStart(allAuthorized ? "people with command access" : "someone without command access", turn.addressed.length, policy.approvalPolicy === "on-request" ? "asks the owner, no network" : "read only, no cards");
+            deps.log(`codex: ${session} turn — ${turn.addressed.length} addressed, ${turn.digest.messages.length} context, ` +
+                `${policy.approvalPolicy === "on-request" ? "asks the owner" : "read only (not all from someone with command access)"}` +
+                `${codex.threadId ? "" : ", new thread"}`);
+            outcome = await (deps.runTurn ?? codex_app_server_1.runCodexTurn)({
+                binaryPath: bin.path,
+                ...(codex.threadId ? { threadId: codex.threadId } : {}),
+                prompt,
+                cwd: codex.cwd,
+                policy,
+                onApproval,
+                signal: abort.signal,
+                log: (line) => both(`${prefix}${line}`),
+                onNotification: (method, params) => {
+                    slog?.notification(method, params);
+                    const dropped = this.noteNotification(session, method, params);
+                    if (dropped > 0)
+                        both(`${prefix}files changed under ${dropped} command(s) allowed for this session — they will be asked again`);
+                },
+            }, { spawn: deps.spawn ?? child_process_1.spawn });
+        }
+        finally {
+            typing?.stop();
+            this.running.delete(session);
+        }
+        slog?.turnEnd(outcome.kind === "completed" ? "completed" : outcome.stopped ? "stopped" : `failed — ${outcome.reason}`);
+        // A fresh start stopped this turn: its messages wait behind the note (minus the note request).
+        const requeueFor = this.requeueOnStop.get(session);
+        if (requeueFor !== undefined) {
+            this.requeueOnStop.delete(session);
+            const keep = (m) => !(0, fresh_start_1.isNoteRequestFor)(m, requeueFor);
+            deps.queue.putBack(session, {
+                addressed: turn.addressed.filter(keep),
+                digest: { messages: turn.digest.messages.filter(keep), omitted: turn.digest.omitted },
+            });
+            deps.log(`codex: ${session} turn stopped for a fresh start — its messages wait for the fresh thread`);
+            return;
+        }
+        if (outcome.kind === "completed") {
+            // A fresh start that landed while this turn ran has already forgotten the old thread.
+            if (!this.freshTurns.has(session) && (this.generation.get(session) ?? 0) === generation) {
+                if (outcome.threadId)
+                    this.allowances.rebind(session, NEW_THREAD, outcome.threadId);
+                deps.registry.setCodexThread(session, outcome.threadId ?? codex.threadId, true);
+            }
+            deps.onDelivered(session, turn.addressed);
+            this.said.delete(session);
+            return;
+        }
+        if (outcome.stopped) {
+            // Stopped by `shutdown`, not by a person: the batch is still owed an answer after restart.
+            if (this.closed) {
+                deps.queue.putBack(session, turn);
+                return;
+            }
+            deps.onPending(session, turn.addressed, "stopped from the chat");
+            return;
+        }
+        if (outcome.threadMissing && !codex.primed && !retried) {
+            // A thread started for this session that Codex never wrote down (no turn completed on it):
+            // start a new one rather than leave the session unable to answer.
+            deps.log(`codex: ${session} thread ${codex.threadId} is gone before its first turn — starting a new one`);
+            deps.registry.setCodexThread(session, undefined);
+            return this.runOne(session, turn, true);
+        }
+        // The raw reason can name paths on that computer: the room (and the pending record, which
+        // BayChat may show) get a plain line, and the full reason goes to the log only.
+        deps.log(`codex: ${session} could not answer — ${outcome.reason}`);
+        return drop("failed", "Codex could not answer this time. The details are in the relay's log on that computer.");
+    }
+}
+exports.CodexSessionRunner = CodexSessionRunner;
+/** The queue a daemon gives its Codex runner. */
+function codexTurnQueue() {
+    return new turn_queue_1.AcpTurnQueue(codexQueuePath());
+}

package/dist/relay/codex-version.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_UPGRADE_HINT = exports.MIN_CODEX_APP_SERVER = void 0;
+exports.codexExecFallback = codexExecFallback;
+exports.codexVersionOf = codexVersionOf;
+exports.codexAppServerReady = codexAppServerReady;
+const runtime_binary_1 = require("../runtime-binary");
+const self_upgrade_1 = require("../self-upgrade");
+const spawn_env_1 = require("./spawn-env");
+/**
+ * The oldest Codex the relay runs over `codex app-server` with approvals as cards (2026-10-23).
+ *
+ * The approval requests, `serverRequest/resolved`, `turn.status` and `thread/compact/start` this
+ * relay speaks are the official 0.160 schema's; app-server is marked [experimental] by OpenAI, so
+ * older builds are not guessed at. Checked at launch and before every turn — the recorded path may
+ * have been replaced or upgraded in place since — never assumed.
+ */
+exports.MIN_CODEX_APP_SERVER = "0.160.0";
+/** The upgrade line every refusal ends with. */
+exports.CODEX_UPGRADE_HINT = "Update it with `npm install -g @openai/codex@latest` (or your package manager), then try again.";
+/** `BAYCHAT_CODEX_TRANSPORT=exec`: the way back to the pre-app-server ladder, with no new release. */
+function codexExecFallback(env = process.env) {
+    return env.BAYCHAT_CODEX_TRANSPORT === "exec";
+}
+/** "codex-cli 0.160.0" → "0.160.0"; a pre-release keeps its numeric part. */
+function codexVersionOf(output) {
+    return /(\d+\.\d+\.\d+)/.exec(output)?.[1];
+}
+/**
+ * Is the Codex at `binaryPath` new enough for app-server approvals? Never throws: a binary that
+ * will not answer `--version`, or answers something unreadable, is not ready.
+ */
+async function codexAppServerReady(binaryPath, probe = (bin) => (0, runtime_binary_1.probeBinaryVersion)(bin, (0, spawn_env_1.headlessSpawnEnv)())) {
+    let probed;
+    try {
+        probed = await probe(binaryPath);
+    }
+    catch (err) {
+        return { ok: false, reason: `${binaryPath} could not be asked its version (${err instanceof Error ? err.message : String(err)}). ${exports.CODEX_UPGRADE_HINT}` };
+    }
+    if (!probed.ok)
+        return { ok: false, reason: `${binaryPath} did not answer \`--version\` (${probed.detail}). ${exports.CODEX_UPGRADE_HINT}` };
+    const version = codexVersionOf(probed.version);
+    const order = version ? (0, self_upgrade_1.compareVersions)(version, exports.MIN_CODEX_APP_SERVER) : undefined;
+    if (!version || order === undefined)
+        return { ok: false, reason: `Codex answered \`--version\` with "${probed.version}", which this relay cannot read. ${exports.CODEX_UPGRADE_HINT}` };
+    if (order < 0)
+        return { ok: false, reason: `Codex ${version} is older than ${exports.MIN_CODEX_APP_SERVER}, which BayChat needs to bring its approvals to your phone. ${exports.CODEX_UPGRADE_HINT}` };
+    return { ok: true, version };
+}