baychat 0.34.0 → 0.34.2

package/dist/relay/daemon.js

@@ -39,8 +39,10 @@ exports.commandTypedReply = commandTypedReply;
 exports.splitSessionCommands = splitSessionCommands;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const net = __importStar(require("net"));
 const path = __importStar(require("path"));
+const api_1 = require("../api");
 const config_1 = require("../config");
 const bay_deleted_1 = require("../bay-deleted");
 const context_report_1 = require("../context-report");
@@ -58,11 +60,15 @@ const daemon_glue_1 = require("./acp/daemon-glue");
 const presence_1 = require("./acp/presence");
 const runner_1 = require("./acp/runner");
 const turn_queue_1 = require("./acp/turn-queue");
+const codex_commands_1 = require("./codex-commands");
+const codex_runner_1 = require("./codex-runner");
 const session_reply_1 = require("./session-reply");
 const channel_sessions_1 = require("./channel-sessions");
 const runtime_binary_1 = require("../runtime-binary");
 const adapters_1 = require("./adapters");
 const parent_watch_1 = require("./parent-watch");
+const codex_app_server_1 = require("./codex-app-server");
+const runtime_limits_1 = require("./runtime-limits");
 const queue_1 = require("./queue");
 const held_1 = require("./held");
 const provider_env_1 = require("./provider-env");
@@ -79,6 +85,10 @@ const loop_1 = require("./launcher/loop");
 const log_line_1 = require("./log-line");
 const handle_1 = require("./launcher/handle");
 const multiplexer_1 = require("./launcher/multiplexer");
+const codex_relay_launch_1 = require("./launcher/codex-relay-launch");
+const relay_identity_1 = require("./launcher/relay-identity");
+const spawn_env_1 = require("./spawn-env");
+const codex_version_1 = require("./codex-version");
 const approval_settings_1 = require("./launcher/approval-settings");
 /**
  * How long a failed resume-id discovery is believed before it is retried.
@@ -94,6 +104,15 @@ class RelayDaemon {
     registry = new registry_1.SessionRegistry();
     acpQueue = new turn_queue_1.AcpTurnQueue();
     acp;
+    /** Codex sessions the relay runs itself over `codex app-server`, approvals as cards (codex-runner.ts). */
+    codexQueue = (0, codex_runner_1.codexTurnQueue)();
+    codex;
+    /** Relay-run Codex sessions already told, this relay run, that exec mode keeps them silent. */
+    codexFallbackSaid = new Set();
+    codexAsk;
+    codexEntryConfigured;
+    /** The app-server version gate (codex-version.ts); a seam so tests never run `codex --version`. */
+    codexReady;
     acpAlive;
     /** The device MCP connection the relay joins its own (ACP) sessions with (tests inject one). */
     acpCallerFn;
@@ -101,6 +120,8 @@ class RelayDaemon {
     context;
     /** Reads each Codex session's own rollout for its context numbers. */
     codexContext;
+    /** The Codex account's plan limits, every 10 minutes (TERMINAL_CREDITS.md). */
+    codexLimits;
     /** The room each session was last woken in — where its context numbers belong. */
     lastRoom = new Map();
     /** Project briefs whose own message was a session command, waiting for the next chat message. */
@@ -231,6 +252,8 @@ class RelayDaemon {
                 if (relayRun)
                     return this.log(`mailbox registration ignored: ${relayRun}`);
                 this.registry.upsert((0, mailbox_1.registrationToTarget)(reg));
+                // A registration starts over: nothing allowed "for this session" before it carries on.
+                this.codex.forgetAllowances(reg.session);
                 // A session that names itself supersedes anything discovery guessed,
                 // exactly as an attach frame does.
                 if (reg.resumeId)
@@ -284,6 +307,20 @@ class RelayDaemon {
             conversationFor: (session) => this.lastRoom.get(session),
             log: (line) => this.log(line),
         });
+        this.codexLimits = new runtime_limits_1.CodexLimitsPoller({
+            sessions: () => this.registry
+                .all()
+                .filter((t) => t.runtime === "codex" && (t.attached || this.liveSessions.includes(t.name)))
+                .map((t) => t.name),
+            binary: () => {
+                const codex = this.binaryFor("codex");
+                return codex.ok ? codex.path : undefined;
+            },
+            read: (binaryPath) => (0, codex_app_server_1.readCodexRateLimits)(binaryPath, { spawn: child_process_1.spawn }),
+            auth: () => this.auth,
+            request: api_1.apiRequest,
+            log: (line) => this.log(line),
+        });
         this.acpCallerFn = opts.acpCaller ?? presence_1.deviceMcpCaller;
         this.acpAlive = (0, daemon_glue_1.acpKeepAliveScheduler)(() => (0, daemon_glue_1.keepAcpSessionsAlive)({ registry: this.registry, auth: this.auth, caller: opts.acpCaller, log: this.log }));
         this.acp = new runner_1.AcpSessionRunner({
@@ -303,6 +340,36 @@ class RelayDaemon {
             binaryVersion: opts.acpBinaryVersion,
             reportContext: (session, event) => this.reportContext(session, event),
         });
+        this.codexAsk = opts.codexAsk;
+        this.codexEntryConfigured = opts.codexEntryConfigured;
+        this.codexReady = opts.codexReady ?? ((bin) => (0, codex_version_1.codexAppServerReady)(bin));
+        this.codex = new codex_runner_1.CodexSessionRunner({
+            registry: this.registry,
+            queue: this.codexQueue,
+            auth: () => this.auth,
+            binary: () => {
+                const codex = this.binaryFor("codex");
+                return codex.ok ? { ok: true, path: codex.path } : { ok: false, reason: (0, runtime_binary_1.summarizeResolutionFailure)(codex) };
+            },
+            say: async (conversationId, session, text) => {
+                if (this.auth)
+                    await (0, session_reply_1.postSessionReply)(this.auth, conversationId, session, text);
+            },
+            log: (line) => this.log(line),
+            onDelivered: (session, batch) => this.record({ kind: "woken", via: "codex", session }, session, batch),
+            onPending: (session, batch, reason) => this.record({ kind: "pending", session, reason }, session, batch),
+            spawn: child_process_1.spawn,
+            runTurn: opts.codexRunTurn,
+            runCompact: opts.codexRunCompact,
+            askPhoneChoice: opts.codexAsk,
+            caller: opts.acpCaller,
+            // This relay's Bay: `baychat`, or the `baychat-<bay>` a per-Bay relay was started for.
+            mcpEntry: (0, bay_relays_1.relayMcpEntry)(),
+            entryConfigured: opts.codexEntryConfigured,
+            ready: this.codexReady,
+        });
+        // Whatever the relay forgets about a session, its "Allow for this session" answers go with it.
+        this.registry.onForget = (name) => this.codex.forgetAllowances(name);
     }
     async start() {
         // The DEVICE credential, not an agent token. A laptop has one device login
@@ -327,6 +394,7 @@ class RelayDaemon {
         // handed what the previous one was holding rather than a clean slate.
         this.held.load();
         this.acpQueue.load();
+        this.codexQueue.load();
         // A clear that was being typed when the previous relay stopped: the session may well have been
         // cleared, so it is reported cleared-but-not-pointed (the server re-arms it), never left to
         // time out as "not cleared".
@@ -364,6 +432,7 @@ class RelayDaemon {
         // After the socket is ours: a relay refused as a duplicate must not keep sessions alive.
         this.acpKeepAlive = (0, daemon_glue_1.startAcpUpkeep)(this.acpAlive.run);
         this.codexContext.start();
+        this.codexLimits.start();
         if (!(0, bay_relays_1.isBayRelayChild)()) {
             // Never awaited and never fatal: the launcher retries its own network failures until stop().
             void this.startLauncherFn({
@@ -393,6 +462,29 @@ class RelayDaemon {
                     stop: (name) => (0, acp_launch_1.stopAcpSession)(name, { registry: this.registry, abort: (n) => void this.acp.stop(n), log: (line) => this.log(line) }),
                     running: () => (0, acp_launch_1.launchedAcpSessions)(this.registry),
                 },
+                // Codex started from the app: run here over app-server, its approvals as cards.
+                codex: {
+                    start: (launch) => (0, codex_relay_launch_1.launchCodexRelaySession)(launch, {
+                        registry: this.registry,
+                        log: (line) => this.log(line),
+                        resolveBinary: this.resolveBinary,
+                        caller: () => (this.auth ? this.acpCallerFn(this.auth) : undefined),
+                        ready: this.codexReady,
+                        viewer: {
+                            multiplexer: (0, multiplexer_1.detectMultiplexer)(multiplexer_1.realRun),
+                            run: multiplexer_1.realRun,
+                            cli: (0, approval_settings_1.currentCliLaunch)(),
+                            env: { ...(0, relay_identity_1.relayIdentityEnv)(), PATH: (0, spawn_env_1.headlessSpawnEnv)().PATH ?? "" },
+                        },
+                    }),
+                    stop: (name) => (0, codex_relay_launch_1.stopCodexSession)(name, {
+                        registry: this.registry,
+                        end: (n) => this.codex.end(n),
+                        log: (line) => this.log(line),
+                        viewer: { multiplexer: (0, multiplexer_1.detectMultiplexer)(multiplexer_1.realRun), run: multiplexer_1.realRun },
+                    }),
+                    running: () => (0, codex_relay_launch_1.launchedCodexSessions)(this.registry),
+                },
             }).catch((err) => this.log(`launcher stopped: ${err instanceof Error ? err.message : String(err)}`));
         }
         this.log(`listening on ${sockPath} (pid ${process.pid}) as device "${device.user.name}"`);
@@ -547,10 +639,13 @@ class RelayDaemon {
         if (command.id === "compact") {
             if (compact.refusal)
                 return say(compact.refusal);
-            if (target.acp) {
+            if (target.acp && !target.codex) {
                 return say(`"${session}" is run by the relay and tidies its own memory; /compact cannot reach it. /new starts it fresh.`);
             }
         }
+        // A Codex the relay runs: /compact /stop /status /new /clear /exit mean what its runner can do.
+        if (await (0, codex_commands_1.runCodexSessionCommand)(this.codex, session, target, message, command, say))
+            return;
         // `/mode-*`, `/stop`, and what `/status` `/exit` `/clear` `/new` mean with no terminal.
         if (await (0, commands_1.runAcpSessionCommand)(this.acp, session, target, message, command, say))
             return;
@@ -691,8 +786,11 @@ class RelayDaemon {
             // running now is stopped and its messages wait behind the note (acp/runner.ts).
             done();
             this.forgetCarried(session);
-            this.acp.freshStart(session, (0, fresh_start_1.freshStartMessage)(message, fresh), fresh.handoffId);
-            this.log(`fresh start ${fresh.handoffId}: ${session} will start a new ACP session from its note`);
+            if (target.codex)
+                this.codex.freshStart(session, (0, fresh_start_1.freshStartMessage)(message, fresh), fresh.handoffId);
+            else
+                this.acp.freshStart(session, (0, fresh_start_1.freshStartMessage)(message, fresh), fresh.handoffId);
+            this.log(`fresh start ${fresh.handoffId}: ${session} will start a new ${target.codex ? "Codex thread" : "ACP session"} from its note`);
             await report({ handoffId: fresh.handoffId, status: "fresh" });
             return;
         }
@@ -884,7 +982,7 @@ class RelayDaemon {
         // carried it always precedes the session's first event, but checking a thread id reads
         // the disk. Wait for it rather than drop a message for a session we are registering.
         await this.serverRegistrations.get(session);
-        const target = this.registry.get(session);
+        let target = this.registry.get(session);
         if (!target) {
             // NOT reported as pending, though an earlier version of this did.
             //
@@ -969,6 +1067,34 @@ class RelayDaemon {
             this.acp.handle(session, batch);
             return;
         }
+        if (target.codex) {
+            if (!(0, codex_version_1.codexExecFallback)()) {
+                // Codex run by the relay over app-server (codex-runner.ts): the same shape as ACP — filed,
+                // and run by its own drain loop, so this lock is free again for a `/stop`.
+                this.codex.handle(session, batch);
+                return;
+            }
+            // BAYCHAT_CODEX_TRANSPORT=exec: a `codex exec` turn runs `--ask-for-approval never`, which
+            // also blocks Codex's own BayChat replies — measured 2026-10-23, the turn ran and nothing
+            // came back. So it is not run: the room is told once why, and the messages are held
+            // (pending) for when the relay is back on app-server. A Codex at its keyboard (no
+            // `target.codex`) keeps the old ladder.
+            const reason = `Codex is in fallback mode on ${os.hostname()} (BAYCHAT_CODEX_TRANSPORT=exec) and can't answer here`;
+            this.log(`codex: ${session} not woken — ${reason}`);
+            if (this.auth && !this.codexFallbackSaid.has(session)) {
+                this.codexFallbackSaid.add(session);
+                for (const conversationId of new Set(batch.map((m) => m.conversationId))) {
+                    try {
+                        await (0, session_reply_1.postSessionReply)(this.auth, conversationId, session, `${reason}. Messages wait until the relay there runs without BAYCHAT_CODEX_TRANSPORT=exec.`);
+                    }
+                    catch (err) {
+                        this.log(`codex: could not tell ${conversationId} that ${session} is in fallback mode: ${errText(err)}`);
+                    }
+                }
+            }
+            this.record({ kind: "pending", session, reason }, session, batch);
+            return;
+        }
         const adapter = (0, adapters_1.adapterFor)(target.runtime);
         // ORDERED ABOVE THE FIFO, deliberately.
         //
@@ -990,7 +1116,7 @@ class RelayDaemon {
         // write path: observed 2026-08-31, a headlessly-woken Codex read the room
         // and was structurally unable to answer it.
         const resolvedForQueue = await this.resolveResume(target);
-        if (adapter.queueMessage && resolvedForQueue.resumeId) {
+        if (adapter.queueMessage && resolvedForQueue.resumeId && !target.codex) {
             // Same rule as the headless spawn: an ABSOLUTE runtimeBin came from the
             // session itself and is never re-resolved; only a bare name is looked up.
             const declared = resolvedForQueue.runtimeBin ?? target.runtime;
@@ -1282,10 +1408,14 @@ class RelayDaemon {
                 ? (input) => this.runTurn({ runtime: target.runtime, ...input })
                 : adapter.runTurn?.bind(adapter);
             if (richTransport) {
+                // Only a Codex turn that can ask waits for the version probe; every other turn starts as
+                // soon as it always did.
+                const approvals = target.runtime === "codex" && this.auth && !(0, codex_version_1.codexExecFallback)() ? await this.headlessCodexApprovals(session, batch, target, executable) : {};
                 const outcome = await richTransport({
                     binaryPath: executable,
                     target: resolved,
                     prompt,
+                    ...approvals,
                 });
                 if (outcome.kind === "completed") {
                     this.record({ kind: "woken", via: "headless", session, exitCode: 0 }, session, batch);
@@ -1295,6 +1425,13 @@ class RelayDaemon {
                     this.record({ kind: "pending", session, reason: outcome.reason }, session, batch);
                     return;
                 }
+                if (approvals.policy) {
+                    // This turn was given a policy — read only for a sender without command access, cards
+                    // for everyone else. `codex exec resume` can honour neither, and a turn that may already
+                    // have asked (and been answered) must not run a second time with other rules. Pending.
+                    this.record({ kind: "pending", session, reason: `Codex stopped before the turn finished (${outcome.reason}); not retried without its approval rules` }, session, batch);
+                    return;
+                }
                 this.log(`${target.runtime}: falling back to a plain spawn — ${outcome.reason}`);
             }
             // A Windows .cmd needs its interpreter named explicitly, whatever produced
@@ -1336,6 +1473,48 @@ class RelayDaemon {
             // `.finally`, which owns it for exactly as long as this turn runs.
         }
     }
+    /**
+     * A terminal-registered Codex woken headlessly (`thread/resume` while its terminal is closed)
+     * asks its approvals the way a relay-run one does (codex-runner.ts): the owner (or a grantee)
+     * woke it → `on-request` in a no-network workspace sandbox, every approval a card in the room
+     * that woke it; anyone else → read only, no cards. Nothing for another runtime, or when this
+     * relay is not logged in (the turn then runs `never`, as it always did).
+     */
+    async headlessCodexApprovals(session, batch, target, executable) {
+        const auth = this.auth;
+        if (target.runtime !== "codex" || !auth || (0, codex_version_1.codexExecFallback)())
+            return {};
+        // A Codex too old for the 0.160 approval protocol keeps the turn it always had: `never`.
+        const ready = await this.codexReady(executable);
+        if (!ready.ok) {
+            this.log(`codex: ${session} headless turn runs without cards — ${ready.reason}`);
+            return {};
+        }
+        const entry = (0, bay_relays_1.relayMcpEntry)();
+        const { allAuthorized, policy } = (0, codex_runner_1.codexTurnPolicyFor)(batch, entry, this.codexEntryConfigured);
+        return {
+            policy,
+            onApproval: (0, codex_runner_1.codexApprovalHandler)({
+                auth,
+                session,
+                room: batch.at(-1).conversationId,
+                allAuthorized,
+                entry,
+                host: os.hostname(),
+                // Keyed by the thread being resumed: another thread under this name starts with nothing.
+                allow: this.codex.allowListFor(session, target.resumeId ?? ""),
+                cwd: target.resumeCwd ?? target.cwd,
+                log: (line) => this.log(line),
+                ask: this.codexAsk,
+            }),
+            onNotification: (method, params) => {
+                const dropped = this.codex.noteNotification(session, method, params);
+                if (dropped > 0)
+                    this.log(`codex: ${session} files changed under ${dropped} command(s) allowed for this session — they will be asked again`);
+            },
+            log: (line) => this.log(`codex: ${session} ${line}`),
+        };
+    }
     /**
      * The proven executable for a runtime, resolved at most once per process
      * until something gives us reason to doubt it.
@@ -1434,6 +1613,8 @@ class RelayDaemon {
      * displaces any socket holding the name, exactly as a newer local attach would.
      */
     recordAttach(frame, sock) {
+        // A (re-)registration starts over: nothing allowed "for this session" before it carries on.
+        this.codex.forgetAllowances(frame.session);
         this.registry.upsert({
             name: frame.session,
             runtime: frame.runtime,
@@ -1752,7 +1933,7 @@ class RelayDaemon {
         return {
             deliveries: this.queue.activeSessions(),
             headless: [...this.headlessInFlight],
-            acp: this.acp.activeSessions(),
+            acp: [...this.acp.activeSessions(), ...this.codex.activeSessions()],
             heldAt: this.held.summary().map((h) => h.heldAt),
             launching: this.launching,
             lastActivityAt: this.lastActivityAt,
@@ -1771,8 +1952,10 @@ class RelayDaemon {
         clearInterval(this.acpKeepAlive);
         this.launcherAbort.abort();
         this.codexContext.stop();
+        this.codexLimits.stop();
         this.context.close();
         this.acp.shutdown();
+        this.codex.shutdown();
         this.abort.abort();
         for (const sock of this.attached.values())
             sock.destroy();
@@ -1782,6 +1965,7 @@ class RelayDaemon {
         this.channels.clear();
         await this.queue.idle();
         await this.acp.idle();
+        await this.codex.idle();
         for (const w of this.mailboxWatchers)
             w.stop();
         await new Promise((resolve) => this.server ? this.server.close(() => resolve()) : resolve());

package/dist/relay/fresh-start.js

@@ -72,7 +72,8 @@ function parseFreshStart(message) {
 }
 /** How this relay would clear this session — decided BEFORE the note is asked for. */
 function freshStartPlan(target) {
-    if (target.acp)
+    // Run by the relay (ACP, or Codex over app-server): no terminal — the runner starts it fresh.
+    if (target.acp || target.codex)
         return { kind: "acp" };
     if (target.runtime === "claude" || target.runtime === "codex") {
         if (!target.pane)

package/dist/relay/launcher/capabilities.js

@@ -47,25 +47,40 @@ const MACHINE_MAX = 64;
 const VERSION_MAX = 64;
 /**
  * Build the capabilities. A missing policy offers no spots; a spot whose runtimes are all
- * missing is left out entirely, since the app could not start anything there.
+ * missing is not offered — the app could not start anything there — and `onUnavailable` hears
+ * which one and why.
  */
 function buildCapabilities(policy, deps) {
     const resolved = new Map();
-    const versionOf = (runtime) => {
-        if (!resolved.has(runtime)) {
-            const r = deps.resolveBinary(exports.RUNTIME_BINARY[runtime]);
-            resolved.set(runtime, r.ok ? r.version.split("\n")[0].trim().slice(0, VERSION_MAX) || null : undefined);
+    const resolutionOf = (runtime) => {
+        let r = resolved.get(runtime);
+        if (!r) {
+            r = deps.resolveBinary(exports.RUNTIME_BINARY[runtime]);
+            resolved.set(runtime, r);
         }
-        return resolved.get(runtime);
+        return r;
     };
     const spots = [];
     for (const spot of policy?.spots ?? []) {
         const runtimes = spot.runtimes.flatMap((name) => {
-            const version = versionOf(name);
-            return version === undefined ? [] : [{ name, version }];
+            const r = resolutionOf(name);
+            return r.ok ? [{ name, version: r.version.split("\n")[0].trim().slice(0, VERSION_MAX) || null }] : [];
         });
-        if (runtimes.length > 0)
+        if (runtimes.length > 0) {
             spots.push({ id: spot.id, label: spot.label, runtimes });
+            continue;
+        }
+        const runtime = spot.runtimes[0];
+        if (!runtime)
+            continue;
+        const r = resolutionOf(runtime);
+        const missing = {
+            id: spot.id,
+            label: spot.label,
+            runtime,
+            reason: !r.ok && r.rejected.length > 0 ? "RUNTIME_BROKEN" : "RUNTIME_NOT_FOUND",
+        };
+        deps.onUnavailable?.(missing, r.ok ? "" : r.reason);
     }
     return {
         machine: (deps.hostname ?? os.hostname()).replace(/\.local$/, "").slice(0, MACHINE_MAX) || "computer",

package/dist/relay/launcher/codex-launch.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CODEX_ROOM_ID_RE = exports.CODEX_UNATTENDED_FLAGS = void 0;
 exports.codexConfigPath = codexConfigPath;
+exports.codexConfigHasEntry = codexConfigHasEntry;
 exports.codexLaunchProblem = codexLaunchProblem;
 exports.readCodexConfig = readCodexConfig;
 const fs = __importStar(require("fs"));
@@ -81,12 +82,18 @@ function escapeRe(text) {
  * as text: two table headers and one key are all it needs, and a TOML parser would be a new
  * dependency for that.
  */
+/** Does Codex's config.toml have an `[mcp_servers.<entry>]` table? A config override for an entry
+ *  that is not there would CREATE a partial one — never do that. */
+function codexConfigHasEntry(config, entry) {
+    if (!config)
+        return false;
+    return new RegExp(`^\\s*\\[mcp_servers\\.(?:${escapeRe(entry)}|"${escapeRe(entry)}")\\]\\s*$`, "m").test(config);
+}
 function codexLaunchProblem(folder, readConfig, 
 /** The MCP connection the prompt names (`baychat`, or `baychat-<bay>` on a computer with several). */
 entry = "baychat") {
     const config = readConfig();
-    const server = new RegExp(`^\\s*\\[mcp_servers\\.(?:${escapeRe(entry)}|"${escapeRe(entry)}")\\]\\s*$`, "m");
-    if (!config || !server.test(config))
+    if (!config || !codexConfigHasEntry(config, entry))
         return "RUNTIME_NOT_CONNECTED";
     // `[projects."/path"]` (or single-quoted) followed, before the next table, by trust_level = "trusted".
     const table = new RegExp(`^\\s*\\[projects\\.(?:"${escapeRe(folder)}"|'${escapeRe(folder)}')\\]\\s*$([^\\[]*)`, "m");

package/dist/relay/launcher/codex-relay-launch.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexViewerArgv = codexViewerArgv;
+exports.launchCodexRelaySession = launchCodexRelaySession;
+exports.launchedCodexSessions = launchedCodexSessions;
+exports.stopCodexSession = stopCodexSession;
+const presence_1 = require("../acp/presence");
+const multiplexer_launch_1 = require("../../multiplexer-launch");
+const argv_1 = require("./argv");
+const multiplexer_1 = require("./multiplexer");
+const refused = (reason) => ({ status: "REFUSED", reason });
+/** The viewer's command: our own CLI, `relay log <name> -f`, as argv for a detached tmux session. */
+function codexViewerArgv(session, folder, cli, env) {
+    return (0, multiplexer_launch_1.multiplexerArgv)("tmux", { kind: "detached", name: (0, argv_1.multiplexerSessionName)(session), cwd: folder }, { binary: cli.node, args: [cli.entry, "relay", "log", session, "-f"], env });
+}
+async function launchCodexRelaySession(launch, deps) {
+    if (deps.registry.get(launch.session)) {
+        deps.log(`launch ${launch.launchId}: refused, "${launch.session}" is already a session on this computer`);
+        return refused(deps.registry.get(launch.session)?.codex ? "NAME_TAKEN" : "NAME_TAKEN_FOREIGN");
+    }
+    const viewer = deps.viewer;
+    if (viewer?.multiplexer === "tmux" && (0, multiplexer_1.launchSessionExists)("tmux", launch.session, viewer.run)) {
+        deps.log(`launch ${launch.launchId}: refused, a tmux session ${(0, argv_1.multiplexerSessionName)(launch.session)} is already running here`);
+        return refused("NAME_TAKEN_FOREIGN");
+    }
+    const binary = deps.resolveBinary("codex");
+    if (!binary.ok)
+        return refused("RUNTIME_MISSING");
+    const ready = await deps.ready?.(binary.path);
+    if (ready && !ready.ok) {
+        deps.log(`launch ${launch.launchId}: refused, ${ready.reason}`);
+        return refused("RUNTIME_TOO_OLD");
+    }
+    const caller = deps.caller();
+    if (!caller)
+        return refused("BAY_NOT_CONNECTED");
+    const room = !launch.join || "direct" in launch.join ? undefined : launch.join;
+    try {
+        await (0, presence_1.joinSession)(caller, launch.session, room);
+    }
+    catch (err) {
+        deps.log(`launch ${launch.launchId}: ${launch.session} could not join BayChat (${err instanceof Error ? err.message : String(err)})`);
+        return { status: "FAILED", reason: "JOIN_FAILED" };
+    }
+    deps.registry.upsert({
+        name: launch.session,
+        runtime: "codex",
+        runtimeBin: binary.path,
+        relayOwned: true,
+        launchedBy: launch.launchId,
+        // No thread yet: the first turn starts one (see the file header).
+        codex: { cwd: launch.folder },
+    });
+    if (viewer?.multiplexer === "tmux") {
+        const res = viewer.run("tmux", codexViewerArgv(launch.session, launch.folder, viewer.cli, viewer.env), { cwd: launch.folder, env: viewer.env });
+        if (res.error || res.status !== 0)
+            deps.log(`launch ${launch.launchId}: no viewer for "${launch.session}" (${res.error?.message ?? (res.stderr.trim() || `exit ${res.status}`)}); \`baychat relay log ${launch.session} -f\` shows it`);
+    }
+    deps.log(`launch ${launch.launchId}: started "${launch.session}" (Codex, run by the relay, approvals on the phone) in ${launch.folder}; its first message starts its Codex thread`);
+    return { status: "STARTED" };
+}
+/** The relay-run Codex sessions the app started that are still registered, for the launch caps. */
+function launchedCodexSessions(registry) {
+    return registry.all().flatMap((t) => (t.relayOwned && t.codex && t.launchedBy ? [{ name: t.name, cwd: t.codex.cwd }] : []));
+}
+/**
+ * End on a relay-run Codex the app started: stop its turn, forget it (so the keep-alive never
+ * brings it back) and close its viewer. One registered any other way is not ours to end.
+ */
+function stopCodexSession(name, deps) {
+    const target = deps.registry.get(name);
+    if (!target?.relayOwned || !target.codex || !target.launchedBy)
+        return false;
+    deps.end(name);
+    deps.registry.remove(name);
+    if (deps.viewer?.multiplexer === "tmux" && (0, multiplexer_1.launchSessionExists)("tmux", name, deps.viewer.run))
+        (0, multiplexer_1.killLaunchSession)("tmux", name, deps.viewer.run);
+    deps.log(`codex: ${name} ended from BayChat; the relay no longer runs it`);
+    return true;
+}