@nopeek/agent-bridge 0.7.5 → 0.7.6

package/dist/backends.js

@@ -364,6 +364,7 @@ export function hermesBrain(cfg) {
             out += `${line}\n`;
             onChunk?.(`${line}\n`);
         };
+        let timedOut = false;
         const finish = () => {
             if (settled)
                 return;
@@ -381,10 +382,11 @@ export function hermesBrain(cfg) {
             // "No session found" can land on stderr in some hermes builds.
             if (!out.trim() && HERMES_NO_SESSION.test(stderr.trim()))
                 noSession = true;
-            resolvePromise({ reply: out.trim(), noSession, sessionId, stderr });
+            resolvePromise({ reply: out.trim(), noSession, sessionId, stderr, timedOut });
         };
         const timer = setTimeout(() => {
             console.error(`${tag} timed out after ${cfg.brainTimeoutMs / 1000}s, killing`);
+            timedOut = true;
             child.kill("SIGKILL");
             finish();
         }, cfg.brainTimeoutMs);
@@ -401,7 +403,7 @@ export function hermesBrain(cfg) {
             console.error(`${tag} spawn error: ${err.message}`);
             if (!settled) {
                 settled = true;
-                resolvePromise({ reply: "", noSession: false, sessionId: null, stderr: err.message });
+                resolvePromise({ reply: "", noSession: false, sessionId: null, stderr: err.message, timedOut: false });
             }
         });
         child.on("close", () => {
@@ -448,6 +450,14 @@ export function hermesBrain(cfg) {
         if (!run.reply) {
             if (run.stderr.trim())
                 console.error(`${tag} stderr: ${run.stderr.slice(0, 1000)}`);
+            // Distinguish the actual failure instead of always blaming "no
+            // authenticated provider" — that message was previously hardcoded for
+            // EVERY empty-reply cause (including a plain timeout on a slow cold
+            // start), which misdirects the user to run a command that isn't the fix.
+            if (run.timedOut) {
+                const secs = Math.round(cfg.brainTimeoutMs / 1000);
+                return `⚠️ My brain took longer than ${secs}s to respond and I had to give up — this can happen on the very first message while a session/provider is warming up. Try messaging me again.`;
+            }
             return "⚠️ My brain isn't reachable right now — Hermes has no authenticated provider on the host. Run 'hermes model' there, then message me again.";
         }
         return run.reply;

package/dist/bridge.d.ts

@@ -1,5 +1,5 @@
 import type { BridgeConfig, Pairing, BrainSpec, BrainBackend } from "./config.js";
-export declare const VERSION = "0.7.5";
+export declare const VERSION = "0.7.6";
 export interface PairRequest {
     pairingSecret: string;
     appId: string;

package/dist/bridge.js

@@ -17,7 +17,7 @@ import { resolveBrain } from "./brain.js";
 import { provisionSoul, provisionHermesProfile } from "./backends.js";
 import { reportCapabilities } from "./capabilities.js";
 import { isBrainBackend } from "./config.js";
-export const VERSION = "0.7.5";
+export const VERSION = "0.7.6";
 /** How often to re-probe + report brain availability to the server. */
 const CAPABILITIES_INTERVAL_MS = 5 * 60_000;
 // ---- Reconnect watchdog -----------------------------------------------------
@@ -33,6 +33,11 @@ const WATCHDOG_INTERVAL_MS = 30_000;
 const SOFT_STALE_MS = 90_000;
 /** Every bot down longer than this (sustained) → exit for a clean relaunch. */
 const HARD_STALE_MS = 5 * 60_000;
+/** A SINGLE bot down this long despite repeated forced restarts → exit too.
+ *  Covers a bot wedged for a reason forceRestart() can't fix from inside the
+ *  process (e.g. a stuck OS-level DNS resolution) while OTHER bots are fine —
+ *  the all-bots-down HARD_STALE_MS check alone would never catch that case. */
+const ULTRA_STALE_MS = 10 * 60_000;
 export class PairError extends Error {
     code;
     constructor(code, message) {
@@ -357,20 +362,25 @@ export class BridgeApp {
         let allLiveness = [];
         for (const r of this.runtimes)
             allLiveness = allLiveness.concat(r.watchdogSoftPass(SOFT_STALE_MS));
-        // Layer 4 (the guarantee): if EVERY bot across ALL pairings has been down
-        // longer than HARD_STALE_MS and there is at least one bot, soft recovery
-        // has failed — the process networking is wedged. Require the condition
-        // sustained over two consecutive checks, then exit for a clean relaunch.
+        // Layer 4 (the guarantee): exit for a clean relaunch when soft recovery has
+        // clearly failed — either EVERY bot is down past HARD_STALE_MS, or a SINGLE
+        // bot has been down past ULTRA_STALE_MS despite repeated forceRestart()
+        // calls (a bot wedged for a reason forceRestart can't fix from inside the
+        // process — e.g. a stuck OS-level DNS resolution — while other bots are
+        // fine; the all-down check alone would never catch that). Require the
+        // condition sustained over two consecutive checks, then exit.
         const hasBots = allLiveness.length > 0;
         const allHardStale = hasBots && allLiveness.every((ms) => ms > HARD_STALE_MS);
-        if (this.paired && hasBots && allHardStale) {
+        const anyUltraStale = hasBots && allLiveness.some((ms) => ms > ULTRA_STALE_MS);
+        if (this.paired && hasBots && (allHardStale || anyUltraStale)) {
             this.hardStaleStreak++;
-            const mins = Math.round(HARD_STALE_MS / 60_000);
+            const mins = Math.round((allHardStale ? HARD_STALE_MS : ULTRA_STALE_MS) / 60_000);
+            const reason = allHardStale ? `no bot connected for ${mins}min across ${allLiveness.length} bot(s)` : `a bot stuck down > ${mins}min`;
             if (this.hardStaleStreak >= 2) {
-                console.error(`[watchdog] no bot connected for ${mins}min across ${allLiveness.length} bot(s) — exiting for a clean relaunch`);
+                console.error(`[watchdog] ${reason} — exiting for a clean relaunch`);
                 process.exit(1);
             }
-            console.error(`[watchdog] all ${allLiveness.length} bot(s) down > ${mins}min — will exit for a clean relaunch if still down next check`);
+            console.error(`[watchdog] ${reason} — will exit for a clean relaunch if still stuck next check`);
         }
         else {
             this.hardStaleStreak = 0;

package/dist/cli.js

@@ -8,7 +8,7 @@
 import { loadConfig, HELP } from "./config.js";
 import { BridgeApp, VERSION } from "./bridge.js";
 import { startLocalApi } from "./localapi.js";
-import { installService, uninstallService, printStatus } from "./service.js";
+import { installService, uninstallService, printStatus, checkForUpdate } from "./service.js";
 // ---------------------------------------------------------------- guards ----
 // The bridge must never die to a stray rejection deep inside a WS/crypto
 // callback — one flaky bot cannot take the fleet down.
@@ -22,6 +22,14 @@ if (typeof WebSocket === "undefined" || !globalThis.crypto?.subtle) {
     console.error(`@nopeek/agent-bridge needs Node >= 22 (global WebSocket + fetch + WebCrypto). Current: ${process.version}`);
     process.exit(1);
 }
+// Every log line gets an ISO timestamp. The service log otherwise has no time
+// axis at all — investigating an incident (e.g. "which network blip closed
+// every bot's socket, and when did the watchdog recover it") is only possible
+// if log lines can be correlated against system events by clock time.
+for (const level of ["log", "error", "warn"]) {
+    const orig = console[level].bind(console);
+    console[level] = (...args) => orig(`[${new Date().toISOString()}]`, ...args);
+}
 // ----------------------------------------------------------- subcommands ----
 const argv = process.argv.slice(2);
 const SUBCOMMANDS = new Set(["install", "uninstall", "status", "run", "help"]);
@@ -100,6 +108,15 @@ catch (err) {
     process.exit(1);
 }
 app.start();
+// Periodic self-update: a published fix (e.g. a reconnect-reliability bug)
+// otherwise sits unused on already-installed bridges until someone manually
+// reinstalls. Check shortly after startup, then every 6h; each check exits the
+// process on a successful update so the always-restart service (KeepAlive)
+// relaunches running the new code. No-op on install methods it doesn't
+// recognize (see checkForUpdate) — never touches a dev checkout.
+const UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60_000;
+setTimeout(() => void checkForUpdate(VERSION, cfg.homeDir), 60_000).unref();
+setInterval(() => void checkForUpdate(VERSION, cfg.homeDir), UPDATE_CHECK_INTERVAL_MS).unref();
 const shutdown = (signal) => {
     console.log(`[bridge] ${signal} — shutting down`);
     app.stop();

package/dist/service.d.ts

@@ -1,4 +1,16 @@
 import type { BridgeConfig } from "./config.js";
+/**
+ * Periodic self-update: compares the running version against npm's published
+ * `latest` and, if newer, re-installs using the SAME method this process is
+ * actually running from (global npm root, or the private <home>/app copy —
+ * see resolveEntrypoint above) and exits so the always-restart service
+ * relaunches running the fresh code. Only acts on an install method it
+ * recognizes — a pnpm-linked dev checkout or anything unrecognized is left
+ * alone (safety over completeness). This is how a published fix (like a
+ * reconnect-reliability bug) actually reaches already-installed bridges
+ * instead of sitting unused until someone manually reinstalls.
+ */
+export declare function checkForUpdate(currentVersion: string, homeDir: string): Promise<void>;
 export declare function installService(cfg: BridgeConfig, noOpen?: boolean): Promise<void>;
 export declare function uninstallService(): void;
 export declare function printStatus(port: number): Promise<void>;

package/dist/service.js

@@ -32,6 +32,61 @@ function resolveEntrypoint(homeDir) {
         throw new Error(`expected ${entry} after install — not found`);
     return entry;
 }
+/**
+ * Periodic self-update: compares the running version against npm's published
+ * `latest` and, if newer, re-installs using the SAME method this process is
+ * actually running from (global npm root, or the private <home>/app copy —
+ * see resolveEntrypoint above) and exits so the always-restart service
+ * relaunches running the fresh code. Only acts on an install method it
+ * recognizes — a pnpm-linked dev checkout or anything unrecognized is left
+ * alone (safety over completeness). This is how a published fix (like a
+ * reconnect-reliability bug) actually reaches already-installed bridges
+ * instead of sitting unused until someone manually reinstalls.
+ */
+export async function checkForUpdate(currentVersion, homeDir) {
+    let latest;
+    try {
+        const res = await fetch("https://registry.npmjs.org/@nopeek/agent-bridge/latest", {
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            return;
+        const body = (await res.json());
+        latest = body.version ?? "";
+    }
+    catch {
+        return; // offline / registry unreachable — try again next check
+    }
+    if (!latest || latest === currentVersion)
+        return;
+    const self = realpathSync(process.argv[1]);
+    let installArgs = null;
+    try {
+        const globalRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf8" }).trim();
+        if (globalRoot && self.startsWith(globalRoot))
+            installArgs = ["install", "-g", "@nopeek/agent-bridge@latest"];
+    }
+    catch {
+        /* npm not on PATH / no permission to query — fall through to the private-copy check */
+    }
+    if (!installArgs) {
+        const privateHome = join(homeDir, "app");
+        if (self.startsWith(privateHome))
+            installArgs = ["install", "--prefix", privateHome, "@nopeek/agent-bridge@latest"];
+    }
+    if (!installArgs) {
+        console.log(`[update] v${latest} is available (running v${currentVersion}) but this install (${self}) isn't a recognized global/private copy — skipping auto-update`);
+        return;
+    }
+    console.log(`[update] v${latest} available (running v${currentVersion}) — updating via 'npm ${installArgs.join(" ")}'`);
+    const r = spawnSync("npm", installArgs, { stdio: "inherit" });
+    if (r.status !== 0) {
+        console.error(`[update] npm install failed (exit ${r.status}) — will retry next check`);
+        return;
+    }
+    console.log(`[update] updated to v${latest} — exiting for the service to relaunch with the new version`);
+    process.exit(0);
+}
 function launchctl(args, ignoreFailure = false) {
     try {
         execFileSync("launchctl", args, { stdio: "pipe" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "description": "Run your own agents as E2EE NoPeek bots. Pairs with one-time codes (multiple accounts per computer), runs every bot each account owns, and pipes messages to any command or webhook.",
   "type": "module",
   "license": "MIT",