baychat 0.29.9 → 0.31.0

package/dist/start-command.js

@@ -43,6 +43,9 @@ const multiplexer_launch_1 = require("./multiplexer-launch");
 const profiles_1 = require("./relay/profiles");
 const runtime_binary_1 = require("./runtime-binary");
 const update_command_1 = require("./update-command");
+const policy_1 = require("./auto-update/policy");
+const store_1 = require("./auto-update/store");
+const commands_1 = require("./relay/commands");
 const launch_1 = require("./channel/launch");
 /**
  * `baychat start [name]` — the whole product in one command.
@@ -105,7 +108,11 @@ async function cmdStart(args) {
     // 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)()) {
+    //
+    // Since 0.31.0 the relay updates this computer by itself (docs/features/CLI_AUTO_UPDATE.md), in
+    // a quiet moment and without restarting under a running turn. When it says it does, `start`
+    // leaves updating to it; when the person switched automatic updates off, `start` honours that.
+    if (!args.includes("--no-update") && (0, update_command_1.autoUpdateDue)() && (await startShouldUpdate())) {
         try {
             await (0, update_command_1.cmdUpdate)({ quiet: true });
         }
@@ -140,6 +147,13 @@ async function cmdStart(args) {
     // A NAMED session: running `baychat start` again returns you to the agent already running.
     return (0, multiplexer_launch_1.launchAgent)({ binary: binary.path, args: agentArgs, env: channel?.env ?? {} }, { kind: "reattach", name: name || "baychat" });
 }
+/** Is the daily update `start`'s job here, rather than the relay's or nobody's? */
+async function startShouldUpdate() {
+    if ((0, policy_1.autoUpdateOffReason)(process.env, (0, store_1.loadAutoSetting)()))
+        return false;
+    const relay = await (0, commands_1.tryRelayStatus)();
+    return relay?.autoUpdate?.mode !== "auto";
+}
 /**
  * Which agent to start.
  *

package/dist/update-command.js

@@ -39,10 +39,10 @@ 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");
+const refresh_clients_1 = require("./refresh-clients");
+const commands_1 = require("./relay/commands");
+const policy_1 = require("./auto-update/policy");
+const store_1 = require("./auto-update/store");
 const self_upgrade_1 = require("./self-upgrade");
 /**
  * `baychat update` — bring this whole machine onto the current version, in one word.
@@ -76,6 +76,8 @@ const self_upgrade_1 = require("./self-upgrade");
 const AUTO_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const STAMP_FILE = "last-update-check.json";
 async function cmdUpdate(opts = {}) {
+    if (opts.auto !== undefined)
+        return setAutoUpdate(opts.auto);
     const say = (line) => {
         if (!opts.quiet)
             console.log(line);
@@ -93,12 +95,24 @@ async function cmdUpdate(opts = {}) {
         done.push(`upgraded baychat ${upgradedFrom} → ${(0, self_upgrade_1.ownVersion)()}`);
     }
     else {
-        const outcome = (0, self_upgrade_1.upgradePackage)({
-            install: (0, self_upgrade_1.classifyInstall)((0, self_upgrade_1.currentEntry)()),
-            current: (0, self_upgrade_1.ownVersion)(),
-            npm: self_upgrade_1.realNpm,
-            readVersion: self_upgrade_1.readPackageVersion,
-        });
+        // One npm install over this baychat at a time: the relay may be installing one by itself.
+        const unlock = (0, store_1.acquireUpdateLock)();
+        if (!unlock) {
+            console.error("BayChat is updating itself right now (the relay is installing a new version). Try again in a minute.");
+            return 1;
+        }
+        let outcome;
+        try {
+            outcome = await (0, self_upgrade_1.upgradePackage)({
+                install: (0, self_upgrade_1.classifyInstall)((0, self_upgrade_1.currentEntry)()),
+                current: (0, self_upgrade_1.ownVersion)(),
+                npm: self_upgrade_1.realNpm,
+                readVersion: self_upgrade_1.readPackageVersion,
+            });
+        }
+        finally {
+            unlock();
+        }
         const told = (0, self_upgrade_1.describeOutcome)(outcome);
         if (!told.ok) {
             // Never "Updated this machine" over a package that did not move. Stop before the relay
@@ -122,33 +136,22 @@ async function cmdUpdate(opts = {}) {
         if (told.done)
             done.push(told.done);
     }
-    // 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");
-    }
+    // 2 + 3. EVERY CONNECTED CLIENT, and Claude Code.
+    done.push(...(0, refresh_clients_1.refreshConnectedClients)(device, say));
     // 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)();
+        await (0, commands_1.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)();
+    const relay = await (0, commands_1.ensureRelayInstalled)();
     done.push(relay.startsWith("Relay:") ? relay.toLowerCase() : relay);
     writeStamp();
+    // Whatever the relay left for the terminal ("x is available", "updated itself") is answered now.
+    (0, store_1.takeUpdateNotice)();
     if (done.length === 0) {
         say("Everything was already up to date.");
         return 0;
@@ -164,6 +167,27 @@ async function cmdUpdate(opts = {}) {
         console.log(`  ✓ ${line}`);
     return 0;
 }
+/**
+ * `baychat update --auto on|off` — the relay's automatic updates for this computer (default on).
+ * Read by the relay on its next look, within a minute; nothing needs restarting.
+ */
+function setAutoUpdate(value) {
+    if (value !== "on" && value !== "off") {
+        console.error("Usage: baychat update --auto on|off");
+        return 1;
+    }
+    (0, store_1.saveAutoSetting)(value);
+    const envOff = (0, policy_1.autoUpdateOffReason)(process.env, "on");
+    if (value === "off") {
+        console.log("Automatic updates are off on this computer. Update with `baychat update` when you choose; `baychat update --auto on` turns them back on.");
+    }
+    else {
+        console.log("Automatic updates are on: the relay installs new BayChat versions by itself in a quiet moment, and asks on your phone first when a version needs you.");
+        if (envOff)
+            console.log(`Note: ${envOff} is set here, which keeps them off for anything started from this shell.`);
+    }
+    return 0;
+}
 /**
  * Has it been long enough for `start` to check again?
  *
@@ -217,10 +241,6 @@ function runOnNewCode(packageRoot, from, quiet) {
     }
     return child.status ?? 1;
 }
-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/dist/waiting-cards.js

@@ -0,0 +1,107 @@
+"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.markWaitingCard = markWaitingCard;
+exports.countWaitingCards = countWaitingCards;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const parent_watch_1 = require("./relay/parent-watch");
+/**
+ * Which processes on this computer are waiting for a tap on a decision card right now.
+ *
+ * The hooks (`approve-hook`, `denied-hook`) and the Claude Code channel each wait on their own
+ * card in their own process, so nothing else on the machine knows a question is open. The relay's
+ * automatic update must (docs/features/CLI_AUTO_UPDATE.md): it never restarts BayChat while
+ * somebody is about to answer one. So each waiter leaves a marker for as long as it waits —
+ * `~/.baychat/waiting-cards/<pid>-<card id>` — and removes it when done. A crashed waiter's marker
+ * is ignored (and cleared) because its pid is gone; an absurdly old one because pids are reused.
+ */
+/** Longer than any card is waited on (the denied-command card's 3600 s, an approval's day). */
+const MARKER_MAX_AGE_MS = 2 * 24 * 60 * 60 * 1000;
+function markerDir() {
+    return path.join((0, config_1.configDir)(), "waiting-cards");
+}
+/** Mark `cardId` as waited on by this process. Returns the function that ends the mark. Never throws. */
+function markWaitingCard(cardId, pid = process.pid) {
+    const safeId = cardId.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 64) || "card";
+    let file;
+    try {
+        file = path.join(markerDir(), `${pid}-${safeId}`);
+        fs.mkdirSync(markerDir(), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(file, "");
+    }
+    catch {
+        // Without the marker an update might restart the relay mid-question; the card itself still
+        // works, because its wait never goes through the relay. Not worth failing a hook over.
+        return () => undefined;
+    }
+    return () => {
+        try {
+            fs.rmSync(file, { force: true });
+        }
+        catch {
+            // A marker left behind is ignored once this process has exited (its pid is gone).
+        }
+    };
+}
+/** How many cards live processes are waiting on. Stale markers are removed on the way. */
+function countWaitingCards(isAlive = parent_watch_1.processIsAlive, now = Date.now()) {
+    let names;
+    try {
+        names = fs.readdirSync(markerDir());
+    }
+    catch {
+        // No directory: nobody has ever waited on a card here.
+        return 0;
+    }
+    let live = 0;
+    for (const name of names) {
+        const file = path.join(markerDir(), name);
+        const pid = Number(name.split("-")[0]);
+        let fresh = false;
+        try {
+            fresh = now - fs.statSync(file).mtimeMs < MARKER_MAX_AGE_MS;
+        }
+        catch {
+            continue; // Removed between the listing and the look: its waiter finished.
+        }
+        if (Number.isInteger(pid) && pid > 1 && fresh && isAlive(pid))
+            live += 1;
+        else
+            fs.rmSync(file, { force: true });
+    }
+    return live;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.29.9",
+  "version": "0.31.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"
@@ -22,6 +22,9 @@
     "vitest": "^4.1.10"
   },
   "license": "MIT",
+  "baychat": {
+    "attention": {}
+  },
   "homepage": "https://baychat.io",
   "keywords": [
     "baychat",