baychat 0.21.5 → 0.22.0

package/dist/relay/daemon.js

@@ -34,10 +34,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelayDaemon = void 0;
+exports.splitSessionCommands = splitSessionCommands;
+const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
 const path = __importStar(require("path"));
 const config_1 = require("../config");
+const session_commands_1 = require("./session-commands");
+const terminal_pane_1 = require("./terminal-pane");
+const commands_1 = require("./acp/commands");
+const daemon_glue_1 = require("./acp/daemon-glue");
+const runner_1 = require("./acp/runner");
+const turn_queue_1 = require("./acp/turn-queue");
+const session_reply_1 = require("./session-reply");
 const runtime_binary_1 = require("../runtime-binary");
 const adapters_1 = require("./adapters");
 const parent_watch_1 = require("./parent-watch");
@@ -60,6 +69,10 @@ const watermarks_1 = require("./watermarks");
 const DISCOVERY_INTERVAL_MS = 10 * 60_000;
 class RelayDaemon {
     registry = new registry_1.SessionRegistry();
+    acpQueue = new turn_queue_1.AcpTurnQueue();
+    acp;
+    acpAlive;
+    acpKeepAlive;
     queue;
     abort = new AbortController();
     /** Live attach sockets by session name. */
@@ -83,6 +96,8 @@ class RelayDaemon {
     liveSessions = [];
     /** Why discovery last refused, per session, and when — throttles the rescan. */
     discoveryReasons = new Map();
+    /** Set at `start()`. Undefined only before the daemon is running. */
+    auth;
     discovery;
     spawnHeadless;
     isAlive;
@@ -145,6 +160,11 @@ class RelayDaemon {
         this.mailboxWatchers = (0, mailbox_1.mailboxRootCandidates)().map((root) => new mailbox_watcher_1.MailboxWatcher({
             root,
             onRegister: (reg) => {
+                // A relay-run session's program is the daemon's to choose (Ruling R32): `upsert`
+                // merges, so a mailbox file would keep `acp` and swap the binary the runner spawns.
+                const relayRun = (0, daemon_glue_1.acpAttachRefusal)(this.registry, reg.session);
+                if (relayRun)
+                    return this.log(`mailbox registration ignored: ${relayRun}`);
                 this.registry.upsert((0, mailbox_1.registrationToTarget)(reg));
                 // A session that names itself supersedes anything discovery guessed,
                 // exactly as an attach frame does.
@@ -185,6 +205,22 @@ class RelayDaemon {
             this.lastError = `delivery failed for ${session}: ${errText(err)}`;
             this.log(this.lastError);
         });
+        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({
+            registry: this.registry,
+            queue: this.acpQueue,
+            auth: () => this.auth,
+            spawn: child_process_1.spawn,
+            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: "acp", session }, session, batch),
+            onPending: (session, batch, reason) => this.record({ kind: "pending", session, reason }, session, batch),
+            runTurn: opts.acpRunTurn,
+            caller: opts.acpCaller,
+        });
     }
     async start() {
         // The DEVICE credential, not an agent token. A laptop has one device login
@@ -199,11 +235,16 @@ class RelayDaemon {
             throw new Error(`device credential expired ${device.expiresAt} — run \`npx baychat login\``);
         }
         const auth = { baseUrl: device.baseUrl, token: device.token };
+        // Kept for session-command replies. Every other API call the daemon makes is inside
+        // the feed, which closes over `auth`; a command's reply happens in `deliver`, which
+        // does not.
+        this.auth = auth;
         this.registry.load();
         // Held messages outlive the process that held them. Loaded before the socket
         // opens, so a session that re-arms in the first moments of a new daemon is
         // handed what the previous one was holding rather than a clean slate.
         this.held.load();
+        this.acpQueue.load();
         const sockPath = (0, socket_1.socketPath)();
         if (await (0, socket_1.probeSocket)(sockPath)) {
             throw new Error(`a relay is already listening on ${sockPath} — run \`baychat relay status\``);
@@ -229,6 +270,8 @@ class RelayDaemon {
             });
         });
         writePidFile();
+        // 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.log);
         this.log(`listening on ${sockPath} (pid ${process.pid}) as device "${device.user.name}"`);
         this.log(`${this.registry.all().length} known session target(s)`);
         // The event SOURCE is pluggable (socket preferred, long-poll floor); every
@@ -249,6 +292,7 @@ class RelayDaemon {
                 const dropped = this.registry.pruneToLive(names);
                 for (const name of dropped)
                     this.log(`session ended server-side, dropped: ${name}`);
+                void this.acpAlive.lapsed(this.registry, names);
             },
             onPoll: (cursor) => {
                 this.cursor = cursor;
@@ -329,6 +373,96 @@ class RelayDaemon {
             this.log(`delivered ${room.messages.length} held message(s) to ${session} in ${room.conversationId} on re-attach`);
         }
     }
+    /**
+     * Run one session command and say in the room what happened.
+     *
+     * ── EVERY PATH REPLIES, INCLUDING EVERY REFUSAL ───────────────────────────────────────
+     * A command produces no agent turn, so silence is the only thing the sender can tell
+     * apart from silence. A refusal that names its reason is the whole difference between
+     * "this feature is broken" and "start your agent inside tmux".
+     */
+    async runSessionCommand(session, message, command) {
+        const say = async (text) => {
+            if (!this.auth)
+                return;
+            try {
+                await (0, session_reply_1.postSessionReply)(this.auth, message.conversationId, session, text);
+            }
+            catch (err) {
+                // Never an empty catch: a command that ran and could not say so is exactly the
+                // state this reply exists to prevent, so it has to be visible somewhere.
+                this.log(`could not report ${command.trigger} for ${session}: ${errText(err)}`);
+            }
+        };
+        const target = this.registry.get(session);
+        if (!target) {
+            await say(`This relay does not know a session called "${session}" on this machine.`);
+            return;
+        }
+        this.log(`session command ${command.trigger} for ${session} from ${message.senderId}`);
+        if (command.id === "help") {
+            await say((0, session_commands_1.sessionCommandHelp)());
+            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;
+        if (command.id === "status") {
+            const where = target.pane
+                ? target.pane.kind === "tmux"
+                    ? `tmux pane ${target.pane.pane}`
+                    : target.pane.kind
+                : "no multiplexer — /clear and /new cannot reach it";
+            await say([
+                `Session "${session}"`,
+                `  runtime: ${target.runtime}`,
+                `  terminal: ${where}`,
+                `  attached: ${target.attached ? `yes (${target.transport ?? "socket"})` : "no"}`,
+                `  can resume: ${target.resumeId ? `yes (${target.resumeSource ?? "recorded"})` : "no"}`,
+            ].join("\n"));
+            return;
+        }
+        if (command.id === "exit") {
+            // DETACH, never kill. Ending somebody's terminal agent from a phone is not a thing
+            // the relay should be able to do by itself, and "stop being reachable" is the part it
+            // genuinely owns and can undo. The reply says which one happened, because "exit" will
+            // read to most people as the other one.
+            const sock = this.attached.get(session);
+            if (sock && !sock.destroyed)
+                sock.end();
+            this.attached.delete(session);
+            this.mailboxes.delete(session);
+            this.registry.setAttached(session, false);
+            await say(`"${session}" is no longer reachable from the Bay. Its terminal is untouched and still open — run the join command there to bring it back.`);
+            return;
+        }
+        // What is left types into the terminal.
+        if (!target.pane) {
+            await say((0, session_commands_1.noTerminalReason)());
+            return;
+        }
+        const keys = command.keys?.(target.runtime);
+        if (!keys) {
+            await say(`${command.trigger} has nothing to type for a ${target.runtime} session.`);
+            return;
+        }
+        // `ownerPid` is how a SCREEN session is verified — screen cannot be asked what is
+        // running in a window, so the question goes to the process instead. tmux ignores it and
+        // asks tmux.
+        const typed = await (0, terminal_pane_1.typeIntoPane)(target.pane, target.runtime, keys, {
+            ownerPid: target.ownerPid,
+        });
+        if (!typed.ok) {
+            await say((0, session_commands_1.noTerminalReason)(`${command.trigger} could not run: ${typed.reason}`));
+            return;
+        }
+        if (command.id === "clear" || command.id === "new") {
+            // See `SessionRegistry.clearResume`: the live session's transcript is gone, so the
+            // recorded resume id now points at something no half of this session has.
+            this.registry.clearResume(session);
+        }
+        await say(`Typed ${keys} into "${session}". Its context is cleared.`);
+    }
     /**
      * Wait for a session to re-arm its socket, up to `graceMs`.
      *
@@ -353,6 +487,20 @@ class RelayDaemon {
      * flight for the same session at once.
      */
     async deliver(session, batch) {
+        // COMMANDS FIRST, and separated from chat rather than chosen between.
+        //
+        // A batch is coalesced, so it can hold a command and a sentence at once. Dropping the
+        // sentence would lose a message; handing the command to the agent would ask a MODEL to
+        // obey something its HARNESS owns — `/clear` is read by the runtime's TUI, and no model
+        // can run it for itself. So the commands are executed here and everything else wakes
+        // the session exactly as it always did.
+        const { commands, chat } = splitSessionCommands(batch);
+        for (const { message, command } of commands) {
+            await this.runSessionCommand(session, message, command);
+        }
+        if (chat.length === 0)
+            return;
+        batch = chat;
         const target = this.registry.get(session);
         if (!target) {
             // NOT reported as pending, though an earlier version of this did.
@@ -432,6 +580,12 @@ class RelayDaemon {
                 }
             }
         }
+        if (target.acp) {
+            // The relay drives this session itself: no attach to wait for, no resume id to discover.
+            // The runner files the batch and returns at once, so this lock is free again for a `/stop`.
+            this.acp.handle(session, batch);
+            return;
+        }
         const adapter = (0, adapters_1.adapterFor)(target.runtime);
         // ORDERED ABOVE THE FIFO, deliberately.
         //
@@ -882,6 +1036,9 @@ class RelayDaemon {
         let session;
         const read = (0, socket_1.createFrameReader)((frame) => {
             if (frame.type === "attach") {
+                const relayRun = (0, daemon_glue_1.acpAttachRefusal)(this.registry, frame.session);
+                if (relayRun)
+                    return void (0, socket_1.writeFrame)(sock, { type: "error", message: relayRun });
                 if (frame.delivery === "queue" &&
                     (frame.runtime !== "codex" || !frame.resumeId || !frame.runtimeBin)) {
                     (0, socket_1.writeFrame)(sock, {
@@ -902,6 +1059,7 @@ class RelayDaemon {
                     cwd: frame.cwd,
                     runtimeBin: frame.runtimeBin,
                     ownerPid: frame.ownerPid,
+                    pane: frame.pane,
                     providerUrl: frame.providerUrl,
                     providerVar: frame.providerVar,
                 });
@@ -953,6 +1111,11 @@ class RelayDaemon {
                 (0, socket_1.writeFrame)(sock, { type: "status-result", status: this.status() });
                 return;
             }
+            if (frame.type === "acp-register") {
+                const result = (0, daemon_glue_1.registerAcpFrame)(frame, { registry: this.registry, log: this.log, resolveBinary: this.resolveBinary });
+                (0, socket_1.writeFrame)(sock, result.ok ? { type: "status-result", status: this.status() } : { type: "error", message: result.message });
+                return;
+            }
             if (frame.type === "stop") {
                 this.log("stop requested over socket");
                 (0, socket_1.writeFrame)(sock, { type: "status-result", status: this.status() });
@@ -1000,11 +1163,14 @@ class RelayDaemon {
         };
     }
     async stop() {
+        clearInterval(this.acpKeepAlive);
+        this.acp.shutdown();
         this.abort.abort();
         for (const sock of this.attached.values())
             sock.destroy();
         this.attached.clear();
         await this.queue.idle();
+        await this.acp.idle();
         for (const w of this.mailboxWatchers)
             w.stop();
         await new Promise((resolve) => this.server ? this.server.close(() => resolve()) : resolve());
@@ -1019,6 +1185,35 @@ class RelayDaemon {
     }
 }
 exports.RelayDaemon = RelayDaemon;
+/**
+ * Separate the session commands in a batch from the ordinary chat in it.
+ *
+ * THREE CONDITIONS, ALL REQUIRED, and each closes a different door:
+ *
+ *  - `shouldRespond` — the message is addressed to THIS session. Without it, a `/clear`
+ *    typed into a group chat that the session merely watches would clear it.
+ *  - `commandAuthorized` — the SERVER says this sender may command this session. The relay
+ *    never decides that itself (see `RelayMessage.commandAuthorized`), and an absent field
+ *    is a no, so an older server can only ever under-permit.
+ *  - an exact trigger match — "can you /clear please" is a sentence ABOUT a command and
+ *    must reach the agent as one.
+ *
+ * Anything failing any of them is chat, and wakes the session exactly as it does today.
+ */
+function splitSessionCommands(batch) {
+    const commands = [];
+    const chat = [];
+    for (const message of batch) {
+        const command = message.shouldRespond === true && message.commandAuthorized === true
+            ? (0, session_commands_1.parseSessionCommand)(message.content)
+            : undefined;
+        if (command)
+            commands.push({ message, command });
+        else
+            chat.push(message);
+    }
+    return { commands, chat };
+}
 function writePidFile() {
     try {
         fs.writeFileSync((0, socket_1.pidFilePath)(), String(process.pid), { mode: 0o600 });

package/dist/relay/mailbox.js

@@ -186,6 +186,7 @@ function registrationToTarget(reg) {
         cwd: reg.cwd,
         runtimeBin: reg.runtimeBin,
         ownerPid: reg.ownerPid,
+        pane: reg.pane,
         // Persisted, so a LATER headless resume still knows this session is
         // sandboxed and must be told to re-arm in the foreground. `status()`
         // recomputes the live rung for display; this is the remembered one.

package/dist/relay/profiles.js

@@ -171,6 +171,28 @@ exports.RUNTIME_PROFILES = [
         checked: "2026-08-31",
         source: "https://aider.chat/docs/config/options.html",
     },
+    {
+        id: "dsh",
+        label: "DeepSeek Harness",
+        bin: "dsh",
+        // dsh sets DSH_SESSION_ID for every command the model runs (dsh-shell-env) [source]. This
+        // table's own invariant below restricts `kind: "env"` to a row that has been RUN against a
+        // live session — only `pi` qualifies so far, and this row is `docs`, not `run` (see the
+        // header comment: "Only claude and codex are run"). So the variable is reported here as
+        // `flag-only`, not `env`: dsh's docs show the id exists, but whether a running session can
+        // read its own back and pass it to `--session-id` has not been executed here.
+        sessionId: {
+            kind: "flag-only",
+            how: "DSH_SESSION_ID is set for every command dsh's model runs (dsh-shell-env docs); whether a running session can read its own back to resume itself is unconfirmed.",
+        },
+        // No headless rung (Ruling R27): a headless `dsh --profile headless` turn would run with
+        // dsh's own permissions, outside the modes the relay enforces. dsh is driven by the relay
+        // over ACP instead (`relay/acp/`), which is where its modes live.
+        noHeadlessReason: "DeepSeek Harness is run by the relay over ACP (`baychat connect dsh`), which enforces modes; a terminal dsh session is not woken headlessly.",
+        confidence: "docs",
+        checked: "2026-09-19",
+        source: "https://www.npmjs.com/package/@deepseek-ai/dsh (0.1.5-rc.2, dsh-shell-env + dsh-acp README)",
+    },
     {
         id: "pi",
         label: "Pi",

package/dist/relay/registry.js

@@ -113,6 +113,28 @@ class SessionRegistry {
     get(name) {
         return this.sessions.get(name);
     }
+    /**
+     * Forget how to resume this session — what `/clear` means to the headless path.
+     *
+     * A separate method because `upsert` strips undefined, deliberately: every other caller
+     * is reporting what it LEARNED, and a field it did not learn must not erase one that was.
+     * This caller is the exception — it is reporting what stopped being true.
+     *
+     * Why `/clear` must do this at all: it clears the LIVE session's context by typing into
+     * its terminal, and the recorded `resumeId` still points at the conversation that just
+     * stopped existing. Left in place, a later headless wake would resume a transcript the
+     * live session no longer has — the two halves of one session disagreeing about what was
+     * said, which is worse than either being empty.
+     */
+    clearResume(name) {
+        const existing = this.sessions.get(name);
+        if (!existing)
+            return;
+        delete existing.resumeId;
+        delete existing.resumeSource;
+        delete existing.resumeEvidence;
+        this.save();
+    }
     all() {
         return [...this.sessions.values()];
     }
@@ -141,12 +163,17 @@ class SessionRegistry {
      *
      * Attached sessions are never pruned: a live socket outranks a poll, which
      * may simply have raced a join that hasn't been stamped live yet.
+     *
+     * Relay-owned ACP sessions are never pruned either: there is no terminal
+     * behind them to have ended, and the server's live list never mentions them
+     * as something a poll would confirm — the relay itself is the only thing
+     * that keeps them alive, so it must be the only thing that can drop them.
      */
     pruneToLive(liveNames) {
         const live = new Set(liveNames);
         const dropped = [];
         for (const [name, target] of this.sessions) {
-            if (!live.has(name) && !target.attached) {
+            if (!live.has(name) && !target.attached && !target.relayOwned) {
                 this.sessions.delete(name);
                 dropped.push(name);
             }
@@ -155,6 +182,24 @@ class SessionRegistry {
             this.save();
         return dropped;
     }
+    /** Record (or, with `undefined`, forget) the agent's own ACP session id. */
+    setAcpSession(name, sessionId) {
+        const t = this.sessions.get(name);
+        if (!t?.acp)
+            return;
+        if (sessionId === undefined)
+            delete t.acp.sessionId;
+        else
+            t.acp.sessionId = sessionId;
+        this.save();
+    }
+    setAcpMode(name, mode) {
+        const t = this.sessions.get(name);
+        if (!t?.acp)
+            return;
+        t.acp.mode = mode;
+        this.save();
+    }
 }
 exports.SessionRegistry = SessionRegistry;
 function stripUndefined(obj) {

package/dist/relay/session-commands.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_COMMANDS = void 0;
+exports.parseSessionCommand = parseSessionCommand;
+exports.sessionCommandHelp = sessionCommandHelp;
+exports.noTerminalReason = noTerminalReason;
+/** Claude has no `/new`; `/clear` is how it starts a fresh chat. */
+const freshChat = (runtime) => (runtime === "codex" ? "/new" : "/clear");
+exports.SESSION_COMMANDS = [
+    {
+        id: "clear",
+        trigger: "/clear",
+        summary: "Clear this session's context, exactly as typing /clear in its terminal does.",
+        keys: () => "/clear",
+    },
+    {
+        id: "new",
+        trigger: "/new",
+        summary: "Start a fresh chat in this session, keeping the terminal open.",
+        keys: freshChat,
+    },
+    // ── ACP sessions (run by the relay, no terminal) ──────────────────────────────────────
+    // Four ROWS rather than `/mode <x>`, on purpose. The rule above says the wire carries a NAME
+    // and never an argument; an enum argument would be the first crack in it. These select a row
+    // like every other command, type nothing, and are answered by the relay.
+    { id: "mode-chat", trigger: "/mode-chat", mode: "chat", summary: "Relay-run agents: BayChat tools only — nothing on the computer. Owner or anyone with command access." },
+    { id: "mode-read", trigger: "/mode-read", mode: "read", summary: "Relay-run agents: may read files, no commands, no writes. Owner or anyone with command access." },
+    { id: "mode-ask", trigger: "/mode-ask", mode: "ask", summary: "Relay-run agents: may run commands; writes ask on your phone first. Owner or anyone with command access." },
+    { id: "mode-full", trigger: "/mode-full", mode: "full", summary: "Relay-run agents: may write inside its folder without asking. Owner or anyone with command access." },
+    { id: "stop", trigger: "/stop", summary: "Relay-run agents: stop the turn that is running now." },
+    {
+        id: "exit",
+        trigger: "/exit",
+        summary: "Stop this session being reachable from the Bay. Its terminal stays open — this does not close it.",
+    },
+    {
+        id: "status",
+        trigger: "/status",
+        summary: "What this relay knows about the session: runtime, terminal, and whether it is live.",
+    },
+    {
+        id: "help",
+        trigger: "/help",
+        summary: "This list.",
+    },
+];
+/**
+ * Is this message one of the commands, or is it chat?
+ *
+ * EXACT MATCH on the trimmed text, deliberately. "can you /clear please" is a sentence
+ * about a command and must reach the agent as one; anything looser would turn discussing
+ * the feature into using it. Case-insensitive because a phone keyboard capitalises the
+ * start of a line without being asked.
+ *
+ * Says nothing about whether the sender MAY run it — that is the server's answer, checked
+ * by the caller. Parsing and permission are kept apart so neither can be mistaken for the
+ * other.
+ */
+function parseSessionCommand(text) {
+    const normalised = text.trim().toLowerCase();
+    if (!normalised.startsWith("/"))
+        return undefined;
+    return exports.SESSION_COMMANDS.find((command) => command.trigger === normalised);
+}
+/** The reply to `/help`, and the thing to say when a command cannot run. */
+function sessionCommandHelp() {
+    return [
+        "Commands this session understands:",
+        ...exports.SESSION_COMMANDS.map((command) => `  ${command.trigger} — ${command.summary}`),
+        "",
+        "Only you, and anyone you have given permission to, can run them.",
+    ].join("\n");
+}
+/**
+ * The refusal for a session whose terminal cannot be typed into.
+ *
+ * NAMES THE FIX. A person whose session is not in a multiplexer has done nothing wrong and
+ * cannot be expected to know why a chat command needs one; "it did not work" would leave
+ * them with no next step, which is the failure this whole codebase keeps writing comments
+ * about.
+ */
+function noTerminalReason(detail) {
+    return [
+        detail ??
+            "This session is not running inside a terminal multiplexer, so there is nothing to type into.",
+        "Start it with `baychat` next time and they will work — that runs your agent somewhere these commands can reach.",
+        "/status, /exit and /help work either way.",
+    ].join(" ");
+}

package/dist/relay/session-reply.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postSessionReply = postSessionReply;
+const api_1 = require("../api");
+/**
+ * Say, in the room, what a session command did.
+ *
+ * ── WHY A REPLY IS PART OF THE FEATURE AND NOT A NICETY ───────────────────────────────
+ *
+ * Everything else the relay does is witnessed by the agent answering: you know the wake
+ * landed because a reply appears. A session command produces NO agent turn — `/clear` is
+ * absorbed by the runtime's own TUI and says nothing back — so without this the sender
+ * sees precisely the same thing whether the command cleared their session, refused because
+ * the terminal is not in tmux, or was silently ignored because the relay is a version
+ * behind. That is the failure mode this codebase keeps writing comments about, and it would
+ * be the default here.
+ *
+ * So every outcome is reported, refusals included, and the wording distinguishes them. The
+ * message is posted AS THE SESSION, which is right: the session is the thing that did (or
+ * did not do) it, and a reply from anyone else would be a second voice in the room
+ * explaining somebody's terminal.
+ */
+async function postSessionReply(auth, conversationId, sessionName, text, request = api_1.apiRequest) {
+    await request(auth, "POST", `/api/device-api/conversations/${encodeURIComponent(conversationId)}/messages`, { session: sessionName, content: text });
+}