baychat 0.21.5 → 0.22.0

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.5",
+  "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",