@antseed/cli 0.1.0

package/src/config/loader.ts

@@ -0,0 +1,251 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import type {
+  HierarchicalPricingConfig,
+  AntseedConfig,
+  ProviderPricingConfig,
+  TokenPricingUsdPerMillion,
+} from './types.js';
+import { createDefaultConfig } from './defaults.js';
+import { assertValidConfig } from './validation.js';
+
+/**
+ * Resolve a config path, expanding ~ to the user's home directory.
+ */
+function resolveConfigPath(configPath: string): string {
+  if (configPath.startsWith('~')) {
+    return resolve(homedir(), configPath.slice(2));
+  }
+  return resolve(configPath);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function toFiniteOrNaN(value: unknown): number {
+  return typeof value === 'number' ? value : Number.NaN;
+}
+
+function clonePricing(pricing: TokenPricingUsdPerMillion): TokenPricingUsdPerMillion {
+  return {
+    inputUsdPerMillion: pricing.inputUsdPerMillion,
+    outputUsdPerMillion: pricing.outputUsdPerMillion,
+  };
+}
+
+function normalizeTokenPricing(value: unknown): TokenPricingUsdPerMillion | null {
+  if (!isRecord(value)) return null;
+  return {
+    inputUsdPerMillion: toFiniteOrNaN(value['inputUsdPerMillion']),
+    outputUsdPerMillion: toFiniteOrNaN(value['outputUsdPerMillion']),
+  };
+}
+
+function mergeTokenPricing(
+  defaults: TokenPricingUsdPerMillion,
+  value: unknown
+): TokenPricingUsdPerMillion {
+  if (!isRecord(value)) {
+    return clonePricing(defaults);
+  }
+  return {
+    inputUsdPerMillion: typeof value['inputUsdPerMillion'] === 'number'
+      ? value['inputUsdPerMillion']
+      : defaults.inputUsdPerMillion,
+    outputUsdPerMillion: typeof value['outputUsdPerMillion'] === 'number'
+      ? value['outputUsdPerMillion']
+      : defaults.outputUsdPerMillion,
+  };
+}
+
+function cloneProviderPricing(
+  providers: Record<string, ProviderPricingConfig> | undefined
+): Record<string, ProviderPricingConfig> | undefined {
+  if (!providers) return undefined;
+  const out: Record<string, ProviderPricingConfig> = {};
+  for (const [provider, cfg] of Object.entries(providers)) {
+    out[provider] = {
+      ...(cfg.defaults ? { defaults: clonePricing(cfg.defaults) } : {}),
+      ...(cfg.models ? { models: { ...cfg.models } } : {}),
+    };
+  }
+  return out;
+}
+
+function mergeModelPricing(
+  defaults: Record<string, TokenPricingUsdPerMillion> | undefined,
+  value: unknown
+): Record<string, TokenPricingUsdPerMillion> | undefined {
+  const out: Record<string, TokenPricingUsdPerMillion> = {
+    ...(defaults ?? {}),
+  };
+  if (isRecord(value)) {
+    for (const [model, rawPricing] of Object.entries(value)) {
+      const parsed = normalizeTokenPricing(rawPricing);
+      if (parsed) {
+        out[model] = parsed;
+      }
+    }
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function mergeProviderPricing(
+  defaults: Record<string, ProviderPricingConfig> | undefined,
+  value: unknown
+): Record<string, ProviderPricingConfig> | undefined {
+  const out = cloneProviderPricing(defaults) ?? {};
+  if (isRecord(value)) {
+    for (const [provider, rawCfg] of Object.entries(value)) {
+      if (!isRecord(rawCfg)) continue;
+      const existing = out[provider];
+      const parsedDefaults = normalizeTokenPricing(rawCfg['defaults']);
+      const next: ProviderPricingConfig = {
+        ...(parsedDefaults ? { defaults: parsedDefaults } : (existing?.defaults ? { defaults: existing.defaults } : {})),
+      };
+      const mergedModels = mergeModelPricing(existing?.models, rawCfg['models']);
+      if (mergedModels) {
+        next.models = mergedModels;
+      }
+      if (next.defaults || next.models) {
+        out[provider] = next;
+      }
+    }
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function mergeHierarchicalPricing(
+  defaults: HierarchicalPricingConfig,
+  value: unknown
+): HierarchicalPricingConfig {
+  if (!isRecord(value)) {
+    return {
+      defaults: clonePricing(defaults.defaults),
+      ...(defaults.providers ? { providers: cloneProviderPricing(defaults.providers) } : {}),
+    };
+  }
+  const mergedProviders = mergeProviderPricing(defaults.providers, value['providers']);
+  return {
+    defaults: mergeTokenPricing(defaults.defaults, value['defaults']),
+    ...(mergedProviders ? { providers: mergedProviders } : {}),
+  };
+}
+
+function mergeSellerConfig(
+  defaults: AntseedConfig['seller'],
+  value: unknown
+): AntseedConfig['seller'] {
+  if (!isRecord(value)) {
+    return {
+      reserveFloor: defaults.reserveFloor,
+      maxConcurrentBuyers: defaults.maxConcurrentBuyers,
+      enabledProviders: [...defaults.enabledProviders],
+      pricing: mergeHierarchicalPricing(defaults.pricing, undefined),
+    };
+  }
+  return {
+    reserveFloor: typeof value['reserveFloor'] === 'number'
+      ? value['reserveFloor']
+      : defaults.reserveFloor,
+    maxConcurrentBuyers: typeof value['maxConcurrentBuyers'] === 'number'
+      ? value['maxConcurrentBuyers']
+      : defaults.maxConcurrentBuyers,
+    enabledProviders: Array.isArray(value['enabledProviders'])
+      ? value['enabledProviders'].filter((entry): entry is string => typeof entry === 'string')
+      : [...defaults.enabledProviders],
+    pricing: mergeHierarchicalPricing(defaults.pricing, value['pricing']),
+  };
+}
+
+function mergeBuyerConfig(
+  defaults: AntseedConfig['buyer'],
+  value: unknown
+): AntseedConfig['buyer'] {
+  if (!isRecord(value)) {
+    return {
+      preferredProviders: [...defaults.preferredProviders],
+      maxPricing: mergeHierarchicalPricing(defaults.maxPricing, undefined),
+      minPeerReputation: defaults.minPeerReputation,
+      proxyPort: defaults.proxyPort,
+    };
+  }
+  return {
+    preferredProviders: Array.isArray(value['preferredProviders'])
+      ? value['preferredProviders'].filter((entry): entry is string => typeof entry === 'string')
+      : [...defaults.preferredProviders],
+    maxPricing: mergeHierarchicalPricing(defaults.maxPricing, value['maxPricing']),
+    minPeerReputation: typeof value['minPeerReputation'] === 'number'
+      ? value['minPeerReputation']
+      : defaults.minPeerReputation,
+    proxyPort: typeof value['proxyPort'] === 'number'
+      ? value['proxyPort']
+      : defaults.proxyPort,
+  };
+}
+
+/**
+ * Load configuration from a JSON file.
+ * Returns default configuration if the file does not exist.
+ */
+export async function loadConfig(configPath: string): Promise<AntseedConfig> {
+  const resolved = resolveConfigPath(configPath);
+
+  let raw: string;
+  try {
+    raw = await readFile(resolved, 'utf-8');
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return createDefaultConfig();
+    }
+    throw err;
+  }
+
+  let parsedRaw: unknown;
+  try {
+    parsedRaw = JSON.parse(raw);
+  } catch {
+    console.warn(`Warning: Could not parse config at ${resolved}. Using defaults.`);
+    return createDefaultConfig();
+  }
+
+  const defaults = createDefaultConfig();
+  const parsed = isRecord(parsedRaw) ? parsedRaw : {};
+
+  const merged: AntseedConfig = {
+    ...defaults,
+    ...(parsed as Partial<AntseedConfig>),
+    identity: {
+      ...defaults.identity,
+      ...(isRecord(parsed['identity']) ? parsed['identity'] : {}),
+    },
+    seller: mergeSellerConfig(defaults.seller, parsed['seller']),
+    buyer: mergeBuyerConfig(defaults.buyer, parsed['buyer']),
+    payments: {
+      ...defaults.payments,
+      ...(isRecord(parsed['payments']) ? parsed['payments'] : {}),
+    },
+    network: {
+      ...defaults.network,
+      ...(isRecord(parsed['network']) ? parsed['network'] : {}),
+    },
+    providers: Array.isArray(parsed['providers'])
+      ? (parsed['providers'] as AntseedConfig['providers'])
+      : defaults.providers,
+  };
+
+  assertValidConfig(merged);
+  return merged;
+}
+
+/**
+ * Save configuration to a JSON file.
+ * Creates the directory if it doesn't exist.
+ */
+export async function saveConfig(configPath: string, config: AntseedConfig): Promise<void> {
+  const resolved = resolveConfigPath(configPath);
+  await mkdir(dirname(resolved), { recursive: true });
+  await writeFile(resolved, JSON.stringify(config, null, 2), 'utf-8');
+}

package/src/config/types.ts

@@ -0,0 +1,139 @@
+import type { ProviderType } from '@antseed/node';
+
+/**
+ * Provider configuration for the Antseed config file.
+ * This is distinct from the provider.ts ProviderConfig used internally.
+ */
+export interface CLIProviderConfig {
+  /** Provider type identifier */
+  type: ProviderType;
+  /** API endpoint URL */
+  endpoint: string;
+  /** Name of the HTTP header used for authentication */
+  authHeaderName: string;
+  /** Auth token / API key value */
+  authValue: string;
+  /** Auth type: 'apikey' (default), 'oauth' (with refresh), or 'claude-code' (read from keychain) */
+  authType?: 'apikey' | 'oauth' | 'claude-code';
+  /** OAuth refresh token (required when authType is 'oauth') */
+  refreshToken?: string;
+  /** Token expiration timestamp in epoch ms (used with authType 'oauth') */
+  expiresAt?: number;
+}
+
+/**
+ * Re-export ProviderType for convenience in config commands.
+ */
+export type { ProviderType } from '@antseed/node';
+
+/**
+ * Dual token pricing in USD per 1M tokens.
+ */
+export interface TokenPricingUsdPerMillion {
+  inputUsdPerMillion: number;
+  outputUsdPerMillion: number;
+}
+
+/**
+ * Provider-level optional defaults and per-model overrides.
+ */
+export interface ProviderPricingConfig {
+  defaults?: TokenPricingUsdPerMillion;
+  models?: Record<string, TokenPricingUsdPerMillion>;
+}
+
+/**
+ * Hierarchical pricing with global defaults and optional provider/model overrides.
+ */
+export interface HierarchicalPricingConfig {
+  defaults: TokenPricingUsdPerMillion;
+  providers?: Record<string, ProviderPricingConfig>;
+}
+
+/**
+ * Seller-specific configuration within the Antseed config.
+ */
+export interface SellerCLIConfig {
+  /** Reserve floor in messages per hour to keep for yourself */
+  reserveFloor: number;
+  /** Maximum number of concurrent buyer connections */
+  maxConcurrentBuyers: number;
+  /** Which provider types are enabled for selling */
+  enabledProviders: string[];
+  /** Seller offer pricing rules in USD per 1M tokens */
+  pricing: HierarchicalPricingConfig;
+}
+
+/**
+ * Buyer-specific configuration within the Antseed config.
+ */
+export interface BuyerCLIConfig {
+  /** Preferred provider types for purchasing */
+  preferredProviders: string[];
+  /** Buyer max willing-to-pay rules in USD per 1M tokens */
+  maxPricing: HierarchicalPricingConfig;
+  /** Minimum peer reputation score (0-100) */
+  minPeerReputation: number;
+  /** Local proxy listen port */
+  proxyPort: number;
+}
+
+/**
+ * Payment configuration within the Antseed config.
+ */
+export interface PaymentsCLIConfig {
+  /** Preferred payment method */
+  preferredMethod: 'crypto';
+  /** Platform fee rate (0-1) */
+  platformFeeRate: number;
+  /** Optional crypto settlement settings (Base network) */
+  crypto?: {
+    /** Chain identifier */
+    chainId: 'base-local' | 'base-sepolia' | 'base-mainnet';
+    /** Base JSON-RPC URL (e.g. http://127.0.0.1:8545 for local anvil) */
+    rpcUrl: string;
+    /** Deployed AntseedEscrow contract address */
+    escrowContractAddress: string;
+    /** USDC token contract address */
+    usdcContractAddress: string;
+    /** Default lock amount per session in human-readable USDC (e.g. "1" = 1 USDC) */
+    defaultLockAmountUSDC?: string;
+  };
+}
+
+/**
+ * Network configuration within the Antseed config.
+ */
+export interface NetworkCLIConfig {
+  /** Additional bootstrap nodes for DHT discovery (host:port pairs) */
+  bootstrapNodes: string[];
+}
+
+/**
+ * Top-level Antseed configuration structure.
+ */
+export interface AntseedConfig {
+  /** Node identity information (peer ID, display name) */
+  identity: {
+    displayName: string;
+    walletAddress?: string;
+  };
+  /** Configured LLM provider credentials */
+  providers: CLIProviderConfig[];
+  /** Seller mode settings */
+  seller: SellerCLIConfig;
+  /** Buyer mode settings */
+  buyer: BuyerCLIConfig;
+  /** Payment settings */
+  payments: PaymentsCLIConfig;
+  /** Network / DHT settings */
+  network: NetworkCLIConfig;
+  /** Installed plugins */
+  plugins?: { name: string; package: string; installedAt: string }[];
+}
+
+/**
+ * ProviderConfig alias for use in config commands.
+ * Maps to CLIProviderConfig.
+ */
+export type ProviderConfig = CLIProviderConfig;

package/src/config/validation.ts

@@ -0,0 +1,78 @@
+import type {
+  HierarchicalPricingConfig,
+  AntseedConfig,
+  TokenPricingUsdPerMillion,
+} from './types.js';
+
+function validatePricingLeaf(
+  path: string,
+  value: TokenPricingUsdPerMillion,
+  errors: string[]
+): void {
+  if (!Number.isFinite(value.inputUsdPerMillion) || value.inputUsdPerMillion < 0) {
+    errors.push(`${path}.inputUsdPerMillion must be a non-negative finite number`);
+  }
+  if (!Number.isFinite(value.outputUsdPerMillion) || value.outputUsdPerMillion < 0) {
+    errors.push(`${path}.outputUsdPerMillion must be a non-negative finite number`);
+  }
+}
+
+function validateHierarchicalPricing(
+  path: string,
+  pricing: HierarchicalPricingConfig,
+  errors: string[]
+): void {
+  validatePricingLeaf(`${path}.defaults`, pricing.defaults, errors);
+
+  for (const [provider, providerPricing] of Object.entries(pricing.providers ?? {})) {
+    if (providerPricing.defaults) {
+      validatePricingLeaf(`${path}.providers.${provider}.defaults`, providerPricing.defaults, errors);
+    }
+
+    for (const [model, modelPricing] of Object.entries(providerPricing.models ?? {})) {
+      validatePricingLeaf(
+        `${path}.providers.${provider}.models.${model}`,
+        modelPricing,
+        errors
+      );
+    }
+  }
+}
+
+/**
+ * Validate the full config and return all issues.
+ */
+export function validateConfig(config: AntseedConfig): string[] {
+  const errors: string[] = [];
+
+  validateHierarchicalPricing('seller.pricing', config.seller.pricing, errors);
+  validateHierarchicalPricing('buyer.maxPricing', config.buyer.maxPricing, errors);
+
+  if (!Number.isFinite(config.buyer.minPeerReputation) || config.buyer.minPeerReputation < 0 || config.buyer.minPeerReputation > 100) {
+    errors.push('buyer.minPeerReputation must be in range 0-100');
+  }
+
+  if (!Number.isInteger(config.buyer.proxyPort) || config.buyer.proxyPort < 1 || config.buyer.proxyPort > 65535) {
+    errors.push('buyer.proxyPort must be an integer in range 1-65535');
+  }
+
+  if (!Number.isInteger(config.seller.maxConcurrentBuyers) || config.seller.maxConcurrentBuyers < 1) {
+    errors.push('seller.maxConcurrentBuyers must be an integer >= 1');
+  }
+
+  if (!Number.isFinite(config.seller.reserveFloor) || config.seller.reserveFloor < 0) {
+    errors.push('seller.reserveFloor must be a non-negative finite number');
+  }
+
+  return errors;
+}
+
+/**
+ * Assert that config is valid. Throws with all discovered violations.
+ */
+export function assertValidConfig(config: AntseedConfig): void {
+  const errors = validateConfig(config);
+  if (errors.length === 0) return;
+
+  throw new Error(`Invalid config:\n- ${errors.join('\n- ')}`);
+}

package/src/env/load-env.ts

@@ -0,0 +1,20 @@
+import dotenv from 'dotenv';
+import { resolve } from 'node:path';
+
+function applyEnvFile(filePath: string): void {
+  dotenv.config({ path: filePath, override: false });
+}
+
+/**
+ * Load runtime environment variables from .env files.
+ * Precedence: existing process.env > explicit env file > .env.local > .env
+ */
+export function loadEnvFromFiles(): void {
+  const explicit = process.env['ANTSEED_ENV_FILE'];
+  if (explicit) {
+    applyEnvFile(resolve(explicit));
+  }
+
+  applyEnvFile(resolve(process.cwd(), '.env.local'));
+  applyEnvFile(resolve(process.cwd(), '.env'));
+}

package/src/plugins/loader.ts

@@ -0,0 +1,96 @@
+import path, { join } from 'node:path'
+import { getPluginsDir } from './manager.js'
+import { TRUSTED_PLUGINS } from './registry.js'
+import type { AntseedProviderPlugin, AntseedRouterPlugin, PluginConfigKey } from '@antseed/node'
+
+function resolvePackageName(nameOrPackage: string): string {
+  const legacy = LEGACY_PACKAGE_MAP[nameOrPackage]
+  if (legacy) return legacy
+  const trusted = TRUSTED_PLUGINS.find(p => p.name === nameOrPackage)
+  return trusted?.package ?? nameOrPackage
+}
+
+type PluginKind = 'provider' | 'router'
+
+async function loadPlugin<T>(
+  nameOrPackage: string,
+  kind: PluginKind,
+  methodName: keyof AntseedProviderPlugin | keyof AntseedRouterPlugin
+): Promise<T> {
+  const pkgName = resolvePackageName(nameOrPackage)
+  const pluginsDir = getPluginsDir()
+  const pluginPath = join(pluginsDir, 'node_modules', pkgName, 'dist', 'index.js')
+  const resolved = path.resolve(pluginPath)
+  if (!resolved.startsWith(path.resolve(pluginsDir))) {
+    throw new Error(`Invalid plugin path: ${pkgName}`)
+  }
+
+  let mod: { default?: unknown }
+  try {
+    mod = await import(resolved) as { default?: unknown }
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err)
+    if (
+      err &&
+      typeof err === 'object' &&
+      'code' in err &&
+      (err as { code?: string }).code === 'ERR_MODULE_NOT_FOUND'
+    ) {
+      throw new Error(
+        `Plugin "${pkgName}" not found. Install it with:\n  antseed plugin add ${pkgName}`
+      )
+    }
+    throw new Error(
+      `Plugin "${pkgName}" failed to load from ${resolved}.\nCause: ${cause}`
+    )
+  }
+
+  const plugin = mod.default
+  if (!plugin || typeof plugin !== 'object' || (plugin as { type?: string }).type !== kind) {
+    throw new Error(
+      `Plugin "${pkgName}" does not export a valid ${kind} plugin (expected default export with type: '${kind}')`
+    )
+  }
+
+  if (typeof (plugin as Record<string, unknown>)[methodName] !== 'function') {
+    throw new Error(`Plugin "${pkgName}" does not implement ${methodName}()`)
+  }
+
+  return plugin as T
+}
+
+export async function loadProviderPlugin(nameOrPackage: string): Promise<AntseedProviderPlugin> {
+  return loadPlugin<AntseedProviderPlugin>(nameOrPackage, 'provider', 'createProvider')
+}
+
+export async function loadRouterPlugin(nameOrPackage: string): Promise<AntseedRouterPlugin> {
+  return loadPlugin<AntseedRouterPlugin>(nameOrPackage, 'router', 'createRouter')
+}
+
+export function buildPluginConfig(
+  configKeys: PluginConfigKey[],
+  runtimeOverrides?: Record<string, string>,
+  instanceConfig?: Record<string, string>,
+): Record<string, string> {
+  const config: Record<string, string> = {}
+  // Priority: instanceConfig (lowest) < env vars < runtime overrides (highest)
+  if (instanceConfig) {
+    Object.assign(config, instanceConfig)
+  }
+  for (const key of configKeys) {
+    const value = process.env[key.key]
+    if (value !== undefined) {
+      config[key.key] = value
+    }
+  }
+  if (runtimeOverrides) {
+    Object.assign(config, runtimeOverrides)
+  }
+  return config
+}
+
+/** Map legacy package names to current names */
+export const LEGACY_PACKAGE_MAP: Record<string, string> = {
+  'antseed-provider-anthropic': '@antseed/provider-claude-code',
+  'antseed-router-claude-code': '@antseed/router-local-proxy',
+}

package/src/plugins/manager.ts

@@ -0,0 +1,66 @@
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { mkdir, readFile, writeFile, access } from 'node:fs/promises'
+import { constants, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const execFileAsync = promisify(execFile)
+
+export const PLUGINS_DIR = join(homedir(), '.antseed', 'plugins')
+
+function resolvePluginsDir(): string {
+  if (existsSync(PLUGINS_DIR)) return PLUGINS_DIR
+  return PLUGINS_DIR
+}
+
+export function getPluginsDir(): string {
+  return resolvePluginsDir()
+}
+
+export interface InstalledPlugin {
+  name: string
+  package: string
+  version: string
+}
+
+async function ensurePluginsDir(): Promise<void> {
+  const pluginsDir = resolvePluginsDir()
+  const pluginsPackageJson = join(pluginsDir, 'package.json')
+  await mkdir(pluginsDir, { recursive: true })
+  try {
+    await access(pluginsPackageJson, constants.R_OK)
+  } catch {
+    await writeFile(
+      pluginsPackageJson,
+      JSON.stringify({ name: 'antseed-plugins', version: '1.0.0', private: true, dependencies: {} }, null, 2),
+      'utf-8'
+    )
+  }
+}
+
+export async function installPlugin(packageName: string): Promise<void> {
+  await ensurePluginsDir()
+  await execFileAsync('npm', ['install', '--ignore-scripts', packageName], { cwd: getPluginsDir() })
+}
+
+export async function removePlugin(packageName: string): Promise<void> {
+  await ensurePluginsDir()
+  await execFileAsync('npm', ['uninstall', packageName], { cwd: getPluginsDir() })
+}
+
+export async function listInstalledPlugins(): Promise<InstalledPlugin[]> {
+  await ensurePluginsDir()
+  try {
+    const raw = await readFile(join(getPluginsDir(), 'package.json'), 'utf-8')
+    const pkg = JSON.parse(raw) as { dependencies?: Record<string, string> }
+    const deps = pkg.dependencies ?? {}
+    return Object.entries(deps).map(([pkgName, version]) => ({
+      name: pkgName,
+      package: pkgName,
+      version: version,
+    }))
+  } catch {
+    return []
+  }
+}

package/src/plugins/registry.ts

@@ -0,0 +1,45 @@
+export interface TrustedPlugin {
+  name: string
+  type: 'provider' | 'router'
+  description: string
+  package: string
+}
+
+export const TRUSTED_PLUGINS: TrustedPlugin[] = [
+  {
+    name: 'anthropic',
+    type: 'provider',
+    description: 'Sell Anthropic API capacity (API key)',
+    package: '@antseed/provider-anthropic',
+  },
+  {
+    name: 'claude-code',
+    type: 'provider',
+    description: 'Sell Claude capacity via Claude Code keychain',
+    package: '@antseed/provider-claude-code',
+  },
+  {
+    name: 'openrouter',
+    type: 'provider',
+    description: 'Sell via OpenRouter (multi-model)',
+    package: '@antseed/provider-openrouter',
+  },
+  {
+    name: 'local-llm',
+    type: 'provider',
+    description: 'Sell local LLM capacity (Ollama, llama.cpp)',
+    package: '@antseed/provider-local-llm',
+  },
+  {
+    name: 'local-proxy',
+    type: 'router',
+    description: 'Local HTTP proxy for Claude Code, Aider, Codex',
+    package: '@antseed/router-local-proxy',
+  },
+  {
+    name: 'local-chat',
+    type: 'router',
+    description: 'Local desktop chat router',
+    package: '@antseed/router-local-chat',
+  },
+]