@0xwork/cli 0.2.0 → 1.0.1

package/src/commands/retract-cancel.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+
+function register(program) {
+  program
+    .command('retract-cancel <chainTaskId>')
+    .description('Retract a pending mutual cancel request')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'retract-cancel', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would retract cancel request on task #${taskId}`,
+    }, () => {
+      header('↩️', `Retract 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 (!onChain.cancelRequestedBy) {
+    s1.fail('No pending request'); fail('No pending cancel request to retract.');
+  }
+  if (onChain.cancelRequestedBy.toLowerCase() !== address.toLowerCase()) {
+    s1.fail('Not your request');
+    fail(`Only the requester can retract. Requested by: ${onChain.cancelRequestedBy}`);
+  }
+  s1.succeed('Verified');
+
+  const s2 = createSpinner('Retracting…');
+  s2.start();
+  const result = await sdk.retractCancelRequest(parseInt(taskId));
+  s2.succeed('Retracted');
+
+  success({
+    command: 'retract-cancel', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash,
+    message: `Retracted cancel request on task #${taskId}`,
+  }, () => {
+    header('✔', `Cancel Request Retracted — Task #${taskId}`);
+    hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/revision.js

@@ -0,0 +1,73 @@
+'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 { truncAddr } = require('../format');
+
+function register(program) {
+  program
+    .command('revision <chainTaskId>')
+    .description('Request revision on submitted work (max 2 per task)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'revision', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would request revision on task #${taskId}`,
+    }, () => {
+      header('🔄', `Revision #${taskId} — Dry Run`);
+      hint('Set PRIVATE_KEY in .env.'); 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 !== 'Submitted') {
+    s1.fail(`Task is ${onChain.state}`); fail(`Expected Submitted state`);
+  }
+  if (onChain.poster.toLowerCase() !== address.toLowerCase()) {
+    s1.fail('Not your task'); fail(`Only the poster can request revision.`);
+  }
+  if (onChain.revisionCount >= 2) {
+    s1.fail('Max revisions reached'); fail('Maximum of 2 revisions reached. You must approve or reject.');
+  }
+  s1.succeed('Verified');
+
+  const s2 = createSpinner('Requesting revision…');
+  s2.start();
+  const result = await sdk.requestRevision(parseInt(taskId));
+  s2.succeed('Revision requested');
+
+  const used = onChain.revisionCount + 1;
+  const remaining = 2 - used;
+
+  success({
+    command: 'revision', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash, worker: onChain.worker,
+    revisionsUsed: used, revisionsRemaining: remaining,
+    message: `Revision requested on task #${taskId} (${used}/2 used)`,
+  }, () => {
+    header('🔄', `Revision Requested — Task #${taskId}`);
+    keyValue('Worker', truncAddr(onChain.worker));
+    keyValue('Revisions', `${used}/2 used (${remaining} remaining)`);
+    hint("Worker's deadline extended by 48h.");
+    blank();
+    hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/status.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const config = require('../config');
+const { isDryRun, resolveAddress, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, divider, TABLE_CHARS } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty, fmtDeadline, fmtStatus, fmtCategory, fmtDesc, formatTaskBrief, truncAddr } = require('../format');
+const { fetchWithTimeout } = require('../http');
+
+function register(program) {
+  program
+    .command('status')
+    .description('Show your active tasks')
+    .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 spinner = createSpinner('Fetching tasks…');
+  spinner.start();
+
+  const resp = await fetchWithTimeout(`${config.API_URL}/tasks/worker/${address}`);
+  if (!resp.ok) {
+    spinner.stop();
+    fail(`API error: ${resp.status}`);
+  }
+  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);
+
+  spinner.stop();
+
+  const result = {
+    command: 'status',
+    dryRun: isDryRun(),
+    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),
+    },
+  };
+
+  success(result, () => {
+    header('📋', `Task Status`, chalk.dim(truncAddr(address)));
+
+    // Summary
+    const counts = [
+      active.length    ? chalk.yellow(`${active.length} active`)       : null,
+      submitted.length ? chalk.blue(`${submitted.length} submitted`)   : null,
+      completed.length ? chalk.green(`${completed.length} completed`)  : null,
+      disputed.length  ? chalk.red(`${disputed.length} disputed`)      : null,
+    ].filter(Boolean);
+
+    if (counts.length === 0) {
+      console.log(chalk.dim('    No tasks found for this wallet.'));
+      blank();
+      return;
+    }
+
+    console.log(`    ${counts.join('  ·  ')}  ·  ${chalk.green(fmtBounty(totalEarned))} earned`);
+    blank();
+
+    // Active tasks table
+    const allActive = [...active, ...submitted, ...disputed];
+    if (allActive.length > 0) {
+      const table = new Table({
+        chars: TABLE_CHARS,
+        style: { head: ['cyan'], 'padding-left': 1, 'padding-right': 1 },
+        head: ['ID', 'Bounty', 'Status', 'Category', 'Deadline'],
+        colWidths: [7, 10, 14, 11, 11],
+      });
+
+      for (const t of allActive) {
+        table.push([
+          chalk.cyan(`#${t.chain_task_id}`),
+          chalk.green(fmtBounty(t.bounty_amount)),
+          fmtStatus(t.status),
+          fmtCategory(t.category),
+          fmtDeadline(t.deadline),
+        ]);
+      }
+
+      console.log('  ' + table.toString().split('\n').join('\n  '));
+      blank();
+    }
+  });
+}
+
+module.exports = { register };

package/src/commands/submit.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { isTextFile } = require('../format');
+
+function register(program) {
+  program
+    .command('submit <chainTaskId>')
+    .description('Submit completed work with deliverables')
+    .option('--proof <url>', 'URL or hash of deliverable')
+    .option('--summary <text>', 'Description of what was delivered')
+    .option('--files <paths>', 'Comma-separated file paths to upload')
+    .action(async (chainTaskId, opts) => {
+      try {
+        await run(chainTaskId, opts);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId, opts) {
+  if (!opts.proof && !opts.files) {
+    fail('Provide --proof=<url> and/or --files=<paths>',
+      { suggestion: 'Example: 0xwork submit 45 --proof="https://x.com/..." or --files=report.md,data.csv' });
+  }
+
+  // Read files if provided
+  const files = [];
+  if (opts.files) {
+    const filePaths = opts.files.split(',').map(s => s.trim());
+    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 (isDryRun()) {
+    return success({
+      command: 'submit',
+      dryRun: true,
+      taskId: parseInt(taskId),
+      message: `DRY RUN: Would submit to task #${taskId}`,
+      proof: opts.proof || null,
+      files: files.map(f => f.name),
+      summary: opts.summary || '',
+      txHash: null,
+      proofHash: null,
+    }, () => {
+      header('📤', `Submit Task #${taskId} — Dry Run`);
+      hint('Set PRIVATE_KEY in .env to submit work.');
+      blank();
+    });
+  }
+
+  const sdk = requireSDK();
+
+  // Pre-flight: check task state
+  const s1 = createSpinner('Verifying task state…');
+  s1.start();
+
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Claimed' && onChain.state !== 'Submitted') {
+    s1.fail(`Task is ${onChain.state}`);
+    fail(`Task #${taskId} is ${onChain.state}, expected Claimed`);
+  }
+  if (onChain.worker.toLowerCase() !== sdk.address.toLowerCase()) {
+    s1.fail('Not your task');
+    fail(`Task #${taskId} is claimed by ${onChain.worker}, not ${sdk.address}`);
+  }
+
+  s1.succeed('Task verified');
+
+  // Submit with file upload (SDK handles proof hash generation)
+  if (files.length > 0) {
+    const s2 = createSpinner(`Uploading ${files.length} file(s)…`);
+    s2.start();
+
+    const result = await sdk.submitDeliverable(parseInt(taskId), {
+      files,
+      summary: opts.summary || '',
+    });
+
+    s2.succeed('Submitted');
+
+    return success({
+      command: 'submit',
+      dryRun: false,
+      taskId: parseInt(taskId),
+      txHash: result.txHash,
+      proofHash: result.proofHash,
+      proof: opts.proof || null,
+      files: files.map(f => f.name),
+      summary: opts.summary || '',
+      message: `Submitted ${files.length} file(s) to task #${taskId}`,
+    }, () => {
+      header('✔', `Task #${taskId} Submitted`);
+      keyValue('Files', files.map(f => f.name).join(', '));
+      if (opts.proof) keyValue('Proof', opts.proof);
+      if (opts.summary) keyValue('Summary', opts.summary);
+      keyValue('Proof hash', chalk.dim(result.proofHash));
+      blank();
+      hint('Waiting for poster approval (auto-approves after 7 days)');
+      blank();
+      hint(`tx: ${result.txHash}`);
+      blank();
+    });
+  }
+
+  // Simple submit with proof URL/hash
+  const s2 = createSpinner('Submitting work…');
+  s2.start();
+
+  const result = await sdk.submitWork(parseInt(taskId), opts.proof);
+
+  s2.succeed('Submitted');
+
+  success({
+    command: 'submit',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    proof: opts.proof,
+    summary: opts.summary || '',
+    message: `Submitted task #${taskId}`,
+  }, () => {
+    header('✔', `Task #${taskId} Submitted`);
+    keyValue('Proof', opts.proof);
+    if (opts.summary) keyValue('Summary', opts.summary);
+    blank();
+    hint('Waiting for poster approval (auto-approves after 7 days)');
+    blank();
+    hint(`tx: ${result.txHash}`);
+    blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/task.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const chalk = require('chalk');
+const config = require('../config');
+const { getSDK, getEthers, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, box, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { getAxobotlPrice, formatAxobotlUsd } = require('../price');
+const { fmtBounty, fmtDeadline, fmtStatus, fmtCategory, fmtAxobotl, fmtDuration, truncAddr } = require('../format');
+const { resolveTask } = require('../resolve');
+const { checkSafety } = require('../safety');
+
+function register(program) {
+  program
+    .command('task <chainTaskId>')
+    .description('Get full details for a specific task')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  const spinner = createSpinner('Fetching task…');
+  spinner.start();
+
+  const t = await resolveTask(taskId);
+  const price = await getAxobotlPrice();
+
+  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),
+  };
+
+  // On-chain enrichment
+  if (!isDryRun()) {
+    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;
+    }
+  }
+
+  // Price enrichment
+  if (price) {
+    if (result.currentStakeRequired) {
+      result.currentStakeRequiredUsd = formatAxobotlUsd(result.currentStakeRequired, price);
+    }
+    if (result.stakeRaw) {
+      const ethers = getEthers();
+      const stakeNum = parseFloat(ethers.formatUnits(result.stakeRaw, 18));
+      result.stakeUsd = formatAxobotlUsd(stakeNum, price);
+    }
+    result.axobotlPriceUsd = price;
+  }
+
+  spinner.stop();
+
+  success({ command: 'task', task: result }, () => {
+    const stakeStr = result.currentStakeRequired
+      ? `${fmtAxobotl(result.currentStakeRequired)} AXOBOTL`
+      : (result.stakeRaw ? `${fmtAxobotl(parseFloat(getEthers().formatUnits(result.stakeRaw, 18)))} AXOBOTL` : '—');
+    const stakeUsdStr = result.currentStakeRequiredUsd || result.stakeUsd || '';
+
+    const lines = [
+      '',
+      `${chalk.dim('Bounty:'.padEnd(14))} ${chalk.green.bold(fmtBounty(result.bounty) + ' USDC')}`,
+      `${chalk.dim('Deadline:'.padEnd(14))} ${fmtDeadline(result.deadline, true)}`,
+      `${chalk.dim('Status:'.padEnd(14))} ${fmtStatus(result.status)}`,
+      `${chalk.dim('Category:'.padEnd(14))} ${fmtCategory(result.category)}`,
+      `${chalk.dim('Poster:'.padEnd(14))} ${truncAddr(result.poster)}`,
+      `${chalk.dim('Worker:'.padEnd(14))} ${result.worker ? truncAddr(result.worker) : '—'}`,
+      '',
+      `${chalk.dim('Stake:'.padEnd(14))} ${stakeStr}${stakeUsdStr ? chalk.dim(` (~${stakeUsdStr})`) : ''}`,
+    ];
+
+    if (result.proofHash) {
+      lines.push(`${chalk.dim('Proof:'.padEnd(14))} ${chalk.dim(result.proofHash)}`);
+    }
+
+    lines.push('');
+
+    // Description (word-wrapped)
+    if (result.description) {
+      lines.push(chalk.dim('Description:'));
+      const descLines = result.description.split('\n');
+      for (const dl of descLines) {
+        const words = dl.split(' ');
+        let line = '';
+        for (const w of words) {
+          if (line.length + w.length + 1 > 56) {
+            lines.push(`  ${line}`);
+            line = w;
+          } else {
+            line = line ? `${line} ${w}` : w;
+          }
+        }
+        if (line) lines.push(`  ${line}`);
+      }
+    }
+
+    if (result.safetyFlags && result.safetyFlags.length > 0) {
+      lines.push('');
+      lines.push(chalk.yellow(`⚠ Safety flags: ${result.safetyFlags.join(', ')}`));
+    }
+
+    box(`Task #${result.chainTaskId} — ${result.category || 'Task'}`, lines);
+  });
+}
+
+module.exports = { register };

package/src/config.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// ─── .env loader (zero deps) ───────────────────────────────────────
+// Walks from CWD upward looking for .env files.
+// CWD .env overrides system env (agent's local config wins).
+// Parent .env files are fallback only (don't override).
+
+function loadEnv() {
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+  let first = true;
+  while (dir !== root) {
+    const envPath = path.join(dir, '.env');
+    if (fs.existsSync(envPath)) {
+      parseEnvFile(envPath, first);
+      return;
+    }
+    first = false;
+    dir = path.dirname(dir);
+  }
+}
+
+function parseEnvFile(envPath, override = false) {
+  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);
+    }
+    if (override || !process.env[key]) process.env[key] = val;
+  }
+}
+
+// Load on require
+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 || process.env.BASE_RPC_URL || '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;
+
+module.exports = {
+  API_URL,
+  RPC_URL,
+  PRIVATE_KEY,
+  WALLET_ADDRESS,
+  loadEnv,
+};