@antseed/cli 0.1.0

package/src/cli/formatters.ts

@@ -0,0 +1,64 @@
+import chalk from 'chalk';
+
+/**
+ * Format a USD earnings string with a dollar sign and green color.
+ * @param amountUSD - Amount as string (e.g., "1.234567")
+ * @returns Formatted string like "$1.23"
+ */
+export function formatEarnings(amountUSD: string): string {
+  const num = parseFloat(amountUSD);
+  return chalk.green(`$${num.toFixed(2)}`);
+}
+
+/**
+ * Format a token count with K/M suffix.
+ * @param tokens - Number of tokens
+ * @returns Formatted string like "1.5K" or "2.3M"
+ */
+export function formatTokens(tokens: number): string {
+  if (tokens >= 1_000_000) {
+    return `${(tokens / 1_000_000).toFixed(1)}M`;
+  }
+  if (tokens >= 1_000) {
+    return `${(tokens / 1_000).toFixed(1)}K`;
+  }
+  return String(tokens);
+}
+
+/**
+ * Format a capacity usage percentage with color coding.
+ * Green < 50%, Yellow 50-80%, Red > 80%
+ */
+export function formatCapacity(percent: number): string {
+  const label = `${percent.toFixed(0)}%`;
+  if (percent < 50) return chalk.green(label);
+  if (percent < 80) return chalk.yellow(label);
+  return chalk.red(label);
+}
+
+/**
+ * Format a duration in milliseconds to a human-readable string.
+ * @param ms - Duration in milliseconds
+ * @returns String like "2h 15m" or "45s" or "3d 1h"
+ */
+export function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ${minutes % 60}m`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ${hours % 24}h`;
+}
+
+/**
+ * Format a reputation score (0-1) with color coding.
+ * Green >= 0.8, Yellow >= 0.5, Red < 0.5
+ */
+export function formatReputation(score: number): string {
+  const label = `${(score * 100).toFixed(0)}%`;
+  if (score >= 0.8) return chalk.green(label);
+  if (score >= 0.5) return chalk.yellow(label);
+  return chalk.red(label);
+}

package/src/cli/index.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { loadEnvFromFiles } from '../env/load-env.js';
+import { registerSeedCommand } from './commands/seed.js';
+import { registerConnectCommand } from './commands/connect.js';
+import { registerStatusCommand } from './commands/status.js';
+import { registerConfigCommand } from './commands/config.js';
+import { registerDashboardCommand } from './commands/dashboard.js';
+import { registerDevCommand } from './commands/dev.js';
+import { registerBrowseCommand } from './commands/browse.js';
+import { registerInitCommand } from './commands/init.js';
+import { registerPluginCommand } from './commands/plugin.js';
+import { registerProfileCommand, registerPeerCommand } from './commands/profile.js';
+import { registerDepositCommand } from './commands/deposit.js';
+import { registerWithdrawCommand } from './commands/withdraw.js';
+import { registerBalanceCommand } from './commands/balance.js';
+
+loadEnvFromFiles();
+
+const program = new Command();
+
+program
+  .name('antseed')
+  .description('P2P marketplace for reselling idle LLM plan capacity')
+  .version('0.1.0')
+  .option('-c, --config <path>', 'path to config file', '~/.antseed/config.json')
+  .option('--data-dir <path>', 'path to node identity/state directory', '~/.antseed')
+  .option('-v, --verbose', 'enable verbose logging', false);
+
+registerSeedCommand(program);
+registerConnectCommand(program);
+registerStatusCommand(program);
+registerConfigCommand(program);
+registerDashboardCommand(program);
+registerDevCommand(program);
+registerBrowseCommand(program);
+registerInitCommand(program);
+registerPluginCommand(program);
+registerProfileCommand(program);
+registerPeerCommand(program);
+registerDepositCommand(program);
+registerWithdrawCommand(program);
+registerBalanceCommand(program);
+
+program.parse(process.argv);

package/src/cli/shutdown.ts

@@ -0,0 +1,38 @@
+type ShutdownCallback = () => Promise<void>;
+
+let shutdownCallbacks: ShutdownCallback[] = [];
+let isShuttingDown = false;
+
+/**
+ * Register a callback to be called on shutdown (SIGINT/SIGTERM).
+ * Multiple callbacks are called in LIFO order (last registered = first called).
+ * The process exits after all callbacks complete.
+ *
+ * @param callback - Async function to run during shutdown
+ */
+export function setupShutdownHandler(callback: ShutdownCallback): void {
+  shutdownCallbacks.push(callback);
+
+  // Only register signal handlers once
+  if (shutdownCallbacks.length === 1) {
+    const handler = async () => {
+      if (isShuttingDown) return; // Prevent double-shutdown
+      isShuttingDown = true;
+
+      // Execute callbacks in LIFO order
+      const callbacks = [...shutdownCallbacks].reverse();
+      for (const cb of callbacks) {
+        try {
+          await cb();
+        } catch (err) {
+          console.error('Shutdown error:', (err as Error).message);
+        }
+      }
+
+      process.exit(0);
+    };
+
+    process.on('SIGINT', handler);
+    process.on('SIGTERM', handler);
+  }
+}

package/src/config/defaults.ts

@@ -0,0 +1,49 @@
+import type { AntseedConfig } from './types.js';
+
+/**
+ * Create a default Antseed configuration with sensible defaults.
+ */
+export function createDefaultConfig(): AntseedConfig {
+  return {
+    identity: {
+      displayName: 'Antseed Node',
+    },
+    providers: [],
+    seller: {
+      reserveFloor: 10,
+      maxConcurrentBuyers: 5,
+      enabledProviders: [],
+      pricing: {
+        defaults: {
+          inputUsdPerMillion: 10,
+          outputUsdPerMillion: 10,
+        },
+      },
+    },
+    buyer: {
+      preferredProviders: ['anthropic', 'openai', 'claude-code', 'claude-oauth', 'openrouter', 'local-llm'],
+      maxPricing: {
+        defaults: {
+          inputUsdPerMillion: 100,
+          outputUsdPerMillion: 100,
+        },
+      },
+      minPeerReputation: 50,
+      proxyPort: 8377,
+    },
+    payments: {
+      preferredMethod: 'crypto',
+      platformFeeRate: 0.05,
+      crypto: {
+        chainId: 'base-local',
+        rpcUrl: 'http://127.0.0.1:8545',
+        escrowContractAddress: '0x5FbDB2315678afecb367f032d93F642f64180aa3',
+        usdcContractAddress: '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512',
+        defaultLockAmountUSDC: '1',
+      },
+    },
+    network: {
+      bootstrapNodes: [],
+    },
+  };
+}

package/src/config/effective.test.ts

@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createDefaultConfig } from './defaults.js';
+import {
+  resolveEffectiveBuyerConfig,
+  resolveEffectiveRoleConfig,
+  resolveEffectiveSellerConfig,
+} from './effective.js';
+
+test('effective seller config precedence is flags > env > config > defaults', () => {
+  const config = createDefaultConfig();
+  config.seller.pricing.defaults.inputUsdPerMillion = 10;
+  config.seller.pricing.defaults.outputUsdPerMillion = 20;
+
+  const env = {
+    ANTSEED_SELLER_INPUT_USD_PER_MILLION: '30',
+    ANTSEED_SELLER_OUTPUT_USD_PER_MILLION: '40',
+  } as NodeJS.ProcessEnv;
+
+  const effective = resolveEffectiveSellerConfig({
+    config,
+    env,
+    sellerOverrides: {
+      inputUsdPerMillion: 50,
+    },
+  });
+
+  assert.equal(effective.pricing.defaults.inputUsdPerMillion, 50);
+  assert.equal(effective.pricing.defaults.outputUsdPerMillion, 40);
+});
+
+test('effective buyer config precedence is flags > env > config > defaults', () => {
+  const config = createDefaultConfig();
+  config.buyer.minPeerReputation = 25;
+  config.buyer.maxPricing.defaults.inputUsdPerMillion = 70;
+  config.buyer.maxPricing.defaults.outputUsdPerMillion = 80;
+
+  const env = {
+    ANTSEED_BUYER_MIN_REPUTATION: '45',
+    ANTSEED_BUYER_PREFERRED_PROVIDERS: 'openai,anthropic',
+    ANTSEED_BUYER_MAX_INPUT_USD_PER_MILLION: '90',
+    ANTSEED_BUYER_MAX_OUTPUT_USD_PER_MILLION: '95',
+  } as NodeJS.ProcessEnv;
+
+  const effective = resolveEffectiveBuyerConfig({
+    config,
+    env,
+    buyerOverrides: {
+      minPeerReputation: 55,
+      preferredProviders: ['anthropic', 'openai'],
+      maxOutputUsdPerMillion: 99,
+    },
+  });
+
+  assert.equal(effective.minPeerReputation, 55);
+  assert.deepEqual(effective.preferredProviders, ['anthropic', 'openai']);
+  assert.equal(effective.maxPricing.defaults.inputUsdPerMillion, 90);
+  assert.equal(effective.maxPricing.defaults.outputUsdPerMillion, 99);
+});
+
+test('effective config resolution does not mutate loaded config', () => {
+  const config = createDefaultConfig();
+  const original = JSON.parse(JSON.stringify(config));
+
+  const env = {
+    ANTSEED_BUYER_MAX_INPUT_USD_PER_MILLION: '123',
+  } as NodeJS.ProcessEnv;
+
+  const effective = resolveEffectiveRoleConfig({
+    config,
+    env,
+    sellerOverrides: {
+      outputUsdPerMillion: 44,
+    },
+  });
+
+  assert.equal(effective.buyer.maxPricing.defaults.inputUsdPerMillion, 123);
+  assert.equal(effective.seller.pricing.defaults.outputUsdPerMillion, 44);
+  assert.deepEqual(config, original);
+});

package/src/config/effective.ts

@@ -0,0 +1,119 @@
+import type { BuyerCLIConfig, AntseedConfig, SellerCLIConfig } from './types.js';
+
+export interface SellerRuntimeOverrides {
+  reserveFloor?: number;
+  inputUsdPerMillion?: number;
+  outputUsdPerMillion?: number;
+}
+
+export interface BuyerRuntimeOverrides {
+  proxyPort?: number;
+  minPeerReputation?: number;
+  preferredProviders?: string[];
+  maxInputUsdPerMillion?: number;
+  maxOutputUsdPerMillion?: number;
+}
+
+export interface ResolveEffectiveConfigInput {
+  config: AntseedConfig;
+  env?: NodeJS.ProcessEnv;
+  sellerOverrides?: SellerRuntimeOverrides;
+  buyerOverrides?: BuyerRuntimeOverrides;
+}
+
+function parseEnvNumber(env: NodeJS.ProcessEnv, key: string): number | undefined {
+  const raw = env[key];
+  if (raw === undefined) return undefined;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function parseEnvProviders(env: NodeJS.ProcessEnv, key: string): string[] | undefined {
+  const raw = env[key];
+  if (!raw) return undefined;
+  const list = raw
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+  return list.length > 0 ? list : undefined;
+}
+
+export function resolveEffectiveSellerConfig(input: ResolveEffectiveConfigInput): SellerCLIConfig {
+  const env = input.env ?? process.env;
+  const seller = structuredClone(input.config.seller);
+
+  const envInputUsdPerMillion = parseEnvNumber(env, 'ANTSEED_SELLER_INPUT_USD_PER_MILLION');
+  const envOutputUsdPerMillion = parseEnvNumber(env, 'ANTSEED_SELLER_OUTPUT_USD_PER_MILLION');
+
+  if (envInputUsdPerMillion !== undefined) {
+    seller.pricing.defaults.inputUsdPerMillion = envInputUsdPerMillion;
+  }
+  if (envOutputUsdPerMillion !== undefined) {
+    seller.pricing.defaults.outputUsdPerMillion = envOutputUsdPerMillion;
+  }
+
+  const overrides = input.sellerOverrides;
+  if (overrides?.reserveFloor !== undefined) {
+    seller.reserveFloor = overrides.reserveFloor;
+  }
+  if (overrides?.inputUsdPerMillion !== undefined) {
+    seller.pricing.defaults.inputUsdPerMillion = overrides.inputUsdPerMillion;
+  }
+  if (overrides?.outputUsdPerMillion !== undefined) {
+    seller.pricing.defaults.outputUsdPerMillion = overrides.outputUsdPerMillion;
+  }
+
+  return seller;
+}
+
+export function resolveEffectiveBuyerConfig(input: ResolveEffectiveConfigInput): BuyerCLIConfig {
+  const env = input.env ?? process.env;
+  const buyer = structuredClone(input.config.buyer);
+
+  const envMinReputation = parseEnvNumber(env, 'ANTSEED_BUYER_MIN_REPUTATION');
+  const envPreferredProviders = parseEnvProviders(env, 'ANTSEED_BUYER_PREFERRED_PROVIDERS');
+  const envMaxInputUsdPerMillion = parseEnvNumber(env, 'ANTSEED_BUYER_MAX_INPUT_USD_PER_MILLION');
+  const envMaxOutputUsdPerMillion = parseEnvNumber(env, 'ANTSEED_BUYER_MAX_OUTPUT_USD_PER_MILLION');
+
+  if (envMinReputation !== undefined) {
+    buyer.minPeerReputation = envMinReputation;
+  }
+  if (envPreferredProviders) {
+    buyer.preferredProviders = envPreferredProviders;
+  }
+  if (envMaxInputUsdPerMillion !== undefined) {
+    buyer.maxPricing.defaults.inputUsdPerMillion = envMaxInputUsdPerMillion;
+  }
+  if (envMaxOutputUsdPerMillion !== undefined) {
+    buyer.maxPricing.defaults.outputUsdPerMillion = envMaxOutputUsdPerMillion;
+  }
+
+  const overrides = input.buyerOverrides;
+  if (overrides?.proxyPort !== undefined) {
+    buyer.proxyPort = overrides.proxyPort;
+  }
+  if (overrides?.minPeerReputation !== undefined) {
+    buyer.minPeerReputation = overrides.minPeerReputation;
+  }
+  if (overrides?.preferredProviders && overrides.preferredProviders.length > 0) {
+    buyer.preferredProviders = [...overrides.preferredProviders];
+  }
+  if (overrides?.maxInputUsdPerMillion !== undefined) {
+    buyer.maxPricing.defaults.inputUsdPerMillion = overrides.maxInputUsdPerMillion;
+  }
+  if (overrides?.maxOutputUsdPerMillion !== undefined) {
+    buyer.maxPricing.defaults.outputUsdPerMillion = overrides.maxOutputUsdPerMillion;
+  }
+
+  return buyer;
+}
+
+export function resolveEffectiveRoleConfig(input: ResolveEffectiveConfigInput): {
+  seller: SellerCLIConfig;
+  buyer: BuyerCLIConfig;
+} {
+  return {
+    seller: resolveEffectiveSellerConfig(input),
+    buyer: resolveEffectiveBuyerConfig(input),
+  };
+}

package/src/config/loader.test.ts

@@ -0,0 +1,95 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { loadConfig } from './loader.js';
+
+async function withTempConfig(contents: string, fn: (configPath: string) => Promise<void>): Promise<void> {
+  const dir = await mkdtemp(join(tmpdir(), 'antseed-cli-config-'));
+  const configPath = join(dir, 'config.json');
+  try {
+    await writeFile(configPath, contents, 'utf-8');
+    await fn(configPath);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+test('loadConfig deep-merges nested hierarchical pricing without dropping defaults', async () => {
+  await withTempConfig(
+    JSON.stringify({
+      seller: {
+        pricing: {
+          providers: {
+            anthropic: {
+              models: {
+                'claude-sonnet-4-5-20250929': {
+                  inputUsdPerMillion: 12,
+                  outputUsdPerMillion: 18,
+                },
+              },
+            },
+          },
+        },
+      },
+      buyer: {
+        maxPricing: {
+          providers: {
+            openai: {
+              defaults: {
+                inputUsdPerMillion: 55,
+                outputUsdPerMillion: 77,
+              },
+            },
+          },
+        },
+      },
+    }),
+    async (configPath) => {
+      const config = await loadConfig(configPath);
+
+      assert.equal(config.seller.pricing.defaults.inputUsdPerMillion, 10);
+      assert.equal(config.seller.pricing.defaults.outputUsdPerMillion, 10);
+      assert.equal(
+        config.seller.pricing.providers?.anthropic?.models?.['claude-sonnet-4-5-20250929']?.inputUsdPerMillion,
+        12
+      );
+      assert.equal(
+        config.seller.pricing.providers?.anthropic?.models?.['claude-sonnet-4-5-20250929']?.outputUsdPerMillion,
+        18
+      );
+
+      assert.equal(config.buyer.maxPricing.defaults.inputUsdPerMillion, 100);
+      assert.equal(config.buyer.maxPricing.defaults.outputUsdPerMillion, 100);
+      assert.equal(config.buyer.maxPricing.providers?.openai?.defaults?.inputUsdPerMillion, 55);
+      assert.equal(config.buyer.maxPricing.providers?.openai?.defaults?.outputUsdPerMillion, 77);
+    }
+  );
+});
+
+test('loadConfig throws explicit validation error for incomplete model pricing', async () => {
+  await withTempConfig(
+    JSON.stringify({
+      seller: {
+        pricing: {
+          providers: {
+            anthropic: {
+              models: {
+                broken: {
+                  inputUsdPerMillion: 12,
+                },
+              },
+            },
+          },
+        },
+      },
+    }),
+    async (configPath) => {
+      await assert.rejects(
+        async () => loadConfig(configPath),
+        /seller\.pricing\.providers\.anthropic\.models\.broken\.outputUsdPerMillion/
+      );
+    }
+  );
+});