@antseed/cli 0.1.0

package/src/cli/commands/connect.test.ts

@@ -0,0 +1,69 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createDefaultConfig } from '../../config/defaults.js';
+import { resolveEffectiveBuyerConfig } from '../../config/effective.js';
+import {
+  buildBuyerRuntimeOverridesFromFlags,
+  buildBuyerBootstrapEntries,
+  buildRouterRuntimeEnvFromBuyerConfig,
+} from './connect.js';
+
+test('connect runtime overrides are runtime-only and win over env/config', () => {
+  const config = createDefaultConfig();
+  config.buyer.proxyPort = 7777;
+  config.buyer.maxPricing.defaults.inputUsdPerMillion = 50;
+  config.buyer.maxPricing.defaults.outputUsdPerMillion = 60;
+  const beforeResolution = JSON.parse(JSON.stringify(config));
+
+  const env = {
+    ANTSEED_BUYER_MAX_INPUT_USD_PER_MILLION: '70',
+    ANTSEED_BUYER_MAX_OUTPUT_USD_PER_MILLION: '80',
+  } as NodeJS.ProcessEnv;
+
+  const overrides = buildBuyerRuntimeOverridesFromFlags({
+    port: 9000,
+    maxInputUsdPerMillion: 90,
+    maxOutputUsdPerMillion: 95,
+  });
+
+  const effective = resolveEffectiveBuyerConfig({
+    config,
+    env,
+    buyerOverrides: overrides,
+  });
+
+  assert.equal(effective.proxyPort, 9000);
+  assert.equal(effective.maxPricing.defaults.inputUsdPerMillion, 90);
+  assert.equal(effective.maxPricing.defaults.outputUsdPerMillion, 95);
+  assert.deepEqual(config, beforeResolution);
+});
+
+test('connect maps effective buyer config into router runtime env keys', () => {
+  const config = createDefaultConfig();
+  config.buyer.minPeerReputation = 72;
+  config.buyer.preferredProviders = ['anthropic', 'openai'];
+  config.buyer.maxPricing.defaults.inputUsdPerMillion = 21;
+  config.buyer.maxPricing.defaults.outputUsdPerMillion = 63;
+
+  const runtimeEnv = buildRouterRuntimeEnvFromBuyerConfig(config.buyer);
+  assert.equal(runtimeEnv['ANTSEED_MIN_REPUTATION'], '72');
+  assert.equal(runtimeEnv['ANTSEED_PREFERRED_PROVIDERS'], 'anthropic,openai');
+
+  const parsed = JSON.parse(runtimeEnv['ANTSEED_MAX_PRICING_JSON'] ?? '{}') as {
+    defaults?: { inputUsdPerMillion?: number; outputUsdPerMillion?: number };
+  };
+  assert.equal(parsed.defaults?.inputUsdPerMillion, 21);
+  assert.equal(parsed.defaults?.outputUsdPerMillion, 63);
+});
+
+test('connect bootstrap entries use official nodes when config is empty and include local seeder first', () => {
+  const entries = buildBuyerBootstrapEntries([], 6881);
+  assert.equal(entries[0], '127.0.0.1:6881');
+  assert.ok(entries.length > 1);
+});
+
+test('connect bootstrap entries respect explicit configured nodes', () => {
+  const entries = buildBuyerBootstrapEntries(['10.0.0.2:6881'], 6889);
+  assert.equal(entries[0], '127.0.0.1:6889');
+  assert.deepEqual(entries.slice(1), ['10.0.0.2:6881']);
+});

package/src/cli/commands/connect.ts

@@ -0,0 +1,342 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import ora from 'ora'
+import { readFile } 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 { AntseedNode, BaseEscrowClient, loadOrCreateIdentity, identityToEvmAddress, getInstance } from '@antseed/node'
+import type { NodePaymentsConfig } from '@antseed/node'
+import { OFFICIAL_BOOTSTRAP_NODES, parseBootstrapList, toBootstrapConfig } from '@antseed/node/discovery'
+import { setupShutdownHandler } from '../shutdown.js'
+import { loadRouterPlugin, buildPluginConfig } from '../../plugins/loader.js'
+import { BuyerProxy } from '../../proxy/buyer-proxy.js'
+import { resolveEffectiveBuyerConfig, type BuyerRuntimeOverrides } from '../../config/effective.js'
+import type { BuyerCLIConfig } from '../../config/types.js'
+
+interface LocalSeederInfo {
+  dhtPort: number
+  signalingPort: number
+  pid: number
+}
+
+export function buildBuyerRuntimeOverridesFromFlags(options: {
+  port?: number
+  minPeerReputation?: number
+  preferredProviders?: string[]
+  maxInputUsdPerMillion?: number
+  maxOutputUsdPerMillion?: number
+}): BuyerRuntimeOverrides {
+  const overrides: BuyerRuntimeOverrides = {}
+  if (options.port !== undefined) {
+    overrides.proxyPort = options.port
+  }
+  if (options.minPeerReputation !== undefined) {
+    overrides.minPeerReputation = options.minPeerReputation
+  }
+  if (options.preferredProviders && options.preferredProviders.length > 0) {
+    overrides.preferredProviders = options.preferredProviders
+  }
+  if (options.maxInputUsdPerMillion !== undefined) {
+    overrides.maxInputUsdPerMillion = options.maxInputUsdPerMillion
+  }
+  if (options.maxOutputUsdPerMillion !== undefined) {
+    overrides.maxOutputUsdPerMillion = options.maxOutputUsdPerMillion
+  }
+  return overrides
+}
+
+export function buildRouterRuntimeEnvFromBuyerConfig(buyerConfig: BuyerCLIConfig): Record<string, string> {
+  const runtimeEnv: Record<string, string> = {
+    ANTSEED_MIN_REPUTATION: String(buyerConfig.minPeerReputation),
+    ANTSEED_MAX_PRICING_JSON: JSON.stringify(buyerConfig.maxPricing),
+  }
+  if (buyerConfig.preferredProviders.length > 0) {
+    runtimeEnv['ANTSEED_PREFERRED_PROVIDERS'] = buyerConfig.preferredProviders.join(',')
+  }
+  return runtimeEnv
+}
+
+export function buildBuyerBootstrapEntries(
+  configuredBootstrapNodes: string[] | undefined,
+  localSeederDhtPort?: number,
+): string[] {
+  const configured = Array.isArray(configuredBootstrapNodes)
+    ? configuredBootstrapNodes.filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+    : []
+
+  // Respect explicit user bootstrap config. If none is provided, keep default public bootstrap nodes.
+  const baseEntries = configured.length > 0
+    ? configured
+    : OFFICIAL_BOOTSTRAP_NODES.map((node) => `${node.host}:${node.port}`)
+
+  const entries = [...baseEntries]
+
+  if (Number.isFinite(localSeederDhtPort) && (localSeederDhtPort ?? 0) > 0) {
+    const localBootstrap = `127.0.0.1:${Math.floor(localSeederDhtPort as number)}`
+    if (!entries.includes(localBootstrap)) {
+      entries.unshift(localBootstrap)
+    }
+  }
+
+  return entries
+}
+
+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)
+  }
+}
+
+async function getLocalSeederInfo(): Promise<LocalSeederInfo | null> {
+  try {
+    const stateFile = join(homedir(), '.antseed', 'daemon.state.json')
+    const raw = await readFile(stateFile, 'utf-8')
+    const state = JSON.parse(raw) as { state?: string; dhtPort?: number; signalingPort?: number; pid?: number }
+    if (state.state === 'seeding' && state.dhtPort && state.pid) {
+      try {
+        process.kill(state.pid, 0)
+        const signalingPort = state.signalingPort ?? state.dhtPort
+        return { dhtPort: state.dhtPort, signalingPort, pid: state.pid }
+      } catch {
+        return null
+      }
+    }
+  } catch {
+    // No state file or unreadable
+  }
+  return null
+}
+
+export function registerConnectCommand(program: Command): void {
+  program
+    .command('connect')
+    .description('Start the buyer proxy and connect to sellers on the P2P network')
+    .option('-p, --port <number>', 'local proxy port', (v) => parseInt(v, 10))
+    .option('--router <name>', 'router plugin name or npm package')
+    .option('--instance <id>', 'use a configured plugin instance by ID')
+    .option('--max-input-usd-per-million <number>', 'runtime-only max input pricing override in USD per 1M tokens', parseFloat)
+    .option('--max-output-usd-per-million <number>', 'runtime-only max output pricing override in USD per 1M tokens', parseFloat)
+    .action(async (options) => {
+      const globalOpts = getGlobalOptions(program)
+      const config = await loadConfig(globalOpts.config)
+      const runtimeOverrides = buildBuyerRuntimeOverridesFromFlags({
+        port: options.port as number | undefined,
+        maxInputUsdPerMillion: options.maxInputUsdPerMillion as number | undefined,
+        maxOutputUsdPerMillion: options.maxOutputUsdPerMillion as number | undefined,
+      })
+      const effectiveBuyerConfig = resolveEffectiveBuyerConfig({
+        config,
+        buyerOverrides: runtimeOverrides,
+      })
+
+      let router
+      let toolHints: Array<{ name: string; envVar: string }> = []
+
+      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 !== 'router') {
+          console.error(chalk.red(`Instance "${options.instance}" is a ${instance.type}, not a router.`))
+          process.exit(1)
+        }
+        const spinner = ora(`Loading router plugin "${instance.package}"...`).start()
+        try {
+          const plugin = await loadRouterPlugin(instance.package)
+          const runtimeEnv = buildRouterRuntimeEnvFromBuyerConfig(effectiveBuyerConfig)
+          const pluginConfig = buildPluginConfig(plugin.configSchema ?? plugin.configKeys ?? [], runtimeEnv, instance.config as Record<string, string>)
+          router = await plugin.createRouter(pluginConfig)
+          spinner.succeed(chalk.green(`Router "${plugin.displayName}" loaded`))
+          toolHints = (plugin as any).TOOL_HINTS ?? []
+        } catch (err) {
+          spinner.fail(chalk.red(`Failed to load router: ${(err as Error).message}`))
+          process.exit(1)
+        }
+      } else if (options.router) {
+        const spinner = ora(`Loading router plugin "${options.router}"...`).start()
+        try {
+          const plugin = await loadRouterPlugin(options.router)
+          const runtimeEnv = buildRouterRuntimeEnvFromBuyerConfig(effectiveBuyerConfig)
+          const pluginConfig = buildPluginConfig(plugin.configSchema ?? plugin.configKeys ?? [], runtimeEnv)
+          router = await plugin.createRouter(pluginConfig)
+          spinner.succeed(chalk.green(`Router "${plugin.displayName}" loaded`))
+          toolHints = (plugin as any).TOOL_HINTS ?? []
+        } catch (err) {
+          spinner.fail(chalk.red(`Failed to load router: ${(err as Error).message}`))
+          process.exit(1)
+        }
+      } else {
+        console.error(chalk.red('Error: No router specified.'))
+        console.error(chalk.dim('Run: antseed connect --router <name>  or  antseed connect --instance <id>'))
+        process.exit(1)
+      }
+
+      // Auto-discover local seeder
+      const seederInfo = await getLocalSeederInfo()
+      const allBootstrapEntries = buildBuyerBootstrapEntries(
+        config.network?.bootstrapNodes,
+        seederInfo?.dhtPort,
+      )
+      const bootstrapNodes = toBootstrapConfig(parseBootstrapList(allBootstrapEntries))
+
+      const nodeSpinner = ora('Connecting to P2P network...').start()
+
+      // Build payment config from CLI config if available and reachable
+      let paymentsConfig: NodePaymentsConfig | undefined
+      const settlementEnv = parseOptionalBoolEnv(process.env['ANTSEED_ENABLE_SETTLEMENT'])
+      const crypto = config.payments?.crypto
+      let settlementEnabled = settlementEnv ?? Boolean(crypto)
+
+      if (settlementEnabled && crypto && settlementEnv !== true) {
+        const rpcUp = await isRpcReachable(crypto.rpcUrl)
+        if (!rpcUp) {
+          settlementEnabled = false
+          console.log(chalk.yellow(`Payments disabled: RPC node unreachable at ${crypto.rpcUrl}`))
+          console.log(chalk.dim('Start your chain node or set ANTSEED_ENABLE_SETTLEMENT=true to force-enable payments.'))
+        }
+      }
+
+      if (settlementEnabled && crypto) {
+        paymentsConfig = {
+          enabled: true,
+          rpcUrl: crypto.rpcUrl,
+          contractAddress: crypto.escrowContractAddress,
+          usdcAddress: crypto.usdcContractAddress,
+          defaultEscrowAmountUSDC: crypto.defaultLockAmountUSDC
+            ? String(Math.round(parseFloat(crypto.defaultLockAmountUSDC) * 1_000_000))
+            : '1000000',
+          platformFeeRate: config.payments.platformFeeRate,
+        }
+      }
+
+      console.log(chalk.bold('Effective buyer settings:'))
+      console.log(
+        chalk.dim(
+          `  preferred providers: ${effectiveBuyerConfig.preferredProviders.length > 0 ? effectiveBuyerConfig.preferredProviders.join(', ') : '(any)'}`
+        )
+      )
+      console.log(
+        chalk.dim(
+          `  max pricing defaults (USD/1M): input=${effectiveBuyerConfig.maxPricing.defaults.inputUsdPerMillion}, output=${effectiveBuyerConfig.maxPricing.defaults.outputUsdPerMillion}`
+        )
+      )
+      console.log(chalk.dim(`  min peer reputation: ${effectiveBuyerConfig.minPeerReputation}`))
+      console.log(chalk.dim(`  proxy port: ${effectiveBuyerConfig.proxyPort}`))
+      console.log('')
+
+      const node = new AntseedNode({
+        role: 'buyer',
+        bootstrapNodes,
+        allowPrivateIPs: true,
+        dataDir: globalOpts.dataDir,
+        payments: paymentsConfig,
+      })
+
+      node.setRouter(router)
+
+      try {
+        await node.start()
+        nodeSpinner.succeed(chalk.green('Connected to P2P network'))
+      } catch (err) {
+        nodeSpinner.fail(chalk.red(`Failed to connect: ${(err as Error).message}`))
+        process.exit(1)
+      }
+
+      // Display available USDC balance only if payments are active
+      if (paymentsConfig?.enabled && config.payments?.crypto) {
+        try {
+          const identity = await loadOrCreateIdentity(globalOpts.dataDir)
+          const address = identityToEvmAddress(identity)
+          const escrowClient = new BaseEscrowClient({
+            rpcUrl: config.payments.crypto.rpcUrl,
+            contractAddress: config.payments.crypto.escrowContractAddress,
+            usdcAddress: config.payments.crypto.usdcContractAddress,
+          })
+          const account = await escrowClient.getBuyerAccount(address)
+          console.log(chalk.dim(`Wallet: ${address}`))
+          const availUsdc = Number(account.available) / 1_000_000
+          console.log(chalk.dim(`Escrow available: ${availUsdc.toFixed(6)} USDC`))
+        } catch {
+          // Non-fatal — chain may not be available
+          console.log(chalk.dim('Payment balance unavailable (chain not reachable)'))
+        }
+      }
+
+      // Start the local HTTP proxy
+      const proxyPort = effectiveBuyerConfig.proxyPort
+      const proxySpinner = ora(`Starting local proxy on port ${proxyPort}...`).start()
+
+      const proxy = new BuyerProxy({
+        port: proxyPort,
+        node,
+      })
+
+      try {
+        await proxy.start()
+        proxySpinner.succeed(chalk.green(`Proxy listening on http://localhost:${proxyPort}`))
+      } catch (err) {
+        proxySpinner.fail(chalk.red(`Failed to start proxy: ${(err as Error).message}`))
+        await node.stop()
+        process.exit(1)
+      }
+
+      const proxyUrl = `http://localhost:${proxyPort}`
+      console.log('')
+
+      if (toolHints.length > 0) {
+        console.log(chalk.bold('Configure your tools:'))
+        for (const hint of toolHints) {
+          console.log(`  export ${hint.envVar}=${proxyUrl}   # ${hint.name}`)
+        }
+      } else {
+        console.log(chalk.bold('Configure your CLI tools:'))
+        console.log(`  export ANTHROPIC_BASE_URL=${proxyUrl}`)
+        console.log(`  export OPENAI_BASE_URL=${proxyUrl}`)
+      }
+      console.log('')
+      console.log(chalk.dim('Enable debug logs: export ANTSEED_DEBUG=1'))
+      console.log('')
+
+      setupShutdownHandler(async () => {
+        nodeSpinner.start('Shutting down...')
+        await proxy.stop()
+        await node.stop()
+        nodeSpinner.succeed('Disconnected. All sessions finalized.')
+      })
+    })
+}

package/src/cli/commands/dashboard.ts

@@ -0,0 +1,59 @@
+import type { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import open from 'open';
+import { getGlobalOptions } from './types.js';
+import { loadConfig } from '../../config/loader.js';
+import { createDashboardServer } from 'antseed-dashboard';
+import type { DashboardServer } from 'antseed-dashboard';
+import { setupShutdownHandler } from '../shutdown.js';
+
+const DEFAULT_DASHBOARD_PORT = 3117;
+
+/**
+ * Register the `antseed dashboard` command on the Commander program.
+ */
+export function registerDashboardCommand(program: Command): void {
+  program
+    .command('dashboard')
+    .description('Start the web dashboard for monitoring and configuration')
+    .option('-p, --port <number>', 'dashboard port', (v) => parseInt(v, 10), DEFAULT_DASHBOARD_PORT)
+    .option('--no-open', 'do not open browser automatically')
+    .action(async (options) => {
+      const globalOpts = getGlobalOptions(program);
+      const config = await loadConfig(globalOpts.config);
+
+      const port = (options.port ?? DEFAULT_DASHBOARD_PORT) as number;
+      const spinner = ora('Starting dashboard server...').start();
+
+      let server: DashboardServer;
+      try {
+        server = await createDashboardServer(
+          config as unknown as Parameters<typeof createDashboardServer>[0],
+          port,
+          { configPath: globalOpts.config }
+        );
+        await server.start();
+        spinner.succeed(chalk.green('Dashboard running'));
+      } catch (err) {
+        spinner.fail(chalk.red(`Failed to start dashboard: ${(err as Error).message}`));
+        process.exit(1);
+      }
+
+      const url = `http://localhost:${port}`;
+      console.log('');
+      console.log(chalk.bold('Dashboard: ') + chalk.cyan(url));
+      console.log(chalk.dim('Press Ctrl+C to stop'));
+      console.log('');
+
+      if (options.open !== false) {
+        await open(url);
+      }
+
+      setupShutdownHandler(async () => {
+        spinner.start('Stopping dashboard server...');
+        await server.stop();
+        spinner.succeed('Dashboard stopped.');
+      });
+    });
+}

package/src/cli/commands/deposit.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 registerDepositCommand(program: Command): void {
+  program
+    .command('deposit <amount>')
+    .description('Deposit USDC into 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('Depositing USDC into escrow...').start();
+
+      try {
+        const txHash = await escrowClient.deposit(wallet, amountBaseUnits);
+        spinner.succeed(chalk.green(`Deposited ${amountFloat} USDC into escrow`));
+        console.log(chalk.dim(`Transaction: ${txHash}`));
+      } catch (err) {
+        spinner.fail(chalk.red(`Deposit failed: ${(err as Error).message}`));
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/dev.ts

@@ -0,0 +1,107 @@
+import type { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import crypto from 'node:crypto';
+import { getGlobalOptions } from './types.js';
+import { loadConfig } from '../../config/loader.js';
+import { AntseedNode } from '@antseed/node';
+import { DHTNode } from '@antseed/node/discovery';
+import { toPeerId } from '@antseed/node';
+import { parseBootstrapList, toBootstrapConfig } from '@antseed/node/discovery';
+import { setupShutdownHandler } from '../shutdown.js';
+
+export function registerDevCommand(program: Command): void {
+  program
+    .command('dev')
+    .description('Run seller + buyer locally for development and testing')
+    .option('-p, --port <number>', 'buyer proxy port', (v) => parseInt(v, 10))
+    .action(async (options) => {
+      const globalOpts = getGlobalOptions(program);
+      const config = await loadConfig(globalOpts.config);
+
+      if (options.port !== undefined) {
+        config.buyer.proxyPort = options.port as number;
+      }
+
+      const spinner = ora('Starting local network...').start();
+
+      // 1. Create and start local bootstrap DHT node
+      const bootstrapPeerId = toPeerId(crypto.randomBytes(32).toString('hex'));
+      const bootstrapDht = new DHTNode({
+        peerId: bootstrapPeerId,
+        port: 0,
+        bootstrapNodes: [],
+        reannounceIntervalMs: 60_000,
+        operationTimeoutMs: 10_000,
+      });
+
+      try {
+        await bootstrapDht.start();
+      } catch (err) {
+        spinner.fail(chalk.red(`Failed to start local DHT: ${(err as Error).message}`));
+        process.exit(1);
+      }
+
+      const bootstrapPort = bootstrapDht.getPort();
+      spinner.text = 'Starting seller node...';
+
+      // 2. Bootstrap config pointing at local node
+      const localBootstrap = toBootstrapConfig(parseBootstrapList([`127.0.0.1:${bootstrapPort}`]));
+
+      // 3. Start seller node
+      const seller = new AntseedNode({
+        role: 'seller',
+        bootstrapNodes: localBootstrap,
+      });
+
+      try {
+        await seller.start();
+      } catch (err) {
+        await bootstrapDht.stop();
+        spinner.fail(chalk.red(`Failed to start seller: ${(err as Error).message}`));
+        process.exit(1);
+      }
+
+      spinner.text = 'Starting buyer node...';
+
+      // 4. Start buyer node
+      const buyer = new AntseedNode({
+        role: 'buyer',
+        bootstrapNodes: localBootstrap,
+      });
+
+      try {
+        await buyer.start();
+      } catch (err) {
+        await seller.stop();
+        await bootstrapDht.stop();
+        spinner.fail(chalk.red(`Failed to start buyer proxy: ${(err as Error).message}`));
+        process.exit(1);
+      }
+
+      spinner.succeed(chalk.green('Dev mode running (local network)'));
+
+      const proxyUrl = `http://localhost:${config.buyer.proxyPort}`;
+
+      console.log('');
+      console.log(chalk.bold('Proxy running at: ') + chalk.cyan(proxyUrl));
+      console.log(chalk.dim(`Local DHT bootstrap on port ${bootstrapPort}`));
+      console.log('');
+      console.log(chalk.bold('Configure your CLI tools:'));
+      console.log(chalk.dim('  # Anthropic (Claude Code)'));
+      console.log(`  export ANTHROPIC_BASE_URL=${proxyUrl}`);
+      console.log(chalk.dim('  # OpenAI (Codex)'));
+      console.log(`  export OPENAI_BASE_URL=${proxyUrl}`);
+      console.log(chalk.dim('  # Google'));
+      console.log(`  export GOOGLE_API_BASE_URL=${proxyUrl}`);
+      console.log('');
+
+      setupShutdownHandler(async () => {
+        spinner.start('Shutting down dev environment...');
+        await buyer.stop();
+        await seller.stop();
+        await bootstrapDht.stop();
+        spinner.succeed('Dev environment stopped.');
+      });
+    });
+}