@nopeek/agent-bridge 0.7.5 → 0.7.7

package/dist/backends.js

@@ -139,19 +139,31 @@ function runClaudeOnce(bin, args, text, cwd, timeoutMs, tag, onDelta) {
                 console.error(`${tag} stderr: ${stderr.slice(0, 1000)}`);
             resolvePromise({ reply, exitCode });
         };
-        const timer = setTimeout(() => {
-            console.error(`${tag} timed out after ${timeoutMs / 1000}s, killing`);
-            child.kill("SIGKILL");
-            finish(null);
-        }, timeoutMs);
+        // IDLE timeout (see the identical fix in the hermes runOnce() above): reset
+        // on every byte of output so a genuinely agentic, tool-using turn can run as
+        // long as it keeps producing output, and only true silence kills it.
+        let timer;
+        const armIdleTimer = () => {
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                console.error(`${tag} idle ${timeoutMs / 1000}s (no output), killing`);
+                child.kill("SIGKILL");
+                finish(null);
+            }, timeoutMs);
+        };
+        armIdleTimer();
         child.stdout.on("data", (d) => {
+            armIdleTimer();
             lineBuf += d.toString();
             const lines = lineBuf.split("\n");
             lineBuf = lines.pop() ?? "";
             for (const line of lines)
                 handleLine(line);
         });
-        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.stderr.on("data", (d) => {
+            armIdleTimer();
+            stderr += d.toString();
+        });
         child.on("error", (err) => {
             clearTimeout(timer);
             console.error(`${tag} spawn error: ${err.message}`);
@@ -364,6 +376,7 @@ export function hermesBrain(cfg) {
             out += `${line}\n`;
             onChunk?.(`${line}\n`);
         };
+        let timedOut = false;
         const finish = () => {
             if (settled)
                 return;
@@ -381,27 +394,43 @@ 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`);
-            child.kill("SIGKILL");
-            finish();
-        }, cfg.brainTimeoutMs);
+        // IDLE timeout, not a flat wall-clock one: reset on every byte of output
+        // (stdout OR stderr — either is a sign the process is alive and working,
+        // not hung). A genuinely agentic turn (tool use, indexing a fresh repo on
+        // a brand-new profile) can legitimately run for minutes while still
+        // producing periodic status output — a flat timer kills that productive
+        // work indiscriminately. Only true SILENCE this long means hung.
+        let timer;
+        const armIdleTimer = () => {
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                console.error(`${tag} idle ${cfg.brainTimeoutMs / 1000}s (no output), killing`);
+                timedOut = true;
+                child.kill("SIGKILL");
+                finish();
+            }, cfg.brainTimeoutMs);
+        };
+        armIdleTimer();
         child.stdout.on("data", (d) => {
+            armIdleTimer();
             lineBuf += d.toString();
             const lines = lineBuf.split("\n");
             lineBuf = lines.pop() ?? "";
             for (const line of lines)
                 handleLine(line);
         });
-        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.stderr.on("data", (d) => {
+            armIdleTimer();
+            stderr += d.toString();
+        });
         child.on("error", (err) => {
             clearTimeout(timer);
             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 +477,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 went quiet for over ${secs}s with no output and I had to give up on that turn — a long tool-use step or a very slow provider response can trigger this. 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.7";
 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.7";
 /** 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/config.d.ts

@@ -82,9 +82,9 @@ export interface BridgeConfig {
 export declare const DEFAULT_API_URL = "https://d3qweh72vesa98.cloudfront.net";
 export declare const DEFAULT_APP_URL = "https://d32w3to73s0pu5.cloudfront.net/messenger/";
 export declare const DEFAULT_PORT = 8790;
-export declare const DEFAULT_BRAIN_TIMEOUT_MS = 180000;
+export declare const DEFAULT_BRAIN_TIMEOUT_MS = 300000;
 export declare function defaultHomeDir(): string;
-export declare const HELP = "nopeek-agent-bridge \u2014 run your agents as E2EE NoPeek bots\n\nUsage:\n  nopeek-agent-bridge install     Install as a background service (launchd/systemd),\n                                  then finish setup from the NoPeek app:\n                                  Bots -> Connect this computer.\n  nopeek-agent-bridge uninstall   Remove the background service (keeps data/settings).\n  nopeek-agent-bridge status      Show the running bridge's status.\n  nopeek-agent-bridge [run]       Run in the foreground. Unpaired bridges wait to be\n                                  paired from the NoPeek app; --pair still works:\n                                    npx @nopeek/agent-bridge --pair npr_\u2026 --app-id app_\u2026\n\nOptions:\n  --pair <code>            Pairing code from the NoPeek app             (env NOPEEK_PAIRING_CODE)\n  --app-id <id>            NoPeek app id                                (env NOPEEK_APP_ID)\n  --api-url <url>          API base, default https://d3qweh72vesa98.cloudfront.net  (env NOPEEK_API_URL)\n  --brain-cmd <cmd>        Shell brain: message on stdin -> reply on stdout   (env BRAIN_CMD)\n  --brain-url <url>        Webhook brain: POST {text,...} -> {text|reply}     (env BRAIN_URL)\n  --brain-map <json>       Per-bot overrides {\"<handle>\":{\"cmd\":\"\u2026\"}|{\"url\":\"\u2026\"}|\n                           {\"backend\":\"claude\"|\"hermes\"|\"echo\"}}              (env BRAIN_MAP)\n  --brain-provision-cmd <cmd>  Run once per new bot; stdout becomes its brain command\n                           (env BRAIN_PROVISION_CMD \u2014 e.g. a script that creates a\n                           fresh Hermes profile with its own soul + memory)\n  --app-url <url>          App opened after install                     (env NOPEEK_APP_URL)\n  --no-open                install: don't open the app in the browser\n  --brain-timeout-ms <ms>  Brain timeout, default 180000          (env BRAIN_TIMEOUT_MS)\n  --port <port>            Local control API port, default 8790    (env NOPEEK_BRIDGE_PORT)\n  --data-dir <dir>         Device-key store dir                        (env NOPEEK_BRIDGE_DATA_DIR)\n  --home <dir>             Bridge home, default ~/.nopeek-bridge       (env NOPEEK_BRIDGE_HOME)\n  --config <path>          Config file, default ./nopeek-bridge.config.json\n  -h, --help               Show this help\n\nWith no brain configured, bots run in echo mode (\"You said: \u2026\") \u2014 a zero-config smoke test.\nPairing and brains can be managed entirely from the NoPeek app once the service is running.";
+export declare const HELP = "nopeek-agent-bridge \u2014 run your agents as E2EE NoPeek bots\n\nUsage:\n  nopeek-agent-bridge install     Install as a background service (launchd/systemd),\n                                  then finish setup from the NoPeek app:\n                                  Bots -> Connect this computer.\n  nopeek-agent-bridge uninstall   Remove the background service (keeps data/settings).\n  nopeek-agent-bridge status      Show the running bridge's status.\n  nopeek-agent-bridge [run]       Run in the foreground. Unpaired bridges wait to be\n                                  paired from the NoPeek app; --pair still works:\n                                    npx @nopeek/agent-bridge --pair npr_\u2026 --app-id app_\u2026\n\nOptions:\n  --pair <code>            Pairing code from the NoPeek app             (env NOPEEK_PAIRING_CODE)\n  --app-id <id>            NoPeek app id                                (env NOPEEK_APP_ID)\n  --api-url <url>          API base, default https://d3qweh72vesa98.cloudfront.net  (env NOPEEK_API_URL)\n  --brain-cmd <cmd>        Shell brain: message on stdin -> reply on stdout   (env BRAIN_CMD)\n  --brain-url <url>        Webhook brain: POST {text,...} -> {text|reply}     (env BRAIN_URL)\n  --brain-map <json>       Per-bot overrides {\"<handle>\":{\"cmd\":\"\u2026\"}|{\"url\":\"\u2026\"}|\n                           {\"backend\":\"claude\"|\"hermes\"|\"echo\"}}              (env BRAIN_MAP)\n  --brain-provision-cmd <cmd>  Run once per new bot; stdout becomes its brain command\n                           (env BRAIN_PROVISION_CMD \u2014 e.g. a script that creates a\n                           fresh Hermes profile with its own soul + memory)\n  --app-url <url>          App opened after install                     (env NOPEEK_APP_URL)\n  --no-open                install: don't open the app in the browser\n  --brain-timeout-ms <ms>  Brain timeout, default 300000          (env BRAIN_TIMEOUT_MS)\n  --port <port>            Local control API port, default 8790    (env NOPEEK_BRIDGE_PORT)\n  --data-dir <dir>         Device-key store dir                        (env NOPEEK_BRIDGE_DATA_DIR)\n  --home <dir>             Bridge home, default ~/.nopeek-bridge       (env NOPEEK_BRIDGE_HOME)\n  --config <path>          Config file, default ./nopeek-bridge.config.json\n  -h, --help               Show this help\n\nWith no brain configured, bots run in echo mode (\"You said: \u2026\") \u2014 a zero-config smoke test.\nPairing and brains can be managed entirely from the NoPeek app once the service is running.";
 /** Load config from argv + env + cwd config file + home settings. Never
  *  requires pairing — an unpaired bridge waits for the app to pair it. */
 export declare function loadConfig(argv?: string[]): BridgeConfig;

package/dist/config.js

@@ -15,7 +15,12 @@ export function isBrainBackend(v) {
 export const DEFAULT_API_URL = "https://d3qweh72vesa98.cloudfront.net";
 export const DEFAULT_APP_URL = "https://d32w3to73s0pu5.cloudfront.net/messenger/";
 export const DEFAULT_PORT = 8790;
-export const DEFAULT_BRAIN_TIMEOUT_MS = 180_000;
+// Idle timeout (resets on any child-process output, not a flat wall-clock cap
+// — see backends.ts). 300s of true SILENCE covers a long tool-use step (repo
+// indexing, slow provider call) on a genuinely agentic brain without needing
+// per-deployment tuning, while still killing a truly hung process reasonably
+// fast.
+export const DEFAULT_BRAIN_TIMEOUT_MS = 300_000;
 export function defaultHomeDir() {
     return process.env.NOPEEK_BRIDGE_HOME || join(homedir(), ".nopeek-bridge");
 }

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