baychat 0.25.3 → 0.27.0

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,111 @@
+"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_LAUNCH_COMMAND = exports.CHANNEL_LAUNCH_ARGS = exports.CHANNEL_MIN_CLAUDE = void 0;
+exports.parseClaudeVersion = parseClaudeVersion;
+exports.claudeSupportsChannel = claudeSupportsChannel;
+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 fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+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 = `claude ${exports.CHANNEL_LAUNCH_ARGS.join(" ")}`;
+/** `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;
+    }
+}

package/dist/channel/server.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelService = exports.nodeFeedConnect = exports.CHANNEL_INSTRUCTIONS = void 0;
+exports.realLogin = realLogin;
+exports.realCallTool = realCallTool;
+exports.mintTicket = mintTicket;
+exports.startChannelServer = startChannelServer;
+/**
+ * `baychat channel` — the Claude Code channel server (docs/features/CLAUDE_CODE_CHANNEL.md).
+ *
+ * A local stdio MCP server that Claude Code starts beside the remote `baychat` connection. It
+ * declares `claude/channel`, so every `notifications/claude/channel` it sends is queued into the
+ * running session as a prompt — which is what wakes an idle session without a Monitor.
+ *
+ * It does ONE job: hold a session's incoming feed and say when something arrived. Reading,
+ * answering and everything else stay on the remote `baychat` tools, so the session's view of
+ * the Bay is the same whichever way it was woken.
+ *
+ * stdout is the JSON-RPC channel: diagnostics go to stderr only.
+ */
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const index_js_2 = require("@modelcontextprotocol/sdk/client/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const bays_1 = require("../bays");
+const config_1 = require("../config");
+const ws_1 = require("../relay/ws");
+const detect_1 = require("./detect");
+const feed_1 = require("./feed");
+/** Delivered to Claude as context when this server connects. */
+exports.CHANNEL_INSTRUCTIONS = `This is BayChat's wake-up channel. After join_session, call this server's listen tool with the ` +
+    `confirmed session name (and bay, when the session joined a Bay other than the default). If it ` +
+    `answers active, BayChat messages arrive as <channel source="${detect_1.CHANNEL_MCP_ENTRY}" session="…" ` +
+    `event="messages" conversation_ids="…">: read those conversations with the remote BayChat ` +
+    `get_messages tool (the same Bay's tools the session joined with), obey shouldRespond and answer ` +
+    `in BayChat. Do NOT also open a Monitor or call listen_messages: that would replace this feed. ` +
+    `If listen answers inactive or failed, use listen_messages and a native Monitor as before. ` +
+    `event="reset" means catch up with get_messages; event="stopped" means the feed ended and says why.`;
+const LISTEN_TOOL = {
+    name: "listen",
+    description: "Hear this BayChat session's incoming messages through the Claude Code channel instead of a Monitor. " +
+        "Call once, right after join_session, with the confirmed session name. Answers active (messages will " +
+        "arrive as <channel> events; open no Monitor), inactive (this Claude Code was not started with the " +
+        "channel; use listen_messages + Monitor) or failed (use listen_messages + Monitor).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            session: { type: "string", description: "The session name join_session confirmed." },
+            bay: {
+                type: "string",
+                description: "The Bay the session joined, when it is not this computer's default Bay (its name or baychat-<bay> entry).",
+            },
+        },
+        required: ["session"],
+    },
+};
+/** The real login lookup: the default Bay, or a named one from `credentials.json`. */
+function realLogin(bay) {
+    const device = (0, config_1.loadDeviceCredentials)();
+    if (!device)
+        throw new Error("This computer is not signed in to BayChat. Run `baychat login`.");
+    const bays = (0, config_1.loadBayLogins)();
+    if (bay === undefined || !bay.trim()) {
+        const def = bays.find((b) => b.isDefault);
+        return { baseUrl: device.baseUrl, token: device.token, expiresAt: device.expiresAt, ...(def ? { bayName: def.bayName } : {}) };
+    }
+    const found = (0, bays_1.findBayLogin)(bays, bay);
+    return { baseUrl: device.baseUrl, token: found.token, expiresAt: found.expiresAt, bayName: found.bayName };
+}
+/** One remote tool call over the BayChat HTTP MCP endpoint, then disconnect. */
+async function realCallTool(login, name, args) {
+    const client = new index_js_2.Client({ name: "baychat-channel", version: "1" });
+    try {
+        await client.connect(new streamableHttp_js_1.StreamableHTTPClientTransport(new URL("/api/mcp", login.baseUrl), {
+            requestInit: {
+                headers: { Authorization: `Bearer ${login.token}` },
+                signal: AbortSignal.timeout(15_000),
+            },
+        }));
+        return (await client.callTool({ name, arguments: args }));
+    }
+    finally {
+        await client.close().catch(() => {
+            /* The call already finished or failed; a failed close has nothing left to release. */
+        });
+    }
+}
+/** Node's built-in WebSocket with subprotocols (the ticket rides in them, never the URL). */
+const nodeFeedConnect = (url, protocols, handlers) => {
+    const ctor = globalThis.WebSocket;
+    if (typeof ctor !== "function") {
+        throw new ws_1.WebSocketUnavailableError("this Node has no built-in WebSocket (Node 22 or newer is needed for the channel)");
+    }
+    const ws = new ctor(url, protocols);
+    ws.onopen = () => handlers.onOpen();
+    ws.onmessage = (ev) => handlers.onMessage(typeof ev?.data === "string" ? ev.data : String(ev?.data ?? ""));
+    ws.onerror = (ev) => handlers.onError(typeof ev?.message === "string" && ev.message ? ev.message : "socket error");
+    ws.onclose = (ev) => handlers.onClose(typeof ev?.code === "number" ? ev.code : 1006, ev?.reason ?? "");
+    return { send: (data) => ws.send(data), close: (code, reason) => ws.close(code, reason) };
+};
+exports.nodeFeedConnect = nodeFeedConnect;
+function resultText(result) {
+    return (result.content ?? [])
+        .filter((c) => c.type === "text" && typeof c.text === "string")
+        .map((c) => c.text)
+        .join("\n")
+        .trim();
+}
+/** HTTP status of a refused MCP request, when the SDK error carries one. */
+function httpStatus(err) {
+    const code = err?.code;
+    return typeof code === "number" ? code : undefined;
+}
+/**
+ * Mint a listener ticket through `listen_messages`. Fatal only when retrying cannot help: the
+ * session is gone, or the login was refused or ran out. Everything else (offline, a restart,
+ * the per-minute limit) is retried by the feed.
+ */
+async function mintTicket(deps, bay, session, cursor) {
+    let login;
+    try {
+        login = deps.login(bay);
+    }
+    catch (err) {
+        return { ok: false, fatal: true, detail: err instanceof Error ? err.message : String(err) };
+    }
+    const expires = Date.parse(login.expiresAt);
+    if (login.expiresAt && Number.isFinite(expires) && expires <= Date.now()) {
+        return { ok: false, fatal: true, detail: "This computer's BayChat login has expired. Run `baychat login`." };
+    }
+    try {
+        const result = await deps.callTool(login, "listen_messages", { session, ...(cursor ? { cursor } : {}) });
+        const text = resultText(result);
+        if (result.isError) {
+            const fatal = /no live session|SESSION_NOT_FOUND|not a member|cannot delegate/i.test(text);
+            return { ok: false, fatal, detail: text || "BayChat refused to open the feed." };
+        }
+        const structured = (result.structuredContent ?? safeJson(text));
+        const ws = structured?.monitor?.ws;
+        if (typeof ws?.url !== "string" || !Array.isArray(ws.protocols) || !ws.protocols.every((p) => typeof p === "string")) {
+            return { ok: false, fatal: false, detail: "BayChat's answer had no feed address." };
+        }
+        return { ok: true, ticket: { url: ws.url, protocols: ws.protocols } };
+    }
+    catch (err) {
+        const status = httpStatus(err);
+        if (status === 401 || status === 403) {
+            return { ok: false, fatal: true, detail: "BayChat refused this computer's login. Run `baychat login`." };
+        }
+        return { ok: false, fatal: false, detail: err instanceof Error ? err.message : String(err) };
+    }
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function toolResult(status, text, extra = {}) {
+    return { content: [{ type: "text", text }], structuredContent: { status, ...extra } };
+}
+/** The tool-call side of the server, separate from stdio so the tests drive it directly. */
+class ChannelService {
+    deps;
+    push;
+    feeds = new Map();
+    constructor(deps, push) {
+        this.deps = deps;
+        this.push = push;
+    }
+    async listen(args) {
+        const session = typeof args.session === "string" ? args.session.trim() : "";
+        if (!session)
+            return { content: [{ type: "text", text: "Pass session: the name join_session confirmed." }], isError: true };
+        const bay = typeof args.bay === "string" && args.bay.trim() ? args.bay.trim() : undefined;
+        const evidence = this.deps.detect();
+        if (!evidence.active) {
+            return toolResult("inactive", `Inactive: this Claude Code session was not started with the BayChat channel, so its events would be ` +
+                `dropped. Use listen_messages and a native Monitor for session "${session}" as usual. To use the channel ` +
+                `next time, start Claude Code with \`baychat start\`, or \`claude ${detect_1.DEV_CHANNELS_FLAG} ${detect_1.CHANNEL_FLAG_VALUE}\`.`, { session });
+        }
+        let bayName;
+        try {
+            bayName = this.deps.login(bay).bayName;
+        }
+        catch (err) {
+            return toolResult("failed", `Failed: ${err instanceof Error ? err.message : String(err)} Use listen_messages and a native Monitor instead.`, { session });
+        }
+        const key = `${bayName ?? ""}\u0000${session}`;
+        this.feeds.get(key)?.stop();
+        const feed = new feed_1.ChannelFeed({
+            session,
+            ...(bayName ? { bayName } : {}),
+            mint: (cursor) => mintTicket(this.deps, bay, session, cursor),
+            connect: this.deps.connect,
+            status: async () => {
+                try {
+                    const result = await this.deps.callTool(this.deps.login(bay), "get_delivery_status", { session });
+                    if (result.isError)
+                        return "unknown";
+                    const s = result.structuredContent?.status ?? safeJsonStatus(resultText(result));
+                    return s === "connected" || s === "disconnected" ? s : "unknown";
+                }
+                catch {
+                    return "unknown";
+                }
+            },
+            push: this.push,
+            log: this.deps.log,
+            ...this.deps.feedOverrides,
+        });
+        this.feeds.set(key, feed);
+        const started = await feed.start();
+        if (!started.ok) {
+            this.feeds.delete(key);
+            return toolResult("failed", `Failed: ${started.detail} Use listen_messages and a native Monitor instead.`, { session });
+        }
+        return toolResult("active", `Active: session "${session}"${bayName ? ` (${bayName})` : ""} now hears the Bay through the channel. New messages ` +
+            `arrive here as <channel source="${detect_1.CHANNEL_MCP_ENTRY}"> events, with no deadline and no re-arming. Do NOT open a ` +
+            `Monitor or call listen_messages — either would replace this feed. Now read one get_messages batch (limit 10) ` +
+            `to catch up on anything from before listening.`, { session, ...(bayName ? { bay: bayName } : {}), how: evidence.how });
+    }
+    stopAll() {
+        for (const feed of this.feeds.values())
+            feed.stop();
+        this.feeds.clear();
+    }
+}
+exports.ChannelService = ChannelService;
+function safeJsonStatus(text) {
+    const parsed = safeJson(text);
+    return parsed?.status;
+}
+/** Boot on stdio and block on the transport. */
+async function startChannelServer(deps) {
+    const log = deps?.log ?? ((line) => console.error(`[baychat channel] ${line}`));
+    const mcp = new index_js_1.Server({ name: detect_1.CHANNEL_MCP_ENTRY, version: "1" }, {
+        capabilities: { experimental: { "claude/channel": {} }, tools: {} },
+        instructions: exports.CHANNEL_INSTRUCTIONS,
+    });
+    const service = new ChannelService({
+        login: deps?.login ?? realLogin,
+        detect: deps?.detect ?? (() => (0, detect_1.detectChannel)()),
+        callTool: deps?.callTool ?? realCallTool,
+        connect: deps?.connect ?? exports.nodeFeedConnect,
+        log,
+    }, async (content, meta) => {
+        try {
+            await mcp.notification({ method: "notifications/claude/channel", params: { content, meta } });
+        }
+        catch (err) {
+            log(`could not hand an event to Claude Code: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    mcp.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: [LISTEN_TOOL] }));
+    mcp.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+        if (req.params.name === LISTEN_TOOL.name)
+            return service.listen((req.params.arguments ?? {}));
+        return { content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }], isError: true };
+    });
+    // Claude Code closes our stdin when the session ends. An open feed socket would otherwise
+    // keep this process alive with nobody left to tell, holding the session "connected".
+    const shutdown = () => {
+        service.stopAll();
+        process.exit(0);
+    };
+    mcp.onclose = shutdown;
+    process.stdin.once("end", shutdown);
+    process.stdin.once("close", shutdown);
+    await mcp.connect(new stdio_js_1.StdioServerTransport());
+    log("ready on stdio");
+}