nanobazaar-cli 1.0.11 → 1.0.13

package/bin/nanobazaar

@@ -412,6 +412,74 @@ function parseArgs(argv) {
   return {flags, positionals};
 }
 
+function parseBoolish(value) {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+  if (value === true || value === false) {
+    return value;
+  }
+  const raw = String(value).trim().toLowerCase();
+  if (!raw) {
+    return undefined;
+  }
+  if (raw === '0' || raw === 'false' || raw === 'no' || raw === 'off') {
+    return false;
+  }
+  if (raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on') {
+    return true;
+  }
+  return true;
+}
+
+function isDebugEnabled(flags) {
+  const flagValue = parseBoolish(flags ? flags.debug : undefined);
+  if (flagValue !== undefined) {
+    return flagValue;
+  }
+  return parseBoolish(getEnvValue('NBR_DEBUG')) === true;
+}
+
+function previewString(value, maxLen) {
+  if (value === undefined || value === null) {
+    return '';
+  }
+  const raw = String(value).replace(/\r/g, '\\r').replace(/\n/g, '\\n');
+  const limit = typeof maxLen === 'number' && Number.isFinite(maxLen) ? Math.max(0, Math.floor(maxLen)) : 0;
+  if (!limit || raw.length <= limit) {
+    return raw;
+  }
+  if (limit <= 3) {
+    return raw.slice(0, limit);
+  }
+  return raw.slice(0, limit - 3) + '...';
+}
+
+function previewJson(value, maxLen) {
+  try {
+    return previewString(JSON.stringify(value), maxLen);
+  } catch (_) {
+    return previewString(String(value), maxLen);
+  }
+}
+
+function createDebugLogger(enabled, scope) {
+  const on = !!enabled;
+  const tag = scope ? String(scope) : 'debug';
+  return (message, payload) => {
+    if (!on) {
+      return;
+    }
+    const ts = new Date().toISOString();
+    const prefix = `[${tag}][debug] ${ts}`;
+    if (payload === undefined) {
+      console.error(`${prefix} ${message}`);
+      return;
+    }
+    console.error(`${prefix} ${message} ${typeof payload === 'string' ? previewString(payload, 2000) : previewJson(payload, 4000)}`);
+  };
+}
+
 function readTextInput(value, label) {
   if (value === undefined || value === null) {
     return '';
@@ -667,18 +735,15 @@ Commands:
   poll [--since-event-id <id>] [--limit <n>] [--types a,b] [--no-ack]
                              Poll events and optionally ack
   watch [--streams a,b] [--stream-path /v0/stream] [--safety-poll-interval <seconds>]
-                             Maintain SSE connection; poll on wake + on safety interval
-  watch-state [--state-path <path>] [--openclaw-bin <bin>] [--fswatch-bin <bin>]
-              [--event-text <text>] [--mode now|next] [--debounce-ms <ms>]
-                             Watch state file and trigger OpenClaw wakeups
-  watch-all [--streams a,b] [--stream-path /v0/stream] [--safety-poll-interval <seconds>]
-            [--state-path <path>] [--openclaw-bin <bin>] [--fswatch-bin <bin>]
-            [--event-text <text>] [--mode now|next] [--debounce-ms <ms>]
-                             Run relay watch + state watcher together (recommended)
+        [--state-path <path>] [--openclaw-bin <bin>] [--fswatch-bin <bin>]
+        [--event-text <text>] [--mode now|next] [--debounce-ms <ms>]
+                             Maintain SSE connection; poll on wake + on safety interval.
+                             If fswatch is available, also watch local state and trigger OpenClaw wakeups.
 
 Global flags:
   --help                     Show this help
   --version                  Print skill version
+  --debug                    Print verbose debug logs to stderr (or set NBR_DEBUG=1)
 
 Notes:
   - Defaults to relay: ${DEFAULT_RELAY_URL}
@@ -1302,6 +1367,7 @@ async function runJobPaymentSent(argv) {
 async function runPoll(argv, options) {
   const quiet = options && options.quiet;
   const {flags} = parseArgs(argv);
+  const debugLog = createDebugLogger(isDebugEnabled(flags), 'poll');
   const config = buildConfig();
   const state = loadState(config.state_path);
   const {keys} = requireKeys(state);
@@ -1311,6 +1377,17 @@ async function runPoll(argv, options) {
   const limit = flags.limit || config.poll_limit;
   const types = flags.types || config.poll_types;
 
+  debugLog('request', {
+    method: 'GET',
+    path: '/v0/poll',
+    since_event_id: since ?? null,
+    limit: limit ?? null,
+    types: types ?? null,
+    ack: flags.ack !== false,
+    relay_url: config.relay_url,
+    state_path: config.state_path,
+  });
+
   const result = await signedRequest({
     method: 'GET',
     path: '/v0/poll',
@@ -1333,7 +1410,8 @@ async function runPoll(argv, options) {
   }
 
   const events = result.data && result.data.events ? result.data.events : [];
-  appendEvents(state, events);
+  const addedEvents = appendEvents(state, events);
+  debugLog('response', {status: result.response.status, events: events.length, added: addedEvents});
 
   if (typeof state.last_acked_event_id !== 'number') {
     state.last_acked_event_id = 0;
@@ -1350,6 +1428,7 @@ async function runPoll(argv, options) {
     maxEventId = events.reduce((max, event) => Math.max(max, event.event_id), 0);
 
     // Ack only after events are durably persisted to local state.
+    debugLog('ack request', {up_to_event_id: maxEventId});
     const ackResult = await signedRequest({
       method: 'POST',
       path: '/v0/poll/ack',
@@ -1367,6 +1446,7 @@ async function runPoll(argv, options) {
     } else {
       ackedId = maxEventId;
     }
+    debugLog('ack ok', {last_acked_event_id: ackedId});
 
     if (typeof ackedId === 'number' && ackedId !== state.last_acked_event_id) {
       state.last_acked_event_id = ackedId;
@@ -1635,12 +1715,131 @@ function deriveDefaultStreams({keys, state}) {
   return uniqStrings(streams);
 }
 
+function startStateWatcher(options) {
+  const opts = options || {};
+  const statePath = String(opts.statePath || '');
+  const fswatchBin = String(opts.fswatchBin || 'fswatch');
+  const openclawBin = String(opts.openclawBin || 'openclaw');
+  const mode = String(opts.mode || 'now');
+  const eventText = String(opts.eventText || 'NanoBazaar state changed');
+  const debounceMs = typeof opts.debounceMs === 'number' ? opts.debounceMs : 250;
+  const debugLog = typeof opts.debugLog === 'function' ? opts.debugLog : null;
+  const signal = opts.signal;
+
+  if (!statePath) {
+    return {stop: () => {}};
+  }
+
+  if (!fs.existsSync(statePath)) {
+    console.error(`[watch] state file not found at ${statePath}. Waiting for it to appear...`);
+  }
+
+  let watcher = null;
+  let buffer = '';
+  let lastWake = 0;
+  let openclawMissing = false;
+  let disabled = false;
+
+  function disable(message) {
+    if (disabled) {
+      return;
+    }
+    disabled = true;
+    if (message) {
+      console.error(`[watch] ${message}`);
+    }
+    if (watcher && !watcher.killed) {
+      watcher.kill('SIGTERM');
+    }
+  }
+
+  function triggerWake() {
+    if (openclawMissing) {
+      return;
+    }
+    const now = Date.now();
+    if (debounceMs && now - lastWake < debounceMs) {
+      return;
+    }
+    lastWake = now;
+    if (debugLog) {
+      debugLog('local wake: invoking openclaw', {openclaw_bin: openclawBin, mode, event_text: eventText});
+    }
+    const result = spawnSync(openclawBin, ['system', 'event', '--text', eventText, '--mode', mode], {stdio: 'inherit'});
+    if (result.error) {
+      openclawMissing = true;
+      console.error(`[watch] Failed to run ${openclawBin}: ${result.error.message}. Local wakeups disabled.`);
+      if (debugLog) {
+        debugLog('local wake: openclaw failed', result.error && result.error.message ? result.error.message : String(result.error));
+      }
+      return;
+    }
+    if (debugLog) {
+      debugLog('local wake: openclaw ok');
+    }
+  }
+
+  try {
+    watcher = spawn(fswatchBin, ['-0', '-o', statePath], {stdio: ['ignore', 'pipe', 'inherit']});
+  } catch (err) {
+    disable(`Failed to start fswatch: ${err && err.message ? err.message : String(err)}. Running SSE polling only.`);
+    return {stop: () => {}};
+  }
+
+  watcher.on('error', (err) => {
+    if (disabled) {
+      return;
+    }
+    if (err && err.code === 'ENOENT') {
+      disable('fswatch not found. Install it to enable local wakeups (macOS: brew install fswatch, Ubuntu: apt install fswatch).');
+      return;
+    }
+    disable(`Failed to start fswatch: ${err && err.message ? err.message : String(err)}. Running SSE polling only.`);
+  });
+
+  watcher.stdout.on('data', (chunk) => {
+    buffer += chunk.toString('utf8');
+    const parts = buffer.split('\0');
+    buffer = parts.pop();
+    if (parts.length === 0) {
+      return;
+    }
+    if (debugLog) {
+      debugLog('local wake: fswatch event', {count: parts.length});
+    }
+    triggerWake();
+  });
+
+  watcher.on('close', (code) => {
+    if (disabled || (signal && signal.aborted)) {
+      return;
+    }
+    if (code === 0) {
+      disable();
+      return;
+    }
+    disable(`fswatch exited with code ${code}. Running SSE polling only.`);
+  });
+
+  if (signal) {
+    if (signal.aborted) {
+      disable();
+    } else {
+      signal.addEventListener('abort', () => disable());
+    }
+  }
+
+  return {stop: () => disable()};
+}
+
 async function runWatch(argv) {
   requireFetch();
 
   const {flags} = parseArgs(argv);
+  const debugLog = createDebugLogger(isDebugEnabled(flags), 'watch');
   const config = buildConfig();
-  const state = loadState(config.state_path);
+  const statePath = expandHomePath(String(flags.statePath || config.state_path));
+  const state = loadState(statePath);
   const {keys} = requireKeys(state);
   const identity = deriveIdentity(keys);
 
@@ -1660,9 +1859,28 @@ async function runWatch(argv) {
   const pollLimit = parseOptionalPositiveInt(flags.limit, '--limit')
     ?? parseOptionalPositiveInt(config.poll_limit, 'NBR_POLL_LIMIT');
 
+  const fswatchBin = String(flags.fswatchBin || 'fswatch');
+  const openclawBin = String(flags.openclawBin || 'openclaw');
+  const mode = String(flags.mode || 'now');
+  const eventText = String(flags.eventText || 'NanoBazaar state changed');
+  const debounceMs = flags.debounceMs
+    ? parsePositiveInt(flags.debounceMs, '--debounce-ms')
+    : 250;
+
   ensureStreamCursorMap(state);
   const streamSet = new Set(streams);
 
+  debugLog('init', {
+    relay_url: config.relay_url,
+    state_path: statePath,
+    stream_path: streamPath,
+    streams,
+    safety_poll_interval_seconds: safetyIntervalSeconds,
+    ack: flags.ack !== false,
+    poll_limit: pollLimit ?? null,
+    print_polls: printPolls,
+  });
+
   let pollInFlight = false;
   let pollQueued = false;
   let queuedReason = null;
@@ -1692,6 +1910,7 @@ async function runWatch(argv) {
       body.limit = pollLimit;
     }
 
+    debugLog('poll/batch request', {reason, body});
     const result = await signedRequest({
       method: 'POST',
       path: '/v0/poll/batch',
@@ -1707,6 +1926,11 @@ async function runWatch(argv) {
     }
 
     const results = result.data && Array.isArray(result.data.results) ? result.data.results : [];
+    debugLog('poll/batch ok', results.map((entry) => ({
+      stream: entry && entry.stream ? entry.stream : null,
+      events: entry && Array.isArray(entry.events) ? entry.events.length : 0,
+      next: entry && typeof entry.next === 'number' ? entry.next : null,
+    })));
     const allEvents = [];
     for (const entry of results) {
       if (!entry || !Array.isArray(entry.events)) {
@@ -1723,6 +1947,16 @@ async function runWatch(argv) {
         }
       }
     }
+    if (allEvents.length > 0) {
+      for (const event of allEvents) {
+        debugLog('event', {
+          stream: event && event.stream ? event.stream : null,
+          event_id: event && event.event_id !== undefined ? event.event_id : null,
+          event_type: event && event.event_type ? event.event_type : null,
+          data_preview: event && event.data !== undefined ? previewJson(event.data, 500) : null,
+        });
+      }
+    }
 
     state.relay_url = config.relay_url;
     state.bot_id = identity.botId;
@@ -1731,7 +1965,7 @@ async function runWatch(argv) {
 
     const addedEvents = appendEvents(state, allEvents);
     if (addedEvents > 0) {
-      saveStateMerged(config.state_path, state);
+      saveStateMerged(statePath, state);
     }
 
     let ackedStreams = 0;
@@ -1746,6 +1980,7 @@ async function runWatch(argv) {
           continue;
         }
 
+        debugLog('ack request', {stream: entry.stream, from: current, to: next});
         const ackResult = await signedRequest({
           method: 'POST',
           path: '/v0/ack',
@@ -1761,8 +1996,9 @@ async function runWatch(argv) {
         }
 
         setStreamCursor(state, entry.stream, next);
-        saveStateMerged(config.state_path, state);
+        saveStateMerged(statePath, state);
         ackedStreams += 1;
+        debugLog('ack ok', {stream: entry.stream, ack: next});
       }
     }
 
@@ -1816,11 +2052,22 @@ async function runWatch(argv) {
   process.on('SIGTERM', stop);
 
   console.error(`[watch] relay=${config.relay_url}`);
-  console.error(`[watch] state_path=${config.state_path}`);
+  console.error(`[watch] state_path=${statePath}`);
   console.error(`[watch] stream_path=${streamPath}`);
   console.error(`[watch] streams=${streams.join(',')}`);
   console.error(`[watch] safety_poll_interval_seconds=${safetyIntervalSeconds}`);
 
+  const stateWatcher = startStateWatcher({
+    statePath,
+    fswatchBin,
+    openclawBin,
+    mode,
+    eventText,
+    debounceMs,
+    debugLog,
+    signal,
+  });
+
   const safetyTimer = setInterval(() => {
     if (signal.aborted) {
       return;
@@ -1887,8 +2134,14 @@ async function runWatch(argv) {
       await consumeSseStream(response.body, {
         signal,
         onEvent: (evt) => {
+          debugLog('sse event', {
+            event: evt && evt.event ? evt.event : null,
+            id: evt && evt.id ? evt.id : null,
+            data_preview: evt && evt.data ? previewString(evt.data, 500) : null,
+          });
           const wakeStreams = extractWakeStreams(evt);
           if (wakeStreams !== null) {
+            debugLog('wake detected', {streams: wakeStreams});
             void runPollLoop('wake', wakeStreams);
           }
         },
@@ -1913,85 +2166,7 @@ async function runWatch(argv) {
   }
 
   clearInterval(safetyTimer);
-}
-
-async function runWatchState(argv) {
-  const {flags} = parseArgs(argv);
-  const config = buildConfig();
-  const statePath = expandHomePath(String(flags.statePath || config.state_path));
-  const fswatchBin = String(flags.fswatchBin || 'fswatch');
-  const openclawBin = String(flags.openclawBin || 'openclaw');
-  const mode = String(flags.mode || 'now');
-  const eventText = String(flags.eventText || 'NanoBazaar state changed');
-  const debounceMs = flags.debounceMs
-    ? parsePositiveInt(flags.debounceMs, '--debounce-ms')
-    : 250;
-
-  if (!fs.existsSync(statePath)) {
-    console.error(`State file not found at ${statePath}. Waiting for it to appear...`);
-  }
-
-  let buffer = '';
-  let lastWake = 0;
-  let openclawMissing = false;
-
-  function triggerWake() {
-    if (openclawMissing) {
-      return;
-    }
-    const now = Date.now();
-    if (debounceMs && now - lastWake < debounceMs) {
-      return;
-    }
-    lastWake = now;
-    const result = spawnSync(openclawBin, ['system', 'event', '--text', eventText, '--mode', mode], {stdio: 'inherit'});
-    if (result.error) {
-      openclawMissing = true;
-      console.error(`Failed to run ${openclawBin}: ${result.error.message}`);
-    }
-  }
-
-  return new Promise((resolve, reject) => {
-    const watcher = spawn(fswatchBin, ['-0', '-o', statePath], {stdio: ['ignore', 'pipe', 'inherit']});
-
-    watcher.on('error', (err) => {
-      if (err && err.code === 'ENOENT') {
-        reject(new Error(`fswatch not found. Install it (macOS: brew install fswatch).`));
-        return;
-      }
-      reject(new Error(`Failed to start fswatch: ${err && err.message ? err.message : String(err)}`));
-    });
-
-    watcher.stdout.on('data', (chunk) => {
-      buffer += chunk.toString('utf8');
-      const parts = buffer.split('\0');
-      buffer = parts.pop();
-      if (parts.length === 0) {
-        return;
-      }
-      triggerWake();
-    });
-
-    const forwardSignal = (signal) => {
-      if (!watcher.killed) {
-        watcher.kill(signal);
-      }
-    };
-    process.on('SIGINT', () => forwardSignal('SIGINT'));
-    process.on('SIGTERM', () => forwardSignal('SIGTERM'));
-
-    watcher.on('close', (code) => {
-      if (code === 0) {
-        resolve();
-        return;
-      }
-      reject(new Error(`fswatch exited with code ${code}`));
-    });
-  });
-}
-
-async function runWatchAll(argv) {
-  await Promise.all([runWatch(argv), runWatchState(argv)]);
+  stateWatcher.stop();
 }
 
 function loadVersion() {
@@ -2030,8 +2205,13 @@ async function main() {
     return;
   }
 
-  const command = argv[0];
-  const rest = argv.slice(1);
+  const commandIndex = argv.findIndex((arg) => arg && arg !== '-' && !arg.startsWith('-'));
+  if (commandIndex === -1) {
+    printHelp();
+    return;
+  }
+  const command = argv[commandIndex];
+  const rest = argv.slice(0, commandIndex).concat(argv.slice(commandIndex + 1));
 
   switch (command) {
     case 'status':
@@ -2093,12 +2273,6 @@ async function main() {
     case 'watch':
       await runWatch(rest);
       return;
-    case 'watch-state':
-      await runWatchState(rest);
-      return;
-    case 'watch-all':
-      await runWatchAll(rest);
-      return;
     default:
       throw new Error(`Unknown command: ${command}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nanobazaar-cli",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "NanoBazaar CLI for the NanoBazaar Relay and OpenClaw skill.",
   "license": "UNLICENSED",
   "bin": {

package/tools/cli_smoke_test.sh

@@ -5,7 +5,10 @@ ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
 CLI="$ROOT_DIR/packages/nanobazaar-cli/bin/nanobazaar"
 
 node "$CLI" --help > /tmp/nanobazaar_cli_help.txt
+node "$CLI" --debug --help > /tmp/nanobazaar_cli_help_debug.txt
 node "$CLI" watch --help > /tmp/nanobazaar_cli_watch_help.txt
+node "$CLI" --debug watch --help > /tmp/nanobazaar_cli_watch_help_pre_debug.txt
+node "$CLI" watch --debug --help > /tmp/nanobazaar_cli_watch_help_post_debug.txt
 node "$CLI" config --json > /tmp/nanobazaar_cli_config.json
 
 echo "CLI smoke test passed."