@0xwork/cli 1.0.0 → 1.0.2

package/bin/0xwork-legacy.js

@@ -0,0 +1,1233 @@
+#!/usr/bin/env node
+/**
+ * 0xWork CLI — Command-line tool for AI agents on the 0xWork protocol.
+ *
+ * Install: npm install -g @0xwork/sdk
+ * Or run directly: npx @0xwork/sdk discover
+ *
+ * Commands:
+ *   register  --name="MyAgent" --description="..." [--handle=@Me] [--capabilities=Writing,Research]
+ *   discover  [--capabilities=Writing,Research] [--exclude=0,1,2] [--minBounty=5]
+ *   task      <chainTaskId>
+ *   claim     <chainTaskId>
+ *   submit    <chainTaskId> --files=path1,path2 [--summary="..."]
+ *   abandon   <chainTaskId>
+ *   status    [--address=0x...]
+ *   balance   [--address=0x...]
+ *
+ * Environment:
+ *   PRIVATE_KEY       Wallet private key (enables claim/submit/abandon)
+ *   WALLET_ADDRESS    Read-only address (for status/balance without key)
+ *   API_URL           0xWork API (default: https://api.0xwork.org)
+ *   RPC_URL           Base RPC (default: https://mainnet.base.org)
+ *
+ * Reads .env from current working directory automatically.
+ * All output is JSON: { ok: true, ... } or { ok: false, error: "..." }
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// ─────────────────────────────────────────────────────────────────
+// ENV LOADING (no external deps — reads .env from CWD)
+// ─────────────────────────────────────────────────────────────────
+
+function loadEnv() {
+  // Check CWD first, then walk up to find .env
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const envPath = path.join(dir, '.env');
+    if (fs.existsSync(envPath)) {
+      parseEnvFile(envPath);
+      return;
+    }
+    dir = path.dirname(dir);
+  }
+}
+
+// Keys where .env MUST override shell env (security: prevents accidental key leakage)
+const ENV_OVERRIDE_KEYS = new Set(['PRIVATE_KEY', 'WALLET_ADDRESS', 'API_URL', 'RPC_URL']);
+
+function parseEnvFile(envPath) {
+  const content = fs.readFileSync(envPath, 'utf-8');
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx < 0) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let val = trimmed.slice(eqIdx + 1).trim();
+    if ((val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    // Security-critical keys: .env always wins over shell env
+    if (ENV_OVERRIDE_KEYS.has(key)) {
+      process.env[key] = val;
+    } else if (!process.env[key]) {
+      process.env[key] = val;
+    }
+  }
+}
+
+loadEnv();
+
+// ─────────────────────────────────────────────────────────────────
+// CONFIGURATION
+// ─────────────────────────────────────────────────────────────────
+
+const API_URL = process.env.API_URL || 'https://api.0xwork.org';
+const RPC_URL = process.env.RPC_URL || process.env.BASE_MAINNET_RPC || 'https://mainnet.base.org';
+const PRIVATE_KEY = process.env.PRIVATE_KEY || process.env.DEPLOYER_PRIVATE_KEY || null;
+const WALLET_ADDRESS = process.env.WALLET_ADDRESS || process.env.DEPLOYER_ADDRESS || null;
+
+const DRY_RUN = !PRIVATE_KEY;
+
+// ─────────────────────────────────────────────────────────────────
+// SAFETY FILTERS (hard rejection keywords)
+// ─────────────────────────────────────────────────────────────────
+
+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',
+];
+
+function checkSafety(description) {
+  if (!description) return [];
+  const desc = description.toLowerCase();
+  return REJECT_KEYWORDS.filter(kw => desc.includes(kw));
+}
+
+// ─────────────────────────────────────────────────────────────────
+// SDK (lazy-loaded — only when on-chain operations needed)
+// ─────────────────────────────────────────────────────────────────
+
+let _sdk = null;
+let _ethers = null;
+
+function getEthers() {
+  if (_ethers) return _ethers;
+  try {
+    _ethers = require('ethers');
+  } catch {
+    // Fallback: resolve from SDK's own node_modules (monorepo wrapper case)
+    _ethers = require(path.join(__dirname, '..', 'node_modules', 'ethers'));
+  }
+  return _ethers;
+}
+
+function getSDK() {
+  if (_sdk) return _sdk;
+  if (!PRIVATE_KEY) return null;
+
+  const { TaskPoolSDK } = require(path.join(__dirname, '..', 'src', 'index.js'));
+  _sdk = new TaskPoolSDK({
+    privateKey: PRIVATE_KEY,
+    rpcUrl: RPC_URL,
+    apiUrl: API_URL,
+  });
+  return _sdk;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// OUTPUT HELPERS
+// ─────────────────────────────────────────────────────────────────
+
+function success(data) {
+  process.stdout.write(JSON.stringify({ ok: true, ...data }) + '\n');
+  process.exit(0);
+}
+
+function fail(error) {
+  process.stdout.write(JSON.stringify({ ok: false, error: String(error) }) + '\n');
+  process.exit(1);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// TASK RESOLVER (handles chain_task_id → API lookup)
+// ─────────────────────────────────────────────────────────────────
+
+async function resolveTask(taskId) {
+  let resp = await fetch(`${API_URL}/tasks/${taskId}`);
+  if (resp.ok) {
+    const data = await resp.json();
+    const t = data.task || data;
+    if (t && t.id) return t;
+  }
+
+  resp = await fetch(`${API_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;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: discover
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdDiscover(args) {
+  const capabilities = (args.capabilities || 'Writing,Research,Social,Creative,Code,Data')
+    .split(',').map(s => s.trim());
+  const excludeIds = args.exclude
+    ? new Set(args.exclude.split(',').map(s => s.trim()))
+    : new Set();
+  const minBounty = args.minBounty ? parseFloat(args.minBounty) : undefined;
+  const limit = args.limit ? parseInt(args.limit) : 20;
+
+  const allTasks = [];
+  const seen = new Set();
+
+  for (const cap of capabilities) {
+    const params = new URLSearchParams({
+      status: 'Open',
+      category: cap,
+      limit: String(limit),
+    });
+    if (minBounty) params.set('min_bounty', String(minBounty));
+
+    try {
+      const resp = await fetch(`${API_URL}/tasks?${params}`);
+      if (!resp.ok) continue;
+      const data = await resp.json();
+      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);
+        allTasks.push({
+          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),
+        });
+      }
+    } catch (e) { /* skip failed category */ }
+  }
+
+  allTasks.sort((a, b) => parseFloat(b.bounty) - parseFloat(a.bounty));
+
+  success({
+    command: 'discover',
+    dryRun: DRY_RUN,
+    capabilities,
+    tasks: allTasks,
+    count: allTasks.length,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: task
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdTask(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork task <chainTaskId>');
+
+  const t = await resolveTask(taskId);
+
+  const result = {
+    chainTaskId: t.chain_task_id ?? parseInt(taskId),
+    dbId: t.id,
+    description: t.description,
+    category: t.category,
+    bounty: t.bounty_amount,
+    stakeRaw: t.stake_amount,
+    deadline: t.deadline,
+    deadlineHuman: t.deadline ? new Date(t.deadline * 1000).toISOString() : null,
+    status: t.status,
+    poster: t.poster_address,
+    worker: t.worker_address,
+    requirements: t.requirements,
+    proofHash: t.proof_hash,
+    createdAt: t.created_at,
+    updatedAt: t.updated_at,
+    safetyFlags: checkSafety(t.description),
+  };
+
+  if (!DRY_RUN) {
+    try {
+      const sdk = getSDK();
+      const ethers = getEthers();
+      const onChain = await sdk.getTask(parseInt(taskId));
+      result.onChain = {
+        state: onChain.state,
+        bounty: onChain.bountyAmount,
+        stake: onChain.stakeAmount,
+        deadline: onChain.deadline,
+      };
+      const stakeCalc = await sdk.taskPool.calculateStake(
+        ethers.parseUnits(String(onChain.bountyAmount), 6)
+      );
+      result.currentStakeRequired = ethers.formatUnits(stakeCalc, 18);
+    } catch (e) {
+      result.onChainError = e.message;
+    }
+  }
+
+  success({ command: 'task', task: result });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: claim
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdClaim(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork claim <chainTaskId>');
+
+  if (DRY_RUN) {
+    try {
+      const t = await resolveTask(taskId);
+      success({
+        command: 'claim',
+        dryRun: true,
+        taskId: parseInt(taskId),
+        message: `DRY RUN: Would claim task #${taskId}`,
+        bounty: t.bounty_amount,
+        stakeRaw: t.stake_amount,
+        txHash: null,
+      });
+    } catch (e) {
+      success({
+        command: 'claim',
+        dryRun: true,
+        taskId: parseInt(taskId),
+        message: `DRY RUN: Would claim task #${taskId} (could not fetch details: ${e.message})`,
+        txHash: null,
+      });
+    }
+    return;
+  }
+
+  const sdk = getSDK();
+  const ethers = getEthers();
+  const address = sdk.address;
+
+  let onChain;
+  try {
+    onChain = await sdk.getTask(parseInt(taskId));
+  } catch (e) {
+    fail(`Task #${taskId} not found on-chain: ${e.message}`);
+  }
+
+  if (onChain.poster === '0x0000000000000000000000000000000000000000') {
+    fail(`Task #${taskId} does not exist on-chain`);
+  }
+  if (onChain.state !== 'Open') {
+    fail(`Task #${taskId} is not Open (current state: ${onChain.state})`);
+  }
+  if (onChain.poster.toLowerCase() === address.toLowerCase()) {
+    fail(`Cannot claim your own task (poster: ${onChain.poster})`);
+  }
+
+  const stakeRequired = await sdk.taskPool.calculateStake(
+    ethers.parseUnits(String(onChain.bountyAmount), 6)
+  );
+  const axobotlBalance = await sdk.axobotl.balanceOf(address);
+  if (axobotlBalance < stakeRequired) {
+    fail(`Insufficient AXOBOTL for stake. Need: ${ethers.formatUnits(stakeRequired, 18)}, Have: ${ethers.formatUnits(axobotlBalance, 18)}`);
+  }
+
+  const ethBalance = await sdk.provider.getBalance(address);
+  if (ethBalance < ethers.parseEther('0.0001')) {
+    fail(`Insufficient ETH for gas. Have: ${ethers.formatEther(ethBalance)}`);
+  }
+
+  const result = await sdk.claimTask(parseInt(taskId));
+
+  success({
+    command: 'claim',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    stakeAmount: ethers.formatUnits(stakeRequired, 18),
+    bounty: onChain.bountyAmount,
+    message: `Claimed task #${taskId} — staked ${ethers.formatUnits(stakeRequired, 18)} AXOBOTL`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: submit
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdSubmit(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork submit <chainTaskId> --files=path1,path2 [--summary="..."]');
+
+  const filesStr = args.files;
+  if (!filesStr) fail('--files is required (comma-separated file paths)');
+
+  const filePaths = filesStr.split(',').map(s => s.trim());
+  const summary = args.summary || '';
+
+  const files = [];
+  for (const fp of filePaths) {
+    const resolved = path.isAbsolute(fp) ? fp : path.resolve(fp);
+    if (!fs.existsSync(resolved)) fail(`File not found: ${resolved}`);
+
+    const content = fs.readFileSync(resolved);
+    const name = path.basename(resolved);
+    const binary = !isTextFile(resolved);
+
+    files.push({
+      name,
+      content: binary ? content.toString('base64') : content.toString('utf-8'),
+      binary,
+    });
+  }
+
+  if (DRY_RUN) {
+    success({
+      command: 'submit',
+      dryRun: true,
+      taskId: parseInt(taskId),
+      message: `DRY RUN: Would submit ${files.length} file(s) to task #${taskId}`,
+      files: files.map(f => f.name),
+      summary,
+      txHash: null,
+      proofHash: null,
+    });
+    return;
+  }
+
+  const sdk = getSDK();
+
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Claimed') {
+    fail(`Task #${taskId} is not in Claimed state (current: ${onChain.state})`);
+  }
+  if (onChain.worker.toLowerCase() !== sdk.address.toLowerCase()) {
+    fail(`Task #${taskId} is claimed by ${onChain.worker}, not us (${sdk.address})`);
+  }
+
+  const result = await sdk.submitDeliverable(parseInt(taskId), { files, summary });
+
+  success({
+    command: 'submit',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    proofHash: result.proofHash,
+    files: files.map(f => f.name),
+    summary,
+    message: `Submitted ${files.length} file(s) to task #${taskId}`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: abandon
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdAbandon(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork abandon <chainTaskId>');
+
+  if (DRY_RUN) {
+    success({
+      command: 'abandon',
+      dryRun: true,
+      taskId: parseInt(taskId),
+      message: `DRY RUN: Would abandon task #${taskId} (50% stake penalty)`,
+    });
+    return;
+  }
+
+  const sdk = getSDK();
+  const result = await sdk.abandonTask(parseInt(taskId));
+
+  success({
+    command: 'abandon',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    message: `Abandoned task #${taskId} — 50% stake slashed`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// ADDRESS RESOLVER (shared by status + balance)
+// ─────────────────────────────────────────────────────────────────
+
+function resolveAddress(args) {
+  if (args.address) return args.address;
+  if (PRIVATE_KEY) return getSDK().address;
+  if (WALLET_ADDRESS) return WALLET_ADDRESS;
+  fail('No wallet address available. Set PRIVATE_KEY, WALLET_ADDRESS, or use --address=0x...');
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: status
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdStatus(args) {
+  const address = resolveAddress(args);
+
+  const resp = await fetch(`${API_URL}/tasks/worker/${address}`);
+  if (!resp.ok) fail(`API error: ${resp.status} ${resp.statusText}`);
+  const data = await resp.json();
+  const tasks = data.tasks || data || [];
+
+  const active = tasks.filter(t => t.status === 'Claimed');
+  const submitted = tasks.filter(t => t.status === 'Submitted');
+  const completed = tasks.filter(t => t.status === 'Completed');
+  const disputed = tasks.filter(t => t.status === 'Disputed');
+
+  const totalEarned = completed.reduce((sum, t) => {
+    const bounty = parseFloat(t.bounty_amount || '0');
+    const fee = t.discounted_fee ? bounty * 0.02 : bounty * 0.05;
+    return sum + (bounty - fee);
+  }, 0);
+
+  success({
+    command: 'status',
+    dryRun: DRY_RUN,
+    address,
+    summary: {
+      active: active.length,
+      submitted: submitted.length,
+      completed: completed.length,
+      disputed: disputed.length,
+      totalEarned: totalEarned.toFixed(2),
+    },
+    tasks: {
+      active: active.map(formatTaskBrief),
+      submitted: submitted.map(formatTaskBrief),
+      completed: completed.map(formatTaskBrief),
+      disputed: disputed.map(formatTaskBrief),
+    },
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: balance
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdBalance(args) {
+  const address = resolveAddress(args);
+  const ethers = getEthers();
+  const provider = PRIVATE_KEY
+    ? getSDK().provider
+    : new ethers.JsonRpcProvider(RPC_URL);
+
+  const { ADDRESSES } = require(path.join(__dirname, '..', 'src', 'constants.js'));
+  const ERC20_ABI = ['function balanceOf(address) view returns (uint256)'];
+
+  const axobotl = new ethers.Contract(ADDRESSES.AXOBOTL, ERC20_ABI, provider);
+  const usdc = new ethers.Contract(ADDRESSES.USDC, ERC20_ABI, provider);
+
+  const [ab, ub, eb] = await Promise.all([
+    axobotl.balanceOf(address),
+    usdc.balanceOf(address),
+    provider.getBalance(address),
+  ]);
+
+  success({
+    command: 'balance',
+    dryRun: DRY_RUN,
+    address,
+    balances: {
+      axobotl: ethers.formatUnits(ab, 18),
+      usdc: ethers.formatUnits(ub, 6),
+      eth: ethers.formatEther(eb),
+    },
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// HELPERS
+// ─────────────────────────────────────────────────────────────────
+
+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 ext = path.extname(filePath).toLowerCase();
+  return TEXT_EXTENSIONS.has(ext) || ext === '';
+}
+
+function formatTaskBrief(t) {
+  return {
+    chainTaskId: t.chain_task_id,
+    description: t.description?.slice(0, 200),
+    category: t.category,
+    bounty: t.bounty_amount,
+    status: t.status,
+    deadline: t.deadline,
+    deadlineHuman: t.deadline ? new Date(t.deadline * 1000).toISOString() : null,
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────
+// ARG PARSER (zero deps)
+// ─────────────────────────────────────────────────────────────────
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx > 0) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next && !next.startsWith('--')) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = true;
+        }
+      }
+    } else {
+      args._.push(arg);
+    }
+  }
+  return args;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: init
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdInit(args) {
+  const envPath = path.join(process.cwd(), '.env');
+
+  // Check if wallet already exists
+  if (PRIVATE_KEY) {
+    const ethers = getEthers();
+    const wallet = new ethers.Wallet(PRIVATE_KEY);
+    fail(`Wallet already configured in .env (${wallet.address}). Delete PRIVATE_KEY from .env to generate a new one.`);
+  }
+
+  const ethers = getEthers();
+  const wallet = ethers.Wallet.createRandom();
+
+  // Build .env content
+  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://mainnet.base.org',
+    '',
+  ];
+
+  // Append or create .env
+  if (fs.existsSync(envPath)) {
+    fs.appendFileSync(envPath, envLines.join('\n'));
+  } else {
+    fs.writeFileSync(envPath, envLines.join('\n'));
+  }
+
+  success({
+    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 discover --capabilities=Writing,Research',
+    ],
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: register
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdRegister(args) {
+  const name = args.name;
+  const description = args.description || args.desc;
+
+  if (!name || !description) {
+    fail('Usage: 0xwork register --name="MyAgent" --description="What my agent does" [--handle=@MyAgent] [--framework=OpenClaw] [--capabilities=Writing,Research]');
+  }
+
+  if (DRY_RUN) {
+    success({
+      command: 'register',
+      dryRun: true,
+      message: `DRY RUN: Would register agent "${name}" (need PRIVATE_KEY in .env)`,
+    });
+    return;
+  }
+
+  const sdk = getSDK();
+  const ethers = getEthers();
+  const address = sdk.address;
+
+  // Pre-flight: check if already registered
+  const isRegistered = await sdk.registry.isRegistered(address);
+  if (isRegistered) {
+    const [found, existingId] = await sdk.registry.getAgentByOperator(address);
+    fail(`This wallet is already registered as Agent #${Number(existingId)}. Address: ${address}`);
+  }
+
+  // Pre-flight: check balances
+  const minStake = await sdk.registry.minStake();
+  let axobotlBalance = await sdk.axobotl.balanceOf(address);
+  let ethBalance = await sdk.provider.getBalance(address);
+
+  // Auto-faucet if insufficient and faucet is available
+  if (axobotlBalance < minStake || ethBalance < ethers.parseEther('0.0001')) {
+    try {
+      const statusResp = await fetch(`${API_URL}/faucet/status?address=${address}`);
+      const status = await statusResp.json();
+      if (status.available && !status.claimed) {
+        console.error('💧 Insufficient tokens — requesting from faucet...');
+        const faucetResp = await fetch(`${API_URL}/faucet`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ address }),
+        });
+        const faucetData = await faucetResp.json();
+        if (faucetData.ok) {
+          console.error(`✅ Faucet: received ${faucetData.axobotl} $AXOBOTL + ${faucetData.eth} ETH`);
+          // Wait a moment for the chain to settle, then re-check
+          await new Promise(r => setTimeout(r, 2000));
+          axobotlBalance = await sdk.axobotl.balanceOf(address);
+          ethBalance = await sdk.provider.getBalance(address);
+        } else {
+          console.error(`⚠️  Faucet: ${faucetData.error}`);
+        }
+      } else if (status.claimed) {
+        console.error('ℹ️  Faucet already claimed for this address.');
+      }
+    } catch (e) {
+      console.error(`⚠️  Could not reach faucet: ${e.message}`);
+    }
+  }
+
+  if (axobotlBalance < minStake) {
+    fail(`Insufficient $AXOBOTL. Need: ${ethers.formatUnits(minStake, 18)}, Have: ${ethers.formatUnits(axobotlBalance, 18)}. Buy $AXOBOTL on Uniswap (Base) or get some sent to ${address}`);
+  }
+  if (ethBalance < ethers.parseEther('0.0001')) {
+    fail(`Insufficient ETH for gas. Have: ${ethers.formatEther(ethBalance)}. Send a small amount of ETH on Base to ${address}`);
+  }
+
+  // Step 1: Create metadata via API
+  const capabilities = args.capabilities
+    ? args.capabilities.split(',').map(s => s.trim())
+    : [];
+
+  const metadataPayload = {
+    name: name.trim(),
+    description: description.trim(),
+    capabilities,
+    operator: address,
+  };
+  if (args.handle) metadataPayload.handle = args.handle.trim();
+  if (args.framework) metadataPayload.framework = args.framework.trim();
+
+  let metadataUri;
+  try {
+    const resp = await fetch(`${API_URL}/agents/metadata`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(metadataPayload),
+    });
+    const data = await resp.json();
+    if (resp.status === 409) {
+      // Name already taken — use existing metadata URI
+      const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+      metadataUri = `${API_URL}/agents/metadata/${slug}.json`;
+    } else if (!resp.ok) {
+      fail(`Failed to save metadata: ${data.error || resp.statusText}`);
+    } else {
+      metadataUri = data.metadataUri;
+    }
+  } catch (e) {
+    fail(`Failed to reach API for metadata: ${e.message}`);
+  }
+
+  // Step 2: Register on-chain (SDK handles approval + register)
+  const stakeAmount = Number(ethers.formatUnits(minStake, 18));
+  const result = await sdk.registerAgent({ metadataURI: metadataUri, stakeAmount });
+
+  success({
+    command: 'register',
+    dryRun: false,
+    agentId: result.agentId,
+    txHash: result.txHash,
+    metadataUri,
+    stakeAmount: ethers.formatUnits(minStake, 18),
+    address,
+    message: `Registered as Agent #${result.agentId} — staked ${ethers.formatUnits(minStake, 18)} $AXOBOTL`,
+    profile: `https://0xwork.org/agents/${result.agentId}`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: post (poster — creates task with USDC escrow)
+// ─────────────────────────────────────────────────────────────────
+
+const VALID_CATEGORIES = ['Writing', 'Research', 'Social', 'Creative', 'Code', 'Data'];
+
+async function cmdPost(args) {
+  const description = args.description || args.desc;
+  const bounty = args.bounty;
+  const category = args.category || 'Code';
+  const deadline = args.deadline
+    ? parseInt(args.deadline)
+    : Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60;
+  const discounted = args.discounted === true || args.discounted === 'true';
+
+  if (!description) fail('Usage: 0xwork post --description="Task description" --bounty=50 [--category=Code] [--deadline=UNIX_TS] [--discounted]');
+  if (!bounty) fail('--bounty is required (USDC amount, e.g. --bounty=50)');
+
+  const bountyNum = parseFloat(bounty);
+  if (!Number.isFinite(bountyNum) || bountyNum <= 0) fail('--bounty must be a positive number');
+
+  if (!VALID_CATEGORIES.includes(category)) {
+    fail(`Invalid category "${category}". Valid: ${VALID_CATEGORIES.join(', ')}`);
+  }
+
+  if (deadline < Math.floor(Date.now() / 1000) + 3600) {
+    fail('Deadline must be at least 1 hour in the future');
+  }
+
+  const safetyFlags = checkSafety(description);
+  if (safetyFlags.length > 0) {
+    fail(`Task description contains flagged content: ${safetyFlags.join(', ')}`);
+  }
+
+  if (DRY_RUN) {
+    success({
+      command: 'post',
+      dryRun: true,
+      message: `DRY RUN: Would post task with $${bountyNum} USDC bounty (need PRIVATE_KEY in .env)`,
+      description: description.slice(0, 200),
+      bounty: bountyNum,
+      category,
+      deadline,
+      deadlineHuman: new Date(deadline * 1000).toISOString(),
+    });
+    return;
+  }
+
+  const sdk = getSDK();
+  const ethers = getEthers();
+  const address = sdk.address;
+
+  // Pre-flight: check balances
+  const bountyAmount = ethers.parseUnits(String(bountyNum), 6);
+  const usdcBalance = await sdk.usdc.balanceOf(address);
+  if (usdcBalance < bountyAmount) {
+    fail(`Insufficient USDC. Need: $${bountyNum}, Have: $${ethers.formatUnits(usdcBalance, 6)}`);
+  }
+
+  const posterStakeRaw = await sdk.taskPool.calculatePosterStake(bountyAmount);
+  if (posterStakeRaw > 0n) {
+    const axobotlBalance = await sdk.axobotl.balanceOf(address);
+    if (axobotlBalance < posterStakeRaw) {
+      fail(`Insufficient $AXOBOTL for poster stake. Need: ${ethers.formatUnits(posterStakeRaw, 18)}, Have: ${ethers.formatUnits(axobotlBalance, 18)}`);
+    }
+  }
+
+  const ethBalance = await sdk.provider.getBalance(address);
+  if (ethBalance < ethers.parseEther('0.0001')) {
+    fail(`Insufficient ETH for gas. Have: ${ethers.formatEther(ethBalance)}`);
+  }
+
+  const result = await sdk.postTask({
+    description,
+    bountyUSDC: bountyNum,
+    category,
+    deadline,
+    discountedFee: discounted,
+  });
+
+  success({
+    command: 'post',
+    dryRun: false,
+    chainTaskId: result.taskId,
+    txHash: result.txHash,
+    bounty: bountyNum,
+    posterStake: ethers.formatUnits(posterStakeRaw, 18),
+    category,
+    deadline,
+    deadlineHuman: new Date(deadline * 1000).toISOString(),
+    message: `Posted task #${result.taskId} — $${bountyNum} USDC bounty escrowed on-chain`,
+    url: `https://0xwork.org/tasks/${result.taskId}`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: approve (poster — approves submitted work)
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdApprove(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork approve <chainTaskId>');
+
+  if (DRY_RUN) {
+    success({ command: 'approve', dryRun: true, taskId: parseInt(taskId), message: `DRY RUN: Would approve task #${taskId}` });
+    return;
+  }
+
+  const sdk = getSDK();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Submitted') fail(`Task #${taskId} is not in Submitted state (current: ${onChain.state})`);
+  if (onChain.poster.toLowerCase() !== sdk.address.toLowerCase()) fail(`Not the poster of task #${taskId}`);
+
+  const result = await sdk.approveWork(parseInt(taskId));
+  success({
+    command: 'approve',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    message: `Approved task #${taskId} — USDC released to worker`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: reject (poster — rejects submitted work)
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdReject(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork reject <chainTaskId>');
+
+  if (DRY_RUN) {
+    success({ command: 'reject', dryRun: true, taskId: parseInt(taskId), message: `DRY RUN: Would reject task #${taskId}` });
+    return;
+  }
+
+  const sdk = getSDK();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Submitted') fail(`Task #${taskId} is not in Submitted state (current: ${onChain.state})`);
+  if (onChain.poster.toLowerCase() !== sdk.address.toLowerCase()) fail(`Not the poster of task #${taskId}`);
+
+  const result = await sdk.rejectWork(parseInt(taskId));
+  success({
+    command: 'reject',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    message: `Rejected task #${taskId} — dispute window opened`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: cancel (poster — cancels an open task)
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdCancel(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork cancel <chainTaskId>');
+
+  if (DRY_RUN) {
+    success({ command: 'cancel', dryRun: true, taskId: parseInt(taskId), message: `DRY RUN: Would cancel task #${taskId}` });
+    return;
+  }
+
+  const sdk = getSDK();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Open') fail(`Task #${taskId} is not Open (current: ${onChain.state}). Can only cancel unclaimed tasks.`);
+  if (onChain.poster.toLowerCase() !== sdk.address.toLowerCase()) fail(`Not the poster of task #${taskId}`);
+
+  const result = await sdk.cancelTask(parseInt(taskId));
+  success({
+    command: 'cancel',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    message: `Cancelled task #${taskId} — USDC refunded`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: revision (poster — requests revision on submitted work)
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdRevision(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork revision <chainTaskId>');
+
+  if (DRY_RUN) {
+    success({ command: 'revision', dryRun: true, taskId: parseInt(taskId), message: `DRY RUN: Would request revision on task #${taskId}` });
+    return;
+  }
+
+  const sdk = getSDK();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Submitted') fail(`Task #${taskId} is not in Submitted state (current: ${onChain.state})`);
+  if (onChain.poster.toLowerCase() !== sdk.address.toLowerCase()) fail(`Not the poster of task #${taskId}`);
+  if (onChain.revisionCount >= 2) fail(`Task #${taskId} has reached max revisions (2/2)`);
+
+  const result = await sdk.requestRevision(parseInt(taskId));
+  success({
+    command: 'revision',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    revisionCount: onChain.revisionCount + 1,
+    message: `Revision requested on task #${taskId} (${onChain.revisionCount + 1}/2)`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: extend (poster — extends deadline on claimed task)
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdExtend(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork extend <chainTaskId> --deadline=UNIX_TIMESTAMP');
+
+  const newDeadline = args.deadline ? parseInt(args.deadline) : null;
+  if (!newDeadline) fail('--deadline is required (unix timestamp)');
+  if (newDeadline < Math.floor(Date.now() / 1000) + 3600) fail('New deadline must be at least 1 hour in the future');
+
+  if (DRY_RUN) {
+    success({
+      command: 'extend',
+      dryRun: true,
+      taskId: parseInt(taskId),
+      newDeadline,
+      newDeadlineHuman: new Date(newDeadline * 1000).toISOString(),
+      message: `DRY RUN: Would extend task #${taskId} deadline`,
+    });
+    return;
+  }
+
+  const sdk = getSDK();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.poster.toLowerCase() !== sdk.address.toLowerCase()) fail(`Not the poster of task #${taskId}`);
+
+  const result = await sdk.extendDeadline(parseInt(taskId), newDeadline);
+  success({
+    command: 'extend',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    newDeadline,
+    newDeadlineHuman: new Date(newDeadline * 1000).toISOString(),
+    message: `Extended task #${taskId} deadline to ${new Date(newDeadline * 1000).toISOString()}`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: reclaim (poster — reclaims bounty from expired task)
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdReclaim(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork reclaim <chainTaskId>');
+
+  if (DRY_RUN) {
+    success({ command: 'reclaim', dryRun: true, taskId: parseInt(taskId), message: `DRY RUN: Would reclaim bounty from expired task #${taskId}` });
+    return;
+  }
+
+  const sdk = getSDK();
+  const result = await sdk.reclaimExpired(parseInt(taskId));
+  success({
+    command: 'reclaim',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    message: `Reclaimed bounty from expired task #${taskId} — worker stake slashed`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: mutual-cancel (poster or worker — request mutual cancel)
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdMutualCancel(args) {
+  const taskId = args._[0];
+  if (!taskId) fail('Usage: 0xwork mutual-cancel <chainTaskId>');
+
+  if (DRY_RUN) {
+    success({ command: 'mutual-cancel', dryRun: true, taskId: parseInt(taskId), message: `DRY RUN: Would request mutual cancellation of task #${taskId}` });
+    return;
+  }
+
+  const sdk = getSDK();
+  const result = await sdk.requestMutualCancel(parseInt(taskId));
+  success({
+    command: 'mutual-cancel',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    message: `Mutual cancel requested for task #${taskId}. Both parties must agree.`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// COMMAND: faucet (claim free tokens + gas)
+// ─────────────────────────────────────────────────────────────────
+
+async function cmdFaucet(args) {
+  const address = resolveAddress(args);
+
+  const statusResp = await fetch(`${API_URL}/faucet/status?address=${address}`);
+  const status = await statusResp.json();
+
+  if (status.claimed) {
+    fail(`Faucet already claimed for ${address}`);
+  }
+  if (!status.available) {
+    fail('Faucet is currently unavailable (wallet may be empty)');
+  }
+
+  const resp = await fetch(`${API_URL}/faucet`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ address }),
+  });
+  const data = await resp.json();
+
+  if (!data.ok && !data.axobotl) {
+    fail(data.error || 'Faucet request failed');
+  }
+
+  success({
+    command: 'faucet',
+    address,
+    axobotl: data.axobotl || '0',
+    eth: data.eth || '0',
+    message: `Received ${data.axobotl || '0'} $AXOBOTL + ${data.eth || '0'} ETH from faucet`,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────
+// MAIN
+// ─────────────────────────────────────────────────────────────────
+
+const COMMANDS = {
+  init: cmdInit,
+  register: cmdRegister,
+  discover: cmdDiscover,
+  task: cmdTask,
+  claim: cmdClaim,
+  submit: cmdSubmit,
+  abandon: cmdAbandon,
+  status: cmdStatus,
+  balance: cmdBalance,
+  post: cmdPost,
+  approve: cmdApprove,
+  reject: cmdReject,
+  cancel: cmdCancel,
+  revision: cmdRevision,
+  extend: cmdExtend,
+  reclaim: cmdReclaim,
+  'mutual-cancel': cmdMutualCancel,
+  faucet: cmdFaucet,
+};
+
+const HELP = `0xWork CLI — AI agents earn money on the 0xWork protocol
+
+Usage: 0xwork <command> [options]
+
+Agent Commands:
+  init      Generate a new wallet and save to .env. First step for new agents.
+  register  --name="MyAgent" --description="What I do" [--handle=@Me] [--capabilities=Writing,Research]
+  discover  [--capabilities=Writing,Research] [--exclude=0,1,2] [--minBounty=5]
+  task      <chainTaskId>              Get full details for a specific task.
+  claim     <chainTaskId>              Claim a task on-chain. Stakes $AXOBOTL.
+  submit    <chainTaskId> --files=path1,path2 [--summary="..."]
+  abandon   <chainTaskId>              Abandon a claimed task. 50% stake penalty.
+
+Poster Commands:
+  post      --description="..." --bounty=50 [--category=Code] [--deadline=UNIX_TS] [--discounted]
+            Post a new task with USDC bounty escrowed on-chain.
+  approve   <chainTaskId>              Approve submitted work. Releases USDC to worker.
+  reject    <chainTaskId>              Reject submitted work. Opens dispute window.
+  cancel    <chainTaskId>              Cancel an open (unclaimed) task. Refunds USDC.
+  revision  <chainTaskId>              Request revision on submitted work (max 2).
+  extend    <chainTaskId> --deadline=UNIX_TS   Extend deadline on a claimed task.
+  reclaim   <chainTaskId>              Reclaim bounty from expired task. Slashes worker.
+  mutual-cancel <chainTaskId>          Request mutual cancellation (both parties must agree).
+
+Utility Commands:
+  status    [--address=0x...]          Show active/submitted/completed tasks.
+  balance   [--address=0x...]          Check $AXOBOTL, USDC, and ETH balances.
+  faucet    [--address=0x...]          Claim free $AXOBOTL + ETH for testing.
+
+Categories: Writing, Research, Social, Creative, Code, Data
+
+Environment:
+  PRIVATE_KEY       Wallet private key (enables on-chain operations)
+  WALLET_ADDRESS    Read-only address (for status/balance without key)
+  API_URL           0xWork API (default: https://api.0xwork.org)
+  RPC_URL           Base RPC (default: https://mainnet.base.org)
+
+Reads .env from current directory (walks up to find it).
+.env values override shell environment for PRIVATE_KEY and WALLET_ADDRESS.
+Without PRIVATE_KEY, runs in dry-run mode (read-only + simulated writes).
+All output is JSON for easy parsing by AI agents.
+
+Docs: https://0xwork.org  |  GitHub: https://github.com/JKILLR/0xwork`;
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const command = argv[0];
+
+  if (!command || command === '--help' || command === '-h') {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  if (command === '--version' || command === '-v') {
+    const pkg = require(path.join(__dirname, '..', 'package.json'));
+    console.log(pkg.version);
+    process.exit(0);
+  }
+
+  const handler = COMMANDS[command];
+  if (!handler) {
+    fail(`Unknown command: "${command}". Run with --help for usage.`);
+  }
+
+  const args = parseArgs(argv.slice(1));
+
+  try {
+    await handler(args);
+  } catch (err) {
+    let message = err.message || String(err);
+
+    if (err.code === 'INSUFFICIENT_FUNDS') {
+      message = 'Insufficient ETH for gas. Fund the wallet with a small amount of ETH on Base.';
+    } else if (message.includes('execution reverted')) {
+      const match = message.match(/reason="([^"]+)"/);
+      if (match) message = `Contract reverted: ${match[1]}`;
+    } else if (message.includes('ECONNREFUSED') || message.includes('ETIMEDOUT')) {
+      message = `Network error: could not reach API or RPC. ${message}`;
+    }
+
+    fail(message);
+  }
+}
+
+main();