nanobazaar-cli 2.0.2 → 2.0.4

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to `nanobazaar-cli` are documented in this file.
 
 This project follows Semantic Versioning.
 
+## [2.0.4] - 2026-02-11
+
+### Fixed
+- `nanobazaar watch` now reconnects SSE loops with backoff + jitter and includes health logs.
+
+## [2.0.3] - 2026-02-09
+
+### Changed
+- `nanobazaar watch` now wakes only on relay wake events; removed the safety interval.
+
 ## [2.0.2] - 2026-02-08
 
 ### Fixed

package/bin/nanobazaar

@@ -32,6 +32,11 @@ const CONFIG_BASE_DIR = XDG_CONFIG_HOME || path.join(HOME_DIR, '.config');
 const STATE_DEFAULT = path.join(CONFIG_BASE_DIR, 'nanobazaar', 'nanobazaar.json');
 const STATE_LOCK_RETRY_MS = 50;
 const STATE_LOCK_TIMEOUT_MS = 5000;
+const WATCH_RECONNECT_BASE_MS = 1000;
+const WATCH_RECONNECT_FACTOR = 2;
+const WATCH_RECONNECT_CAP_MS = 60000;
+const WATCH_RECONNECT_JITTER_RATIO = 0.2;
+const WATCH_RECONNECT_STABLE_WINDOW_MS = 30000;
 let STATE_LOCK_SLEEP = null;
 
 function requireFetch() {
@@ -1275,10 +1280,10 @@ Commands:
                              Poll events and optionally ack
   poll ack --up-to-event-id <id>
                              Advance the server-side poll cursor (used for 410 resync)
-  watch [--stream-path /v0/stream] [--safety-wake-interval <seconds>]
+  watch [--stream-path /v0/stream]
         [--state-path <path>] [--openclaw-bin <bin>] [--event-text <text>]
         [--mode now|next] [--no-openclaw]
-                             Maintain SSE connection; wake OpenClaw on relay wake events + on a safety interval.
+                             Maintain SSE connection; wake OpenClaw on relay wake events.
                              Does not poll or ack (OpenClaw should run /nanobazaar poll).
 
 Global flags:
@@ -2905,11 +2910,44 @@ function appendEvents(state, events) {
 }
 
 function backoffDelayMs(attempt, opts) {
-  const baseMs = opts && opts.baseMs ? opts.baseMs : 500;
-  const maxMs = opts && opts.maxMs ? opts.maxMs : 30000;
-  const exp = Math.min(maxMs, baseMs * (2 ** Math.max(0, attempt)));
-  const jittered = exp * (0.5 + Math.random());
-  return Math.min(maxMs, Math.max(baseMs, Math.floor(jittered)));
+  const baseMs = opts && opts.baseMs ? opts.baseMs : WATCH_RECONNECT_BASE_MS;
+  const factor = opts && opts.factor ? opts.factor : WATCH_RECONNECT_FACTOR;
+  const capMs = opts && (opts.capMs || opts.maxMs) ? (opts.capMs || opts.maxMs) : WATCH_RECONNECT_CAP_MS;
+  const jitterRatio = opts && typeof opts.jitterRatio === 'number'
+    ? Math.min(1, Math.max(0, opts.jitterRatio))
+    : WATCH_RECONNECT_JITTER_RATIO;
+  const randomFn = opts && typeof opts.random === 'function' ? opts.random : Math.random;
+  const safeAttempt = Math.max(0, Math.floor(attempt));
+  const exponent = Math.min(capMs, baseMs * (factor ** safeAttempt));
+  const jitterOffset = jitterRatio === 0 ? 0 : ((randomFn() * 2) - 1) * jitterRatio;
+  const jittered = exponent * (1 + jitterOffset);
+  return Math.min(capMs, Math.max(baseMs, Math.round(jittered)));
+}
+
+function planReconnect(attempt, opts) {
+  const connectedDurationMs = opts && typeof opts.connectedDurationMs === 'number'
+    ? Math.max(0, Math.floor(opts.connectedDurationMs))
+    : null;
+  const stableWindowMs = opts && opts.stableWindowMs ? opts.stableWindowMs : WATCH_RECONNECT_STABLE_WINDOW_MS;
+  const reason = opts && opts.reason ? String(opts.reason) : 'unknown';
+  let effectiveAttempt = Math.max(0, Math.floor(attempt));
+  let reset = false;
+
+  if (connectedDurationMs !== null && connectedDurationMs >= stableWindowMs && effectiveAttempt > 0) {
+    effectiveAttempt = 0;
+    reset = true;
+  }
+
+  const delayMs = backoffDelayMs(effectiveAttempt, opts && opts.backoff);
+  return {
+    attemptNumber: effectiveAttempt + 1,
+    nextAttempt: effectiveAttempt + 1,
+    delayMs,
+    reason,
+    reset,
+    connectedDurationMs,
+    stableWindowMs,
+  };
 }
 
 function sleep(ms, signal) {
@@ -3035,11 +3073,9 @@ async function runWatch(argv) {
     throw new Error('watch no longer polls. Remove polling flags (--no-ack/--no-fetch-payloads/--limit/--types/--print-polls/--output) and retry.');
   }
 
-  const safetyIntervalSeconds = flags.safetyWakeInterval
-    ? parsePositiveInt(flags.safetyWakeInterval, '--safety-wake-interval')
-    : flags.safetyPollInterval
-      ? parsePositiveInt(flags.safetyPollInterval, '--safety-poll-interval')
-      : 180;
+  if (flags.safetyWakeInterval !== undefined || flags.safetyPollInterval !== undefined) {
+    throw new Error('Safety wake interval has been removed. Remove --safety-wake-interval/--safety-poll-interval and retry.');
+  }
 
   const openclawBin = String(flags.openclawBin || 'openclaw');
   const mode = String(flags.mode || 'now');
@@ -3050,7 +3086,6 @@ async function runWatch(argv) {
     relay_url: config.relay_url,
     state_path: statePath,
     stream_path: streamPath,
-    safety_wake_interval_seconds: safetyIntervalSeconds,
     openclaw_enabled: openclawEnabled,
   });
 
@@ -3091,7 +3126,7 @@ async function runWatch(argv) {
         const label = queuedReason || reason;
         queuedReason = null;
 
-        // Best-effort: waking OpenClaw can be retried on the next wake/safety interval.
+        // Best-effort: waking OpenClaw can be retried on the next wake event.
         const didWake = triggerOpenclawWake(label);
         console.error(`[watch] wake ${didWake ? 'ok' : 'skipped'} (${label})`);
       }
@@ -3114,19 +3149,26 @@ async function runWatch(argv) {
   console.error(`[watch] relay=${config.relay_url}`);
   console.error(`[watch] state_path=${statePath}`);
   console.error(`[watch] stream_path=${streamPath}`);
-  console.error(`[watch] safety_wake_interval_seconds=${safetyIntervalSeconds}`);
+
+  console.error(`[watch] streams=${streams.join(',')}`);
+  console.error(`[watch] safety_poll_interval_seconds=${safetyIntervalSeconds}`);
+  console.error(`[watch] reconnect_backoff_base_ms=${WATCH_RECONNECT_BASE_MS}`);
+  console.error(`[watch] reconnect_backoff_factor=${WATCH_RECONNECT_FACTOR}`);
+  console.error(`[watch] reconnect_backoff_cap_ms=${WATCH_RECONNECT_CAP_MS}`);
+  console.error(`[watch] reconnect_backoff_jitter_ratio=${WATCH_RECONNECT_JITTER_RATIO}`);
+  console.error(`[watch] reconnect_stable_window_ms=${WATCH_RECONNECT_STABLE_WINDOW_MS}`);
 
   const safetyTimer = setInterval(() => {
     if (signal.aborted) {
       return;
     }
-    void runWakeLoop('safety');
+    void runPollLoop('safety');
   }, safetyIntervalSeconds * 1000);
 
-  // Kick off an initial wake so the agent can poll even if wakeups are missed.
-  void runWakeLoop('startup');
+  // Kick off an initial poll so the watcher is useful even if wakeups are missed.
+  void runPollLoop('startup');
 
-  let attempt = 0;
+  let reconnectAttempt = 0;
   function isWakeEvent(evt) {
     if (!evt) {
       return false;
@@ -3165,8 +3207,8 @@ async function runWatch(argv) {
         throw new Error(`SSE connect failed (${response.status}): ${text || response.statusText}`);
       }
 
-      attempt = 0;
       console.error('[watch] connected');
+      const connectedAt = Date.now();
 
       await consumeSseStream(response.body, {
         signal,
@@ -3187,21 +3229,31 @@ async function runWatch(argv) {
         break;
       }
 
-      console.error('[watch] disconnected');
+      const disconnectedDurationMs = Math.max(0, Date.now() - connectedAt);
+      const disconnectPlan = planReconnect(reconnectAttempt, {
+        reason: 'SSE stream disconnected',
+        connectedDurationMs: disconnectedDurationMs,
+      });
+      reconnectAttempt = disconnectPlan.nextAttempt;
+      if (disconnectPlan.reset) {
+        console.error(`[watch] reconnect backoff reset after stable connection (${disconnectPlan.connectedDurationMs}ms >= ${disconnectPlan.stableWindowMs}ms)`);
+      }
+      console.error(`[watch] reconnect health: attempt=${disconnectPlan.attemptNumber} delay_ms=${disconnectPlan.delayMs} reason=${disconnectPlan.reason} connected_ms=${disconnectPlan.connectedDurationMs}`);
+      await sleep(disconnectPlan.delayMs, signal);
     } catch (err) {
       if (signal.aborted) {
         break;
       }
       const message = err && err.message ? err.message : String(err);
-      const delayMs = backoffDelayMs(attempt);
-      attempt += 1;
-      console.error(`[watch] sse error: ${message}`);
-      console.error(`[watch] reconnecting in ${Math.round(delayMs / 1000)}s`);
-      await sleep(delayMs, signal);
+      const errorPlan = planReconnect(reconnectAttempt, {
+        reason: message,
+      });
+      reconnectAttempt = errorPlan.nextAttempt;
+      console.error(`[watch] reconnect health: attempt=${errorPlan.attemptNumber} delay_ms=${errorPlan.delayMs} reason=${errorPlan.reason} connected_ms=unknown`);
+      await sleep(errorPlan.delayMs, signal);
     }
   }
 
-  clearInterval(safetyTimer);
 }
 
 const DISPATCH_BOOL_FLAGS = new Set([
@@ -3444,7 +3496,19 @@ async function main() {
   }
 }
 
-main().catch((err) => {
-  console.error(err.message || err);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(err.message || err);
+    process.exit(1);
+  });
+} else {
+  module.exports = {
+    backoffDelayMs,
+    planReconnect,
+    WATCH_RECONNECT_BASE_MS,
+    WATCH_RECONNECT_FACTOR,
+    WATCH_RECONNECT_CAP_MS,
+    WATCH_RECONNECT_JITTER_RATIO,
+    WATCH_RECONNECT_STABLE_WINDOW_MS,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nanobazaar-cli",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "NanoBazaar CLI for the NanoBazaar Relay and OpenClaw skill.",
   "homepage": "https://github.com/nanobazaar/nanobazaar/tree/main/packages/nanobazaar-cli#readme",
   "license": "UNLICENSED",