nanobazaar-cli 2.0.0 → 2.0.2

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to `nanobazaar-cli` are documented in this file.
 
 This project follows Semantic Versioning.
 
+## [2.0.2] - 2026-02-08
+
+### Fixed
+- `job mark-paid` now defaults to an idempotency key derived from the request payload (prevents `409 idempotency collision` when retrying with updated evidence).
+
+### Added
+- `NBR_IDEMPOTENCY_KEY` env override for commands that accept `--idempotency-key` (`job charge|mark-paid|deliver|reissue-charge`).
+
+## [2.0.1] - 2026-02-08
+
+### Changed
+- `nanobazaar watch` is now notifier-only: it keeps an SSE connection and wakes OpenClaw on relay wake events + a safety interval, but does not poll or ack.
+- Added `--safety-wake-interval` (alias for `--safety-poll-interval`) to reflect notifier semantics.
+
 ## [2.0.0] - 2026-02-08
 
 ### Added

package/bin/nanobazaar

@@ -74,6 +74,35 @@ function sha256Hex(buffer) {
   return crypto.createHash('sha256').update(buffer).digest('hex');
 }
 
+function stableJsonNormalize(value) {
+  if (value === undefined) {
+    return null;
+  }
+  if (value === null || typeof value !== 'object') {
+    return value;
+  }
+  if (typeof value.toJSON === 'function') {
+    return stableJsonNormalize(value.toJSON());
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => stableJsonNormalize(entry));
+  }
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    const entry = value[key];
+    // Match JSON.stringify: omit undefined values in objects.
+    if (entry === undefined) {
+      continue;
+    }
+    out[key] = stableJsonNormalize(entry);
+  }
+  return out;
+}
+
+function stableJsonStringify(value) {
+  return JSON.stringify(stableJsonNormalize(value));
+}
+
 function loadState(filePath) {
   try {
     const raw = fs.readFileSync(filePath, 'utf8');
@@ -289,6 +318,17 @@ function getEnvValue(name) {
   return value && value.trim() ? value.trim() : '';
 }
 
+function resolveIdempotencyKey(flags, fallback) {
+  if (flags && flags.idempotencyKey) {
+    return String(flags.idempotencyKey);
+  }
+  const envKey = getEnvValue('NBR_IDEMPOTENCY_KEY');
+  if (envKey) {
+    return envKey;
+  }
+  return fallback ? String(fallback) : '';
+}
+
 function expandHomePath(value) {
   if (!value) {
     return value;
@@ -1235,11 +1275,11 @@ 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-poll-interval <seconds>]
+  watch [--stream-path /v0/stream] [--safety-wake-interval <seconds>]
         [--state-path <path>] [--openclaw-bin <bin>] [--event-text <text>]
-        [--mode now|next] [--no-openclaw] [--no-fetch-payloads]
-                             Maintain SSE connection; poll on wake + on safety interval.
-                             Triggers an OpenClaw wakeup when new events are persisted.
+        [--mode now|next] [--no-openclaw]
+                             Maintain SSE connection; wake OpenClaw on relay wake events + on a safety interval.
+                             Does not poll or ack (OpenClaw should run /nanobazaar poll).
 
 Global flags:
   --help                     Show this help
@@ -1990,7 +2030,7 @@ async function runJobCharge(argv) {
     method: 'POST',
     path: `/v0/jobs/${jobId}/charge`,
     body: payload,
-    idempotencyKey: String(flags.idempotencyKey || chargeId),
+    idempotencyKey: resolveIdempotencyKey(flags, chargeId),
     relayUrl: config.relay_url,
     keys,
     identity,
@@ -2060,11 +2100,15 @@ async function runJobMarkPaid(argv) {
   const {keys} = requireKeys(state);
   const identity = deriveIdentity(keys);
 
+  const requestBody = payload && Object.keys(payload).length > 0 ? payload : undefined;
+  const bodyHash = sha256Hex(stableJsonStringify(requestBody)).slice(0, 16);
+  const defaultIdempotencyKey = `mark_paid:${jobId}:${bodyHash}`;
+
   const result = await signedRequest({
     method: 'POST',
     path: `/v0/jobs/${jobId}/mark_paid`,
-    body: payload && Object.keys(payload).length > 0 ? payload : undefined,
-    idempotencyKey: String(flags.idempotencyKey || `mark_paid:${jobId}`),
+    body: requestBody,
+    idempotencyKey: resolveIdempotencyKey(flags, defaultIdempotencyKey),
     relayUrl: config.relay_url,
     keys,
     identity,
@@ -2144,7 +2188,7 @@ async function runJobDeliver(argv) {
     method: 'POST',
     path: `/v0/jobs/${jobId}/deliver`,
     body: {payload: built.envelope},
-    idempotencyKey: String(flags.idempotencyKey || payloadId),
+    idempotencyKey: resolveIdempotencyKey(flags, payloadId),
     relayUrl: config.relay_url,
     keys,
     identity,
@@ -2272,7 +2316,7 @@ async function runJobReissueCharge(argv) {
     method: 'POST',
     path: `/v0/jobs/${jobId}/charge/reissue`,
     body: payload,
-    idempotencyKey: String(flags.idempotencyKey || payload.charge_id),
+    idempotencyKey: resolveIdempotencyKey(flags, payload.charge_id),
     relayUrl: config.relay_url,
     keys,
     identity,
@@ -2987,14 +3031,15 @@ async function runWatch(argv) {
     throw new Error('Local fswatch wakeups are removed. Remove --fswatch-bin/--debounce-ms and retry.');
   }
 
-  const safetyIntervalSeconds = flags.safetyPollInterval
-    ? parsePositiveInt(flags.safetyPollInterval, '--safety-poll-interval')
-    : 180;
+  if (flags.ack !== undefined || flags.fetchPayloads !== undefined || flags.limit !== undefined || flags.output !== undefined || flags.printPolls !== undefined || flags.types !== undefined) {
+    throw new Error('watch no longer polls. Remove polling flags (--no-ack/--no-fetch-payloads/--limit/--types/--print-polls/--output) and retry.');
+  }
 
-  const printPolls = !!flags.printPolls;
-  const pollLimit = parseOptionalPositiveInt(flags.limit, '--limit')
-    ?? parseOptionalPositiveInt(config.poll_limit, 'NBR_POLL_LIMIT');
-  const pollTypes = flags.types || config.poll_types;
+  const safetyIntervalSeconds = flags.safetyWakeInterval
+    ? parsePositiveInt(flags.safetyWakeInterval, '--safety-wake-interval')
+    : flags.safetyPollInterval
+      ? parsePositiveInt(flags.safetyPollInterval, '--safety-poll-interval')
+      : 180;
 
   const openclawBin = String(flags.openclawBin || 'openclaw');
   const mode = String(flags.mode || 'now');
@@ -3005,22 +3050,18 @@ async function runWatch(argv) {
     relay_url: config.relay_url,
     state_path: statePath,
     stream_path: streamPath,
-    safety_poll_interval_seconds: safetyIntervalSeconds,
-    ack: flags.ack !== false,
-    poll_limit: pollLimit ?? null,
-    poll_types: pollTypes ?? null,
-    print_polls: printPolls,
+    safety_wake_interval_seconds: safetyIntervalSeconds,
     openclaw_enabled: openclawEnabled,
   });
 
-  let pollInFlight = false;
-  let pollQueued = false;
-  let queuedReason = null;
   let openclawMissing = false;
+  let wakeInFlight = false;
+  let wakeQueued = false;
+  let queuedReason = null;
 
   function triggerOpenclawWake(reason) {
     if (!openclawEnabled || openclawMissing) {
-      return;
+      return false;
     }
     if (debugLog) {
       debugLog('openclaw wake', {reason, openclaw_bin: openclawBin, mode, event_text: eventText});
@@ -3032,53 +3073,30 @@ async function runWatch(argv) {
       if (debugLog) {
         debugLog('openclaw wake failed', result.error && result.error.message ? result.error.message : String(result.error));
       }
+      return false;
     }
+    return true;
   }
 
-  async function runPollLoop(reason) {
+  async function runWakeLoop(reason) {
     queuedReason = reason;
-    pollQueued = true;
-    if (pollInFlight) {
+    wakeQueued = true;
+    if (wakeInFlight) {
       return;
     }
-    pollInFlight = true;
+    wakeInFlight = true;
     try {
-      while (pollQueued) {
-        pollQueued = false;
+      while (wakeQueued) {
+        wakeQueued = false;
         const label = queuedReason || reason;
         queuedReason = null;
-        try {
-          const {response, events, addedEvents, ackedId} = await pollOnce({
-            config,
-            state,
-            statePath,
-            keys,
-            identity,
-            since: undefined,
-            limit: pollLimit,
-            types: pollTypes,
-            ack: flags.ack !== false,
-            fetchPayloads: flags.fetchPayloads !== false,
-            quiet: true,
-            compact: !!flags.compact,
-            debugLog,
-          });
 
-          if (printPolls && response) {
-            printJson(response, !!flags.compact);
-          }
-
-          console.error(`[watch] poll ok (${label}): events=${events.length} added=${addedEvents} ack=${flags.ack === false ? 'disabled' : ackedId}`);
-          if (addedEvents > 0) {
-            triggerOpenclawWake(label);
-          }
-        } catch (err) {
-          console.error(`[watch] poll error (${label}): ${err && err.message ? err.message : String(err)}`);
-          // Keep running; polling is idempotent and can be retried on the next wake/safety interval.
-        }
+        // Best-effort: waking OpenClaw can be retried on the next wake/safety interval.
+        const didWake = triggerOpenclawWake(label);
+        console.error(`[watch] wake ${didWake ? 'ok' : 'skipped'} (${label})`);
       }
     } finally {
-      pollInFlight = false;
+      wakeInFlight = false;
     }
   }
 
@@ -3096,17 +3114,17 @@ 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_poll_interval_seconds=${safetyIntervalSeconds}`);
+  console.error(`[watch] safety_wake_interval_seconds=${safetyIntervalSeconds}`);
 
   const safetyTimer = setInterval(() => {
     if (signal.aborted) {
       return;
     }
-    void runPollLoop('safety');
+    void runWakeLoop('safety');
   }, safetyIntervalSeconds * 1000);
 
-  // Kick off an initial poll so the watcher is useful even if wakeups are missed.
-  void runPollLoop('startup');
+  // Kick off an initial wake so the agent can poll even if wakeups are missed.
+  void runWakeLoop('startup');
 
   let attempt = 0;
   function isWakeEvent(evt) {
@@ -3160,7 +3178,7 @@ async function runWatch(argv) {
           });
           if (isWakeEvent(evt)) {
             debugLog('wake detected', {});
-            void runPollLoop('wake');
+            void runWakeLoop('wake');
           }
         },
       });

package/package.json

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