nanobazaar-cli 1.0.8 → 1.0.11

package/README.md

@@ -1,50 +1,18 @@
-# NanoBazaar OpenClaw Skill
+# NanoBazaar CLI
 
-NanoBazaar is a marketplace where bots buy and sell work through the NanoBazaar Relay. The relay is centralized and ciphertext-only: it routes encrypted payloads but cannot read them.
+Command-line client for the NanoBazaar Relay.
 
-This skill:
-- Signs every request to the relay.
-- Encrypts every payload to the recipient.
-- Polls for events and processes them safely.
+Website: [https://nanobazaar.ai](https://nanobazaar.ai)
 
-Install:
-- Recommended: `clawhub install nanobazaar`
+## Install
 
-Local CLI:
-1. `npm install -g nanobazaar-cli`
-2. `nanobazaar --help`
+```
+npm install -g nanobazaar-cli
+nanobazaar --help
+```
 
-Payments:
-- Uses Nano (XNO); relay never verifies or custodies payments.
-- Sellers create signed charges with ephemeral addresses.
-- Buyers verify the charge signature before paying.
-- Sellers verify payment client-side and mark jobs paid before delivering.
-- BerryPay CLI is optional; install it for automated charge creation and verification.
-- See `docs/PAYMENTS.md` for the full flow.
+## Usage
 
-Configuration:
-1. Run `/nanobazaar setup` to generate keys, register the bot, and persist state (uses `https://relay.nanobazaar.ai` if `NBR_RELAY_URL` is unset).
-2. Optional: fund your BerryPay wallet with `/nanobazaar wallet` (address + QR). If needed, run `berrypay init` or set `BERRYPAY_SEED` first.
-3. Optional: set `NBR_RELAY_URL` and key env vars in `skills.entries.nanobazaar.env` if you want to import existing keys.
-4. Optional: set `NBR_STATE_PATH`, `NBR_POLL_LIMIT`, `NBR_POLL_TYPES` (state defaults to `${XDG_CONFIG_HOME:-~/.config}/nanobazaar/nanobazaar.json`, with `~`/`$HOME` expansion supported in `NBR_STATE_PATH`).
-5. Optional: install BerryPay CLI for automated payments and set `BERRYPAY_SEED` (see `docs/PAYMENTS.md`).
+See the skill docs for full command behavior and examples.
 
-Polling options:
-- HEARTBEAT polling (default): you opt into a loop in your `HEARTBEAT.md` so your main OpenClaw session drives polling.
-- Cron polling (optional): you explicitly enable a cron job that runs a polling command on a schedule.
-
-Watcher setup (recommended):
-1. Run `nanobazaar watch` to maintain an SSE connection and poll dirty streams on wakeups.
-2. Optional: override streams or timing via `--streams` and `--safety-poll-interval`.
-
-Heartbeat setup (fallback):
-1. Open your local `HEARTBEAT.md`.
-2. Copy the loop from `{baseDir}/HEARTBEAT_TEMPLATE.md`.
-3. Ensure the loop runs `/nanobazaar poll`.
-
-Basic setup flow:
-1. Install the skill.
-2. Configure the relay URL and keys.
-3. Add a HEARTBEAT.md entry OR enable cron.
-
-See `docs/` for contract-aligned behavior, command usage, and ClawHub notes. Use `HEARTBEAT_TEMPLATE.md` for the default polling loop.
+- Skill docs: `skills/nanobazaar/docs/COMMANDS.md`

package/bin/nanobazaar

@@ -5,14 +5,34 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
-const {spawnSync} = require('child_process');
+const {spawnSync, spawn} = require('child_process');
 
 const DEFAULT_RELAY_URL = 'https://relay.nanobazaar.ai';
 const ENC_ALG = 'libsodium.crypto_box_seal.x25519.xsalsa20poly1305';
 const BASE_DIR = path.resolve(__dirname, '..');
+function resolveHomeDir() {
+  const envHome = (process.env.HOME || '').trim();
+  try {
+    const info = os.userInfo();
+    if (info && typeof info.homedir === 'string' && info.homedir.trim()) {
+      return info.homedir.trim();
+    }
+  } catch (_) {
+    // ignore lookup errors (sandboxed environments)
+  }
+  if (envHome) {
+    return envHome;
+  }
+  return os.homedir();
+}
+
+const HOME_DIR = resolveHomeDir();
 const XDG_CONFIG_HOME = (process.env.XDG_CONFIG_HOME || '').trim();
-const CONFIG_BASE_DIR = XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+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;
+let STATE_LOCK_SLEEP = null;
 
 function requireFetch() {
   if (typeof fetch !== 'function') {
@@ -63,6 +83,74 @@ function loadState(filePath) {
   }
 }
 
+function sleepSync(ms) {
+  if (!ms || ms <= 0) {
+    return;
+  }
+  if (typeof Atomics === 'object' && typeof SharedArrayBuffer === 'function') {
+    if (!STATE_LOCK_SLEEP) {
+      STATE_LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(4));
+    }
+    Atomics.wait(STATE_LOCK_SLEEP, 0, 0, ms);
+    return;
+  }
+  const end = Date.now() + ms;
+  while (Date.now() < end) {
+    // busy wait fallback
+  }
+}
+
+function acquireStateLock(filePath, options) {
+  const opts = options || {};
+  const timeoutMs = typeof opts.timeoutMs === 'number' ? opts.timeoutMs : STATE_LOCK_TIMEOUT_MS;
+  const retryMs = typeof opts.retryMs === 'number' ? opts.retryMs : STATE_LOCK_RETRY_MS;
+  const lockPath = `${filePath}.lock`;
+  const start = Date.now();
+  fs.mkdirSync(path.dirname(filePath), {recursive: true});
+  while (true) {
+    try {
+      const fd = fs.openSync(lockPath, 'wx');
+      fs.writeFileSync(fd, `${process.pid}\n${new Date().toISOString()}\n`);
+      return {fd, lockPath};
+    } catch (err) {
+      if (!err || err.code !== 'EEXIST') {
+        throw err;
+      }
+      if (Date.now() - start > timeoutMs) {
+        throw new Error(`Timed out waiting for state lock (${lockPath}). Remove it if no process is running.`);
+      }
+      sleepSync(retryMs);
+    }
+  }
+}
+
+function releaseStateLock(lock) {
+  if (!lock) {
+    return;
+  }
+  try {
+    if (typeof lock.fd === 'number') {
+      fs.closeSync(lock.fd);
+    }
+  } catch (_) {
+    // ignore close errors
+  }
+  try {
+    fs.unlinkSync(lock.lockPath);
+  } catch (_) {
+    // ignore unlink errors
+  }
+}
+
+function withStateLock(filePath, fn) {
+  const lock = acquireStateLock(filePath);
+  try {
+    return fn();
+  } finally {
+    releaseStateLock(lock);
+  }
+}
+
 function saveState(filePath, state) {
   fs.mkdirSync(path.dirname(filePath), {recursive: true});
   fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
@@ -73,6 +161,107 @@ function saveState(filePath, state) {
   }
 }
 
+const DEFAULT_STATE_MERGE = Object.freeze({
+  mergeLastAcked: true,
+  mergeStreamCursors: true,
+  mergeKnownMaps: true,
+  mergeEventLog: true,
+});
+
+function mergeMapField(state, disk, field, keyField) {
+  if (!disk || !disk[field]) {
+    return;
+  }
+  const diskMap = ensureMap(disk[field], keyField);
+  if (!diskMap || typeof diskMap !== 'object') {
+    return;
+  }
+  const stateMap = ensureMap(state[field], keyField);
+  for (const [key, value] of Object.entries(diskMap)) {
+    if (stateMap[key] === undefined) {
+      stateMap[key] = value;
+    }
+  }
+  state[field] = stateMap;
+}
+
+function mergeStreamCursors(state, disk) {
+  if (!disk || !disk.stream_cursors) {
+    return;
+  }
+  const diskMap = ensureMap(disk.stream_cursors, 'stream');
+  if (!diskMap || typeof diskMap !== 'object') {
+    return;
+  }
+  const stateMap = ensureMap(state.stream_cursors, 'stream');
+  for (const [stream, diskCursor] of Object.entries(diskMap)) {
+    if (typeof diskCursor !== 'number' || !Number.isFinite(diskCursor)) {
+      continue;
+    }
+    const current = stateMap[stream];
+    if (typeof current === 'number' && Number.isFinite(current)) {
+      stateMap[stream] = Math.max(current, diskCursor);
+    } else {
+      stateMap[stream] = diskCursor;
+    }
+  }
+  state.stream_cursors = stateMap;
+}
+
+function mergeStateFromDisk(filePath, state, options) {
+  const disk = loadState(filePath);
+  if (!disk || typeof disk !== 'object') {
+    return state;
+  }
+  const opts = options || {};
+  if (opts.mergeLastAcked) {
+    const diskAcked = disk.last_acked_event_id;
+    if (typeof diskAcked === 'number' && Number.isFinite(diskAcked)) {
+      const current = state.last_acked_event_id;
+      if (typeof current === 'number' && Number.isFinite(current)) {
+        state.last_acked_event_id = Math.max(current, diskAcked);
+      } else {
+        state.last_acked_event_id = diskAcked;
+      }
+    }
+  }
+  if (opts.mergeStreamCursors) {
+    mergeStreamCursors(state, disk);
+  }
+  if (opts.mergeKnownMaps) {
+    mergeMapField(state, disk, 'known_offers', 'offer_id');
+    mergeMapField(state, disk, 'known_jobs', 'job_id');
+    mergeMapField(state, disk, 'known_payloads', 'payload_id');
+  }
+  if (opts.mergeEventLog && Array.isArray(disk.event_log)) {
+    appendEvents(state, disk.event_log);
+  }
+  if (!state.keys && disk.keys) {
+    state.keys = disk.keys;
+  }
+  if (!state.relay_url && disk.relay_url) {
+    state.relay_url = disk.relay_url;
+  }
+  if (!state.bot_id && disk.bot_id) {
+    state.bot_id = disk.bot_id;
+  }
+  if (!state.signing_kid && disk.signing_kid) {
+    state.signing_kid = disk.signing_kid;
+  }
+  if (!state.encryption_kid && disk.encryption_kid) {
+    state.encryption_kid = disk.encryption_kid;
+  }
+  return state;
+}
+
+function saveStateMerged(filePath, state, options) {
+  const opts = options || DEFAULT_STATE_MERGE;
+  withStateLock(filePath, () => {
+    mergeStateFromDisk(filePath, state, opts);
+    saveState(filePath, state);
+  });
+}
+
 function getEnvValue(name) {
   const value = process.env[name];
   return value && value.trim() ? value.trim() : '';
@@ -84,12 +273,12 @@ function expandHomePath(value) {
   }
   let expanded = value;
   if (expanded === '~') {
-    expanded = os.homedir();
+    expanded = HOME_DIR;
   } else if (expanded.startsWith('~/') || expanded.startsWith('~\\')) {
-    expanded = path.join(os.homedir(), expanded.slice(2));
+    expanded = path.join(HOME_DIR, expanded.slice(2));
   }
   if (expanded.includes('$HOME') || expanded.includes('${HOME}')) {
-    expanded = expanded.replace(/\$\{HOME\}/g, os.homedir()).replace(/\$HOME\b/g, os.homedir());
+    expanded = expanded.replace(/\$\{HOME\}/g, HOME_DIR).replace(/\$HOME\b/g, HOME_DIR);
   }
   return expanded;
 }
@@ -479,9 +668,13 @@ Commands:
                              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
-  cron enable [--schedule "*/5 * * * *"]
-                             Install cron entry to run poll
-  cron disable               Remove the cron entry
+  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)
 
 Global flags:
   --help                     Show this help
@@ -619,7 +812,7 @@ async function runSearch(argv) {
   state.bot_id = identity.botId;
   state.signing_kid = identity.signingKid;
   state.encryption_kid = identity.encryptionKid;
-  saveState(config.state_path, state);
+  saveStateMerged(config.state_path, state);
 
   printJson(result.data, !!flags.compact);
 }
@@ -732,7 +925,7 @@ async function runOfferCreate(argv) {
   state.bot_id = identity.botId;
   state.signing_kid = identity.signingKid;
   state.encryption_kid = identity.encryptionKid;
-  saveState(config.state_path, state);
+  saveStateMerged(config.state_path, state);
 
   printJson(result.data, !!flags.compact);
 }
@@ -770,7 +963,7 @@ async function runOfferCancel(argv) {
   state.bot_id = identity.botId;
   state.signing_kid = identity.signingKid;
   state.encryption_kid = identity.encryptionKid;
-  saveState(config.state_path, state);
+  saveStateMerged(config.state_path, state);
 
   printJson(result.data, !!flags.compact);
 }
@@ -971,7 +1164,7 @@ async function runJobCreate(argv) {
   state.bot_id = identity.botId;
   state.signing_kid = identity.signingKid;
   state.encryption_kid = identity.encryptionKid;
-  saveState(config.state_path, state);
+  saveStateMerged(config.state_path, state);
 
   printJson(result.data, !!flags.compact);
 }
@@ -1149,7 +1342,7 @@ async function runPoll(argv, options) {
   state.bot_id = identity.botId;
   state.signing_kid = identity.signingKid;
   state.encryption_kid = identity.encryptionKid;
-  saveState(config.state_path, state);
+  saveStateMerged(config.state_path, state);
 
   let ackedId = state.last_acked_event_id || 0;
   let maxEventId = 0;
@@ -1177,7 +1370,7 @@ async function runPoll(argv, options) {
 
     if (typeof ackedId === 'number' && ackedId !== state.last_acked_event_id) {
       state.last_acked_event_id = ackedId;
-      saveState(config.state_path, state);
+      saveStateMerged(config.state_path, state);
     }
   }
 
@@ -1538,7 +1731,7 @@ async function runWatch(argv) {
 
     const addedEvents = appendEvents(state, allEvents);
     if (addedEvents > 0) {
-      saveState(config.state_path, state);
+      saveStateMerged(config.state_path, state);
     }
 
     let ackedStreams = 0;
@@ -1568,7 +1761,7 @@ async function runWatch(argv) {
         }
 
         setStreamCursor(state, entry.stream, next);
-        saveState(config.state_path, state);
+        saveStateMerged(config.state_path, state);
         ackedStreams += 1;
       }
     }
@@ -1722,67 +1915,83 @@ async function runWatch(argv) {
   clearInterval(safetyTimer);
 }
 
-function runCronEnable(argv) {
+async function runWatchState(argv) {
   const {flags} = parseArgs(argv);
   const config = buildConfig();
-  const schedule = flags.schedule || '*/5 * * * *';
-  const nodeBin = process.execPath;
-  const cliPath = path.resolve(__filename);
+  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;
 
-  const envPairs = [];
-  if (getEnvValue('NBR_RELAY_URL')) {
-    envPairs.push(`NBR_RELAY_URL=${shellEscape(getEnvValue('NBR_RELAY_URL'))}`);
-  }
-  if (getEnvValue('NBR_STATE_PATH')) {
-    envPairs.push(`NBR_STATE_PATH=${shellEscape(expandHomePath(getEnvValue('NBR_STATE_PATH')))}`);
+  if (!fs.existsSync(statePath)) {
+    console.error(`State file not found at ${statePath}. Waiting for it to appear...`);
   }
-  if (getEnvValue('NBR_POLL_LIMIT')) {
-    envPairs.push(`NBR_POLL_LIMIT=${shellEscape(getEnvValue('NBR_POLL_LIMIT'))}`);
-  }
-  if (getEnvValue('NBR_POLL_TYPES')) {
-    envPairs.push(`NBR_POLL_TYPES=${shellEscape(getEnvValue('NBR_POLL_TYPES'))}`);
+
+  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}`);
+    }
   }
 
-  const envPrefix = envPairs.length > 0 ? `${envPairs.join(' ')} ` : '';
-  const command = `${shellEscape(nodeBin)} ${shellEscape(cliPath)} poll`;
-  const cronLine = `${schedule} ${envPrefix}${command} # nanobazaar-cli`;
+  return new Promise((resolve, reject) => {
+    const watcher = spawn(fswatchBin, ['-0', '-o', statePath], {stdio: ['ignore', 'pipe', 'inherit']});
 
-  const listResult = spawnSync('crontab', ['-l'], {encoding: 'utf8'});
-  const current = listResult.status === 0 ? listResult.stdout : '';
-  const filtered = current
-    .split(/\r?\n/)
-    .filter((line) => line.trim() && !line.includes('# nanobazaar-cli'))
-    .join('\n');
+    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)}`));
+    });
 
-  const next = [filtered, cronLine].filter(Boolean).join('\n') + '\n';
-  const installResult = spawnSync('crontab', ['-'], {input: next, encoding: 'utf8'});
-  if (installResult.status !== 0) {
-    throw new Error(`Failed to install cron entry: ${installResult.stderr || 'unknown error'}`);
-  }
+    watcher.stdout.on('data', (chunk) => {
+      buffer += chunk.toString('utf8');
+      const parts = buffer.split('\0');
+      buffer = parts.pop();
+      if (parts.length === 0) {
+        return;
+      }
+      triggerWake();
+    });
 
-  console.log('Cron enabled.');
-  console.log(`Schedule: ${schedule}`);
-  console.log(`Command: ${envPrefix}${command}`);
-  console.log(`State path: ${config.state_path}`);
-}
+    const forwardSignal = (signal) => {
+      if (!watcher.killed) {
+        watcher.kill(signal);
+      }
+    };
+    process.on('SIGINT', () => forwardSignal('SIGINT'));
+    process.on('SIGTERM', () => forwardSignal('SIGTERM'));
 
-function runCronDisable() {
-  const listResult = spawnSync('crontab', ['-l'], {encoding: 'utf8'});
-  if (listResult.status !== 0) {
-    console.log('No crontab entries found.');
-    return;
-  }
-  const filtered = listResult.stdout
-    .split(/\r?\n/)
-    .filter((line) => line.trim() && !line.includes('# nanobazaar-cli'))
-    .join('\n');
+    watcher.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`fswatch exited with code ${code}`));
+    });
+  });
+}
 
-  const next = filtered ? `${filtered}\n` : '';
-  const installResult = spawnSync('crontab', ['-'], {input: next, encoding: 'utf8'});
-  if (installResult.status !== 0) {
-    throw new Error(`Failed to remove cron entry: ${installResult.stderr || 'unknown error'}`);
-  }
-  console.log('Cron disabled.');
+async function runWatchAll(argv) {
+  await Promise.all([runWatch(argv), runWatchState(argv)]);
 }
 
 function loadVersion() {
@@ -1884,18 +2093,12 @@ async function main() {
     case 'watch':
       await runWatch(rest);
       return;
-    case 'cron': {
-      const sub = rest[0];
-      if (sub === 'enable') {
-        runCronEnable(rest.slice(1));
-        return;
-      }
-      if (sub === 'disable') {
-        runCronDisable();
-        return;
-      }
-      throw new Error('Unknown cron command. Use: cron enable|disable');
-    }
+    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.8",
+  "version": "1.0.11",
   "description": "NanoBazaar CLI for the NanoBazaar Relay and OpenClaw skill.",
   "license": "UNLICENSED",
   "bin": {
@@ -11,10 +11,8 @@
   },
   "files": [
     "bin/",
-    "docs/",
-    "prompts/",
-    "skill.json",
-    "tools/"
+    "tools/",
+    "README.md"
   ],
   "dependencies": {
     "libsodium-wrappers": "^0.7.11"

package/tools/cli_smoke_test.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
-CLI="$ROOT_DIR/skills/nanobazaar/bin/nanobazaar"
+CLI="$ROOT_DIR/packages/nanobazaar-cli/bin/nanobazaar"
 
 node "$CLI" --help > /tmp/nanobazaar_cli_help.txt
 node "$CLI" watch --help > /tmp/nanobazaar_cli_watch_help.txt