baychat 0.33.2 → 0.33.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.33.2",
+  "version": "0.33.3",
   "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/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.HINT_COOLDOWN_MS = exports.HINT_SPREAD_MS = exports.HINT_MIN_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_RECHECK_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;
@@ -54,9 +54,12 @@ const FIRST_CHECK_SPREAD_MS = 10 * MINUTE;
  *  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. */
+/** A hint never brings a check closer than this to the last one: a server that names a release
+ *  on every reconnect must not become an npm query on every reconnect. */
 exports.HINT_COOLDOWN_MS = 15 * MINUTE;
+/** The server can name a release before npm has it (deployed first, published after): npm is
+ *  asked again this long after each answer that is still older, then the hint is given up. */
+exports.HINT_RECHECK_MS = [15 * MINUTE, 30 * MINUTE, HOUR];
 /** 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/updater.js

@@ -17,10 +17,6 @@ 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();
@@ -28,6 +24,7 @@ class AutoUpdater {
     }
     /** Finish an update the previous relay installed, then look at the state once a minute. */
     start() {
+        this.freshStart();
         void this.runExclusive(() => this.finishPendingUpdate());
         this.timer = setInterval(() => void this.tick(), exports.TICK_MS);
         this.timer.unref();
@@ -50,34 +47,86 @@ class AutoUpdater {
             failure: state.failure?.reason,
         };
     }
+    /**
+     * New code is a new chance. Check failures recorded by ANOTHER version say nothing about this
+     * one — the failure may be the very bug this version fixes. Real case, 2026-10-21: relays that
+     * failed 11 times on 0.33.0 ("npm was not found on PATH") carried that backoff into 0.33.1, which
+     * fixed it, and would not have asked npm again for a day. So the schedule starts over, and the
+     * first check comes 5–15 minutes after this start.
+     */
+    freshStart() {
+        const state = this.deps.loadState();
+        if (!state.current || state.current === this.deps.current)
+            return;
+        if (state.lastCheckAt === undefined && !state.checkFailures)
+            return;
+        const was = state.current;
+        state.lastCheckAt = undefined;
+        state.checkFailures = undefined;
+        state.lastCheckError = undefined;
+        state.current = this.deps.current;
+        this.deps.saveState(state);
+        this.deps.log(`auto-update: now running ${this.deps.current} (checks were recorded by ${was}); asking npm afresh`);
+    }
     /**
      * 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).
+     * The moment never moves earlier than the backoff allows (`hintDue`): not within
+     * HINT_COOLDOWN_MS of the last check, not before a failed check's retry. The hint is kept, on
+     * disk, rather than dropped: a server deployed before the npm publish names a version npm does
+     * not have yet (2026-10-21, 0.33.2: the hint's check came 1 minute before the publish), so npm
+     * is asked again after each HINT_RECHECK_MS step until it names that version, then given up.
      */
     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)
+        if (ahead === undefined || ahead <= 0)
             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)
+        if (validHint(state.hint)?.version === version)
+            return; // waiting on it, or gave up on it
+        const nextAt = this.hintDue(state, this.deps.now() + policy_1.HINT_MIN_MS + this.deps.random() * policy_1.HINT_SPREAD_MS);
+        state.hint = { version, attempts: 0, nextAt };
+        this.deps.saveState(state);
+        this.deps.log(`auto-update: the server names ${version}; asking npm in ${Math.ceil((nextAt - this.deps.now()) / 60_000)} min`);
+    }
+    /** The earliest a hinted check may run: `wanted`, or later if the backoff says so. */
+    hintDue(state, wanted) {
+        let at = wanted;
+        if (state.lastCheckAt !== undefined)
+            at = Math.max(at, state.lastCheckAt + policy_1.HINT_COOLDOWN_MS);
+        if ((state.checkFailures ?? 0) > 0)
+            at = Math.max(at, (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread));
+        return at;
+    }
+    /** After a check: the hint is answered (npm names it, or this copy has it), retried, or given up. */
+    settleHint(state, now, wasDue) {
+        const hint = validHint(state.hint);
+        if (!hint)
+            return void (state.hint = undefined);
+        const latest = state.latest ? (0, self_upgrade_1.compareVersions)(state.latest, hint.version) : undefined;
+        if ((latest !== undefined && latest >= 0) || (0, self_upgrade_1.compareVersions)(hint.version, this.deps.current) !== 1) {
+            state.hint = undefined;
+            return;
+        }
+        if (!wasDue || hint.nextAt === undefined)
             return;
-        if ((state.checkFailures ?? 0) > 0 && now < (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread))
+        const attempts = hint.attempts + 1;
+        const wait = policy_1.HINT_RECHECK_MS[attempts - 1];
+        if (wait === undefined) {
+            state.hint = { version: hint.version, attempts };
+            this.deps.log(`auto-update: npm still does not have ${hint.version}; the daily check takes over`);
             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`);
+        }
+        state.hint = { version: hint.version, attempts, nextAt: now + wait };
+        this.deps.log(`auto-update: npm does not have ${hint.version} yet; asking again in ${wait / 60_000} min`);
     }
     /** One look at the state. Never throws; never runs twice at once. */
     async tick() {
@@ -97,11 +146,10 @@ class AutoUpdater {
             if (mode === "off" || mode === "none")
                 return;
             const now = this.deps.now();
-            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);
-            }
+            const hintAt = validHint(state.hint)?.nextAt;
+            const hinted = hintAt !== undefined && now >= hintAt;
+            if (hinted || now >= (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread))
+                await this.check(state, mode, hinted);
             if (mode !== "auto")
                 return;
             if (state.card?.requestId && now - this.lastCardPoll >= policy_1.CARD_POLL_MS)
@@ -129,20 +177,25 @@ class AutoUpdater {
             return { mode: "notify", reason: "for a relay started by hand (install with `baychat update`)" };
         return { mode: "auto" };
     }
-    /** Ask npm, and decide. */
-    async check(state, mode) {
+    /** Ask npm, and decide. `hinted`: the check a server's hint asked for (counts as a hint attempt). */
+    async check(state, mode, hinted = false) {
         const looked = await this.deps.lookupLatest();
-        state.lastCheckAt = this.deps.now();
+        const now = this.deps.now();
+        state.lastCheckAt = now;
         if (!looked.ok) {
-            // Offline, npm down: quiet. Tried again within the hour, then less often.
+            // Offline, npm down: quiet. Tried again within the hour, then less often — a waiting hint too.
             state.checkFailures = (state.checkFailures ?? 0) + 1;
             state.lastCheckError = looked.reason;
+            const hint = validHint(state.hint);
+            if (hint?.nextAt !== undefined)
+                state.hint = { ...hint, nextAt: this.hintDue(state, now) };
             this.deps.log(`auto-update: could not ask npm (${looked.reason})`);
             return this.deps.saveState(state);
         }
         state.checkFailures = 0;
         state.lastCheckError = undefined;
         state.latest = looked.release.version;
+        this.settleHint(state, now, hinted);
         const plan = (0, policy_1.planUpdate)(this.deps.current, looked.release);
         if (plan.kind === "current") {
             // Updated some other way (`baychat update`), or nothing new: nothing may stay on the phone.
@@ -355,6 +408,15 @@ class AutoUpdater {
     }
 }
 exports.AutoUpdater = AutoUpdater;
+/** The persisted hint, if it is one: the state file is ours, but a hand edit or an older shape must
+ *  not stop the updater. */
+function validHint(raw) {
+    if (!raw || typeof raw !== "object" || typeof raw.version !== "string" || typeof raw.attempts !== "number")
+        return undefined;
+    if (raw.nextAt !== undefined && typeof raw.nextAt !== "number")
+        return undefined;
+    return raw;
+}
 function errText(err) {
     return err instanceof Error ? err.message : String(err);
 }

package/package.json

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