baychat 0.26.0 → 0.27.1

package/README.md

@@ -111,6 +111,13 @@ not reconnect. Claude Code needs a host that exposes native WebSocket Monitor
 the old shell/relay join is available only as an explicitly chosen fallback.
 Updating npm alone does not refresh a skill already loaded in a running session.
 
+**No Monitor deadline with the channel.** `baychat connect claude` also registers
+`baychat_channel`, a local Claude Code channel. Start Claude Code with
+`baychat claude` (or `baychat start`, which uses tmux when installed)
+and the skill calls its `listen` tool instead of opening a Monitor: the channel holds the
+feed, reconnects by itself, and wakes the session only when a message arrives. Started
+without the flag, `listen` answers `inactive` and the Monitor path above is used.
+
 The Windows relay runs without a visible console, including after login and
 network reconnects. Incoming messages appear as `@Sender` in the coding task.
 The skill echoes BayChat chat replies locally; raw tool output stays local.

package/dist/channel/detect.js

@@ -0,0 +1,145 @@
+"use strict";
+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.DEV_CHANNELS_FLAG = exports.CHANNEL_FLAG_VALUE = exports.CHANNEL_MCP_ENTRY = void 0;
+exports.argsEnableChannel = argsEnableChannel;
+exports.realProcessReader = realProcessReader;
+exports.detectChannel = detectChannel;
+/**
+ * Was this Claude Code session started with the BayChat channel switched on?
+ *
+ * Claude Code never tells a channel server whether it registered it: without the launch flag
+ * the server still connects and its tools still work, but every event it pushes is dropped in
+ * silence (checked in the 2.1.284 source: the gate only logs). A session told "you are
+ * listening" when nothing can arrive is deaf with a green light — worse than the Monitor it
+ * replaced. So `listen` answers active only on evidence, and otherwise sends the session back
+ * to `listen_messages` + Monitor.
+ *
+ * Two kinds of evidence, either enough:
+ *
+ *  1. `BAYCHAT_CHANNEL=1` in this process's environment. `baychat claude` and `baychat start` set
+ *     it on the Claude Code they launch WITH the flag, and Claude Code passes its environment to
+ *     the servers it spawns (checked on 2.1.284). Set per launch, never exported, so a plain
+ *     `claude` does not inherit it.
+ *  2. The flag on an ancestor's command line: `--dangerously-load-development-channels` or
+ *     `--channels` naming `server:baychat_channel`, for people who type the flag themselves.
+ *     NOT reliable on its own: Claude Code sets `process.title = "claude"` at start, and where it
+ *     runs on Node (an npm install, e.g. under nvm on WSL) that overwrites /proc/<pid>/cmdline,
+ *     so the flags vanish. Found 2026-10-02 on the owner's WSL: launched with the flag, `ps`
+ *     showed only `claude`, and `listen` wrongly answered inactive. A wrong "inactive" is safe —
+ *     the session falls back to a Monitor — but it is why (1) exists.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+/** This server's name in Claude Code's MCP config. An underscore, so no Bay slug can equal it. */
+exports.CHANNEL_MCP_ENTRY = "baychat_channel";
+/** What `--dangerously-load-development-channels` takes for a bare MCP server. */
+exports.CHANNEL_FLAG_VALUE = `server:${exports.CHANNEL_MCP_ENTRY}`;
+exports.DEV_CHANNELS_FLAG = "--dangerously-load-development-channels";
+const CHANNEL_FLAGS = [exports.DEV_CHANNELS_FLAG, "--channels"];
+/** How far up the process tree to look. */
+const MAX_DEPTH = 4;
+/**
+ * True when one process's argument list switches the channel on: a channels flag followed —
+ * as its value, `=value`, or one of the space-separated entries after it — by our server.
+ */
+function argsEnableChannel(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const flag = CHANNEL_FLAGS.find((f) => arg === f || arg.startsWith(`${f}=`));
+        if (!flag)
+            continue;
+        const values = [];
+        if (arg.startsWith(`${flag}=`))
+            values.push(...arg.slice(flag.length + 1).split(/[\s,]+/));
+        else {
+            for (let j = i + 1; j < args.length && !args[j].startsWith("-"); j++)
+                values.push(...args[j].split(/[\s,]+/));
+        }
+        if (values.includes(exports.CHANNEL_FLAG_VALUE))
+            return true;
+    }
+    return false;
+}
+/** Linux: /proc, exact argv. Elsewhere: `ps`, whose argument text is split on spaces. */
+function realProcessReader(platform = process.platform) {
+    return (pid) => {
+        if (platform === "linux") {
+            try {
+                const cmdline = fs.readFileSync(`/proc/${pid}/cmdline`, "utf8");
+                const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+                // Field 4 of stat, counted after the parenthesised command name (which may hold spaces).
+                const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+                return { ppid, args: cmdline.split("\0").filter(Boolean) };
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (platform === "win32")
+            return undefined;
+        try {
+            const out = (0, node_child_process_1.execFileSync)("ps", ["-o", "ppid=", "-o", "args=", "-p", String(pid)], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 3_000,
+            }).trim();
+            const m = /^(\d+)\s+(.*)$/s.exec(out);
+            if (!m)
+                return undefined;
+            return { ppid: Number(m[1]), args: m[2].split(/\s+/) };
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+/** Look for the flag on this process's ancestors, then fall back to the env marker. */
+function detectChannel(opts = {}) {
+    const env = opts.env ?? process.env;
+    if (env.BAYCHAT_CHANNEL === "1")
+        return { active: true, how: "env" };
+    const read = opts.read ?? realProcessReader();
+    let pid = opts.pid ?? process.ppid;
+    for (let depth = 0; depth < MAX_DEPTH && pid > 1; depth++) {
+        const info = read(pid);
+        if (!info)
+            break;
+        if (info.args && argsEnableChannel(info.args))
+            return { active: true, how: "process" };
+        pid = info.ppid;
+    }
+    return { active: false, how: "none" };
+}

package/dist/channel/feed.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelFeed = exports.BACKOFF_MS = exports.CLOSE_STOPPED = void 0;
+/** Close code the server sends when a feed was stopped or replaced on purpose. */
+exports.CLOSE_STOPPED = 4000;
+/** Seconds between reconnect attempts: quick at first, then no more than once a minute. */
+exports.BACKOFF_MS = [1_000, 2_000, 5_000, 10_000, 30_000, 60_000];
+const READY_TIMEOUT_MS = 10_000;
+const WATCHDOG_MS = 2 * 60_000;
+/** A timer that fires this much later than asked means the computer slept: reconnect at once. */
+const SLEEP_GAP_MS = 60_000;
+class ChannelFeed {
+    deps;
+    state = "connecting";
+    cursor;
+    socket;
+    /** Bumped for each socket, so a late callback from an old one cannot touch the new one. */
+    generation = 0;
+    attempt = 0;
+    retryTimer;
+    watchdogTimer;
+    lastTick = 0;
+    now;
+    setTimer;
+    clearTimer;
+    constructor(deps) {
+        this.deps = deps;
+        this.now = deps.now ?? Date.now;
+        this.setTimer = deps.setTimer ?? ((fn, ms) => {
+            const t = setTimeout(fn, ms);
+            // The stdio transport keeps the process alive; a timer must not on its own.
+            t.unref?.();
+            return t;
+        });
+        this.clearTimer = deps.clearTimer ?? ((h) => clearTimeout(h));
+    }
+    get currentState() {
+        return this.state;
+    }
+    get lastCursor() {
+        return this.cursor;
+    }
+    /**
+     * Open the feed and wait for its first `ready`.
+     *
+     * Resolves `{ ok: true }` once the server has seated the feed — the only moment "connected"
+     * is true — or with the reason it could not. A failed start leaves nothing running, so the
+     * session can fall back to a Monitor with nothing competing for its feed.
+     */
+    async start() {
+        const minted = await this.deps.mint(undefined);
+        if (!minted.ok) {
+            this.state = "stopped";
+            return { ok: false, detail: minted.detail };
+        }
+        const ready = await new Promise((resolve) => {
+            const timer = this.setTimer(() => {
+                this.teardown();
+                this.state = "stopped";
+                resolve({ ok: false, detail: "The BayChat feed did not answer within 10 seconds." });
+            }, this.deps.readyTimeoutMs ?? READY_TIMEOUT_MS);
+            this.open(minted.ticket, {
+                onReady: () => {
+                    this.clearTimer(timer);
+                    resolve({ ok: true });
+                },
+                onFailBeforeReady: (detail) => {
+                    this.clearTimer(timer);
+                    this.teardown();
+                    this.state = "stopped";
+                    resolve({ ok: false, detail });
+                },
+            });
+        });
+        if (ready.ok)
+            this.armWatchdog();
+        return ready;
+    }
+    /** Stop for good: no reconnect, no watchdog. Used on replace and on process exit. */
+    stop() {
+        this.state = "stopped";
+        this.teardown();
+    }
+    teardown() {
+        this.generation++;
+        if (this.retryTimer !== undefined)
+            this.clearTimer(this.retryTimer);
+        if (this.watchdogTimer !== undefined)
+            this.clearTimer(this.watchdogTimer);
+        this.retryTimer = undefined;
+        this.watchdogTimer = undefined;
+        const socket = this.socket;
+        this.socket = undefined;
+        try {
+            socket?.close(1000, "BayChat channel closed");
+        }
+        catch {
+            /* Already closed: nothing left to release. */
+        }
+    }
+    open(ticket, first) {
+        const generation = ++this.generation;
+        const current = () => generation === this.generation && this.state !== "stopped";
+        let ready = false;
+        this.state = "connecting";
+        try {
+            this.socket = this.deps.connect(ticket.url, ticket.protocols, {
+                onOpen: () => { },
+                onMessage: (data) => {
+                    if (!current())
+                        return;
+                    const frame = parseFrame(data);
+                    if (!frame)
+                        return;
+                    if (typeof frame.cursor === "string" && frame.cursor)
+                        this.cursor = frame.cursor;
+                    if (frame.type === "ready") {
+                        ready = true;
+                        this.state = "open";
+                        this.attempt = 0;
+                        first?.onReady();
+                        return;
+                    }
+                    if (frame.type === "messages")
+                        void this.pushMessages(frame);
+                    else if (frame.type === "reset")
+                        void this.pushReset();
+                },
+                onError: (detail) => this.log(`feed error: ${detail}`),
+                onClose: (code, reason) => {
+                    if (!current())
+                        return;
+                    this.socket = undefined;
+                    if (!ready && first) {
+                        first.onFailBeforeReady(`The BayChat feed closed before it was ready (${code}${reason ? `: ${reason}` : ""}).`);
+                        return;
+                    }
+                    if (code === exports.CLOSE_STOPPED) {
+                        // Stopped or replaced on purpose — by stop_listening, end_session, or a newer
+                        // listener for this session. Reconnecting would fight whichever replaced it.
+                        this.log(`feed for ${this.deps.session} stopped by the server (${reason || code})`);
+                        this.stop();
+                        return;
+                    }
+                    this.scheduleReconnect(`closed ${code}${reason ? `: ${reason}` : ""}`);
+                },
+            });
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            if (first)
+                first.onFailBeforeReady(detail);
+            else
+                this.scheduleReconnect(detail);
+        }
+    }
+    scheduleReconnect(why) {
+        if (this.state === "stopped")
+            return;
+        this.state = "retrying";
+        const delay = exports.BACKOFF_MS[Math.min(this.attempt, exports.BACKOFF_MS.length - 1)];
+        this.attempt++;
+        this.log(`feed for ${this.deps.session} ${why}; reconnecting in ${delay / 1000}s`);
+        if (this.retryTimer !== undefined)
+            this.clearTimer(this.retryTimer);
+        this.retryTimer = this.setTimer(() => {
+            this.retryTimer = undefined;
+            void this.reconnect();
+        }, delay);
+    }
+    async reconnect() {
+        if (this.state === "stopped")
+            return;
+        const minted = await this.deps.mint(this.cursor);
+        // `stop()` may have run while the mint was in flight.
+        if (this.stopped())
+            return;
+        if (minted.ok) {
+            this.open(minted.ticket);
+            return;
+        }
+        if (minted.fatal) {
+            this.stop();
+            await this.deps.push(`BayChat stopped listening for session "${this.deps.session}": ${minted.detail} ` +
+                `If the session expired, call join_session again with the same name and room, then call ` +
+                `the baychat_channel listen tool again. Until then this session does not hear the Bay.`, this.meta({ event: "stopped" }));
+            return;
+        }
+        this.scheduleReconnect(`could not reconnect (${minted.detail})`);
+    }
+    /**
+     * Every two minutes: ask the server whether it still sees this feed.
+     *
+     * A socket can die without a close — a laptop lid, a NAT that forgot us — and the server's
+     * pings do not reach this side's code to notice. The server's own answer is the check. A
+     * timer that fires far later than asked means the computer slept: reconnect at once rather
+     * than trust a socket from before the sleep.
+     */
+    armWatchdog() {
+        const every = this.deps.watchdogMs ?? WATCHDOG_MS;
+        this.lastTick = this.now();
+        this.watchdogTimer = this.setTimer(() => void this.watchdog(every), every);
+    }
+    async watchdog(every) {
+        this.watchdogTimer = undefined;
+        if (this.state === "stopped")
+            return;
+        const late = this.now() - this.lastTick - every > SLEEP_GAP_MS;
+        if (this.state === "open") {
+            const seen = late ? "disconnected" : await this.deps.status();
+            if (this.state === "open" && seen === "disconnected") {
+                this.log(`feed for ${this.deps.session} ${late ? "outlived a sleep" : "is not seen by the server"}; reopening`);
+                this.generation++;
+                const socket = this.socket;
+                this.socket = undefined;
+                try {
+                    socket?.close(1000, "Reopening");
+                }
+                catch {
+                    /* Already gone. */
+                }
+                this.attempt = 0;
+                this.scheduleReconnect("watchdog");
+            }
+        }
+        else if (late && this.state === "retrying" && this.retryTimer !== undefined) {
+            // Woken from sleep mid-backoff: try now instead of after the rest of a long wait.
+            this.clearTimer(this.retryTimer);
+            this.retryTimer = undefined;
+            this.attempt = 0;
+            void this.reconnect();
+        }
+        if (!this.stopped())
+            this.armWatchdog();
+    }
+    async pushMessages(frame) {
+        const items = (frame.messages ?? []).filter((m) => typeof m?.conversationId === "string" && typeof m?.messageId === "string");
+        if (!items.length)
+            return;
+        const conversations = [...new Set(items.map((m) => m.conversationId))];
+        const count = items.length;
+        await this.deps.push(`${count === 1 ? "A new BayChat message" : `${count} new BayChat messages`} for session "${this.deps.session}"` +
+            `${this.deps.bayName ? ` in the ${this.deps.bayName} Bay` : ""}. ` +
+            `Read ${conversations.length === 1 ? "conversation" : "conversations"} ${conversations.join(", ")} with get_messages ` +
+            `from your last watermark, obey shouldRespond, and answer in BayChat. This channel stays open: do not open a Monitor.`, this.meta({
+            event: "messages",
+            conversation_ids: conversations.join(","),
+            message_ids: items.map((m) => m.messageId).join(","),
+        }));
+    }
+    async pushReset() {
+        await this.deps.push(`BayChat reset the feed for session "${this.deps.session}". Catch up on your joined conversations with get_messages; ` +
+            `a reset never means there were no messages. The channel stays open.`, this.meta({ event: "reset" }));
+    }
+    meta(extra) {
+        return {
+            session: this.deps.session,
+            ...(this.deps.bayName ? { bay: this.deps.bayName } : {}),
+            ...extra,
+        };
+    }
+    /** Read through a method: an `await` in between can change it, which narrowing cannot see. */
+    stopped() {
+        return this.state === "stopped";
+    }
+    log(line) {
+        this.deps.log?.(line);
+    }
+}
+exports.ChannelFeed = ChannelFeed;
+function parseFrame(data) {
+    try {
+        const parsed = JSON.parse(data);
+        if (parsed && typeof parsed === "object" && typeof parsed.type === "string")
+            return parsed;
+    }
+    catch {
+        /* Not JSON: the server never sends that, so it is not ours to act on. */
+    }
+    return undefined;
+}

package/dist/channel/launch.js

@@ -0,0 +1,159 @@
+"use strict";
+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.CHANNEL_ENV = exports.CHANNEL_LAUNCH_COMMAND = exports.CHANNEL_LAUNCH_ARGS = exports.CHANNEL_MIN_CLAUDE = void 0;
+exports.parseClaudeVersion = parseClaudeVersion;
+exports.claudeSupportsChannel = claudeSupportsChannel;
+exports.channelLaunchFor = channelLaunchFor;
+exports.cmdClaude = cmdClaude;
+exports.claudeChannelAddArgs = claudeChannelAddArgs;
+exports.registerChannelWithClaude = registerChannelWithClaude;
+exports.claudeUserConfigPath = claudeUserConfigPath;
+exports.channelRegistered = channelRegistered;
+/**
+ * Getting the channel into Claude Code: registering the server, and starting sessions with it on.
+ *
+ * Two halves, both needed: Claude Code must know the server (`claude mcp add`, once per computer)
+ * AND each session must be started with the channel flag — being in the MCP config is not enough
+ * for a channel to deliver anything (docs: "a server also has to be named in --channels").
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const runtime_binary_1 = require("../runtime-binary");
+const detect_1 = require("./detect");
+/**
+ * The first Claude Code this is switched on for. Channels exist from earlier releases, but
+ * 2.1.234 is where Claude Code started sending a channel only what it registered for the
+ * session — the behaviour this design is checked against. On an older one `baychat start`
+ * launches without the flag (an unknown flag would stop Claude Code from starting at all), and
+ * the session listens through a Monitor exactly as before.
+ */
+exports.CHANNEL_MIN_CLAUDE = [2, 1, 234];
+/** `2.1.284 (Claude Code)` → [2, 1, 284]; undefined for anything else. */
+function parseClaudeVersion(text) {
+    const m = /(\d+)\.(\d+)\.(\d+)/.exec(text);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined;
+}
+function claudeSupportsChannel(version) {
+    if (!version)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (version[i] !== exports.CHANNEL_MIN_CLAUDE[i])
+            return version[i] > exports.CHANNEL_MIN_CLAUDE[i];
+    }
+    return true;
+}
+/** The arguments `baychat start` adds to a Claude Code launch. */
+exports.CHANNEL_LAUNCH_ARGS = [detect_1.DEV_CHANNELS_FLAG, detect_1.CHANNEL_FLAG_VALUE];
+/** What to type to start Claude Code with the channel on. */
+exports.CHANNEL_LAUNCH_COMMAND = "baychat claude";
+/**
+ * The marker the channel trusts (detect.ts). Set on the ONE process launched, never exported:
+ * Claude Code can hide its own flags, so the launcher vouches for them instead.
+ */
+exports.CHANNEL_ENV = { BAYCHAT_CHANNEL: "1" };
+/**
+ * Decide for one Claude Code binary. Plain (and the session uses a Monitor) when the channel
+ * server is not registered or this Claude Code is too old for the flag — an unknown flag would
+ * stop it from starting at all.
+ */
+function channelLaunchFor(claudePath, deps = {}) {
+    const registered = deps.registered ?? (() => channelRegistered());
+    if (!registered())
+        return { on: false, args: [], env: {}, why: "the BayChat channel is not set up here (run `baychat connect claude`)" };
+    const text = (deps.version ?? probeVersion)(claudePath);
+    if (!claudeSupportsChannel(text ? parseClaudeVersion(text) : undefined)) {
+        return { on: false, args: [], env: {}, why: `Claude Code ${exports.CHANNEL_MIN_CLAUDE.join(".")} or newer is needed for the channel (run \`claude update\`)` };
+    }
+    return { on: true, args: [...exports.CHANNEL_LAUNCH_ARGS], env: { ...exports.CHANNEL_ENV } };
+}
+function probeVersion(claudePath) {
+    const probe = (0, node_child_process_1.spawnSync)(claudePath, ["--version"], { encoding: "utf8", timeout: 10_000 });
+    return probe.error || probe.status !== 0 ? undefined : String(probe.stdout ?? "");
+}
+/**
+ * `baychat claude [args…]` — Claude Code with the BayChat channel switched on, in this terminal.
+ * No multiplexer (that is `baychat start`), nothing else changed: every argument is passed on.
+ */
+function cmdClaude(args) {
+    const binary = (0, runtime_binary_1.resolveRuntimeBinary)("claude", (0, runtime_binary_1.currentBinaryEnv)());
+    if (!binary.ok) {
+        console.error(`Could not start Claude Code: ${binary.reason}`);
+        return 1;
+    }
+    const launch = channelLaunchFor(binary.path);
+    if (!launch.on)
+        console.error(`Starting Claude Code without the BayChat channel: ${launch.why}. Messages will use the Monitor.`);
+    const result = (0, node_child_process_1.spawnSync)(binary.path, [...launch.args, ...args], { stdio: "inherit", env: { ...process.env, ...launch.env } });
+    if (result.error) {
+        console.error(`Could not start Claude Code: ${result.error.message}`);
+        return 1;
+    }
+    return result.status ?? 0;
+}
+/** `claude mcp add` argv for the channel server: this CLI by absolute path, run as `channel`. */
+function claudeChannelAddArgs(launch) {
+    return ["mcp", "add", "--scope", "user", detect_1.CHANNEL_MCP_ENTRY, "--", launch.node, launch.entry, "channel"];
+}
+/**
+ * Register the channel server with Claude Code. Re-adds on "already exists", so a CLI that moved
+ * (a new Node, a reinstall elsewhere) points Claude Code at where it is now.
+ */
+function registerChannelWithClaude(launch, run) {
+    const args = claudeChannelAddArgs(launch);
+    let res = run(args);
+    if (res.status !== 0 && /already exists/i.test(res.stderr)) {
+        const removed = run(["mcp", "remove", "--scope", "user", detect_1.CHANNEL_MCP_ENTRY]);
+        if (removed.status === 0)
+            res = run(args);
+    }
+    return res.status === 0;
+}
+/** Claude Code's user config, where `--scope user` servers live. */
+function claudeUserConfigPath(home = os.homedir()) {
+    return path.join(home, ".claude.json");
+}
+/** Is the channel server in Claude Code's user config? Read-only; unreadable counts as no. */
+function channelRegistered(file = claudeUserConfigPath(), read = (p) => fs.readFileSync(p, "utf8")) {
+    try {
+        const parsed = JSON.parse(read(file));
+        return !!parsed?.mcpServers && Object.hasOwn(parsed.mcpServers, detect_1.CHANNEL_MCP_ENTRY);
+    }
+    catch {
+        return false;
+    }
+}