@antseed/cli 0.1.0 → 0.1.1

package/src/cli/commands/config.ts

@@ -1,271 +0,0 @@
-import type { Command } from 'commander';
-import chalk from 'chalk';
-import { getGlobalOptions } from './types.js';
-import { loadConfig, saveConfig } from '../../config/loader.js';
-import type { AntseedConfig, ProviderConfig, ProviderType } from '../../config/types.js';
-import { assertValidConfig } from '../../config/validation.js';
-
-/**
- * Register the `antseed config` command and its subcommands.
- */
-export function registerConfigCommand(program: Command): void {
-  const configCmd = program
-    .command('config')
-    .description('Manage Antseed configuration');
-
-  // antseed config show
-  configCmd
-    .command('show')
-    .description('Display current configuration (credentials redacted)')
-    .action(async () => {
-      const globalOpts = getGlobalOptions(program);
-      const config = await loadConfig(globalOpts.config);
-      const redacted = redactConfig(config);
-      console.log(JSON.stringify(redacted, null, 2));
-    });
-
-  // antseed config set <key> <value>
-  configCmd
-    .command('set <key> <value>')
-    .description('Set a configuration value (e.g., seller.reserveFloor 20)')
-    .action(async (key: string, value: string) => {
-      try {
-        const globalOpts = getGlobalOptions(program);
-        const config = await loadConfig(globalOpts.config);
-        const validKeys = getValidConfigKeys(config);
-        if (!validKeys.includes(key)) {
-          console.error(chalk.red(`Invalid config key: ${key}`));
-          console.error(chalk.dim(`Available keys: ${validKeys.join(', ')}`));
-          process.exitCode = 1;
-          return;
-        }
-        setConfigValue(config as unknown as Record<string, unknown>, key, value);
-        assertValidConfig(config);
-        await saveConfig(globalOpts.config, config);
-        console.log(chalk.green(`Set ${key} = ${value}`));
-      } catch (err) {
-        console.error(chalk.red(`Error: ${(err as Error).message}`));
-        process.exitCode = 1;
-      }
-    });
-
-  const sellerCmd = configCmd
-    .command('seller')
-    .description('Role-scoped seller configuration commands');
-
-  sellerCmd
-    .command('show')
-    .description('Display seller configuration')
-    .action(async () => {
-      const globalOpts = getGlobalOptions(program);
-      const config = await loadConfig(globalOpts.config);
-      console.log(JSON.stringify(config.seller, null, 2));
-    });
-
-  sellerCmd
-    .command('set <key> <value>')
-    .description('Set seller configuration value (e.g., pricing.defaults.inputUsdPerMillion 12)')
-    .action(async (key: string, value: string) => {
-      await setRoleScopedValue(program, 'seller', key, value);
-    });
-
-  const buyerCmd = configCmd
-    .command('buyer')
-    .description('Role-scoped buyer configuration commands');
-
-  buyerCmd
-    .command('show')
-    .description('Display buyer configuration')
-    .action(async () => {
-      const globalOpts = getGlobalOptions(program);
-      const config = await loadConfig(globalOpts.config);
-      console.log(JSON.stringify(config.buyer, null, 2));
-    });
-
-  buyerCmd
-    .command('set <key> <value>')
-    .description('Set buyer configuration value (e.g., preferredProviders [\"anthropic\",\"openai\"])')
-    .action(async (key: string, value: string) => {
-      await setRoleScopedValue(program, 'buyer', key, value);
-    });
-
-  // antseed config add-provider
-  configCmd
-    .command('add-provider')
-    .description('Add a new provider credential')
-    .requiredOption('-t, --type <type>', 'provider type (anthropic, openai, google, moonshot)')
-    .requiredOption('-k, --key <key>', 'API key or auth token')
-    .option('-e, --endpoint <url>', 'custom API endpoint URL')
-    .action(async (options) => {
-      const knownTypes = ['anthropic', 'openai', 'google', 'moonshot'];
-      if (!knownTypes.includes(options.type as string)) {
-        console.error(chalk.red(`Unknown provider type: ${options.type as string}`));
-        console.error(chalk.dim(`Known types: ${knownTypes.join(', ')}`));
-        process.exitCode = 1;
-        return;
-      }
-      const globalOpts = getGlobalOptions(program);
-      const config = await loadConfig(globalOpts.config);
-      const provider = buildProviderConfig(
-        options.type as ProviderType,
-        options.key as string,
-        options.endpoint as string | undefined
-      );
-      config.providers.push(provider);
-      await saveConfig(globalOpts.config, config);
-      console.log(chalk.green(`Added ${options.type as string} provider`));
-    });
-
-  // antseed config remove-provider <type>
-  configCmd
-    .command('remove-provider <type>')
-    .description('Remove a provider credential by type')
-    .action(async (type: string) => {
-      const globalOpts = getGlobalOptions(program);
-      const config = await loadConfig(globalOpts.config);
-      const before = config.providers.length;
-      config.providers = config.providers.filter((p) => p.type !== type);
-      const removed = before - config.providers.length;
-      await saveConfig(globalOpts.config, config);
-      if (removed > 0) {
-        console.log(chalk.green(`Removed ${removed} ${type} provider(s)`));
-      } else {
-        console.log(chalk.yellow(`No ${type} provider found`));
-      }
-    });
-
-  // antseed config init
-  configCmd
-    .command('init')
-    .description('Initialize a new config file with defaults')
-    .action(async () => {
-      const globalOpts = getGlobalOptions(program);
-      const { createDefaultConfig } = await import('../../config/defaults.js');
-      const config = createDefaultConfig();
-      await saveConfig(globalOpts.config, config);
-      console.log(chalk.green(`Config initialized at ${globalOpts.config}`));
-    });
-}
-
-/**
- * Redact sensitive fields (auth values) from config for display.
- */
-export function redactConfig(config: AntseedConfig): Record<string, unknown> {
-  const clone = JSON.parse(JSON.stringify(config)) as Record<string, unknown>;
-  const providers = clone['providers'] as Array<Record<string, unknown>> | undefined;
-  for (const provider of providers ?? []) {
-    if (provider['authValue']) {
-      const val = provider['authValue'] as string;
-      provider['authValue'] = val.slice(0, 8) + '...' + val.slice(-4);
-    }
-  }
-
-  return clone;
-}
-
-/**
- * Set a nested config value by dot-separated key path.
- * @example setConfigValue(config, 'seller.reserveFloor', '20')
- */
-export function setConfigValue(config: Record<string, unknown>, key: string, value: string): void {
-  const parts = key.split('.');
-  let current: Record<string, unknown> = config;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i]!;
-    if (typeof current[part] !== 'object' || current[part] === null) {
-      throw new Error(`Invalid config key: ${key}`);
-    }
-    current = current[part] as Record<string, unknown>;
-  }
-  const lastKey = parts[parts.length - 1]!;
-  const trimmed = value.trim();
-
-  if (
-    (trimmed.startsWith('{') && trimmed.endsWith('}')) ||
-    (trimmed.startsWith('[') && trimmed.endsWith(']'))
-  ) {
-    try {
-      current[lastKey] = JSON.parse(trimmed) as unknown;
-      return;
-    } catch {
-      throw new Error(`Invalid JSON value for ${key}`);
-    }
-  }
-
-  // Auto-parse numeric scalars
-  const numVal = Number(trimmed);
-  current[lastKey] = Number.isNaN(numVal) ? value : numVal;
-}
-
-function getValidConfigKeys(config: AntseedConfig, prefix = ''): string[] {
-  const keys: string[] = [];
-  for (const [k, v] of Object.entries(config)) {
-    if (k === 'providers' || k === 'plugins') continue;
-    const path = prefix ? `${prefix}.${k}` : k;
-    if (v && typeof v === 'object' && !Array.isArray(v)) {
-      keys.push(...getValidConfigKeys(v as unknown as AntseedConfig, path));
-    } else {
-      keys.push(path);
-    }
-  }
-  return keys;
-}
-
-async function setRoleScopedValue(
-  program: Command,
-  role: 'seller' | 'buyer',
-  key: string,
-  value: string,
-): Promise<void> {
-  try {
-    const globalOpts = getGlobalOptions(program);
-    const config = await loadConfig(globalOpts.config);
-    const fullKey = `${role}.${key}`;
-    const validKeys = getValidConfigKeys(config);
-    if (!validKeys.includes(fullKey)) {
-      console.error(chalk.red(`Invalid ${role} config key: ${key}`));
-      const scopedKeys = validKeys
-        .filter((path) => path.startsWith(`${role}.`))
-        .map((path) => path.slice(role.length + 1));
-      console.error(chalk.dim(`Available ${role} keys: ${scopedKeys.join(', ')}`));
-      process.exitCode = 1;
-      return;
-    }
-    setConfigValue(config as unknown as Record<string, unknown>, fullKey, value);
-    assertValidConfig(config);
-    await saveConfig(globalOpts.config, config);
-    console.log(chalk.green(`Set ${fullKey} = ${value}`));
-  } catch (err) {
-    console.error(chalk.red(`Error: ${(err as Error).message}`));
-    process.exitCode = 1;
-  }
-}
-
-/**
- * Build a ProviderConfig with default endpoint and auth header for known providers.
- */
-export function buildProviderConfig(
-  type: ProviderType,
-  authValue: string,
-  customEndpoint?: string
-): ProviderConfig {
-  const defaults: Record<string, { endpoint: string; authHeaderName: string }> = {
-    anthropic: { endpoint: 'https://api.anthropic.com', authHeaderName: 'x-api-key' },
-    openai: { endpoint: 'https://api.openai.com', authHeaderName: 'Authorization' },
-    google: { endpoint: 'https://generativelanguage.googleapis.com', authHeaderName: 'x-goog-api-key' },
-    moonshot: { endpoint: 'https://api.moonshot.cn', authHeaderName: 'Authorization' },
-  };
-
-  const fallbackDefaults = {
-    endpoint: customEndpoint ?? '',
-    authHeaderName: 'Authorization',
-  };
-  const def = defaults[type] ?? fallbackDefaults;
-
-  return {
-    type,
-    endpoint: customEndpoint ?? def.endpoint,
-    authHeaderName: def.authHeaderName,
-    authValue,
-  };
-}

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

@@ -1,69 +0,0 @@
-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

@@ -1,342 +0,0 @@
-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.')
-      })
-    })
-}