baychat 0.25.2 → 0.26.0

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,6 +3,8 @@ 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");
 /** One-time Claude setup reuses a valid login, registers MCP, and refreshes its skill. */
 async function cmdConnectClaude(opts = {}) {
@@ -32,6 +34,11 @@ 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)

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,

package/dist/main.js

@@ -9,6 +9,7 @@ const start_command_1 = require("./start-command");
 const update_command_1 = require("./update-command");
 const session_command_1 = require("./session-command");
 const doctor_command_1 = require("./doctor-command");
+const bays_command_1 = require("./bays-command");
 const hermes_1 = require("./hermes");
 const connect_1 = require("./connect");
 const connect_plan_1 = require("./connect-plan");
@@ -16,6 +17,8 @@ const runtimes_1 = require("./runtimes");
 const mcp_1 = require("./mcp");
 const mcp_config_1 = require("./mcp-config");
 const commands_2 = require("./relay/commands");
+const bays_1 = require("./bays");
+const config_1 = require("./config");
 const help_topics_1 = require("./help-topics");
 const args_1 = require("./args");
 const owner_pid_1 = require("./relay/owner-pid");
@@ -44,7 +47,7 @@ Usage:
                                         the package, every connected client's config, and
                                         the relay daemon (which otherwise keeps running
                                         old code). \`baychat\` does this for you once a day
-  baychat join [name] [group] [--sessions | --private | --group <title>] [--runtime <runtime>]
+  baychat join [name] [group] [--sessions | --private | --group <title>] [--runtime <runtime>] [--bay <Bay>]
   baychat join --session <name> --group <title> --runtime codex
   baychat skill --runtime codex|claude   Read the current packaged skill workflow
                                         Join and connect incoming messages in this terminal
@@ -69,6 +72,10 @@ Usage:
                                         Log this laptop in to BayChat (QR) and add the
                                         BayChat MCP server to Claude Code. Creates a
                                         device credential only — no agent, no room
+  baychat bays [default <name>]         The Bays this computer is logged in to. One phone
+                                        approval signs an Enterprise owner's computer in to
+                                        the Personal Bay AND its Team Bays; \`default\` picks
+                                        the one a session joins when it names no Bay
   baychat pair <code> [--base <url>]   Redeem a pairing code from the BayChat app
   baychat hermes init [--home <dir>] [--enable]
                                         Install the BayChat platform plugin into a Hermes
@@ -267,6 +274,12 @@ async function main() {
             });
             return loggedIn ? 0 : 2; // 2 = not approved yet, or expired
         }
+        case "bays":
+            if (args.some((arg) => arg === "--help" || arg === "-h")) {
+                console.log(bays_command_1.BAYS_USAGE);
+                return 0;
+            }
+            return (0, bays_command_1.cmdBays)(args);
         case "pair": {
             if (!args[0])
                 throw new Error("Usage: baychat pair <code>");
@@ -395,7 +408,15 @@ async function main() {
                         "--resume-id",
                         "--timeout",
                         "--owner-pid",
-                    ], "baychat relay attach --session <name> [--runtime claude|codex|hermes] [--resume-id <id>] [--timeout <sec>]");
+                        "--bay",
+                    ], "baychat relay attach --session <name> [--runtime claude|codex|hermes] [--resume-id <id>] [--timeout <sec>] [--bay <Bay>]");
+                    // A session in a non-default Bay attaches to THAT Bay's relay (MULTI_BAY_DEVICE_LOGIN.md).
+                    const bayName = (0, args_1.flag)(rest, "--bay");
+                    if (bayName) {
+                        const bay = (0, bays_1.findBayLogin)((0, config_1.loadBayLogins)(), bayName);
+                        if (!bay.isDefault)
+                            (0, commands_2.useBayRelay)(bay.bayId);
+                    }
                     const timeoutSec = numberFlag(rest, "--timeout");
                     return await (0, commands_2.cmdRelayAttach)({
                         session,