baychat 0.22.0 → 0.23.1

package/dist/relay/acp/runner.js

@@ -36,15 +36,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AcpSessionRunner = void 0;
 exports.effectiveMode = effectiveMode;
 const os = __importStar(require("os"));
+const runtime_binary_1 = require("../../runtime-binary");
 const spawn_env_1 = require("../spawn-env");
 const agents_1 = require("./agents");
 const approval_1 = require("./approval");
 const client_1 = require("./client");
 const modes_1 = require("./modes");
-const permissions_1 = require("./permissions");
 const policy_1 = require("./policy");
 const presence_1 = require("./presence");
 const prompt_1 = require("./prompt");
+const types_1 = require("./types");
 /**
  * How much power ONE turn gets.
  *
@@ -62,6 +63,17 @@ function effectiveMode(sessionMode, ceiling, allAuthorized, allowedHere) {
     const usable = modes_1.ACP_MODES.filter((m) => allowedHere.includes(m) && (0, modes_1.modeRank)(m) <= (0, modes_1.modeRank)(wanted));
     return usable.at(-1) ?? "chat";
 }
+/**
+ * Is this call BayChat's `send_message` — the agent's answer going into the room? `mcpServer` is
+ * the name BayChat's server was handed over under this turn. dsh names the call by its title;
+ * Cursor titles it "<server>: send_message" and names server and tool in its input [run].
+ * Another server's `send_message` is not ours.
+ */
+function isBayChatSend(call, mcpServer) {
+    if (call.title === `mcp__${mcpServer}__send_message`)
+        return true;
+    return call.rawInput.providerIdentifier === mcpServer && call.rawInput.toolName === "send_message";
+}
 const RETRY_MAX_MS = 60_000;
 const errText = (err) => (err instanceof Error ? err.message : String(err));
 /**
@@ -174,6 +186,10 @@ class AcpSessionRunner {
             return;
         seen.add(key);
         this.said.set(session, seen);
+        await this.tell(session, key, conversationId, text);
+    }
+    /** Say it in the room now, every time. A failure to say is logged, never thrown. */
+    async tell(session, key, conversationId, text) {
         try {
             await this.deps.say(conversationId, session, text);
         }
@@ -193,28 +209,46 @@ class AcpSessionRunner {
         const acp = target?.acp;
         const row = acp ? (0, agents_1.acpAgent)(acp.agent) : undefined;
         if (!target || !acp || !row)
-            return drop("setup", `"${session}" is not set up on that computer any more. Run \`baychat connect dsh\` there.`);
+            return drop("setup", `"${session}" is not set up on that computer any more. Run \`${(0, agents_1.connectCommandFor)(acp?.agent)}\` there.`);
         const auth = deps.auth();
         if (!auth)
-            return drop("setup", `The relay on that computer is not logged in to BayChat. Run \`baychat connect ${row.id}\` there.`);
+            return drop("setup", `The relay on that computer is not logged in to BayChat. Run \`${row.connectCommand}\` there.`);
         if (!target.runtimeBin)
             return drop("spawn", `${row.label} is not installed where the relay can find it. ${row.installHint}`);
         const folder = (0, policy_1.checkFolder)((deps.loadPolicy ?? policy_1.loadPolicy)(), row.id, acp.cwd);
         if (!folder.ok)
             return drop("policy", folder.reason);
+        // Every turn, every mode: what is on disk now, not what was there at `connect`.
+        const refusal = row.turnRefusal?.(acp.cwd);
+        if (refusal)
+            return drop("override", refusal);
+        const env = { ...(deps.env ?? spawn_env_1.headlessSpawnEnv)() };
+        if (row.versionPattern) {
+            // The recorded path may since have been replaced by something else answering to the name.
+            const probed = await (deps.binaryVersion ?? ((bin) => (0, runtime_binary_1.probeBinaryVersion)(bin, env)))(target.runtimeBin);
+            if (!probed.ok || !(0, agents_1.binaryIdentified)(row, probed.version)) {
+                return drop("spawn", (0, agents_1.unidentifiedBinary)(row, target.runtimeBin, probed.ok ? probed.version : `nothing usable: ${probed.detail}`));
+            }
+        }
         const platform = deps.platform ?? process.platform;
         const allAuthorized = turn.addressed.every((m) => m.senderIsOwner === true || m.commandAuthorized === true);
         const mode = effectiveMode(acp.mode, folder.maxMode, allAuthorized, row.modesFor(platform));
         const patchDir = deps.patchDir ?? (0, agents_1.acpPatchDir)();
-        (0, agents_1.writeModePatches)(row, patchDir); // cheap, and an upgrade that changes a patch takes effect at once
-        const launch = row.launch(mode, patchDir);
+        (0, agents_1.writeModePatch)(row, mode, session, patchDir); // cheap; an upgrade or a /mode-* takes effect at once
+        const launch = row.launch(mode, patchDir, session);
+        const mcpServer = row.mcpServerName?.() ?? types_1.BAYCHAT_MCP_SERVER;
+        const toolNote = row.toolNote?.(mcpServer);
         const onPermission = async (call) => {
             const host = (deps.hostname ?? os.hostname)();
-            const decision = (0, permissions_1.decidePermission)(mode, call, { cwd: acp.cwd, host, agentLabel: row.label });
+            const decision = row.decidePermission(mode, call, { cwd: acp.cwd, host, agentLabel: row.label, mcpServer });
             if (decision.kind === "refuse") {
                 deps.log(`acp: ${session} permission REFUSED — ${decision.reason}`);
                 return "reject";
             }
+            if (decision.kind === "allow") {
+                deps.log(`acp: ${session} permission ALLOWED without asking — ${decision.reason}`);
+                return "allow";
+            }
             typing?.pause(); // the card is the signal while a person decides
             const answer = await (deps.askPhone ?? approval_1.askPhone)({ auth, session, conversationId: room, question: decision.question });
             typing?.resume(); // a no-op once the turn has stopped typing — `stop()` is final
@@ -224,24 +258,32 @@ class AcpSessionRunner {
         const caller = (deps.caller ?? presence_1.deviceMcpCaller)(auth);
         const abort = new AbortController();
         let typing;
+        let stopGuard;
+        /** What the row's guard found on disk mid-turn — the turn is stopped the moment it is set. */
+        let breach;
         let outcome;
         try {
             this.running.set(session, abort);
+            stopGuard = row.guardTurn?.(acp.cwd, (finding) => {
+                breach = `${row.label} was stopped in the middle of its turn: ${finding}`;
+                abort.abort();
+            });
             typing = (0, presence_1.startTyping)(caller, session, room, { log: deps.log });
             deps.log(`acp: ${session} turn — ${turn.addressed.length} addressed, ${turn.digest.messages.length} context, mode ${mode}${allAuthorized ? "" : " (not all from someone with command access)"}`);
             outcome = await (deps.runTurn ?? client_1.runAcpTurn)({
                 binaryPath: target.runtimeBin,
                 args: launch.args,
-                env: { ...(deps.env ?? spawn_env_1.headlessSpawnEnv)(), ...launch.env },
+                env: { ...env, ...launch.env },
                 cwd: acp.cwd,
                 sessionId: acp.sessionId,
-                mcpServers: [{ type: "http", name: "baychat", url: `${auth.baseUrl.replace(/\/$/, "")}/api/mcp`, headers: [{ name: "Authorization", value: `Bearer ${auth.token}` }] }],
-                prompt: `Mode for this turn: ${mode}.\n\n${(0, prompt_1.turnPrompt)(turn)}`,
-                freshPreamble: (0, prompt_1.setupPreamble)(session, mode),
+                mcpServers: [{ type: "http", name: mcpServer, url: `${auth.baseUrl.replace(/\/$/, "")}/api/mcp`, headers: [{ name: "Authorization", value: `Bearer ${auth.token}` }] }],
+                prompt: `Mode for this turn: ${mode}.\n\n${toolNote ? `${toolNote}\n\n` : ""}${(0, prompt_1.turnPrompt)(turn)}`,
+                freshPreamble: (0, prompt_1.setupPreamble)(session, (0, agents_1.describeAgentMode)(row, mode)),
+                sessionModeId: row.acpModeId,
                 onPermission,
                 // Its message is in the room; a refreshed indicator after that would be a ghost.
                 onToolCall: (call) => {
-                    if (call.title === "mcp__baychat__send_message")
+                    if (isBayChatSend(call, mcpServer))
                         typing?.stop();
                 },
                 classifyError: (m) => row.classifyError(m),
@@ -249,10 +291,21 @@ class AcpSessionRunner {
             }, { spawn: deps.spawn, log: deps.log, platform });
         }
         finally {
-            // Every exit — outcome or throw — ends typing and frees `/stop`, or `/stop` would lie.
+            // Every exit — outcome or throw — ends typing and the guard and frees `/stop`, or `/stop` would lie.
+            stopGuard?.();
             typing?.stop();
             this.running.delete(session);
         }
+        if (breach !== undefined) {
+            // Said every time, not once: it happened in THIS turn. The next turn's `turnRefusal` then
+            // refuses until the file is gone.
+            deps.log(`acp: ${session} ${breach}`);
+            await this.tell(session, "override", room, breach);
+            if (outcome.kind !== "completed") {
+                deps.onPending(session, turn.addressed, breach);
+                return "next";
+            }
+        }
         if (outcome.kind === "completed") {
             deps.registry.setAcpSession(session, outcome.sessionId);
             deps.onDelivered(session, turn.addressed);

package/dist/relay/acp/types.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BAYCHAT_MCP_SERVER = void 0;
+/** The name BayChat's MCP server is handed to the agent under — and how an agent names it back. */
+exports.BAYCHAT_MCP_SERVER = "baychat";

package/dist/relay/daemon.js

@@ -271,7 +271,7 @@ 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.acpKeepAlive = (0, daemon_glue_1.startAcpUpkeep)(this.acpAlive.run);
         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

package/dist/relay/updates.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUSPENDED_RECHECK_MS = void 0;
 exports.runUpdatesLoop = runUpdatesLoop;
 exports.catchUpFromWatermarks = catchUpFromWatermarks;
 const api_1 = require("../api");
@@ -9,6 +10,49 @@ const WAIT_SECONDS = 25;
 const BACKOFF_MIN_MS = 1_000;
 const BACKOFF_MAX_MS = 30_000;
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * How long the relay waits before asking again once the server has said the account or the
+ * Bay is SUSPENDED. Long on purpose — nothing the relay does changes the answer, so this is
+ * only about noticing when a person has lifted it.
+ */
+exports.SUSPENDED_RECHECK_MS = 15 * 60_000;
+/** `sleep`, but over at once when `signal` aborts — a relay told to stop must not sit out 15 minutes. */
+function sleepUnlessAborted(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            return resolve();
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", done);
+            resolve();
+        }
+        signal.addEventListener("abort", done);
+    });
+}
+/**
+ * The server's refusal about STANDING, not about the credential (docs/features/MODERATION.md
+ * in the API): 403 ACCOUNT_SUSPENDED — the account is suspended or being deleted by BayChat —
+ * or 403 BAY_SUSPENDED — the Bay this laptop is logged in to is suspended.
+ *
+ * Neither is fixed by `npx baychat login`, and neither is transient in the 5xx sense. Treating
+ * them as terminal (the default for a 4xx) made the daemon exit, and every service manager this
+ * CLI installs (`systemd` Restart=always, launchd KeepAlive, the Windows task's
+ * RestartOnFailure) restarted it into the same refusal every few seconds: a crash-loop that
+ * says nothing useful, the exact shape of the relay that restarted 111k times on an expired
+ * credential. An exit code cannot stop that without changing units that are already installed,
+ * so the relay stays up instead, says plainly what happened, and asks again rarely — which also
+ * means it resumes by itself when a Bay suspension is lifted.
+ */
+function standingRefusal(err) {
+    if (!(err instanceof api_1.ApiError) || err.status !== 403)
+        return null;
+    if (err.code === "ACCOUNT_SUSPENDED")
+        return "account";
+    if (err.code === "BAY_SUSPENDED")
+        return "bay";
+    return null;
+}
 /**
  * Transient failures are ridden out, not surfaced. A 502 while the api
  * container restarts, a network throw, a 429 — all mean "later", not "stop".
@@ -43,7 +87,7 @@ function isTransient(err) {
  * watermark, then poll again with no cursor.
  */
 async function runUpdatesLoop(opts) {
-    const { auth, watermarks, onEvents, onSessions, onPoll, onError, initialCursor, signal, request = api_1.apiRequest } = opts;
+    const { auth, watermarks, onEvents, onSessions, onPoll, onError, initialCursor, signal, request = api_1.apiRequest, suspendedRecheckMs = exports.SUSPENDED_RECHECK_MS, } = opts;
     let cursor = initialCursor;
     let backoff = BACKOFF_MIN_MS;
     while (!signal.aborted) {
@@ -86,6 +130,18 @@ async function runUpdatesLoop(opts) {
                 cursor = undefined;
                 continue;
             }
+            const standing = standingRefusal(err);
+            if (standing) {
+                const minutes = Math.round(suspendedRecheckMs / 60_000);
+                onError?.(new Error(standing === "account"
+                    ? `this BayChat account has been suspended — the relay is paused and will check again in ${minutes} min. ` +
+                        "Logging in again will not help; if you think this is a mistake, contact support@baychat.io."
+                    : `the Bay this machine is logged in to has been suspended — the relay is paused and will check again in ${minutes} min. ` +
+                        "If you think this is a mistake, contact support@baychat.io."), true);
+                await sleepUnlessAborted(suspendedRecheckMs, signal);
+                backoff = BACKOFF_MIN_MS;
+                continue;
+            }
             if (!isTransient(err)) {
                 onError?.(err, false);
                 throw err; // terminal — an expired device credential needs `npx baychat login`

package/dist/runtime-binary.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRuntimeBinary = resolveRuntimeBinary;
 exports.describeResolution = describeResolution;
 exports.spawnPlanFor = spawnPlanFor;
+exports.probeBinaryVersion = probeBinaryVersion;
 exports.summarizeProbe = summarizeProbe;
 exports.currentBinaryEnv = currentBinaryEnv;
 exports.summarizeResolutionFailure = summarizeResolutionFailure;
@@ -213,6 +214,22 @@ function spawnPlanFor(candidate, platform) {
 }
 /** How long a `--version` probe may run before it is treated as broken. */
 const PROBE_TIMEOUT_MS = 5_000;
+/**
+ * `<binary> --version`, without blocking the event loop — for a caller that probes a known path
+ * while other work runs (the relay, before starting an agent). Same rules as the resolution
+ * probe: no shell, the environment the agent will get, `summarizeProbe` decides.
+ */
+function probeBinaryVersion(binaryPath, env) {
+    const plan = spawnPlanFor(binaryPath, process.platform);
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)(plan.file, [...plan.prefixArgs, "--version"], { timeout: PROBE_TIMEOUT_MS, windowsHide: true, shell: false, env, encoding: "utf8" }, (err, stdout, stderr) => {
+            const status = err ? (typeof err.code === "number" ? err.code : null) : 0;
+            // A non-zero exit is still a run: only a failure to run at all is an `error`.
+            const failedToRun = err && typeof err.code !== "number" ? err : undefined;
+            resolve(summarizeProbe({ status, stdout: stdout ?? "", stderr: stderr ?? "", error: failedToRun }));
+        });
+    });
+}
 /** The most stderr worth quoting back to a user in a rejection reason. */
 const PROBE_DETAIL_LIMIT = 200;
 /**

package/dist/tool-defs.js

@@ -266,6 +266,56 @@ exports.CONVERSATION_TOOL_DEFS = [
                 "attachments, never both."),
         },
     },
+    {
+        name: "create_poll",
+        title: "Ask the room to choose",
+        description: "Put a poll in the room: one question, two to ten answers, counted by the server. " +
+            "USE IT WHEN THE ANSWER IS A CHOICE SEVERAL PEOPLE OWN — a release date, which of two " +
+            "designs, who is free on Thursday. For a decision ONE person owns, use request_approval " +
+            "instead: that blocks your session until they answer, while a poll does not block " +
+            "anything and you read the result later. " +
+            "Everyone in the room can vote, including other agents, and every vote is visible to the " +
+            "room. Do not create a second poll to ask the same thing again — read the first one's " +
+            "tally with get_messages.",
+        inputSchema: {
+            conversationId: zod_1.z
+                .string()
+                .describe("The conversation id (from list_conversations)."),
+            question: zod_1.z.string().describe("The question, as the room will read it."),
+            options: zod_1.z
+                .array(zod_1.z.string())
+                .describe("The answers, in the order they should appear: at least two, at most ten, each " +
+                "distinct. Keep them short — they are drawn as rows on a phone."),
+            allowMultiple: zod_1.z
+                .boolean()
+                .optional()
+                .describe("May one voter pick more than one answer? Defaults to false — one answer each."),
+        },
+    },
+    {
+        name: "vote_in_poll",
+        title: "Vote in a poll",
+        description: "Cast, change or withdraw YOUR OWN vote in a poll. You are a participant of the room like " +
+            "anyone else, and your vote is counted and shown beside theirs. " +
+            "GET pollId FROM THE POLL CARD: a poll arrives through get_messages as a message whose " +
+            "`cardPayload` holds { pollId, question, options }, and whose `poll` holds the tally so " +
+            "far. " +
+            "`optionIndexes` COUNTS FROM ZERO — the first answer is 0, whatever the numbering in the " +
+            "message text says. It is the COMPLETE set of answers you want to hold: send one index " +
+            "for a single-answer poll, several for a poll that allows them, and an empty array to " +
+            "take your vote back. Sending the same vote twice changes nothing. " +
+            "VOTE ONLY WHEN YOU WERE ASKED TO, or when you genuinely hold the information the " +
+            "question is about. A poll is the room's decision, not yours to settle.",
+        inputSchema: {
+            pollId: zod_1.z
+                .string()
+                .describe("The poll's id, from the poll card's `cardPayload.pollId`."),
+            optionIndexes: zod_1.z
+                .array(zod_1.z.number())
+                .describe("The complete set of answers you want to hold, counting from ZERO. Empty withdraws " +
+                "your vote."),
+        },
+    },
     {
         name: "set_typing",
         title: "Show that you are working",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "baychat",
-  "version": "0.22.0",
-  "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex) with BayChat and chat in groups",
+  "version": "0.23.1",
+  "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex, Cursor) with BayChat, or have the relay run DeepSeek or the Cursor CLI for you",
   "bin": {
     "baychat": "dist/index.js"
   },
@@ -29,6 +29,8 @@
     "chat",
     "claude-code",
     "codex",
+    "cursor",
+    "deepseek",
     "cli",
     "connector",
     "group-chat"