ccm.js

#!/usr/bin/env node

const fs = require("fs");
const http = require("http");
const os = require("os");
const path = require("path");
const readline = require("readline");
const crypto = require("crypto");
const { execFileSync, spawnSync } = require("child_process");
const { createWindowsRuntime } = require("./lib/windows-runtime");
const { syncWindowsCodexBaseUrl, syncWindowsCodexApiKey } = require("./lib/wsl-runtime");
const { importWslRegistries, withOfficialChannel } = require("./lib/wsl-import");
const {
  buildOfficialEnv,
  ensureCodexOfficialLogin,
  ensureOfficialHome,
} = require("./lib/codex-official");
const {
  buildOfficialEnv: buildOfficialClaudeEnv,
  clearApiChannel: clearClaudeApiChannel,
  ensureClaudeOfficialLogin,
  readSettings: readClaudeSettings,
  updateApiChannel: updateClaudeApiChannel,
} = require("./lib/claude-settings");
const {
  PI_API_TYPES,
  applyPiChannel,
  capturePiDefaults,
  clearPiManagedSelection,
  normalizePiApi,
  parseJsonObject: parsePiJsonObject,
  readPiSnapshot,
} = require("./lib/pi-settings");
const {
  GROK_API_BACKENDS,
  activateGrokOfficial,
  applyGrokChannel,
  normalizeGrokApiBackend,
  readGrokSnapshot,
} = require("./lib/grok-settings");

const WINDOWS_RUNTIME = process.platform === "win32" ? createWindowsRuntime() : null;
const HOME = WINDOWS_RUNTIME ? WINDOWS_RUNTIME.home : os.homedir();
const STATE_HOME =
  process.env.CCM_STATE_HOME ||
  (WINDOWS_RUNTIME ? WINDOWS_RUNTIME.stateHome : path.join(HOME, ".local", "state", "ccm"));
const ACTIVATION_PATH = path.join(STATE_HOME, "activate.sh");
const SESSION_META_PATH = path.join(STATE_HOME, "session-metadata.json");
const SESSION_ARCHIVE_DIR = path.join(STATE_HOME, "session-archives");
const SESSION_TRASH_DIR = path.join(STATE_HOME, "trash", "sessions");
const SKILL_BACKUP_DIR = path.join(STATE_HOME, "skill-backups");
const SKILL_DISABLED_DIR = path.join(STATE_HOME, "disabled-skills");
const SKILL_TRASH_DIR = path.join(STATE_HOME, "trash", "skills");
const TUI_PAGES = ["channels", "skills", "sessions"];
const CCM_BUILD_ID = "2026-09-05-codex-empty-model-v0.4.8";
let claudePluginCache = { expiresAt: 0, installed: [] };

const CODEX_HOME =
  process.env.CCM_CODEX_HOME ||
  process.env.CODEX_HOME ||
  (WINDOWS_RUNTIME ? WINDOWS_RUNTIME.codexHome : path.join(HOME, ".codex"));
const OFFICIAL_CODEX_HOME = CODEX_HOME;
const CODEX_SHELL_INIT =
  process.env.CCM_CODEX_SHELL_INIT ||
  (WINDOWS_RUNTIME ? "" : resolveUnixShellInitPath(HOME, process.env));
const CLAUDE_BASHRC =
  process.env.CCM_CLAUDE_BASHRC ||
  (WINDOWS_RUNTIME
    ? WINDOWS_RUNTIME.claudeSettingsPath
    : resolveUnixShellInitPath(HOME, process.env));
const CLAUDE_HOME =
  process.env.CCM_CLAUDE_HOME ||
  (WINDOWS_RUNTIME ? WINDOWS_RUNTIME.claudeHome : path.join(HOME, ".claude"));
const PI_HOME =
  process.env.CCM_PI_HOME ||
  path.join(HOME, ".pi", "agent");
const GROK_HOME =
  process.env.CCM_GROK_HOME ||
  process.env.GROK_HOME ||
  path.join(HOME, ".grok");

const TOOLS = {
  codex: {
    id: "codex",
    label: "Codex",
    command: process.env.CCM_CODEX_BIN || "codex",
    home: CODEX_HOME,
    registryPath: path.join(STATE_HOME, "channels.json"),
    statePath: path.join(STATE_HOME, "state.json"),
    backupDir: path.join(STATE_HOME, "backups"),
    lockPath: path.join(STATE_HOME, "switch.lock"),
  },
  claude: {
    id: "claude",
    label: "Claude",
    command: process.env.CCM_CLAUDE_BIN || "claude",
    home: CLAUDE_HOME,
    bashrcPath: CLAUDE_BASHRC,
    registryPath: path.join(STATE_HOME, "claude-channels.json"),
    statePath: path.join(STATE_HOME, "claude-state.json"),
    backupDir: path.join(STATE_HOME, "claude-backups"),
    lockPath: path.join(STATE_HOME, "claude-switch.lock"),
  },
  pi: {
    id: "pi",
    label: "Pi",
    command: process.env.CCM_PI_BIN || "pi",
    home: PI_HOME,
    modelsPath: path.join(PI_HOME, "models.json"),
    settingsPath: path.join(PI_HOME, "settings.json"),
    registryPath: path.join(STATE_HOME, "pi-channels.json"),
    statePath: path.join(STATE_HOME, "pi-state.json"),
    backupDir: path.join(STATE_HOME, "pi-backups"),
    lockPath: path.join(STATE_HOME, "pi-switch.lock"),
  },
  grok: {
    id: "grok",
    label: "Grok Build",
    command: process.env.CCM_GROK_BIN || "grok",
    home: GROK_HOME,
    configPath: path.join(GROK_HOME, "config.toml"),
    registryPath: path.join(STATE_HOME, "grok-channels.json"),
    statePath: path.join(STATE_HOME, "grok-state.json"),
    backupDir: path.join(STATE_HOME, "grok-backups"),
    lockPath: path.join(STATE_HOME, "grok-switch.lock"),
  },
};

if (require.main === module) {
  main();
}

function main() {
  try {
    const args = parseArgs(process.argv.slice(2));

    if (args.help) {
      printHelp();
      return;
    }

    if (args.importWsl) {
      runWslImport(args);
      return;
    }

    for (const tool of Object.values(TOOLS)) {
      ensureToolStateDirs(tool);
      bootstrapRegistryIfNeeded(tool);
    }

    if (args.doctor) {
      printDoctor();
      return;
    }

    if (args.loginOfficial) {
      switchToOfficialAndLogin(args.tool || "codex");
      return;
    }

    if (args.ui) {
      runWebUi(args);
      return;
    }

    if (args.tui) {
      runTerminalUi(args.tool || "codex").catch(fail);
      return;
    }

    if (!args.hasExplicitCommand) {
      runTerminalUi("codex").catch(fail);
      return;
    }

    const tool = getTool(args.tool || "codex");

    if (args.list) {
      listChannelsCli(tool);
      return;
    }

    if (args.current) {
      printCurrentChannelCli(tool);
      return;
    }

    if (args.use) {
      useChannelCli(tool, args.use);
      return;
    }

    runInteractive(tool).catch(fail);
  } catch (error) {
    fail(error);
  }
}

function parseArgs(argv) {
  const args = {
    _: [],
    tool: "",
    list: false,
    current: false,
    use: "",
    ui: false,
    tui: false,
    host: "127.0.0.1",
    port: 17883,
    help: false,
    doctor: false,
    importWsl: false,
    dryRun: false,
    loginOfficial: false,
    hasExplicitCommand: argv.length > 0,
  };

  for (let index = 0; index < argv.length; index += 1) {
    const item = argv[index];
    if (item === "--help" || item === "-h") {
      args.help = true;
    } else if (item === "--doctor" || item === "doctor") {
      args.doctor = true;
    } else if (item === "--import-wsl") {
      args.importWsl = true;
    } else if (item === "--dry-run") {
      args.dryRun = true;
    } else if (item === "--login-official") {
      args.loginOfficial = true;
    } else if (item === "--tool") {
      args.tool = requireValue(argv, index, "--tool");
      index += 1;
    } else if (item === "--codex") {
      args.tool = "codex";
    } else if (item === "--claude") {
      args.tool = "claude";
    } else if (item === "--pi") {
      args.tool = "pi";
    } else if (item === "--grok") {
      args.tool = "grok";
    } else if (item === "--list") {
      args.list = true;
    } else if (item === "--current") {
      args.current = true;
    } else if (item === "--use") {
      args.use = requireValue(argv, index, "--use");
      index += 1;
    } else if (item === "--ui" || item === "ui") {
      args.ui = true;
    } else if (item === "--tui" || item === "--terminal-ui" || item === "tui") {
      args.tui = true;
    } else if (item === "--host") {
      args.host = requireValue(argv, index, "--host");
      index += 1;
    } else if (item === "--port") {
      args.port = Number(requireValue(argv, index, "--port"));
      index += 1;
    } else if (["codex", "claude", "pi", "grok"].includes(item)) {
      args.tool = item;
    } else {
      args._.push(item);
    }
  }

  if (!Number.isInteger(args.port) || args.port <= 0 || args.port > 65535) {
    throw new Error("--port 必须是 1-65535 之间的数字");
  }

  return args;
}

function requireValue(argv, index, option) {
  const value = argv[index + 1];
  if (!value || value.startsWith("--")) {
    throw new Error(`${option} 需要提供值`);
  }
  return value;
}

function printHelp() {
  console.log(`CCM Agent Channel Manager

用法:
  ccm
  ccm --tui
  ccm codex
  ccm claude
  ccm pi
  ccm grok
  ccm --ui [--host 127.0.0.1] [--port 17883]
  ccm --tool codex --list
  ccm --tool claude --list
  ccm --tool pi --list
  ccm --tool grok --list
  ccm --tool codex --current
  ccm --tool claude --current
  ccm --tool pi --current
  ccm --tool grok --current
  ccm --tool codex --use <channel-name-or-id>
  ccm --tool claude --use <channel-name-or-id>
  ccm --tool pi --use <channel-name-or-id>
  ccm --tool grok --use <channel-name-or-id>
  ccm --doctor
  ccm --import-wsl [--dry-run]
  ccm --tool codex --login-official
  ccm --tool claude --login-official
  ccm --tool pi --login-official
  ccm --tool grok --login-official

说明:
  Codex 渠道写入 ${CODEX_HOME}/config.toml 和 auth.json
  Claude 渠道写入 ${CLAUDE_BASHRC} 中的 ANTHROPIC_BASE_URL 与密钥变量
  Pi 第三方渠道写入 ${PI_HOME}/models.json 和 settings.json；官方登录在 Pi 内执行 /login
  Grok 第三方渠道写入 ${GROK_HOME}/config.toml；官方登录执行 grok login

环境变量覆盖:
  CCM_CODEX_HOME     覆盖 Codex home（默认 CODEX_HOME 或 ~/.codex）
  CCM_CLAUDE_BASHRC  覆盖 Claude shell 初始化文件（macOS zsh 默认 ~/.zshrc，其他 Unix 默认 ~/.bashrc）
  CCM_PI_HOME        覆盖 Pi agent 配置目录（默认 ~/.pi/agent）
  CCM_GROK_HOME      覆盖 Grok Build 配置目录（默认 ~/.grok）
  CCM_STATE_HOME     覆盖渠道注册表和备份目录
  CCM_CODEX_BIN      覆盖 codex 命令
  CCM_CLAUDE_BIN     覆盖 claude 命令
  CCM_PI_BIN         覆盖 pi 命令
  CCM_GROK_BIN       覆盖 grok 命令
`);
}

function runWslImport(args) {
  const sourceRoot =
    process.env.CCM_WSL_ROOT ||
    "\\\\wsl.localhost\\Ubuntu-24.04\\home\\fleix";
  const result = importWslRegistries({
    sourceRoot,
    stateHome: STATE_HOME,
    dryRun: args.dryRun,
  });
  console.log(args.dryRun ? "WSL import preview" : "WSL import complete");
  console.log(`Codex channels: ${result.codexCount}`);
  console.log(`Claude channels: ${result.claudeCount}`);
  if (result.backupDir) {
    console.log(`Previous Windows registries backed up: ${result.backupDir}`);
  }
}

function loginOfficialCli(toolId) {
  if (toolId === "claude") {
    ensureClaudeOfficialLogin({
      settingsPath: TOOLS.claude.bashrcPath,
      command: TOOLS.claude.command,
      env: process.env,
      spawnSyncImpl: spawnToolCommand,
    });
    console.log("Claude 官方登录已完成");
    return;
  }
  if (toolId === "pi") {
    console.log("Pi 已启动。请在 Pi 中输入 /login，然后选择要使用的官方订阅提供商。");
    const result = spawnToolCommand(TOOLS.pi.command, [], {
      stdio: "inherit",
      env: { ...process.env },
    });
    if (result.error) {
      throw result.error;
    }
    if (result.status !== 0) {
      throw new Error("pi login exited with code " + result.status);
    }
    return;
  }
  if (toolId === "grok") {
    const args = isWslRuntime() ? ["login", "--device-auth"] : ["login"];
    const result = spawnToolCommand(TOOLS.grok.command, args, {
      stdio: "inherit",
      env: { ...process.env },
    });
    if (result.error) {
      throw result.error;
    }
    if (result.status !== 0) {
      throw new Error("grok login exited with code " + result.status);
    }
    console.log("Grok Build 官方登录已完成。");
    return;
  }
  if (toolId !== "codex") {
    throw new Error(`不支持的官方登录工具: ${toolId}`);
  }
  const result = ensureCodexOfficialLogin({
    officialHome: OFFICIAL_CODEX_HOME,
    command: TOOLS.codex.command,
    env: process.env,
    spawnSyncImpl: spawnToolCommand,
  });
  console.log(result.loginStarted ? "Codex 官方登录已完成" : "Codex 官方登录已存在");
}

function switchToOfficialAndLogin(toolId) {
  const tool = getTool(toolId);
  const official = loadRegistry(tool).find((channel) => channel.kind === "official");
  if (!official) {
    throw new Error(`${tool.label} 官方渠道不存在`);
  }
  switchToChannelSync(tool, official);
  loginOfficialCli(tool.id);
  return official;
}

function printDoctor() {
  const scriptPath = safeRealpath(__filename);
  const homeBinPath = path.join(HOME, "bin", "ccm");
  const mainScript = path.join(HOME, ".nvm", "versions", "node", "v24.15.0", "bin", "ccm");
  const frameProbe = stripAnsi(
    buildTerminalUiFrame({
      activeToolId: "codex",
      activePage: "channels",
      selectedIndex: 0,
      message: "doctor",
      help: false,
      busy: false,
    }),
  );
  const interactiveType = WINDOWS_RUNTIME
    ? spawnSync("where.exe", ["ccm"], { encoding: "utf8" })
    : spawnSync("bash", ["-ic", "type -a ccm"], { encoding: "utf8" });

  console.log("ccm doctor");
  console.log(`build_id      : ${CCM_BUILD_ID}`);
  console.log(`node          : ${process.version} ${process.execPath}`);
  console.log(`script        : ${__filename}`);
  console.log(`script_real   : ${scriptPath}`);
  console.log(`script_sha256 : ${sha256File(__filename) || "-"}`);
  console.log(`main_sha256   : ${sha256File(mainScript) || "-"}`);
  console.log(`home_bin      : ${homeBinPath}`);
  console.log(`home_bin_real : ${safeRealpath(homeBinPath) || "-"}`);
  console.log(`home_bin_sha  : ${sha256File(homeBinPath) || "-"}`);
  console.log(`cwd           : ${process.cwd()}`);
  console.log(`home          : ${HOME}`);
  console.log(`shell         : ${process.env.SHELL || "-"}`);
  console.log(`term          : ${process.env.TERM || "-"}`);
  console.log(`path          : ${process.env.PATH || "-"}`);
  console.log(`frame_header  : ${frameProbe.includes("ccm Channel Manager") ? "yes" : "no"}`);
  console.log(WINDOWS_RUNTIME ? "where ccm:" : "type -a ccm:");
  process.stdout.write((interactiveType.stdout || "").trimEnd() || "-");
  if (interactiveType.stderr) {
    process.stdout.write(`\n${interactiveType.stderr.trimEnd()}`);
  }
  process.stdout.write("\n");
}

async function runToolChooser() {
  while (true) {
    clearScreen();
    console.log("Channel Manager");
    console.log("");
    const tools = Object.values(TOOLS);
    tools.forEach(printToolSummary);
    console.log("");
    tools.forEach((tool, index) => console.log(`${index + 1}. 管理 ${tool.label} 渠道`));
    console.log(`${tools.length + 1}. 启动 Web UI`);
    console.log("q. 退出");
    console.log("");

    const answer = (await prompt("请选择: ")).trim().toLowerCase();
    if (answer === "q") {
      return;
    }
    const selectedTool =
      tools.find((tool, index) => answer === String(index + 1) || answer === tool.id) || null;
    if (selectedTool) {
      await runInteractive(selectedTool);
      continue;
    }
    if (answer === String(tools.length + 1) || answer === "ui") {
      console.log("");
      console.log("请在终端运行: ccm --ui");
      await pause();
      continue;
    }
    console.log("选择无效。");
    await pause();
  }
}

async function runTerminalUi(initialToolId) {
  if (!process.stdin.isTTY || !process.stdout.isTTY) {
    throw new Error("终端 TUI 需要在交互式终端中运行");
  }

  writeRuntimeProbe();

  const stdin = process.stdin;
  const stdout = process.stdout;
  const state = {
    activeToolId: getTool(initialToolId).id,
    activePage: "channels",
    selectedIndex: 0,
    message: "Enter 切换渠道，Tab 切换 Agent。",
    help: false,
    busy: false,
    modal: null,
  };

  const wasRaw = stdin.isRaw;
  const wasPaused =
    typeof stdin.isPaused === "function" ? stdin.isPaused() : false;

  readline.emitKeypressEvents(stdin);
  if (wasPaused) {
    stdin.resume();
  }
  stdin.setRawMode(true);
  stdout.write("\x1b[?1049h\x1b[?25l");

  return new Promise((resolve) => {
    let cleanedUp = false;

    function cleanup() {
      if (cleanedUp) {
        return;
      }
      cleanedUp = true;
      stdin.removeListener("keypress", onKeypress);
      try {
        stdin.setRawMode(Boolean(wasRaw));
      } catch {}
      if (typeof stdin.pause === "function") {
        stdin.pause();
      }
      stdout.write("\x1b[0m\x1b[?25h\x1b[?1049l");
    }

    function render() {
      const frame = buildTerminalUiFrame(state);
      stdout.write(`\x1b[2J\x1b[H${frame}`);
    }

    function clampSelection() {
      const items = getTuiItems(state);
      if (!items.length) {
        state.selectedIndex = 0;
        return;
      }
      state.selectedIndex = Math.max(
        0,
        Math.min(state.selectedIndex, items.length - 1),
      );
    }

    function selectCurrentChannel() {
      const tool = getTool(state.activeToolId);
      const channels = loadRegistry(tool);
      const current = resolveCurrentChannel(tool, channels);
      const index = current
        ? channels.findIndex((channel) => channel.id === current.id)
        : -1;
      if (index >= 0) {
        state.selectedIndex = index;
        return;
      }
      clampSelection();
    }

    function selectDefaultForPage() {
      if (state.activePage === "channels") {
        selectCurrentChannel();
        return;
      }
      state.selectedIndex = 0;
      clampSelection();
    }

    function setActiveTool(toolId) {
      state.activeToolId = getTool(toolId).id;
      selectDefaultForPage();
      state.message = `${pageLabel(state.activePage)} / ${getTool(state.activeToolId).label}`;
    }

    function setActivePage(pageId) {
      state.activePage = pageId;
      selectDefaultForPage();
      state.message = `${pageLabel(pageId)} / ${getTool(state.activeToolId).label}`;
    }

    function rotatePage(delta) {
      const current = TUI_PAGES.indexOf(state.activePage);
      const next = (current + delta + TUI_PAGES.length) % TUI_PAGES.length;
      setActivePage(TUI_PAGES[next]);
    }

    async function suspendForPrompt(fn) {
      state.busy = true;
      stdin.removeListener("keypress", onKeypress);
      try {
        stdin.setRawMode(false);
      } catch {}
      stdout.write("\x1b[?25h\x1b[?1049l");
      try {
        await fn();
      } catch (error) {
        state.message = `操作失败: ${error.message}`;
      } finally {
        readline.emitKeypressEvents(stdin);
        stdin.on("keypress", onKeypress);
        stdin.setRawMode(true);
        stdout.write("\x1b[?1049h\x1b[?25l");
        state.busy = false;
        clampSelection();
        render();
      }
    }

    function selectedChannel() {
      const channels = loadRegistry(getTool(state.activeToolId));
      return channels[state.selectedIndex] || null;
    }

    function selectedSession() {
      const sessions = listSessions(state.activeToolId);
      return sessions[state.selectedIndex] || null;
    }

    function selectedSkill() {
      const skills = listSkills(state.activeToolId);
      return skills[state.selectedIndex] || null;
    }

    async function switchSelected(mode) {
      const tool = getTool(state.activeToolId);
      const channel = selectedChannel();
      if (!channel) {
        state.message = "当前没有可切换的渠道。";
        render();
        return;
      }

      const running = detectRunningToolPids(tool);
      try {
        switchToChannelSync(tool, channel);
        if (shouldStartOfficialLogin(channel, mode)) {
          await suspendForPrompt(async () => {
            loginOfficialCli(tool.id);
            state.message = `${channel.name} official login completed.`;
          });
          return;
        }
        state.message =
          tool.id === "claude"
            ? `已切换到 ${channel.name}。本次 ccm 内已生效，退出后 shell wrapper 会自动加载。`
            : `已切换到 ${channel.name}。${running.length ? "已运行的 Codex 进程不会自动继承新配置。" : ""}`;
        if (mode === "start" || mode === "resume") {
          cleanup();
          launchTool(tool, channel, mode);
          return;
        }
        render();
      } catch (error) {
        state.message = `切换失败: ${error.message}`;
        render();
      }
    }

    async function loginSelectedOfficialChannel() {
      const channel = selectedChannel();
      if (!channel || channel.kind !== "official") {
        state.message = "Select an Official channel first.";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        switchToChannelSync(getTool(state.activeToolId), channel);
        loginOfficialCli(state.activeToolId);
        state.message = `${channel.name} official login completed.`;
      });
    }

    function editSelected() {
      const tool = getTool(state.activeToolId);
      const channel = selectedChannel();
      if (!channel) {
        state.message = "请选择一个渠道后再编辑。";
        render();
        return;
      }
      state.modal = createChannelFormModal(tool, "edit", channel);
      state.help = false;
      render();
    }

    async function deleteSelected() {
      const tool = getTool(state.activeToolId);
      const channel = selectedChannel();
      if (!channel) {
        state.message = "请选择一个渠道后再删除。";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        await deleteChannel(tool, channel.id);
        state.message = "删除操作已完成。";
      });
    }

    function addForActiveTool() {
      const tool = getTool(state.activeToolId);
      state.modal = createChannelFormModal(tool, "add");
      state.help = false;
      render();
    }

    function closeModal() {
      state.modal = null;
      state.message = "已取消渠道表单。";
      render();
    }

    function submitChannelModal() {
      const modal = state.modal;
      if (!modal || modal.type !== "channel-form") {
        return;
      }

      try {
        const tool = getTool(modal.toolId);
        const values = channelModalValues(modal);
        const saved = saveChannelForm(tool, modal.mode, modal.channelId, values);
        const channels = loadRegistry(tool);
        const index = channels.findIndex((item) => item.id === saved.id);
        state.modal = null;
        state.selectedIndex = Math.max(0, index);
        state.message = modal.mode === "add" ? "渠道已新增。" : "渠道已更新。";
      } catch (error) {
        modal.error = error.message;
      }
      render();
    }

    function handleModalKeypress(str, key = {}) {
      const modal = state.modal;
      if (!modal || modal.type !== "channel-form") {
        return;
      }

      const name = key.name || "";
      const fields = modal.fields;
      const field = fields[modal.activeField];

      if (name === "escape") {
        closeModal();
        return;
      }

      if (name === "return" || name === "enter") {
        submitChannelModal();
        return;
      }

      if (name === "tab" || name === "up" || name === "down") {
        const backwards = name === "up" || (name === "tab" && key.shift);
        modal.activeField =
          (modal.activeField + (backwards ? -1 : 1) + fields.length) %
          fields.length;
        modal.error = "";
        render();
        return;
      }

      if (!field) {
        return;
      }

      if (field.type === "select") {
        if (
          name === "left" ||
          name === "right" ||
          str === " " ||
          name === "space"
        ) {
          const delta = name === "left" ? -1 : 1;
          const current = Math.max(0, field.options.indexOf(field.value));
          field.value =
            field.options[
              (current + delta + field.options.length) % field.options.length
            ];
          modal.error = "";
          render();
        }
        return;
      }

      const chars = Array.from(field.value);
      field.cursor = Math.max(0, Math.min(field.cursor, chars.length));

      if (name === "left") {
        field.cursor = Math.max(0, field.cursor - 1);
      } else if (name === "right") {
        field.cursor = Math.min(chars.length, field.cursor + 1);
      } else if (name === "home") {
        field.cursor = 0;
      } else if (name === "end") {
        field.cursor = chars.length;
      } else if (name === "backspace") {
        if (field.cursor > 0) {
          chars.splice(field.cursor - 1, 1);
          field.cursor -= 1;
          field.value = chars.join("");
        }
      } else if (name === "delete") {
        if (field.cursor < chars.length) {
          chars.splice(field.cursor, 1);
          field.value = chars.join("");
        }
      } else if (key.ctrl && name === "u") {
        field.value = "";
        field.cursor = 0;
      } else if (str && !key.ctrl && !key.meta) {
        const inserted = Array.from(str).filter(
          (char) => char >= " " && char !== "\x7f",
        );
        if (inserted.length) {
          chars.splice(field.cursor, 0, ...inserted);
          field.cursor += inserted.length;
          field.value = chars.join("");
        }
      } else {
        return;
      }

      modal.error = "";
      render();
    }

    async function rollbackActiveTool() {
      const tool = getTool(state.activeToolId);
      await suspendForPrompt(async () => {
        await rollbackLastBackup(tool);
        state.message = "回滚操作已完成。";
      });
    }

    function resumeSelectedSession() {
      const tool = getTool(state.activeToolId);
      const session = selectedSession();
      if (!session) {
        state.message = "请选择一个会话后再恢复。";
        render();
        return;
      }

      try {
        if (session.channel_id) {
          const channel = loadRegistry(tool).find(
            (item) => item.id === session.channel_id,
          );
          if (channel) {
            switchToChannelSync(tool, channel);
          }
        }
        cleanup();
        launchSession(tool, session);
      } catch (error) {
        state.message = `恢复失败: ${error.message}`;
        render();
      }
    }

    function describeSelectedSkill() {
      const skill = selectedSkill();
      if (!skill) {
        state.message = "当前没有可查看的 skill/plugin。";
        render();
        return;
      }
      state.message = `${skill.name}: ${skill.description || skill.path}`;
      render();
    }

    async function toggleFavoriteSelectedSession() {
      const session = selectedSession();
      if (!session) {
        state.message = "请选择一个会话。";
        render();
        return;
      }
      const next = toggleSessionFavorite(session);
      const nextSessions = listSessions(state.activeToolId);
      const nextIndex = nextSessions.findIndex((item) => item.key === session.key);
      if (nextIndex >= 0) {
        state.selectedIndex = nextIndex;
      }
      state.message = next.favorite ? "会话已收藏。" : "已取消收藏。";
      render();
    }

    async function tagSelectedSession() {
      const session = selectedSession();
      if (!session) {
        state.message = "请选择一个会话。";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        const answer = await promptWithDefault(
          "标签（逗号分隔）",
          session.tags.join(", "),
        );
        const next = setSessionTags(session, answer);
        state.message = next.tags?.length
          ? `标签已更新: ${next.tags.join(", ")}`
          : "标签已清空。";
      });
    }

    async function bindSelectedSessionChannel() {
      const tool = getTool(state.activeToolId);
      const session = selectedSession();
      if (!session) {
        state.message = "请选择一个会话。";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        const channels = loadRegistry(tool);
        console.log("");
        console.log("0. 解除渠道绑定");
        channels.forEach((channel, index) => {
          console.log(`${index + 1}. ${channel.name}`);
        });
        const answer = (await prompt("选择渠道: ")).trim();
        const index = Number(answer) - 1;
        if (answer === "0" || !answer) {
          bindSessionChannel(session, "");
          state.message = "已解除会话渠道绑定。";
          return;
        }
        if (!Number.isInteger(index) || !channels[index]) {
          state.message = "无效的渠道选择。";
          return;
        }
        bindSessionChannel(session, channels[index].id);
        state.message = `会话已绑定渠道: ${channels[index].name}`;
      });
    }

    async function archiveSelectedSession() {
      const session = selectedSession();
      if (!session) {
        state.message = "请选择一个会话。";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        const archivePath = archiveSession(session);
        state.message = `会话已归档: ${archivePath}`;
      });
    }

    async function deleteSelectedSession() {
      const session = selectedSession();
      if (!session) {
        state.message = "请选择一个会话。";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        const answer = (
          await prompt(`将会话“${session.title}”移入 CCM 回收站？ [y/N]: `)
        )
          .trim()
          .toLowerCase();
        if (answer !== "y") {
          state.message = "已取消删除。";
          return;
        }
        const target = trashSession(session);
        state.message = `会话已移入回收站: ${target}`;
      });
    }

    async function cleanupSessions() {
      const tool = getTool(state.activeToolId);
      await suspendForPrompt(async () => {
        const daysText = await promptWithDefault("清理多少天前的会话", "90");
        const days = Number(daysText);
        if (!Number.isFinite(days) || days < 1) {
          state.message = "天数必须大于 0。";
          return;
        }
        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
        const candidates = listSessions(tool.id, 100000).filter(
          (session) =>
            !session.favorite &&
            session.path &&
            fs.existsSync(session.path) &&
            new Date(session.updated_at || 0).getTime() < cutoff,
        );
        if (!candidates.length) {
          state.message = `没有 ${days} 天前的未收藏会话。`;
          return;
        }
        const answer = (
          await prompt(
            `将 ${candidates.length} 个未收藏会话移入 CCM 回收站？输入 DELETE 确认: `,
          )
        ).trim();
        if (answer !== "DELETE") {
          state.message = "已取消批量清理。";
          return;
        }
        let moved = 0;
        for (const session of candidates) {
          try {
            trashSession(session);
            moved += 1;
          } catch {}
        }
        state.message = `已将 ${moved} 个会话移入回收站。`;
      });
    }

    async function exportSelectedSkill() {
      const skill = selectedSkill();
      if (!skill) {
        state.message = "请选择一个 skill/plugin。";
        render();
        return;
      }
      try {
        const target = backupSkill(skill);
        state.message = `已导出备份: ${target}`;
      } catch (error) {
        state.message = `备份失败: ${error.message}`;
      }
      render();
    }

    async function toggleSelectedSkill() {
      const skill = selectedSkill();
      if (!skill) {
        state.message = "请选择一个 skill/plugin。";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        const result =
          state.activeToolId === "claude"
            ? toggleClaudePlugin(skill)
            : toggleCodexSkill(skill);
        state.message = result.enabled ? "已启用。" : "已禁用。";
      });
    }

    async function createSkillForActiveTool() {
      await suspendForPrompt(async () => {
        if (state.activeToolId === "claude") {
          const pluginId = await promptRequired(
            "插件 ID（如 playwright@claude-plugins-official）: ",
          );
          installClaudePlugin(pluginId, "user");
          state.message = `Claude plugin 已安装: ${pluginId}`;
          return;
        }
        const name = await promptRequired("Skill 名称: ");
        const description = await promptRequired("触发说明: ");
        const target = createCodexSkill(name, description, "");
        openTextEditor(path.join(target, "SKILL.md"));
        state.message = `Skill 已创建: ${target}`;
      });
    }

    async function editSelectedSkill() {
      const skill = selectedSkill();
      if (!skill) {
        state.message = "请选择一个 skill。";
        render();
        return;
      }
      if (state.activeToolId === "claude") {
        state.message = "Claude plugin 请使用安装、启停和卸载操作。";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        const original = fs.readFileSync(skill.path, "utf8");
        const metadata = parseSkillMarkdown(original);
        const description = await promptWithDefault(
          "触发说明",
          metadata.description || "",
        );
        editCodexSkill(skill, description, "");
        openTextEditor(skill.path);
        state.message = "Skill 已更新并自动备份。";
      });
    }

    async function deleteSelectedSkill() {
      const skill = selectedSkill();
      if (!skill) {
        state.message = "请选择一个 skill/plugin。";
        render();
        return;
      }
      await suspendForPrompt(async () => {
        const label = state.activeToolId === "claude" ? "卸载插件" : "移入回收站";
        const answer = (
          await prompt(`${label}“${skill.name}”？ [y/N]: `)
        )
          .trim()
          .toLowerCase();
        if (answer !== "y") {
          state.message = "已取消。";
          return;
        }
        if (state.activeToolId === "claude") {
          uninstallClaudePlugin(skill);
          state.message = "Claude plugin 已卸载，数据已保留。";
        } else {
          const target = trashCodexSkill(skill);
          state.message = `Skill 已移入回收站: ${target}`;
        }
      });
    }

    async function onKeypress(str, key = {}) {
      if (state.busy) {
        return;
      }

      const name = key.name || "";
      if (key.ctrl && name === "c") {
        cleanup();
        resolve();
        return;
      }

      if (state.modal) {
        handleModalKeypress(str, key);
        return;
      }

      if (name === "q") {
        cleanup();
        resolve();
        return;
      }

      const tool = getTool(state.activeToolId);
      const items = getTuiItems(state);

      if (/^[1-9]$/.test(str || "")) {
        const index = Number(str) - 1;
        if (index >= 0 && index < items.length) {
          state.selectedIndex = index;
          state.message = `已选中 #${index + 1} ${itemDisplayName(items[index])}`;
        } else {
          state.message = `没有第 ${str} 个渠道。`;
        }
        render();
        return;
      }

      if (name === "tab") {
        const toolIds = Object.keys(TOOLS);
        const currentIndex = toolIds.indexOf(state.activeToolId);
        setActiveTool(toolIds[(currentIndex + 1) % toolIds.length]);
        render();
        return;
      }

      if (name === "right" || str === "l" || str === "]") {
        rotatePage(1);
        render();
        return;
      }

      if (name === "left" || str === "h" || str === "[") {
        rotatePage(-1);
        render();
        return;
      }

      if (name === "home") {
        state.selectedIndex = 0;
        state.message = items[0] ? `已选中 #1 ${itemDisplayName(items[0])}` : "当前没有条目。";
        render();
        return;
      }

      if (name === "end") {
        state.selectedIndex = Math.max(0, items.length - 1);
        const selected = items[state.selectedIndex];
        state.message = selected
          ? `已选中 #${state.selectedIndex + 1} ${itemDisplayName(selected)}`
          : "当前没有条目。";
        render();
        return;
      }

      if (name === "up" || str === "k") {
        if (items.length) {
          state.selectedIndex =
            (state.selectedIndex - 1 + items.length) % items.length;
          state.message = `已选中 #${state.selectedIndex + 1} ${itemDisplayName(items[state.selectedIndex])}`;
        }
        render();
        return;
      }

      if (name === "down" || str === "j") {
        if (items.length) {
          state.selectedIndex = (state.selectedIndex + 1) % items.length;
          state.message = `已选中 #${state.selectedIndex + 1} ${itemDisplayName(items[state.selectedIndex])}`;
        }
        render();
        return;
      }

      if (name === "return" || name === "enter" || str === "s") {
        if (state.activePage === "channels") {
          await switchSelected("switch");
        } else if (state.activePage === "sessions") {
          resumeSelectedSession();
        } else {
          describeSelectedSkill();
        }
        return;
      }

      if (str === "c") {
        if (state.activePage === "channels") {
          await switchSelected("start");
        }
        return;
      }

      if (str === "o" && state.activePage === "channels") {
        await loginSelectedOfficialChannel();
        return;
      }

      if (str === "r") {
        if (state.activePage === "channels") {
          await switchSelected("resume");
        }
        return;
      }

      if (str === "a") {
        if (state.activePage === "channels") {
          addForActiveTool();
        } else if (state.activePage === "sessions") {
          await archiveSelectedSession();
        }
        return;
      }

      if (str === "e") {
        if (state.activePage === "channels") {
          editSelected();
        } else if (state.activePage === "skills") {
          await editSelectedSkill();
        }
        return;
      }

      if (str === "d") {
        if (state.activePage === "channels") {
          await deleteSelected();
        } else if (state.activePage === "sessions") {
          await deleteSelectedSession();
        } else if (state.activePage === "skills") {
          await deleteSelectedSkill();
        }
        return;
      }

      if (str === "f" && state.activePage === "sessions") {
        await toggleFavoriteSelectedSession();
        return;
      }

      if (str === "t" && state.activePage === "sessions") {
        await tagSelectedSession();
        return;
      }

      if (str === "b" && state.activePage === "sessions") {
        await bindSelectedSessionChannel();
        return;
      }

      if (str === "x") {
        if (state.activePage === "sessions") {
          await cleanupSessions();
        } else if (state.activePage === "skills") {
          await exportSelectedSkill();
        }
        return;
      }

      if (str === "u" && state.activePage === "skills") {
        await toggleSelectedSkill();
        return;
      }

      if ((str === "n" || str === "i") && state.activePage === "skills") {
        await createSkillForActiveTool();
        return;
      }

      if (str === "z") {
        if (state.activePage === "channels") {
          await rollbackActiveTool();
        }
        return;
      }

      if (str === "?") {
        state.help = !state.help;
        render();
        return;
      }
    }

    stdin.on("keypress", onKeypress);
    selectDefaultForPage();
    render();
  });
}

function buildTerminalUiFrame(state) {
  let frame;
  if (state.activePage === "skills") {
    frame = buildSkillsFrame(state);
  } else if (state.activePage === "sessions") {
    frame = buildSessionsFrame(state);
  } else {
    frame = buildChannelsFrame(state);
  }
  return state.modal ? `${frame}${buildTuiModalOverlay(state)}` : frame;
}

function buildChannelsFrame(state) {
  const tool = getTool(state.activeToolId);
  const channels = loadRegistry(tool);
  const current = resolveCurrentChannel(tool, channels);
  const snapshot = readCurrentSnapshot(tool);
  const width = Math.max(80, process.stdout.columns || 100);
  const height = Math.max(24, process.stdout.rows || 30);
  const innerWidth = width - 4;
  const helpLineCount = state.help ? 5 : 0;
  const fixedLineCount = 17 + helpLineCount;
  const rowCapacity = Math.max(4, height - fixedLineCount);
  const selectedIndex = channels.length
    ? Math.max(0, Math.min(state.selectedIndex, channels.length - 1))
    : 0;
  const start = Math.max(
    0,
    Math.min(
      Math.max(0, selectedIndex - Math.floor(rowCapacity / 2)),
      Math.max(0, channels.length - rowCapacity),
    ),
  );
  const visible = channels.slice(start, start + rowCapacity);
  const target = toolTargetPath(tool);
  const cols = terminalTableColumns(innerWidth);
  const lines = [];

  lines.push(boxTop(width));
  lines.push(boxSeparator(width));
  lines.push(buildTuiHeader(state, width, innerWidth));
  lines.push(boxSeparator(width));
  lines.push(
    boxLine(
      summaryLine("工具", tool.label, "当前", current ? current.name : "未收录", "渠道", String(channels.length), innerWidth),
      width,
    ),
  );
  lines.push(
    boxLine(
      `${tuiColor("地址", "label")} ${fitText(snapshot.base_url || "-", innerWidth - 6)}`,
      width,
    ),
  );
  lines.push(
    boxLine(
      joinLeftRight(
        `${tuiColor("写入", "label")} ${fitText(target, Math.max(20, innerWidth - 30))}`,
        `${tuiColor("密钥", "label")} ${maskKey(snapshot.api_key || "")}`,
        innerWidth,
      ),
      width,
    ),
  );
  lines.push(boxSeparator(width));
  lines.push(
    boxLine(
      tuiColor(
        tableRow(["状态", "#", "名称", "Base URL", "密钥", "模型"], cols),
        "tableHead",
      ),
      width,
    ),
  );
  lines.push(boxSeparator(width));

  if (!channels.length) {
    lines.push(boxLine(tuiColor("暂无渠道。按 a 新增。", "muted"), width));
  } else {
    for (const [offset, channel] of visible.entries()) {
      const index = start + offset;
      const selected = index === selectedIndex;
      const isCurrent = current && current.id === channel.id;
      const row = tableRow(
        [
          statusBadge(selected, isCurrent),
          String(index + 1),
          channel.kind === "official" ? `[Official] ${channel.name}` : channel.name,
          channel.kind === "official" ? "Official subscription" : channel.base_url,
          maskKey(channel.api_key),
          channel.model || "-",
        ],
        cols,
      );
      lines.push(
        boxLine(
          row,
          width,
          selected ? "selectedRow" : isCurrent ? "currentRow" : "",
        ),
      );
    }
  }

  const moreAbove = start > 0 ? `上方还有 ${start} 条` : "";
  const moreBelow =
    start + visible.length < channels.length
      ? `下方还有 ${channels.length - start - visible.length} 条`
      : "";
  if (moreAbove || moreBelow) {
    lines.push(
      boxLine(
        tuiColor(`${moreAbove}${moreAbove && moreBelow ? " / " : ""}${moreBelow}`, "muted"),
        width,
      ),
    );
  }

  while (lines.length < height - (state.help ? 7 : 4)) {
    lines.push(boxLine("", width));
  }

  lines.push(boxSeparator(width));
  lines.push(
    boxLine(
      `${tuiColor("提示", "label")} ${fitText(state.message || "", innerWidth - 6)}`,
      width,
    ),
  );
  lines.push(
    boxLine(
      `${keyHint("←/→")} 页面   ${keyHint("Tab")} 工具   ${keyHint("↑/↓")} 选择   ${keyHint("1-9")} 直达   ${keyHint("Enter/s")} 切换渠道`,
      width,
    ),
  );
  lines.push(
    boxLine(
      `${keyHint("a")} 新增   ${keyHint("e")} 编辑   ${keyHint("d")} 删除   ${keyHint("c")} 启动   ${keyHint("r")} 恢复   ${keyHint("o")} Official Login   ${keyHint("?")} 帮助   ${keyHint("q")} 退出`,
      width,
    ),
  );

  if (state.help) {
    lines.push(boxLine("", width));
    lines.push(boxLine(tuiColor("帮助", "title"), width));
    lines.push(boxLine("Claude 渠道会写入 ~/.bashrc 的 ANTHROPIC_BASE_URL 和密钥变量。", width));
    lines.push(boxLine("切换 Claude 后，ccm 内立即生效；退出 ccm 后 shell wrapper 自动加载到当前终端。", width));
    lines.push(boxLine("Web UI 仍可用：ccm --ui", width));
  }

  lines.push(boxBottom(width));
  return `${lines.join("\n")}\n`;
}

function createChannelFormModal(tool, mode, channel = null) {
  const editing = mode === "edit";
  const fields = [
    channelFormField("name", "名称", editing ? channel.name : "", {
      required: true,
      placeholder: "例如：anyrouter",
    }),
    channelFormField("base_url", "Base URL", editing ? channel.base_url : "", {
      required: true,
      placeholder: "https://api.example.com/v1",
    }),
    channelFormField("api_key", "密钥", "", {
      required: !editing,
      secret: true,
      placeholder: editing
        ? `留空则保留 ${maskKey(channel.api_key)}`
        : "必填，输入内容会被遮罩",
    }),
  ];

  if (tool.id === "claude") {
    fields.push({
      key: "auth_env_key",
      label: "密钥变量",
      type: "select",
      value: normalizeClaudeAuthEnvKey(
        editing ? channel.auth_env_key : "ANTHROPIC_AUTH_TOKEN",
      ),
      options: ["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_API_KEY"],
    });
  }

  const wireOptions = channelWireApiOptions(tool.id);
  if (wireOptions.length) {
    fields.push({
      key: "wire_api",
      label: "API protocol",
      type: "select",
      value: normalizeChannelWireApi(
        tool.id,
        editing ? channel.wire_api : wireOptions[0],
      ),
      options: wireOptions,
    });
  }

  fields.push(
    channelFormField("model", "默认模型", editing ? channel.model || "" : "", {
      required: ["pi", "grok"].includes(tool.id),
      placeholder: ["pi", "grok"].includes(tool.id) ? "必填，例如 provider/model-id" : "可留空",
    }),
    channelFormField("remark", "备注", editing ? channel.remark || "" : "", {
      placeholder: "可留空",
    }),
  );

  return {
    type: "channel-form",
    mode,
    toolId: tool.id,
    channelId: channel ? channel.id : "",
    title: `${editing ? "编辑" : "新增"} ${tool.label} 渠道`,
    fields,
    activeField: 0,
    error: "",
  };
}

function channelWireApiOptions(toolId) {
  if (toolId === "codex") {
    return ["responses", "chat"];
  }
  if (toolId === "pi") {
    return [...PI_API_TYPES];
  }
  if (toolId === "grok") {
    return [...GROK_API_BACKENDS];
  }
  return [];
}

function normalizeChannelWireApi(toolId, value) {
  if (toolId === "pi") {
    return normalizePiApi(value);
  }
  if (toolId === "grok") {
    return normalizeGrokApiBackend(value);
  }
  return value === "chat" ? "chat" : "responses";
}

function channelFormField(key, label, value, options = {}) {
  const text = String(value || "");
  return {
    key,
    label,
    type: "text",
    value: text,
    cursor: Array.from(text).length,
    required: Boolean(options.required),
    secret: Boolean(options.secret),
    placeholder: options.placeholder || "",
  };
}

function channelModalValues(modal) {
  return Object.fromEntries(
    modal.fields.map((field) => [field.key, String(field.value || "").trim()]),
  );
}

function saveChannelForm(tool, mode, channelId, values) {
  if (!values.name) {
    throw new Error("名称不能为空。");
  }
  if (!values.base_url) {
    throw new Error("Base URL 不能为空。");
  }
  validateHttpUrl(values.base_url);
  if (mode === "add" && !values.api_key) {
    throw new Error("密钥不能为空。");
  }
  if (["pi", "grok"].includes(tool.id) && !values.model) {
    throw new Error(tool.label + " third-party channels require a model ID.");
  }

  const channels = loadRegistry(tool);
  const now = nowIso();
  let channel;

  if (mode === "edit") {
    channel = channels.find((item) => item.id === channelId);
    if (!channel) {
      throw new Error("该渠道已不存在。");
    }
    channel.name = values.name;
    channel.base_url = normalizeBaseUrl(values.base_url);
    if (values.api_key) {
      channel.api_key = values.api_key;
    }
    channel.model = values.model || "";
    channel.remark = values.remark || "";
    channel.updated_at = now;
  } else {
    channel = {
      id: uniqueId(channels, slugify(values.name) || `channel-${Date.now()}`),
      name: values.name,
      base_url: normalizeBaseUrl(values.base_url),
      api_key: values.api_key,
      model: values.model || "",
      remark: values.remark || "",
      created_at: now,
      updated_at: now,
      last_used_at: "",
    };
    channels.push(channel);
  }

  if (tool.id === "codex") {
    channel.wire_api = normalizeChannelWireApi(tool.id, values.wire_api || channel.wire_api);
  } else if (tool.id === "claude") {
    channel.auth_env_key = normalizeClaudeAuthEnvKey(values.auth_env_key);
  } else {
    channel.wire_api = normalizeChannelWireApi(tool.id, values.wire_api || channel.wire_api);
  }

  saveRegistry(tool, channels);
  return channel;
}

function buildTuiModalOverlay(state) {
  const modal = state.modal;
  if (!modal || modal.type !== "channel-form") {
    return "";
  }

  const screenWidth = Math.max(80, process.stdout.columns || 100);
  const screenHeight = Math.max(24, process.stdout.rows || 30);
  const modalWidth = Math.max(64, Math.min(78, screenWidth - 8));
  const contentWidth = modalWidth - 4;
  const labelWidth = 12;
  const inputWidth = Math.max(24, contentWidth - labelWidth - 3);
  const activeField = modal.fields[modal.activeField];
  const lines = [
    boxTop(modalWidth),
    boxLine(
      joinLeftRight(
        tuiColor(modal.title, "title"),
        tuiColor(`${modal.activeField + 1}/${modal.fields.length}`, "muted"),
        contentWidth,
      ),
      modalWidth,
    ),
    boxSeparator(modalWidth),
  ];

  for (const [index, field] of modal.fields.entries()) {
    const active = index === modal.activeField;
    const required = field.required ? tuiColor(" *", "error") : "";
    const label = `${active ? "▶" : " "} ${field.label}${required}`;
    const input = formatChannelModalValue(field, inputWidth, active);
    lines.push(
      boxLine(
        `${fitText(label, labelWidth)} ${input}`,
        modalWidth,
        active ? "modalActive" : "",
      ),
    );
  }

  lines.push(boxSeparator(modalWidth));
  lines.push(
    boxLine(
      modal.error
        ? `${tuiColor("错误", "error")} ${fitText(modal.error, contentWidth - 6)}`
        : `${tuiColor("提示", "label")} ${
            activeField && activeField.type === "select"
              ? "←/→ 或空格切换选项"
              : "可直接输入；Ctrl+U 清空当前字段"
          }`,
      modalWidth,
    ),
  );
  lines.push(
    boxLine(
      `${keyHint("Tab/↑↓")} 切换字段   ${keyHint("Enter")} 保存   ${keyHint("Esc")} 取消`,
      modalWidth,
    ),
  );
  lines.push(boxBottom(modalWidth));

  const top = Math.max(2, Math.floor((screenHeight - lines.length) / 2) + 1);
  const left = Math.max(2, Math.floor((screenWidth - modalWidth) / 2) + 1);
  return lines
    .map((line, index) => `\x1b[${top + index};${left}H${line}`)
    .join("");
}

function formatChannelModalValue(field, width, active) {
  if (field.type === "select") {
    return fitText(
      active ? `◀ ${field.value} ▶` : field.value,
      width,
    );
  }

  if (!active) {
    const value = field.value
      ? field.secret
        ? "*".repeat(Math.min(Array.from(field.value).length, width))
        : field.value
      : tuiColor(field.placeholder || "", "muted");
    return fitText(value, width);
  }

  const raw = Array.from(field.value);
  const cursor = Math.max(0, Math.min(field.cursor, raw.length));
  if (!raw.length) {
    return fitText(
      `${tuiColor("│", "cursor")}${tuiColor(field.placeholder || "", "muted")}`,
      width,
    );
  }

  const visual = field.secret ? raw.map(() => "*") : raw;
  let start = 0;
  while (
    start < cursor &&
    stringWidth(visual.slice(start, cursor).join("")) > width - 1
  ) {
    start += 1;
  }
  const before = visual.slice(start, cursor).join("");
  const remainingWidth = Math.max(0, width - stringWidth(before) - 1);
  let after = "";
  for (const char of visual.slice(cursor)) {
    if (stringWidth(after + char) > remainingWidth) {
      break;
    }
    after += char;
  }
  return fitText(`${before}${tuiColor("│", "cursor")}${after}`, width);
}

function buildSkillsFrame(state) {
  const tool = getTool(state.activeToolId);
  const skills = listSkills(tool.id);
  const width = Math.max(80, process.stdout.columns || 100);
  const height = Math.max(24, process.stdout.rows || 30);
  const innerWidth = width - 4;
  const fixedLineCount = 15;
  const rowCapacity = Math.max(4, height - fixedLineCount);
  const selectedIndex = skills.length
    ? Math.max(0, Math.min(state.selectedIndex, skills.length - 1))
    : 0;
  const start = Math.max(
    0,
    Math.min(
      Math.max(0, selectedIndex - Math.floor(rowCapacity / 2)),
      Math.max(0, skills.length - rowCapacity),
    ),
  );
  const visible = skills.slice(start, start + rowCapacity);
  const cols = skillsTableColumns(innerWidth);
  const selected = skills[selectedIndex] || null;
  const lines = [];

  lines.push(boxTop(width));
  lines.push(buildTuiHeader(state, width, innerWidth));
  lines.push(boxSeparator(width));
  lines.push(
    boxLine(
      summaryLine("工具", tool.label, "条目", String(skills.length), "模式", "管理", innerWidth),
      width,
    ),
  );
  lines.push(
    boxLine(
      `${tuiColor("详情", "label")} ${fitText(selected ? `${skillStateLabel(selected)}  ${selected.description || selected.path}` : "-", innerWidth - 6)}`,
      width,
    ),
  );
  lines.push(boxSeparator(width));
  lines.push(
    boxLine(
      tuiColor(tableRow(["状态", "#", "名称", "类型", "说明", "更新时间"], cols), "tableHead"),
      width,
    ),
  );
  lines.push(boxSeparator(width));

  if (!skills.length) {
    lines.push(boxLine(tuiColor("当前没有可读取的 skill/plugin。", "muted"), width));
  } else {
    for (const [offset, skill] of visible.entries()) {
      const index = start + offset;
      const isSelected = index === selectedIndex;
      lines.push(
        boxLine(
          tableRow(
            [
              `${isSelected ? "▶" : ""}${skillStateMark(skill)}`,
              String(index + 1),
              skill.name,
              skill.type,
              skill.description || "-",
              formatShortTime(skill.updated_at),
            ],
            cols,
          ),
          width,
          isSelected ? "selectedRow" : "",
        ),
      );
    }
  }

  while (lines.length < height - 5) {
    lines.push(boxLine("", width));
  }
  lines.push(boxSeparator(width));
  lines.push(boxLine(`${tuiColor("提示", "label")} ${fitText(state.message || "Enter 查看当前条目摘要。", innerWidth - 6)}`, width));
  lines.push(boxLine(`${keyHint("←/→")} 页面   ${keyHint("Tab")} 工具   ${keyHint("↑/↓")} 选择   ${keyHint("Enter")} 摘要   ${keyHint("x")} 备份`, width));
  lines.push(boxLine(`${keyHint("u")} 启停   ${keyHint("n/i")} 新建/安装   ${keyHint("e")} 编辑   ${keyHint("d")} 删除/卸载   ${keyHint("q")} 退出`, width));
  lines.push(boxBottom(width));
  return `${lines.join("\n")}\n`;
}

function buildSessionsFrame(state) {
  const tool = getTool(state.activeToolId);
  const sessions = listSessions(tool.id);
  const channels = loadRegistry(tool);
  const width = Math.max(80, process.stdout.columns || 100);
  const height = Math.max(24, process.stdout.rows || 30);
  const innerWidth = width - 4;
  const fixedLineCount = 15;
  const rowCapacity = Math.max(4, height - fixedLineCount);
  const selectedIndex = sessions.length
    ? Math.max(0, Math.min(state.selectedIndex, sessions.length - 1))
    : 0;
  const start = Math.max(
    0,
    Math.min(
      Math.max(0, selectedIndex - Math.floor(rowCapacity / 2)),
      Math.max(0, sessions.length - rowCapacity),
    ),
  );
  const visible = sessions.slice(start, start + rowCapacity);
  const cols = sessionsTableColumns(innerWidth);
  const selected = sessions[selectedIndex] || null;
  const lines = [];

  lines.push(boxTop(width));
  lines.push(buildTuiHeader(state, width, innerWidth));
  lines.push(boxSeparator(width));
  lines.push(
    boxLine(
      summaryLine("工具", tool.label, "会话", String(sessions.length), "模式", "管理 + resume", innerWidth),
      width,
    ),
  );
  lines.push(
    boxLine(
      `${tuiColor("选中", "label")} ${fitText(selected ? sessionDetailText(selected, channels) : "-", innerWidth - 6)}`,
      width,
    ),
  );
  lines.push(boxSeparator(width));
  lines.push(
    boxLine(
      tuiColor(tableRow(["状态", "#", "标题", "项目", "更新时间", "会话ID"], cols), "tableHead"),
      width,
    ),
  );
  lines.push(boxSeparator(width));

  if (!sessions.length) {
    lines.push(boxLine(tuiColor("当前没有可读取的会话。", "muted"), width));
  } else {
    for (const [offset, session] of visible.entries()) {
      const index = start + offset;
      const isSelected = index === selectedIndex;
      lines.push(
        boxLine(
          tableRow(
            [
              `${isSelected ? "▶" : ""}${sessionStateMark(session)}`,
              String(index + 1),
              session.title,
              session.cwd || "-",
              formatShortTime(session.updated_at),
              session.id,
            ],
            cols,
          ),
          width,
          isSelected ? "selectedRow" : "",
        ),
      );
    }
  }

  while (lines.length < height - 5) {
    lines.push(boxLine("", width));
  }
  lines.push(boxSeparator(width));
  lines.push(boxLine(`${tuiColor("提示", "label")} ${fitText(state.message || "Enter 恢复会话。", innerWidth - 6)}`, width));
  lines.push(boxLine(`${keyHint("←/→")} 页面   ${keyHint("Tab")} 工具   ${keyHint("↑/↓")} 选择   ${keyHint("Enter")} resume   ${keyHint("f")} 收藏   ${keyHint("t")} 标签`, width));
  lines.push(boxLine(`${keyHint("b")} 绑渠道   ${keyHint("a")} 归档   ${keyHint("d")} 回收   ${keyHint("x")} 批量清理   ${keyHint("q")} 退出`, width));
  lines.push(boxBottom(width));
  return `${lines.join("\n")}\n`;
}

function getTuiItems(state) {
  if (state.activePage === "skills") {
    return listSkills(state.activeToolId);
  }
  if (state.activePage === "sessions") {
    return listSessions(state.activeToolId);
  }
  return loadRegistry(getTool(state.activeToolId));
}

function itemDisplayName(item) {
  return item ? item.title || item.name || item.id || item.path || "-" : "-";
}

function skillStateMark(skill) {
  if (skill.type === "available" || skill.installed === false) {
    return "+";
  }
  return skill.disabled ? "○" : "●";
}

function skillStateLabel(skill) {
  if (skill.type === "available" || skill.installed === false) {
    return "可安装";
  }
  return skill.disabled ? "已禁用" : "已启用";
}

function sessionStateMark(session) {
  return `${session.favorite ? "★" : ""}${session.archived_at ? "A" : ""}`;
}

function sessionDetailText(session, channels) {
  const channel = channels.find((item) => item.id === session.channel_id);
  const parts = [session.title];
  if (session.favorite) {
    parts.push("★收藏");
  }
  if (session.tags?.length) {
    parts.push(`#${session.tags.join(" #")}`);
  }
  if (channel) {
    parts.push(`渠道:${channel.name}`);
  }
  if (session.archived_at) {
    parts.push("已归档");
  }
  if (session.cwd) {
    parts.push(session.cwd);
  }
  return parts.join("  ");
}

function pageLabel(pageId) {
  const labels = {
    channels: "Channels",
    skills: "Skills",
    sessions: "Sessions",
  };
  return labels[pageId] || pageId;
}

function pageTabs(activePage) {
  return TUI_PAGES.map((page) =>
    page === activePage ? `[${pageLabel(page)}]` : pageLabel(page),
  ).join(" ");
}

function tuiHeaderText(state, width) {
  const titles = {
    channels: "Channel",
    skills: "Skill",
    sessions: "Session",
  };
  const title = `ccm ${titles[state.activePage] || pageLabel(state.activePage)} Manager`;
  return joinLeftRight(
    `${tuiColor(title, "title")} ${tuiColor(pageTabs(state.activePage), "muted")}`,
    activeTabText(state.activeToolId),
    width,
  );
}

function buildTuiHeader(state, width, innerWidth) {
  return boxLine(tuiHeaderText(state, innerWidth), width);
}

function listSkills(toolId) {
  if (toolId === "codex") {
    return listCodexSkills();
  }
  if (toolId === "claude") {
    return listClaudePlugins();
  }
  return [];
}

function listCodexSkills() {
  const skillsDir = path.join(TOOLS.codex.home, "skills");
  const active = listSkillDirectories(skillsDir, false);
  const disabledRoot = path.join(SKILL_DISABLED_DIR, "codex");
  const disabled = listSkillDirectories(disabledRoot, true);
  return [...active, ...disabled].sort((a, b) => a.name.localeCompare(b.name));
}

function listSkillDirectories(root, disabled) {
  if (!fs.existsSync(root)) {
    return [];
  }
  return fs
    .readdirSync(root, { withFileTypes: true })
    .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
    .map((entry) => {
      const dir = path.join(root, entry.name);
      const skillPath = path.join(dir, "SKILL.md");
      if (!fs.existsSync(skillPath)) {
        return null;
      }
      const stat = safeStat(skillPath) || safeStat(dir);
      const metadata = parseSkillMarkdown(fs.readFileSync(skillPath, "utf8"));
      return {
        id: entry.name,
        name: metadata.name || entry.name,
        description: metadata.description || "",
        type: disabled ? "skill-off" : "skill",
        path: skillPath,
        root_path: dir,
        original_path: disabled
          ? path.join(TOOLS.codex.home, "skills", entry.name)
          : dir,
        disabled,
        updated_at: stat ? stat.mtime.toISOString() : "",
      };
    })
    .filter(Boolean);
}

function listClaudePlugins() {
  const installed = listInstalledClaudePlugins();
  if (installed.length) {
    return installed;
  }
  return listAvailableClaudePluginManifests();
}

function listInstalledClaudePlugins(force = false) {
  if (!force && claudePluginCache.expiresAt > Date.now()) {
    return claudePluginCache.installed;
  }
  const result = spawnToolCommand(TOOLS.claude.command, ["plugin", "list", "--json"], {
    encoding: "utf8",
    env: { ...process.env },
    timeout: 15000,
  });
  let items = [];
  if (!result.error && result.status === 0) {
    try {
      const parsed = JSON.parse(result.stdout || "[]");
      items = Array.isArray(parsed) ? parsed : parsed.installed || [];
    } catch {}
  }
  const plugins = items.map(normalizeClaudePluginRecord).filter(Boolean);
  claudePluginCache = {
    expiresAt: Date.now() + 3000,
    installed: plugins,
  };
  return plugins;
}

function normalizeClaudePluginRecord(item) {
  if (!item || typeof item !== "object") {
    return null;
  }
  const pluginId =
    item.pluginId || item.id || item.name || item.plugin || item.fullName || "";
  if (!pluginId) {
    return null;
  }
  return {
    id: pluginId,
    name: item.name || pluginId.split("@")[0],
    description: item.description || item.status || "",
    type: item.enabled === false || item.disabled ? "plugin-off" : "plugin",
    path: item.installPath || item.path || "",
    disabled: item.enabled === false || Boolean(item.disabled),
    installed: true,
    scope: item.scope || "user",
    updated_at: item.updatedAt || item.installedAt || "",
  };
}

function listAvailableClaudePluginManifests() {
  const root = path.join(TOOLS.claude.home, "plugins", "marketplaces");
  const seen = new Set();
  const plugins = [];
  for (const manifestPath of findFiles(root, "plugin.json", 6)) {
    if (!manifestPath.includes(`${path.sep}.claude-plugin${path.sep}`)) {
      continue;
    }
    const pluginDir = path.dirname(path.dirname(manifestPath));
    if (seen.has(pluginDir)) {
      continue;
    }
    seen.add(pluginDir);
    try {
      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
      const stat = safeStat(manifestPath) || safeStat(pluginDir);
      plugins.push({
        id: `${manifest.name || path.basename(pluginDir)}@claude-plugins-official`,
        name: manifest.name || path.basename(pluginDir),
        description: manifest.description || "",
        type: "available",
        path: pluginDir,
        disabled: true,
        installed: false,
        scope: "user",
        updated_at: stat ? stat.mtime.toISOString() : "",
      });
    } catch {}
  }
  return plugins.sort((a, b) => a.name.localeCompare(b.name));
}

function parseSkillMarkdown(text) {
  const metadata = {};
  const match = String(text || "").match(/^---\r?\n([\s\S]*?)\r?\n---/);
  if (match) {
    for (const line of match[1].split(/\r?\n/)) {
      const item = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
      if (item) {
        metadata[item[1]] = item[2].trim().replace(/^["']|["']$/g, "");
      }
    }
  }
  if (!metadata.description) {
    const firstParagraph = String(text || "")
      .replace(/^---\n[\s\S]*?\n---/, "")
      .replace(/^---\r?\n[\s\S]*?\r?\n---/, "")
      .split(/\n\s*\n/)
      .map((part) => part.replace(/^#+\s*/gm, "").trim())
      .find(Boolean);
    metadata.description = firstParagraph || "";
  }
  return metadata;
}

function backupSkill(skill) {
  const sourcePath = skill.root_path || skill.path;
  if (!sourcePath || !fs.existsSync(sourcePath)) {
    throw new Error("找不到 skill/plugin 路径");
  }
  const toolId = skill.type.startsWith("plugin") || skill.type === "available"
    ? "claude"
    : "codex";
  const targetDir = path.join(
    SKILL_BACKUP_DIR,
    toolId,
    `${timestampForPath()}-${sanitizePathPart(skill.name || skill.id)}`,
  );
  fs.mkdirSync(path.dirname(targetDir), { recursive: true, mode: 0o700 });
  fs.cpSync(sourcePath, targetDir, { recursive: true, force: false });
  atomicWriteFile(
    path.join(targetDir, "manifest.json"),
    `${JSON.stringify(
      {
        tool: toolId,
        skill_id: skill.id || "",
        skill_name: skill.name || skill.id || "",
        source_path: sourcePath,
        backed_up_at: nowIso(),
      },
      null,
      2,
    )}\n`,
    0o600,
  );
  return targetDir;
}

function toggleCodexSkill(skill) {
  if (!skill || !skill.root_path) {
    throw new Error("请选择一个 Codex skill");
  }
  const disabledRoot = path.join(SKILL_DISABLED_DIR, "codex");
  fs.mkdirSync(disabledRoot, { recursive: true, mode: 0o700 });
  if (skill.disabled) {
    if (fs.existsSync(skill.original_path)) {
      throw new Error(`启用位置已存在: ${skill.original_path}`);
    }
    const target = skill.original_path;
    movePath(skill.root_path, target);
    return { enabled: true, path: target };
  }
  backupSkill(skill);
  const target = path.join(disabledRoot, skill.id);
  if (fs.existsSync(target)) {
    throw new Error(`禁用目录已存在: ${target}`);
  }
  movePath(skill.root_path, target);
  return { enabled: false, path: target };
}

function createCodexSkill(name, description, instructions) {
  const id = normalizeSkillName(name);
  if (!id) {
    throw new Error("Skill 名称只能包含小写字母、数字和连字符");
  }
  const skillDir = path.join(TOOLS.codex.home, "skills", id);
  if (fs.existsSync(skillDir)) {
    throw new Error(`Skill 已存在: ${id}`);
  }
  fs.mkdirSync(skillDir, { recursive: true, mode: 0o700 });
  const content = [
    "---",
    `name: ${id}`,
    `description: ${yamlScalar(description)}`,
    "---",
    "",
    `# ${name.trim() || id}`,
    "",
    instructions.trim() || "Describe the workflow and when to use this skill.",
    "",
  ].join("\n");
  atomicWriteFile(path.join(skillDir, "SKILL.md"), content, 0o600);
  return skillDir;
}

function editCodexSkill(skill, description, instructions) {
  if (!skill || skill.disabled || !skill.path || !fs.existsSync(skill.path)) {
    throw new Error("只能编辑已启用的 Codex skill");
  }
  backupSkill(skill);
  const original = fs.readFileSync(skill.path, "utf8");
  const metadata = parseSkillMarkdown(original);
  const body = stripSkillFrontmatter(original).trim();
  const nextDescription = description.trim() || metadata.description || "";
  const nextBody = instructions.trim() || body || `# ${skill.name}`;
  const content = [
    "---",
    `name: ${normalizeSkillName(metadata.name || skill.id) || skill.id}`,
    `description: ${yamlScalar(nextDescription)}`,
    "---",
    "",
    nextBody,
    "",
  ].join("\n");
  atomicWriteFile(skill.path, content, 0o600);
}

function trashCodexSkill(skill) {
  if (!skill || !skill.root_path || !fs.existsSync(skill.root_path)) {
    throw new Error("找不到 skill 路径");
  }
  backupSkill(skill);
  const trashDir = path.join(SKILL_TRASH_DIR, "codex");
  fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
  const target = uniquePath(
    path.join(
      trashDir,
      `${timestampForPath()}-${sanitizePathPart(skill.id || skill.name)}`,
    ),
  );
  movePath(skill.root_path, target);
  return target;
}

function normalizeSkillName(value) {
  return String(value || "")
    .trim()
    .toLowerCase()
    .replace(/[^a-z0-9-]+/g, "-")
    .replace(/^-+|-+$/g, "")
    .replace(/-{2,}/g, "-")
    .slice(0, 63);
}

function stripSkillFrontmatter(text) {
  return String(text || "")
    .replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
}

function yamlScalar(value) {
  return JSON.stringify(String(value || "").trim());
}

function runClaudePluginCommand(args) {
  const result = spawnToolCommand(TOOLS.claude.command, ["plugin", ...args], {
    encoding: "utf8",
    env: { ...process.env },
    timeout: 120000,
  });
  claudePluginCache = { expiresAt: 0, installed: [] };
  if (result.error) {
    throw result.error;
  }
  if (result.status !== 0) {
    throw new Error((result.stderr || result.stdout || "Claude plugin 命令失败").trim());
  }
  return (result.stdout || "").trim();
}

function openTextEditor(targetPath) {
  const invocation = WINDOWS_RUNTIME
    ? WINDOWS_RUNTIME.editorCommand(targetPath)
    : (() => {
        const parts = splitCommandLine(process.env.EDITOR || process.env.VISUAL || "nano");
        return { command: parts.shift(), args: [...parts, targetPath] };
      })();
  const result = spawnSync(invocation.command, invocation.args, {
    stdio: "inherit",
    env: { ...process.env },
  });
  if (result.error) {
    throw result.error;
  }
  if (result.status !== 0) {
    throw new Error(`编辑器退出码: ${result.status}`);
  }
}

function spawnToolCommand(command, args, options) {
  return WINDOWS_RUNTIME
    ? WINDOWS_RUNTIME.spawnCommand(command, args, options)
    : spawnSync(command, args, options);
}

function splitCommandLine(value) {
  return String(value || "")
    .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
    ?.map((part) => part.replace(/^["']|["']$/g, "")) || [];
}

function installClaudePlugin(pluginId, scope = "user") {
  return runClaudePluginCommand(["install", pluginId, "--scope", scope]);
}

function toggleClaudePlugin(plugin) {
  if (!plugin || !plugin.id) {
    throw new Error("请选择一个 Claude plugin");
  }
  if (!plugin.installed) {
    installClaudePlugin(plugin.id, plugin.scope || "user");
    return { enabled: true, installed: true };
  }
  const command = plugin.disabled ? "enable" : "disable";
  runClaudePluginCommand([command, plugin.id, "--scope", plugin.scope || "user"]);
  return { enabled: plugin.disabled, installed: true };
}

function uninstallClaudePlugin(plugin) {
  if (!plugin || !plugin.id || !plugin.installed) {
    throw new Error("该插件尚未安装");
  }
  runClaudePluginCommand([
    "uninstall",
    plugin.id,
    "--scope",
    plugin.scope || "user",
    "--keep-data",
  ]);
}

function listSessions(toolId, limit = 200) {
  const metadata = loadSessionMetadata();
  const sessions =
    toolId === "codex"
      ? listCodexSessions()
      : toolId === "claude"
        ? listClaudeSessions()
        : [];
  return sessions
    .map((session) => ({
      ...session,
      favorite: Boolean(metadata[session.key]?.favorite),
      tags: normalizeTags(metadata[session.key]?.tags),
      channel_id: metadata[session.key]?.channel_id || "",
      archived_at: metadata[session.key]?.archived_at || "",
    }))
    .sort((a, b) => {
      if (a.favorite !== b.favorite) {
        return a.favorite ? -1 : 1;
      }
      return new Date(b.updated_at || 0) - new Date(a.updated_at || 0);
    })
    .slice(0, limit);
}

function listCodexSessions() {
  const indexPath = path.join(TOOLS.codex.home, "session_index.jsonl");
  if (!fs.existsSync(indexPath)) {
    return [];
  }
  const pathMap = buildCodexSessionPathMap();
  return fs
    .readFileSync(indexPath, "utf8")
    .split(/\r?\n/)
    .filter(Boolean)
    .map((line) => {
      try {
        const item = JSON.parse(line);
        return {
          key: `codex:${item.id}`,
          tool: "codex",
          id: item.id,
          title: item.thread_name || item.id,
          cwd: "",
          updated_at: item.updated_at || "",
          path: pathMap.get(item.id) || "",
        };
      } catch {
        return null;
      }
    })
    .filter(Boolean);
}

function buildCodexSessionPathMap() {
  const map = new Map();
  const sessionsRoot = path.join(TOOLS.codex.home, "sessions");
  const files = findFiles(sessionsRoot, ".jsonl", 5);
  for (const filePath of files) {
    const match = path.basename(filePath).match(
      /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i,
    );
    if (match) {
      map.set(match[1], filePath);
    }
  }
  return map;
}

function loadSessionMetadata() {
  return readJsonObject(SESSION_META_PATH);
}

function saveSessionMetadata(metadata) {
  atomicWriteFile(
    SESSION_META_PATH,
    `${JSON.stringify(metadata, null, 2)}\n`,
    0o600,
  );
}

function updateSessionMetadata(session, patch) {
  const metadata = loadSessionMetadata();
  const current = metadata[session.key] || {};
  const next = {
    ...current,
    ...patch,
    tool: session.tool,
    session_id: session.id,
    title: session.title,
    updated_at: nowIso(),
  };
  if (!next.favorite && !normalizeTags(next.tags).length && !next.channel_id && !next.archived_at) {
    delete metadata[session.key];
  } else {
    next.tags = normalizeTags(next.tags);
    metadata[session.key] = next;
  }
  saveSessionMetadata(metadata);
  return metadata[session.key] || {};
}

function normalizeTags(value) {
  const tags = Array.isArray(value) ? value : String(value || "").split(",");
  return [...new Set(tags.map((tag) => String(tag).trim()).filter(Boolean))].slice(0, 12);
}

function toggleSessionFavorite(session) {
  return updateSessionMetadata(session, { favorite: !session.favorite });
}

function setSessionTags(session, value) {
  return updateSessionMetadata(session, { tags: normalizeTags(value) });
}

function bindSessionChannel(session, channelId) {
  return updateSessionMetadata(session, { channel_id: channelId || "" });
}

function archiveSession(session) {
  if (!session.path || !fs.existsSync(session.path)) {
    throw new Error("找不到该会话的原始文件");
  }
  const archiveDir = path.join(SESSION_ARCHIVE_DIR, session.tool);
  fs.mkdirSync(archiveDir, { recursive: true, mode: 0o700 });
  const archiveName = `${timestampForPath()}-${sanitizePathPart(session.id)}.jsonl`;
  const archivePath = path.join(archiveDir, archiveName);
  fs.copyFileSync(session.path, archivePath);
  if (WINDOWS_RUNTIME) {
    WINDOWS_RUNTIME.chmod(archivePath, 0o600);
  } else {
    fs.chmodSync(archivePath, 0o600);
  }
  const manifestPath = `${archivePath}.json`;
  atomicWriteFile(
    manifestPath,
    `${JSON.stringify(
      {
        key: session.key,
        tool: session.tool,
        session_id: session.id,
        title: session.title,
        cwd: session.cwd || "",
        source_path: session.path,
        archived_at: nowIso(),
      },
      null,
      2,
    )}\n`,
    0o600,
  );
  updateSessionMetadata(session, {
    archived_at: nowIso(),
    archive_path: archivePath,
  });
  return archivePath;
}

function trashSession(session) {
  if (!session.path || !fs.existsSync(session.path)) {
    throw new Error("找不到该会话的原始文件");
  }
  const trashDir = path.join(SESSION_TRASH_DIR, session.tool);
  fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
  const targetPath = uniquePath(
    path.join(
      trashDir,
      `${timestampForPath()}-${sanitizePathPart(path.basename(session.path))}`,
    ),
  );
  movePath(session.path, targetPath);
  if (session.tool === "codex") {
    removeCodexSessionIndexEntry(session.id);
  }
  const metadata = loadSessionMetadata();
  delete metadata[session.key];
  saveSessionMetadata(metadata);
  atomicWriteFile(
    `${targetPath}.json`,
    `${JSON.stringify(
      {
        key: session.key,
        tool: session.tool,
        session_id: session.id,
        title: session.title,
        original_path: session.path,
        trashed_at: nowIso(),
      },
      null,
      2,
    )}\n`,
    0o600,
  );
  return targetPath;
}

function removeCodexSessionIndexEntry(sessionId) {
  const indexPath = path.join(TOOLS.codex.home, "session_index.jsonl");
  if (!fs.existsSync(indexPath)) {
    return;
  }
  const lines = fs.readFileSync(indexPath, "utf8").split(/\r?\n/);
  const kept = lines.filter((line) => {
    if (!line.trim()) {
      return false;
    }
    try {
      return JSON.parse(line).id !== sessionId;
    } catch {
      return true;
    }
  });
  atomicWriteFile(indexPath, `${kept.join("\n")}${kept.length ? "\n" : ""}`, 0o600);
}

function listClaudeSessions() {
  const projectsDir = path.join(TOOLS.claude.home, "projects");
  const files = findFiles(projectsDir, ".jsonl", 2);
  return files.map(readClaudeSessionSummary).filter(Boolean);
}

function readClaudeSessionSummary(filePath) {
  try {
    const stat = fs.statSync(filePath);
    const id = path.basename(filePath, ".jsonl");
    const projectDir = path.basename(path.dirname(filePath));
    const text = fs.readFileSync(filePath, "utf8");
    const lines = text.split(/\r?\n/).filter(Boolean);
    let title = "";
    let cwd = "";
    let updatedAt = stat.mtime.toISOString();

    for (const line of lines) {
      let item = null;
      try {
        item = JSON.parse(line);
      } catch {
        continue;
      }
      if (!cwd && item.cwd) {
        cwd = item.cwd;
      }
      if (!title && item.type === "user" && item.message) {
        title = extractMessageText(item.message.content);
      }
      if (title && cwd) {
        break;
      }
    }

    return {
      key: `claude:${id}`,
      tool: "claude",
      id,
      title: title || id,
      cwd: cwd || decodeClaudeProjectPath(projectDir),
      updated_at: updatedAt,
      path: filePath,
    };
  } catch {
    return null;
  }
}

function extractMessageText(content) {
  if (typeof content === "string") {
    return compactText(content);
  }
  if (Array.isArray(content)) {
    return compactText(
      content
        .map((item) => {
          if (typeof item === "string") {
            return item;
          }
          if (item && typeof item.text === "string") {
            return item.text;
          }
          return "";
        })
        .filter(Boolean)
        .join(" "),
    );
  }
  return "";
}

function compactText(value) {
  return String(value || "").replace(/\s+/g, " ").trim();
}

function decodeClaudeProjectPath(value) {
  if (!value || value[0] !== "-") {
    return value || "";
  }
  return value.replace(/-/g, "/");
}

function launchSession(tool, session) {
  if (tool.id === "codex") {
    const env = { ...process.env, CODEX_HOME: tool.home };
    const result = spawnToolCommand(tool.command, ["resume", session.id], {
      stdio: "inherit",
      env,
    });
    if (result.error) {
      console.error(`启动 codex resume 失败: ${result.error.message}`);
    }
    process.exit(result.status || 0);
  }

  const result = spawnToolCommand(tool.command, ["--resume", session.id], {
    stdio: "inherit",
    env: { ...process.env },
  });
  if (result.error) {
    console.error(`启动 claude --resume 失败: ${result.error.message}`);
  }
  process.exit(result.status || 0);
}

function findFiles(root, targetName, maxDepth) {
  if (!root || !fs.existsSync(root)) {
    return [];
  }
  const results = [];
  walkFiles(root, targetName, maxDepth, 0, results);
  return results;
}

function walkFiles(dir, targetName, maxDepth, depth, results) {
  if (depth > maxDepth) {
    return;
  }
  let entries = [];
  try {
    entries = fs.readdirSync(dir, { withFileTypes: true });
  } catch {
    return;
  }
  for (const entry of entries) {
    const fullPath = path.join(dir, entry.name);
    if (entry.isDirectory()) {
      walkFiles(fullPath, targetName, maxDepth, depth + 1, results);
    } else if (entry.isFile()) {
      if (
        entry.name === targetName ||
        (targetName.startsWith(".") && entry.name.endsWith(targetName))
      ) {
        results.push(fullPath);
      }
    }
  }
}

function safeStat(targetPath) {
  try {
    return fs.statSync(targetPath);
  } catch {
    return null;
  }
}

function readJsonObject(targetPath) {
  if (!fs.existsSync(targetPath)) {
    return {};
  }
  try {
    const text = fs.readFileSync(targetPath, "utf8").trim();
    const parsed = text ? JSON.parse(text) : {};
    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
      ? parsed
      : {};
  } catch {
    return {};
  }
}

function sanitizePathPart(value) {
  return String(value || "item")
    .replace(/[^\p{L}\p{N}._-]+/gu, "-")
    .replace(/^-+|-+$/g, "")
    .slice(0, 120) || "item";
}

function uniquePath(targetPath) {
  if (!fs.existsSync(targetPath)) {
    return targetPath;
  }
  const ext = path.extname(targetPath);
  const base = targetPath.slice(0, targetPath.length - ext.length);
  let index = 2;
  while (fs.existsSync(`${base}-${index}${ext}`)) {
    index += 1;
  }
  return `${base}-${index}${ext}`;
}

function movePath(sourcePath, targetPath) {
  fs.mkdirSync(path.dirname(targetPath), { recursive: true, mode: 0o700 });
  try {
    fs.renameSync(sourcePath, targetPath);
  } catch (error) {
    if (error.code !== "EXDEV") {
      throw error;
    }
    fs.cpSync(sourcePath, targetPath, { recursive: true, force: false });
    fs.rmSync(sourcePath, { recursive: true, force: false });
  }
}

function safeRealpath(targetPath) {
  try {
    return fs.realpathSync(targetPath);
  } catch {
    return "";
  }
}

function sha256File(targetPath) {
  try {
    return crypto.createHash("sha256").update(fs.readFileSync(targetPath)).digest("hex");
  } catch {
    return "";
  }
}

function writeRuntimeProbe() {
  try {
    const frame = stripAnsi(
      buildTerminalUiFrame({
        activeToolId: "codex",
        activePage: "channels",
        selectedIndex: 0,
        message: "runtime",
        help: false,
        busy: false,
      }),
    );
    fs.writeFileSync(
      path.join(STATE_HOME, "runtime.json"),
      `${JSON.stringify(
        {
          build_id: CCM_BUILD_ID,
          started_at: new Date().toISOString(),
          node: process.version,
          exec_path: process.execPath,
          script: __filename,
          script_real: safeRealpath(__filename),
          script_sha256: sha256File(__filename),
          cwd: process.cwd(),
          term: process.env.TERM || "",
          shell: process.env.SHELL || "",
          path: process.env.PATH || "",
          frame_header: frame.includes("ccm Channel Manager [Channels] Skills Sessions"),
        },
        null,
        2,
      )}\n`,
    );
  } catch {}
}

function formatShortTime(value) {
  if (!value) {
    return "-";
  }
  const date = new Date(value);
  if (Number.isNaN(date.getTime())) {
    return "-";
  }
  const month = String(date.getMonth() + 1).padStart(2, "0");
  const day = String(date.getDate()).padStart(2, "0");
  const hours = String(date.getHours()).padStart(2, "0");
  const minutes = String(date.getMinutes()).padStart(2, "0");
  return `${month}-${day} ${hours}:${minutes}`;
}

function skillsTableColumns(innerWidth) {
  const gap = 2;
  const status = 6;
  const index = 4;
  const name = Math.min(24, Math.max(14, Math.floor(innerWidth * 0.22)));
  const url = 8;
  const model = 12;
  const key = Math.max(20, innerWidth - status - index - name - url - model - gap * 5);
  return { status, index, name, url, key, model, gap };
}

function sessionsTableColumns(innerWidth) {
  const gap = 2;
  const status = 6;
  const index = 4;
  const name = Math.min(30, Math.max(16, Math.floor(innerWidth * 0.26)));
  const model = 14;
  const key = 14;
  const url = Math.max(16, innerWidth - status - index - name - model - key - gap * 5);
  return { status, index, name, url, key, model, gap };
}

function activeTabText(activeToolId) {
  return Object.values(TOOLS)
    .map((tool) =>
      tuiColor(
        " " + tool.label + " ",
        activeToolId === tool.id ? "tabActive" : "tabInactive",
      ),
    )
    .join(" ");
}

function repeat(char, width) {
  return char.repeat(Math.max(0, width));
}

function fitText(value, width) {
  const text = String(value || "");
  if (width <= 0) {
    return "";
  }
  const currentWidth = stringWidth(text);
  if (currentWidth === width) {
    return text;
  }
  if (currentWidth < width) {
    return text + " ".repeat(width - currentWidth);
  }
  return truncateDisplay(text, width);
}

function terminalTableColumns(innerWidth) {
  const gap = 2;
  let status = 8;
  let index = 4;
  let name = Math.min(22, Math.max(12, Math.floor(innerWidth * 0.18)));
  let key = 13;
  let model = Math.min(18, Math.max(10, Math.floor(innerWidth * 0.12)));
  let url = innerWidth - status - index - name - key - model - gap * 5;

  if (url < 24) {
    name = 12;
    model = 10;
    status = 7;
    url = Math.max(20, innerWidth - status - index - name - key - model - gap * 5);
  }

  return { status, index, name, url, key, model, gap };
}

function tableRow(values, cols) {
  const gap = " ".repeat(cols.gap);
  return [
    fitText(values[0], cols.status),
    fitText(values[1], cols.index),
    fitText(values[2], cols.name),
    fitText(values[3], cols.url),
    fitText(values[4], cols.key),
    fitText(values[5], cols.model),
  ].join(gap);
}

function statusBadge(selected, current) {
  if (selected && current) {
    return "▶ 当前";
  }
  if (current) {
    return "● 当前";
  }
  if (selected) {
    return "▶";
  }
  return "";
}

function summaryLine(labelA, valueA, labelB, valueB, labelC, valueC, width) {
  const left = `${tuiColor(labelA, "label")} ${fitText(valueA, 12)}`;
  const middle = `${tuiColor(labelB, "label")} ${fitText(valueB, 20)}`;
  const right = `${tuiColor(labelC, "label")} ${valueC}`;
  return joinLeftRight(`${left}  ${middle}`, right, width);
}

function joinLeftRight(left, right, width) {
  const gap = width - stringWidth(left) - stringWidth(right);
  if (gap <= 1) {
    return fitText(stripAnsi(`${left} ${right}`), width);
  }
  return `${left}${" ".repeat(gap)}${right}`;
}

function keyHint(value) {
  return tuiColor(value, "key");
}

function boxTop(width) {
  return `${tuiColor("╭", "border")}${tuiColor(repeat("─", width - 2), "border")}${tuiColor("╮", "border")}`;
}

function boxSeparator(width) {
  return `${tuiColor("├", "border")}${tuiColor(repeat("─", width - 2), "border")}${tuiColor("┤", "border")}`;
}

function boxBottom(width) {
  return `${tuiColor("╰", "border")}${tuiColor(repeat("─", width - 2), "border")}${tuiColor("╯", "border")}`;
}

function boxLine(content, width, style = "") {
  const innerWidth = width - 4;
  let cell = String(content || "");
  if (stringWidth(cell) > innerWidth) {
    cell = fitText(stripAnsi(cell), innerWidth);
  }
  cell = padAnsi(cell, innerWidth);
  if (style) {
    cell = tuiColor(cell, style);
  }
  return `${tuiColor("│", "border")} ${cell} ${tuiColor("│", "border")}`;
}

function padAnsi(value, width) {
  const text = String(value || "");
  const currentWidth = stringWidth(text);
  if (currentWidth >= width) {
    return text;
  }
  return text + " ".repeat(width - currentWidth);
}

function tuiColor(value, style) {
  const text = String(value || "");
  if (process.env.NO_COLOR || !process.stdout.isTTY) {
    return text;
  }
  const styles = {
    title: "\x1b[1m\x1b[38;5;51m",
    muted: "\x1b[38;5;245m",
    label: "\x1b[38;5;110m",
    border: "\x1b[38;5;238m",
    tableHead: "\x1b[1m\x1b[38;5;153m",
    selectedRow: "\x1b[48;5;24m\x1b[38;5;231m",
    currentRow: "\x1b[38;5;120m",
    tabActive: "\x1b[1m\x1b[38;5;16m\x1b[48;5;80m",
    tabInactive: "\x1b[38;5;245m",
    key: "\x1b[1m\x1b[38;5;220m",
    error: "\x1b[1m\x1b[38;5;203m",
    cursor: "\x1b[1m\x1b[38;5;231m\x1b[48;5;39m",
    modalActive: "\x1b[48;5;236m\x1b[38;5;231m",
  };
  const code = styles[style] || "";
  return code ? `${code}${text}\x1b[0m` : text;
}

function stripAnsi(value) {
  return String(value || "").replace(/\x1b\[[0-9;]*m/g, "");
}

function stringWidth(value) {
  let width = 0;
  for (const char of stripAnsi(value)) {
    width += codePointWidth(char.codePointAt(0));
  }
  return width;
}

function codePointWidth(codePoint) {
  if (!Number.isFinite(codePoint)) {
    return 0;
  }
  if (codePoint === 0) {
    return 0;
  }
  if (codePoint < 32 || (codePoint >= 0x7f && codePoint < 0xa0)) {
    return 0;
  }
  if (codePoint >= 0x300 && codePoint <= 0x36f) {
    return 0;
  }
  if (
    codePoint >= 0x1100 &&
    (codePoint <= 0x115f ||
      codePoint === 0x2329 ||
      codePoint === 0x232a ||
      (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
      (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
      (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
      (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
      (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
      (codePoint >= 0xff00 && codePoint <= 0xff60) ||
      (codePoint >= 0xffe0 && codePoint <= 0xffe6))
  ) {
    return 2;
  }
  return 1;
}

function truncateDisplay(value, width) {
  if (width <= 0) {
    return "";
  }
  if (width === 1) {
    return "…";
  }
  const limit = width - 1;
  let output = "";
  let used = 0;
  for (const char of String(value || "")) {
    const charWidth = codePointWidth(char.codePointAt(0));
    if (used + charWidth > limit) {
      break;
    }
    output += char;
    used += charWidth;
  }
  return output + "…" + " ".repeat(Math.max(0, width - used - 1));
}

function printToolSummary(tool) {
  const channels = loadRegistry(tool);
  const current = resolveCurrentChannel(tool, channels);
  const snapshot = readCurrentSnapshot(tool);
  const baseUrl = snapshot.base_url ? ` ${snapshot.base_url}` : "";
  console.log(
    `${padRight(tool.label, 8)} 当前: ${current ? current.name : "未收录"}${baseUrl}  渠道数: ${channels.length}`,
  );
}

function listChannelsCli(tool) {
  const channels = loadRegistry(tool);
  const current = resolveCurrentChannel(tool, channels);
  if (!channels.length) {
    console.log(`${tool.label} 当前还没有配置任何渠道。`);
    return;
  }

  console.log(`${tool.label} 渠道列表`);
  console.log("");
  console.log("标记 序号 名称             地址                             密钥");
  console.log("---- ---- ---------------- -------------------------------- -----------");

  for (const [index, channel] of channels.entries()) {
    const mark = current && current.id === channel.id ? "*" : " ";
    console.log(
      `${padRight(mark, 4)} ${padRight(String(index + 1), 4)} ${padRight(channel.name, 16)} ${padRight(channel.base_url, 32)} ${maskKey(channel.api_key)}`,
    );
  }
}

function printCurrentChannelCli(tool) {
  const channels = loadRegistry(tool);
  const current = resolveCurrentChannel(tool, channels);
  if (current) {
    printCurrentDetails(tool, current);
    return;
  }

  const snapshot = readCurrentSnapshot(tool);
  if (!snapshot.base_url && !snapshot.api_key) {
    console.log(`${tool.label} 当前没有检测到激活渠道。`);
    return;
  }

  console.log(`${tool.label} 当前渠道`);
  console.log("");
  console.log("状态: 未收录");
  console.log(`地址: ${snapshot.base_url || "-"}`);
  console.log(`密钥: ${maskKey(snapshot.api_key || "")}`);
  if (tool.id === "claude") {
    console.log(`密钥变量: ${snapshot.auth_env_key || "-"}`);
  }
  if (snapshot.model) {
    console.log(`模型: ${snapshot.model}`);
  }
}

function useChannelCli(tool, channelName) {
  const channels = loadRegistry(tool);
  const channel = findChannel(channels, channelName);
  if (!channel) {
    throw new Error(`未找到 ${tool.label} 渠道: ${channelName}`);
  }

  switchToChannelSync(tool, channel);
  console.log(`已切换到 ${tool.label} 渠道 ${channel.name}`);
  if (tool.id === "claude") {
    console.log("Claude 已写入 ~/.bashrc 和 ccm 激活脚本；shell wrapper 会在 ccm 返回后自动加载。");
  }
}

async function runInteractive(tool) {
  while (true) {
    const channels = loadRegistry(tool);
    const current = resolveCurrentChannel(tool, channels);
    printMainMenu(tool, channels, current);
    const answer = (
      await prompt(
        "请输入序号或“序号+操作”，或选择 [a] 新增、[v] 查看当前、[r] 回滚、[b] 返回、[q] 退出: ",
      )
    )
      .trim()
      .toLowerCase();

    if (!answer) {
      continue;
    }

    if (answer === "q") {
      process.exit(0);
    }

    if (answer === "b") {
      return;
    }

    if (answer === "a") {
      await addChannel(tool);
      continue;
    }

    if (answer === "v") {
      printCurrentDetails(tool, current);
      await pause();
      continue;
    }

    if (answer === "r") {
      await rollbackLastBackup(tool);
      await pause();
      continue;
    }

    const parsedAction = parseChannelQuickAction(answer, channels);
    if (parsedAction) {
      const shouldExit = await executeChannelQuickAction(
        tool,
        parsedAction.channel,
        parsedAction.action,
      );
      if (shouldExit) {
        return;
      }
      continue;
    }

    const selected = selectByNumber(answer, channels);
    if (!selected) {
      console.log("选择无效。");
      await pause();
      continue;
    }

    const shouldExit = await runChannelActions(tool, selected);
    if (shouldExit) {
      return;
    }
  }
}

function printMainMenu(tool, channels, current) {
  clearScreen();
  const runningPids = detectRunningToolPids(tool);
  const snapshot = readCurrentSnapshot(tool);

  console.log(`${tool.label} Channel Manager`);
  console.log("");
  if (tool.id === "codex") {
    console.log(`Codex home : ${tool.home}`);
  } else {
    console.log(`Bashrc     : ${tool.bashrcPath}`);
  }
  console.log(`状态目录   : ${STATE_HOME}`);
  console.log(
    `当前渠道   : ${current ? current.name : "未收录"}${snapshot.base_url ? `  ${snapshot.base_url}` : ""}`,
  );
  console.log(`${tool.label} 进程: ${runningPids.length ? runningPids.join(", ") : "无"}`);
  console.log("");

  if (!channels.length) {
    console.log("当前还没有配置任何渠道。");
    console.log("");
  } else {
    for (const [index, channel] of channels.entries()) {
      const mark = current && current.id === channel.id ? "当前" : "";
      const model = channel.model ? `  模型=${channel.model}` : "";
      const authKey =
        tool.id === "claude" && channel.auth_env_key
          ? `  变量=${channel.auth_env_key}`
          : "";
      console.log(
        `${index + 1}. ${padRight(channel.name, 16)} ${padRight(channel.base_url, 32)} ${maskKey(channel.api_key)}${model}${authKey}${mark ? `  ${mark}` : ""}`,
      );
    }
    console.log("");
  }

  console.log("快捷键");
  console.log("  输入序号           进入该渠道的操作菜单");
  console.log(`  输入 序号s         仅切换到该 ${tool.label} 渠道`);
  console.log(`  输入 序号c         切换并启动 ${tool.id}`);
  console.log(`  输入 序号r         切换并恢复上次 ${tool.label} 会话`);
  console.log("  输入 序号e         编辑该渠道");
  console.log("  输入 序号d         删除该渠道");
  console.log("  [a] 新增渠道   [v] 查看当前   [r] 回滚上次切换   [b] 返回   [q] 退出");
  console.log("");
}

function printCurrentDetails(tool, current) {
  const snapshot = readCurrentSnapshot(tool);
  console.log("");
  console.log(`${tool.label} 当前渠道`);
  console.log("");
  if (current) {
    console.log(`名称    : ${current.name}`);
    console.log(`地址    : ${current.base_url}`);
    console.log(`密钥    : ${maskKey(current.api_key)}`);
    if (tool.id === "claude") {
      console.log(`密钥变量: ${current.auth_env_key || "ANTHROPIC_AUTH_TOKEN"}`);
    }
    console.log(`模型    : ${current.model || "（保持现状）"}`);
    console.log(`备注    : ${current.remark || ""}`);
    return;
  }

  console.log("当前激活配置与任何已保存渠道都不匹配。");
  console.log(`地址    : ${snapshot.base_url || "-"}`);
  console.log(`密钥    : ${maskKey(snapshot.api_key || "")}`);
  if (tool.id === "claude") {
    console.log(`密钥变量: ${snapshot.auth_env_key || "-"}`);
  }
  console.log(`模型    : ${snapshot.model || "-"}`);
}

async function runChannelActions(tool, channel) {
  while (true) {
    clearScreen();
    console.log(`工具: ${tool.label}`);
    console.log(`渠道: ${channel.name}`);
    console.log(`地址    : ${channel.base_url}`);
    console.log(`密钥    : ${maskKey(channel.api_key)}`);
    if (tool.id === "claude") {
      console.log(`密钥变量: ${channel.auth_env_key || "ANTHROPIC_AUTH_TOKEN"}`);
    }
    console.log(`模型    : ${channel.model || "（保持现状）"}`);
    console.log(`备注    : ${channel.remark || ""}`);
    console.log("");
    console.log(`1. 切换并启动 ${tool.id}`);
    console.log("2. 切换并恢复上次会话");
    console.log("3. 仅切换");
    console.log("4. 编辑渠道");
    console.log("5. 删除渠道");
    console.log("6. 返回");
    console.log("");

    const action = (await prompt("请选择操作: ")).trim();

    if (action === "6") {
      return false;
    }

    if (action === "4") {
      await editChannel(tool, channel.id);
      channel = loadRegistry(tool).find((item) => item.id === channel.id);
      if (!channel) {
        return false;
      }
      continue;
    }

    if (action === "5") {
      await deleteChannel(tool, channel.id);
      return false;
    }

    if (!["1", "2", "3"].includes(action)) {
      console.log("操作无效。");
      await pause();
      continue;
    }

    const switched = await switchToChannel(tool, channel);
    if (!switched) {
      await pause();
      continue;
    }

    if (action === "3") {
      printSwitchOnlyNote(tool);
      await pause();
      return false;
    }

    launchTool(tool, channel, action === "2" ? "resume" : "start");
    return true;
  }
}

async function executeChannelQuickAction(tool, channel, action) {
  if (action === "menu") {
    return runChannelActions(tool, channel);
  }

  if (action === "edit") {
    await editChannel(tool, channel.id);
    return false;
  }

  if (action === "delete") {
    await deleteChannel(tool, channel.id);
    return false;
  }

  const switched = await switchToChannel(tool, channel);
  if (!switched) {
    await pause();
    return false;
  }

  if (action === "switch") {
    printSwitchOnlyNote(tool);
    await pause();
    return false;
  }

  launchTool(tool, channel, action === "resume" ? "resume" : "start");
  return true;
}

function printSwitchOnlyNote(tool) {
  console.log("");
  console.log(`渠道已切换。你现在可以手动启动 ${tool.label}。`);
  if (tool.id === "claude") {
    console.log("本次 ccm 内已生效；退出 ccm 后 shell wrapper 会自动加载到当前终端。");
  }
}

async function addChannel(tool) {
  clearScreen();
  console.log(`新增 ${tool.label} 渠道`);
  console.log("");

  const name = await promptRequired("名称: ");
  const baseUrl = await promptUrl("地址: ");
  const apiKey = await promptSecretRequired("密钥: ");
  const modelLabel =
    tool.id === "claude" ? "默认模型（启动时使用，可留空）" : "默认模型（可留空）";
  const model = (await prompt(`${modelLabel}: `)).trim();
  const remark = (await prompt("备注（可留空）: ")).trim();
  const authEnvKey =
    tool.id === "claude"
      ? await promptClaudeAuthEnvKey("密钥变量", "ANTHROPIC_AUTH_TOKEN")
      : "";
  saveChannelForm(tool, "add", "", {
    name,
    base_url: baseUrl,
    api_key: apiKey,
    auth_env_key: authEnvKey,
    model,
    remark,
  });
  console.log("");
  console.log("渠道已新增。");
  await pause();
}

async function editChannel(tool, channelId) {
  const channels = loadRegistry(tool);
  const channel = channels.find((item) => item.id === channelId);
  if (!channel) {
    console.log("该渠道已不存在。");
    await pause();
    return;
  }

  clearScreen();
  console.log(`编辑 ${tool.label} 渠道`);
  console.log("");

  const name = await promptWithDefault("名称", channel.name);
  const baseUrl = await promptUrl("地址", channel.base_url);

  const keepKey = (
    await prompt(`保留当前密钥 ${maskKey(channel.api_key)} ? [Y/n]: `)
  )
    .trim()
    .toLowerCase();
  let apiKey = "";
  if (keepKey === "n") {
    apiKey = await promptSecretRequired("新的密钥: ");
  }

  let authEnvKey = "";
  if (tool.id === "claude") {
    authEnvKey = await promptClaudeAuthEnvKey(
      "密钥变量",
      channel.auth_env_key || "ANTHROPIC_AUTH_TOKEN",
    );
  }

  const model = (await promptWithDefault("默认模型", channel.model || "")).trim();
  const remark = (await promptWithDefault("备注", channel.remark || "")).trim();
  saveChannelForm(tool, "edit", channel.id, {
    name,
    base_url: baseUrl,
    api_key: apiKey,
    auth_env_key: authEnvKey,
    model,
    remark,
  });
  console.log("");
  console.log("渠道已更新。");
  await pause();
}

async function deleteChannel(tool, channelId) {
  const channels = loadRegistry(tool);
  const channel = channels.find((item) => item.id === channelId);
  if (!channel) {
    console.log("该渠道已不存在。");
    await pause();
    return false;
  }

  const answer = (
    await prompt(`确认删除 ${tool.label} 渠道 ${channel.name} 吗？输入 "delete" 确认: `)
  ).trim();
  if (answer !== "delete") {
    console.log("已取消删除。");
    await pause();
    return false;
  }

  deleteChannelById(tool, channelId);
  console.log("渠道已删除。");
  await pause();
  return true;
}

function deleteChannelById(tool, channelId) {
  const channels = loadRegistry(tool);
  const next = channels.filter((item) => item.id !== channelId);
  saveRegistry(tool, next);
  const state = loadToolState(tool);
  if (state.current_channel_id === channelId) {
    state.current_channel_id = "";
    saveToolState(tool, state);
  }
}

async function switchToChannel(tool, channel) {
  const running = detectRunningToolPids(tool);
  if (running.length) {
    console.log(`检测到正在运行的 ${tool.id} 进程: ${running.join(", ")}`);
    const answer = (await prompt("仍然继续切换吗？ [y/N]: "))
      .trim()
      .toLowerCase();
    if (answer !== "y") {
      return false;
    }
  }

  try {
    switchToChannelSync(tool, channel);
    console.log("");
    console.log(`已切换到 ${tool.label} 渠道 ${channel.name}`);
    return true;
  } catch (error) {
    console.log("");
    console.log(`切换失败: ${error.message}`);
    return false;
  }
}

function switchToChannelSync(tool, channel) {
  if (tool.id === "codex" && channel.kind !== "official" && !fs.existsSync(tool.home)) {
    throw new Error(`Codex home 不存在: ${tool.home}`);
  }

  let releaseLock = null;
  let backupPath = "";
  let codexEnvironmentSynced = false;
  try {
    releaseLock = acquireLock(tool);
    backupPath = backupCurrentFiles(tool, channel);
    const state = loadToolState(tool);
    if (tool.id === "codex" && channel.kind === "official") {
      ensureOfficialHome(tool.home);
      clearCodexApiKey(tool);
    } else if (tool.id === "claude" && channel.kind === "official") {
      if (WINDOWS_RUNTIME) {
        clearClaudeApiChannel(tool.bashrcPath);
      } else {
        rewriteClaudeBashrc(tool, channel);
      }
    } else if (tool.id === "codex") {
      rewriteCodexConfig(tool, channel);
      rewriteCodexAuth(tool, channel);
    } else if (tool.id === "claude") {
      rewriteClaudeBashrc(tool, channel);
      if (!WINDOWS_RUNTIME) {
        writeClaudeActivation(channel);
        applyClaudeChannelEnvToProcess(channel);
      }
    } else if (tool.id === "pi") {
      if (channel.kind === "official") {
        restorePiOfficialConfig(tool, state);
      } else {
        rewritePiConfig(tool, channel, state);
      }
    } else if (tool.id === "grok") {
      if (channel.kind === "official") {
        restoreGrokOfficialConfig(tool, state);
      } else {
        rewriteGrokConfig(tool, channel, state);
      }
    }

    if (["codex", "pi", "grok"].includes(tool.id) && channel.kind !== "official") {
      const actual = readCurrentSnapshot(tool);
      if (
        normalizeBaseUrl(actual.base_url || "") !== normalizeBaseUrl(channel.base_url) ||
        (actual.api_key || "") !== channel.api_key ||
        (actual.model || "") !== (channel.model || "")
      ) {
        throw new Error(tool.label + " channel verification failed after writing configuration.");
      }
    }
    if (tool.id === "codex") {
      // Mark this before syncing. If the second Windows registry write fails, the
      // catch block restores both configuration files and environment variables.
      codexEnvironmentSynced = true;
      syncCodexRuntimeEnvironment(
        channel.kind === "official" ? "" : channel.base_url,
        channel.kind === "official" ? "" : channel.api_key,
      );
    }

    const registry = loadRegistry(tool);
    const target = registry.find((item) => item.id === channel.id);
    if (target) {
      target.last_used_at = nowIso();
      target.updated_at = nowIso();
      saveRegistry(tool, registry);
    }

    state.current_channel_id = channel.id;
    state.last_backup_dir = backupPath;
    state.last_switched_at = nowIso();
    saveToolState(tool, state);

  } catch (error) {
    if (backupPath) {
      try {
        restoreToolFilesFromBackup(tool, backupPath);
        if (tool.id === "codex" && codexEnvironmentSynced) {
          const snapshot = readCodexSnapshot(tool);
          syncCodexRuntimeEnvironment(snapshot.base_url, snapshot.api_key);
        }
      } catch (rollbackError) {
        error.message = `${error.message}; rollback failed: ${rollbackError.message}`;
      }
    }
    throw error;
  } finally {
    if (releaseLock) {
      releaseLock();
    }
  }
}

async function rollbackLastBackup(tool) {
  const state = loadToolState(tool);
  if (!state.last_backup_dir) {
    console.log("当前没有可回滚的备份。");
    return;
  }

  const answer = (await prompt(`回滚到 ${state.last_backup_dir} 吗？ [y/N]: `))
    .trim()
    .toLowerCase();
  if (answer !== "y") {
    console.log("已取消回滚。");
    return;
  }

  rollbackBackupSync(tool);
  console.log("回滚已完成。");
}

function rollbackBackupSync(tool) {
  const state = loadToolState(tool);
  if (!state.last_backup_dir) {
    throw new Error("当前没有可回滚的备份");
  }

  let releaseLock = null;
  try {
    releaseLock = acquireLock(tool);
    if (tool.id === "codex") {
      restoreCodexFilesFromBackup(tool, state.last_backup_dir);
      const snapshot = readCodexSnapshot(tool);
      syncCodexRuntimeEnvironment(snapshot.base_url, snapshot.api_key);
    } else if (tool.id === "claude") {
      const bashrcBackup = path.join(state.last_backup_dir, "bashrc");
      if (!fs.existsSync(bashrcBackup)) {
        throw new Error("备份文件缺失");
      }
      atomicWriteFile(tool.bashrcPath, fs.readFileSync(bashrcBackup, "utf8"), 0o600);
    } else {
      restoreToolFilesFromBackup(tool, state.last_backup_dir);
    }
  } finally {
    if (releaseLock) {
      releaseLock();
    }
  }
}

function restoreCodexFilesFromBackup(tool, backupPath) {
  const configBackup = path.join(backupPath, "config.toml");
  const authBackup = path.join(backupPath, "auth.json");
  if (!fs.existsSync(configBackup) || !fs.existsSync(authBackup)) {
    throw new Error("Codex backup files are missing.");
  }
  atomicWriteFile(codexConfigPath(tool), fs.readFileSync(configBackup, "utf8"), 0o600);
  atomicWriteFile(codexAuthPath(tool), fs.readFileSync(authBackup, "utf8"), 0o600);
}

function restoreToolFilesFromBackup(tool, backupPath) {
  if (tool.id === "codex") {
    restoreCodexFilesFromBackup(tool, backupPath);
    return;
  }
  if (tool.id === "claude") {
    const bashrcBackup = path.join(backupPath, "bashrc");
    if (!fs.existsSync(bashrcBackup)) {
      throw new Error("Claude backup file is missing.");
    }
    atomicWriteFile(tool.bashrcPath, fs.readFileSync(bashrcBackup, "utf8"), 0o600);
    return;
  }
  if (tool.id === "pi") {
    restoreBackupFile(path.join(backupPath, "models.json"), tool.modelsPath);
    restoreBackupFile(path.join(backupPath, "settings.json"), tool.settingsPath);
    return;
  }
  if (tool.id === "grok") {
    restoreBackupFile(path.join(backupPath, "config.toml"), tool.configPath);
    return;
  }
  throw new Error("Unsupported backup tool: " + tool.id);
}

function restoreBackupFile(backupPath, targetPath) {
  if (!fs.existsSync(backupPath)) {
    throw new Error("Backup file is missing: " + backupPath);
  }
  atomicWriteFile(targetPath, fs.readFileSync(backupPath, "utf8"), 0o600);
}

function resolveUnixShellInitPath(home, env = process.env) {
  const shell = path.basename(String(env.SHELL || "")).toLowerCase();
  return path.join(home, shell === "zsh" ? ".zshrc" : ".bashrc");
}

function isWslRuntime() {
  if (process.platform !== "linux") {
    return false;
  }
  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) {
    return true;
  }
  try {
    return /microsoft/i.test(fs.readFileSync("/proc/version", "utf8"));
  } catch {
    return false;
  }
}

function backupCurrentFiles(tool, channel) {
  const backupPath = path.join(
    tool.backupDir,
    `${timestampForPath()}-${slugify(channel.name) || channel.id}`,
  );
  fs.mkdirSync(backupPath, { recursive: true, mode: 0o700 });

  if (tool.id === "codex") {
    backupOneFile(codexConfigPath(tool), path.join(backupPath, "config.toml"), "");
    backupOneFile(codexAuthPath(tool), path.join(backupPath, "auth.json"), "{}\n");
  } else if (tool.id === "claude") {
    backupOneFile(tool.bashrcPath, path.join(backupPath, "bashrc"), "");
  } else if (tool.id === "pi") {
    backupOneFile(tool.modelsPath, path.join(backupPath, "models.json"), "{}\n");
    backupOneFile(tool.settingsPath, path.join(backupPath, "settings.json"), "{}\n");
  } else if (tool.id === "grok") {
    backupOneFile(tool.configPath, path.join(backupPath, "config.toml"), "");
  }

  const manifest = {
    tool: tool.id,
    channel_id: channel.id,
    channel_name: channel.name,
    created_at: nowIso(),
  };
  atomicWriteFile(
    path.join(backupPath, "manifest.json"),
    `${JSON.stringify(manifest, null, 2)}\n`,
    0o600,
  );
  return backupPath;
}

function backupOneFile(sourcePath, targetPath, emptyContent) {
  if (fs.existsSync(sourcePath)) {
    fs.copyFileSync(sourcePath, targetPath);
    if (WINDOWS_RUNTIME) {
      WINDOWS_RUNTIME.chmod(targetPath, 0o600);
    } else {
      fs.chmodSync(targetPath, 0o600);
    }
  } else {
    fs.writeFileSync(targetPath, emptyContent, { mode: 0o600 });
  }
}

function rewriteCodexConfig(tool, channel) {
  const configPath = codexConfigPath(tool);
  let text = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";

  text = removeSectionBlocks(text, "model_providers.codex.auth");
  text = setTopLevelKey(text, "model_provider", tomlString("codex"));
  text = setTopLevelKey(text, "web_search", tomlString("live"));
  text = setTopLevelKey(text, "cli_auth_credentials_store", tomlString("file"));
  if (channel.model) {
    text = setTopLevelKey(text, "model", tomlString(channel.model));
  } else {
    // The Desktop app may write its last official model back to config.toml
    // after OAuth login. An empty third-party channel model means "use the
    // provider default", not "keep that official-model override".
    text = removeTopLevelKey(text, "model");
  }
  text = upsertProviderSection(text, channel);
  text = upsertSectionKey(
    text,
    "sandbox_workspace_write",
    "network_access",
    "true",
  );
  atomicWriteFile(configPath, text, 0o600);
}

function rewriteCodexAuth(tool, channel) {
  const authPath = codexAuthPath(tool);
  let data = {};
  if (fs.existsSync(authPath)) {
    const text = fs.readFileSync(authPath, "utf8").trim();
    data = text ? JSON.parse(text) : {};
  }
  data.OPENAI_API_KEY = channel.api_key;
  atomicWriteFile(authPath, `${JSON.stringify(data, null, 2)}\n`, 0o600);
}

function clearCodexApiKey(tool) {
  const authPath = codexAuthPath(tool);
  let data = {};
  if (fs.existsSync(authPath)) {
    const text = fs.readFileSync(authPath, "utf8").trim();
    data = text ? JSON.parse(text) : {};
  }
  delete data.OPENAI_API_KEY;
  if (data.auth_mode === "apikey") {
    delete data.auth_mode;
  }
  atomicWriteFile(authPath, `${JSON.stringify(data, null, 2)}\n`, 0o600);
}

function syncCodexRuntimeEnvironment(baseUrlValue, apiKeyValue) {
  const baseUrl = normalizeBaseUrl(baseUrlValue || "");
  const apiKey = String(apiKeyValue || "");

  if (process.env.CCM_SKIP_USER_ENV_SYNC !== "1") {
    if (WINDOWS_RUNTIME) {
      WINDOWS_RUNTIME.syncCodexBaseUrl(baseUrl);
      WINDOWS_RUNTIME.syncCodexApiKey(apiKey);
    } else if (process.env.CCM_WSL_SYNC_WINDOWS_ENV === "1") {
      syncWindowsCodexBaseUrl(baseUrl);
      syncWindowsCodexApiKey(apiKey);
    }
    if (!WINDOWS_RUNTIME) {
      syncCodexShellEnvironment(baseUrl, apiKey);
    }
  }
  if (baseUrl) {
    process.env.OPENAI_BASE_URL = baseUrl;
  } else {
    delete process.env.OPENAI_BASE_URL;
  }
  if (apiKey) {
    process.env.OPENAI_API_KEY = apiKey;
  } else {
    delete process.env.OPENAI_API_KEY;
  }
}

function syncCodexShellEnvironment(baseUrl, apiKey) {
  if (!CODEX_SHELL_INIT) {
    return;
  }
  const current = fs.existsSync(CODEX_SHELL_INIT)
    ? fs.readFileSync(CODEX_SHELL_INIT, "utf8")
    : "";
  const lines = [
    baseUrl
      ? `export OPENAI_BASE_URL=${shellDoubleQuote(baseUrl)}`
      : "unset OPENAI_BASE_URL",
    apiKey
      ? `export OPENAI_API_KEY=${shellDoubleQuote(apiKey)}`
      : "unset OPENAI_API_KEY",
  ];
  atomicWriteFile(
    CODEX_SHELL_INIT,
    replaceManagedShellBlock(
      current,
      "# >>> CCM Codex channel >>>",
      "# <<< CCM Codex channel <<<",
      lines,
    ),
    0o600,
  );
}

function replaceManagedShellBlock(text, begin, end, lines) {
  const block = `${begin}\n${lines.join("\n")}\n${end}`;
  const expression = new RegExp(
    `${escapeRegex(begin)}[\\s\\S]*?${escapeRegex(end)}`,
    "m",
  );
  if (expression.test(text)) {
    return `${text.replace(expression, block).replace(/\s*$/, "")}\n`;
  }
  const prefix = text.replace(/\s*$/, "");
  return `${prefix}${prefix ? "\n\n" : ""}${block}\n`;
}

function rewriteClaudeBashrc(tool, channel) {
  if (WINDOWS_RUNTIME) {
    updateClaudeApiChannel(tool.bashrcPath, channel);
    return;
  }
  let text = fs.existsSync(tool.bashrcPath) ? fs.readFileSync(tool.bashrcPath, "utf8") : "";
  const authEnvKey = normalizeClaudeAuthEnvKey(channel.auth_env_key);
  const otherAuthEnvKey =
    authEnvKey === "ANTHROPIC_AUTH_TOKEN" ? "ANTHROPIC_API_KEY" : "ANTHROPIC_AUTH_TOKEN";
  text = upsertShellExport(text, "ANTHROPIC_BASE_URL", normalizeBaseUrl(channel.base_url));
  text = upsertShellExport(text, authEnvKey, channel.api_key);
  text = upsertShellUnset(text, otherAuthEnvKey);
  atomicWriteFile(tool.bashrcPath, text, 0o600);
}

function writeClaudeActivation(channel) {
  const authEnvKey = normalizeClaudeAuthEnvKey(channel.auth_env_key);
  const otherAuthEnvKey =
    authEnvKey === "ANTHROPIC_AUTH_TOKEN" ? "ANTHROPIC_API_KEY" : "ANTHROPIC_AUTH_TOKEN";
  const lines = [
    "# Generated by ccm. Source this file to activate the selected Claude channel.",
    `export ANTHROPIC_BASE_URL=${shellDoubleQuote(normalizeBaseUrl(channel.base_url))}`,
    `export ${authEnvKey}=${shellDoubleQuote(channel.api_key)}`,
    `unset ${otherAuthEnvKey}`,
  ];
  if (channel.model) {
    lines.push(`export ANTHROPIC_MODEL=${shellDoubleQuote(channel.model)}`);
  }
  lines.push("");
  atomicWriteFile(ACTIVATION_PATH, `${lines.join("\n")}`, 0o600);
}

function applyClaudeChannelEnvToProcess(channel) {
  const authEnvKey = normalizeClaudeAuthEnvKey(channel.auth_env_key);
  const otherAuthEnvKey =
    authEnvKey === "ANTHROPIC_AUTH_TOKEN" ? "ANTHROPIC_API_KEY" : "ANTHROPIC_AUTH_TOKEN";
  process.env.ANTHROPIC_BASE_URL = normalizeBaseUrl(channel.base_url);
  process.env[authEnvKey] = channel.api_key;
  delete process.env[otherAuthEnvKey];
  if (channel.model) {
    process.env.ANTHROPIC_MODEL = channel.model;
  }
}

function upsertProviderSection(text, channel) {
  const header = "model_providers.codex";
  const range = findSectionRange(text, header);
  const blockLines = [
    `[${header}]`,
    `name = ${tomlString("codex")}`,
    `base_url = ${tomlString(normalizeBaseUrl(channel.base_url))}`,
    `env_key = ${tomlString("OPENAI_API_KEY")}`,
    `wire_api = ${tomlString(channel.wire_api || "responses")}`,
    "supports_standalone_web_search = true",
  ];
  const block = `${blockLines.join("\n")}\n`;

  if (!range) {
    const prefix = text.trimEnd();
    return `${prefix}${prefix ? "\n\n" : ""}${block}`;
  }

  const body = text.slice(range.bodyStart, range.end);
  let nextBody = body
    .split(/\r?\n/)
    .filter((line) => !/^\s*(requires_openai_auth|env_key|experimental_bearer_token)\s*=/.test(line))
    .join("\n");
  nextBody = setSectionKey(nextBody, "name", tomlString("codex"));
  nextBody = setSectionKey(
    nextBody,
    "base_url",
    tomlString(normalizeBaseUrl(channel.base_url)),
  );
  nextBody = setSectionKey(nextBody, "env_key", tomlString("OPENAI_API_KEY"));
  nextBody = setSectionKey(
    nextBody,
    "wire_api",
    tomlString(channel.wire_api || "responses"),
  );
  nextBody = setSectionKey(nextBody, "supports_standalone_web_search", "true");
  nextBody = ensureLeadingNewline(nextBody).replace(/\s*$/, "\n");

  return `${text.slice(0, range.bodyStart)}${nextBody}${text.slice(range.end)}`;
}

function readPiConfigObject(filePath, label) {
  const text = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
  return parsePiJsonObject(text, label);
}

function writePiConfigObject(filePath, value) {
  atomicWriteFile(filePath, JSON.stringify(value, null, 2) + "\n", 0o600);
}

function rewritePiConfig(tool, channel, state) {
  const models = readPiConfigObject(tool.modelsPath, "Pi models.json");
  const settings = readPiConfigObject(tool.settingsPath, "Pi settings.json");
  if (
    !state.pi_restore_defaults &&
    !String(settings.defaultProvider || "").startsWith("ccm-")
  ) {
    state.pi_restore_defaults = capturePiDefaults(settings);
  }
  const next = applyPiChannel(models, settings, channel);
  writePiConfigObject(tool.modelsPath, next.models);
  writePiConfigObject(tool.settingsPath, next.settings);
}

function restorePiOfficialConfig(tool, state) {
  const settings = readPiConfigObject(tool.settingsPath, "Pi settings.json");
  const next = clearPiManagedSelection(settings, state.pi_restore_defaults);
  writePiConfigObject(tool.settingsPath, next);
  delete state.pi_restore_defaults;
}

function rewriteGrokConfig(tool, channel, state) {
  const text = fs.existsSync(tool.configPath) ? fs.readFileSync(tool.configPath, "utf8") : "";
  const next = applyGrokChannel(text, channel);
  atomicWriteFile(tool.configPath, next.text, 0o600);
}

function restoreGrokOfficialConfig(tool, state) {
  const text = fs.existsSync(tool.configPath) ? fs.readFileSync(tool.configPath, "utf8") : "";
  const next = activateGrokOfficial(text);
  atomicWriteFile(tool.configPath, next, 0o600);
}

function readCurrentSnapshot(tool) {
  if (tool.id === "codex") {
    return readCodexSnapshot(tool);
  }
  if (tool.id === "claude") {
    return readClaudeSnapshot(tool);
  }
  if (tool.id === "pi") {
    return readPiSnapshotForTool(tool);
  }
  if (tool.id === "grok") {
    return readGrokSnapshotForTool(tool);
  }
  return {};
}

function readCodexSnapshot(tool) {
  const configPath = codexConfigPath(tool);
  const authPath = codexAuthPath(tool);
  const configText = fs.existsSync(configPath)
    ? fs.readFileSync(configPath, "utf8")
    : "";
  const authText = fs.existsSync(authPath) ? fs.readFileSync(authPath, "utf8") : "";
  const providerId = readTopLevelString(configText, "model_provider") || "codex";
  const model = readTopLevelString(configText, "model") || "";
  const baseUrl = readSectionString(configText, `model_providers.${providerId}`, "base_url");

  let apiKey = "";
  if (authText.trim()) {
    try {
      apiKey = JSON.parse(authText).OPENAI_API_KEY || "";
    } catch {
      apiKey = "";
    }
  }

  return {
    provider_id: providerId,
    model,
    base_url: normalizeBaseUrl(baseUrl || ""),
    api_key: apiKey,
  };
}

function readClaudeSnapshot(tool) {
  if (WINDOWS_RUNTIME) {
    const env = readClaudeSettings(tool.bashrcPath).env || {};
    const authToken = env.ANTHROPIC_AUTH_TOKEN || "";
    const apiKey = env.ANTHROPIC_API_KEY || "";
    return {
      provider_id: "claude",
      model: env.ANTHROPIC_MODEL || "",
      base_url: normalizeBaseUrl(env.ANTHROPIC_BASE_URL || ""),
      api_key: authToken || apiKey || "",
      auth_env_key: authToken ? "ANTHROPIC_AUTH_TOKEN" : apiKey ? "ANTHROPIC_API_KEY" : "ANTHROPIC_AUTH_TOKEN",
    };
  }
  const text = fs.existsSync(tool.bashrcPath) ? fs.readFileSync(tool.bashrcPath, "utf8") : "";
  const env = readShellEnv(text, [
    "ANTHROPIC_BASE_URL",
    "ANTHROPIC_AUTH_TOKEN",
    "ANTHROPIC_API_KEY",
    "ANTHROPIC_MODEL",
  ]);
  const baseUrl = env.ANTHROPIC_BASE_URL || "";
  const authToken = env.ANTHROPIC_AUTH_TOKEN || "";
  const apiKey = env.ANTHROPIC_API_KEY || "";
  const model = env.ANTHROPIC_MODEL || "";
  const authEnvKey = authToken ? "ANTHROPIC_AUTH_TOKEN" : apiKey ? "ANTHROPIC_API_KEY" : "";
  return {
    provider_id: "claude",
    model,
    base_url: normalizeBaseUrl(baseUrl || ""),
    api_key: authToken || apiKey || "",
    auth_env_key: authEnvKey || "ANTHROPIC_AUTH_TOKEN",
  };
}

function readPiSnapshotForTool(tool) {
  const models = readPiConfigObject(tool.modelsPath, "Pi models.json");
  const settings = readPiConfigObject(tool.settingsPath, "Pi settings.json");
  return readPiSnapshot(models, settings);
}

function readGrokSnapshotForTool(tool) {
  const text = fs.existsSync(tool.configPath) ? fs.readFileSync(tool.configPath, "utf8") : "";
  return readGrokSnapshot(text);
}

function resolveCurrentChannel(tool, channels) {
  const state = loadToolState(tool);
  const selected = channels.find((channel) => channel.id === state.current_channel_id);
  if (selected && selected.kind === "official") {
    return selected;
  }
  const snapshot = readCurrentSnapshot(tool);
  return (
    channels.find((channel) => {
      const sameBase =
        normalizeBaseUrl(channel.base_url) === normalizeBaseUrl(snapshot.base_url);
      const sameKey = (channel.api_key || "") === (snapshot.api_key || "");
      return sameBase && sameKey;
    }) || null
  );
}

function bootstrapRegistryIfNeeded(tool) {
  if (fs.existsSync(tool.registryPath)) {
    const registry = loadRegistry(tool);
    if (registry.length) {
      const withOfficial = withOfficialChannel(registry, tool.id);
      if (withOfficial.length !== registry.length) {
        saveRegistry(tool, withOfficial);
      }
      return;
    }
  }

  const snapshot = readCurrentSnapshot(tool);
  if (!snapshot.base_url && !snapshot.api_key) {
    const registry = withOfficialChannel([], tool.id);
    saveRegistry(tool, registry);
    saveToolState(tool, {
      current_channel_id: registry[0].id,
      last_backup_dir: "",
      last_switched_at: "",
    });
    return;
  }

  const suggestedName = guessChannelName(snapshot.base_url) || "default";
  const now = nowIso();
  const channel = {
    id: uniqueId([], slugify(suggestedName) || "default"),
    name: suggestedName,
    base_url: snapshot.base_url,
    api_key: snapshot.api_key,
    model: snapshot.model || "",
    remark:
      tool.id === "codex"
        ? "从当前 Codex config/auth 自动导入"
        : "从当前 ~/.bashrc 自动导入",
    created_at: now,
    updated_at: now,
    last_used_at: "",
  };

  if (tool.id === "codex") {
    channel.wire_api = "responses";
  } else if (tool.id === "claude") {
    channel.auth_env_key = normalizeClaudeAuthEnvKey(snapshot.auth_env_key);
  } else if (tool.id === "pi") {
    channel.wire_api = normalizePiApi(snapshot.wire_api);
  } else if (tool.id === "grok") {
    channel.wire_api = normalizeGrokApiBackend(snapshot.wire_api);
  }

  const registry = withOfficialChannel([channel], tool.id);
  saveRegistry(tool, registry);
  saveToolState(tool, {
    current_channel_id: channel.id,
    last_backup_dir: "",
    last_switched_at: "",
  });
}

function loadRegistry(tool) {
  if (!fs.existsSync(tool.registryPath)) {
    return [];
  }
  const text = fs.readFileSync(tool.registryPath, "utf8").trim();
  if (!text) {
    return [];
  }
  const parsed = JSON.parse(text);
  return Array.isArray(parsed) ? parsed : [];
}

function saveRegistry(tool, registry) {
  atomicWriteFile(tool.registryPath, `${JSON.stringify(registry, null, 2)}\n`, 0o600);
}

function loadToolState(tool) {
  const empty = {
    current_channel_id: "",
    last_backup_dir: "",
    last_switched_at: "",
  };
  if (!fs.existsSync(tool.statePath)) {
    return { ...empty };
  }
  const text = fs.readFileSync(tool.statePath, "utf8").trim();
  if (!text) {
    return { ...empty };
  }
  return { ...empty, ...JSON.parse(text) };
}

function saveToolState(tool, state) {
  atomicWriteFile(tool.statePath, `${JSON.stringify(state, null, 2)}\n`, 0o600);
}

function ensureToolStateDirs(tool) {
  fs.mkdirSync(STATE_HOME, { recursive: true, mode: 0o700 });
  fs.mkdirSync(tool.backupDir, { recursive: true, mode: 0o700 });
  for (const dir of [
    SESSION_ARCHIVE_DIR,
    SESSION_TRASH_DIR,
    SKILL_BACKUP_DIR,
    SKILL_DISABLED_DIR,
    SKILL_TRASH_DIR,
  ]) {
    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
  }
  if (WINDOWS_RUNTIME) {
    WINDOWS_RUNTIME.applyPrivateAcl(STATE_HOME);
  }
}

function atomicWriteFile(targetPath, content, mode) {
  const dir = path.dirname(targetPath);
  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
  const tempPath = path.join(
    dir,
    `.${path.basename(targetPath)}.tmp-${process.pid}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`,
  );
  fs.writeFileSync(tempPath, content, { mode });
  try {
    fs.renameSync(tempPath, targetPath);
  } catch (error) {
    if (!WINDOWS_RUNTIME || !["EEXIST", "EPERM"].includes(error.code)) {
      throw error;
    }
    fs.rmSync(targetPath, { force: true });
    fs.renameSync(tempPath, targetPath);
  }
  if (WINDOWS_RUNTIME) {
    WINDOWS_RUNTIME.chmod(targetPath, mode);
  } else {
    fs.chmodSync(targetPath, mode);
  }
}

function acquireLock(tool) {
  try {
    const fd = fs.openSync(tool.lockPath, "wx", 0o600);
    fs.writeFileSync(fd, String(process.pid));
    return () => {
      try {
        fs.closeSync(fd);
      } catch {}
      try {
        fs.unlinkSync(tool.lockPath);
      } catch {}
    };
  } catch (error) {
    if (error.code !== "EEXIST") {
      throw error;
    }

    try {
      const existing = fs.readFileSync(tool.lockPath, "utf8").trim();
      if (existing && isPidAlive(Number(existing))) {
        throw new Error(`另一个 ccm 进程正在持有锁 (pid ${existing})`);
      }
      fs.unlinkSync(tool.lockPath);
      return acquireLock(tool);
    } catch (nested) {
      if (nested.code === "ENOENT") {
        return acquireLock(tool);
      }
      throw nested;
    }
  }
}

function isPidAlive(pid) {
  if (!Number.isFinite(pid) || pid <= 0) {
    return false;
  }
  try {
    process.kill(pid, 0);
    return true;
  } catch {
    return false;
  }
}

function detectRunningToolPids(tool) {
  if (WINDOWS_RUNTIME) {
    return WINDOWS_RUNTIME.detectToolPids(tool.id);
  }
  try {
    const output = execFileSync("ps", ["-eo", "pid=,args="], {
      encoding: "utf8",
      stdio: ["ignore", "pipe", "ignore"],
    });
    const executable = {
      codex: "codex",
      claude: "claude",
      pi: "pi",
      grok: "grok",
    }[tool.id] || tool.id;
    const commandPattern = new RegExp(
      "(^|[\\\\s/])" + escapeRegex(executable) + "(\\\\s|$)",
    );
    return output
      .split(/\r?\n/)
      .map((line) => line.trim())
      .filter(Boolean)
      .map((line) => {
        const match = line.match(/^(\d+)\s+(.*)$/);
        return match ? { pid: Number(match[1]), args: match[2] } : null;
      })
      .filter(Boolean)
      .filter((row) => row.pid !== process.pid)
      .filter((row) => commandPattern.test(row.args))
      .filter((row) => !/(^|[\s/])ccm(\s|$)/.test(row.args))
      .map((row) => row.pid);
  } catch {
    return [];
  }
}

function launchTool(tool, channel, mode) {
  let args = [];
  let env = { ...process.env };

  if (tool.id === "codex") {
    if (channel.kind === "official") {
      ensureCodexOfficialLogin({
        officialHome: OFFICIAL_CODEX_HOME,
        command: tool.command,
        env: process.env,
        spawnSyncImpl: spawnToolCommand,
      });
      env = buildOfficialEnv(OFFICIAL_CODEX_HOME, process.env);
    } else {
      env.CODEX_HOME = tool.home;
      env.OPENAI_BASE_URL = normalizeBaseUrl(channel.base_url);
      env.OPENAI_API_KEY = channel.api_key;
    }
    args = mode === "resume" ? ["resume", "--last"] : [];
  } else if (tool.id === "claude") {
    if (channel.kind === "official") {
      env = buildOfficialClaudeEnv(process.env);
      args = mode === "resume" ? ["--continue"] : [];
    } else {
      const authEnvKey = normalizeClaudeAuthEnvKey(channel.auth_env_key);
      env.ANTHROPIC_BASE_URL = normalizeBaseUrl(channel.base_url);
      env[authEnvKey] = channel.api_key;
      if (authEnvKey === "ANTHROPIC_AUTH_TOKEN") {
        delete env.ANTHROPIC_API_KEY;
      } else {
        delete env.ANTHROPIC_AUTH_TOKEN;
      }
      if (channel.model) {
        args.push("--model", channel.model);
      }
      if (mode === "resume") {
        args.push("--continue");
      }
    }
  } else if (tool.id === "pi") {
    args = [];
  } else if (tool.id === "grok") {
    args = mode === "resume" ? ["--continue"] : [];
  }

  const result = spawnToolCommand(tool.command, args, {
    stdio: "inherit",
    env,
  });
  if (result.error) {
    console.error(`启动 ${tool.id} 失败: ${result.error.message}`);
  }
  process.exit(result.status || 0);
}

function shouldStartOfficialLogin(channel, mode) {
  return Boolean(channel && channel.kind === "official" && mode === "switch");
}

function createWebUiServer() {
  return http.createServer(async (req, res) => {
    try {
      const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
      if (req.method === "GET" && url.pathname === "/") {
        sendText(res, 200, renderWebUiHtml(), "text/html; charset=utf-8");
        return;
      }
      if (req.method === "GET" && url.pathname === "/api/state") {
        sendJson(res, 200, buildUiState());
        return;
      }
      if (req.method === "POST" && url.pathname === "/api/channel") {
        const body = await readJsonBody(req);
        sendJson(res, 200, saveChannelFromUi(body));
        return;
      }
      if (req.method === "POST" && url.pathname === "/api/use") {
        const body = await readJsonBody(req);
        const tool = getTool(body.tool);
        const channel = findChannel(loadRegistry(tool), body.id);
        if (!channel) {
          throw new Error("渠道不存在");
        }
        switchToChannelSync(tool, channel);
        sendJson(res, 200, {
          ok: true,
          message:
            tool.id === "claude"
              ? "已写入 ~/.bashrc 和 ccm 激活脚本；从 shell wrapper 返回后会自动加载。"
              : "已切换。",
        });
        return;
      }
      if (req.method === "POST" && url.pathname === "/api/delete") {
        const body = await readJsonBody(req);
        const tool = getTool(body.tool);
        deleteChannelById(tool, String(body.id || ""));
        sendJson(res, 200, { ok: true });
        return;
      }
      if (req.method === "POST" && url.pathname === "/api/rollback") {
        const body = await readJsonBody(req);
        const tool = getTool(body.tool);
        rollbackBackupSync(tool);
        sendJson(res, 200, { ok: true });
        return;
      }
      if (req.method === "POST" && url.pathname === "/api/login-official") {
        const body = await readJsonBody(req);
        switchToOfficialAndLogin(body.tool);
        sendJson(res, 200, { ok: true, message: `${body.tool} official login completed` });
        return;
      }
      sendJson(res, 404, { ok: false, error: "Not found" });
    } catch (error) {
      sendJson(res, 400, { ok: false, error: error.message });
    }
  });
}

function runWebUi(args) {
  const server = createWebUiServer();

  server.on("error", async (error) => {
    if (error.code === "EADDRINUSE") {
      const address = `http://${args.host}:${args.port}`;
      const isCcmUi = await probeExistingUi(args.host, args.port);
      if (isCcmUi) {
        console.log(`ccm Web UI 已在运行: ${address}`);
        console.log("如需重新启动，请先结束旧进程，或使用 --port 指定其他端口。");
        process.exitCode = 0;
        return;
      }
      console.error(`ccm 错误: 端口已被其他程序占用: ${address}`);
      console.error(`请换一个端口，例如: ccm --ui --port ${args.port + 1}`);
      process.exitCode = 1;
      return;
    }

    if (error.code === "EPERM") {
      console.error(
        `ccm 错误: 当前环境不允许监听 ${args.host}:${args.port}。请在普通 WSL 终端中运行 ccm --ui，或使用 ccm 打开终端 UI。`,
      );
      process.exitCode = 1;
      return;
    }

    console.error(`ccm 错误: Web UI 启动失败: ${error.message}`);
    process.exitCode = 1;
  });

  server.listen(args.port, args.host, () => {
    const address = `http://${args.host}:${args.port}`;
    console.log(`ccm Web UI: ${address}`);
    console.log("按 Ctrl+C 停止。");
  });
}

function probeExistingUi(host, port) {
  return new Promise((resolve) => {
    const req = http.get(
      {
        host,
        port,
        path: "/api/state",
        timeout: 800,
      },
      (res) => {
        let body = "";
        res.setEncoding("utf8");
        res.on("data", (chunk) => {
          body += chunk;
          if (body.length > 64 * 1024) {
            req.destroy();
            resolve(false);
          }
        });
        res.on("end", () => {
          try {
            const data = JSON.parse(body);
            resolve(Boolean(data && data.codex && data.claude));
          } catch {
            resolve(false);
          }
        });
      },
    );
    req.on("timeout", () => {
      req.destroy();
      resolve(false);
    });
    req.on("error", () => resolve(false));
  });
}

function buildUiState() {
  const result = {};
  for (const tool of Object.values(TOOLS)) {
    const channels = loadRegistry(tool);
    const current = resolveCurrentChannel(tool, channels);
    const snapshot = readCurrentSnapshot(tool);
    const state = loadToolState(tool);
    result[tool.id] = {
      id: tool.id,
      label: tool.label,
      target: toolTargetPath(tool),
      current_channel_id: current ? current.id : "",
      current_name: current ? current.name : "未收录",
      snapshot: {
        base_url: snapshot.base_url || "",
        api_key_masked: maskKey(snapshot.api_key || ""),
        model: snapshot.model || "",
        auth_env_key: snapshot.auth_env_key || "",
      },
      state,
      channels: channels.map((channel) => ({
        id: channel.id,
        name: channel.name,
        kind: channel.kind || "api",
        base_url: channel.base_url,
        api_key_masked: maskKey(channel.api_key),
        model: channel.model || "",
        remark: channel.remark || "",
        wire_api: channel.wire_api || "responses",
        auth_env_key: channel.auth_env_key || "ANTHROPIC_AUTH_TOKEN",
        updated_at: channel.updated_at || "",
        last_used_at: channel.last_used_at || "",
      })),
    };
  }
  return result;
}

function saveChannelFromUi(body) {
  const tool = getTool(body.tool);
  const channels = loadRegistry(tool);
  const id = String(body.id || "");
  const existing = id ? channels.find((item) => item.id === id) : null;
  const now = nowIso();
  const name = String(body.name || "").trim();
  const baseUrl = normalizeBaseUrl(body.base_url || "");
  const apiKey = String(body.api_key || "");

  if (!name) {
    throw new Error("名称不能为空");
  }
  if (!baseUrl) {
    throw new Error("地址不能为空");
  }
  validateHttpUrl(baseUrl);
  if (!existing && !apiKey) {
    throw new Error("新增渠道时密钥不能为空");
  }
  if (["pi", "grok"].includes(tool.id) && !String(body.model || "").trim()) {
    throw new Error(tool.label + " third-party channels require a model ID.");
  }

  const channel =
    existing ||
    {
      id: uniqueId(channels, slugify(name) || `channel-${Date.now()}`),
      created_at: now,
      last_used_at: "",
    };

  channel.name = name;
  channel.base_url = baseUrl;
  if (apiKey) {
    channel.api_key = apiKey;
  }
  channel.model = String(body.model || "").trim();
  channel.remark = String(body.remark || "").trim();
  channel.updated_at = now;
  if (tool.id === "codex") {
    channel.wire_api = normalizeChannelWireApi(tool.id, body.wire_api || channel.wire_api);
  } else if (tool.id === "claude") {
    channel.auth_env_key = normalizeClaudeAuthEnvKey(body.auth_env_key);
  } else {
    channel.wire_api = normalizeChannelWireApi(tool.id, body.wire_api || channel.wire_api);
  }

  if (!existing) {
    channels.push(channel);
  }
  saveRegistry(tool, channels);
  return { ok: true, id: channel.id };
}

function sendJson(res, statusCode, payload) {
  sendText(res, statusCode, `${JSON.stringify(payload)}\n`, "application/json; charset=utf-8");
}

function sendText(res, statusCode, text, contentType) {
  res.writeHead(statusCode, {
    "Content-Type": contentType,
    "Cache-Control": "no-store",
  });
  res.end(text);
}

module.exports = {
  TOOLS,
  archiveSession,
  buildTerminalUiFrame,
  buildUiState,
  createWebUiServer,
  createCodexSkill,
  listClaudePlugins,
  listCodexSkills,
  listSessions,
  rollbackBackupSync,
  runClaudePluginCommand,
  resolveUnixShellInitPath,
  saveChannelFromUi,
  shouldStartOfficialLogin,
  toggleCodexSkill,
  trashCodexSkill,
  trashSession,
  updateSessionMetadata,
};

function readJsonBody(req) {
  return new Promise((resolve, reject) => {
    let raw = "";
    req.on("data", (chunk) => {
      raw += chunk;
      if (raw.length > 1024 * 1024) {
        reject(new Error("请求体过大"));
        req.destroy();
      }
    });
    req.on("end", () => {
      try {
        resolve(raw ? JSON.parse(raw) : {});
      } catch {
        reject(new Error("JSON 格式无效"));
      }
    });
    req.on("error", reject);
  });
}

function renderWebUiHtml() {
  return `<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>ccm Channel Manager</title>
  <style>
    :root {
      color-scheme: light;
      --bg: #f7f8fb;
      --panel: #ffffff;
      --text: #18212f;
      --muted: #667085;
      --line: #d8dee8;
      --accent: #0f766e;
      --accent-2: #2563eb;
      --danger: #b42318;
      --shadow: 0 10px 30px rgba(24, 33, 47, .08);
    }
    * { box-sizing: border-box; }
    body {
      margin: 0;
      background: var(--bg);
      color: var(--text);
      font: 14px/1.45 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
    }
    button, input, select, textarea { font: inherit; }
    button {
      border: 1px solid var(--line);
      background: #fff;
      color: var(--text);
      border-radius: 6px;
      padding: 7px 10px;
      cursor: pointer;
    }
    button.primary {
      background: var(--accent);
      border-color: var(--accent);
      color: #fff;
    }
    button.blue {
      background: var(--accent-2);
      border-color: var(--accent-2);
      color: #fff;
    }
    button.danger { color: var(--danger); }
    button:disabled { opacity: .55; cursor: default; }
    .app {
      min-height: 100vh;
      display: grid;
      grid-template-rows: auto 1fr;
    }
    header {
      display: flex;
      align-items: center;
      gap: 18px;
      padding: 14px 22px;
      border-bottom: 1px solid var(--line);
      background: #fff;
    }
    h1 {
      margin: 0;
      font-size: 18px;
      font-weight: 650;
      letter-spacing: 0;
    }
    .tabs {
      display: inline-flex;
      gap: 4px;
      padding: 3px;
      border: 1px solid var(--line);
      border-radius: 8px;
      background: #f2f4f7;
    }
    .tab {
      border: 0;
      background: transparent;
      min-width: 86px;
    }
    .tab.active {
      background: #fff;
      box-shadow: 0 1px 3px rgba(24, 33, 47, .12);
    }
    main {
      display: grid;
      grid-template-columns: minmax(0, 1fr) 360px;
      gap: 18px;
      padding: 18px;
    }
    .panel {
      background: var(--panel);
      border: 1px solid var(--line);
      border-radius: 8px;
      box-shadow: var(--shadow);
      min-width: 0;
    }
    .summary {
      display: grid;
      grid-template-columns: repeat(3, minmax(0, 1fr));
      gap: 1px;
      overflow: hidden;
    }
    .metric {
      padding: 14px;
      background: #fff;
      min-width: 0;
    }
    .label {
      color: var(--muted);
      font-size: 12px;
      margin-bottom: 5px;
    }
    .value {
      font-weight: 650;
      overflow-wrap: anywhere;
    }
    .table-wrap {
      margin-top: 18px;
      overflow: auto;
    }
    table {
      width: 100%;
      min-width: 760px;
      border-collapse: collapse;
    }
    th, td {
      padding: 11px 12px;
      border-bottom: 1px solid var(--line);
      text-align: left;
      vertical-align: middle;
      white-space: nowrap;
    }
    th {
      color: var(--muted);
      font-size: 12px;
      font-weight: 600;
      background: #f9fafb;
    }
    td.url {
      max-width: 310px;
      overflow: hidden;
      text-overflow: ellipsis;
    }
    .current-pill {
      display: inline-flex;
      align-items: center;
      height: 22px;
      padding: 0 8px;
      border-radius: 999px;
      background: #d1fae5;
      color: #065f46;
      font-size: 12px;
      font-weight: 650;
    }
    .official-pill {
      display: inline-flex;
      align-items: center;
      height: 22px;
      padding: 0 8px;
      border-radius: 999px;
      background: #e0e7ff;
      color: #3730a3;
      font-size: 12px;
      font-weight: 650;
    }
    .actions {
      display: flex;
      gap: 7px;
      justify-content: flex-end;
    }
    aside {
      padding: 16px;
      align-self: start;
    }
    h2 {
      margin: 0 0 14px;
      font-size: 16px;
    }
    form {
      display: grid;
      gap: 12px;
    }
    .field {
      display: grid;
      gap: 6px;
    }
    .field span {
      color: var(--muted);
      font-size: 12px;
    }
    input, select, textarea {
      width: 100%;
      border: 1px solid var(--line);
      border-radius: 6px;
      background: #fff;
      color: var(--text);
      padding: 8px 9px;
      min-width: 0;
    }
    textarea { min-height: 72px; resize: vertical; }
    .form-actions {
      display: flex;
      gap: 8px;
      justify-content: flex-end;
      margin-top: 4px;
    }
    .toast {
      position: fixed;
      left: 50%;
      bottom: 18px;
      transform: translateX(-50%);
      min-width: 260px;
      max-width: min(560px, calc(100vw - 28px));
      padding: 10px 12px;
      border-radius: 8px;
      background: #18212f;
      color: #fff;
      box-shadow: var(--shadow);
      display: none;
    }
    .toast.show { display: block; }
    @media (max-width: 900px) {
      header { align-items: flex-start; flex-direction: column; gap: 10px; }
      main { grid-template-columns: 1fr; }
      .summary { grid-template-columns: 1fr; }
      aside { order: -1; }
    }
  </style>
</head>
<body>
  <div class="app">
    <header>
      <h1>ccm Channel Manager</h1>
      <div class="tabs" id="tabs"></div>
      <button id="refresh" type="button">刷新</button>
    </header>
    <main>
      <section>
        <div class="panel summary" id="summary"></div>
        <div class="panel table-wrap">
          <table>
            <thead>
              <tr>
                <th>状态</th>
                <th>名称</th>
                <th>地址</th>
                <th>密钥</th>
                <th>模型</th>
                <th>备注</th>
                <th></th>
              </tr>
            </thead>
            <tbody id="rows"></tbody>
          </table>
        </div>
      </section>
      <aside class="panel">
        <h2 id="formTitle">新增渠道</h2>
        <form id="form">
          <input type="hidden" id="channelId">
          <label class="field">
            <span>名称</span>
            <input id="name" autocomplete="off" required>
          </label>
          <label class="field">
            <span>Base URL</span>
            <input id="baseUrl" inputmode="url" required>
          </label>
          <label class="field">
            <span>密钥</span>
            <input id="apiKey" autocomplete="off" type="password">
          </label>
          <label class="field">
            <span>模型</span>
            <input id="model" autocomplete="off">
          </label>
          <label class="field protocol-only">
            <span>Wire API</span>
            <select id="wireApi">
              <option value="responses">responses</option>
              <option value="chat">chat</option>
            </select>
          </label>
          <label class="field claude-only" hidden>
            <span>密钥变量</span>
            <select id="authEnvKey">
              <option value="ANTHROPIC_AUTH_TOKEN">ANTHROPIC_AUTH_TOKEN</option>
              <option value="ANTHROPIC_API_KEY">ANTHROPIC_API_KEY</option>
            </select>
          </label>
          <label class="field">
            <span>备注</span>
            <textarea id="remark"></textarea>
          </label>
          <div class="form-actions">
            <button id="reset" type="button">清空</button>
            <button class="primary" type="submit">保存</button>
          </div>
        </form>
      </aside>
    </main>
  </div>
  <div class="toast" id="toast"></div>
  <script>
    let state = {};
    let activeTool = "codex";

    const qs = (selector) => document.querySelector(selector);
    const qsa = (selector) => [...document.querySelectorAll(selector)];

    function protocolOptions(toolId) {
      if (toolId === "codex") return ["responses", "chat"];
      if (toolId === "pi") {
        return ["openai-completions", "openai-responses", "anthropic-messages", "google-generative-ai"];
      }
      if (toolId === "grok") return ["responses", "chat_completions", "messages"];
      return [];
    }

    function configureForm(toolId) {
      const protocols = protocolOptions(toolId);
      qs(".protocol-only").hidden = protocols.length === 0;
      qs(".claude-only").hidden = toolId !== "claude";
      qs("#wireApi").innerHTML = protocols
        .map((value) => '<option value="' + value + '">' + value + '</option>')
        .join("");
      qs("#model").required = toolId === "pi" || toolId === "grok";
      qs("#model").placeholder = qs("#model").required ? "必填：模型 ID" : "";
    }

    function renderTabs() {
      const tools = Object.values(state);
      qs("#tabs").innerHTML = tools
        .map((tool) =>
          '<button class="tab' + (tool.id === activeTool ? ' active' : '') +
          '" data-tool="' + escapeHtml(tool.id) + '" type="button">' +
          escapeHtml(tool.label) + '</button>',
        )
        .join("");
      qsa(".tab").forEach((button) => {
        button.addEventListener("click", () => {
          activeTool = button.dataset.tool;
          resetForm();
          render();
        });
      });
    }

    qsa(".tab").forEach((button) => {
      button.addEventListener("click", () => {
        activeTool = button.dataset.tool;
        qsa(".tab").forEach((item) => item.classList.toggle("active", item === button));
        resetForm();
        render();
      });
    });

    qs("#refresh").addEventListener("click", load);
    qs("#reset").addEventListener("click", resetForm);
    qs("#form").addEventListener("submit", async (event) => {
      event.preventDefault();
      const payload = {
        tool: activeTool,
        id: qs("#channelId").value,
        name: qs("#name").value,
        base_url: qs("#baseUrl").value,
        api_key: qs("#apiKey").value,
        model: qs("#model").value,
        wire_api: qs("#wireApi").value,
        auth_env_key: qs("#authEnvKey").value,
        remark: qs("#remark").value,
      };
      await apiPost("/api/channel", payload);
      resetForm();
      await load();
      showToast("已保存");
    });

    async function load() {
      const response = await fetch("/api/state", { cache: "no-store" });
      state = await response.json();
      render();
    }

    function render() {
      if (!state[activeTool]) {
        activeTool = Object.keys(state)[0] || "";
      }
      const tool = state[activeTool];
      if (!tool) return;
      renderTabs();
      configureForm(activeTool);
      qs("#summary").innerHTML = [
        metric("当前渠道", tool.current_name || "未收录"),
        metric("当前地址", tool.snapshot.base_url || "-"),
        metric("目标文件", tool.target || "-"),
      ].join("");
      qs("#rows").innerHTML = tool.channels.map((channel) => {
        const isCurrent = channel.id === tool.current_channel_id;
        const isOfficial = channel.kind === "official";
        return '<tr>' +
          '<td>' + (isCurrent ? '<span class="current-pill">当前</span> ' : '') +
          (isOfficial ? '<span class="official-pill">Official</span>' : '') + '</td>' +
          '<td>' + escapeHtml(channel.name) + '</td>' +
          '<td class="url" title="' + escapeHtml(channel.base_url) + '">' + escapeHtml(isOfficial ? 'Official subscription' : channel.base_url) + '</td>' +
          '<td>' + escapeHtml(channel.api_key_masked) + '</td>' +
          '<td>' + escapeHtml(channel.model || '') + '</td>' +
          '<td>' + escapeHtml(channel.remark || '') + '</td>' +
          '<td><div class="actions">' +
          '<button class="blue" type="button" onclick="useChannel(\\'' + channel.id + '\\')">切换</button>' +
          (isOfficial
            ? '<button type="button" onclick="loginOfficial()">Official Login</button>'
            : '<button type="button" onclick="editChannel(\\'' + channel.id + '\\')">编辑</button>' +
              '<button class="danger" type="button" onclick="deleteChannel(\\'' + channel.id + '\\')">删除</button>') +
          '</div></td>' +
        '</tr>';
      }).join("");
    }

    function metric(label, value) {
      return '<div class="metric"><div class="label">' + escapeHtml(label) +
        '</div><div class="value">' + escapeHtml(value) + '</div></div>';
    }

    window.useChannel = async (id) => {
      const result = await apiPost("/api/use", { tool: activeTool, id });
      await load();
      showToast(result.message || "已切换");
    };

    window.loginOfficial = async () => {
      const result = await apiPost("/api/login-official", { tool: activeTool });
      await load();
      showToast(result.message || "Official login completed");
    };

    window.editChannel = (id) => {
      const channel = state[activeTool].channels.find((item) => item.id === id);
      if (!channel) return;
      qs("#formTitle").textContent = "编辑渠道";
      qs("#channelId").value = channel.id;
      qs("#name").value = channel.name;
      qs("#baseUrl").value = channel.base_url;
      qs("#apiKey").value = "";
      qs("#apiKey").placeholder = "留空则保留原密钥";
      qs("#model").value = channel.model || "";
      qs("#wireApi").value = channel.wire_api || "responses";
      qs("#authEnvKey").value = channel.auth_env_key || "ANTHROPIC_AUTH_TOKEN";
      qs("#remark").value = channel.remark || "";
    };

    window.deleteChannel = async (id) => {
      if (!confirm("确认删除该渠道？")) return;
      await apiPost("/api/delete", { tool: activeTool, id });
      resetForm();
      await load();
      showToast("已删除");
    };

    function resetForm() {
      qs("#formTitle").textContent = "新增渠道";
      qs("#form").reset();
      qs("#channelId").value = "";
      qs("#apiKey").placeholder = "";
      configureForm(activeTool);
      const protocols = protocolOptions(activeTool);
      if (protocols.length) qs("#wireApi").value = protocols[0];
      qs("#authEnvKey").value = "ANTHROPIC_AUTH_TOKEN";
    }

    async function apiPost(url, payload) {
      const response = await fetch(url, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
      });
      const data = await response.json();
      if (!response.ok || data.ok === false) {
        throw new Error(data.error || "操作失败");
      }
      return data;
    }

    function showToast(message) {
      const toast = qs("#toast");
      toast.textContent = message;
      toast.classList.add("show");
      setTimeout(() => toast.classList.remove("show"), 2400);
    }

    function escapeHtml(value) {
      return String(value ?? "").replace(/[&<>"']/g, (char) => ({
        "&": "&amp;",
        "<": "&lt;",
        ">": "&gt;",
        '"': "&quot;",
        "'": "&#39;",
      }[char]));
    }

    load().catch((error) => showToast(error.message));
  </script>
</body>
</html>`;
}

function toolTargetPath(tool) {
  if (tool.id === "codex") {
    return tool.home;
  }
  if (tool.id === "claude") {
    return tool.bashrcPath;
  }
  if (tool.id === "pi") {
    return tool.modelsPath + " + " + tool.settingsPath;
  }
  if (tool.id === "grok") {
    return tool.configPath;
  }
  return tool.home || "";
}

function getTool(id) {
  const tool = TOOLS[String(id || "").toLowerCase()];
  if (!tool) {
    throw new Error(`未知工具: ${id}`);
  }
  return tool;
}

function findChannel(channels, value) {
  return channels.find((item) => item.id === value || item.name === value) || null;
}

function codexConfigPath(tool) {
  return path.join(tool.home, "config.toml");
}

function codexAuthPath(tool) {
  return path.join(tool.home, "auth.json");
}

function readTopLevelString(text, key) {
  const match = text.match(new RegExp(`^${escapeRegex(key)}\\s*=\\s*\"([^\"]*)\"\\s*$`, "m"));
  return match ? match[1] : "";
}

function readSectionString(text, header, key) {
  const range = findSectionRange(text, header);
  if (!range) {
    return "";
  }
  const body = text.slice(range.bodyStart, range.end);
  const match = body.match(new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*\"([^\"]*)\"\\s*$`, "m"));
  return match ? match[1] : "";
}

function readShellExport(text, key) {
  const pattern = new RegExp(`^\\s*(?:export\\s+)?${escapeRegex(key)}\\s*=\\s*(.*)$`);
  const lines = text.split(/\r?\n/);
  let value = "";
  for (const line of lines) {
    if (/^\s*#/.test(line)) {
      continue;
    }
    const match = pattern.exec(line);
    if (match) {
      value = parseShellValue(match[1]);
    }
  }
  return value;
}

function readShellEnv(text, keys) {
  const allowed = new Set(keys);
  const env = {};
  const assignPattern = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/;
  const unsetPattern = /^\s*unset\s+(.+)$/;

  for (const line of text.split(/\r?\n/)) {
    if (/^\s*#/.test(line)) {
      continue;
    }

    const unsetMatch = unsetPattern.exec(line);
    if (unsetMatch) {
      for (const rawName of unsetMatch[1].split(/\s+/)) {
        const name = rawName.trim();
        if (allowed.has(name)) {
          delete env[name];
        }
      }
      continue;
    }

    const assignMatch = assignPattern.exec(line);
    if (assignMatch && allowed.has(assignMatch[1])) {
      env[assignMatch[1]] = parseShellValue(assignMatch[2]);
    }
  }

  return env;
}

function parseShellValue(raw) {
  const text = String(raw || "").trim();
  if (!text) {
    return "";
  }
  if (text.startsWith('"')) {
    let value = "";
    for (let index = 1; index < text.length; index += 1) {
      const char = text[index];
      if (char === "\\") {
        index += 1;
        if (index < text.length) {
          value += text[index];
        }
        continue;
      }
      if (char === '"') {
        return value;
      }
      value += char;
    }
    return value;
  }
  if (text.startsWith("'")) {
    const end = text.indexOf("'", 1);
    return end >= 0 ? text.slice(1, end) : text.slice(1);
  }
  return text.replace(/\s+#.*$/, "").trim();
}

function upsertShellExport(text, key, value) {
  const line = `export ${key}=${shellDoubleQuote(value)}`;
  const lines = text.split(/\r?\n/);
  const pattern = new RegExp(`^\\s*(?:(?:export\\s+)?${escapeRegex(key)}\\s*=|unset\\s+.*\\b${escapeRegex(key)}\\b)`);
  let replaced = false;

  for (let index = 0; index < lines.length; index += 1) {
    if (!/^\s*#/.test(lines[index]) && pattern.test(lines[index])) {
      lines[index] = line;
      replaced = true;
    }
  }

  if (!replaced) {
    const insertAt = findClaudeEnvInsertIndex(lines);
    if (insertAt >= 0) {
      lines.splice(insertAt + 1, 0, line);
    } else {
      if (lines.length && lines[lines.length - 1].trim()) {
        lines.push("");
      }
      lines.push("# Claude Code via ccm");
      lines.push(line);
    }
  }

  return `${lines.join("\n").replace(/\s*$/, "")}\n`;
}

function upsertShellUnset(text, key) {
  const line = `unset ${key}`;
  const lines = text.split(/\r?\n/);
  const pattern = new RegExp(`^\\s*(?:(?:export\\s+)?${escapeRegex(key)}\\s*=|unset\\s+.*\\b${escapeRegex(key)}\\b)`);
  let replaced = false;

  for (let index = 0; index < lines.length; index += 1) {
    if (!/^\s*#/.test(lines[index]) && pattern.test(lines[index])) {
      if (!replaced) {
        lines[index] = line;
        replaced = true;
      } else {
        lines.splice(index, 1);
        index -= 1;
      }
    }
  }

  if (!replaced) {
    const insertAt = findClaudeEnvInsertIndex(lines);
    if (insertAt >= 0) {
      lines.splice(insertAt + 1, 0, line);
    } else {
      if (lines.length && lines[lines.length - 1].trim()) {
        lines.push("");
      }
      lines.push("# Claude Code via ccm");
      lines.push(line);
    }
  }

  return `${lines.join("\n").replace(/\s*$/, "")}\n`;
}

function findClaudeEnvInsertIndex(lines) {
  for (let index = lines.length - 1; index >= 0; index -= 1) {
    if (/ANTHROPIC_|Claude Code/i.test(lines[index])) {
      return index;
    }
  }
  return -1;
}

function shellDoubleQuote(value) {
  return `"${String(value || "").replace(/(["\\$`])/g, "\\$1")}"`;
}

function normalizeClaudeAuthEnvKey(value) {
  const key = String(value || "ANTHROPIC_AUTH_TOKEN").trim();
  if (key === "ANTHROPIC_API_KEY") {
    return key;
  }
  return "ANTHROPIC_AUTH_TOKEN";
}

async function promptClaudeAuthEnvKey(label, defaultValue) {
  while (true) {
    const answer = (
      await prompt(`${label} [${defaultValue || "ANTHROPIC_AUTH_TOKEN"}]: `)
    ).trim();
    const value = normalizeClaudeAuthEnvKey(answer || defaultValue);
    if (value === "ANTHROPIC_AUTH_TOKEN" || value === "ANTHROPIC_API_KEY") {
      return value;
    }
    console.log("密钥变量只支持 ANTHROPIC_AUTH_TOKEN 或 ANTHROPIC_API_KEY。");
  }
}

function setTopLevelKey(text, key, value) {
  const line = `${key} = ${value}`;
  const pattern = new RegExp(`^${escapeRegex(key)}\\s*=\\s*.*$`, "m");
  if (pattern.test(text)) {
    return text.replace(pattern, line);
  }

  const sectionMatch = text.match(/^\[[^\n]+\]\s*$/m);
  if (sectionMatch) {
    return `${text.slice(0, sectionMatch.index)}${line}\n${text.slice(sectionMatch.index)}`;
  }

  return `${text.trimEnd()}${text.trim() ? "\n" : ""}${line}\n`;
}

function removeTopLevelKey(text, key) {
  const pattern = new RegExp(`^\\s*${escapeRegex(key)}\\s*=`);
  let inRoot = true;
  const lines = String(text || "").split(/\r?\n/);
  return lines
    .filter((line) => {
      if (/^\s*\[/.test(line)) {
        inRoot = false;
      }
      return !(inRoot && pattern.test(line));
    })
    .join("\n");
}

function setSectionKey(body, key, value) {
  const line = `${key} = ${value}`;
  const pattern = new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*.*$`, "m");
  if (pattern.test(body)) {
    return body.replace(pattern, line);
  }

  const trimmed = body.replace(/\s*$/, "");
  return `${trimmed}\n${line}\n`;
}

function upsertSectionKey(text, header, key, value) {
  const range = findSectionRange(text, header);
  if (!range) {
    const prefix = text.trimEnd();
    return `${prefix}${prefix ? "\n\n" : ""}[${header}]\n${key} = ${value}\n`;
  }

  const body = text.slice(range.bodyStart, range.end);
  const nextBody = ensureLeadingNewline(
    setSectionKey(body, key, value),
  ).replace(/\s*$/, "\n");
  return `${text.slice(0, range.bodyStart)}${nextBody}${text.slice(range.end)}`;
}

function findSectionRange(text, header) {
  const headerRe = new RegExp(`^\\[${escapeRegex(header)}\\]\\s*$`, "m");
  const match = headerRe.exec(text);
  if (!match) {
    return null;
  }

  const bodyStart = match.index + match[0].length;
  const remainder = text.slice(bodyStart);
  const nextSection = /^\[[^\n]+\]\s*$/m.exec(remainder);
  const end = nextSection ? bodyStart + nextSection.index : text.length;
  return { start: match.index, bodyStart, end };
}

function removeSectionBlocks(text, headerPrefix) {
  const lines = text.split(/\r?\n/);
  const next = [];
  let skip = false;
  for (const line of lines) {
    const trimmed = line.trim();
    if (/^\[.*\]$/.test(trimmed)) {
      if (
        trimmed === `[${headerPrefix}]` ||
        trimmed.startsWith(`[${headerPrefix}.`)
      ) {
        skip = true;
        continue;
      }
      skip = false;
    }
    if (!skip) {
      next.push(line);
    }
  }
  return next.join("\n");
}

function normalizeBaseUrl(value) {
  const trimmed = String(value || "").trim();
  if (!trimmed) {
    return "";
  }
  return trimmed.replace(/\/+$/, "");
}

function validateHttpUrl(value) {
  try {
    const parsed = new URL(value);
    if (!["http:", "https:"].includes(parsed.protocol)) {
      throw new Error();
    }
  } catch {
    throw new Error("请输入有效的 http(s) URL");
  }
}

function guessChannelName(baseUrl) {
  try {
    const host = new URL(baseUrl).hostname;
    const bits = host.split(".").filter(Boolean);
    if (bits.length >= 2) {
      return bits[bits.length - 2];
    }
    return host || "default";
  } catch {
    return "default";
  }
}

function maskKey(value) {
  const key = String(value || "");
  if (!key) {
    return "(empty)";
  }
  if (key.length <= 8) {
    return `${key.slice(0, 2)}****${key.slice(-2)}`;
  }
  return `${key.slice(0, 3)}****${key.slice(-4)}`;
}

function tomlString(value) {
  return JSON.stringify(String(value));
}

function escapeRegex(value) {
  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

function ensureLeadingNewline(value) {
  return value.startsWith("\n") ? value : `\n${value}`;
}

function selectByNumber(input, items) {
  const index = Number(input);
  if (!Number.isInteger(index) || index < 1 || index > items.length) {
    return null;
  }
  return items[index - 1];
}

function parseChannelQuickAction(input, channels) {
  const match = String(input || "").trim().match(/^(\d+)\s*([a-z]?)$/i);
  if (!match) {
    return null;
  }

  const index = Number(match[1]);
  if (!Number.isInteger(index) || index < 1 || index > channels.length) {
    return null;
  }

  const suffix = (match[2] || "").toLowerCase();
  const actionMap = {
    "": "menu",
    s: "switch",
    c: "start",
    r: "resume",
    e: "edit",
    d: "delete",
  };
  const action = actionMap[suffix];
  if (!action) {
    return null;
  }

  return {
    channel: channels[index - 1],
    action,
  };
}

function uniqueId(existing, preferred) {
  let next = preferred;
  let counter = 2;
  const ids = new Set(existing.map((item) => item.id));
  while (ids.has(next)) {
    next = `${preferred}-${counter}`;
    counter += 1;
  }
  return next;
}

function slugify(value) {
  return String(value || "")
    .trim()
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/^-+|-+$/g, "");
}

function nowIso() {
  return new Date().toISOString();
}

function timestampForPath() {
  return nowIso().replace(/[:.]/g, "-");
}

function clearScreen() {
  if (process.stdout.isTTY) {
    process.stdout.write("\x1Bc");
  }
}

function padRight(value, width) {
  const text = String(value || "");
  if (text.length >= width) {
    return text;
  }
  return text + " ".repeat(width - text.length);
}

async function promptRequired(label) {
  while (true) {
    const answer = (await prompt(label)).trim();
    if (answer) {
      return answer;
    }
    console.log("该项不能为空。");
  }
}

async function promptUrl(label, defaultValue = "") {
  while (true) {
    const fullLabel = defaultValue ? `${label} [${defaultValue}]: ` : label;
    const answer = (await prompt(fullLabel)).trim() || defaultValue;
    try {
      validateHttpUrl(answer);
      return normalizeBaseUrl(answer);
    } catch {
      console.log("请输入有效的 http(s) URL。");
    }
  }
}

async function promptWithDefault(label, defaultValue) {
  const answer = await prompt(`${label} [${defaultValue}]: `);
  return answer.trim() || defaultValue;
}

async function promptSecretRequired(label) {
  while (true) {
    const answer = (await promptSecret(label)).trim();
    if (answer) {
      return answer;
    }
    console.log("该项不能为空。");
  }
}

function prompt(question) {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });
  return new Promise((resolve) => {
    rl.question(question, (answer) => {
      rl.close();
      resolve(answer);
    });
  });
}

function promptSecret(question) {
  if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== "function") {
    return prompt(question);
  }

  return new Promise((resolve) => {
    const stdin = process.stdin;
    const stdout = process.stdout;
    try {
      readline.emitKeypressEvents(stdin);
      const wasRaw = stdin.isRaw;
      const wasPaused = typeof stdin.isPaused === "function" ? stdin.isPaused() : false;
      if (wasPaused) {
        stdin.resume();
      }
      stdin.setRawMode(true);
      stdout.write(question);

      let buffer = "";

      function cleanup() {
        stdin.removeListener("keypress", onKeypress);
        stdin.setRawMode(Boolean(wasRaw));
        if (wasPaused && typeof stdin.pause === "function") {
          stdin.pause();
        }
        stdout.write("\n");
      }

      function onKeypress(str, key) {
        if (key && key.ctrl && key.name === "c") {
          cleanup();
          process.exit(130);
        }

        if (key && (key.name === "return" || key.name === "enter")) {
          cleanup();
          resolve(buffer);
          return;
        }

        if (key && key.name === "backspace") {
          if (!buffer) {
            return;
          }
          buffer = buffer.slice(0, -1);
          stdout.write("\b \b");
          return;
        }

        if (key && key.sequence === "\u0003") {
          cleanup();
          process.exit(130);
        }

        if (!str || (key && (key.meta || key.ctrl))) {
          return;
        }

        buffer += str;
        stdout.write("*");
      }

      stdin.on("keypress", onKeypress);
    } catch {
      resolve(prompt(question));
    }
  });
}

async function pause() {
  await prompt("按 Enter 继续...");
}

function fail(error) {
  console.error(`ccm 错误: ${error.message}`);
  process.exitCode = 1;
}