@kkmila/cpc 1.0.0

package/src/commands/provider.mjs

@@ -0,0 +1,1576 @@
+import { select, checkbox, confirm, input, number } from "@inquirer/prompts";
+import chalk from "chalk";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+import yaml from "js-yaml";
+import { loadRegistry, getAgents, resolveAgentPaths } from "../lib/agents.mjs";
+
+/**
+ * Get the config directory path (~/.config/cpc)
+ */
+function getConfigDir() {
+	return resolve(homedir(), ".config", "cpc");
+}
+
+/**
+ * Load providers configuration from ~/.config/cpc/providers.json
+ */
+function loadProviders() {
+	const configDir = getConfigDir();
+	const providersPath = resolve(configDir, "providers.json");
+	if (!existsSync(providersPath)) {
+		return { version: "2.0", providers: {} };
+	}
+	try {
+		const content = readFileSync(providersPath, "utf8");
+		const data = JSON.parse(content);
+		// 兼容旧版本
+		if (!data.version) {
+			data.version = "2.0";
+		}
+		return data;
+	} catch (err) {
+		console.error(chalk.red(`Error loading providers.json: ${err.message}`));
+		return { version: "2.0", providers: {} };
+	}
+}
+
+/**
+ * Save providers configuration to ~/.config/cpc/providers.json
+ */
+function saveProviders(data) {
+	const configDir = getConfigDir();
+	if (!existsSync(configDir)) {
+		mkdirSync(configDir, { recursive: true });
+	}
+	const providersPath = resolve(configDir, "providers.json");
+	writeFileSync(providersPath, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Fetch models from OpenAI-compatible API
+ */
+async function fetchModelsFromAPI(baseUrl, apiKey, apiType) {
+	try {
+		let url = baseUrl;
+
+		// 根据API类型构造正确的URL
+		if (apiType === "openai-completions" || apiType === "responses") {
+			// 确保URL以/v1结尾
+			if (!url.endsWith("/v1")) {
+				url = url.replace(/\/+$/, "") + "/v1";
+			}
+			url += "/models";
+		} else if (apiType === "anthropic-messages") {
+			// Anthropic没有标准的模型列表端点
+			return {
+				success: false,
+				error: "Anthropic API does not support model listing",
+			};
+		}
+
+		const response = await fetch(url, {
+			method: "GET",
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				"Content-Type": "application/json",
+			},
+			signal: AbortSignal.timeout(10000), // 10秒超时
+		});
+
+		if (!response.ok) {
+			return {
+				success: false,
+				error: `HTTP ${response.status}: ${response.statusText}`,
+			};
+		}
+
+		const data = await response.json();
+
+		if (data.data && Array.isArray(data.data)) {
+			// 标准OpenAI格式
+			const models = data.data.map((m) => ({
+				id: m.id,
+				name: m.name || m.id,
+				contextWindow: m.context_window || null,
+				maxTokens: m.max_tokens || null,
+				reasoning: m.reasoning || false,
+				input: m.input || ["text"],
+			}));
+			return { success: true, models };
+		}
+
+		return { success: false, error: "Invalid response format" };
+	} catch (err) {
+		if (err.name === "AbortError" || err.name === "TimeoutError") {
+			return { success: false, error: "Connection timeout" };
+		}
+		return { success: false, error: err.message };
+	}
+}
+
+/**
+ * 常见模型的默认配置
+ */
+const MODEL_DEFAULTS = {
+	// OpenAI
+	"gpt-4": { contextWindow: 8192, maxTokens: 4096, reasoning: false },
+	"gpt-4-turbo": { contextWindow: 128000, maxTokens: 4096, reasoning: false },
+	"gpt-4o": { contextWindow: 128000, maxTokens: 16384, reasoning: false },
+	"gpt-4o-mini": { contextWindow: 128000, maxTokens: 16384, reasoning: false },
+	"gpt-3.5-turbo": { contextWindow: 16385, maxTokens: 4096, reasoning: false },
+	o1: { contextWindow: 200000, maxTokens: 100000, reasoning: true },
+	"o1-mini": { contextWindow: 128000, maxTokens: 65536, reasoning: true },
+	"o1-preview": { contextWindow: 128000, maxTokens: 32768, reasoning: true },
+	"o3-mini": { contextWindow: 200000, maxTokens: 100000, reasoning: true },
+
+	// Anthropic
+	"claude-3-opus-20240229": {
+		contextWindow: 200000,
+		maxTokens: 4096,
+		reasoning: false,
+	},
+	"claude-3-sonnet-20240229": {
+		contextWindow: 200000,
+		maxTokens: 4096,
+		reasoning: false,
+	},
+	"claude-3-haiku-20240307": {
+		contextWindow: 200000,
+		maxTokens: 4096,
+		reasoning: false,
+	},
+	"claude-3-5-sonnet-20241022": {
+		contextWindow: 200000,
+		maxTokens: 8192,
+		reasoning: false,
+	},
+	"claude-3-5-haiku-20241022": {
+		contextWindow: 200000,
+		maxTokens: 8192,
+		reasoning: false,
+	},
+
+	// DeepSeek
+	"deepseek-chat": { contextWindow: 32768, maxTokens: 4096, reasoning: false },
+	"deepseek-coder": { contextWindow: 32768, maxTokens: 4096, reasoning: false },
+	"deepseek-reasoner": {
+		contextWindow: 65536,
+		maxTokens: 8192,
+		reasoning: true,
+	},
+
+	// Qwen
+	"qwen-turbo": { contextWindow: 8192, maxTokens: 2048, reasoning: false },
+	"qwen-plus": { contextWindow: 32768, maxTokens: 8192, reasoning: false },
+	"qwen-max": { contextWindow: 32768, maxTokens: 8192, reasoning: false },
+
+	// 通用默认值
+	default: { contextWindow: 32768, maxTokens: 4096, reasoning: false },
+};
+
+/**
+ * 获取模型的默认配置
+ */
+function getModelDefaults(modelId) {
+	// 精确匹配
+	if (MODEL_DEFAULTS[modelId]) {
+		return MODEL_DEFAULTS[modelId];
+	}
+
+	// 模糊匹配
+	const lowerId = modelId.toLowerCase();
+	for (const [pattern, defaults] of Object.entries(MODEL_DEFAULTS)) {
+		if (lowerId.includes(pattern.toLowerCase())) {
+			return defaults;
+		}
+	}
+
+	// 检测是否是推理模型
+	const isReasoning =
+		lowerId.includes("reason") ||
+		lowerId.includes("o1") ||
+		lowerId.includes("o3") ||
+		lowerId.includes("think");
+
+	return {
+		...MODEL_DEFAULTS["default"],
+		reasoning: isReasoning,
+	};
+}
+
+/**
+ * 让用户配置模型属性
+ */
+async function configureModel(modelId, defaults = null) {
+	if (!defaults) {
+		defaults = getModelDefaults(modelId);
+	}
+
+	console.log(chalk.dim(`\nConfiguring model: ${modelId}`));
+	console.log(chalk.dim(`(Press Enter to use defaults)`));
+
+	const contextWindow = await number({
+		message: "Context window size (tokens):",
+		default: defaults.contextWindow,
+		validate: (v) => v > 0 || "Must be positive",
+	});
+
+	const maxTokens = await number({
+		message: "Max output tokens:",
+		default: defaults.maxTokens,
+		validate: (v) => v > 0 || "Must be positive",
+	});
+
+	const isReasoning = await confirm({
+		message: "Is this a reasoning model?",
+		default: defaults.reasoning,
+	});
+
+	return {
+		id: modelId,
+		name: modelId,
+		contextWindow: contextWindow || defaults.contextWindow,
+		maxTokens: maxTokens || defaults.maxTokens,
+		reasoning: isReasoning,
+		input: ["text"],
+	};
+}
+
+/**
+ * 交互式添加模型
+ */
+async function addModelsInteractively(existingModels = []) {
+	const models = [...existingModels];
+
+	console.log(chalk.bold("\n添加模型配置"));
+	console.log(chalk.dim("输入模型ID，输入空行结束"));
+
+	while (true) {
+		const modelId = await input({
+			message: "模型ID (空行结束):",
+		});
+
+		if (!modelId.trim()) {
+			break;
+		}
+
+		// 检查是否已存在
+		if (models.find((m) => m.id === modelId)) {
+			console.log(chalk.yellow(`模型 ${modelId} 已存在`));
+			continue;
+		}
+
+		const configured = await configureModel(modelId);
+		models.push(configured);
+		console.log(chalk.green(`✓ 已添加: ${modelId}`));
+	}
+
+	return models;
+}
+
+/**
+ * Get provider configuration for a specific agent
+ */
+function getAgentProviderConfig(agentId, provider) {
+	switch (agentId) {
+		case "claude-code":
+			return {
+				env: {
+					ANTHROPIC_AUTH_TOKEN: provider.apiKey,
+					ANTHROPIC_BASE_URL: provider.baseUrl,
+					ANTHROPIC_MODEL:
+						provider.models[0]?.id || "claude-3-5-sonnet-20241022",
+				},
+			};
+
+		case "pi":
+			return {
+				modelsJson: {
+					providers: {
+						[provider.name]: {
+							baseUrl: provider.baseUrl,
+							api: provider.api,
+							apiKey: provider.apiKey,
+							models: provider.models.map((m) => ({
+								id: m.id,
+								name: m.name || m.id,
+								reasoning: m.reasoning || false,
+								input: m.input || ["text"],
+								contextWindow: m.contextWindow || 32768,
+								maxTokens: m.maxTokens || 4096,
+							})),
+						},
+					},
+				},
+			};
+
+		case "hermes":
+			return {
+				configYaml: {
+					model: {
+						default: provider.models[0]?.id || "default",
+						provider: provider.name,
+						base_url: provider.baseUrl,
+						api_key: provider.apiKey,
+						api_mode:
+							provider.api === "anthropic-messages"
+								? "anthropic_messages"
+								: "openai",
+					},
+				},
+			};
+
+		case "codex":
+			return {
+				configToml: {
+					model_provider: provider.name,
+					model: provider.models[0]?.id || "default",
+					model_providers: {
+						[provider.name]: {
+							name: provider.name,
+							base_url: provider.baseUrl,
+							wire_api:
+								provider.api === "anthropic-messages"
+									? "chat_completions"
+									: "responses",
+							requires_openai_auth: false,
+						},
+					},
+				},
+			};
+
+		case "openclaw":
+			return {
+				openclawJson: {
+					models: {
+						providers: {
+							[provider.name]: {
+								baseUrl: provider.baseUrl,
+								apiKey: provider.apiKey,
+								api: provider.api,
+								models: provider.models.map((m) => ({
+									id: m.id,
+									name: m.name || m.id,
+									reasoning: m.reasoning || false,
+									input: m.input || ["text"],
+									contextWindow: m.contextWindow || 32768,
+									maxTokens: m.maxTokens || 4096,
+								})),
+							},
+						},
+					},
+				},
+			};
+
+		case "omp":
+			return {
+				modelsYml: {
+					providers: {
+						[`custom-${provider.name}`]: {
+							baseUrl: provider.baseUrl,
+							apiKey: provider.apiKey,
+							api: provider.api,
+							authHeader: true,
+							models: provider.models.map((m) => ({
+								id: m.id,
+								name: m.name || m.id,
+								reasoning: m.reasoning || false,
+								input: m.input || ["text"],
+								contextWindow: m.contextWindow || 32768,
+								maxTokens: m.maxTokens || 4096,
+								cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+							})),
+						},
+					},
+				},
+			};
+
+		default:
+			return null;
+	}
+}
+
+/**
+ * Install provider configuration to agent
+ */
+function installProviderToAgent(agentId, provider, agentHome) {
+	const config = getAgentProviderConfig(agentId, provider);
+	if (!config) {
+		console.log(chalk.yellow(`  ⚠ 未知 agent: ${agentId}`));
+		return false;
+	}
+
+	try {
+		switch (agentId) {
+			case "claude-code": {
+				const settingsPath = join(agentHome, "settings.json");
+				let settings = {};
+				if (existsSync(settingsPath)) {
+					settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+				}
+				settings.env = { ...settings.env, ...config.env };
+				writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+				console.log(chalk.green(`  ✓ 更新 Claude Code settings.json`));
+				return true;
+			}
+
+			case "pi": {
+				const modelsPath = join(agentHome, "models.json");
+				let models = { providers: {} };
+				if (existsSync(modelsPath)) {
+					models = JSON.parse(readFileSync(modelsPath, "utf8"));
+				}
+				models.providers = {
+					...models.providers,
+					...config.modelsJson.providers,
+				};
+				writeFileSync(modelsPath, JSON.stringify(models, null, 2));
+				console.log(chalk.green(`  ✓ 更新 Pi models.json`));
+				return true;
+			}
+
+			case "hermes": {
+				const configPath = join(agentHome, "config.yaml");
+				let configData = {};
+				if (existsSync(configPath)) {
+					configData = yaml.load(readFileSync(configPath, "utf8"));
+				}
+				configData.model = { ...configData.model, ...config.configYaml.model };
+				writeFileSync(configPath, yaml.dump(configData));
+				console.log(chalk.green(`  ✓ 更新 Hermes config.yaml`));
+				return true;
+			}
+
+			case "codex": {
+				const configPath = join(agentHome, "config.toml");
+				let configContent = "";
+				if (existsSync(configPath)) {
+					configContent = readFileSync(configPath, "utf8");
+				}
+
+				const providerSection = `\n[model_providers.${provider.name}]\nname = "${provider.name}"\nbase_url = "${provider.baseUrl}"\nwire_api = "${provider.api === "anthropic-messages" ? "chat_completions" : "responses"}"\nrequires_openai_auth = false\n`;
+
+				const modelLine = `model_provider = "${provider.name}"\n`;
+				const modelIdLine = `model = "${provider.models[0]?.id || "default"}"\n`;
+
+				if (configContent.includes("model_provider =")) {
+					configContent = configContent.replace(
+						/model_provider = .*\n/,
+						modelLine,
+					);
+				} else {
+					configContent = modelLine + configContent;
+				}
+
+				if (configContent.includes("model =")) {
+					configContent = configContent.replace(/model = .*\n/, modelIdLine);
+				} else {
+					configContent = modelIdLine + configContent;
+				}
+
+				if (!configContent.includes(`[model_providers.${provider.name}]`)) {
+					configContent += providerSection;
+				}
+
+				writeFileSync(configPath, configContent);
+				console.log(chalk.green(`  ✓ 更新 Codex config.toml`));
+				return true;
+			}
+
+			case "openclaw": {
+				const configPath = join(agentHome, "openclaw.json");
+				let configData = {};
+				if (existsSync(configPath)) {
+					configData = JSON.parse(readFileSync(configPath, "utf8"));
+				}
+				if (!configData.models) configData.models = {};
+				if (!configData.models.providers) configData.models.providers = {};
+				configData.models.providers = {
+					...configData.models.providers,
+					...config.openclawJson.models.providers,
+				};
+				writeFileSync(configPath, JSON.stringify(configData, null, 2));
+				console.log(chalk.green(`  ✓ 更新 OpenClaw openclaw.json`));
+				return true;
+			}
+
+			case "omp": {
+				const modelsPath = join(agentHome, "models.yml");
+				let modelsData = { providers: {} };
+				if (existsSync(modelsPath)) {
+					modelsData = yaml.load(readFileSync(modelsPath, "utf8"));
+				}
+				modelsData.providers = {
+					...modelsData.providers,
+					...config.modelsYml.providers,
+				};
+				writeFileSync(modelsPath, yaml.dump(modelsData));
+				console.log(chalk.green(`  ✓ 更新 OMP models.yml`));
+				return true;
+			}
+
+			default:
+				console.log(chalk.yellow(`  ⚠ 未知 agent: ${agentId}`));
+				return false;
+		}
+	} catch (err) {
+		console.error(chalk.red(`  ✗ 更新 ${agentId} 失败: ${err.message}`));
+		return false;
+	}
+}
+
+export function registerProvider(program, repoRoot) {
+	// ── cpc add ──────────────────────────────────────────────────
+	program
+		.command("add")
+		.description("Add a new custom model provider")
+		.option("--name <name>", "Provider name")
+		.option("--url <url>", "Base URL for the provider")
+		.option("--key <key>", "API key")
+		.option("--api <api>", "API type (openai-completions, anthropic-messages)")
+		.option("--fetch", "Auto-fetch models from API")
+		.option("--all", "Select all models when fetching")
+		.option("--force", "Overwrite existing provider without confirmation")
+		.action(async (opts) => {
+			const providersData = loadProviders();
+
+			// Step 1: Get provider name
+			let name = opts.name;
+			if (!name) {
+				name = await input({
+					message: "Enter provider name:",
+					validate: (value) =>
+						value.trim() !== "" || "Provider name is required",
+				});
+			}
+
+			// Check if provider already exists
+			if (providersData.providers[name]) {
+				if (!opts.force) {
+					const overwrite = await confirm({
+						message: `Provider "${name}" already exists. Overwrite?`,
+						default: false,
+					});
+					if (!overwrite) {
+						console.log(chalk.yellow("Cancelled."));
+						return;
+					}
+				}
+			}
+
+			// Step 2: Get base URL
+			let baseUrl = opts.url;
+			if (!baseUrl) {
+				baseUrl = await input({
+					message: "Enter base URL (e.g., https://api.openai.com/v1):",
+					validate: (value) => {
+						try {
+							new URL(value);
+							return true;
+						} catch {
+							return "Please enter a valid URL";
+						}
+					},
+				});
+			}
+
+			// Step 3: Get API key
+			let apiKey = opts.key;
+			if (!apiKey) {
+				apiKey = await input({
+					message: "Enter API key:",
+					validate: (value) => value.trim() !== "" || "API key is required",
+				});
+			}
+
+			// Step 4: Get API type
+			let api = opts.api;
+			if (!api) {
+				api = await select({
+					message: "Select API type:",
+					choices: [
+						{
+							name: "OpenAI Completions (compatible with most providers)",
+							value: "openai-completions",
+						},
+						{ name: "Anthropic Messages", value: "anthropic-messages" },
+						{ name: "Responses (OpenAI native)", value: "responses" },
+					],
+				});
+			}
+
+			// Step 5: Fetch or add models
+			let models = [];
+
+			if (
+				opts.fetch ||
+				(!opts.name &&
+					(await confirm({
+						message: "Auto-fetch models from API?",
+						default: true,
+					})))
+			) {
+				console.log(chalk.dim("\nFetching models from API..."));
+				const result = await fetchModelsFromAPI(baseUrl, apiKey, api);
+
+				if (result.success && result.models.length > 0) {
+					console.log(chalk.green(`✓ Found ${result.models.length} models`));
+
+					let selected;
+
+					// 如果指定了--all或者非交互模式，选择所有模型
+					if (opts.all || opts.name) {
+						selected = result.models.map((m) => m.id);
+						console.log(
+							chalk.dim(`Auto-selected all ${selected.length} models`),
+						);
+					} else {
+						// 让用户选择要添加的模型
+						selected = await checkbox({
+							message: "Select models to add:",
+							choices: result.models.map((m) => ({
+								name: `${m.id.padEnd(40)} ctx:${m.contextWindow || "?"}`,
+								value: m.id,
+								checked: true,
+							})),
+							instructions: {
+								navigator: "↑↓ navigate",
+								select: "space select",
+								all: "a toggle all",
+							},
+						});
+					}
+
+					// 配置选中的模型
+					for (const modelId of selected) {
+						const model = result.models.find((m) => m.id === modelId);
+						const defaults = getModelDefaults(modelId);
+						const configured = {
+							id: modelId,
+							name: model?.name || modelId,
+							contextWindow: model?.contextWindow || defaults.contextWindow,
+							maxTokens: model?.maxTokens || defaults.maxTokens,
+							reasoning: model?.reasoning || defaults.reasoning,
+							input: model?.input || ["text"],
+						};
+						models.push(configured);
+					}
+				} else {
+					console.log(
+						chalk.yellow(`⚠ Could not fetch models: ${result.error}`),
+					);
+					console.log(chalk.dim("You can add models manually."));
+				}
+			}
+
+			// 如果没有通过API获取到模型，手动添加
+			if (models.length === 0) {
+				models = await addModelsInteractively();
+			}
+
+			if (models.length === 0) {
+				console.log(chalk.yellow("No models added. Cancelled."));
+				return;
+			}
+
+			// Save provider
+			providersData.providers[name] = {
+				name,
+				baseUrl,
+				apiKey,
+				api,
+				models,
+				createdAt: new Date().toISOString(),
+			};
+
+			saveProviders(providersData);
+			console.log(
+				chalk.green(
+					`\n✓ Provider "${name}" added with ${models.length} model(s)!`,
+				),
+			);
+			console.log(chalk.dim(`  Saved to: config/providers.json`));
+		});
+
+	// ── cpc list ─────────────────────────────────────────────────
+	program
+		.command("list")
+		.description("List all configured providers")
+		.option("--detail", "Show model details")
+		.action((opts) => {
+			const providersData = loadProviders();
+			const providers = Object.entries(providersData.providers);
+
+			console.log(
+				chalk.bold(
+					"\n╔══════════════════════════════════════════════════════════╗",
+				),
+			);
+			console.log(
+				chalk.bold(
+					"║                   Custom Providers                      ║",
+				),
+			);
+			console.log(
+				chalk.bold(
+					"╚══════════════════════════════════════════════════════════╝",
+				),
+			);
+			console.log();
+
+			if (providers.length === 0) {
+				console.log(chalk.dim("  No providers configured."));
+				console.log(chalk.dim("  Use `cpc add` to add a new provider."));
+				console.log();
+				return;
+			}
+
+			for (const [name, config] of providers) {
+				console.log(chalk.bold.blue(`[${name}]`));
+				console.log(`  URL:     ${chalk.dim(config.baseUrl)}`);
+				console.log(`  API:     ${chalk.dim(config.api)}`);
+				console.log(`  Models:  ${chalk.dim(config.models?.length || 0)}`);
+
+				if (opts.detail && config.models?.length > 0) {
+					console.log(chalk.dim("  ─────────────────────────────────────"));
+					for (const m of config.models) {
+						console.log(`  ${chalk.green(m.id)}`);
+						console.log(`    Context: ${m.contextWindow} tokens`);
+						console.log(`    MaxOut:  ${m.maxTokens} tokens`);
+						console.log(`    Reason:  ${m.reasoning ? "Yes" : "No"}`);
+					}
+				}
+
+				console.log(`  Created: ${chalk.dim(config.createdAt)}`);
+				console.log();
+			}
+		});
+
+	// ── cpc models ───────────────────────────────────────────────
+	program
+		.command("models [providerName]")
+		.description("List models for a provider")
+		.action(async (providerName) => {
+			const providersData = loadProviders();
+			const providers = Object.entries(providersData.providers);
+
+			if (providers.length === 0) {
+				console.log(chalk.yellow("No providers configured."));
+				return;
+			}
+
+			if (!providerName) {
+				providerName = await select({
+					message: "Select provider:",
+					choices: providers.map(([name, config]) => ({
+						name: `${name.padEnd(20)} (${config.models?.length || 0} models)`,
+						value: name,
+					})),
+				});
+			}
+
+			const config = providersData.providers[providerName];
+			if (!config) {
+				console.error(chalk.red(`Provider "${providerName}" not found.`));
+				process.exit(1);
+			}
+
+			console.log(chalk.bold(`\nModels for ${providerName}:\n`));
+
+			if (!config.models || config.models.length === 0) {
+				console.log(chalk.dim("  No models configured."));
+				return;
+			}
+
+			// 表格输出
+			console.log(
+				chalk.dim(
+					"  Model ID                                  Context    MaxOut   Reasoning",
+				),
+			);
+			console.log(
+				chalk.dim(
+					"  ───────────────────────────────────────── ────────── ──────── ──────────",
+				),
+			);
+
+			for (const m of config.models) {
+				const id = m.id.padEnd(42);
+				const ctx = String(m.contextWindow || "?").padEnd(10);
+				const max = String(m.maxTokens || "?").padEnd(8);
+				const reason = m.reasoning ? "Yes" : "No";
+				console.log(`  ${chalk.green(id)} ${ctx} ${max} ${reason}`);
+			}
+			console.log();
+		});
+
+	// ── cpc edit-model ───────────────────────────────────────────
+	program
+		.command("edit-model [providerName]")
+		.description("Edit model configuration for a provider")
+		.action(async (providerName) => {
+			const providersData = loadProviders();
+			const providers = Object.entries(providersData.providers);
+
+			if (providers.length === 0) {
+				console.log(chalk.yellow("No providers configured."));
+				return;
+			}
+
+			if (!providerName) {
+				providerName = await select({
+					message: "Select provider:",
+					choices: providers.map(([name, config]) => ({
+						name: `${name.padEnd(20)} (${config.models?.length || 0} models)`,
+						value: name,
+					})),
+				});
+			}
+
+			const config = providersData.providers[providerName];
+			if (!config) {
+				console.error(chalk.red(`Provider "${providerName}" not found.`));
+				process.exit(1);
+			}
+
+			// 选择操作
+			const action = await select({
+				message: "Select action:",
+				choices: [
+					{ name: "Add model", value: "add" },
+					{ name: "Edit model", value: "edit" },
+					{ name: "Remove model", value: "remove" },
+					{ name: "Cancel", value: "cancel" },
+				],
+			});
+
+			if (action === "cancel") {
+				return;
+			}
+
+			if (action === "add") {
+				const newModels = await addModelsInteractively(config.models || []);
+				config.models = newModels;
+				saveProviders(providersData);
+				console.log(chalk.green(`✓ Models updated for "${providerName}"`));
+			} else if (action === "edit") {
+				if (!config.models || config.models.length === 0) {
+					console.log(chalk.yellow("No models to edit."));
+					return;
+				}
+
+				const modelId = await select({
+					message: "Select model to edit:",
+					choices: config.models.map((m) => ({
+						name: `${m.id.padEnd(40)} ctx:${m.contextWindow}`,
+						value: m.id,
+					})),
+				});
+
+				const model = config.models.find((m) => m.id === modelId);
+				const updated = await configureModel(modelId, model);
+
+				const index = config.models.findIndex((m) => m.id === modelId);
+				config.models[index] = updated;
+				saveProviders(providersData);
+				console.log(chalk.green(`✓ Model "${modelId}" updated`));
+			} else if (action === "remove") {
+				if (!config.models || config.models.length === 0) {
+					console.log(chalk.yellow("No models to remove."));
+					return;
+				}
+
+				const selected = await checkbox({
+					message: "Select models to remove:",
+					choices: config.models.map((m) => ({
+						name: m.id,
+						value: m.id,
+					})),
+				});
+
+				config.models = config.models.filter((m) => !selected.includes(m.id));
+				saveProviders(providersData);
+				console.log(chalk.green(`✓ Removed ${selected.length} model(s)`));
+			}
+		});
+
+	// ── cpc fetch-models ─────────────────────────────────────────
+	program
+		.command("fetch-models [providerName]")
+		.description("Fetch latest models from provider API")
+		.option("--merge", "Merge with existing models (default: replace)")
+		.action(async (providerName, opts) => {
+			const providersData = loadProviders();
+			const providers = Object.entries(providersData.providers);
+
+			if (providers.length === 0) {
+				console.log(chalk.yellow("No providers configured."));
+				return;
+			}
+
+			if (!providerName) {
+				providerName = await select({
+					message: "Select provider:",
+					choices: providers.map(([name, config]) => ({
+						name: `${name.padEnd(20)} ${config.baseUrl}`,
+						value: name,
+					})),
+				});
+			}
+
+			const config = providersData.providers[providerName];
+			if (!config) {
+				console.error(chalk.red(`Provider "${providerName}" not found.`));
+				process.exit(1);
+			}
+
+			console.log(chalk.dim(`\nFetching models from ${config.baseUrl}...`));
+			const result = await fetchModelsFromAPI(
+				config.baseUrl,
+				config.apiKey,
+				config.api,
+			);
+
+			if (!result.success) {
+				console.log(chalk.red(`✗ Failed to fetch models: ${result.error}`));
+				return;
+			}
+
+			console.log(chalk.green(`✓ Found ${result.models.length} models`));
+
+			// 让用户选择要添加的模型
+			const existingIds = (config.models || []).map((m) => m.id);
+			const newModels = result.models.filter(
+				(m) => !existingIds.includes(m.id),
+			);
+
+			if (newModels.length === 0) {
+				console.log(chalk.dim("All models already configured."));
+				return;
+			}
+
+			console.log(chalk.dim(`\n${newModels.length} new models available:`));
+
+			const selected = await checkbox({
+				message: "Select models to add:",
+				choices: newModels.map((m) => ({
+					name: m.id,
+					value: m.id,
+					checked: true,
+				})),
+				instructions: {
+					navigator: "↑↓ navigate",
+					select: "space select",
+					all: "a toggle all",
+				},
+			});
+
+			if (selected.length === 0) {
+				console.log(chalk.yellow("No models selected."));
+				return;
+			}
+
+			// 配置选中的模型
+			for (const modelId of selected) {
+				const model = result.models.find((m) => m.id === modelId);
+				const defaults = getModelDefaults(modelId);
+				const configured = {
+					id: modelId,
+					name: model?.name || modelId,
+					contextWindow: model?.contextWindow || defaults.contextWindow,
+					maxTokens: model?.maxTokens || defaults.maxTokens,
+					reasoning: model?.reasoning || defaults.reasoning,
+					input: model?.input || ["text"],
+				};
+
+				if (opts.merge) {
+					config.models = config.models || [];
+					config.models.push(configured);
+				} else {
+					// 替换模式：保留现有的，添加新的
+					if (!config.models) config.models = [];
+					if (!config.models.find((m) => m.id === modelId)) {
+						config.models.push(configured);
+					}
+				}
+			}
+
+			saveProviders(providersData);
+			console.log(
+				chalk.green(
+					`\n✓ Added ${selected.length} model(s) to "${providerName}"`,
+				),
+			);
+		});
+
+	// ── cpc remove ───────────────────────────────────────────────
+	program
+		.command("remove [name]")
+		.description("Remove a provider")
+		.option("--force", "Skip confirmation prompt")
+		.action(async (name, opts) => {
+			const providersData = loadProviders();
+			const providers = Object.keys(providersData.providers);
+
+			if (providers.length === 0) {
+				console.log(chalk.yellow("No providers configured."));
+				return;
+			}
+
+			if (!name) {
+				name = await select({
+					message: "Select provider to remove:",
+					choices: providers.map((p) => ({ name: p, value: p })),
+				});
+			}
+
+			if (!providersData.providers[name]) {
+				console.error(chalk.red(`Provider "${name}" not found.`));
+				process.exit(1);
+			}
+
+			if (!opts.force) {
+				const modelCount = providersData.providers[name].models?.length || 0;
+				const confirmed = await confirm({
+					message: `Remove provider "${name}" with ${modelCount} model(s)?`,
+					default: false,
+				});
+
+				if (!confirmed) {
+					console.log(chalk.yellow("Cancelled."));
+					return;
+				}
+			}
+
+			delete providersData.providers[name];
+			saveProviders(providersData);
+			console.log(chalk.green(`✓ Provider "${name}" removed.`));
+		});
+
+	// ── cpc install ──────────────────────────────────────────────
+	program
+		.command("install [providerName]")
+		.description("Install a provider to agent(s)")
+		.option("--agent <agent>", "Target agent")
+		.option("--model <model>", "Install only specific model")
+		.option("--all", "Install all models")
+		.option("--first", "Install only first model")
+		.action(async (providerName, opts) => {
+			const registry = loadRegistry(repoRoot);
+			const agents = getAgents(registry);
+			const providersData = loadProviders();
+			const providers = Object.entries(providersData.providers);
+
+			if (providers.length === 0) {
+				console.log(chalk.yellow("No providers configured."));
+				console.log(chalk.dim("Use `cpc add` to add a new provider first."));
+				return;
+			}
+
+			// Step 1: Select provider
+			if (!providerName) {
+				providerName = await select({
+					message: "Select provider to install:",
+					choices: providers.map(([name, config]) => ({
+						name: `${name.padEnd(20)} (${config.models?.length || 0} models)`,
+						value: name,
+					})),
+				});
+			}
+
+			const provider = providersData.providers[providerName];
+			if (!provider) {
+				console.error(chalk.red(`Provider "${providerName}" not found.`));
+				process.exit(1);
+			}
+
+			// Step 2: Select model (optional)
+			const installProvider = { ...provider };
+
+			if (opts.model) {
+				const model = provider.models.find((m) => m.id === opts.model);
+				if (!model) {
+					console.error(
+						chalk.red(
+							`Model "${opts.model}" not found in provider "${providerName}".`,
+						),
+					);
+					process.exit(1);
+				}
+				installProvider.models = [model];
+			} else if (opts.all) {
+				// 使用所有模型
+				installProvider.models = provider.models;
+			} else if (opts.first) {
+				// 只使用第一个模型
+				installProvider.models = [provider.models[0]];
+			} else if (provider.models.length > 1) {
+				const action = await select({
+					message: "Select models to install:",
+					choices: [
+						{ name: `All ${provider.models.length} models`, value: "all" },
+						{ name: "Select specific models", value: "select" },
+						{ name: "Only first model", value: "first" },
+					],
+				});
+
+				if (action === "select") {
+					const selected = await checkbox({
+						message: "Select models:",
+						choices: provider.models.map((m) => ({
+							name: `${m.id.padEnd(40)} ctx:${m.contextWindow}`,
+							value: m.id,
+							checked: true,
+						})),
+					});
+					installProvider.models = provider.models.filter((m) =>
+						selected.includes(m.id),
+					);
+				} else if (action === "first") {
+					installProvider.models = [provider.models[0]];
+				}
+			}
+
+			// Step 3: Select agent(s)
+			let agentId;
+			if (opts.agent) {
+				agentId = opts.agent;
+			} else {
+				agentId = await select({
+					message: "Select target agent:",
+					choices: [
+						...Object.entries(agents).map(([id, a]) => ({
+							name: `${id.padEnd(14)} ${a.description || ""}`,
+							value: id,
+						})),
+						{ name: "─────────", value: "__separator__", disabled: true },
+						{ name: "all agents", value: "all" },
+					],
+				});
+			}
+
+			const agentIds = agentId === "all" ? Object.keys(agents) : [agentId];
+
+			// Step 4: Install provider to agents
+			console.log();
+			let successCount = 0;
+
+			for (const aid of agentIds) {
+				const agentDef = agents[aid];
+				if (!agentDef) {
+					console.log(chalk.red(`Unknown agent: ${aid}`));
+					continue;
+				}
+
+				const agent = resolveAgentPaths(agentDef);
+				console.log(chalk.bold(`→ ${aid}`));
+				console.log(chalk.dim(`  ${installProvider.models.length} model(s)`));
+
+				const success = installProviderToAgent(
+					aid,
+					installProvider,
+					agent.home,
+				);
+				if (success) successCount++;
+				console.log();
+			}
+
+			if (successCount > 0) {
+				console.log(
+					chalk.green.bold(
+						`✓ Provider installed to ${successCount} agent(s) with ${installProvider.models.length} model(s)!`,
+					),
+				);
+			} else {
+				console.log(chalk.yellow("No agents were updated."));
+			}
+		});
+
+	// ── cpc test ─────────────────────────────────────────────────
+	program
+		.command("test [providerName]")
+		.description("Test a provider connection")
+		.action(async (providerName) => {
+			const providersData = loadProviders();
+			const providers = Object.entries(providersData.providers);
+
+			if (providers.length === 0) {
+				console.log(chalk.yellow("No providers configured."));
+				return;
+			}
+
+			if (!providerName) {
+				providerName = await select({
+					message: "Select provider to test:",
+					choices: providers.map(([name, config]) => ({
+						name: `${name.padEnd(20)} ${config.baseUrl}`,
+						value: name,
+					})),
+				});
+			}
+
+			const provider = providersData.providers[providerName];
+			if (!provider) {
+				console.error(chalk.red(`Provider "${providerName}" not found.`));
+				process.exit(1);
+			}
+
+			console.log(chalk.bold(`\nTesting provider: ${providerName}`));
+			console.log(chalk.dim(`URL: ${provider.baseUrl}`));
+			console.log(chalk.dim(`API: ${provider.api}`));
+			console.log(chalk.dim(`Models: ${provider.models?.length || 0}`));
+			console.log();
+
+			// Test 1: Connection
+			console.log(chalk.dim("1. Testing connection..."));
+			try {
+				const response = await fetch(provider.baseUrl, {
+					method: "GET",
+					headers: {
+						Authorization: `Bearer ${provider.apiKey}`,
+						"Content-Type": "application/json",
+					},
+					signal: AbortSignal.timeout(5000),
+				});
+
+				if (response.ok) {
+					console.log(chalk.green("   ✓ Connection successful"));
+				} else {
+					console.log(chalk.yellow(`   ⚠ Status: ${response.status}`));
+				}
+			} catch (err) {
+				if (err.name === "AbortError" || err.name === "TimeoutError") {
+					console.log(chalk.red("   ✗ Connection timeout"));
+				} else {
+					console.log(chalk.red(`   ✗ Connection failed: ${err.message}`));
+				}
+			}
+
+			// Test 2: Model listing (if supported)
+			if (provider.api !== "anthropic-messages") {
+				console.log(chalk.dim("\n2. Testing model listing..."));
+				const result = await fetchModelsFromAPI(
+					provider.baseUrl,
+					provider.apiKey,
+					provider.api,
+				);
+
+				if (result.success) {
+					console.log(chalk.green(`   ✓ Found ${result.models.length} models`));
+
+					// 检查配置的模型是否存在
+					const configuredIds = (provider.models || []).map((m) => m.id);
+					const availableIds = result.models.map((m) => m.id);
+					const missing = configuredIds.filter(
+						(id) => !availableIds.includes(id),
+					);
+
+					if (missing.length > 0) {
+						console.log(
+							chalk.yellow(
+								`   ⚠ ${missing.length} configured model(s) not found in API`,
+							),
+						);
+					}
+				} else {
+					console.log(chalk.yellow(`   ⚠ ${result.error}`));
+				}
+			}
+
+			console.log();
+		});
+
+	// ── cpc export ───────────────────────────────────────────────
+	program
+		.command("export [providerName]")
+		.description("Export provider configuration to a file")
+		.option("--output <file>", "Output file path")
+		.action(async (providerName, opts) => {
+			const providersData = loadProviders();
+			const providers = Object.entries(providersData.providers);
+
+			if (providers.length === 0) {
+				console.log(chalk.yellow("No providers configured."));
+				return;
+			}
+
+			if (!providerName) {
+				providerName = await select({
+					message: "Select provider to export:",
+					choices: providers.map(([name, config]) => ({
+						name: `${name.padEnd(20)} (${config.models?.length || 0} models)`,
+						value: name,
+					})),
+				});
+			}
+
+			const provider = providersData.providers[providerName];
+			if (!provider) {
+				console.error(chalk.red(`Provider "${providerName}" not found.`));
+				process.exit(1);
+			}
+
+			const outputFile = opts.output || `${providerName}-provider.json`;
+
+			const exportData = {
+				version: "2.0",
+				exportedAt: new Date().toISOString(),
+				provider: {
+					...provider,
+					apiKey: provider.apiKey ? "***" : undefined,
+				},
+			};
+
+			try {
+				writeFileSync(outputFile, JSON.stringify(exportData, null, 2));
+				console.log(chalk.green(`✓ Provider exported to: ${outputFile}`));
+				console.log(chalk.dim(`  Models: ${provider.models?.length || 0}`));
+				console.log(chalk.dim("  Note: API key has been masked for security."));
+			} catch (err) {
+				console.error(chalk.red(`Failed to export: ${err.message}`));
+				process.exit(1);
+			}
+		});
+
+	// ── cpc import ───────────────────────────────────────────────
+	program
+		.command("import <file>")
+		.description("Import provider configuration from a file")
+		.option("--key <key>", "API key (required if exported key is masked)")
+		.option("--force", "Overwrite existing provider without confirmation")
+		.action(async (file, opts) => {
+			const providersData = loadProviders();
+
+			if (!existsSync(file)) {
+				console.error(chalk.red(`File not found: ${file}`));
+				process.exit(1);
+			}
+
+			try {
+				const content = readFileSync(file, "utf8");
+				const importData = JSON.parse(content);
+
+				if (!importData.provider || !importData.provider.name) {
+					console.error(chalk.red("Invalid provider file format."));
+					process.exit(1);
+				}
+
+				const provider = importData.provider;
+
+				if (providersData.providers[provider.name]) {
+					if (!opts.force) {
+						const overwrite = await confirm({
+							message: `Provider "${provider.name}" already exists. Overwrite?`,
+							default: false,
+						});
+
+						if (!overwrite) {
+							console.log(chalk.yellow("Cancelled."));
+							return;
+						}
+					}
+				}
+
+				if (provider.apiKey === "***") {
+					if (opts.key) {
+						provider.apiKey = opts.key;
+					} else {
+						provider.apiKey = await input({
+							message: "Enter API key for this provider:",
+							validate: (value) => value.trim() !== "" || "API key is required",
+						});
+					}
+				}
+
+				providersData.providers[provider.name] = {
+					...provider,
+					importedAt: new Date().toISOString(),
+				};
+
+				saveProviders(providersData);
+				console.log(
+					chalk.green(`✓ Provider "${provider.name}" imported successfully!`),
+				);
+				console.log(chalk.dim(`  Models: ${provider.models?.length || 0}`));
+			} catch (err) {
+				console.error(chalk.red(`Failed to import: ${err.message}`));
+				process.exit(1);
+			}
+		});
+
+	// ── cpc list-installed ───────────────────────────────────────
+	program
+		.command("list-installed")
+		.description("List providers installed in agents")
+		.option("--agent <agent>", "Filter by agent")
+		.action((opts) => {
+			const registry = loadRegistry(repoRoot);
+			const agents = getAgents(registry);
+
+			console.log(chalk.bold("\nInstalled Providers\n"));
+
+			const agentIds = opts.agent ? [opts.agent] : Object.keys(agents);
+
+			for (const aid of agentIds) {
+				const agentDef = agents[aid];
+				if (!agentDef) continue;
+
+				const agent = resolveAgentPaths(agentDef);
+				console.log(chalk.bold(`${agent.name} (${aid})`));
+
+				try {
+					switch (aid) {
+						case "claude-code": {
+							const settingsPath = join(agent.home, "settings.json");
+							if (existsSync(settingsPath)) {
+								const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+								if (settings.env) {
+									const baseUrl = settings.env.ANTHROPIC_BASE_URL;
+									const model = settings.env.ANTHROPIC_MODEL;
+									if (baseUrl) {
+										console.log(`  Base URL: ${chalk.dim(baseUrl)}`);
+										console.log(`  Model:    ${chalk.dim(model || "not set")}`);
+									} else {
+										console.log(chalk.dim("  No custom provider configured"));
+									}
+								}
+							} else {
+								console.log(chalk.dim("  Settings file not found"));
+							}
+							break;
+						}
+
+						case "pi": {
+							const modelsPath = join(agent.home, "models.json");
+							if (existsSync(modelsPath)) {
+								const models = JSON.parse(readFileSync(modelsPath, "utf8"));
+								if (
+									models.providers &&
+									Object.keys(models.providers).length > 0
+								) {
+									for (const [name, config] of Object.entries(
+										models.providers,
+									)) {
+										console.log(`  ${chalk.blue(name)}`);
+										console.log(`    URL:    ${chalk.dim(config.baseUrl)}`);
+										console.log(`    API:    ${chalk.dim(config.api)}`);
+										console.log(
+											`    Models: ${chalk.dim(config.models?.length || 0)}`,
+										);
+									}
+								} else {
+									console.log(chalk.dim("  No providers configured"));
+								}
+							} else {
+								console.log(chalk.dim("  Models file not found"));
+							}
+							break;
+						}
+
+						case "hermes": {
+							const configPath = join(agent.home, "config.yaml");
+							if (existsSync(configPath)) {
+								const configData = yaml.load(readFileSync(configPath, "utf8"));
+								if (configData.model) {
+									console.log(
+										`  Provider: ${chalk.dim(configData.model.provider || "not set")}`,
+									);
+									console.log(
+										`  Base URL: ${chalk.dim(configData.model.base_url || "not set")}`,
+									);
+									console.log(
+										`  Model:    ${chalk.dim(configData.model.default || "not set")}`,
+									);
+								} else {
+									console.log(chalk.dim("  No provider configured"));
+								}
+							} else {
+								console.log(chalk.dim("  Config file not found"));
+							}
+							break;
+						}
+
+						case "codex": {
+							const configPath = join(agent.home, "config.toml");
+							if (existsSync(configPath)) {
+								const content = readFileSync(configPath, "utf8");
+								const providerMatch = content.match(/model_provider = "(.*?)"/);
+								const modelMatch = content.match(/model = "(.*?)"/);
+								if (providerMatch) {
+									console.log(`  Provider: ${chalk.dim(providerMatch[1])}`);
+									console.log(
+										`  Model:    ${chalk.dim(modelMatch ? modelMatch[1] : "not set")}`,
+									);
+								} else {
+									console.log(chalk.dim("  No provider configured"));
+								}
+							} else {
+								console.log(chalk.dim("  Config file not found"));
+							}
+							break;
+						}
+
+						case "openclaw": {
+							const configPath = join(agent.home, "openclaw.json");
+							if (existsSync(configPath)) {
+								const configData = JSON.parse(readFileSync(configPath, "utf8"));
+								if (configData.models && configData.models.providers) {
+									for (const [name, config] of Object.entries(
+										configData.models.providers,
+									)) {
+										console.log(`  ${chalk.blue(name)}`);
+										console.log(`    URL:    ${chalk.dim(config.baseUrl)}`);
+										console.log(`    API:    ${chalk.dim(config.api)}`);
+										console.log(
+											`    Models: ${chalk.dim(config.models?.length || 0)}`,
+										);
+									}
+								} else {
+									console.log(chalk.dim("  No providers configured"));
+								}
+							} else {
+								console.log(chalk.dim("  Config file not found"));
+							}
+							break;
+						}
+
+						case "omp": {
+							const modelsPath = join(agent.home, "models.yml");
+							if (existsSync(modelsPath)) {
+								const modelsData = yaml.load(readFileSync(modelsPath, "utf8"));
+								if (
+									modelsData.providers &&
+									Object.keys(modelsData.providers).length > 0
+								) {
+									for (const [name, config] of Object.entries(
+										modelsData.providers,
+									)) {
+										console.log(`  ${chalk.blue(name)}`);
+										console.log(`    URL:    ${chalk.dim(config.baseUrl)}`);
+										console.log(`    API:    ${chalk.dim(config.api)}`);
+										console.log(
+											`    Models: ${chalk.dim(config.models?.length || 0)}`,
+										);
+									}
+								} else {
+									console.log(chalk.dim("  No providers configured"));
+								}
+							} else {
+								console.log(chalk.dim("  Models file not found"));
+							}
+							break;
+						}
+
+						default:
+							console.log(chalk.dim("  Unsupported agent"));
+					}
+				} catch (err) {
+					console.log(chalk.red(`  Error reading config: ${err.message}`));
+				}
+
+				console.log();
+			}
+		});
+}