@antseed/cli 0.1.0

package/src/cli/commands/seed.ts

@@ -0,0 +1,447 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import ora from 'ora'
+import { writeFile, unlink } from 'node:fs/promises'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import { getGlobalOptions } from './types.js'
+import { loadConfig } from '../../config/loader.js'
+import type { CLIProviderConfig } from '../../config/types.js'
+import { AntseedNode, type Provider, getInstance } from '@antseed/node'
+import type { PaymentConfig } from '@antseed/node/payments'
+import { parseBootstrapList, toBootstrapConfig } from '@antseed/node/discovery'
+import { setupShutdownHandler } from '../shutdown.js'
+import { loadProviderPlugin, buildPluginConfig } from '../../plugins/loader.js'
+import { resolveEffectiveSellerConfig, type SellerRuntimeOverrides } from '../../config/effective.js'
+import type { SellerCLIConfig } from '../../config/types.js'
+
+const STATE_FILE = join(homedir(), '.antseed', 'daemon.state.json')
+
+/** Map config file provider entry to env-style key/value pairs for the plugin. */
+function providerConfigToEnv(p: CLIProviderConfig): Record<string, string> {
+  const env: Record<string, string> = {}
+  if (p.authValue) env['ANTHROPIC_API_KEY'] = p.authValue
+  if (p.authType) env['ANTSEED_AUTH_TYPE'] = p.authType
+  return env
+}
+
+function parseOptionalBoolEnv(value: string | undefined): boolean | null {
+  if (value === undefined) return null
+  const normalized = value.trim().toLowerCase()
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true
+  if (['0', 'false', 'no', 'off'].includes(normalized)) return false
+  return null
+}
+
+async function isRpcReachable(rpcUrl: string, timeoutMs = 1500): Promise<boolean> {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), timeoutMs)
+
+  try {
+    const response = await fetch(rpcUrl, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'eth_chainId',
+        params: [],
+      }),
+      signal: controller.signal,
+    })
+
+    if (!response.ok) return false
+
+    const payload = await response.json() as { result?: unknown }
+    return typeof payload.result === 'string' && payload.result.startsWith('0x')
+  } catch {
+    return false
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+function toUSDCBaseUnits(value: string | undefined, fallbackBaseUnits: string): string {
+  if (value === undefined) return fallbackBaseUnits
+  const parsed = Number.parseFloat(value.trim())
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallbackBaseUnits
+  return String(Math.round(parsed * 1_000_000))
+}
+
+export function buildSellerRuntimeOverridesFromFlags(options: {
+  reserve?: number
+  inputUsdPerMillion?: number
+  outputUsdPerMillion?: number
+}): SellerRuntimeOverrides {
+  const overrides: SellerRuntimeOverrides = {}
+  if (options.reserve !== undefined) {
+    overrides.reserveFloor = options.reserve
+  }
+  if (options.inputUsdPerMillion !== undefined) {
+    overrides.inputUsdPerMillion = options.inputUsdPerMillion
+  }
+  if (options.outputUsdPerMillion !== undefined) {
+    overrides.outputUsdPerMillion = options.outputUsdPerMillion
+  }
+  return overrides
+}
+
+export function buildSellerPluginRuntimeEnv(
+  sellerConfig: SellerCLIConfig,
+  providerName: string,
+): Record<string, string> {
+  const providerPricing = sellerConfig.pricing.providers?.[providerName]
+  const effectiveDefaults = providerPricing?.defaults ?? sellerConfig.pricing.defaults
+  const modelPricing = providerPricing?.models
+  const runtimeEnv: Record<string, string> = {
+    ANTSEED_INPUT_USD_PER_MILLION: String(effectiveDefaults.inputUsdPerMillion),
+    ANTSEED_OUTPUT_USD_PER_MILLION: String(effectiveDefaults.outputUsdPerMillion),
+    ANTSEED_MAX_CONCURRENCY: String(sellerConfig.maxConcurrentBuyers),
+  }
+  if (modelPricing && Object.keys(modelPricing).length > 0) {
+    runtimeEnv['ANTSEED_MODEL_PRICING_JSON'] = JSON.stringify(modelPricing)
+  }
+  return runtimeEnv
+}
+
+export function registerSeedCommand(program: Command): void {
+  program
+    .command('seed')
+    .description('Start seeding your idle LLM capacity to the P2P network')
+    .option('--provider <name>', 'provider plugin name (e.g., anthropic)')
+    .option('--instance <id>', 'use a configured plugin instance by ID')
+    .option('-r, --reserve <number>', 'runtime-only reserve floor override (does not write config file)', parseFloat)
+    .option('--input-usd-per-million <number>', 'runtime-only input pricing override in USD per 1M tokens', parseFloat)
+    .option('--output-usd-per-million <number>', 'runtime-only output pricing override in USD per 1M tokens', parseFloat)
+    .action(async (options) => {
+      const globalOpts = getGlobalOptions(program)
+      const config = await loadConfig(globalOpts.config)
+      const runtimeOverrides = buildSellerRuntimeOverridesFromFlags({
+        reserve: options.reserve as number | undefined,
+        inputUsdPerMillion: options.inputUsdPerMillion as number | undefined,
+        outputUsdPerMillion: options.outputUsdPerMillion as number | undefined,
+      })
+      const effectiveSellerConfig = resolveEffectiveSellerConfig({
+        config,
+        sellerOverrides: runtimeOverrides,
+      })
+
+      let provider: Provider
+
+      if (options.instance) {
+        const configPath = join(homedir(), '.antseed', 'config.json')
+        const instance = await getInstance(configPath, options.instance)
+        if (!instance) {
+          console.error(chalk.red(`Instance "${options.instance}" not found.`))
+          process.exit(1)
+        }
+        if (instance.type !== 'provider') {
+          console.error(chalk.red(`Instance "${options.instance}" is a ${instance.type}, not a provider.`))
+          process.exit(1)
+        }
+        const spinner = ora(`Loading provider plugin "${instance.package}"...`).start()
+        try {
+          const plugin = await loadProviderPlugin(instance.package)
+          const runtimeEnv = buildSellerPluginRuntimeEnv(effectiveSellerConfig, plugin.name)
+          const pluginConfig = buildPluginConfig(plugin.configSchema ?? plugin.configKeys ?? [], runtimeEnv, instance.config as Record<string, string>)
+          provider = await plugin.createProvider(pluginConfig)
+          if (provider.init) {
+            spinner.text = 'Validating credentials...'
+            await provider.init()
+          }
+          spinner.succeed(chalk.green(`Provider "${plugin.displayName}" loaded`))
+        } catch (err) {
+          spinner.fail(chalk.red(`Failed to load provider: ${(err as Error).message}`))
+          process.exit(1)
+        }
+      } else if (options.provider) {
+        const spinner = ora(`Loading provider plugin "${options.provider}"...`).start()
+        try {
+          const plugin = await loadProviderPlugin(options.provider)
+          const configProvider = config.providers.find(p => p.type === options.provider)
+          const fileConfig = configProvider ? providerConfigToEnv(configProvider) : {}
+          const runtimeEnv = buildSellerPluginRuntimeEnv(effectiveSellerConfig, options.provider as string)
+          const envAndRuntimeConfig = buildPluginConfig(plugin.configSchema ?? plugin.configKeys ?? [], runtimeEnv)
+          const pluginConfig = { ...fileConfig, ...envAndRuntimeConfig }
+          provider = await plugin.createProvider(pluginConfig)
+          if (provider.init) {
+            spinner.text = 'Validating credentials...'
+            await provider.init()
+          }
+          spinner.succeed(chalk.green(`Provider "${plugin.displayName}" loaded`))
+        } catch (err) {
+          spinner.fail(chalk.red(`Failed to load provider: ${(err as Error).message}`))
+          process.exit(1)
+        }
+      } else {
+        console.error(chalk.red('Error: No provider specified.'))
+        console.error(chalk.dim('Run: antseed seed --provider <name>  or  antseed seed --instance <id>'))
+        process.exit(1)
+      }
+
+      const bootstrapNodes = config.network.bootstrapNodes.length > 0
+        ? toBootstrapConfig(parseBootstrapList(config.network.bootstrapNodes))
+        : undefined
+
+      const preferredMethod = config.payments.preferredMethod
+      const defaultEscrowAmountUSDC = process.env['ANTSEED_DEFAULT_ESCROW_USDC'] ?? config.payments.crypto?.defaultLockAmountUSDC ?? '1'
+      const defaultEscrowAmountUSDCBaseUnits = toUSDCBaseUnits(defaultEscrowAmountUSDC, '1000000')
+      const settlementIdleMsRaw = process.env['ANTSEED_SETTLEMENT_IDLE_MS']
+      const settlementIdleMs = settlementIdleMsRaw ? parseInt(settlementIdleMsRaw, 10) : 30_000
+      const sellerWalletAddress = process.env['ANTSEED_SELLER_WALLET_ADDRESS']
+
+      let paymentConfig: PaymentConfig | null = null
+      if (preferredMethod === 'crypto' && config.payments.crypto) {
+        const defaultLockAmountUSDCBaseUnits = toUSDCBaseUnits(
+          config.payments.crypto.defaultLockAmountUSDC ?? defaultEscrowAmountUSDC,
+          defaultEscrowAmountUSDCBaseUnits,
+        )
+        const cryptoConfig: NonNullable<PaymentConfig['crypto']> = {
+          chainId: config.payments.crypto.chainId,
+          rpcUrl: config.payments.crypto.rpcUrl,
+          contractAddress: config.payments.crypto.escrowContractAddress,
+          usdcAddress: config.payments.crypto.usdcContractAddress,
+          defaultLockAmountUSDC: defaultLockAmountUSDCBaseUnits,
+        }
+
+        paymentConfig = {
+          crypto: cryptoConfig,
+        }
+      }
+
+      const settlementEnv = parseOptionalBoolEnv(process.env['ANTSEED_ENABLE_SETTLEMENT'])
+      let paymentsEnabled = settlementEnv ?? paymentConfig !== null
+      const cryptoRpcUrl = paymentConfig?.crypto?.rpcUrl
+
+      if (paymentsEnabled && cryptoRpcUrl && settlementEnv !== true) {
+        const rpcUp = await isRpcReachable(cryptoRpcUrl)
+        if (!rpcUp) {
+          paymentsEnabled = false
+          console.log(chalk.yellow(`Payments disabled: RPC node unreachable at ${cryptoRpcUrl}`))
+          console.log(chalk.dim('Start your chain node or set ANTSEED_ENABLE_SETTLEMENT=true to force-enable payments.'))
+        }
+      }
+
+      const providerName = options.provider as string | undefined ?? provider.name ?? 'unknown'
+      const runtimeProviderPricing = buildSellerPluginRuntimeEnv(effectiveSellerConfig, providerName)
+      const runtimeInputUsdPerMillion = Number.parseFloat(runtimeProviderPricing['ANTSEED_INPUT_USD_PER_MILLION'] ?? '')
+      const runtimeOutputUsdPerMillion = Number.parseFloat(runtimeProviderPricing['ANTSEED_OUTPUT_USD_PER_MILLION'] ?? '')
+      let runtimeModelPricing: Record<string, { inputUsdPerMillion: number; outputUsdPerMillion: number }> | undefined
+      if (runtimeProviderPricing['ANTSEED_MODEL_PRICING_JSON']) {
+        try {
+          const parsed = JSON.parse(runtimeProviderPricing['ANTSEED_MODEL_PRICING_JSON']) as unknown
+          if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const out: Record<string, { inputUsdPerMillion: number; outputUsdPerMillion: number }> = {}
+            for (const [model, pricing] of Object.entries(parsed as Record<string, unknown>)) {
+              if (!pricing || typeof pricing !== 'object' || Array.isArray(pricing)) continue
+              const input = Number((pricing as Record<string, unknown>)['inputUsdPerMillion'])
+              const output = Number((pricing as Record<string, unknown>)['outputUsdPerMillion'])
+              if (Number.isFinite(input) && Number.isFinite(output)) {
+                out[model] = { inputUsdPerMillion: input, outputUsdPerMillion: output }
+              }
+            }
+            if (Object.keys(out).length > 0) {
+              runtimeModelPricing = out
+            }
+          }
+        } catch {
+          // Ignore malformed model pricing; fallback defaults are still emitted.
+        }
+      }
+      console.log(chalk.bold('Effective seller settings:'))
+      console.log(chalk.dim(`  provider: ${providerName}`))
+      console.log(
+        chalk.dim(
+          `  pricing defaults (USD/1M): input=${runtimeProviderPricing['ANTSEED_INPUT_USD_PER_MILLION']}, output=${runtimeProviderPricing['ANTSEED_OUTPUT_USD_PER_MILLION']}`
+        )
+      )
+      console.log(
+        chalk.dim(
+          `  enabled providers: ${effectiveSellerConfig.enabledProviders.length > 0 ? effectiveSellerConfig.enabledProviders.join(', ') : '(none)'}`
+        )
+      )
+      console.log(chalk.dim(`  reserve floor: ${effectiveSellerConfig.reserveFloor}`))
+      console.log(chalk.dim(`  max concurrent buyers: ${effectiveSellerConfig.maxConcurrentBuyers}`))
+      console.log('')
+
+      const nodeSpinner = ora('Starting seeding daemon...').start()
+
+      const node = new AntseedNode({
+        role: 'seller',
+        bootstrapNodes,
+        dataDir: globalOpts.dataDir,
+        payments: {
+          enabled: paymentsEnabled,
+          paymentMethod: preferredMethod,
+          platformFeeRate: config.payments.platformFeeRate,
+          settlementIdleMs: Number.isFinite(settlementIdleMs) ? settlementIdleMs : 30_000,
+          defaultEscrowAmountUSDC: defaultEscrowAmountUSDCBaseUnits,
+          sellerWalletAddress,
+          paymentConfig,
+        },
+      })
+
+      node.registerProvider(provider)
+
+      try {
+        await node.start()
+        nodeSpinner.succeed(chalk.green('Seeding active'))
+        console.log(chalk.dim(`  Peer ID: ${node.peerId ?? 'unknown'}`))
+        console.log(chalk.dim(`  DHT port: ${node.dhtPort}`))
+        console.log(chalk.dim(`  Signaling port: ${node.signalingPort}`))
+      } catch (err) {
+        nodeSpinner.fail(chalk.red(`Failed to start seeding: ${(err as Error).message}`))
+        process.exit(1)
+      }
+
+      // Write daemon state so dashboard and connect can discover this seeder
+      const startedAt = Date.now()
+      const syntheticSessionStarts = new Map<string, number>()
+      let stateWriteInFlight = false
+      let stateWritePending = false
+
+      function formatUptime(): string {
+        const ms = Date.now() - startedAt
+        const s = Math.floor(ms / 1000)
+        if (s < 60) return `${s}s`
+        const m = Math.floor(s / 60)
+        if (m < 60) return `${m}m ${s % 60}s`
+        const h = Math.floor(m / 60)
+        return `${h}h ${m % 60}m`
+      }
+
+      function buildDaemonState() {
+        const now = Date.now()
+        const cap = provider.getCapacity()
+        const trackedSessions = node
+          .getActiveSellerSessions()
+          .filter((session) => !session.settling)
+          .map((session) => ({
+            sessionId: session.sessionId,
+            buyerPeerId: session.buyerPeerId,
+            provider: session.provider,
+            startedAt: session.startedAt,
+            lastActivityAt: session.lastActivityAt,
+            totalRequests: session.totalRequests,
+            totalTokens: session.totalTokens,
+            avgLatencyMs: session.avgLatencyMs,
+          }))
+
+        const syntheticCount = Math.max(0, cap.current - trackedSessions.length)
+        const syntheticIds = new Set<string>()
+        const syntheticDetails: Array<{
+          sessionId: string
+          buyerPeerId: string
+          provider: string
+          startedAt: number
+          lastActivityAt: number
+          totalRequests: number
+          totalTokens: number
+          avgLatencyMs: number
+        }> = []
+
+        for (let i = 0; i < syntheticCount; i += 1) {
+          const sessionId = `provider-slot-${i + 1}`
+          syntheticIds.add(sessionId)
+
+          const existingStart = syntheticSessionStarts.get(sessionId)
+          const startedAtTs = typeof existingStart === 'number' ? existingStart : now
+          syntheticSessionStarts.set(sessionId, startedAtTs)
+
+          syntheticDetails.push({
+            sessionId,
+            buyerPeerId: 'unknown',
+            provider: providerName,
+            startedAt: startedAtTs,
+            lastActivityAt: now,
+            totalRequests: 0,
+            totalTokens: 0,
+            avgLatencyMs: 0,
+          })
+        }
+
+        for (const existingId of syntheticSessionStarts.keys()) {
+          if (!syntheticIds.has(existingId)) {
+            syntheticSessionStarts.delete(existingId)
+          }
+        }
+
+        const activeSessionDetails = [...trackedSessions, ...syntheticDetails]
+        const activeSessionsCount = Math.max(node.getActiveSellerSessionCount(), cap.current)
+
+        return {
+          state: 'seeding',
+          pid: process.pid,
+          peerId: node.peerId,
+          dhtPort: node.dhtPort,
+          signalingPort: node.signalingPort,
+          provider: providerName,
+          defaultInputUsdPerMillion: Number.isFinite(runtimeInputUsdPerMillion) ? runtimeInputUsdPerMillion : undefined,
+          defaultOutputUsdPerMillion: Number.isFinite(runtimeOutputUsdPerMillion) ? runtimeOutputUsdPerMillion : undefined,
+          providerPricing: {
+            [providerName]: {
+              defaults: {
+                inputUsdPerMillion: Number.isFinite(runtimeInputUsdPerMillion) ? runtimeInputUsdPerMillion : 0,
+                outputUsdPerMillion: Number.isFinite(runtimeOutputUsdPerMillion) ? runtimeOutputUsdPerMillion : 0,
+              },
+              ...(runtimeModelPricing ? { models: runtimeModelPricing } : {}),
+            },
+          },
+          startedAt,
+          // Fields the dashboard reads
+          peerCount: 0,
+          activeSessions: activeSessionsCount,
+          activeSessionDetails,
+          capacityUsedPercent: cap.max > 0 ? Math.round((cap.current / cap.max) * 100) : 0,
+          earningsToday: '0',
+          tokensToday: 0,
+          uptime: formatUptime(),
+          updatedAt: now,
+          proxyPort: null,
+        }
+      }
+
+      async function writeDaemonState(): Promise<void> {
+        if (stateWriteInFlight) {
+          stateWritePending = true
+          return
+        }
+
+        stateWriteInFlight = true
+        try {
+          await writeFile(STATE_FILE, JSON.stringify(buildDaemonState(), null, 2))
+        } finally {
+          stateWriteInFlight = false
+          if (stateWritePending) {
+            stateWritePending = false
+            await writeDaemonState()
+          }
+        }
+      }
+
+      function scheduleDaemonStateWrite(): void {
+        void writeDaemonState().catch(() => {})
+      }
+
+      await writeDaemonState()
+      node.on('connection', scheduleDaemonStateWrite)
+      node.on('session:updated', scheduleDaemonStateWrite)
+      node.on('session:finalized', scheduleDaemonStateWrite)
+
+      // Refresh state file every 1s so the desktop dashboard reflects live counters.
+      const stateInterval = setInterval(async () => {
+        await writeDaemonState().catch(() => {})
+      }, 1_000)
+
+      setupShutdownHandler(async () => {
+        clearInterval(stateInterval)
+        node.off('connection', scheduleDaemonStateWrite)
+        node.off('session:updated', scheduleDaemonStateWrite)
+        node.off('session:finalized', scheduleDaemonStateWrite)
+        nodeSpinner.start('Shutting down seeding daemon...')
+        await node.stop()
+        await unlink(STATE_FILE).catch(() => {})
+        nodeSpinner.succeed('Seeding daemon stopped. Sessions finalized.')
+      })
+    })
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,73 @@
+import type { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { getGlobalOptions } from './types.js';
+import { loadConfig } from '../../config/loader.js';
+import { resolveEffectiveSellerConfig } from '../../config/effective.js';
+import { getNodeStatus } from '../../status/node-status.js';
+import type { NodeStatus } from '../../status/node-status.js';
+import { formatEarnings, formatTokens } from '../formatters.js';
+
+/** Possible node states */
+export type NodeState = 'seeding' | 'connected' | 'idle';
+
+/**
+ * Register the `antseed status` command on the Commander program.
+ */
+export function registerStatusCommand(program: Command): void {
+  program
+    .command('status')
+    .description('Show current Antseed node status')
+    .option('--json', 'output as JSON', false)
+    .action(async (options) => {
+      try {
+        const globalOpts = getGlobalOptions(program);
+        const config = await loadConfig(globalOpts.config);
+        const effectiveSeller = resolveEffectiveSellerConfig({ config });
+        const status: NodeStatus = await getNodeStatus(config);
+
+        if (options.json) {
+          console.log(JSON.stringify(status, null, 2));
+          return;
+        }
+
+        // State badge
+        const stateColors: Record<NodeState, (s: string) => string> = {
+          seeding: chalk.green,
+          connected: chalk.cyan,
+          idle: chalk.gray,
+        };
+        const colorFn = stateColors[status.state] ?? chalk.white;
+        console.log(chalk.bold('Status: ') + colorFn(status.state.toUpperCase()));
+        console.log('');
+
+        // Summary table
+        const table = new Table({
+          head: [chalk.bold('Metric'), chalk.bold('Value')],
+          colWidths: [25, 35],
+        });
+
+        table.push(
+          ['Peers connected', chalk.cyan(String(status.peerCount))],
+          ['Earnings today', chalk.green(formatEarnings(status.earningsToday))],
+          ['Tokens today', formatTokens(status.tokensToday)],
+          ['Active sessions', String(status.activeSessions)],
+          ['Uptime', status.uptime],
+          ['Wallet address', status.walletAddress ?? chalk.dim('not configured')],
+          ['Proxy port', status.proxyPort ? String(status.proxyPort) : chalk.dim('n/a')],
+        );
+
+        if (status.state === 'seeding') {
+          table.push([
+            'Seller pricing defaults (USD/1M in/out)',
+            `${effectiveSeller.pricing.defaults.inputUsdPerMillion} / ${effectiveSeller.pricing.defaults.outputUsdPerMillion}`,
+          ]);
+        }
+
+        console.log(table.toString());
+      } catch (err) {
+        console.error(chalk.red(`Error: ${(err as Error).message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/cli/commands/types.ts

@@ -0,0 +1,56 @@
+import type { Command } from 'commander';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+/** All command registration functions follow this signature */
+export type RegisterCommandFn = (program: Command) => void;
+
+/** Global CLI options available to all commands */
+export interface GlobalOptions {
+  config: string;
+  dataDir: string;
+  verbose: boolean;
+}
+
+const NEW_HOME_DIR = join(homedir(), '.antseed');
+const NEW_CONFIG_PATH = join(NEW_HOME_DIR, 'config.json');
+
+function resolvePathWithHome(pathLike: string, fallbackAbsolutePath: string): string {
+  const raw = typeof pathLike === 'string' ? pathLike.trim() : '';
+  if (raw.length === 0) {
+    return fallbackAbsolutePath;
+  }
+  if (raw === '~') {
+    return homedir();
+  }
+  if (raw.startsWith('~/')) {
+    return join(homedir(), raw.slice(2));
+  }
+  return resolve(raw);
+}
+
+function isTruthyEnv(value: string | undefined): boolean {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+
+/**
+ * Extract global options from the Commander program instance.
+ */
+export function getGlobalOptions(program: Command): GlobalOptions {
+  const opts = program.opts();
+  const verbose = opts['verbose'] ?? false;
+  if (verbose || isTruthyEnv(process.env['ANTSEED_DEBUG'])) {
+    process.env['ANTSEED_DEBUG'] = '1';
+  }
+
+  const requestedConfig = resolvePathWithHome(opts['config'] ?? '~/.antseed/config.json', NEW_CONFIG_PATH);
+  const requestedDataDir = resolvePathWithHome(opts['dataDir'] ?? '~/.antseed', NEW_HOME_DIR);
+
+  return {
+    config: requestedConfig,
+    dataDir: requestedDataDir,
+    verbose,
+  };
+}

package/src/cli/commands/withdraw.ts

@@ -0,0 +1,61 @@
+import type { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getGlobalOptions } from './types.js';
+import { loadConfig } from '../../config/loader.js';
+import {
+  loadOrCreateIdentity,
+  BaseEscrowClient,
+  identityToEvmWallet,
+  identityToEvmAddress,
+} from '@antseed/node';
+
+export function registerWithdrawCommand(program: Command): void {
+  program
+    .command('withdraw <amount>')
+    .description('Withdraw USDC from the escrow contract (amount in human-readable USDC, e.g. "5" = 5 USDC)')
+    .action(async (amount: string) => {
+      const globalOpts = getGlobalOptions(program);
+      const config = await loadConfig(globalOpts.config);
+
+      const payments = config.payments;
+      if (!payments?.crypto) {
+        console.error(chalk.red('Error: No crypto payment configuration found.'));
+        console.error(chalk.dim('Configure payments.crypto in your config file or run: antseed init'));
+        process.exit(1);
+      }
+
+      const amountFloat = parseFloat(amount);
+      if (isNaN(amountFloat) || amountFloat <= 0) {
+        console.error(chalk.red('Error: Amount must be a positive number.'));
+        process.exit(1);
+      }
+
+      // Convert human-readable USDC to base units (6 decimals)
+      const amountBaseUnits = BigInt(Math.round(amountFloat * 1_000_000));
+
+      const identity = await loadOrCreateIdentity(globalOpts.dataDir);
+      const wallet = identityToEvmWallet(identity);
+      const address = identityToEvmAddress(identity);
+
+      const escrowClient = new BaseEscrowClient({
+        rpcUrl: payments.crypto.rpcUrl,
+        contractAddress: payments.crypto.escrowContractAddress,
+        usdcAddress: payments.crypto.usdcContractAddress,
+      });
+
+      console.log(chalk.dim(`Wallet: ${address}`));
+      console.log(chalk.dim(`Amount: ${amountFloat} USDC (${amountBaseUnits} base units)`));
+
+      const spinner = ora('Withdrawing USDC from escrow...').start();
+
+      try {
+        const txHash = await escrowClient.withdraw(wallet, amountBaseUnits);
+        spinner.succeed(chalk.green(`Withdrew ${amountFloat} USDC from escrow`));
+        console.log(chalk.dim(`Transaction: ${txHash}`));
+      } catch (err) {
+        spinner.fail(chalk.red(`Withdrawal failed: ${(err as Error).message}`));
+        process.exit(1);
+      }
+    });
+}