baychat 0.27.0 → 0.28.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "baychat",
+  "displayName": "BayChat",
+  "description": "Wakes this Claude Code session the moment a BayChat message arrives: no Monitor, no 30-minute deadline. Uses the baychat CLI already on this computer (npm install -g baychat, then baychat login).",
+  "author": { "name": "BayChat", "url": "https://baychat.io" },
+  "homepage": "https://baychat.io",
+  "keywords": ["baychat", "chat", "channel", "mobile", "notifications"],
+  "mcpServers": {
+    "channel": { "command": "baychat", "args": ["channel"] }
+  },
+  "channels": [{ "server": "channel", "displayName": "BayChat" }]
+}

package/README.md

@@ -112,8 +112,8 @@ 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 start` (or `claude --dangerously-load-development-channels server:baychat_channel`)
+a local Claude Code channel (as the `baychat` plugin, from https://baychat.io/claude/marketplace.json). 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.

package/dist/channel/detect.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEV_CHANNELS_FLAG = exports.CHANNEL_FLAG_VALUE = exports.CHANNEL_MCP_ENTRY = void 0;
+exports.DEV_CHANNELS_FLAG = exports.PLUGIN_FLAG_VALUE = exports.PLUGIN_ID = exports.CHANNEL_FLAG_VALUE = exports.CHANNEL_MCP_ENTRY = void 0;
+exports.isOurChannelValue = isOurChannelValue;
 exports.argsEnableChannel = argsEnableChannel;
 exports.realProcessReader = realProcessReader;
 exports.detectChannel = detectChannel;
@@ -47,12 +48,19 @@ exports.detectChannel = detectChannel;
  * replaced. So `listen` answers active only on evidence, and otherwise sends the session back
  * to `listen_messages` + Monitor.
  *
- * The evidence is the command line Claude Code itself was started with: an ancestor process
- * whose arguments carry `--dangerously-load-development-channels` or `--channels` naming
- * `server:baychat_channel`. Claude Code spawns this server directly, so it is the parent; a few
- * more levels are walked for launchers that wrap it. Where process arguments cannot be read
- * (Windows), `BAYCHAT_CHANNEL=1` — set by `baychat start` on the process it launches with the
- * flag — is accepted instead.
+ * 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"));
@@ -60,6 +68,13 @@ const fs = __importStar(require("node:fs"));
 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}`;
+/** The plugin's id and its channel entry, when BayChat is installed as a Claude Code plugin. */
+exports.PLUGIN_ID = "baychat@baychat";
+exports.PLUGIN_FLAG_VALUE = `plugin:${exports.PLUGIN_ID}`;
+/** Does one channel-flag value name BayChat's channel, as a server or as the plugin (any marketplace)? */
+function isOurChannelValue(value) {
+    return value === exports.CHANNEL_FLAG_VALUE || /^plugin:baychat@[A-Za-z0-9._-]+$/.test(value);
+}
 exports.DEV_CHANNELS_FLAG = "--dangerously-load-development-channels";
 const CHANNEL_FLAGS = [exports.DEV_CHANNELS_FLAG, "--channels"];
 /** How far up the process tree to look. */
@@ -81,7 +96,7 @@ function argsEnableChannel(args) {
             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))
+        if (values.some(isOurChannelValue))
             return true;
     }
     return false;
@@ -121,25 +136,18 @@ function realProcessReader(platform = process.platform) {
 }
 /** Look for the flag on this process's ancestors, then fall back to the env marker. */
 function detectChannel(opts = {}) {
-    const read = opts.read ?? realProcessReader();
     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;
-    let readable = false;
     for (let depth = 0; depth < MAX_DEPTH && pid > 1; depth++) {
         const info = read(pid);
         if (!info)
             break;
-        if (info.args) {
-            readable = true;
-            if (argsEnableChannel(info.args))
-                return { active: true, how: "process" };
-        }
+        if (info.args && argsEnableChannel(info.args))
+            return { active: true, how: "process" };
         pid = info.ppid;
     }
-    // Only where nothing could be read: a readable tree without the flag is a real "no", and an
-    // inherited marker must not overrule it (a plain `claude` started inside a `baychat start`
-    // terminal would carry the marker without the flag).
-    if (!readable && env.BAYCHAT_CHANNEL === "1")
-        return { active: true, how: "env" };
     return { active: false, how: "none" };
 }

package/dist/channel/feed.js

@@ -183,7 +183,7 @@ class ChannelFeed {
             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" }));
+                `this BayChat channel's listen tool again. Until then this session does not hear the Bay.`, this.meta({ event: "stopped" }));
             return;
         }
         this.scheduleReconnect(`could not reconnect (${minted.detail})`);

package/dist/channel/launch.js

@@ -33,13 +33,18 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CHANNEL_LAUNCH_COMMAND = exports.CHANNEL_LAUNCH_ARGS = exports.CHANNEL_MIN_CLAUDE = void 0;
+exports.CHANNEL_ENV = exports.CHANNEL_LAUNCH_COMMAND = exports.PLUGIN_MARKETPLACE_URL = 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;
+exports.claudeUserSettingsPath = claudeUserSettingsPath;
+exports.pluginEnabled = pluginEnabled;
+exports.installPluginWithClaude = installPluginWithClaude;
 /**
  * Getting the channel into Claude Code: registering the server, and starting sessions with it on.
  *
@@ -47,9 +52,11 @@ exports.channelRegistered = channelRegistered;
  * 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
@@ -73,10 +80,62 @@ function claudeSupportsChannel(version) {
     }
     return true;
 }
-/** The arguments `baychat start` adds to a Claude Code launch. */
+/** The arguments that switch the hand-registered channel server on. */
 exports.CHANNEL_LAUNCH_ARGS = [detect_1.DEV_CHANNELS_FLAG, detect_1.CHANNEL_FLAG_VALUE];
+/** Where `claude plugin marketplace add` finds BayChat's plugin catalog (served by the web app). */
+exports.PLUGIN_MARKETPLACE_URL = "https://baychat.io/claude/marketplace.json";
 /** What to type to start Claude Code with the channel on. */
-exports.CHANNEL_LAUNCH_COMMAND = `claude ${exports.CHANNEL_LAUNCH_ARGS.join(" ")}`;
+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 = {}) {
+    // Every way BayChat's channel is installed here, each named on the flag. Both can exist after a
+    // move to the plugin; Claude Code then keeps the hand-registered server and hides the plugin's
+    // duplicate, so naming both is what keeps the channel switched on either way.
+    const entries = [
+        ...((deps.plugin ?? (() => pluginEnabled()))() ? [detect_1.PLUGIN_FLAG_VALUE] : []),
+        ...((deps.registered ?? (() => channelRegistered()))() ? [detect_1.CHANNEL_FLAG_VALUE] : []),
+    ];
+    if (!entries.length)
+        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: [detect_1.DEV_CHANNELS_FLAG, ...entries], 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"];
@@ -109,3 +168,33 @@ function channelRegistered(file = claudeUserConfigPath(), read = (p) => fs.readF
         return false;
     }
 }
+/** Claude Code's user settings, where installed plugins are switched on. */
+function claudeUserSettingsPath(home = os.homedir()) {
+    return path.join(home, ".claude", "settings.json");
+}
+/** Is BayChat's plugin installed and switched on for this user? Unreadable counts as no. */
+function pluginEnabled(file = claudeUserSettingsPath(), read = (p) => fs.readFileSync(p, "utf8")) {
+    try {
+        const parsed = JSON.parse(read(file));
+        return parsed?.enabledPlugins?.[detect_1.PLUGIN_ID] === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Install BayChat as a Claude Code plugin: add the catalog from baychat.io, install from it (the
+ * plugin itself is fetched from the `baychat` npm package), then remove the hand-registered
+ * server, which would otherwise hide the plugin's. Returns false at the first step that fails,
+ * leaving whatever worked before untouched — the caller then registers the server by hand.
+ */
+function installPluginWithClaude(run) {
+    const added = run(["plugin", "marketplace", "add", exports.PLUGIN_MARKETPLACE_URL]);
+    if (added.status !== 0 && !/already/i.test(added.stderr))
+        return false;
+    const installed = run(["plugin", "install", detect_1.PLUGIN_ID]);
+    if (installed.status !== 0 && !/already installed/i.test(installed.stderr))
+        return false;
+    run(["mcp", "remove", "--scope", "user", detect_1.CHANNEL_MCP_ENTRY]); // Absent is fine.
+    return true;
+}

package/dist/channel/permission.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionRelay = exports.RELAY_OPTIONS = void 0;
+exports.composeRelayQuestion = composeRelayQuestion;
+/** Button labels, and the ONLY index that means yes. Same as `baychat approve-hook`. */
+exports.RELAY_OPTIONS = ["Allow this once", "Deny"];
+const ALLOW_INDEX = 0;
+/** One window of the server's wait; it answers "waiting" when nobody tapped yet. */
+const POLL_WAIT_SECONDS = 25;
+const MAX_CONSECUTIVE_FAILURES = 5;
+const RETRY_DELAY_MS = 3_000;
+const QUESTION_MAX = 2_000;
+const PREVIEW_MAX = 1_200;
+function clip(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+/** What the person on the phone reads. They decide from this text alone. */
+function composeRelayQuestion(req, host, session) {
+    const lines = [
+        `Claude Code (session "${session}" on ${host}) asks to use ${req.tool_name}: ${req.description}`,
+        "",
+        req.input_preview ? clip(req.input_preview, PREVIEW_MAX) : "",
+        "",
+        "The same question is open in the terminal; whichever answer comes first counts. " +
+            "Allowing runs it on that machine, now. If you did not expect this, deny.",
+    ];
+    return clip(lines.join("\n").replace(/\n{3,}/g, "\n\n").trim(), QUESTION_MAX);
+}
+class PermissionRelay {
+    deps;
+    current;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Relay one dialog. Resolves when it is settled, superseded, or given up on. Never throws. */
+    async onRequest(req) {
+        await this.retire();
+        const target = this.deps.target();
+        if (!target)
+            return; // Nobody is listening through this channel: the terminal alone decides.
+        const pending = { claudeId: req.request_id, login: target.login, retired: false };
+        this.current = pending;
+        try {
+            let reply = await this.deps.api(target.login, "POST", "/api/device-api/approvals", {
+                session: target.session,
+                question: composeRelayQuestion(req, this.deps.host(), target.session),
+                options: [...exports.RELAY_OPTIONS],
+                // The private chat with the owner: a session is usually in a group too, and a prompt about
+                // one person's machine belongs to that person, not to the room.
+                direct: true,
+                wait: 1,
+            });
+            pending.cardId = typeof reply.requestId === "string" && reply.requestId ? reply.requestId : undefined;
+            if (!pending.cardId) {
+                this.deps.log("permission relay: BayChat returned no card id");
+                return;
+            }
+            let failures = 0;
+            for (;;) {
+                if (pending.retired) {
+                    await this.withdraw(pending);
+                    return;
+                }
+                if (reply.status === "answered") {
+                    await this.deps.verdict(req.request_id, reply.answerIndex === ALLOW_INDEX ? "allow" : "deny");
+                    return;
+                }
+                if (reply.status !== "waiting")
+                    return; // cancelled, or a status we do not know: no verdict.
+                try {
+                    reply = await this.deps.api(pending.login, "GET", `/api/device-api/approvals/${encodeURIComponent(pending.cardId)}?wait=${POLL_WAIT_SECONDS}`);
+                    failures = 0;
+                }
+                catch (err) {
+                    failures++;
+                    this.deps.log(`permission relay: waiting failed (${err instanceof Error ? err.message : String(err)}), attempt ${failures}`);
+                    if (failures >= MAX_CONSECUTIVE_FAILURES) {
+                        // Give the decision back to the terminal alone, and take the card off the phone.
+                        await this.withdraw(pending);
+                        return;
+                    }
+                    await (this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(RETRY_DELAY_MS);
+                }
+            }
+        }
+        catch (err) {
+            this.deps.log(`permission relay: could not ask BayChat (${err instanceof Error ? err.message : String(err)}); the terminal still decides`);
+        }
+        finally {
+            if (this.current === pending)
+                this.current = undefined;
+        }
+    }
+    /** The current dialog is over (a newer one opened, or shutdown): stop and withdraw its card. */
+    async retire() {
+        const pending = this.current;
+        if (!pending)
+            return;
+        pending.retired = true;
+        this.current = undefined;
+        await this.withdraw(pending);
+    }
+    async withdraw(pending) {
+        if (!pending.cardId)
+            return; // Not created yet: the create path sees `retired` and withdraws.
+        const cardId = pending.cardId;
+        pending.cardId = undefined;
+        try {
+            await this.deps.api(pending.login, "POST", `/api/device-api/approvals/${encodeURIComponent(cardId)}/withdraw`, {});
+        }
+        catch (err) {
+            // An older server (no route) or a blip: the card stays up, and a tap on it is dropped by
+            // Claude Code as an unknown id. Untidy, never unsafe.
+            this.deps.log(`permission relay: could not withdraw card ${cardId} (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+}
+exports.PermissionRelay = PermissionRelay;

package/dist/channel/server.js

@@ -1,4 +1,37 @@
 "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.ChannelService = exports.nodeFeedConnect = exports.CHANNEL_INSTRUCTIONS = void 0;
 exports.realLogin = realLogin;
@@ -23,20 +56,26 @@ 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 os = __importStar(require("node:os"));
+const zod_1 = require("zod");
+const api_1 = require("../api");
 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");
+const permission_1 = require("./permission");
 /** 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="…" ` +
+    `answers active, BayChat messages arrive as <channel source="…" 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.`;
+    `event="reset" means catch up with get_messages; event="stopped" means the feed ended and says why. ` +
+    `Tool-permission prompts are also offered to the session's owner as a BayChat card; answer in the terminal or ` +
+    `on the phone, whichever is first.`;
 const LISTEN_TOOL = {
     name: "listen",
     description: "Hear this BayChat session's incoming messages through the Claude Code channel instead of a Monitor. " +
@@ -167,6 +206,8 @@ class ChannelService {
     deps;
     push;
     feeds = new Map();
+    /** The most recent session that listened successfully: where permission prompts go. */
+    last;
     constructor(deps, push) {
         this.deps = deps;
         this.push = push;
@@ -180,7 +221,8 @@ class ChannelService {
         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 });
+                `next time, start Claude Code with \`baychat claude\` (or \`baychat start\`) — the plain \`claude ${detect_1.DEV_CHANNELS_FLAG} ${detect_1.CHANNEL_FLAG_VALUE}\` ` +
+                `works too, except where Claude Code hides its own flags (an npm/Node install).`, { session });
         }
         let bayName;
         try {
@@ -216,17 +258,40 @@ class ChannelService {
         const started = await feed.start();
         if (!started.ok) {
             this.feeds.delete(key);
+            if (this.last?.key === key)
+                this.last = undefined;
             return toolResult("failed", `Failed: ${started.detail} Use listen_messages and a native Monitor instead.`, { session });
         }
+        this.last = { key, session, bay };
         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 ` +
+            `arrive here as <channel event="messages"> 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 });
     }
+    /**
+     * Where a permission prompt goes: the session that most recently started listening, while its
+     * feed is still up. None → the prompt stays in the terminal only.
+     */
+    permissionTarget() {
+        const last = this.last;
+        if (!last)
+            return undefined;
+        const state = this.feeds.get(last.key)?.currentState;
+        if (!state || state === "stopped")
+            return undefined;
+        try {
+            const login = this.deps.login(last.bay);
+            return { session: last.session, login: { baseUrl: login.baseUrl, token: login.token } };
+        }
+        catch {
+            return undefined;
+        }
+    }
     stopAll() {
         for (const feed of this.feeds.values())
             feed.stop();
         this.feeds.clear();
+        this.last = undefined;
     }
 }
 exports.ChannelService = ChannelService;
@@ -234,11 +299,24 @@ function safeJsonStatus(text) {
     const parsed = safeJson(text);
     return parsed?.status;
 }
+/** What Claude Code sends when a tool-approval dialog opens (channels reference). */
+const PermissionRequestSchema = zod_1.z.object({
+    method: zod_1.z.literal("notifications/claude/channel/permission_request"),
+    params: zod_1.z.object({
+        request_id: zod_1.z.string(),
+        tool_name: zod_1.z.string(),
+        description: zod_1.z.string(),
+        input_preview: zod_1.z.string(),
+    }),
+});
 /** 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: {} },
+        // `claude/channel/permission`: Claude Code also offers this channel its tool-approval
+        // dialogs (permission.ts). Safe to declare because only the session's owner can answer the
+        // card it becomes — the docs' condition for declaring it.
+        capabilities: { experimental: { "claude/channel": {}, "claude/channel/permission": {} }, tools: {} },
         instructions: exports.CHANNEL_INSTRUCTIONS,
     });
     const service = new ChannelService({
@@ -255,6 +333,23 @@ async function startChannelServer(deps) {
             log(`could not hand an event to Claude Code: ${err instanceof Error ? err.message : String(err)}`);
         }
     });
+    const relay = new permission_1.PermissionRelay({
+        target: () => service.permissionTarget(),
+        api: (login, method, path, body) => (0, api_1.apiRequest)(login, method, path, body),
+        verdict: async (requestId, behavior) => {
+            try {
+                await mcp.notification({ method: "notifications/claude/channel/permission", params: { request_id: requestId, behavior } });
+            }
+            catch (err) {
+                log(`could not hand a verdict to Claude Code: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        host: () => os.hostname(),
+        log,
+    });
+    mcp.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {
+        void relay.onRequest(params);
+    });
     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)
@@ -265,7 +360,9 @@ async function startChannelServer(deps) {
     // keep this process alive with nobody left to tell, holding the session "connected".
     const shutdown = () => {
         service.stopAll();
-        process.exit(0);
+        // Take any open approval card off the phone before going: its dialog dies with this session.
+        // Bounded, so a dead network cannot hold the exit.
+        void Promise.race([relay.retire(), new Promise((r) => setTimeout(r, 2_000))]).finally(() => process.exit(0));
     };
     mcp.onclose = shutdown;
     process.stdin.once("end", shutdown);

package/dist/claude-onboarding.js

@@ -5,7 +5,8 @@ exports.BAY_CHOICE = exports.CLAUDE_REACHABILITY = exports.CLAUDE_JOIN_STEPS = v
 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),
-   and the \`baychat_channel\` server's \`listen\` when it is present.
+   and BayChat's channel \`listen\` tool when it is present
+   (\`mcp__plugin_baychat_channel__listen\` or \`mcp__baychat_channel__listen\`).
    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.
@@ -24,10 +25,11 @@ 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. **Channel first.** If the \`baychat_channel\` server's \`listen\` tool exists
-   (\`mcp__baychat_channel__listen\`), call it with \`{session: "<confirmed name>"}\`
+3. **Channel first.** If BayChat's channel \`listen\` tool exists
+   (\`mcp__plugin_baychat_channel__listen\` from the plugin, or
+   \`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">\`
+   If it answers **active**, messages now arrive as \`<channel … event="messages">\`
    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:
@@ -60,7 +62,7 @@ exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native WebSocket Moni
 exports.CLAUDE_REACHABILITY = `## Staying reachable — native remote messages
 
 **With the channel** (\`listen\` answered active): each new message arrives as a
-\`<channel source="baychat_channel" event="messages" conversation_ids="…">\` event.
+\`<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

package/dist/connect-claude.js

@@ -66,7 +66,12 @@ function registerChannel() {
         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)())
+        const run = (0, bay_mcp_2.realClaudeRun)();
+        // The plugin first: it updates with the npm package and is the form Anthropic can approve.
+        // Where this Claude Code cannot install it, the same server is registered by hand.
+        if ((0, launch_1.installPluginWithClaude)(run))
+            return "registered";
+        return (0, launch_1.registerChannelWithClaude)(launch, run)
             ? "registered"
             : { skipped: "Claude Code did not accept the channel server." };
     }
@@ -77,8 +82,7 @@ function registerChannel() {
 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(`  Start Claude Code with \`${launch_1.CHANNEL_LAUNCH_COMMAND}\` (or \`baychat start\`) to use it.`);
         console.log("  Without it, incoming messages use the native WebSocket Monitor as before.");
         return;
     }

package/dist/main.js

@@ -16,6 +16,7 @@ const connect_plan_1 = require("./connect-plan");
 const runtimes_1 = require("./runtimes");
 const mcp_1 = require("./mcp");
 const server_1 = require("./channel/server");
+const launch_1 = require("./channel/launch");
 const mcp_config_1 = require("./mcp-config");
 const commands_2 = require("./relay/commands");
 const bays_1 = require("./bays");
@@ -473,6 +474,10 @@ async function main() {
             (0, mcp_config_1.cmdMcpConfig)(args.includes("--client") ? ((0, args_1.flag)(args, "--client") ?? "") : undefined);
             return 0;
         }
+        case "claude":
+            // Claude Code with the BayChat channel on (docs/features/CLAUDE_CODE_CHANNEL.md). Every
+            // argument after `claude` is Claude Code's own.
+            return (0, launch_1.cmdClaude)(args);
         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.

package/dist/skill-bootstrap.js

@@ -5,7 +5,7 @@ exports.renderSkillBootstrap = renderSkillBootstrap;
 function renderSkillBootstrap(runtime) {
     const invocation = runtime === "codex" ? "$baychat" : "/baychat";
     const tools = runtime === "claude"
-        ? "allowed-tools:\n  - Bash\n  - Monitor\n  - mcp__baychat\n  - mcp__baychat_channel\n"
+        ? "allowed-tools:\n  - Bash\n  - Monitor\n  - mcp__baychat\n  - mcp__baychat_channel\n  - mcp__plugin_baychat_channel\n"
         : "";
     return `---
 name: baychat

package/dist/start-command.js

@@ -136,8 +136,9 @@ async function cmdStart(args) {
     // `connect claude` registered the server and this Claude Code is new enough to take the flag
     // (an unknown flag would stop it starting). Otherwise it starts exactly as before and the
     // session listens through a Monitor.
-    const agentArgs = runtime === "claude" ? channelArgs(binary.path) : [];
-    const env = agentArgs.length ? { ...process.env, BAYCHAT_CHANNEL: "1" } : process.env;
+    const channel = runtime === "claude" ? (0, launch_1.channelLaunchFor)(binary.path) : undefined;
+    const agentArgs = channel?.args ?? [];
+    const env = { ...process.env, ...(channel?.env ?? {}) };
     // ALREADY INSIDE ONE? Then just run the agent. Nesting multiplexers sends every prefix
     // key to the wrong one, and the person already has everything this command provides.
     const inside = (0, terminal_pane_1.detectPane)();
@@ -241,12 +242,3 @@ function valueAfter(args, flagName) {
     const index = args.indexOf(flagName);
     return index === -1 ? undefined : args[index + 1];
 }
-/** The channel flag for this Claude Code, or nothing when it is not registered or too old. */
-function channelArgs(claudePath) {
-    if (!(0, launch_1.channelRegistered)())
-        return [];
-    const probe = (0, child_process_1.spawnSync)(claudePath, ["--version"], { encoding: "utf8", timeout: 10_000 });
-    if (probe.error || probe.status !== 0)
-        return [];
-    return (0, launch_1.claudeSupportsChannel)((0, launch_1.parseClaudeVersion)(String(probe.stdout ?? ""))) ? [...launch_1.CHANNEL_LAUNCH_ARGS] : [];
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "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"
@@ -37,6 +37,7 @@
   ],
   "files": [
     "dist",
+    ".claude-plugin",
     "README.md",
     "LICENSE"
   ],