baychat 0.25.3 → 0.27.0

package/dist/claude-onboarding.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLAUDE_REACHABILITY = exports.CLAUDE_JOIN_STEPS = void 0;
+exports.BAY_CHOICE = exports.CLAUDE_REACHABILITY = exports.CLAUDE_JOIN_STEPS = void 0;
 /** 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,11 +24,19 @@ 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 \`persistent: true\`. Keep its ticket private.
-   This is a native WebSocket source, not a shell command. No terminal, relay,
-   attach loop or manual re-arming is needed while this listener remains open.
+   \`ws: {url, protocols}\` and \`timeout_ms\`. If your Monitor offers a
+   \`persistent\` option, also set \`persistent: true\`. Keep its ticket private.
+   This is a native WebSocket source, not a shell command. No terminal, relay or
+   attach loop is needed; when its deadline ends it, reopen it (below).
 4. Call \`get_delivery_status({session: "<confirmed name>"})\`. Only \`connected\`
    confirms incoming delivery. \`awaiting_connection\` means a ticket was created
    but Monitor has not connected; show that exact state, not "ready".
@@ -50,17 +59,31 @@ 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
 model acknowledgement; never claim a message is read just because it arrived.
 
-A \`reset\` event means catch up through history. If the socket closes, Monitor
-has ended: \`persistent: true\` does not reconnect a closed socket by itself.
-Close code **4000** means intentionally stopped or replaced: **do not reconnect**.
-For other closes, call \`listen_messages\` with this session and the last cursor,
-open one replacement native Monitor, and confirm \`get_delivery_status\` again.
+A \`reset\` event means catch up through history. Close code **4000** means
+intentionally stopped or replaced: **do not reconnect**.
+
+**The Monitor has a deadline.** Claude Code ends every Monitor after at most 30
+minutes ("Monitor timed out" / "Monitor expired"), whether or not anything
+arrived. That is the runtime's limit, not a stop: **every time it happens, and on
+any other close**, call \`listen_messages\` with this session and the last cursor
+(from \`ready\` or \`messages\`), open one replacement native Monitor, and confirm
+\`get_delivery_status\` again. The reopened feed replays what it missed, so no
+\`get_messages\` catch-up is needed unless a \`reset\` arrives. Skipping this
+leaves the session deaf to the Bay with its terminal still open.
 Keep the last cursor in this conversation; do not save tickets in files.
 
 \`stop_listening\` stops incoming delivery without ending membership.
@@ -68,3 +91,29 @@ Keep the last cursor in this conversation; do not save tickets in files.
 that has been closed cannot answer until resumed. Do not promise instant model
 replies: show connected delivery separately from actual reading and answering.
 `;
+/**
+ * Picking the Bay (docs/features/MULTI_BAY_DEVICE_LOGIN.md). One approval can sign a computer
+ * in to several Bays, and each is its own MCP connection — `baychat` for the default Bay,
+ * `baychat-<bay>` for each other. A session belongs to exactly one, for every call: tools of
+ * two Bays mixed in one session would post in a different Bay than the one it joined.
+ */
+exports.BAY_CHOICE = `## Which Bay
+
+This computer may be logged in to more than one Bay (one approval gives an
+Enterprise owner their Personal Bay and its Team Bays). Each Bay is its own
+BayChat MCP connection: \`baychat\` is the default Bay, and every other Bay is
+\`baychat-<bay>\` (for example \`baychat-harbor\`). \`baychat bays\` lists them.
+
+- If the user named a Bay (\`--bay <Bay>\`, or "join Harbor"), use THAT Bay's
+  connection for EVERY BayChat call in this session — in Claude Code its tools are
+  \`mcp__baychat-<bay>__…\` (e.g. \`mcp__baychat-harbor__join_session\`), not the
+  plain \`mcp__baychat__…\` ones. Never mix two Bays' tools in one session: a call
+  through another Bay's connection reaches a different Bay.
+- If no Bay was named and more than one \`baychat…\` connection is available, ask the
+  user ONCE which Bay before joining. With only \`baychat\`, use it.
+- \`join_session\` reports the Bay it joined (\`bay.name\`). Say it in your one-line
+  confirmation; if it is not the Bay that was asked for, stop and say so.
+- Shell commands take the same choice: \`baychat join … --bay "<Bay>"\`.
+- A Bay named that has no connection here: say so and suggest \`baychat bays\`
+  (or \`baychat login\` to pick up new Bays). Never fall back to another Bay.
+`;

package/dist/client-config-writer.js

@@ -23,7 +23,9 @@
 //   - Callers back up first (`backupPathFor`), so there is always a way back.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeTomlConfig = mergeTomlConfig;
+exports.removeTomlServer = removeTomlServer;
 exports.mergeJsonConfig = mergeJsonConfig;
+exports.removeJsonServer = removeJsonServer;
 exports.mergeClientConfig = mergeClientConfig;
 exports.backupPathFor = backupPathFor;
 exports.expandHome = expandHome;
@@ -31,9 +33,12 @@ exports.expandHome = expandHome;
  * The TOML table header this owns, and the only span it may replace.
  *
  * Sub-tables (`[mcp_servers.baychat.env]`) belong to the same server and are
- * replaced with it; a header for any OTHER server ends the span.
+ * replaced with it; a header for any OTHER server ends the span — including a
+ * per-Bay `[mcp_servers.baychat-harbor]` (MULTI_BAY_DEVICE_LOGIN.md), which is
+ * its own server with its own name and never part of `baychat`'s span.
  */
 const TOML_TABLE = "mcp_servers.baychat";
+const tomlTable = (serverName) => `mcp_servers.${serverName}`;
 /** Matches a top-level TOML table header line, capturing its dotted key. */
 const TOML_HEADER = /^\s*\[\s*([^\]]+?)\s*\]\s*$/;
 /**
@@ -42,12 +47,26 @@ const TOML_HEADER = /^\s*\[\s*([^\]]+?)\s*\]\s*$/;
  * @param existing current file content, or null when the file does not exist yet
  * @param body the `[mcp_servers.baychat]` block to install
  */
-function mergeTomlConfig(existing, body) {
+function mergeTomlConfig(existing, body, serverName = "baychat") {
     const block = body.trimEnd();
     if (existing === null || existing.trim() === "") {
         return { content: `${block}\n`, action: "created" };
     }
     const lines = existing.split("\n");
+    const { start, end } = tomlSpan(lines, serverName === "baychat" ? TOML_TABLE : tomlTable(serverName));
+    if (start === -1) {
+        // Not present — append, keeping exactly one blank line as a separator so the
+        // result is readable whether or not the file ended with a newline.
+        const prefix = existing.endsWith("\n") ? existing.replace(/\n+$/, "\n") : `${existing}\n`;
+        return { content: `${prefix}\n${block}\n`, action: "appended" };
+    }
+    const before = lines.slice(0, start);
+    const after = lines.slice(end);
+    const merged = [...before, ...block.split("\n"), ...after].join("\n");
+    return { content: merged.endsWith("\n") ? merged : `${merged}\n`, action: "updated" };
+}
+/** The line span `[start, end)` of one server's table (and its sub-tables); start -1 = absent. */
+function tomlSpan(lines, table) {
     let start = -1;
     let end = lines.length;
     for (let i = 0; i < lines.length; i += 1) {
@@ -55,7 +74,7 @@ function mergeTomlConfig(existing, body) {
         if (!match)
             continue;
         const key = (match[1] ?? "").replace(/\s+/g, "");
-        const ours = key === TOML_TABLE || key.startsWith(`${TOML_TABLE}.`);
+        const ours = key === table || key.startsWith(`${table}.`);
         if (start === -1) {
             if (ours)
                 start = i;
@@ -67,16 +86,24 @@ function mergeTomlConfig(existing, body) {
             break;
         }
     }
-    if (start === -1) {
-        // Not present — append, keeping exactly one blank line as a separator so the
-        // result is readable whether or not the file ended with a newline.
-        const prefix = existing.endsWith("\n") ? existing.replace(/\n+$/, "\n") : `${existing}\n`;
-        return { content: `${prefix}\n${block}\n`, action: "appended" };
-    }
+    return { start, end };
+}
+/**
+ * Remove one server's table (and sub-tables) from a TOML config, or `null` when it is not
+ * there. Used only for the `baychat-<bay>` entries this CLI wrote itself.
+ */
+function removeTomlServer(existing, serverName) {
+    const lines = existing.split("\n");
+    const { start, end } = tomlSpan(lines, tomlTable(serverName));
+    if (start === -1)
+        return null;
     const before = lines.slice(0, start);
     const after = lines.slice(end);
-    const merged = [...before, ...block.split("\n"), ...after].join("\n");
-    return { content: merged.endsWith("\n") ? merged : `${merged}\n`, action: "updated" };
+    // Drop the blank separator the append left above it, so add+remove round-trips cleanly.
+    while (before.length > 0 && before[before.length - 1].trim() === "")
+        before.pop();
+    const merged = [...before, ...(after.length && before.length ? [""] : []), ...after].join("\n").replace(/\n+$/, "");
+    return merged === "" ? "" : `${merged}\n`;
 }
 /**
  * Merge the BayChat server entry into a JSON MCP config (Cursor, Claude Desktop).
@@ -86,13 +113,13 @@ function mergeTomlConfig(existing, body) {
  * including a file that is merely mid-edit. Refusing lets the CLI say which file
  * to look at.
  */
-function mergeJsonConfig(existing, body) {
+function mergeJsonConfig(existing, body, serverName = "baychat") {
     // `body` is ours, produced by buildClientConfig — a parse failure here is a bug
     // in this package, not user input, so it is allowed to throw plainly.
     const incoming = JSON.parse(body);
-    const entry = incoming.mcpServers?.baychat;
+    const entry = incoming.mcpServers?.[serverName];
     if (entry === undefined) {
-        throw new Error("Generated config has no mcpServers.baychat entry — this is a bug.");
+        throw new Error(`Generated config has no mcpServers.${serverName} entry — this is a bug.`);
     }
     if (existing === null || existing.trim() === "") {
         return { content: `${JSON.stringify(incoming, null, 2)}\n`, action: "created" };
@@ -109,19 +136,40 @@ function mergeJsonConfig(existing, body) {
     }
     const current = parsed;
     const servers = { ...(current.mcpServers ?? {}) };
-    const had = Object.prototype.hasOwnProperty.call(servers, "baychat");
-    servers.baychat = entry;
+    const had = Object.prototype.hasOwnProperty.call(servers, serverName);
+    servers[serverName] = entry;
     const merged = { ...current, mcpServers: servers };
     return {
         content: `${JSON.stringify(merged, null, 2)}\n`,
         action: had ? "updated" : "appended",
     };
 }
+/**
+ * Remove one server entry from a JSON MCP config, or `null` when it is not there (or the file
+ * is not a JSON object — which is left alone, exactly as the merge leaves it alone).
+ */
+function removeJsonServer(existing, serverName) {
+    let parsed;
+    try {
+        parsed = JSON.parse(existing);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const current = parsed;
+    if (!current.mcpServers || !Object.prototype.hasOwnProperty.call(current.mcpServers, serverName))
+        return null;
+    const servers = { ...current.mcpServers };
+    delete servers[serverName];
+    return `${JSON.stringify({ ...current, mcpServers: servers }, null, 2)}\n`;
+}
 /** Merge by dialect. Keeps the format decision in one place. */
-function mergeClientConfig(config, existing) {
+function mergeClientConfig(config, existing, serverName = "baychat") {
     return config.format === "toml"
-        ? mergeTomlConfig(existing, config.body)
-        : mergeJsonConfig(existing, config.body);
+        ? mergeTomlConfig(existing, config.body, serverName)
+        : mergeJsonConfig(existing, config.body, serverName);
 }
 /**
  * Where to copy a file before rewriting it.

package/dist/commands.js

@@ -20,6 +20,7 @@ exports.cmdWatch = cmdWatch;
 exports.cmdLink = cmdLink;
 exports.quoteForCmd = quoteForCmd;
 exports.claudeMcpAddSpawn = claudeMcpAddSpawn;
+exports.refreshConnectedClients = refreshConnectedClients;
 exports.registerWithClaude = registerWithClaude;
 exports.cmdLogin = cmdLogin;
 exports.deviceExpiryWarning = deviceExpiryWarning;
@@ -35,6 +36,7 @@ const api_1 = require("./api");
 const protocol_1 = require("./protocol");
 const connection_qr_1 = require("./connection-qr");
 const config_1 = require("./config");
+const bay_mcp_1 = require("./bay-mcp");
 const context_1 = require("./context");
 const runtime_install_1 = require("./runtime-install");
 const credential_refresh_1 = require("./credential-refresh");
@@ -818,6 +820,9 @@ async function cmdLogin(opts = {}) {
             console.log(`Approve this device in BayChat, then run baychat login --finish on this same computer. Link expires ${request.expiresAt}.`);
         return true;
     }
+    // Read BEFORE the new login is saved: the per-Bay MCP entries the previous login wrote are
+    // removed when they are no longer wanted (MULTI_BAY_DEVICE_LOGIN.md).
+    const previousBays = (0, config_1.loadBayLogins)();
     if (opts.mode === "finish") {
         const result = await (0, device_login_1.finishDeviceLogin)(opts.base || process.env.BAYCHAT_API_URL);
         if (result.status === "pending") {
@@ -830,6 +835,8 @@ async function cmdLogin(opts = {}) {
         completeDeviceLogin(result.device, {
             ...opts,
             message: `✓ Logged in as ${result.device.user.name}`,
+            bays: result.bays,
+            previousBays,
         });
         console.log("Reconnect BayChat in your client to load the refreshed login, then retry the same session name.");
         return true;
@@ -844,6 +851,7 @@ async function cmdLogin(opts = {}) {
         }, {
             ...opts,
             message: `✓ Logged in as ${me.user.name} (${me.tenant.name})`,
+            previousBays,
         });
         return true;
     }
@@ -894,22 +902,47 @@ async function cmdLogin(opts = {}) {
                 token: status.token,
                 user: status.user,
                 expiresAt: status.expiresAt,
-            }, { ...opts, message: `✓ Logged in as ${status.user.name}` });
+            }, {
+                ...opts,
+                message: `✓ Logged in as ${status.user.name}`,
+                bays: (0, device_login_1.parseBayLogins)(status.bays, status.token),
+                previousBays,
+            });
             return true;
         }
     }
     console.log("Login request expired — run baychat login again.");
     return false;
 }
-/** Persist an approved login before refreshing the clients that use it. */
+/**
+ * Persist an approved login before refreshing the clients that use it.
+ *
+ * `bays` is the per-Bay set a multi-Bay approval delivered (MULTI_BAY_DEVICE_LOGIN.md). The
+ * default Bay is `device` and is written to every client exactly as before; the OTHER Bays are
+ * added beside it as `baychat-<bay>` — only when there are two or more, so a one-Bay login
+ * changes nothing it did not change before.
+ */
 function completeDeviceLogin(device, options) {
-    (0, config_1.saveDeviceCredentials)(device);
+    (0, config_1.saveDeviceCredentials)(device, options.bays);
     console.log(options.message);
+    const bays = options.bays ?? [];
+    if (bays.length > 1) {
+        const names = bays.map((b) => (b.isDefault ? `${b.bayName} (default)` : b.bayName)).join(", ");
+        console.log(`  This computer can join: ${names}`);
+    }
     refreshConnectedClients(device.baseUrl, device.token);
     if (options.registerClaude !== false)
         registerWithClaude(device.baseUrl, device.token);
-    if (options.hint !== false)
+    (0, bay_mcp_1.applyBayEntries)(device.baseUrl, options.previousBays ?? [], bays, {
+        claude: options.registerClaude !== false,
+        io: exports.realConfigIo,
+        env: (0, client_paths_1.currentPathEnv)(),
+    });
+    if (options.hint !== false) {
         console.log("\n  Run /baychat <name> in any session.");
+        if (bays.length > 1)
+            console.log("  In another Bay: /baychat <name> --bay <Bay>. See them all: baychat bays.");
+    }
 }
 /**
  * The renewal nudge for a device credential, or null when none is due. Device

package/dist/config.js

@@ -38,6 +38,7 @@ exports.configDir = configDir;
 exports.saveCredentials = saveCredentials;
 exports.loadCredentials = loadCredentials;
 exports.saveDeviceCredentials = saveDeviceCredentials;
+exports.loadBayLogins = loadBayLogins;
 exports.loadDeviceCredentials = loadDeviceCredentials;
 exports.loadCursor = loadCursor;
 exports.saveCursor = saveCursor;
@@ -141,8 +142,36 @@ function loadCredentials() {
         return null;
     return { baseUrl: String(file.baseUrl ?? exports.DEFAULT_API_URL), token: file.token, agent };
 }
-function saveDeviceCredentials(device) {
-    writeMerged({ device });
+/**
+ * Save a device login. `bays` is the per-Bay set a multi-Bay approval delivered; a login that
+ * delivered none (an older server, `--token`) CLEARS any previous set, so `device` and `bays`
+ * can never describe two different logins. (`undefined` drops the key: JSON.stringify omits it.)
+ */
+function saveDeviceCredentials(device, bays) {
+    writeMerged({ device, bays: bays && bays.length > 0 ? bays : undefined });
+}
+/**
+ * Every Bay login on this computer, or `[]` when the login predates multi-Bay approval, when
+ * the device token comes from `BAYCHAT_DEVICE_TOKEN`, or when the stored set is unusable.
+ * `[]` means exactly today's behaviour: one login, `device`.
+ */
+function loadBayLogins() {
+    if (process.env.BAYCHAT_DEVICE_TOKEN)
+        return [];
+    const raw = loadFile().bays;
+    if (!Array.isArray(raw))
+        return [];
+    const bays = raw.filter((b) => !!b &&
+        typeof b === "object" &&
+        typeof b.bayId === "string" &&
+        typeof b.bayName === "string" &&
+        typeof b.token === "string" &&
+        b.token.length > 0 &&
+        typeof b.expiresAt === "string");
+    // A set with no single default is not one this CLI wrote; trust `device` instead.
+    if (bays.length === 0 || bays.filter((b) => b.isDefault === true).length !== 1)
+        return [];
+    return bays.map((b) => ({ ...b, isDefault: b.isDefault === true }));
 }
 function loadDeviceCredentials() {
     // Same env-override shape as BAYCHAT_TOKEN: a headless/CI box can supply a

package/dist/connect-claude.js

@@ -3,7 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdConnectClaude = cmdConnectClaude;
 const commands_1 = require("./commands");
 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 {
@@ -32,11 +37,16 @@ async function cmdConnectClaude(opts = {}) {
         if (!device)
             throw new Error("No device login was saved. Retry baychat connect claude.");
         const registered = (0, commands_1.registerWithClaude)(device.baseUrl, device.token);
+        // The other Bays this login covers, as `baychat-<bay>` (none for a one-Bay login). Passing
+        // the current set as "previous" too removes only entries that no longer belong — e.g. the
+        // Bay that is now the default.
+        const bays = (0, config_1.loadBayLogins)();
+        (0, bay_mcp_1.applyBayEntries)(device.baseUrl, bays, bays, { claude: true, io: commands_1.realConfigIo, env: (0, client_paths_1.currentPathEnv)() });
         for (const line of (0, runtime_install_1.describeInstall)((0, runtime_install_1.installRuntimeCommand)("claude")))
             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;
     }
@@ -46,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/device-login.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBayLogins = parseBayLogins;
 exports.startDeviceLogin = startDeviceLogin;
 exports.finishDeviceLogin = finishDeviceLogin;
 const fs = __importStar(require("node:fs"));
@@ -42,12 +43,46 @@ const node_crypto_1 = require("node:crypto");
 const zod_1 = require("zod");
 const api_1 = require("./api");
 const config_1 = require("./config");
+const bayLoginSchema = zod_1.z.object({
+    bayId: zod_1.z.string().min(1),
+    bayName: zod_1.z.string(),
+    token: zod_1.z.string().min(1),
+    expiresAt: zod_1.z.string().datetime(),
+    isDefault: zod_1.z.boolean(),
+});
 const deviceSchema = zod_1.z.object({
     baseUrl: zod_1.z.string().url(),
     token: zod_1.z.string().min(1),
     user: zod_1.z.object({ id: zod_1.z.string().min(1), name: zod_1.z.string() }),
     expiresAt: zod_1.z.string().datetime(),
+    /** Every Bay's login (MULTI_BAY_DEVICE_LOGIN.md); absent from an older server. */
+    bays: zod_1.z.array(bayLoginSchema).optional(),
 });
+/**
+ * The per-Bay logins in an approval, or `undefined` to behave exactly as before (one login).
+ *
+ * The set is used only when it is coherent with the top-level token every older reader uses:
+ * exactly one default, and the default's token IS the top-level token. Anything else is
+ * ignored rather than half-trusted — `device` alone still works, and a mismatched set would
+ * route sessions to a Bay the approval did not make the default.
+ */
+function parseBayLogins(raw, topLevelToken) {
+    const parsed = zod_1.z.array(bayLoginSchema.passthrough()).safeParse(raw);
+    if (!parsed.success || parsed.data.length === 0)
+        return undefined;
+    const defaults = parsed.data.filter((b) => b.isDefault);
+    if (defaults.length !== 1 || defaults[0].token !== topLevelToken)
+        return undefined;
+    if (new Set(parsed.data.map((b) => b.bayId)).size !== parsed.data.length)
+        return undefined;
+    return parsed.data.map(({ bayId, bayName, token, expiresAt, isDefault }) => ({
+        bayId,
+        bayName,
+        token,
+        expiresAt,
+        isDefault,
+    }));
+}
 const pendingSchema = zod_1.z.object({
     baseUrl: zod_1.z.string().url(),
     id: zod_1.z.string().min(1),
@@ -105,6 +140,7 @@ async function finishDeviceLogin(baseUrl) {
                 throw new Error("BayChat returned an invalid login status. Run baychat login --start again.");
             const parsed = deviceSchema.safeParse({
                 ...status,
+                bays: parseBayLogins(status.bays, status.token),
                 baseUrl: pending.baseUrl,
             });
             if (!parsed.success)
@@ -114,9 +150,10 @@ async function finishDeviceLogin(baseUrl) {
             // existing credentials fails; the next finish must not consume it again.
             writePending({ ...pending, approved: device });
         }
-        (0, config_1.saveDeviceCredentials)(device);
+        const { bays, ...single } = device;
+        (0, config_1.saveDeviceCredentials)(single, bays);
         fs.unlinkSync(pendingPath());
-        return { status: "approved", device };
+        return { status: "approved", device: single, ...(bays ? { bays } : {}) };
     });
 }
 function pendingPath() {

package/dist/doctor-command.js

@@ -48,6 +48,8 @@ const os = __importStar(require("os"));
 const config_1 = require("./config");
 const doctor_1 = require("./doctor");
 const commands_1 = require("./relay/commands");
+const bay_relays_1 = require("./relay/bay-relays");
+const socket_1 = require("./relay/socket");
 const registry_1 = require("./relay/registry");
 const credential_refresh_1 = require("./credential-refresh");
 const client_paths_1 = require("./client-paths");
@@ -75,7 +77,19 @@ async function currentDoctorEnv() {
     // reached for in the first place.
     const registry = new registry_1.SessionRegistry();
     registry.load();
+    // One line per Bay login; a non-default Bay's relay is its own process (relay/bay-relays.ts).
+    const bays = (0, config_1.loadBayLogins)();
+    const bayRelayAlive = {};
+    if (bays.length > 1) {
+        for (const bay of bays) {
+            if (bay.isDefault)
+                continue;
+            bayRelayAlive[bay.bayId] = await (0, socket_1.probeSocket)((0, bay_relays_1.bayRelayScope)(bay.bayId, (0, config_1.configDir)(), (0, socket_1.socketPath)()).socket);
+        }
+    }
     return {
+        bays,
+        bayRelayAlive,
         home: os.homedir(),
         platform: process.platform,
         now: Date.now(),

package/dist/doctor.js

@@ -60,6 +60,7 @@ exports.mailboxCheck = mailboxCheck;
 exports.acpChecks = acpChecks;
 exports.exitCodeFor = exitCodeFor;
 exports.renderReport = renderReport;
+exports.bayChecks = bayChecks;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -106,6 +107,7 @@ const EXPIRY_WARNING_MS = 3 * 86_400_000;
 function buildReport(env) {
     return {
         credentials: credentialsCheck(env),
+        bays: bayChecks(env),
         relay: relayCheck(env),
         mailbox: mailboxCheck(),
         staleCredentials: staleCredentialCheck(env),
@@ -269,6 +271,8 @@ function exitCodeFor(report) {
 function renderReport(report) {
     const lines = [];
     lines.push(...renderSummaryCheck(report.credentials));
+    for (const check of report.bays)
+        lines.push(...renderSummaryCheck(check));
     lines.push(...renderSummaryCheck(report.staleCredentials));
     lines.push(...renderSummaryCheck(report.relay));
     lines.push(...renderSummaryCheck(report.mailbox));
@@ -286,6 +290,39 @@ function renderReport(report) {
     return lines;
 }
 // ─── Individual checks ──────────────────────────────────────────────────────
+/**
+ * One line per Bay login. An expired Bay login fails exactly as an expired device login does
+ * (`baychat login` renews every Bay at once); a non-default Bay whose relay does not answer
+ * warns, because only that Bay's terminal sessions lose their wake-ups.
+ */
+function bayChecks(env) {
+    const bays = env.bays ?? [];
+    if (bays.length < 2)
+        return [];
+    return bays.map((bay) => {
+        const name = "bay";
+        const label = `"${bay.bayName}"${bay.isDefault ? " (default)" : ""}`;
+        const expiresAt = Date.parse(bay.expiresAt);
+        if (Number.isNaN(expiresAt) || expiresAt <= env.now) {
+            return { name, status: "fail", detail: `${label} — login expired`, remedy: "baychat login" };
+        }
+        const left = remaining(expiresAt - env.now);
+        const alive = bay.isDefault ? undefined : env.bayRelayAlive?.[bay.bayId];
+        const relay = alive === undefined ? "" : alive ? ", relay running" : ", relay NOT running";
+        if (alive === false) {
+            return {
+                name,
+                status: "warn",
+                detail: `${label} — ${left} left${relay}`,
+                remedy: "baychat relay stop && baychat relay start",
+            };
+        }
+        const warn = expiresAt - env.now <= EXPIRY_WARNING_MS;
+        return warn
+            ? { name, status: "warn", detail: `${label} — ${left} left${relay}`, remedy: "baychat login" }
+            : { name, status: "pass", detail: `${label} — ${left} left${relay}` };
+    });
+}
 function credentialsCheck(env) {
     if (!env.device) {
         return {
@@ -599,6 +636,7 @@ function withRemedy(line, check) {
 function allChecks(report) {
     return [
         report.credentials,
+        ...report.bays,
         report.staleCredentials,
         report.relay,
         report.mailbox,