baychat 0.21.4 → 0.22.0

package/dist/start-command.js

@@ -0,0 +1,235 @@
+"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.START_RUNTIMES = void 0;
+exports.startRefusal = startRefusal;
+exports.cmdStart = cmdStart;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const config_1 = require("./config");
+const terminal_pane_1 = require("./relay/terminal-pane");
+const profiles_1 = require("./relay/profiles");
+const runtime_binary_1 = require("./runtime-binary");
+const update_command_1 = require("./update-command");
+/**
+ * `baychat start [name]` — the whole product in one command.
+ *
+ * ── THE BAR THIS EXISTS TO MEET ───────────────────────────────────────────────────────
+ *
+ * Karmen's, 2026-09-14: *"everything we do we have to make very easy, basically just
+ * download baychat, and then start session, nothing else."*
+ *
+ * So: this launches the person's agent, inside a terminal multiplexer when one is
+ * available, and says nothing about multiplexers at all. They type one word. `/clear` and
+ * `/new` from the app then work, because `relay attach` finds `$TMUX`/`$TMUX_PANE` waiting
+ * for it — and if no multiplexer is installed, the agent still starts and everything except
+ * those two commands still works. **The fallback is silent on purpose.** A warning about a
+ * program they have never heard of, at the moment they are trying to start work, is exactly
+ * the "something else" this command exists to remove.
+ *
+ * ── WHY NOT A PSEUDO-TERMINAL OF OUR OWN ──────────────────────────────────────────────
+ *
+ * `node-pty` would remove the multiplexer requirement completely and work on Windows too.
+ * It is 64 MB unpacked and compiles through node-gyp on install, so `npx baychat` would
+ * start demanding a C++ toolchain — which fails for everyone, not only the people who
+ * wanted `/clear`. Checked 2026-09-14 and rejected on that basis, not on taste.
+ *
+ * ── WHY IT DOES NOT JUST JOIN, TOO ────────────────────────────────────────────────────
+ *
+ * Joining happens INSIDE the agent (the installed skill runs `baychat join`), because that
+ * is the only place the session's own runtime id, binary and pane can be read. This command
+ * gets the agent into a terminal we can reach; the agent does the rest, exactly as it does
+ * today.
+ */
+const PREFERENCE_FILE = "start-runtime.json";
+/**
+ * Runtimes `start` never probes for or launches. dsh (Ruling R27): it is experimental and
+ * meant to run only in a VM, and BayChat runs it through the relay over ACP
+ * (`baychat connect dsh`), which enforces its modes — a terminal launch would not.
+ */
+const NOT_STARTED = {
+    dsh: "DeepSeek Harness is not started from here: the relay runs it over ACP. Set it up with `baychat connect dsh`.",
+};
+/** Runtimes worth probing for, best-supported first. */
+exports.START_RUNTIMES = ["claude", "codex", ...profiles_1.RUNTIME_PROFILES.map((p) => p.id)].filter((id) => !Object.hasOwn(NOT_STARTED, id));
+/** Why `start` will not launch `runtime`, or undefined when it will. */
+function startRefusal(runtime) {
+    return Object.hasOwn(NOT_STARTED, runtime) ? NOT_STARTED[runtime] : undefined;
+}
+async function cmdStart(args) {
+    if (!(0, config_1.loadDeviceCredentials)()) {
+        console.error("This machine is not signed in yet. Run `npx baychat login` first.");
+        return 1;
+    }
+    // THE UPDATE NOBODY HAS TO REMEMBER.
+    //
+    // Shipping a CLI change reaches nobody until the package is refetched, every connected
+    // client's config is rewritten, and the relay is restarted — a live daemon holds old code
+    // in memory indefinitely. Three steps, in different places, and the failure is silence.
+    // So the one command people actually run does them, once a day.
+    //
+    // ⚠️ NEVER BLOCKS STARTING WORK. Any failure — offline, npm down, a permissions problem —
+    // is swallowed: the agent starts anyway. An update is an improvement to a session, never
+    // a precondition for one, and a person who cannot start their agent because a background
+    // refresh failed would rightly never trust this command again.
+    if (!args.includes("--no-update") && (0, update_command_1.autoUpdateDue)()) {
+        try {
+            await (0, update_command_1.cmdUpdate)({ quiet: true });
+        }
+        catch {
+            /* Starting the agent matters more than being current. */
+        }
+    }
+    const runtimeFlag = valueAfter(args, "--runtime");
+    const positional = args.filter((a) => !a.startsWith("--") && a !== runtimeFlag);
+    const name = positional[0]?.trim();
+    const runtime = runtimeFlag ?? (await chooseRuntime());
+    if (!runtime)
+        return 1;
+    const refusal = startRefusal(runtime);
+    if (refusal) {
+        console.error(refusal);
+        return 1;
+    }
+    const binary = (0, runtime_binary_1.resolveRuntimeBinary)(runtime, (0, runtime_binary_1.currentBinaryEnv)());
+    if (!binary.ok) {
+        console.error(`Could not start ${runtime}: ${binary.reason}`);
+        return 1;
+    }
+    // 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)();
+    const multiplexer = inside ? undefined : firstAvailable(["tmux", "screen"]);
+    if (!multiplexer) {
+        const result = (0, child_process_1.spawnSync)(binary.path, [], { stdio: "inherit" });
+        return result.status ?? 0;
+    }
+    const sessionName = name || "baychat";
+    const argv = multiplexer === "tmux"
+        ? // `-A` attaches to an existing session of that name instead of failing, so running
+            // this twice returns you to your agent rather than erroring at you.
+            ["new", "-A", "-s", sessionName, binary.path]
+        : ["-S", sessionName, "-R", binary.path];
+    const result = (0, child_process_1.spawnSync)(multiplexer, argv, { stdio: "inherit" });
+    if (result.error) {
+        // Falling back rather than failing: the multiplexer is an enhancement, and refusing to
+        // start somebody's agent because of one would be the tail wagging the dog.
+        const direct = (0, child_process_1.spawnSync)(binary.path, [], { stdio: "inherit" });
+        return direct.status ?? 0;
+    }
+    return result.status ?? 0;
+}
+/**
+ * Which agent to start.
+ *
+ * Asks only when it genuinely cannot tell — one installed runtime needs no question — and
+ * remembers the answer, because being asked the same thing every morning is "something
+ * else" by another name.
+ */
+async function chooseRuntime() {
+    const remembered = readPreference();
+    if (remembered)
+        return remembered;
+    const env = (0, runtime_binary_1.currentBinaryEnv)();
+    const installed = [...new Set(exports.START_RUNTIMES)].filter((id) => (0, runtime_binary_1.resolveRuntimeBinary)(id, env).ok);
+    if (installed.length === 0) {
+        console.error("No coding agent found on this machine. Install one (Claude Code or Codex) and run this again.");
+        return undefined;
+    }
+    if (installed.length === 1) {
+        writePreference(installed[0]);
+        return installed[0];
+    }
+    console.log("Which agent should BayChat start?");
+    installed.forEach((id, index) => console.log(`  ${index + 1}. ${id}`));
+    const answer = await ask(`Choose 1-${installed.length}: `);
+    const chosen = installed[Number(answer.trim()) - 1];
+    if (!chosen) {
+        console.error("Not one of the options.");
+        return undefined;
+    }
+    writePreference(chosen);
+    return chosen;
+}
+function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+    }));
+}
+function preferencePath() {
+    return path.join((0, config_1.configDir)(), PREFERENCE_FILE);
+}
+function readPreference() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(preferencePath(), "utf8"));
+        return typeof raw.runtime === "string" ? raw.runtime : undefined;
+    }
+    catch {
+        // Absent or unreadable is simply "not chosen yet" — never an error worth showing.
+        return undefined;
+    }
+}
+function writePreference(runtime) {
+    try {
+        fs.mkdirSync((0, config_1.configDir)(), { recursive: true });
+        fs.writeFileSync(preferencePath(), JSON.stringify({ runtime }, null, 2));
+    }
+    catch {
+        // Not remembering costs one question next time. Never worth failing a start for.
+    }
+}
+/**
+ * The first of these that RUNS, not the first on the PATH.
+ *
+ * The distinction has already cost this codebase a week: the relay's runtime probe picked a
+ * binary that existed and could not start, and resolution fell through to a version too old
+ * for the feature it was being asked for.
+ */
+function firstAvailable(candidates) {
+    for (const candidate of candidates) {
+        const probe = (0, child_process_1.spawnSync)(candidate, ["--version"], { stdio: "ignore" });
+        if (!probe.error && probe.status === 0)
+            return candidate;
+    }
+    return undefined;
+}
+function valueAfter(args, flagName) {
+    const index = args.indexOf(flagName);
+    return index === -1 ? undefined : args[index + 1];
+}

package/dist/update-command.js

@@ -0,0 +1,201 @@
+"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.cmdUpdate = cmdUpdate;
+exports.autoUpdateDue = autoUpdateDue;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const credential_refresh_1 = require("./credential-refresh");
+const commands_1 = require("./commands");
+const client_paths_1 = require("./client-paths");
+const commands_2 = require("./relay/commands");
+/**
+ * `baychat update` — bring this whole machine onto the current version, in one word.
+ *
+ * ── THE PROBLEM IT EXISTS TO END ──────────────────────────────────────────────────────
+ *
+ * Karmen, 2026-09-14: *"it's not every time when we make an update the person has to
+ * update three different things from two different terminals… I just want it to be like
+ * `baychat update` and everything reloads."*
+ *
+ * She is describing something this project has been bitten by repeatedly. Shipping a CLI
+ * change reaches NOBODY until, on every machine: the package is refetched, each connected
+ * client's MCP config is rewritten, and **the relay daemon is restarted** — a live daemon
+ * holds the old code in memory and will happily keep running it for weeks. Three steps, in
+ * different places, none of them discoverable, and the failure is silence rather than an
+ * error.
+ *
+ * ── IT REFRESHES WHAT IS ALREADY THERE, AND CONNECTS NOTHING NEW ──────────────────────
+ *
+ * Every step is idempotent and every step is a RE-application of a decision the person
+ * already made. `refreshExistingClientConfigs` only rewrites config files that already
+ * name BayChat; Claude Code is only re-registered if its binary is present; Hermes only if
+ * `~/.hermes` exists. Running this on a machine that has never been connected does
+ * nothing, loudly — which is the right answer, because "update" must never quietly become
+ * "set up", and a command that installed things would not be safe to run automatically.
+ *
+ * And it must be safe to run automatically, because that is the second half of her ask:
+ * `baychat start` calls this on a day-boundary so nobody has to remember it at all.
+ */
+/** How often `start` re-checks, when it is driving. One a day is invisible; one an hour is a tax. */
+const AUTO_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const STAMP_FILE = "last-update-check.json";
+async function cmdUpdate(opts = {}) {
+    const say = (line) => {
+        if (!opts.quiet)
+            console.log(line);
+    };
+    const device = (0, config_1.loadDeviceCredentials)();
+    if (!device) {
+        console.error("This machine is not signed in, so there is nothing to update. Run `npx baychat login` first.");
+        return 1;
+    }
+    const done = [];
+    // 1. THE PACKAGE. Only a global install can be upgraded in place; an npx run already
+    //    fetched whatever npx had cached, and the honest advice there is `@latest`.
+    const packageStep = updatePackage();
+    if (packageStep)
+        done.push(packageStep);
+    // 2. EVERY CONNECTED CLIENT's copy of the credential and endpoint.
+    try {
+        const updated = (0, credential_refresh_1.refreshExistingClientConfigs)({ url: `${device.baseUrl}/api/mcp`, token: device.token }, commands_1.realConfigIo, (0, client_paths_1.currentPathEnv)());
+        for (const file of updated)
+            done.push(`refreshed ${file}`);
+    }
+    catch (err) {
+        // Never fatal: the next steps are independent, and a machine that failed one of four
+        // is better off doing the other three than stopping at the first.
+        say(`  Could not refresh client configs: ${errText(err)}`);
+    }
+    // 3. CLAUDE CODE, which is not an MCP-config client and registers through its own CLI.
+    if (hasBinary("claude") && (0, commands_1.registerWithClaude)(device.baseUrl, device.token)) {
+        done.push("re-registered BayChat with Claude Code");
+    }
+    // 4. THE RELAY — the step people forget, and the one that silently keeps old code
+    //    running. Stopped and started rather than signalled: the daemon loads its code at
+    //    process start, so nothing short of a restart picks up a new version.
+    try {
+        await (0, commands_2.cmdRelayStop)();
+    }
+    catch {
+        // Not running is the normal case on a fresh boot, and is not a failure to report.
+    }
+    const relay = await (0, commands_2.ensureRelayInstalled)();
+    done.push(relay.startsWith("Relay:") ? relay.toLowerCase() : relay);
+    writeStamp();
+    if (done.length === 0) {
+        say("Everything was already up to date.");
+        return 0;
+    }
+    if (opts.quiet) {
+        // Driven by `start`: one line, because the person asked to begin work, not to read a
+        // report. The full account is available by running the command by hand.
+        console.log(`BayChat updated (${done.length} step${done.length === 1 ? "" : "s"}).`);
+        return 0;
+    }
+    console.log("Updated this machine:");
+    for (const line of done)
+        console.log(`  ✓ ${line}`);
+    return 0;
+}
+/**
+ * Has it been long enough for `start` to check again?
+ *
+ * A stamp rather than a version comparison: the point is to bound how often the network is
+ * touched on a path whose whole job is to start work quickly.
+ */
+function autoUpdateDue(now = Date.now()) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(stampPath(), "utf8"));
+        if (typeof raw.at !== "number")
+            return true;
+        return now - raw.at >= AUTO_CHECK_INTERVAL_MS;
+    }
+    catch {
+        // Never checked, or unreadable — checking is the safe answer.
+        return true;
+    }
+}
+function stampPath() {
+    return path.join((0, config_1.configDir)(), STAMP_FILE);
+}
+function writeStamp() {
+    try {
+        fs.mkdirSync((0, config_1.configDir)(), { recursive: true });
+        fs.writeFileSync(stampPath(), JSON.stringify({ at: Date.now() }));
+    }
+    catch {
+        // Costs one extra check tomorrow. Never worth failing an update for.
+    }
+}
+/**
+ * Upgrade the package itself, where that is a thing this process can do.
+ *
+ * ⚠️ AN `npx` RUN CANNOT UPGRADE ITSELF, and pretending otherwise is worse than saying so:
+ * npx resolves from its own cache, so `npx baychat` can keep running a version from weeks
+ * ago while reporting success at every step. The honest output there is the one flag that
+ * fixes it.
+ */
+function updatePackage() {
+    const globalInstall = isGlobalInstall();
+    if (!globalInstall) {
+        console.log("Tip: `npx baychat` can run a cached older copy. Use `npx baychat@latest` (or install it once with `npm i -g baychat`) so updates land.");
+        return undefined;
+    }
+    const result = (0, child_process_1.spawnSync)("npm", ["install", "-g", "baychat@latest"], {
+        encoding: "utf8",
+        timeout: 120_000,
+    });
+    if (result.status !== 0) {
+        console.log(`  Could not upgrade the package: ${result.stderr?.trim() || "npm failed"}`);
+        return undefined;
+    }
+    return "upgraded the baychat package";
+}
+/** Is this process running from a global npm install, rather than an npx cache? */
+function isGlobalInstall() {
+    const self = process.argv[1] ?? "";
+    // npx unpacks into `_npx` inside the npm cache; a global install never does.
+    return self.includes("node_modules") && !self.includes("_npx");
+}
+function hasBinary(name) {
+    const probe = (0, child_process_1.spawnSync)(name, ["--version"], { stdio: "ignore", timeout: 15_000 });
+    return !probe.error && probe.status === 0;
+}
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.21.4",
+  "version": "0.22.0",
   "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex) with BayChat and chat in groups",
   "bin": {
     "baychat": "dist/index.js"
@@ -13,6 +13,7 @@
     "sync-protocol": "node scripts/sync-protocol.mjs",
     "build": "node scripts/sync-protocol.mjs && node scripts/sync-hermes-plugin.mjs && tsc && node scripts/make-executable.mjs",
     "test": "vitest run",
+    "test:contract": "vitest run src/relay/acp/contract.test.ts",
     "prepublishOnly": "npm run build && npm test"
   },
   "devDependencies": {
@@ -38,6 +39,7 @@
     "LICENSE"
   ],
   "dependencies": {
+    "@agentclientprotocol/sdk": "1.4.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "qrcode": "^1.5.4",
     "yaml": "^2.9.0",