march-control-cli 0.1.3

package/core/index.js

@@ -0,0 +1,1293 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import { Command } from "commander";
+import inquirer from "inquirer";
+import {
+  applyClonedProvider,
+  applyEditedProvider,
+  applyProvider,
+  applyRemovedProvider,
+  applyStoredProvider
+} from "./apply.js";
+import {
+  APP_NAME,
+  DEFAULT_BASE_URL,
+  DEFAULT_CANDIDATE_BASE_URLS,
+  DEFAULT_OPENCLAW_BASE_URL,
+  DEFAULT_PLATFORM_SELECTION,
+  DEFAULT_PRIMARY_MODEL,
+  DEFAULT_PROVIDER_NAME,
+  PLATFORM_META,
+  SUPPORTED_PLATFORMS
+} from "./constants.js";
+import { getCurrentProvider, listProviders } from "./store.js";
+import {
+  buildOpenClawBaseUrl,
+  dedupeStrings,
+  formatLatency,
+  maskApiKey,
+  normalizeBaseUrl,
+  parseCommaList
+} from "./utils.js";
+import { getBestProbeResult, probeBaseUrls } from "./probe.js";
+import { getPreset, listPresets, removePreset, upsertPreset } from "./presets.js";
+
+function collect(value, previous) {
+  previous.push(value);
+  return previous;
+}
+
+function printBrandBanner() {
+  const logo = [
+    " __  __    _    ____   ____ _   _ ",
+    "|  \\/  |  / \\  |  _ \\ / ___| | | |",
+    "| |\\/| | / _ \\ | |_) | |   | |_| |",
+    "| |  | |/ ___ \\|  _ <| |___|  _  |",
+    "|_|  |_/_/   \\_\\_| \\_\\\\____|_| |_|"
+  ];
+
+  console.log("");
+  console.log(chalk.gray("┌────────────────────────────────────────────────────────────┐"));
+  for (const line of logo) {
+    console.log(chalk.cyanBright(`│ ${line.padEnd(58, " ")}│`));
+  }
+  console.log(chalk.yellow("│                March 配置管理工具                         │"));
+  console.log(chalk.gray("│        Codex / OpenCode / OpenClaw 一键管理              │"));
+  console.log(chalk.gray("└────────────────────────────────────────────────────────────┘"));
+}
+
+function printSuccessBanner() {
+  console.log("");
+  console.log(chalk.black.bgGreenBright(" 配置完成 "));
+}
+
+function printHeader(title) {
+  console.log(chalk.cyan(`\n${title}`));
+}
+
+function printSetupStep(step, title, detail = "") {
+  console.log(chalk.cyan(`\n[${step}/4] ${title}`));
+  if (detail) {
+    console.log(chalk.gray(detail));
+  }
+}
+
+function getPlatformLabelList(platforms) {
+  return platforms.map((platform) => PLATFORM_META[platform].label).join(" / ");
+}
+
+function printSetupPlan({
+  modeLabel,
+  presetName,
+  providerName,
+  model,
+  platforms,
+  commonBaseUrl,
+  openclawBaseUrl,
+  probeEnabled,
+  backupEnabled
+}) {
+  printHeader("安装摘要");
+  console.log(`模式: ${modeLabel}`);
+  console.log(`平台: ${getPlatformLabelList(platforms)}`);
+  console.log(`配置名称: ${providerName}`);
+  console.log(`模型: ${model || DEFAULT_PRIMARY_MODEL}`);
+  console.log(`Codex/OpenCode 地址: ${commonBaseUrl}`);
+  if (platforms.includes("openclaw")) {
+    console.log(`OpenClaw 地址: ${openclawBaseUrl}`);
+  }
+  console.log(`测速: ${probeEnabled ? "开启" : "关闭"}`);
+  console.log(`备份: ${backupEnabled ? "开启" : "关闭"}`);
+  if (presetName) {
+    console.log(`预设: ${presetName}`);
+  }
+}
+
+function printNextActions() {
+  printHeader("下一步建议");
+  console.log("1) march menu");
+  console.log("2) march cx list");
+  console.log("3) march preset list");
+}
+
+function printProviderSummary(platform, provider) {
+  const meta = PLATFORM_META[platform];
+  console.log(chalk.green(`\n${meta.label} 当前启用配置`));
+  console.log(`名称: ${provider.name}`);
+  console.log(`ID: ${provider.id}`);
+  console.log(`地址: ${provider.baseUrl}`);
+  console.log(`模型: ${provider.model || DEFAULT_PRIMARY_MODEL}`);
+  console.log(`API Key: ${maskApiKey(provider.apiKey)}`);
+}
+
+function printProviderList(platform) {
+  const meta = PLATFORM_META[platform];
+  const providers = listProviders(platform);
+  const current = getCurrentProvider(platform);
+
+  printHeader(`${meta.label} 已保存配置`);
+
+  if (providers.length === 0) {
+    console.log(chalk.gray("还没有保存任何配置。"));
+    return;
+  }
+
+  for (const provider of providers) {
+    const marker = current?.id === provider.id ? chalk.green("[当前]") : "";
+    console.log(`${provider.name} ${marker}`.trim());
+    console.log(`  ${provider.baseUrl}`);
+  }
+}
+
+function printPresetList() {
+  const presets = listPresets();
+  printHeader("可用预设");
+
+  if (presets.length === 0) {
+    console.log(chalk.gray("暂无预设。"));
+    return;
+  }
+
+  for (const preset of presets) {
+    const sourceLabel = preset.readonly ? chalk.gray("内置") : chalk.green("自定义");
+    console.log(`${preset.name} (${sourceLabel})`);
+    console.log(`  提供方: ${preset.providerName}`);
+    console.log(`  通用地址: ${preset.commonBaseUrl}`);
+    console.log(`  OpenClaw 地址: ${preset.openclawBaseUrl}`);
+    console.log(`  模型: ${preset.model || DEFAULT_PRIMARY_MODEL}`);
+  }
+}
+
+function printPresetSummary(title, preset) {
+  printHeader(title);
+  console.log(`名称: ${preset.name}`);
+  console.log(`提供方: ${preset.providerName}`);
+  console.log(`通用地址: ${preset.commonBaseUrl}`);
+  console.log(`OpenClaw 地址: ${preset.openclawBaseUrl}`);
+  console.log(`模型: ${preset.model || DEFAULT_PRIMARY_MODEL}`);
+  console.log(`来源: ${preset.source || (preset.readonly ? "内置" : "自定义")}`);
+}
+
+function printProbeResults(label, results) {
+  printHeader(`${label} 地址测速结果`);
+
+  for (const result of results) {
+    const status = result.ok ? chalk.green("可用") : chalk.red("失败");
+    console.log(`${status} ${result.baseUrl} (${formatLatency(result)})`);
+  }
+}
+
+function parsePlatforms(platformsArg) {
+  if (!platformsArg) {
+    return [...DEFAULT_PLATFORM_SELECTION];
+  }
+
+  const values = parseCommaList(platformsArg).map((value) => value.toLowerCase());
+  const aliasMap = {
+    cx: "codex",
+    oc: "opencode",
+    ow: "openclaw"
+  };
+
+  const resolved = dedupeStrings(
+    values.map((value) => aliasMap[value] || value).filter((value) => SUPPORTED_PLATFORMS.includes(value))
+  );
+
+  if (resolved.length === 0) {
+    throw new Error(`不支持的平台参数: ${platformsArg}`);
+  }
+
+  return resolved;
+}
+
+async function resolveBaseUrl(label, rawOptions) {
+  const shouldProbe = rawOptions.probe !== false;
+  const confirmChoice = rawOptions.confirmChoice === true;
+  const candidates = dedupeStrings(rawOptions.candidates || []);
+
+  if (candidates.length === 0) {
+    throw new Error(`没有可用候选地址: ${label}`);
+  }
+
+  if (!shouldProbe) {
+    return normalizeBaseUrl(candidates[0]);
+  }
+
+  const results = await probeBaseUrls(candidates, { timeoutMs: 5000 });
+  printProbeResults(label, results);
+  const best = getBestProbeResult(results);
+
+  if (!best) {
+    throw new Error(`无法确定可用地址: ${label}`);
+  }
+
+  if (!rawOptions.interactive || results.length === 1 || !confirmChoice) {
+    return normalizeBaseUrl(best.baseUrl);
+  }
+
+  const answer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "baseUrl",
+      message: `请选择 ${label} 使用地址`,
+      choices: results.map((result) => ({
+        name: `${result.baseUrl} (${formatLatency(result)})`,
+        value: result.baseUrl
+      })),
+      default: best.baseUrl
+    }
+  ]);
+
+  return normalizeBaseUrl(answer.baseUrl);
+}
+
+async function promptForApiKey(initialValue) {
+  if (initialValue?.trim()) {
+    return initialValue.trim();
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "请输入 API Key",
+      mask: "*",
+      validate(value) {
+        return value.trim() ? true : "API Key 不能为空";
+      }
+    }
+  ]);
+
+  return answers.apiKey.trim();
+}
+
+async function promptForSetupDefaults(rawOptions) {
+  if (!rawOptions.interactive || rawOptions.advanced !== true) {
+    return {
+      providerName: rawOptions.providerName || DEFAULT_PROVIDER_NAME,
+      commonBaseUrl: rawOptions.baseUrl || DEFAULT_BASE_URL,
+      openclawBaseUrl: rawOptions.openclawBaseUrl || buildOpenClawBaseUrl(rawOptions.baseUrl || DEFAULT_BASE_URL)
+    };
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "providerName",
+      message: "配置名称",
+      default: rawOptions.providerName || DEFAULT_PROVIDER_NAME
+    },
+    {
+      type: "input",
+      name: "commonBaseUrl",
+      message: "Codex / OpenCode 地址",
+      default: rawOptions.baseUrl || DEFAULT_BASE_URL
+    },
+    {
+      type: "input",
+      name: "openclawBaseUrl",
+      message: "OpenClaw 地址",
+      default:
+        rawOptions.openclawBaseUrl ||
+        buildOpenClawBaseUrl(rawOptions.baseUrl || DEFAULT_BASE_URL)
+    }
+  ]);
+
+  return {
+    providerName: answers.providerName.trim(),
+    commonBaseUrl: answers.commonBaseUrl.trim(),
+    openclawBaseUrl: answers.openclawBaseUrl.trim()
+  };
+}
+function applyPresetToSetupOptions(rawOptions = {}) {
+  const presetName = `${rawOptions.preset || ""}`.trim();
+  if (!presetName) {
+    return {
+      ...rawOptions,
+      _resolvedPreset: null
+    };
+  }
+
+  const preset = getPreset(presetName);
+  if (!preset) {
+    throw new Error(`未找到预设: ${presetName}`);
+  }
+
+  const commonBaseUrl = rawOptions.baseUrl || preset.commonBaseUrl;
+  return {
+    ...rawOptions,
+    providerName: rawOptions.providerName || preset.providerName || preset.name || DEFAULT_PROVIDER_NAME,
+    baseUrl: commonBaseUrl,
+    openclawBaseUrl:
+      rawOptions.openclawBaseUrl || preset.openclawBaseUrl || buildOpenClawBaseUrl(commonBaseUrl),
+    model: rawOptions.model || preset.model || DEFAULT_PRIMARY_MODEL,
+    _resolvedPreset: preset
+  };
+}
+
+async function runSetup(rawOptions = {}) {
+  const options = applyPresetToSetupOptions(rawOptions);
+  const interactive = options.interactive !== false;
+  const advanced = options.advanced === true;
+  const modeLabel = interactive ? (advanced ? "交互-自定义" : "交互-快速") : "命令行";
+
+  if (interactive) {
+    printBrandBanner();
+    printHeader(advanced ? "自定义安装" : "快速安装");
+    if (!advanced) {
+      console.log(chalk.gray("默认使用预设并自动测速选择最佳地址。"));
+    }
+    if (options._resolvedPreset) {
+      console.log(chalk.gray(`使用预设: ${options._resolvedPreset.name}`));
+    }
+  } else {
+    printHeader("March 命令行安装");
+    if (options._resolvedPreset) {
+      console.log(chalk.gray(`使用预设: ${options._resolvedPreset.name}`));
+    }
+  }
+  printSetupStep(1, "收集安装参数");
+
+  const providerMeta = await promptForSetupDefaults({
+    ...options,
+    interactive,
+    advanced
+  });
+
+  const platforms = interactive && !options.platforms
+    ? (
+        await inquirer.prompt([
+          {
+            type: "checkbox",
+            name: "platforms",
+            message: "请选择要安装的平台",
+            choices: SUPPORTED_PLATFORMS.map((platform) => ({
+              name: `${PLATFORM_META[platform].label}${platform === "codex" ? "（推荐）" : ""}`,
+              value: platform,
+              checked: true
+            })),
+            validate(value) {
+              return value.length > 0 ? true : "请至少选择一个平台";
+            }
+          }
+        ])
+      ).platforms
+    : parsePlatforms(options.platforms);
+
+  const apiKey = await promptForApiKey(options.apiKey);
+  printSetupStep(
+    2,
+    "检测可用地址",
+    options.probe === false ? "已跳过测速，将使用提供的首个地址。" : "正在测速并选择最佳可用地址。"
+  );
+  const commonBaseUrl = await resolveBaseUrl("Codex/OpenCode", {
+    interactive,
+    confirmChoice: advanced,
+    probe: options.probe,
+    candidates: [providerMeta.commonBaseUrl, ...DEFAULT_CANDIDATE_BASE_URLS, ...(options.candidateBaseUrls || [])]
+  });
+  const openclawBaseUrl = platforms.includes("openclaw")
+    ? await resolveBaseUrl("OpenClaw", {
+        interactive,
+        confirmChoice: advanced,
+        probe: options.probe,
+        candidates: [
+          providerMeta.openclawBaseUrl || buildOpenClawBaseUrl(commonBaseUrl),
+          ...(options.openclawCandidateBaseUrls || [])
+        ]
+      })
+    : null;
+
+  const providerModel = options.model || DEFAULT_PRIMARY_MODEL;
+  const results = [];
+  const backupEnabled = options.backup !== false;
+
+  printSetupPlan({
+    modeLabel,
+    presetName: options._resolvedPreset?.name || "",
+    providerName: providerMeta.providerName,
+    model: providerModel,
+    platforms,
+    commonBaseUrl,
+    openclawBaseUrl: openclawBaseUrl || "",
+    probeEnabled: options.probe !== false,
+    backupEnabled
+  });
+  printSetupStep(3, "写入配置文件");
+
+  for (const platform of platforms) {
+    const baseUrl = platform === "openclaw" ? openclawBaseUrl : commonBaseUrl;
+    console.log(chalk.gray(`→ 正在配置 ${PLATFORM_META[platform].label} ...`));
+    const result = applyProvider(
+      platform,
+      {
+        name: providerMeta.providerName,
+        baseUrl,
+        apiKey,
+        model: providerModel
+      },
+      {
+        overwrite: options.overwrite,
+        backup: backupEnabled,
+        activate: true
+      }
+    );
+
+    results.push({
+      platform,
+      ...result
+    });
+  }
+
+  printSetupStep(4, "安装完成");
+  printSuccessBanner();
+  printHeader("安装完成");
+  for (const item of results) {
+    console.log(chalk.green(`[OK] ${PLATFORM_META[item.platform].label} 已完成配置`));
+    console.log(`  地址: ${item.provider.baseUrl}`);
+    console.log(`  备份: ${item.backupDir || "(disabled)"}`);
+  }
+  printNextActions();
+}
+
+async function runAdd(platform, rawOptions = {}) {
+  const interactive = rawOptions.interactive !== false;
+  const meta = PLATFORM_META[platform];
+
+  const answers = interactive
+    ? await inquirer.prompt([
+        {
+          type: "input",
+          name: "providerName",
+          message: `${meta.label} 配置名称`,
+          default: rawOptions.providerName || DEFAULT_PROVIDER_NAME
+        },
+        {
+          type: "input",
+          name: "baseUrl",
+          message: `${meta.label} 地址`,
+          default: rawOptions.baseUrl || meta.defaultBaseUrl
+        }
+      ])
+    : {
+        providerName: rawOptions.providerName || DEFAULT_PROVIDER_NAME,
+        baseUrl: rawOptions.baseUrl || meta.defaultBaseUrl
+      };
+
+  const apiKey = await promptForApiKey(rawOptions.apiKey);
+  const baseUrl = await resolveBaseUrl(meta.label, {
+    interactive,
+    confirmChoice: interactive,
+    probe: rawOptions.probe,
+    candidates: [answers.baseUrl, ...(rawOptions.candidateBaseUrls || [])]
+  });
+
+  const result = applyProvider(
+    platform,
+    {
+      name: answers.providerName.trim(),
+      baseUrl,
+      apiKey,
+      model: rawOptions.model || DEFAULT_PRIMARY_MODEL
+    },
+    {
+      overwrite: rawOptions.overwrite,
+      backup: rawOptions.backup !== false,
+      activate: true
+    }
+  );
+
+  printProviderSummary(platform, result.provider);
+  console.log(`备份: ${result.backupDir || "(disabled)"}`);
+}
+
+async function selectProviderId(platform, message) {
+  const providers = listProviders(platform);
+  if (providers.length === 0) {
+    throw new Error("没有找到已保存的配置");
+  }
+
+  const answer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "providerId",
+      message,
+      choices: providers.map((provider) => ({
+        name: `${provider.name} (${provider.baseUrl})`,
+        value: provider.id
+      }))
+    }
+  ]);
+
+  return answer.providerId;
+}
+
+function resolveProviderByIdOrName(platform, nameOrId) {
+  const providers = listProviders(platform);
+  const lowered = `${nameOrId || ""}`.trim().toLowerCase();
+  return (
+    providers.find((provider) => provider.id === nameOrId) ||
+    providers.find((provider) => provider.name.trim().toLowerCase() === lowered) ||
+    null
+  );
+}
+
+async function runEdit(platform, nameOrId, rawOptions = {}) {
+  const interactive = rawOptions.interactive !== false;
+  const targetNameOrId =
+    nameOrId || (interactive ? await selectProviderId(platform, "请选择要编辑的配置") : null);
+
+  if (!targetNameOrId) {
+    throw new Error("缺少配置名称或 ID");
+  }
+
+  const target = resolveProviderByIdOrName(platform, targetNameOrId);
+  if (!target) {
+    throw new Error(`未找到配置: ${targetNameOrId}`);
+  }
+
+  const meta = PLATFORM_META[platform];
+  const answers = interactive
+    ? await inquirer.prompt([
+        {
+          type: "input",
+          name: "providerName",
+          message: `${meta.label} 配置名称`,
+          default: rawOptions.providerName || target.name
+        },
+        {
+          type: "input",
+          name: "baseUrl",
+          message: `${meta.label} 地址`,
+          default: rawOptions.baseUrl || target.baseUrl
+        },
+        {
+          type: "input",
+          name: "model",
+          message: `${meta.label} 模型`,
+          default: rawOptions.model || target.model || DEFAULT_PRIMARY_MODEL
+        },
+        {
+          type: "password",
+          name: "apiKey",
+          message: "API Key（留空则保持不变）",
+          mask: "*"
+        }
+      ])
+    : {
+        providerName: rawOptions.providerName || target.name,
+        baseUrl: rawOptions.baseUrl || target.baseUrl,
+        model: rawOptions.model || target.model || DEFAULT_PRIMARY_MODEL,
+        apiKey: rawOptions.apiKey || ""
+      };
+
+  const resolvedBaseUrl = await resolveBaseUrl(meta.label, {
+    interactive: false,
+    confirmChoice: false,
+    probe: rawOptions.probe,
+    candidates: [answers.baseUrl || target.baseUrl, ...(rawOptions.candidateBaseUrls || [])]
+  });
+
+  const updates = {
+    name: `${answers.providerName || target.name}`.trim(),
+    baseUrl: resolvedBaseUrl,
+    model: `${answers.model || target.model || DEFAULT_PRIMARY_MODEL}`.trim() || DEFAULT_PRIMARY_MODEL
+  };
+  if (`${answers.apiKey || ""}`.trim()) {
+    updates.apiKey = `${answers.apiKey}`.trim();
+  }
+
+  const result = applyEditedProvider(platform, targetNameOrId, updates, {
+    backup: rawOptions.backup !== false,
+    overwrite: rawOptions.overwrite === true,
+    activate: rawOptions.activate === true
+  });
+
+  printProviderSummary(platform, result.provider);
+  console.log(`当前启用: ${result.activeProvider ? result.activeProvider.name : "无"}`);
+  console.log(`备份: ${result.backupDir || "(disabled)"}`);
+}
+async function runClone(platform, sourceNameOrId, rawOptions = {}) {
+  const interactive = rawOptions.interactive !== false;
+  const sourceId =
+    sourceNameOrId || (interactive ? await selectProviderId(platform, "请选择要克隆的配置") : null);
+
+  if (!sourceId) {
+    throw new Error("缺少来源配置名称或 ID");
+  }
+
+  const source = resolveProviderByIdOrName(platform, sourceId);
+  if (!source) {
+    throw new Error(`未找到配置: ${sourceId}`);
+  }
+
+  const meta = PLATFORM_META[platform];
+  const answers = interactive
+    ? await inquirer.prompt([
+        {
+          type: "input",
+          name: "providerName",
+          message: "新配置名称",
+          default: rawOptions.providerName || `${source.name}-copy`
+        },
+        {
+          type: "input",
+          name: "baseUrl",
+          message: `${meta.label} 地址`,
+          default: rawOptions.baseUrl || source.baseUrl
+        },
+        {
+          type: "input",
+          name: "model",
+          message: `${meta.label} 模型`,
+          default: rawOptions.model || source.model || DEFAULT_PRIMARY_MODEL
+        },
+        {
+          type: "password",
+          name: "apiKey",
+          message: "API Key（留空则复用来源配置）",
+          mask: "*"
+        }
+      ])
+    : {
+        providerName: rawOptions.providerName,
+        baseUrl: rawOptions.baseUrl || source.baseUrl,
+        model: rawOptions.model || source.model || DEFAULT_PRIMARY_MODEL,
+        apiKey: rawOptions.apiKey || ""
+      };
+
+  const providerName = `${answers.providerName || ""}`.trim();
+  if (!providerName) {
+    throw new Error("新配置名称不能为空");
+  }
+
+  const resolvedBaseUrl = await resolveBaseUrl(meta.label, {
+    interactive: false,
+    confirmChoice: false,
+    probe: rawOptions.probe,
+    candidates: [answers.baseUrl || source.baseUrl, ...(rawOptions.candidateBaseUrls || [])]
+  });
+
+  const result = applyClonedProvider(
+    platform,
+    sourceId,
+    {
+      name: providerName,
+      baseUrl: resolvedBaseUrl,
+      model: `${answers.model || source.model || DEFAULT_PRIMARY_MODEL}`.trim() || DEFAULT_PRIMARY_MODEL,
+      apiKey: `${answers.apiKey || ""}`.trim() || source.apiKey
+    },
+    {
+      backup: rawOptions.backup !== false,
+      overwrite: rawOptions.overwrite === true,
+      activate: rawOptions.activate === true
+    }
+  );
+
+  printProviderSummary(platform, result.provider);
+  console.log(`当前启用: ${result.activeProvider ? result.activeProvider.name : "无"}`);
+  console.log(`备份: ${result.backupDir || "(disabled)"}`);
+}
+
+async function runRemove(platform, nameOrId, rawOptions = {}) {
+  const interactive = rawOptions.interactive !== false;
+  const targetNameOrId =
+    nameOrId || (interactive ? await selectProviderId(platform, "请选择要删除的配置") : null);
+
+  if (!targetNameOrId) {
+    throw new Error("缺少配置名称或 ID");
+  }
+
+  if (interactive && rawOptions.force !== true) {
+    const answer = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: `确认删除配置 "${targetNameOrId}" 吗？`,
+        default: false
+      }
+    ]);
+
+    if (!answer.confirmed) {
+      console.log(chalk.yellow("已取消。"));
+      return;
+    }
+  }
+
+  const result = applyRemovedProvider(platform, targetNameOrId, {
+    backup: rawOptions.backup !== false,
+    overwrite: rawOptions.overwrite === true,
+    activateFallback: rawOptions.activateFallback !== false
+  });
+
+  console.log(chalk.green(`已删除配置: ${result.removedProvider.name}`));
+  console.log(`回退启用: ${result.activeProvider ? result.activeProvider.name : "无"}`);
+  console.log(`备份: ${result.backupDir || "(disabled)"}`);
+}
+
+function runCurrent(platform) {
+  const provider = getCurrentProvider(platform);
+  if (!provider) {
+    console.log(chalk.yellow("当前没有启用配置。"));
+    return;
+  }
+
+  printProviderSummary(platform, provider);
+}
+
+function runUse(platform, nameOrId, rawOptions = {}) {
+  const result = applyStoredProvider(platform, nameOrId, {
+    overwrite: rawOptions.overwrite,
+    backup: rawOptions.backup !== false
+  });
+  printProviderSummary(platform, result.provider);
+  console.log(`备份: ${result.backupDir || "(disabled)"}`);
+}
+
+async function runProbeCommand(rawOptions = {}) {
+  const urls = dedupeStrings(rawOptions.urls || []);
+
+  if (urls.length === 0) {
+    throw new Error("请至少提供一个 --url");
+  }
+
+  const results = await probeBaseUrls(urls, { timeoutMs: 5000 });
+  printProbeResults("Probe", results);
+}
+
+function runPresetList(rawOptions = {}) {
+  const presets = listPresets();
+  if (rawOptions.json === true) {
+    console.log(JSON.stringify(presets, null, 2));
+    return;
+  }
+  printPresetList();
+}
+
+async function runPresetAdd(rawOptions = {}) {
+  const interactive = rawOptions.interactive !== false;
+  const answers = interactive
+    ? await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "预设名称",
+          default: rawOptions.name || ""
+        },
+        {
+          type: "input",
+          name: "providerName",
+          message: "默认配置名称",
+          default: rawOptions.providerName || rawOptions.name || DEFAULT_PROVIDER_NAME
+        },
+        {
+          type: "input",
+          name: "commonBaseUrl",
+          message: "Codex/OpenCode 地址",
+          default: rawOptions.commonBaseUrl || rawOptions.baseUrl || DEFAULT_BASE_URL
+        },
+        {
+          type: "input",
+          name: "openclawBaseUrl",
+          message: "OpenClaw 地址",
+          default:
+            rawOptions.openclawBaseUrl ||
+            buildOpenClawBaseUrl(rawOptions.commonBaseUrl || rawOptions.baseUrl || DEFAULT_BASE_URL)
+        },
+        {
+          type: "input",
+          name: "model",
+          message: "默认模型",
+          default: rawOptions.model || DEFAULT_PRIMARY_MODEL
+        }
+      ])
+    : {
+        name: rawOptions.name,
+        providerName: rawOptions.providerName || rawOptions.name || DEFAULT_PROVIDER_NAME,
+        commonBaseUrl: rawOptions.commonBaseUrl || rawOptions.baseUrl || DEFAULT_BASE_URL,
+        openclawBaseUrl:
+          rawOptions.openclawBaseUrl ||
+          buildOpenClawBaseUrl(rawOptions.commonBaseUrl || rawOptions.baseUrl || DEFAULT_BASE_URL),
+        model: rawOptions.model || DEFAULT_PRIMARY_MODEL
+      };
+
+  const preset = upsertPreset({
+    name: answers.name,
+    providerName: answers.providerName,
+    commonBaseUrl: answers.commonBaseUrl,
+    openclawBaseUrl: answers.openclawBaseUrl,
+    model: answers.model
+  });
+  printPresetSummary("预设已保存", preset);
+}
+
+async function runPresetUse(name, rawOptions = {}) {
+  await runSetup({
+    ...rawOptions,
+    preset: name,
+    interactive: false
+  });
+}
+
+async function runPresetRemove(name, rawOptions = {}) {
+  const interactive = rawOptions.interactive !== false;
+  if (interactive && rawOptions.force !== true) {
+    const answer = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: `确认删除预设 "${name}" 吗？`,
+        default: false
+      }
+    ]);
+
+    if (!answer.confirmed) {
+      console.log(chalk.yellow("已取消。"));
+      return;
+    }
+  }
+
+  const removed = removePreset(name);
+  printPresetSummary("预设已删除", removed);
+}
+
+async function selectPresetName(message, options = {}) {
+  const presets = listPresets().filter((preset) =>
+    options.customOnly === true ? preset.readonly !== true : true
+  );
+  if (presets.length === 0) {
+    throw new Error(options.customOnly ? "没有找到自定义预设" : "没有找到预设");
+  }
+
+  const answer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "presetName",
+      message,
+      choices: presets.map((preset) => ({
+        name: `${preset.name} (${preset.source || (preset.readonly ? "内置" : "自定义")})`,
+        value: preset.name
+      }))
+    }
+  ]);
+
+  return answer.presetName;
+}
+
+async function runPresetMenu() {
+  let shouldExit = false;
+
+  while (!shouldExit) {
+    const answer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "预设管理",
+        choices: [
+          { name: "查看预设", value: "list" },
+          { name: "新增或更新预设", value: "add" },
+          { name: "立即使用预设", value: "use" },
+          { name: "删除自定义预设", value: "remove" },
+          { name: "返回", value: "back" }
+        ]
+      }
+    ]);
+
+    switch (answer.action) {
+      case "list":
+        runPresetList();
+        break;
+      case "add":
+        await runPresetAdd({ interactive: true });
+        break;
+      case "use": {
+        const presetName = await selectPresetName("请选择预设");
+        await runPresetUse(presetName, {});
+        break;
+      }
+      case "remove": {
+        const presetName = await selectPresetName("请选择要删除的自定义预设", { customOnly: true });
+        await runPresetRemove(presetName, { interactive: true });
+        break;
+      }
+      case "back":
+        shouldExit = true;
+        break;
+      default:
+        shouldExit = true;
+        break;
+    }
+  }
+}
+
+async function runPlatformMenu(platform) {
+  const meta = PLATFORM_META[platform];
+  let shouldExit = false;
+
+  while (!shouldExit) {
+    const answer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: `${meta.label} 配置管理`,
+        choices: [
+          { name: "查看已保存配置", value: "list" },
+          { name: "查看当前启用配置", value: "current" },
+          { name: "新增或更新配置", value: "add" },
+          { name: "切换配置", value: "use" },
+          { name: "编辑配置", value: "edit" },
+          { name: "克隆配置", value: "clone" },
+          { name: "删除配置", value: "remove" },
+          { name: "返回", value: "back" }
+        ]
+      }
+    ]);
+
+    switch (answer.action) {
+      case "list":
+        printProviderList(platform);
+        break;
+      case "current":
+        runCurrent(platform);
+        break;
+      case "add":
+        await runAdd(platform, { interactive: true, probe: true, backup: true });
+        break;
+      case "use": {
+        const providerId = await selectProviderId(platform, "请选择要启用的配置");
+        runUse(platform, providerId, { backup: true });
+        break;
+      }
+      case "edit": {
+        const providerId = await selectProviderId(platform, "请选择要编辑的配置");
+        await runEdit(platform, providerId, { interactive: true, probe: true, backup: true });
+        break;
+      }
+      case "clone": {
+        const providerId = await selectProviderId(platform, "请选择要克隆的配置");
+        await runClone(platform, providerId, { interactive: true, probe: true, backup: true });
+        break;
+      }
+      case "remove": {
+        const providerId = await selectProviderId(platform, "请选择要删除的配置");
+        await runRemove(platform, providerId, { interactive: true, backup: true });
+        break;
+      }
+      case "back":
+        shouldExit = true;
+        break;
+      default:
+        shouldExit = true;
+        break;
+    }
+  }
+}
+
+async function runMainMenu() {
+  let shouldExit = false;
+
+  printBrandBanner();
+
+  while (!shouldExit) {
+    const answer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "March 主菜单",
+        choices: [
+          { name: "快速安装", value: "setup" },
+          { name: "自定义安装", value: "advanced-setup" },
+          { name: "管理预设", value: "presets" },
+          { name: "管理 Codex", value: "codex" },
+          { name: "管理 OpenCode", value: "opencode" },
+          { name: "管理 OpenClaw", value: "openclaw" },
+          { name: "退出", value: "exit" }
+        ]
+      }
+    ]);
+
+    switch (answer.action) {
+      case "setup":
+        await runSetup({ interactive: true, probe: true, backup: true, advanced: false });
+        break;
+      case "advanced-setup":
+        await runSetup({ interactive: true, probe: true, backup: true, advanced: true });
+        break;
+      case "presets":
+        await runPresetMenu();
+        break;
+      case "codex":
+      case "opencode":
+      case "openclaw":
+        await runPlatformMenu(answer.action);
+        break;
+      case "exit":
+        shouldExit = true;
+        break;
+      default:
+        shouldExit = true;
+        break;
+    }
+  }
+}
+const program = new Command();
+program
+  .name(APP_NAME)
+  .description("March 服务商配置管理工具")
+  .version("0.1.2");
+
+program
+  .command("menu")
+  .description("打开交互菜单")
+  .action(async () => {
+    await runMainMenu();
+  });
+
+program
+  .command("setup")
+  .description("一键配置 Codex / OpenCode / OpenClaw")
+  .option("-k, --api-key <apiKey>", "API Key")
+  .option("--preset <name>", "预设名称")
+  .option("-p, --platforms <platforms>", "平台列表，逗号分隔：codex,opencode,openclaw")
+  .option("-n, --provider-name <name>", "配置名称")
+  .option("-b, --base-url <url>", "Codex / OpenCode 地址")
+  .option("--openclaw-base-url <url>", "OpenClaw 地址")
+  .option("--model <model>", "模型")
+  .option("--candidate-base-url <url>", "额外 Codex / OpenCode 备选地址", collect, [])
+  .option("--openclaw-candidate-base-url <url>", "额外 OpenClaw 备选地址", collect, [])
+  .option("--no-probe", "跳过地址测速")
+  .option("--no-backup", "跳过自动备份")
+  .option("--overwrite", "覆盖写入目标配置（不合并）")
+  .action(async (options) => {
+    await runSetup({
+      interactive: false,
+      apiKey: options.apiKey,
+      preset: options.preset,
+      platforms: options.platforms,
+      providerName: options.providerName,
+      baseUrl: options.baseUrl,
+      openclawBaseUrl: options.openclawBaseUrl,
+      model: options.model,
+      candidateBaseUrls: options.candidateBaseUrl,
+      openclawCandidateBaseUrls: options.openclawCandidateBaseUrl,
+      probe: options.probe,
+      backup: options.backup,
+      overwrite: options.overwrite
+    });
+  });
+
+program
+  .command("probe")
+  .description("测速一个或多个地址")
+  .requiredOption("-u, --url <url>", "待测速地址", collect, [])
+  .action(async (options) => {
+    await runProbeCommand({
+      urls: options.url
+    });
+  });
+
+const presetCommand = program.command("preset").description("管理安装预设");
+
+presetCommand
+  .command("list")
+  .description("查看可用预设")
+  .option("--json", "输出 JSON")
+  .action((options) => {
+    runPresetList({
+      json: options.json === true
+    });
+  });
+
+presetCommand
+  .command("add")
+  .description("新增或更新自定义预设")
+  .requiredOption("-n, --name <name>", "预设名称")
+  .option("--provider-name <name>", "默认配置名称")
+  .option("--base-url <url>", "Codex/OpenCode 默认地址")
+  .option("--common-base-url <url>", "Codex/OpenCode 默认地址")
+  .option("--openclaw-base-url <url>", "OpenClaw 默认地址")
+  .option("--model <model>", "默认模型", DEFAULT_PRIMARY_MODEL)
+  .action(async (options) => {
+    await runPresetAdd({
+      interactive: false,
+      name: options.name,
+      providerName: options.providerName,
+      baseUrl: options.baseUrl,
+      commonBaseUrl: options.commonBaseUrl,
+      openclawBaseUrl: options.openclawBaseUrl,
+      model: options.model
+    });
+  });
+
+presetCommand
+  .command("use <name>")
+  .description("使用预设执行安装")
+  .option("-k, --api-key <apiKey>", "API Key")
+  .option("-p, --platforms <platforms>", "平台列表，逗号分隔：codex,opencode,openclaw")
+  .option("-n, --provider-name <name>", "覆盖配置名称")
+  .option("--model <model>", "覆盖模型")
+  .option("--candidate-base-url <url>", "额外 Codex / OpenCode 备选地址", collect, [])
+  .option("--openclaw-candidate-base-url <url>", "额外 OpenClaw 备选地址", collect, [])
+  .option("--no-probe", "跳过地址测速")
+  .option("--no-backup", "跳过自动备份")
+  .option("--overwrite", "覆盖写入目标配置（不合并）")
+  .action(async (name, options) => {
+    await runPresetUse(name, {
+      apiKey: options.apiKey,
+      platforms: options.platforms,
+      providerName: options.providerName,
+      model: options.model,
+      candidateBaseUrls: options.candidateBaseUrl,
+      openclawCandidateBaseUrls: options.openclawCandidateBaseUrl,
+      probe: options.probe,
+      backup: options.backup,
+      overwrite: options.overwrite
+    });
+  });
+
+presetCommand
+  .command("remove <name>")
+  .description("删除自定义预设")
+  .option("-f, --force", "跳过确认")
+  .action(async (name, options) => {
+    await runPresetRemove(name, {
+      interactive: false,
+      force: options.force
+    });
+  });
+
+function registerPlatformCommand(platform) {
+  const meta = PLATFORM_META[platform];
+  const command = program.command(meta.command).description(`管理 ${meta.label} 配置`);
+
+  command.command("list").description(`查看 ${meta.label} 已保存配置`).action(() => printProviderList(platform));
+
+  command.command("current").description(`查看当前启用的 ${meta.label} 配置`).action(() => runCurrent(platform));
+
+  command
+    .command("add")
+    .description(`新增或更新 ${meta.label} 配置`)
+    .option("-n, --provider-name <name>", "配置名称", DEFAULT_PROVIDER_NAME)
+    .option("-u, --base-url <url>", "地址", meta.defaultBaseUrl)
+    .option("-k, --api-key <apiKey>", "API Key")
+    .option("--candidate-base-url <url>", "额外备选地址", collect, [])
+    .option("--model <model>", "模型", DEFAULT_PRIMARY_MODEL)
+    .option("--no-probe", "跳过地址测速")
+    .option("--no-backup", "跳过自动备份")
+    .option("--overwrite", "覆盖写入目标配置（不合并）")
+    .action(async (options) => {
+      await runAdd(platform, {
+        interactive: false,
+        providerName: options.providerName,
+        baseUrl: options.baseUrl,
+        candidateBaseUrls: options.candidateBaseUrl,
+        apiKey: options.apiKey,
+        model: options.model,
+        probe: options.probe,
+        backup: options.backup,
+        overwrite: options.overwrite
+      });
+    });
+
+  command
+    .command("use <nameOrId>")
+    .description(`切换到已保存的 ${meta.label} 配置`)
+    .option("--no-backup", "跳过自动备份")
+    .option("--overwrite", "覆盖写入目标配置（不合并）")
+    .action((nameOrId, options) => {
+      runUse(platform, nameOrId, {
+        backup: options.backup,
+        overwrite: options.overwrite
+      });
+    });
+
+  command
+    .command("edit <nameOrId>")
+    .description(`编辑已有 ${meta.label} 配置`)
+    .option("-n, --provider-name <name>", "配置名称")
+    .option("-u, --base-url <url>", "地址")
+    .option("-k, --api-key <apiKey>", "API Key")
+    .option("--candidate-base-url <url>", "额外备选地址", collect, [])
+    .option("--model <model>", "模型")
+    .option("--activate", "编辑后立即启用")
+    .option("--no-probe", "跳过地址测速")
+    .option("--no-backup", "跳过自动备份")
+    .option("--overwrite", "覆盖写入目标配置（不合并）")
+    .action(async (nameOrId, options) => {
+      await runEdit(platform, nameOrId, {
+        interactive: false,
+        providerName: options.providerName,
+        baseUrl: options.baseUrl,
+        candidateBaseUrls: options.candidateBaseUrl,
+        apiKey: options.apiKey,
+        model: options.model,
+        activate: options.activate,
+        probe: options.probe,
+        backup: options.backup,
+        overwrite: options.overwrite
+      });
+    });
+
+  command
+    .command("clone <nameOrId>")
+    .description(`克隆已有 ${meta.label} 配置`)
+    .requiredOption("-n, --provider-name <name>", "新配置名称")
+    .option("-u, --base-url <url>", "地址")
+    .option("-k, --api-key <apiKey>", "API Key")
+    .option("--candidate-base-url <url>", "额外备选地址", collect, [])
+    .option("--model <model>", "模型")
+    .option("--activate", "克隆后立即启用")
+    .option("--no-probe", "跳过地址测速")
+    .option("--no-backup", "跳过自动备份")
+    .option("--overwrite", "覆盖写入目标配置（不合并）")
+    .action(async (nameOrId, options) => {
+      await runClone(platform, nameOrId, {
+        interactive: false,
+        providerName: options.providerName,
+        baseUrl: options.baseUrl,
+        candidateBaseUrls: options.candidateBaseUrl,
+        apiKey: options.apiKey,
+        model: options.model,
+        activate: options.activate,
+        probe: options.probe,
+        backup: options.backup,
+        overwrite: options.overwrite
+      });
+    });
+
+  command
+    .command("remove <nameOrId>")
+    .description(`删除已有 ${meta.label} 配置`)
+    .option("--no-backup", "跳过自动备份")
+    .option("--no-activate-fallback", "删除当前配置时不自动切换")
+    .option("--overwrite", "覆盖写入目标配置（不合并）")
+    .option("-f, --force", "交互模式下跳过确认")
+    .action(async (nameOrId, options) => {
+      await runRemove(platform, nameOrId, {
+        interactive: false,
+        backup: options.backup,
+        activateFallback: options.activateFallback,
+        overwrite: options.overwrite,
+        force: options.force
+      });
+    });
+
+  command.action(async () => {
+    await runPlatformMenu(platform);
+  });
+}
+
+for (const platform of SUPPORTED_PLATFORMS) {
+  registerPlatformCommand(platform);
+}
+
+try {
+  if (process.argv.length <= 2) {
+    await runSetup({ interactive: true, probe: true, backup: true, advanced: false });
+  } else {
+    await program.parseAsync(process.argv);
+  }
+} catch (error) {
+  console.error(chalk.red(`错误: ${error.message}`));
+  process.exitCode = 1;
+}