@0xwork/cli 0.2.0 → 1.1.0

package/src/format.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const chalk = require('chalk');
+
+/**
+ * Truncate address: 0x84631A26Fab...9C → 0x8463...Dc9C
+ */
+function truncAddr(addr) {
+  if (!addr || addr.length < 12) return addr || '—';
+  return `${addr.slice(0, 6)}…${addr.slice(-4)}`;
+}
+
+/**
+ * Truncate tx hash: 0xabc123...def → 0xabc123…def4
+ */
+function truncTx(hash) {
+  if (!hash || hash.length < 16) return hash || '—';
+  return `${hash.slice(0, 10)}…${hash.slice(-4)}`;
+}
+
+/**
+ * Format bounty amount: "50.0" → "$50.00"
+ */
+function fmtBounty(amount) {
+  if (amount == null) return '—';
+  const n = typeof amount === 'string' ? parseFloat(amount) : amount;
+  if (isNaN(n)) return '—';
+  return `$${n.toFixed(2)}`;
+}
+
+/**
+ * Format bounty amount with chalk green.
+ */
+function fmtBountyColored(amount) {
+  return chalk.green(fmtBounty(amount));
+}
+
+/**
+ * Format AXOBOTL token amount: 440626.5 → "440,627"
+ */
+function fmtAxobotl(amount) {
+  if (amount == null) return '—';
+  const n = typeof amount === 'string' ? parseFloat(amount) : amount;
+  if (isNaN(n)) return '—';
+  return Math.round(n).toLocaleString('en-US');
+}
+
+/**
+ * Format deadline from unix timestamp.
+ * @param {number} ts — unix seconds
+ * @param {boolean} showRemaining — include time remaining
+ */
+function fmtDeadline(ts, showRemaining = false) {
+  if (!ts) return '—';
+  const date = new Date(ts * 1000);
+  const months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+  const str = `${months[date.getMonth()]} ${date.getDate()}`;
+
+  if (!showRemaining) return str;
+
+  const now = Math.floor(Date.now() / 1000);
+  const diff = ts - now;
+  if (diff <= 0) return `${str} ${chalk.red('(expired)')}`;
+  return `${str} (${fmtDuration(diff)} remaining)`;
+}
+
+/**
+ * Format seconds as human duration: 5d 4h, 48h 30m, 2h 15m, 45m
+ */
+function fmtDuration(seconds) {
+  if (seconds <= 0) return '0m';
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor((seconds % 86400) / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  if (d > 0) return `${d}d ${h}h`;
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+
+/**
+ * Color-coded task status.
+ */
+function fmtStatus(status) {
+  const map = {
+    Open:      chalk.green('● Open'),
+    Claimed:   chalk.yellow('● Claimed'),
+    Submitted: chalk.blue('● Submitted'),
+    Completed: chalk.green('● Completed'),
+    Disputed:  chalk.red('● Disputed'),
+    Cancelled: chalk.dim('● Cancelled'),
+  };
+  return map[status] || status;
+}
+
+/**
+ * Color-coded category.
+ */
+function fmtCategory(cat) {
+  return chalk.magenta(cat || '—');
+}
+
+/**
+ * Format a description for table display (truncate).
+ */
+function fmtDesc(desc, maxLen = 38) {
+  if (!desc) return '—';
+  const oneLine = desc.replace(/\n/g, ' ').trim();
+  if (oneLine.length <= maxLen) return oneLine;
+  return oneLine.slice(0, maxLen - 1) + '…';
+}
+
+/**
+ * Format a brief task object for status command.
+ */
+function formatTaskBrief(t) {
+  return {
+    chainTaskId: t.chain_task_id,
+    description: t.description ? t.description.slice(0, 200) : null,
+    category: t.category,
+    bounty: t.bounty_amount,
+    status: t.status,
+    deadline: t.deadline,
+    deadlineHuman: t.deadline ? new Date(t.deadline * 1000).toISOString() : null,
+  };
+}
+
+/**
+ * Text extension set for file type detection.
+ */
+const TEXT_EXTENSIONS = new Set([
+  '.md', '.txt', '.json', '.js', '.ts', '.jsx', '.tsx', '.py', '.rb',
+  '.html', '.css', '.csv', '.xml', '.yaml', '.yml', '.toml', '.sh',
+  '.sol', '.rs', '.go', '.java', '.c', '.cpp', '.h', '.hpp', '.sql',
+  '.env', '.gitignore', '.dockerfile', '.makefile', '.cfg', '.ini',
+]);
+
+function isTextFile(filePath) {
+  const path = require('path');
+  const ext = path.extname(filePath).toLowerCase();
+  return TEXT_EXTENSIONS.has(ext) || ext === '';
+}
+
+module.exports = {
+  truncAddr,
+  truncTx,
+  fmtBounty,
+  fmtBountyColored,
+  fmtAxobotl,
+  fmtDeadline,
+  fmtDuration,
+  fmtStatus,
+  fmtCategory,
+  fmtDesc,
+  formatTaskBrief,
+  isTextFile,
+  TEXT_EXTENSIONS,
+};

package/src/http.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Fetch wrapper with timeout + consistent error messages.
+ * Drop-in replacement for global fetch() across the CLI.
+ */
+
+const DEFAULT_TIMEOUT_MS = 15000; // 15s for API calls
+const PRICE_TIMEOUT_MS   = 10000; // 10s for price lookups
+
+/**
+ * Fetch with AbortController timeout.
+ * @param {string} url
+ * @param {object} [opts] — standard fetch options
+ * @param {number} [opts.timeoutMs] — override timeout (ms)
+ * @returns {Promise<Response>}
+ */
+async function fetchWithTimeout(url, opts = {}) {
+  const { timeoutMs, ...fetchOpts } = opts;
+  const ms = timeoutMs || DEFAULT_TIMEOUT_MS;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), ms);
+
+  try {
+    const resp = await fetch(url, { ...fetchOpts, signal: controller.signal });
+    return resp;
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      throw new Error(`Request timed out after ${Math.round(ms / 1000)}s: ${url}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+module.exports = { fetchWithTimeout, DEFAULT_TIMEOUT_MS, PRICE_TIMEOUT_MS };

package/src/index.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const { setMode } = require('./output');
+const pkg = require('../package.json');
+
+const program = new Command();
+
+program
+  .name('0xwork')
+  .description(chalk.bold('0xWork CLI') + ' — AI agents earn money on the 0xWork protocol')
+  .version(pkg.version, '-v, --version')
+  .option('--json', 'Output raw JSON (for AI agents and scripting)')
+  .option('--quiet', 'Minimal output (success/fail + tx hash)')
+  .option('--no-color', 'Disable colored output')
+  .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.json) setMode('json');
+    else if (opts.quiet) setMode('quiet');
+    if (opts.color === false) {
+      // chalk v4 respects FORCE_COLOR=0
+      process.env.FORCE_COLOR = '0';
+    }
+  });
+
+// ─── Setup ──────────────────────────────────────────────────────────
+require('./commands/init').register(program);
+require('./commands/register').register(program);
+
+// ─── Worker Flow ────────────────────────────────────────────────────
+require('./commands/discover').register(program);
+require('./commands/task').register(program);
+require('./commands/claim').register(program);
+require('./commands/submit').register(program);
+require('./commands/abandon').register(program);
+
+// ─── Poster Flow ────────────────────────────────────────────────────
+require('./commands/post').register(program);
+require('./commands/approve').register(program);
+require('./commands/reject').register(program);
+require('./commands/revision').register(program);
+require('./commands/cancel').register(program);
+require('./commands/extend').register(program);
+
+// ─── V3 Fairness (anyone can trigger) ──────────────────────────────
+require('./commands/claim-approval').register(program);
+require('./commands/auto-resolve').register(program);
+require('./commands/mutual-cancel').register(program);
+require('./commands/retract-cancel').register(program);
+require('./commands/reclaim').register(program);
+
+// ─── Info ───────────────────────────────────────────────────────────
+require('./commands/status').register(program);
+require('./commands/balance').register(program);
+require('./commands/profile').register(program);
+require('./commands/faucet').register(program);
+
+// ─── Custom help ────────────────────────────────────────────────────
+program.addHelpText('after', `
+${chalk.dim('Examples:')}
+  ${chalk.dim('$')} 0xwork init                                    ${chalk.dim('# Generate wallet')}
+  ${chalk.dim('$')} 0xwork register --name="Bot" --description="…" ${chalk.dim('# Register on-chain')}
+  ${chalk.dim('$')} 0xwork discover --capabilities=Writing         ${chalk.dim('# Find matching tasks')}
+  ${chalk.dim('$')} 0xwork claim 45                                ${chalk.dim('# Claim a task')}
+  ${chalk.dim('$')} 0xwork submit 45 --proof="https://…"           ${chalk.dim('# Submit deliverables')}
+  ${chalk.dim('$')} 0xwork balance                                 ${chalk.dim('# Check balances')}
+  ${chalk.dim('$')} 0xwork discover --json                         ${chalk.dim('# JSON output for agents')}
+
+${chalk.dim('Environment:')}
+  ${chalk.dim('PRIVATE_KEY')}       Wallet private key (enables on-chain operations)
+  ${chalk.dim('WALLET_ADDRESS')}    Read-only address (for status/balance without key)
+  ${chalk.dim('API_URL')}           0xWork API (default: https://api.0xwork.org)
+  ${chalk.dim('RPC_URL')}           Base RPC (default: https://mainnet.base.org)
+
+${chalk.dim('Without PRIVATE_KEY, runs in dry-run mode (read-only).')}
+${chalk.dim('Reads .env from current directory automatically.')}
+
+${chalk.dim('Docs:')} https://0xwork.org  ${chalk.dim('|')}  ${chalk.dim('GitHub:')} https://github.com/JKILLR/0xwork
+`);
+
+module.exports = program;

package/src/output.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const chalk = require('chalk');
+
+let _mode = 'human'; // 'human' | 'json' | 'quiet'
+
+function setMode(mode) {
+  _mode = mode;
+}
+
+function getMode() {
+  return _mode;
+}
+
+function isHuman() { return _mode === 'human'; }
+function isJson()  { return _mode === 'json'; }
+function isQuiet() { return _mode === 'quiet'; }
+
+/**
+ * Output success.
+ * @param {Object} data — JSON-serializable data (always used for --json)
+ * @param {Function} [humanFn] — Called in human mode with (data). Print formatted output.
+ */
+function success(data, humanFn) {
+  if (_mode === 'json') {
+    process.stdout.write(JSON.stringify({ ok: true, ...data }) + '\n');
+    process.exit(0);
+  }
+  if (_mode === 'quiet') {
+    const msg = data.txHash || data.message || 'OK';
+    console.log(msg);
+    process.exit(0);
+  }
+  // Human mode
+  if (humanFn) {
+    humanFn(data);
+  }
+  process.exit(0);
+}
+
+/**
+ * Output failure and exit with code 1.
+ */
+function fail(error, extra = {}) {
+  if (_mode === 'json') {
+    process.stdout.write(JSON.stringify({ ok: false, error: String(error), ...extra }) + '\n');
+    process.exit(1);
+  }
+  if (_mode === 'quiet') {
+    console.error(String(error));
+    process.exit(1);
+  }
+  console.error('');
+  console.error(chalk.red(`  ✖ ${error}`));
+  if (extra.suggestion) {
+    console.error(chalk.dim(`    ${extra.suggestion}`));
+  }
+  console.error('');
+  process.exit(1);
+}
+
+/**
+ * Print a styled header line.
+ */
+function header(emoji, text, right) {
+  if (_mode !== 'human') return;
+  let line = `  ${emoji} ${chalk.bold(text)}`;
+  if (right) {
+    line += chalk.dim(`  ${right}`);
+  }
+  console.log('');
+  console.log(line);
+  console.log('');
+}
+
+/**
+ * Print a key-value pair with consistent alignment.
+ */
+function keyValue(key, value, indent = 4) {
+  if (_mode !== 'human') return;
+  const pad = ' '.repeat(indent);
+  const label = chalk.dim(`${key}:`.padEnd(16));
+  console.log(`${pad}${label}${value}`);
+}
+
+/**
+ * Print a blank line (human mode only).
+ */
+function blank() {
+  if (_mode === 'human') console.log('');
+}
+
+/**
+ * Print dim helper text. Text is automatically dimmed —
+ * callers can pass chalk-styled text for partial emphasis within the dim line.
+ */
+function hint(text, indent = 4) {
+  if (_mode !== 'human') return;
+  const pad = ' '.repeat(indent);
+  console.log(`${pad}${chalk.dim(text)}`);
+}
+
+/**
+ * Print a warning line. Unlike hint(), NOT dimmed — warnings stay visible.
+ */
+function warn(text, indent = 4) {
+  if (_mode !== 'human') return;
+  const pad = ' '.repeat(indent);
+  console.log(`${pad}${text}`);
+}
+
+/**
+ * Print a section divider.
+ */
+function divider(width = 40, indent = 4) {
+  if (_mode !== 'human') return;
+  const pad = ' '.repeat(indent);
+  console.log(chalk.dim(`${pad}${'─'.repeat(width)}`));
+}
+
+/**
+ * Box drawing for detail views.
+ */
+function box(title, lines, width = 60) {
+  if (_mode !== 'human') return;
+  const top    = `  ╔${'═'.repeat(width)}╗`;
+  const sep    = `  ╠${'═'.repeat(width)}╣`;
+  const bottom = `  ╚${'═'.repeat(width)}╝`;
+
+  // Pad title by visible length, not raw string length (ANSI-safe)
+  const titleText = `  ${title}`;
+  const titleVisible = stripAnsi(titleText);
+  const titlePad = Math.max(0, width - titleVisible.length);
+
+  console.log('');
+  console.log(chalk.cyan(top));
+  console.log(chalk.cyan('  ║') + chalk.bold(titleText) + ' '.repeat(titlePad) + chalk.cyan('║'));
+  console.log(chalk.cyan(sep));
+  for (const line of lines) {
+    const visible = stripAnsi(line);
+    const padding = Math.max(0, width - visible.length - 2);
+    console.log(chalk.cyan('  ║') + `  ${line}${' '.repeat(padding)}` + chalk.cyan('║'));
+  }
+  console.log(chalk.cyan(bottom));
+  console.log('');
+}
+
+/**
+ * Standard table character set. Import and spread into cli-table3 options.
+ */
+const TABLE_CHARS = {
+  'top': '─', 'top-mid': '┬', 'top-left': '┌', 'top-right': '┐',
+  'bottom': '─', 'bottom-mid': '┴', 'bottom-left': '└', 'bottom-right': '┘',
+  'left': '│', 'left-mid': '├', 'mid': '─', 'mid-mid': '┼',
+  'right': '│', 'right-mid': '┤', 'middle': '│',
+};
+
+/**
+ * Strip ANSI escape codes for length calculation.
+ */
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+module.exports = {
+  setMode,
+  getMode,
+  isHuman,
+  isJson,
+  isQuiet,
+  success,
+  fail,
+  header,
+  keyValue,
+  blank,
+  hint,
+  divider,
+  box,
+  warn,
+  stripAnsi,
+  TABLE_CHARS,
+};

package/src/price.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { fetchWithTimeout, PRICE_TIMEOUT_MS } = require('./http');
+
+let _cachedPrice = null;
+let _priceTs = 0;
+const PRICE_TTL_MS = 5 * 60 * 1000; // 5 min cache
+
+const AXOBOTL_ADDRESS = '0x12cfb53c685Ee7e3F8234d60f20478A1739Ecba3';
+
+/**
+ * Fetch $AXOBOTL price in USD from DEXScreener (cached 5 min).
+ */
+async function getAxobotlPrice() {
+  if (_cachedPrice && Date.now() - _priceTs < PRICE_TTL_MS) return _cachedPrice;
+  try {
+    const resp = await fetchWithTimeout(`https://api.dexscreener.com/latest/dex/tokens/${AXOBOTL_ADDRESS}`, { timeoutMs: PRICE_TIMEOUT_MS });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const pair = data.pairs && data.pairs[0];
+    if (pair && pair.priceUsd) {
+      _cachedPrice = parseFloat(pair.priceUsd);
+      _priceTs = Date.now();
+      return _cachedPrice;
+    }
+  } catch { /* best effort */ }
+  return null;
+}
+
+/**
+ * Format an $AXOBOTL amount as USD string.
+ */
+function formatAxobotlUsd(amount, price) {
+  if (!price || amount == null) return null;
+  const num = typeof amount === 'string' ? parseFloat(amount) : amount;
+  if (isNaN(num)) return null;
+  const usd = num * price;
+  return usd < 0.01 ? '<$0.01' : `$${usd.toFixed(2)}`;
+}
+
+module.exports = { getAxobotlPrice, formatAxobotlUsd };

package/src/resolve.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const config = require('./config');
+const { fetchWithTimeout } = require('./http');
+
+/**
+ * Resolve a task by chain_task_id.
+ * Tries direct API lookup first, then falls back to scanning all tasks.
+ * This handles the case where DB id != chain_task_id.
+ */
+async function resolveTask(taskId) {
+  const url = config.API_URL;
+
+  // Try direct lookup first
+  let resp = await fetchWithTimeout(`${url}/tasks/${taskId}`);
+  if (resp.ok) {
+    const data = await resp.json();
+    const t = data.task || data;
+    if (t && t.id && String(t.chain_task_id) === String(taskId)) return t;
+  }
+
+  // Fallback: scan all tasks to find by chain_task_id
+  resp = await fetchWithTimeout(`${url}/tasks?status=all&limit=200`);
+  if (!resp.ok) throw new Error(`API error: ${resp.status} ${resp.statusText}`);
+  const data = await resp.json();
+  const tasks = data.tasks || data;
+  const t = tasks.find(task => String(task.chain_task_id) === String(taskId));
+  if (!t) throw new Error(`Task #${taskId} not found (checked both DB id and chain_task_id)`);
+  return t;
+}
+
+module.exports = { resolveTask };

package/src/safety.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const REJECT_KEYWORDS = [
+  'personal information', 'doxx', 'hack', 'exploit', 'steal',
+  'impersonate', 'pretend to be', 'fake identity', 'scam',
+  'password', 'private key', 'seed phrase', 'credentials',
+  'illegal', 'nsfw', 'adult content', 'violence',
+  'real-world', 'physical', 'in person', 'meet me',
+];
+
+/**
+ * Check task description for safety flags.
+ * Returns array of matched keywords (empty = safe).
+ */
+function checkSafety(description) {
+  if (!description) return [];
+  const desc = description.toLowerCase();
+  return REJECT_KEYWORDS.filter(kw => desc.includes(kw));
+}
+
+module.exports = { checkSafety, REJECT_KEYWORDS };