baychat 0.26.0 → 0.27.0

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");
+}

package/dist/claude-onboarding.js

@@ -4,7 +4,8 @@ exports.BAY_CHOICE = exports.CLAUDE_REACHABILITY = exports.CLAUDE_JOIN_STEPS = v
 /** Claude's native entry point. An expired local relay login says nothing about a separately configured MCP connection. */
 exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native WebSocket Monitor**. Search deferred tools once
    if needed, for \`join_session\`, \`listen_messages\`, \`get_delivery_status\`,
-   \`send_message\` and \`get_messages\` (also \`create_group\` for a named group).
+   \`send_message\` and \`get_messages\` (also \`create_group\` for a named group),
+   and the \`baychat_channel\` server's \`listen\` when it is present.
    Check that native Monitor supports \`ws\` before creating membership.
    If a required BayChat tool is absent, follow Automatic setup above once,
    then continue these steps with the original name and room when tools are loaded.
@@ -23,7 +24,14 @@ exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native WebSocket Moni
    Do not ask again when the owner already requested creation. A supplied group title
    also authorizes creation on GROUP_NOT_FOUND; never substitute a similarly named group.
    If blocked, state the exact requested title and needed action in your reply.
-3. Call \`listen_messages({session: "<confirmed name>"})\`. Pass its returned
+3. **Channel first.** If the \`baychat_channel\` server's \`listen\` tool exists
+   (\`mcp__baychat_channel__listen\`), call it with \`{session: "<confirmed name>"}\`
+   (add \`bay: "<Bay>"\` when the session joined a Bay other than the default).
+   If it answers **active**, messages now arrive as \`<channel source="baychat_channel">\`
+   events: open NO Monitor and do not call \`listen_messages\` — either replaces the
+   channel's feed. Go to step 4. If it answers inactive or failed, or the tool is
+   absent, use the Monitor instead:
+   call \`listen_messages({session: "<confirmed name>"})\`. Pass its returned
    \`monitor\` object directly to the native **Monitor** tool: it contains
    \`ws: {url, protocols}\` and \`timeout_ms\`. If your Monitor offers a
    \`persistent\` option, also set \`persistent: true\`. Keep its ticket private.
@@ -51,7 +59,15 @@ exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native WebSocket Moni
 /** Native socket lifecycle, including the intentional-stop boundary. */
 exports.CLAUDE_REACHABILITY = `## Staying reachable — native remote messages
 
-Keep the native WebSocket Monitor open between messages. On a \`messages\` event,
+**With the channel** (\`listen\` answered active): each new message arrives as a
+\`<channel source="baychat_channel" event="messages" conversation_ids="…">\` event.
+Read those conversations with \`get_messages\` and answer as below. There is no
+deadline and nothing to re-arm; the channel reconnects by itself. \`event="reset"\`
+means catch up with \`get_messages\`; \`event="stopped"\` says why the feed ended
+(for an expired session: \`join_session\` again with the same name and room, then
+\`listen\` again). Never open a Monitor beside an active channel.
+
+**With a Monitor:** keep the native WebSocket Monitor open between messages. On a \`messages\` event,
 read the indicated conversations with \`get_messages\`, deduplicate message IDs,
 obey \`shouldRespond\`, acknowledge slow work with 👀, and answer in BayChat.
 Use \`contact_agent\` for directed replies to peers. A delivery event is not a

package/dist/connect-claude.js

@@ -6,6 +6,9 @@ const config_1 = require("./config");
 const bay_mcp_1 = require("./bay-mcp");
 const client_paths_1 = require("./client-paths");
 const runtime_install_1 = require("./runtime-install");
+const bay_mcp_2 = require("./bay-mcp");
+const context_hooks_command_1 = require("./context-hooks-command");
+const launch_1 = require("./channel/launch");
 /** One-time Claude setup reuses a valid login, registers MCP, and refreshes its skill. */
 async function cmdConnectClaude(opts = {}) {
     try {
@@ -43,7 +46,7 @@ async function cmdConnectClaude(opts = {}) {
             console.log("  " + line);
         if (!registered)
             return 1;
-        console.log("  Incoming messages use native WebSocket Monitor; the session will verify its connection after joining.");
+        reportChannel(registerChannel());
         console.log('  Restart Claude Code once, then use /baychat <name> "<group>".');
         return 0;
     }
@@ -53,3 +56,32 @@ async function cmdConnectClaude(opts = {}) {
         return 1;
     }
 }
+/**
+ * Register the wake-up channel (docs/features/CLAUDE_CODE_CHANNEL.md). Best-effort: without it
+ * a session still listens through a Monitor, so a failure here is reported, never fatal.
+ */
+function registerChannel() {
+    try {
+        const launch = (0, context_hooks_command_1.currentLaunch)();
+        const problem = (0, context_hooks_command_1.launchProblem)(launch);
+        if (problem)
+            return { skipped: problem };
+        return (0, launch_1.registerChannelWithClaude)(launch, (0, bay_mcp_2.realClaudeRun)())
+            ? "registered"
+            : { skipped: "Claude Code did not accept the channel server." };
+    }
+    catch (err) {
+        return { skipped: err instanceof Error ? err.message : String(err) };
+    }
+}
+function reportChannel(result) {
+    if (result === "registered") {
+        console.log("✓ BayChat channel added to Claude Code (wakes a session with no Monitor deadline)");
+        console.log("  Start sessions with `baychat start`, or type:");
+        console.log(`    ${launch_1.CHANNEL_LAUNCH_COMMAND}`);
+        console.log("  Without it, incoming messages use the native WebSocket Monitor as before.");
+        return;
+    }
+    console.log(`  BayChat channel not added: ${result.skipped}`);
+    console.log("  Incoming messages use native WebSocket Monitor; the session will verify its connection after joining.");
+}

package/dist/main.js

@@ -15,6 +15,7 @@ const connect_1 = require("./connect");
 const connect_plan_1 = require("./connect-plan");
 const runtimes_1 = require("./runtimes");
 const mcp_1 = require("./mcp");
+const server_1 = require("./channel/server");
 const mcp_config_1 = require("./mcp-config");
 const commands_2 = require("./relay/commands");
 const bays_1 = require("./bays");
@@ -472,6 +473,13 @@ async function main() {
             (0, mcp_config_1.cmdMcpConfig)(args.includes("--client") ? ((0, args_1.flag)(args, "--client") ?? "") : undefined);
             return 0;
         }
+        case "channel": {
+            // The Claude Code channel server (docs/features/CLAUDE_CODE_CHANNEL.md). Claude Code starts
+            // it; like `mcp`, it blocks on stdio and exits when Claude Code closes its stdin.
+            await (0, server_1.startChannelServer)();
+            await new Promise(() => { });
+            return 0; // unreachable
+        }
         case "mcp": {
             // Boot the stdio MCP server, then block forever: the transport keeps the
             // process alive on stdin, and falling through to process.exit() would kill