@0xwork/cli 0.1.0 → 1.0.0

package/src/commands/claim-approval.js

@@ -0,0 +1,76 @@
+'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, fmtDuration, truncAddr } = require('../format');
+
+function register(program) {
+  program
+    .command('claim-approval <chainTaskId>')
+    .description('Trigger auto-approve after poster ghosts 7 days')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'claim-approval', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would trigger auto-approve on task #${taskId}`,
+    }, () => {
+      header('⏱️', `Claim Approval #${taskId} — Dry Run`); hint('Set PRIVATE_KEY.'); blank();
+    });
+  }
+
+  const sdk = requireSDK();
+
+  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.submitTimestamp) {
+    s1.fail('No submission timestamp'); fail('No submission timestamp recorded.');
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  const window = 7 * 86400;
+  const eligibleAt = onChain.submitTimestamp + window;
+  if (now < eligibleAt) {
+    const remaining = eligibleAt - now;
+    s1.fail('Not yet eligible');
+    fail(`Auto-approve eligible in ${fmtDuration(remaining)} (at ${new Date(eligibleAt * 1000).toISOString()})`);
+  }
+  s1.succeed('Eligible');
+
+  const s2 = createSpinner('Triggering auto-approve…');
+  s2.start();
+  const result = await sdk.claimApproval(parseInt(taskId));
+  s2.succeed('Auto-approved');
+
+  const bounty = parseFloat(onChain.bountyAmount);
+  const fee = onChain.discountedFee ? bounty * 0.02 : bounty * 0.05;
+  const payout = bounty - fee;
+
+  success({
+    command: 'claim-approval', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash, worker: onChain.worker, payout: payout.toFixed(2),
+    message: `Auto-approved task #${taskId} — ${fmtBounty(payout)} to worker`,
+  }, () => {
+    header('✔', `Task #${taskId} Auto-Approved`);
+    keyValue('Worker', truncAddr(onChain.worker));
+    keyValue('Payout', chalk.green.bold(`${fmtBounty(payout)} USDC`));
+    hint('Poster stake slashed for inaction.');
+    blank(); hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/claim.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const chalk = require('chalk');
+const config = require('../config');
+const { getEthers, isDryRun, requireSDK, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty, fmtDeadline, fmtAxobotl } = require('../format');
+const { getAxobotlPrice, formatAxobotlUsd } = require('../price');
+const { resolveTask } = require('../resolve');
+const { fetchWithTimeout } = require('../http');
+
+function register(program) {
+  program
+    .command('claim <chainTaskId>')
+    .description('Claim a task on-chain (stakes $AXOBOTL as collateral)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    let t;
+    try { t = await resolveTask(taskId); } catch { t = null; }
+    return success({
+      command: 'claim',
+      dryRun: true,
+      taskId: parseInt(taskId),
+      message: `DRY RUN: Would claim task #${taskId}`,
+      bounty: t ? t.bounty_amount : null,
+      stakeRaw: t ? t.stake_amount : null,
+      txHash: null,
+    }, () => {
+      header('🔒', `Claim Task #${taskId} — Dry Run`);
+      hint('Set PRIVATE_KEY in .env to claim tasks.');
+      blank();
+    });
+  }
+
+  const sdk = requireSDK();
+  const ethers = getEthers();
+  const address = sdk.address;
+
+  // Pre-flight: fetch on-chain state
+  const s1 = createSpinner('Checking task state…');
+  s1.start();
+
+  let onChain;
+  try {
+    onChain = await sdk.getTask(parseInt(taskId));
+  } catch (e) {
+    s1.fail('Task not found on-chain');
+    fail(`Task #${taskId} not found on-chain: ${normalizeError(e)}`);
+  }
+
+  if (onChain.poster === '0x0000000000000000000000000000000000000000') {
+    s1.fail('Task does not exist');
+    fail(`Task #${taskId} does not exist on-chain`);
+  }
+  if (onChain.state !== 'Open') {
+    s1.fail(`Task is ${onChain.state}`);
+    fail(`Task #${taskId} is not Open (current: ${onChain.state})`);
+  }
+  if (onChain.poster.toLowerCase() === address.toLowerCase()) {
+    s1.fail('Cannot claim own task');
+    fail('Cannot claim your own task');
+  }
+
+  // Preferred lock check
+  try {
+    const t = await resolveTask(taskId);
+    const lock = t.preferred_lock;
+    if (lock && lock.locked && t.preferred_agent_id != null) {
+      let myAgentId = null;
+      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;
+      }
+      if (myAgentId == null || t.preferred_agent_id !== myAgentId) {
+        const agentName = t.preferred_agent_name || `Agent #${t.preferred_agent_id}`;
+        const hours = Math.ceil(lock.remaining_seconds / 3600);
+        s1.fail('Task is reserved');
+        fail(`Reserved for ${agentName} for ${hours}h. Try again later.`);
+      }
+    }
+  } catch (e) {
+    if (e.message && e.message.startsWith('Reserved')) throw e;
+  }
+
+  s1.succeed('Task is Open');
+
+  // Pre-flight: check balances
+  const s2 = createSpinner('Checking balances…');
+  s2.start();
+
+  const stakeRequired = await sdk.taskPool.calculateStake(
+    ethers.parseUnits(String(onChain.bountyAmount), 6)
+  );
+  const axobotlBalance = await sdk.axobotl.balanceOf(address);
+  if (axobotlBalance < stakeRequired) {
+    s2.fail('Insufficient AXOBOTL');
+    fail(
+      `Insufficient $AXOBOTL for stake`,
+      { suggestion: `Need: ${fmtAxobotl(ethers.formatUnits(stakeRequired, 18))}, Have: ${fmtAxobotl(ethers.formatUnits(axobotlBalance, 18))}. Buy on Uniswap (Base) or request from faucet.` }
+    );
+  }
+
+  const ethBalance = await sdk.provider.getBalance(address);
+  if (ethBalance < ethers.parseEther('0.0001')) {
+    s2.fail('Insufficient ETH');
+    fail('Insufficient ETH for gas', { suggestion: `Have: ${ethers.formatEther(ethBalance)} ETH. Send ETH on Base to ${address}` });
+  }
+
+  s2.succeed('Balances OK');
+
+  // Claim
+  const s3 = createSpinner('Claiming task…');
+  s3.start();
+
+  const result = await sdk.claimTask(parseInt(taskId));
+
+  s3.succeed('Claimed');
+
+  const stakeHuman = ethers.formatUnits(stakeRequired, 18);
+  const price = await getAxobotlPrice();
+  const stakeUsd = price ? formatAxobotlUsd(stakeHuman, price) : null;
+
+  const data = {
+    command: 'claim',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    stakeAmount: stakeHuman,
+    bounty: onChain.bountyAmount,
+    message: `Claimed task #${taskId} — staked ${fmtAxobotl(stakeHuman)} AXOBOTL`,
+  };
+
+  success(data, () => {
+    header('✔', `Task #${taskId} Claimed`);
+    keyValue('Bounty', chalk.green.bold(`${fmtBounty(onChain.bountyAmount)} USDC`));
+    keyValue('Staked', `${fmtAxobotl(stakeHuman)} AXOBOTL${stakeUsd ? chalk.dim(` (~${stakeUsd})`) : ''}`);
+    keyValue('Deadline', fmtDeadline(onChain.deadline, true));
+    blank();
+    hint(`Next: complete the work, then run:`);
+    hint(`  $ 0xwork submit ${taskId} --proof="https://..."`);
+    blank();
+    hint(`tx: ${result.txHash}`);
+    blank();
+  });
+}
+
+module.exports = { register };

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 };