baychat 0.33.0 → 0.33.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "displayName": "BayChat",
   "description": "Wakes this Claude Code session the moment a BayChat message arrives: no Monitor, no 30-minute deadline. Uses the baychat CLI already on this computer (npm install -g baychat, then baychat login).",
   "author": {

package/dist/auto-update/hint.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onReleaseAnnounced = onReleaseAnnounced;
+exports.announceRelease = announceRelease;
+let listener;
+let log = (line) => console.error(line);
+function onReleaseAnnounced(fn, logLine) {
+    listener = fn;
+    if (logLine)
+        log = logLine;
+}
+function announceRelease(version) {
+    try {
+        listener?.(version);
+    }
+    catch (err) {
+        // A hint that cannot be taken is a hint missed; the daily check still comes.
+        log(`auto-update: could not take the server's release hint (${err instanceof Error ? err.message : String(err)})`);
+    }
+}

package/dist/auto-update/policy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HELD_FRESH_MS = exports.QUIET_MS = exports.CARD_POLL_MS = exports.ASK_AGAIN_MS = exports.CHECK_INTERVAL_MS = exports.AUTO_UPDATE_ENV = void 0;
+exports.HELD_FRESH_MS = exports.QUIET_MS = exports.CARD_POLL_MS = exports.ASK_AGAIN_MS = exports.HINT_COOLDOWN_MS = exports.HINT_SPREAD_MS = exports.HINT_MIN_MS = exports.CHECK_INTERVAL_MS = exports.AUTO_UPDATE_ENV = void 0;
 exports.planUpdate = planUpdate;
 exports.autoUpdateOffReason = autoUpdateOffReason;
 exports.nextCheckAt = nextCheckAt;
@@ -50,6 +50,13 @@ const CHECK_SPREAD_MS = HOUR;
 /** The first check after a start: soon, but not in the busy first minutes. */
 const FIRST_CHECK_MIN_MS = 5 * MINUTE;
 const FIRST_CHECK_SPREAD_MS = 10 * MINUTE;
+/** The server named a newer release in the feed's `ready` frame (hint.ts): npm is asked within
+ *  1–5 minutes — spread so a fleet that hears the same frame never asks npm together. */
+exports.HINT_MIN_MS = MINUTE;
+exports.HINT_SPREAD_MS = 4 * MINUTE;
+/** A hint right after a check is not taken: a server that names a release on every reconnect
+ *  must not become an npm query on every reconnect. */
+exports.HINT_COOLDOWN_MS = 15 * MINUTE;
 /** A check that failed (offline, npm down) is tried again sooner than a day, then backs off. */
 const CHECK_RETRY_MS = HOUR;
 /** A failed install of one version waits a day, then two, … up to a week. A newer version resets it. */

package/dist/auto-update/relay-glue.js

@@ -10,6 +10,7 @@ const refresh_clients_1 = require("../refresh-clients");
 const waiting_cards_1 = require("../waiting-cards");
 const policy_1 = require("./policy");
 const store_1 = require("./store");
+const hint_1 = require("./hint");
 const updater_1 = require("./updater");
 /**
  * The automatic update wired to a real relay: npm, the disk, the device API for the card, and the
@@ -50,6 +51,8 @@ function startRelayUpdater(opts) {
     };
     const updater = new updater_1.AutoUpdater(deps);
     updater.start();
+    // The server's feed names the newest release in each `ready` frame: check npm soon, not tomorrow.
+    (0, hint_1.onReleaseAnnounced)((version) => updater.hint(version), opts.log);
     return updater;
 }
 /**

package/dist/auto-update/updater.js

@@ -17,6 +17,10 @@ class AutoUpdater {
     running = false;
     stopped = false;
     lastCardPoll = 0;
+    /** A release the server named (hint.ts), and when npm is asked about it. In memory only: a
+     *  restarted relay hears the next `ready` frame anyway. */
+    hinted;
+    hintCheckAt;
     constructor(deps) {
         this.deps = deps;
         this.startedAt = deps.now();
@@ -46,6 +50,35 @@ class AutoUpdater {
             failure: state.failure?.reason,
         };
     }
+    /**
+     * The server's feed named `version` as the newest BayChat (hint.ts). Newer than this copy, and
+     * newer than what npm last said: ask npm in 1–5 minutes instead of at the daily check. Only the
+     * moment moves — npm still names the version, and planUpdate still decides what happens.
+     *
+     * The moment never moves earlier than the backoff allows: not within HINT_COOLDOWN_MS of the
+     * last check, and not while a failed check waits out its retry (npm down stays npm down,
+     * however often the server reconnects).
+     */
+    hint(version) {
+        const { mode } = this.mode();
+        if (mode === "off" || mode === "none")
+            return;
+        const ahead = (0, self_upgrade_1.compareVersions)(version, this.deps.current);
+        if (ahead === undefined || ahead <= 0 || this.hinted === version)
+            return;
+        const state = this.deps.loadState();
+        const known = state.latest ? (0, self_upgrade_1.compareVersions)(state.latest, version) : undefined;
+        if (known !== undefined && known >= 0)
+            return; // npm already named it (or newer)
+        const now = this.deps.now();
+        if (state.lastCheckAt !== undefined && now - state.lastCheckAt < policy_1.HINT_COOLDOWN_MS)
+            return;
+        if ((state.checkFailures ?? 0) > 0 && now < (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread))
+            return;
+        this.hinted = version;
+        this.hintCheckAt = now + policy_1.HINT_MIN_MS + this.deps.random() * policy_1.HINT_SPREAD_MS;
+        this.deps.log(`auto-update: the server names ${version}; asking npm within minutes`);
+    }
     /** One look at the state. Never throws; never runs twice at once. */
     async tick() {
         await this.runExclusive(async () => {
@@ -64,8 +97,11 @@ class AutoUpdater {
             if (mode === "off" || mode === "none")
                 return;
             const now = this.deps.now();
-            if (now >= (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread))
+            const hinted = this.hintCheckAt !== undefined && now >= this.hintCheckAt;
+            if (hinted || now >= (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread)) {
+                this.hintCheckAt = undefined;
                 await this.check(state, mode);
+            }
             if (mode !== "auto")
                 return;
             if (state.card?.requestId && now - this.lastCardPoll >= policy_1.CARD_POLL_MS)

package/dist/relay/ws.js

@@ -27,6 +27,7 @@ const context_notice_1 = require("./context-notice");
 const project_notes_1 = require("./project-notes");
 const updates_1 = require("./updates");
 const server_registration_1 = require("./server-registration");
+const hint_1 = require("../auto-update/hint");
 /** The published endpoint. Changing it breaks every deployed server — a wire constant. */
 exports.AGENT_WS_PATH = "/api/agent-api/ws";
 /** How long we wait for the server's `ready` after sending `hello`. */
@@ -132,6 +133,8 @@ function runWebSocketFeed(opts) {
                         onSessions?.(frame.sessions, frame.registrations);
                     if (frame.cursor)
                         onCursor?.(frame.cursor);
+                    if (frame.latestCli)
+                        (0, hint_1.announceRelease)(frame.latestCli);
                     onReady?.(frame.cursor ?? null);
                     return;
                 }
@@ -288,6 +291,8 @@ function parseFrame(raw) {
                 cursor: str(frame.cursor),
                 sessions: names(frame.sessions),
                 registrations: (0, server_registration_1.parseRegistrations)(frame.registrations),
+                // Plain x.y.z only; anything else is dropped (a hint, never what installs: auto-update/hint.ts).
+                latestCli: typeof frame.latestCli === "string" && /^\d+\.\d+\.\d+$/.test(frame.latestCli) ? frame.latestCli : undefined,
             };
         case "cursor":
             return {

package/dist/self-upgrade.js

@@ -42,6 +42,7 @@ exports.upgradePackage = upgradePackage;
 exports.lookupLatest = lookupLatest;
 exports.installRelease = installRelease;
 exports.describeOutcome = describeOutcome;
+exports.npmCommand = npmCommand;
 exports.realNpm = realNpm;
 exports.readPackageVersion = readPackageVersion;
 exports.packageEntry = packageEntry;
@@ -249,6 +250,30 @@ function npmFailure(r) {
     const lines = r.stderr.split("\n").map((l) => l.trim()).filter(Boolean);
     return lines.slice(-3).join(" ") || `npm exited with ${r.status}`;
 }
+/**
+ * Which npm to run, and the PATH to run it with: the npm installed beside the Node running this
+ * code, when there is one — else plain `npm` from PATH.
+ *
+ * A relay under systemd or launchd does not read a shell profile, so with Node from nvm (or any
+ * version manager) its PATH holds no npm at all: every automatic update on such a computer failed
+ * with "npm was not found on PATH" (Karmen's PC, 2026-10-21: 11 failed checks, never one update).
+ * The Node that is running is the Node that installed this copy, and its npm sits next to it. That
+ * directory also goes first on the child's PATH, because npm itself starts with
+ * `#!/usr/bin/env node`, which must find a node too.
+ *
+ * Which global folder that npm calls its own (Volta, asdf, a custom `prefix`) does not matter:
+ * installRelease always passes `--prefix <the running copy's prefix>`, which npm puts above its
+ * own config (checked 2026-10-21 with npm_config_prefix pointing elsewhere: the install landed in
+ * `--prefix`), and then believes only the version on disk there.
+ */
+function npmCommand(execPath, platform, pathEnv, exists) {
+    const dir = path.dirname(execPath);
+    const beside = path.join(dir, platform === "win32" ? "npm.cmd" : "npm");
+    if (!exists(beside))
+        return { command: "npm", path: pathEnv };
+    const sep = platform === "win32" ? ";" : ":";
+    return { command: beside, path: pathEnv ? `${dir}${sep}${pathEnv}` : dir };
+}
 /** Run npm for real, without blocking the event loop (the relay keeps serving while npm runs).
  *  Windows' npm is a `.cmd` shim, which Node will only start through a shell, so every argument
  *  is first checked against what cmd.exe could misread and then quoted. */
@@ -257,8 +282,20 @@ function realNpm(args, timeoutMs) {
     if (windows && args.some((a) => commands_1.WINDOWS_UNSAFE.test(a))) {
         return Promise.resolve({ status: null, stdout: "", stderr: "", error: new Error("a path npm needs cannot be passed safely through cmd.exe") });
     }
+    const found = npmCommand(process.execPath, process.platform, process.env.PATH, fs.existsSync);
+    // A Node directory cmd.exe could misread is not run through it: PATH's npm then, as before.
+    const npm = windows && commands_1.WINDOWS_UNSAFE.test(found.command) ? { command: "npm", path: process.env.PATH } : found;
+    // Through cmd.exe the command is a string too: a path with spaces must arrive as one word.
+    const command = windows && npm.command !== "npm" ? (0, commands_1.quoteForCmd)(npm.command) : npm.command;
     return new Promise((resolve) => {
-        (0, child_process_1.execFile)("npm", windows ? args.map(commands_1.quoteForCmd) : args, { encoding: "utf8", timeout: timeoutMs, shell: windows, windowsHide: true, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
+        (0, child_process_1.execFile)(command, windows ? args.map(commands_1.quoteForCmd) : args, {
+            encoding: "utf8",
+            timeout: timeoutMs,
+            shell: windows,
+            windowsHide: true,
+            maxBuffer: 16 * 1024 * 1024,
+            env: { ...process.env, ...(npm.path !== undefined ? { PATH: npm.path } : {}) },
+        }, (err, stdout, stderr) => {
             if (!err)
                 return resolve({ status: 0, stdout, stderr });
             const code = err.code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "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"