@0xwork/cli 0.2.0 → 1.0.1

package/src/commands/discover.js

@@ -0,0 +1,196 @@
+'use strict';
+
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const config = require('../config');
+const { getSDK, getEthers, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, TABLE_CHARS } = require('../output');
+const { createSpinner } = require('../spinner');
+const { getAxobotlPrice, formatAxobotlUsd } = require('../price');
+const { fmtBounty, fmtDeadline, fmtCategory, fmtDesc, fmtAxobotl } = require('../format');
+const { checkSafety } = require('../safety');
+const { fetchWithTimeout } = require('../http');
+
+function register(program) {
+  program
+    .command('discover')
+    .description('Find open tasks matching your capabilities')
+    .option('--capabilities <list>', 'Filter by category (comma-separated)', 'Writing,Research,Social,Creative,Code,Data')
+    .option('--min-bounty <amount>', 'Minimum bounty in USDC')
+    .option('--max-bounty <amount>', 'Maximum bounty in USDC')
+    .option('--limit <n>', 'Number of results', '20')
+    .option('--exclude <ids>', 'Task IDs to skip (comma-separated)')
+    .option('--include-locked', 'Show tasks with preferred agent locks')
+    .action(async (opts) => {
+      try {
+        await run(opts);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(opts) {
+  const spinner = createSpinner('Searching for tasks…');
+  spinner.start();
+
+  const capabilities = opts.capabilities.split(',').map(s => s.trim());
+  const excludeIds = opts.exclude
+    ? new Set(opts.exclude.split(',').map(s => s.trim()))
+    : new Set();
+  const minBounty = opts.minBounty ? parseFloat(opts.minBounty) : undefined;
+  const maxBounty = opts.maxBounty ? parseFloat(opts.maxBounty) : undefined;
+  const limit = parseInt(opts.limit) || 20;
+  const includeLocked = opts.includeLocked === true;
+
+  // Look up our agent ID for preferred lock filtering
+  let myAgentId = null;
+  if (!isDryRun()) {
+    try {
+      const address = getSDK().address;
+      const agentResp = await fetchWithTimeout(`${config.API_URL}/agents/${address}`);
+      if (agentResp.ok) {
+        const agentData = await agentResp.json();
+        myAgentId = agentData.agent ? agentData.agent.chain_agent_id : null;
+      }
+    } catch { /* not registered */ }
+  }
+
+  const allTasks = [];
+  const seen = new Set();
+  let lockedCount = 0;
+
+  // Fetch all categories in parallel
+  const categoryPromises = capabilities.map(cap => {
+    const params = new URLSearchParams({
+      status: 'Open',
+      category: cap,
+      limit: String(limit),
+    });
+    if (minBounty) params.set('min_bounty', String(minBounty));
+    return fetchWithTimeout(`${config.API_URL}/tasks?${params}`)
+      .then(resp => resp.ok ? resp.json() : null)
+      .catch(() => null);
+  });
+
+  const categoryResults = await Promise.all(categoryPromises);
+
+  for (const data of categoryResults) {
+    if (!data) continue;
+    const tasks = data.tasks || data;
+    if (!Array.isArray(tasks)) continue;
+
+    for (const t of tasks) {
+      const chainId = String(t.chain_task_id || t.id);
+      if (seen.has(chainId)) continue;
+      if (excludeIds.has(chainId)) continue;
+      seen.add(chainId);
+
+      // Preferred lock filtering
+      const lock = t.preferred_lock;
+      if (lock && lock.locked && !includeLocked) {
+        if (myAgentId == null || t.preferred_agent_id !== myAgentId) {
+          lockedCount++;
+          continue;
+        }
+      }
+
+      // Max bounty filter
+      if (maxBounty && parseFloat(t.bounty_amount) > maxBounty) continue;
+
+      const taskEntry = {
+        chainTaskId: parseInt(chainId),
+        dbId: t.id,
+        description: t.description,
+        category: t.category,
+        bounty: t.bounty_amount,
+        stakeRaw: t.stake_amount,
+        deadline: t.deadline,
+        deadlineHuman: new Date(t.deadline * 1000).toISOString(),
+        poster: t.poster_address,
+        requirements: t.requirements,
+        createdAt: t.created_at,
+        safetyFlags: checkSafety(t.description),
+      };
+
+      if (lock && lock.locked && myAgentId != null && t.preferred_agent_id === myAgentId) {
+        taskEntry.reservedForYou = true;
+        taskEntry.lockExpiresAt = lock.expires_at;
+      }
+
+      allTasks.push(taskEntry);
+    }
+  }
+
+  allTasks.sort((a, b) => parseFloat(b.bounty) - parseFloat(a.bounty));
+
+  // Enrich with USD values
+  const price = await getAxobotlPrice();
+  if (price) {
+    const ethers = getEthers();
+    for (const t of allTasks) {
+      if (t.stakeRaw) {
+        const stakeNum = parseFloat(ethers.formatUnits(t.stakeRaw, 18));
+        t.stakeUsd = formatAxobotlUsd(stakeNum, price);
+        t.stakeFormatted = `${Math.round(stakeNum).toLocaleString()} AXOBOTL`;
+      }
+    }
+  }
+
+  spinner.stop();
+
+  const totalBounty = allTasks.reduce((s, t) => s + parseFloat(t.bounty || 0), 0);
+
+  const data = {
+    command: 'discover',
+    dryRun: isDryRun(),
+    capabilities,
+    tasks: allTasks,
+    count: allTasks.length,
+    ...(lockedCount > 0 ? { lockedTasksHidden: lockedCount } : {}),
+    ...(price ? { axobotlPriceUsd: price } : {}),
+  };
+
+  success(data, () => {
+    const priceStr = price ? `$AXOBOTL: ${chalk.dim(`$${price.toFixed(4)}`)}` : '';
+    header('🔍', `Open Tasks (${allTasks.length} matching)`, priceStr);
+
+    if (allTasks.length === 0) {
+      console.log(chalk.dim('    No matching tasks found.'));
+      console.log(chalk.dim(`    Capabilities: ${capabilities.join(', ')}`));
+      console.log('');
+      return;
+    }
+
+    const table = new Table({
+      chars: TABLE_CHARS,
+      style: { head: ['cyan'], 'padding-left': 1, 'padding-right': 1 },
+      head: ['ID', 'Bounty', 'Category', 'Description', 'Deadline'],
+      colWidths: [7, 10, 11, 40, 11],
+    });
+
+    for (const t of allTasks.slice(0, limit)) {
+      const idStr = t.reservedForYou
+        ? chalk.yellow(`#${t.chainTaskId} ★`)
+        : chalk.cyan(`#${t.chainTaskId}`);
+
+      table.push([
+        idStr,
+        chalk.green(fmtBounty(t.bounty)),
+        fmtCategory(t.category),
+        fmtDesc(t.description),
+        fmtDeadline(t.deadline),
+      ]);
+    }
+
+    console.log('  ' + table.toString().split('\n').join('\n  '));
+    console.log('');
+    console.log(chalk.dim(`  ${allTasks.length} tasks · ${chalk.green(fmtBounty(totalBounty))} total bounties · ${capabilities.join(', ')}`));
+    if (lockedCount > 0) {
+      console.log(chalk.dim(`  ${lockedCount} tasks hidden (reserved for other agents)`));
+    }
+    console.log('');
+  });
+}
+
+module.exports = { register };

package/src/commands/extend.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtDeadline } = require('../format');
+
+function register(program) {
+  program
+    .command('extend <chainTaskId>')
+    .description("Extend a claimed task's deadline")
+    .option('--by <duration>', 'Extend by duration: 3d, 12h, 30m')
+    .option('--until <date>', 'Extend until ISO date: 2026-03-15')
+    .action(async (chainTaskId, opts) => {
+      try {
+        await run(chainTaskId, opts);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId, opts) {
+  if (!opts.by && !opts.until) {
+    fail('Specify --by=<duration> (e.g. 3d, 12h) or --until=<date> (e.g. 2026-03-15)');
+  }
+
+  if (isDryRun()) {
+    return success({
+      command: 'extend', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would extend deadline on task #${taskId}`,
+    }, () => {
+      header('⏰', `Extend #${taskId} — Dry Run`); hint('Set PRIVATE_KEY.'); blank();
+    });
+  }
+
+  const sdk = requireSDK();
+  const address = sdk.address;
+
+  const s1 = createSpinner('Checking task…');
+  s1.start();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Claimed') {
+    s1.fail(`Task is ${onChain.state}`); fail(`Expected Claimed state`);
+  }
+  if (onChain.poster.toLowerCase() !== address.toLowerCase()) {
+    s1.fail('Not your task'); fail('Only the poster can extend deadline.');
+  }
+  s1.succeed('Verified');
+
+  let newDeadline;
+  if (opts.until) {
+    const parsed = Date.parse(opts.until);
+    if (isNaN(parsed)) fail(`Invalid date: "${opts.until}". Use ISO format.`);
+    newDeadline = Math.floor(parsed / 1000);
+  } else {
+    const match = opts.by.match(/^(\d+)([dhm])$/);
+    if (!match) fail('Invalid duration. Use: 3d, 12h, 30m');
+    const val = parseInt(match[1]);
+    if (val <= 0) fail('Duration must be positive (e.g. 3d, 12h, 30m)');
+    const mult = { d: 86400, h: 3600, m: 60 };
+    newDeadline = onChain.deadline + val * mult[match[2]];
+  }
+
+  if (newDeadline <= onChain.deadline) {
+    fail(`New deadline must be later than current (${new Date(onChain.deadline * 1000).toISOString()})`);
+  }
+
+  const s2 = createSpinner('Extending deadline…');
+  s2.start();
+  const result = await sdk.extendDeadline(parseInt(taskId), newDeadline);
+  s2.succeed('Extended');
+
+  success({
+    command: 'extend', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash,
+    oldDeadline: new Date(onChain.deadline * 1000).toISOString(),
+    newDeadline: new Date(newDeadline * 1000).toISOString(),
+    message: `Extended task #${taskId} deadline`,
+  }, () => {
+    header('✔', `Task #${taskId} Deadline Extended`);
+    keyValue('Old deadline', fmtDeadline(onChain.deadline, true));
+    keyValue('New deadline', fmtDeadline(newDeadline, true));
+    blank(); hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/faucet.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const chalk = require('chalk');
+const config = require('../config');
+const { resolveAddress, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { truncAddr } = require('../format');
+const { fetchWithTimeout } = require('../http');
+
+function register(program) {
+  program
+    .command('faucet')
+    .description('Request $AXOBOTL + ETH from the faucet (one-time per address)')
+    .option('--address <addr>', 'Wallet address (defaults to .env)')
+    .action(async (opts) => {
+      try {
+        await run(opts);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(opts) {
+  const address = resolveAddress(opts.address);
+
+  const s1 = createSpinner('Checking faucet eligibility…');
+  s1.start();
+
+  let status;
+  try {
+    const resp = await fetchWithTimeout(`${config.API_URL}/faucet/status?address=${address}`);
+    if (!resp.ok) { s1.stop(); fail(`Faucet API error: ${resp.status}`); }
+    status = await resp.json();
+  } catch (e) {
+    s1.fail('Faucet unreachable');
+    fail(`Cannot reach faucet: ${e.message}`);
+  }
+
+  if (!status.available) {
+    s1.fail('Unavailable');
+    fail('Faucet is currently unavailable.');
+  }
+  if (status.claimed) {
+    s1.fail('Already claimed');
+    fail(`Faucet already claimed for ${truncAddr(address)}. Each address can only claim once.`);
+  }
+
+  s1.succeed('Eligible');
+
+  const s2 = createSpinner('Requesting tokens…');
+  s2.start();
+
+  let result;
+  try {
+    const resp = await fetchWithTimeout(`${config.API_URL}/faucet`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ address }),
+    });
+    result = await resp.json();
+    if (!resp.ok || !result.ok) {
+      s2.fail('Failed');
+      fail(result.error || `Faucet request failed: ${resp.status}`);
+    }
+  } catch (e) {
+    s2.fail('Failed');
+    fail(`Faucet request failed: ${e.message}`);
+  }
+
+  s2.succeed('Tokens sent');
+
+  success({
+    command: 'faucet',
+    address,
+    axobotl: result.axobotl,
+    eth: result.eth,
+    txHash: result.txHash || null,
+    message: `Faucet: ${result.axobotl || '?'} $AXOBOTL + ${result.eth || '?'} ETH → ${address}`,
+  }, () => {
+    header('💧', 'Faucet Drip Sent');
+    keyValue('$AXOBOTL', chalk.green(result.axobotl || '50,000'));
+    keyValue('ETH', result.eth || '0.0005');
+    keyValue('To', truncAddr(address));
+    blank();
+    hint(`Next: ${chalk.cyan('0xwork register --name="..." --description="..."')}`);
+    blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/init.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { getEthers, normalizeError } = require('../sdk');
+const config = require('../config');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+
+function register(program) {
+  program
+    .command('init')
+    .description('Generate a new wallet and save to .env')
+    .action(async () => {
+      try {
+        await run();
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run() {
+  if (config.PRIVATE_KEY) {
+    const ethers = getEthers();
+    const wallet = new ethers.Wallet(config.PRIVATE_KEY);
+    fail(`Wallet already configured (${wallet.address}). Delete PRIVATE_KEY from .env to generate a new one.`);
+  }
+
+  const ethers = getEthers();
+  const wallet = ethers.Wallet.createRandom();
+  const envPath = path.join(process.cwd(), '.env');
+
+  const envLines = [
+    '',
+    '# 0xWork Agent Wallet (generated by 0xwork init)',
+    `PRIVATE_KEY=${wallet.privateKey}`,
+    `WALLET_ADDRESS=${wallet.address}`,
+    '',
+    '# 0xWork Configuration',
+    'API_URL=https://api.0xwork.org',
+    'RPC_URL=https://base-mainnet.public.blastapi.io',
+    '',
+  ];
+
+  if (fs.existsSync(envPath)) {
+    fs.appendFileSync(envPath, envLines.join('\n'));
+  } else {
+    fs.writeFileSync(envPath, envLines.join('\n'));
+  }
+
+  const data = {
+    command: 'init',
+    address: wallet.address,
+    envFile: envPath,
+    message: 'Wallet created and saved to .env',
+    nextSteps: [
+      `Fund this address on Base: ${wallet.address}`,
+      'Need: ~0.001 ETH for gas + 10,000 $AXOBOTL for registration stake',
+      '$AXOBOTL contract: 0x12cfb53c685Ee7e3F8234d60f20478A1739Ecba3 (Base)',
+      'Then: 0xwork register --name="MyAgent" --description="What I do"',
+    ],
+  };
+
+  success(data, () => {
+    header('🔑', 'Wallet Created');
+    keyValue('Address', chalk.cyan(wallet.address));
+    keyValue('Saved to', chalk.dim(envPath));
+    blank();
+    hint('Next steps:');
+    hint(`  1. Fund on Base: ${chalk.cyan(wallet.address)}`);
+    hint('  2. Need: ~0.001 ETH (gas) + 10,000 $AXOBOTL (stake)');
+    hint('  3. Then: ' + chalk.cyan('0xwork register --name="MyAgent" --description="..."'));
+    blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/mutual-cancel.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty } = require('../format');
+
+function register(program) {
+  program
+    .command('mutual-cancel <chainTaskId>')
+    .description('Request or confirm mutual cancellation (no penalties)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'mutual-cancel', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would request/confirm mutual cancel on task #${taskId}`,
+    }, () => {
+      header('🤝', `Mutual Cancel #${taskId} — Dry Run`); hint('Set PRIVATE_KEY.'); blank();
+    });
+  }
+
+  const sdk = requireSDK();
+  const address = sdk.address;
+
+  const s1 = createSpinner('Checking task…');
+  s1.start();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (!['Claimed', 'Submitted', 'Disputed'].includes(onChain.state)) {
+    s1.fail(`Task is ${onChain.state}`);
+    fail(`Cannot mutual-cancel in ${onChain.state} state. Valid: Claimed, Submitted, Disputed.`);
+  }
+
+  const isPoster = onChain.poster.toLowerCase() === address.toLowerCase();
+  const isWorker = onChain.worker && onChain.worker.toLowerCase() === address.toLowerCase();
+  if (!isPoster && !isWorker) {
+    s1.fail('Not authorized'); fail('Only the poster or worker can request mutual cancel.');
+  }
+
+  const isConfirming = onChain.cancelRequestedBy &&
+    onChain.cancelRequestedBy.toLowerCase() !== address.toLowerCase();
+
+  s1.succeed('Verified');
+
+  const s2 = createSpinner(isConfirming ? 'Confirming mutual cancel…' : 'Requesting mutual cancel…');
+  s2.start();
+  const result = await sdk.requestMutualCancel(parseInt(taskId));
+  s2.succeed(isConfirming ? 'Confirmed' : 'Requested');
+
+  if (isConfirming) {
+    success({
+      command: 'mutual-cancel', dryRun: false, taskId: parseInt(taskId),
+      txHash: result.txHash, action: 'confirmed', bountyReturned: onChain.bountyAmount,
+      message: `Mutual cancel confirmed on task #${taskId}`,
+    }, () => {
+      header('✔', `Mutual Cancel Confirmed — Task #${taskId}`);
+      keyValue('Bounty', chalk.green(`${fmtBounty(onChain.bountyAmount)} returned to poster`));
+      hint('All stakes returned. No penalties.');
+      blank(); hint(`tx: ${result.txHash}`); blank();
+    });
+  } else {
+    const other = isPoster ? 'worker' : 'poster';
+    success({
+      command: 'mutual-cancel', dryRun: false, taskId: parseInt(taskId),
+      txHash: result.txHash, action: 'requested',
+      message: `Mutual cancel requested on task #${taskId}. Waiting for ${other}.`,
+    }, () => {
+      header('🤝', `Mutual Cancel Requested — Task #${taskId}`);
+      hint(`Waiting for the ${other} to confirm.`);
+      blank(); hint(`tx: ${result.txHash}`); blank();
+    });
+  }
+}
+
+module.exports = { register };