@antseed/cli 0.1.0 → 0.1.2

package/src/cli/commands/profile.ts

@@ -1,95 +0,0 @@
-import type { Command } from 'commander';
-import chalk from 'chalk';
-
-/**
- * Register the `antseed profile` command and its subcommands.
- */
-export function registerProfileCommand(program: Command): void {
-  const profile = program
-    .command('profile')
-    .description('Manage your peer profile');
-
-  profile
-    .command('show')
-    .description('Display your current profile')
-    .action(async () => {
-      const { readFile } = await import('node:fs/promises');
-      const { join } = await import('node:path');
-      const { homedir } = await import('node:os');
-
-      const profilePath = join(homedir(), '.antseed', 'profile.json');
-      try {
-        const data = await readFile(profilePath, 'utf-8');
-        const prof = JSON.parse(data);
-        console.log(chalk.bold('Peer Profile'));
-        console.log(chalk.dim('\u2500'.repeat(40)));
-        console.log(`  Name:         ${chalk.cyan(prof.displayName)}`);
-        console.log(`  Description:  ${prof.description}`);
-        console.log(`  Tags:         ${(prof.tags || []).join(', ')}`);
-        console.log(`  Capabilities: ${(prof.capabilities || []).join(', ')}`);
-        console.log(`  Region:       ${prof.region}`);
-        console.log(`  Languages:    ${(prof.languages || []).join(', ')}`);
-        if (prof.website) console.log(`  Website:      ${prof.website}`);
-        console.log(`  Created:      ${new Date(prof.createdAt).toISOString()}`);
-        console.log(`  Updated:      ${new Date(prof.updatedAt).toISOString()}`);
-      } catch {
-        console.log(chalk.yellow('No profile found. Use "antseed profile set" to create one.'));
-      }
-    });
-
-  profile
-    .command('set')
-    .description('Create or update your profile')
-    .requiredOption('--name <name>', 'Display name')
-    .option('--description <desc>', 'Description of what you offer', '')
-    .option('--tags <tags>', 'Comma-separated tags', '')
-    .option('--capabilities <caps>', 'Comma-separated capabilities (inference,agent,skill,tool)', 'inference')
-    .option('--region <region>', 'Region', 'unknown')
-    .option('--languages <langs>', 'Comma-separated languages', 'en')
-    .option('--website <url>', 'Website URL')
-    .action(async (options) => {
-      const { writeFile, mkdir, readFile } = await import('node:fs/promises');
-      const { join } = await import('node:path');
-      const { homedir } = await import('node:os');
-
-      const dir = join(homedir(), '.antseed');
-      await mkdir(dir, { recursive: true });
-      const profilePath = join(dir, 'profile.json');
-
-      let existing: Record<string, unknown> = {};
-      try {
-        existing = JSON.parse(await readFile(profilePath, 'utf-8'));
-      } catch {}
-
-      const now = Date.now();
-      const prof = {
-        ...existing,
-        displayName: options.name,
-        description: options.description || existing.description || '',
-        tags: options.tags ? options.tags.split(',').map((t: string) => t.trim()) : existing.tags || [],
-        capabilities: options.capabilities.split(',').map((c: string) => c.trim()),
-        region: options.region,
-        languages: options.languages.split(',').map((l: string) => l.trim()),
-        website: options.website || existing.website,
-        createdAt: existing.createdAt || now,
-        updatedAt: now,
-      };
-
-      await writeFile(profilePath, JSON.stringify(prof, null, 2));
-      console.log(chalk.green('Profile saved successfully.'));
-    });
-}
-
-/**
- * Register the `antseed peer <peerId>` command.
- */
-export function registerPeerCommand(program: Command): void {
-  program
-    .command('peer')
-    .description('View a peer\'s profile')
-    .argument('<peerId>', 'Peer ID (hex)')
-    .action(async (peerId: string) => {
-      console.log(chalk.bold(`Peer: ${peerId.slice(0, 16)}...`));
-      console.log(chalk.yellow('Connect to the network first to view peer details.'));
-    });
-}

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

@@ -1,70 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { createDefaultConfig } from '../../config/defaults.js';
-import { resolveEffectiveSellerConfig } from '../../config/effective.js';
-import {
-  buildSellerRuntimeOverridesFromFlags,
-  buildSellerPluginRuntimeEnv,
-} from './seed.js';
-
-test('seed runtime overrides are runtime-only and win over env/config', () => {
-  const config = createDefaultConfig();
-  config.seller.reserveFloor = 11;
-  config.seller.pricing.defaults.inputUsdPerMillion = 12;
-  config.seller.pricing.defaults.outputUsdPerMillion = 18;
-  const beforeResolution = JSON.parse(JSON.stringify(config));
-
-  const env = {
-    ANTSEED_SELLER_INPUT_USD_PER_MILLION: '20',
-  } as NodeJS.ProcessEnv;
-
-  const overrides = buildSellerRuntimeOverridesFromFlags({
-    reserve: 33,
-    inputUsdPerMillion: 44,
-    outputUsdPerMillion: 55,
-  });
-
-  const effective = resolveEffectiveSellerConfig({
-    config,
-    env,
-    sellerOverrides: overrides,
-  });
-
-  assert.equal(effective.reserveFloor, 33);
-  assert.equal(effective.pricing.defaults.inputUsdPerMillion, 44);
-  assert.equal(effective.pricing.defaults.outputUsdPerMillion, 55);
-  assert.deepEqual(config, beforeResolution);
-});
-
-test('seed maps effective seller pricing into provider runtime keys', () => {
-  const config = createDefaultConfig();
-  config.seller.maxConcurrentBuyers = 17;
-  config.seller.pricing.defaults.inputUsdPerMillion = 10;
-  config.seller.pricing.defaults.outputUsdPerMillion = 20;
-  config.seller.pricing.providers = {
-    anthropic: {
-      defaults: {
-        inputUsdPerMillion: 15,
-        outputUsdPerMillion: 35,
-      },
-      models: {
-        'claude-sonnet-4-5-20250929': {
-          inputUsdPerMillion: 18,
-          outputUsdPerMillion: 42,
-        },
-      },
-    },
-  };
-
-  const runtimeEnv = buildSellerPluginRuntimeEnv(config.seller, 'anthropic');
-  assert.equal(runtimeEnv['ANTSEED_INPUT_USD_PER_MILLION'], '15');
-  assert.equal(runtimeEnv['ANTSEED_OUTPUT_USD_PER_MILLION'], '35');
-  assert.equal(runtimeEnv['ANTSEED_MAX_CONCURRENCY'], '17');
-
-  const models = JSON.parse(runtimeEnv['ANTSEED_MODEL_PRICING_JSON'] ?? '{}') as Record<string, {
-    inputUsdPerMillion: number;
-    outputUsdPerMillion: number;
-  }>;
-  assert.equal(models['claude-sonnet-4-5-20250929']?.inputUsdPerMillion, 18);
-  assert.equal(models['claude-sonnet-4-5-20250929']?.outputUsdPerMillion, 42);
-});

package/src/cli/commands/seed.ts

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

@@ -1,73 +0,0 @@
-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;
-      }
-    });
-}