#!/usr/bin/env node
/**
 * ============================================================================
 * OpenClaw 配置工具 — 交互式菜单前端
 * ============================================================================
 *
 * 功能特性:
 * - 方向键 (↑↓) 导航菜单选项 (使用 oc-menu-engine 引擎)
 * - 回车/空格 确认选择
 * - 实时搜索过滤
 * - 与 oc-config.sh 业务逻辑完全一致
 * - 纯 Node.js 实现，零外部依赖
 * - 完全兼容 xterm.js / Web PTY 环境
 */

const path = require('path');
const fs = require('fs');
const { spawn, spawnSync, execSync, execFileSync } = require('child_process');
const menu = require('./oc-menu-engine');
const { C, select, input, confirm, spinner, resetRenderCount } = menu;

// ═══════════════════════════════════════════════════════════════════════════
// 配置路径 (与 oc-config.sh 保持一致)
// ═══════════════════════════════════════════════════════════════════════════

const OC_BASE_PATH = process.env.OC_BASE_PATH || '/opt';
const OC_INSTALL_PATH = process.env.OC_INSTALL_PATH || `${OC_BASE_PATH}/openclaw`;
const NODE_BASE = process.env.NODE_BASE || `${OC_INSTALL_PATH}/node`;
const OC_GLOBAL = process.env.OC_GLOBAL || `${OC_INSTALL_PATH}/global`;
const OC_DATA = process.env.OC_DATA || `${OC_INSTALL_PATH}/data`;
const OC_STATE_DIR = process.env.OPENCLAW_STATE_DIR || `${OC_DATA}/.openclaw`;
const CONFIG_FILE = process.env.OPENCLAW_CONFIG_PATH || `${OC_STATE_DIR}/openclaw.json`;
const NODE_BIN = `${NODE_BASE}/bin/node`;
const PERMISSIONS_HELPER = '/usr/libexec/openclaw-permissions.sh';

// 写前备份的后缀。特意不用 .bak: OpenClaw 自身维护 openclaw.json.bak
// 及 .bak.1~.bak.4 轮转，占用同名文件会破坏上游备份链。
const CONFIG_BACKUP_SUFFIX = '.luci-pre-write';

// ═══════════════════════════════════════════════════════════════════════════
// 辅助函数 (与 oc-config.sh 逻辑对应)
// ═══════════════════════════════════════════════════════════════════════════

/**
 * 执行命令并返回结果
 * options.interactive: 若为 true，使用 stdio: 'inherit' 直通终端（用于向导/全屏交互），保证 child.stdout.isTTY 为 true
 * options.capture: 若为 true，静默收集 stdout/stderr 并返回，不输出到终端
 */
function runCommand(cmd, args = [], options = {}) {
  return new Promise((resolve, reject) => {
    const isInteractive = options.interactive === true || options.stdio === 'inherit';
    const isCapture = options.capture === true;

    // 交互模式下使用同步直通 (spawnSync inherit)，使子进程独占控制终端 TTY，
    // 避免父子进程竞争读取 stdin，执行完毕后排空残留按键并恢复终端模式
    if (isInteractive) {
      menu.setRawMode(false);
      process.stdout.write(C.show);
      if (process.stdin.pause) {
        try { process.stdin.pause(); } catch {}
      }
      try {
        const res = spawnSync(cmd, args, {
          stdio: 'inherit',
          shell: false,
          cwd: options.cwd,
          env: { ...process.env, ...options.env },
        });
        try {
          if (process.stdin.isTTY) process.stdin.setRawMode(false);
          while (process.stdin.read() !== null) {}
        } catch {}
        if (process.stdin.resume) {
          try { process.stdin.resume(); } catch {}
        }
        if (res.error) {
          return reject(res.error);
        }
        if (res.status === 0) {
          return resolve({ stdout: '', stderr: '', code: 0 });
        } else {
          return reject(new Error(`Command failed with code ${res.status}: ${res.signal || ''}`));
        }
      } catch (err) {
        return reject(err);
      }
    }

    const child = spawn(cmd, args, {
      stdio: isCapture ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
      shell: !options.noShell,
      env: { ...process.env, ...options.env },
    });

    let stdout = '';
    let stderr = '';

    if (child.stdout) {
      child.stdout.on('data', (data) => {
        stdout += data;
        if (!isCapture) process.stdout.write(data);
      });
    }

    if (child.stderr) {
      child.stderr.on('data', (data) => {
        stderr += data;
        if (!isCapture) process.stderr.write(data);
      });
    }

    child.on('close', (code, signal) => {
      if (code === 0) {
        resolve({ stdout, stderr, code });
      } else {
        reject(new Error(`Command failed with code ${code ?? signal}: ${stderr}`));
      }
    });

    child.on('error', (err) => {
      reject(err);
    });
  });
}

/**
 * 清理过时插件配置并启用有效认证插件 (与 oc-config.sh 的 enable_auth_plugins 对应)
 */
function enableAuthPlugins() {
  if (!fs.existsSync(CONFIG_FILE)) return;
  try {
    const config = readConfig();
    if (!config.plugins) config.plugins = {};
    if (!config.plugins.entries) config.plugins.entries = {};
    const e = config.plugins.entries;
    ['copilot-proxy'].forEach(p => {
      if (!e[p]) e[p] = {};
      e[p].enabled = true;
    });
    delete e['qwen-portal-auth'];
    delete e['google-gemini-cli-auth'];
    delete e['minimax-portal-auth'];
    writeConfig(config);
  } catch {}
}

/**
 * 读取 JSON 配置文件
 */
function fixStatePermissions() {
  try {
    execFileSync(PERMISSIONS_HELPER, ['fix-state', OC_STATE_DIR], { stdio: 'ignore', timeout: 10000 });
  } catch {
    try {
      execSync(`find "${OC_STATE_DIR}" -user root ! -path "*/archived-extensions*" ! -path "*/npm/projects*" -exec chown openclaw:openclaw {} + 2>/dev/null || true`, { stdio: 'ignore' });
      execSync(`[ -d "${OC_STATE_DIR}/extensions" ] && chown -R openclaw:openclaw "${OC_STATE_DIR}/extensions" && chmod -R 755 "${OC_STATE_DIR}/extensions" 2>/dev/null || true`, { stdio: 'ignore' });
      execSync(`[ -d "${OC_STATE_DIR}/archived-extensions" ] && chown -R root:root "${OC_STATE_DIR}/archived-extensions" && chmod -R 755 "${OC_STATE_DIR}/archived-extensions" 2>/dev/null || true`, { stdio: 'ignore' });
    } catch {}
  }
}

/**
 * 配置文件损坏时抛出的专用错误。
 * 用于把“文件存在但内容不是合法 JSON 对象”与“文件不存在”区分开。
 */
class ConfigParseError extends Error {
  constructor(message) {
    super(message);
    this.name = 'ConfigParseError';
  }
}

/**
 * 配置损坏时给用户的恢复指引。
 * 不直接自动改文件，避免在用户不知情的情况下丢配置。
 */
function configRecoveryHint() {
  const lines = [
    `${C.yellow}配置文件可能已损坏，为避免覆盖后丢失全部配置，本次操作已中止。${C.reset}`,
    `${C.yellow}文件:${C.reset} ${CONFIG_FILE}`,
    '',
    `${C.cyan}可尝试的恢复方式:${C.reset}`,
    `  1. 让 OpenClaw 自行修复:  openclaw doctor --fix`,
    `  2. 查看具体语法错误:      openclaw config validate`,
  ];
  const lastGood = `${CONFIG_FILE}.last-good`;
  if (fs.existsSync(lastGood)) {
    lines.push(`  3. 从上次正常配置恢复:    cp ${lastGood} ${CONFIG_FILE}`);
  }
  const preWrite = `${CONFIG_FILE}${CONFIG_BACKUP_SUFFIX}`;
  if (fs.existsSync(preWrite)) {
    lines.push(`  4. 从上次修改前的副本恢复: cp ${preWrite} ${CONFIG_FILE}`);
  }
  return lines.join('\n');
}

/**
 * 读取 JSON 配置文件。
 *
 * 语义 (与旧实现的关键差异):
 * - 文件不存在 / 内容为空  → 返回 {} (首次安装属正常情况)
 * - 文件存在但解析失败     → 抛出 ConfigParseError，绝不返回 {}
 *
 * 旧实现在解析失败时返回 {}，调用方随后 writeConfig() 会把这个空对象
 * 写回磁盘，导致 models.providers / apiKey / channels 等全部配置被静默清空。
 * 因此这里必须 fail closed，让写入路径中止。
 */
function readConfig() {
  if (!fs.existsSync(CONFIG_FILE)) return {};

  let raw;
  try {
    raw = fs.readFileSync(CONFIG_FILE, 'utf8');
  } catch (e) {
    throw new ConfigParseError(`无法读取配置文件: ${e.message}`);
  }

  if (raw.trim() === '') return {};

  let parsed;
  try {
    parsed = JSON.parse(raw);
  } catch (e) {
    throw new ConfigParseError(`配置文件不是合法 JSON: ${e.message}`);
  }

  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
    throw new ConfigParseError('配置根节点必须是 JSON 对象');
  }
  return parsed;
}

/**
 * 只读场景下的安全读取: 配置损坏时返回 {} 而不抛错。
 * 仅供“显示当前值”这类不会回写磁盘的路径使用 (如菜单标题里的当前配置)。
 * 任何会写回磁盘的逻辑都必须用 readConfig()。
 */
function readConfigForDisplay() {
  try {
    return readConfig();
  } catch (e) {
    if (e instanceof ConfigParseError) return {};
    throw e;
  }
}

/**
 * 写入 JSON 配置文件 (原子写 + 写前备份 + 写后校验)。
 *
 * 旧实现直接 fs.writeFileSync 覆盖目标文件，写入中断会留下截断的 JSON，
 * 且没有任何备份可回退。这里改为:
 *   1. 先把现有配置复制为 .luci-pre-write 备份
 *   2. 写入同目录临时文件
 *   3. 回读校验临时文件可被 JSON.parse
 *   4. rename 原子替换目标文件
 *
 * 备份后缀特意不用 .bak: OpenClaw 自身维护 openclaw.json.bak 及 .bak.1~.bak.4
 * 轮转，占用同名文件会破坏上游的备份链。
 */
function writeConfig(config) {
  if (config === null || typeof config !== 'object' || Array.isArray(config)) {
    throw new Error('拒绝写入非对象配置');
  }

  const dir = path.dirname(CONFIG_FILE);
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true }); try { execSync(`chown openclaw:openclaw "${dir}"`, { stdio: "ignore" }); } catch {}
  }

  // 保留原文件权限位，避免 rename 后权限被临时文件的 0600 覆盖
  let mode = 0o644;
  if (fs.existsSync(CONFIG_FILE)) {
    try { mode = fs.statSync(CONFIG_FILE).mode & 0o777; } catch {}
    // 写前备份 (best effort: 备份失败不应阻止用户修改配置)
    try { fs.copyFileSync(CONFIG_FILE, `${CONFIG_FILE}${CONFIG_BACKUP_SUFFIX}`); } catch {}
  }

  const payload = `${JSON.stringify(config, null, 2)}\n`;
  const tmpFile = `${CONFIG_FILE}.tmp-${process.pid}`;
  try {
    fs.writeFileSync(tmpFile, payload, { mode: 0o600 });
    // 回读校验: 确认落盘内容可解析，避免把坏内容 rename 成正式配置
    JSON.parse(fs.readFileSync(tmpFile, 'utf8'));
    try { fs.chmodSync(tmpFile, mode); } catch {}
    fs.renameSync(tmpFile, CONFIG_FILE);
  } catch (e) {
    try { if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile); } catch {}
    throw new Error(`写入配置失败，原配置未被修改: ${e.message}`);
  }

  try {
    execSync(`chown openclaw:openclaw "${CONFIG_FILE}"`, { stdio: 'ignore' });
    fixStatePermissions();
  } catch {}
}

/**
 * 获取 JSON 配置值 (对应 json_get)
 *
 * 只读路径: 配置损坏时返回 null 而不抛错，保证菜单仍能打开并显示恢复提示。
 * 需要回写磁盘的逻辑必须直接用 readConfig()，以便在损坏时中止写入。
 */
function jsonGet(keyPath) {
  const config = readConfigForDisplay();
  const keys = keyPath.split('.');
  let value = config;
  for (const key of keys) {
    if (value && typeof value === 'object' && key in value) {
      value = value[key];
    } else {
      return null;
    }
  }
  return value;
}

/**
 * 设置 JSON 配置值 (对应 json_set)
 */
function jsonSet(keyPath, value) {
  const config = readConfig();
  const keys = keyPath.split('.');
  let obj = config;
  for (let i = 0; i < keys.length - 1; i++) {
    if (!obj[keys[i]]) obj[keys[i]] = {};
    obj = obj[keys[i]];
  }
  obj[keys[keys.length - 1]] = value;
  writeConfig(config);
}

/**
 * 获取当前活跃模型
 */
function getCurrentModel() {
  const primary = jsonGet('agents.defaults.model.primary');
  if (primary) return primary;
  // 只读路径: 与 jsonGet 保持一致，配置损坏时不抛错
  const config = readConfigForDisplay();
  if (config.models?.defaultModel) return config.models.defaultModel;
  return null;
}

/**
 * 查找 OpenClaw 入口文件
 */
function findOpenClawEntry() {
  const searchPaths = [
    `${OC_GLOBAL}/lib/node_modules/openclaw/openclaw.mjs`,
    `${OC_GLOBAL}/lib/node_modules/openclaw/dist/cli.js`,
    `${OC_GLOBAL}/node_modules/openclaw/openclaw.mjs`,
    `${OC_GLOBAL}/node_modules/openclaw/dist/cli.js`,
  ];
  for (const p of searchPaths) {
    if (fs.existsSync(p)) return p;
  }
  try {
    const dirs = fs.readdirSync(OC_GLOBAL);
    for (const dir of dirs) {
      const p = `${OC_GLOBAL}/${dir}/node_modules/openclaw/openclaw.mjs`;
      if (fs.existsSync(p)) return p;
    }
  } catch {}
  return null;
}

/**
 * 执行 OpenClaw CLI 命令 (对应 oc_cmd)
 * 交互式向导（configure / models auth login 等）以 interactive: true 运行，直通 stdio 保证 TTY 正常交互；
 * 命令执行后在 finally 中自动修复状态文件属主。
 */
async function ocCmd(...args) {
  const ocEntry = findOpenClawEntry();
  if (!ocEntry) throw new Error('OpenClaw 未安装');

  const isJson = args.includes('--json');
  const isInteractive = !isJson && (
    args[0] === 'configure' ||
    (args[0] === 'models' && args[1] === 'auth')
  );

  try {
    const res = await runCommand(NODE_BIN, [ocEntry, ...args], {
      interactive: isInteractive,
      capture: isJson,
      env: {
        OPENCLAW_HOME: OC_DATA,
        OPENCLAW_CONFIG_PATH: CONFIG_FILE,
        OPENCLAW_STATE_DIR: OC_STATE_DIR,
        HOME: OC_DATA,
      }
    });
    return res;
  } finally {
    try {
      execSync(`chown openclaw:openclaw "${CONFIG_FILE}" 2>/dev/null || true`, { stdio: 'ignore' });
      execSync(`chown openclaw:openclaw "${CONFIG_FILE}.bak" 2>/dev/null || true`, { stdio: 'ignore' });
      fixStatePermissions();
    } catch {}
  }
}

/**
 * 静默执行 OpenClaw CLI 并返回输出。
 *
 * ocCmd() 会把子进程输出直接透传到终端，适合交互式命令；
 * 但解析 `pairing list --json` 这类结果时需要拿到纯输出且不污染界面，
 * 因此单独提供同步捕获版本。
 *
 * 返回 { ok, stdout }: 命令不存在或非零退出时 ok=false，不抛异常。
 */
function ocCmdCapture(...args) {
  const ocEntry = findOpenClawEntry();
  if (!ocEntry) return { ok: false, stdout: '' };
  try {
    const stdout = execFileSync(NODE_BIN, [ocEntry, ...args], {
      encoding: 'utf8',
      timeout: 20000,
      stdio: ['ignore', 'pipe', 'pipe'],
      env: {
        ...process.env,
        OPENCLAW_HOME: OC_DATA,
        OPENCLAW_CONFIG_PATH: CONFIG_FILE,
        OPENCLAW_STATE_DIR: OC_STATE_DIR,
        HOME: OC_DATA,
      },
    });
    return { ok: true, stdout: stdout || '' };
  } catch (e) {
    // 保留 stdout: 部分命令失败时仍会输出有用信息
    return { ok: false, stdout: (e && (e.stdout || '')) ? String(e.stdout) : '' };
  }
}

/**
 * 从 `openclaw pairing list <channel> --json` 的输出中提取配对码。
 * 优先按 JSON 解析；输出夹带非 JSON 前后缀时回退到正则扫描。
 */
function parsePairingCodes(raw) {
  if (!raw || !raw.trim()) return [];
  const codes = [];
  const pushFrom = (node) => {
    if (!node || typeof node !== 'object') return;
    if (Array.isArray(node)) { node.forEach(pushFrom); return; }
    if (typeof node.code === 'string' && node.code.trim()) codes.push(node.code.trim());
    Object.keys(node).forEach((k) => pushFrom(node[k]));
  };
  try {
    pushFrom(JSON.parse(raw));
  } catch {
    const re = /"code"\s*:\s*"([^"]+)"/g;
    let m;
    while ((m = re.exec(raw)) !== null) codes.push(m[1]);
  }
  return [...new Set(codes)];
}

/**
 * 重启 Gateway
 */
async function restartGateway() {
  resetRenderCount();
  console.log(`\n${C.yellow}正在重启 Gateway...${C.reset}`);

  try {
    await runCommand('/bin/sh', ['-c', [
      "if [ \"$(uci -q get openclaw.main.enabled 2>/dev/null || echo 0)\" != \"1\" ]; then",
      "  uci -q set openclaw.main.enabled='1';",
      "  uci -q commit openclaw;",
      "  /etc/init.d/openclaw enable >/dev/null 2>&1 || true;",
      'fi;',
      '/etc/init.d/openclaw restart_gateway >/dev/null 2>&1 || true;',
      '/etc/init.d/openclaw start >/dev/null 2>&1 || true'
    ].join(' ')]);
  } catch {}

  const spin = spinner({ text: 'Gateway 启动中，请稍候 (约 15-30 秒)...' });
  spin.start();

  const gwPort = jsonGet('gateway.port') || '18789';
  let waited = 0;
  const maxWait = 30;

  while (waited < maxWait) {
    await new Promise(r => setTimeout(r, 3000));
    waited += 3;
    try {
      // 兼容 OpenWrt: 优先 ss，回退 netstat
      let stdout = '';
      try {
        stdout = execSync('ss -tulnp 2>/dev/null', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
      } catch {
        // ss 不存在，使用 netstat
        try {
          stdout = execSync('netstat -tulnp 2>/dev/null', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
        } catch {}
      }
      if (stdout && stdout.includes(`:${gwPort} `)) {
        spin.succeed(`Gateway 已重启成功 (${waited}秒)`);
        return;
      }
    } catch {}
  }

  spin.stop(`${C.yellow}Gateway 仍在启动中，请稍后确认${C.reset}`);
  console.log(`${C.cyan}   查看日志: logread -e openclaw${C.reset}\n`);
}

/**
 * 询问是否重启
 */
async function askRestart() {
  const ok = await confirm({ prompt: '是否立即重启服务以应用配置?', defaultYes: true });
  if (ok) {
    await restartGateway();
  }
}

// ═══════════════════════════════════════════════════════════════════════════
// 主菜单 (对应 main_menu)
// ═══════════════════════════════════════════════════════════════════════════

async function showMainMenu() {
  const currentModel = getCurrentModel();
  const statusLine = currentModel
    ? `${C.green}当前模型: ${currentModel}${C.reset}`
    : `${C.yellow}未配置模型${C.reset}`;

  const result = await select({
    title: 'OpenClaw AI Gateway — OpenWrt 配置管理',
    header: statusLine,
    showSearch: false,
    items: [
      { label: `${C.dim}━━━ AI 模型配置 ━━━${C.reset}`, disabled: true },
      { key: '1', label: '配置 AI 模型和提供商', desc: '', value: 'model' },
      { key: '2', label: '设置活动模型', desc: '', value: 'set-active-model' },

      { label: `${C.dim}━━━ 消息渠道 ━━━${C.reset}`, disabled: true },
      { key: '3', label: '配置消息渠道', desc: '电报/QQ/飞书', value: 'channels' },

      { label: `${C.dim}━━━ 系统管理 ━━━${C.reset}`, disabled: true },
      { key: '4', label: '健康检查与状态', desc: '', value: 'health' },
      { key: '5', label: '查看日志', desc: '', value: 'logs' },
      { key: '6', label: '重启 Gateway', desc: '', value: 'restart' },
      { key: '7', label: '设备配对管理', desc: '审批 Control UI 浏览器配对', value: 'devices' },

      { label: `${C.dim}━━━ 高级选项 ━━━${C.reset}`, disabled: true },
      { key: '8', label: '高级配置', desc: '', value: 'advanced' },
      { key: '9', label: '重置配置', desc: '', value: 'reset' },
      { key: '10', label: '显示当前配置概览', desc: '', value: 'show-config' },
      { key: '11', label: '备份/还原配置', desc: '', value: 'backup' },

      { label: '', disabled: true },
      { key: '0', label: '退出', desc: '', value: 'quit' },
    ],
  });

  return result;
}

// ═══════════════════════════════════════════════════════════════════════════
// 消息渠道菜单 (对应 configure_channels)
// ═══════════════════════════════════════════════════════════════════════════

async function showChannelsMenu() {
  const result = await select({
    title: '配置消息渠道',
    showSearch: false,
    items: [
      { label: `${C.dim}提示: 微信配置请使用 LuCI 界面「微信配置」菜单${C.reset}`, disabled: true },
      { label: '', disabled: true },
      { key: '1', label: 'QQ 机器人', desc: '腾讯QQ', value: 'qq' },
      { key: '2', label: 'Telegram', desc: `${C.green}最常用${C.reset} — 配置 Bot Token`, value: 'telegram' },
      { key: '3', label: 'Discord', desc: '', value: 'discord' },
      { key: '4', label: '飞书 (Feishu)', desc: '', value: 'feishu' },
      { key: '5', label: 'Slack', desc: '', value: 'slack' },
      { key: '6', label: 'WhatsApp', desc: '需通过 Web 控制台扫码', value: 'whatsapp' },
      { key: '7', label: 'Telegram 配对助手', desc: '审批用户配对请求 (需先配置 Token)', value: 'telegram-pairing' },
      { key: '8', label: '官方完整渠道配置向导', desc: '', value: 'wizard' },
      { label: '', disabled: true },
      { key: '0', label: '返回', desc: '', value: 'back' },
    ],
  });

  return result;
}

// ═══════════════════════════════════════════════════════════════════════════
// 高级配置菜单 (对应 advanced_menu)
// ═══════════════════════════════════════════════════════════════════════════

async function showAdvancedMenu() {
  const gwPort = jsonGet('gateway.port') || '18789';
  const gwBind = jsonGet('gateway.bind') || 'lan';
  const gwMode = jsonGet('gateway.mode') || 'local';
  // 正确键是顶层 logging.level；gateway.logLevel 不在 OpenClaw schema 中
  // (gateway.additionalProperties=false)，仅为显示旧配置残留值做兼容读取。
  const logLevel = jsonGet('logging.level') || jsonGet('gateway.logLevel') || '未设置';
  const acpDispatch = jsonGet('acp.dispatch.enabled') || 'false';

  const result = await select({
    title: '高级配置',
    showSearch: false,
    items: [
      { key: '1', label: 'Gateway 端口', desc: `当前: ${gwPort}`, value: 'port' },
      { key: '2', label: 'Gateway 绑定地址', desc: `当前: ${gwBind}`, value: 'bind' },
      { key: '3', label: 'Gateway 运行模式', desc: `当前: ${gwMode}`, value: 'mode' },
      { key: '4', label: '日志级别', desc: `当前: ${logLevel}`, value: 'loglevel' },
      { key: '5', label: 'ACP Dispatch 设置', desc: `当前: ${acpDispatch}`, value: 'acp' },
      { key: '6', label: '官方完整配置向导', desc: 'oc configure', value: 'wizard' },
      { key: '7', label: '查看原始配置 JSON', desc: '', value: 'view-json' },
      { key: '8', label: '编辑配置文件', desc: 'vi / nano', value: 'edit' },
      { key: '9', label: '导出配置备份', desc: '', value: 'backup' },
      { key: '10', label: '导入配置', desc: '', value: 'import' },
      { key: '11', label: '设备配对管理', desc: '审批 Control UI 配对', value: 'devices' },
      { label: '', disabled: true },
      { key: '0', label: '返回', desc: '', value: 'back' },
    ],
  });

  return result;
}

// ═══════════════════════════════════════════════════════════════════════════
// 重置配置菜单 (对应 reset_to_defaults)
// ═══════════════════════════════════════════════════════════════════════════

async function showResetMenu() {
  const result = await select({
    title: '恢复默认配置',
    showSearch: false,
    items: [
      { label: `${C.yellow}请选择恢复级别:${C.reset}`, disabled: true },
      { label: '', disabled: true },
      { key: '1', label: '仅重置网关设置', desc: '端口/绑定/模式恢复默认，保留模型和渠道', value: 'gateway' },
      { key: '2', label: '清除模型配置', desc: '移除所有 AI 模型和 API Key', value: 'models' },
      { key: '3', label: '清除渠道配置', desc: '移除所有消息渠道配置', value: 'channels' },
      { key: '4', label: '完全恢复出厂', desc: '删除所有配置，重新初始化', value: 'full' },
      { label: '', disabled: true },
      { key: '0', label: '返回', desc: '', value: 'back' },
    ],
  });

  return result;
}

// ═══════════════════════════════════════════════════════════════════════════
// 备份/还原菜单 (对应 backup_restore_menu)
// ═══════════════════════════════════════════════════════════════════════════

async function showBackupMenu() {
  const result = await select({
    title: '备份/还原配置',
    showSearch: false,
    items: [
      { key: '1', label: '创建配置备份', desc: '仅配置文件', value: 'create-config' },
      { key: '2', label: '创建完整备份', desc: '配置 + 状态数据', value: 'create-full' },
      { key: '3', label: '验证最新备份', desc: '', value: 'verify' },
      { key: '4', label: '查看备份列表', desc: '', value: 'list' },
      { key: '5', label: '从最新备份恢复配置', desc: '', value: 'restore' },
      { label: '', disabled: true },
      { key: '0', label: '返回', desc: '', value: 'back' },
    ],
  });

  return result;
}

// ═══════════════════════════════════════════════════════════════════════════
// AI 模型配置 (对应 oc-config.sh 的 configure_model)
//
// 业务逻辑全部在 oc-providers.js，本文件只负责交互。Shell 菜单调用同一个
// 后端与同一份 provider-catalog.json，两边菜单项、按键与流程保持一致。
// ═══════════════════════════════════════════════════════════════════════════

const providers = require('./oc-providers');

// 模型模块的菜单只用 Esc 返回: select() 默认把 'q' 也当退出键，且先于搜索处理，
// 会导致可搜索列表里无法输入 q (如搜索 qwen)，也与「q 快速配置」快捷键冲突
function selectMenu(opts) {
  return select({ exitKeys: ['escape'], ...opts });
}

function printResultNotes(r) {
  for (const n of (r.notes || [])) console.log(`${C.dim}   ${n}${C.reset}`);
}

function pause() {
  return input({ prompt: '按回车继续', defaultValue: '' });
}

function verificationHeader() {
  try {
    const v = providers.catalogVerification();
    if (!v.installed) return `${C.yellow}OpenClaw 未安装${C.reset}`;
    return v.verified
      ? `${C.dim}OpenClaw ${v.installed} — provider 目录已在此版本核实 (${v.verifiedAt})${C.reset}`
      : `${C.yellow}OpenClaw ${v.installed} 不在 provider 目录核实范围 (${v.verifiedWith.join(' / ')})，配置项可能有出入${C.reset}`;
  } catch (e) {
    return `${C.red}provider 目录读取失败: ${e.message}${C.reset}`;
  }
}

async function showModelMenu() {
  const currentModel = getCurrentModel();
  return selectMenu({
    title: 'AI 模型配置',
    header: `${currentModel ? `${C.green}当前默认模型: ${currentModel}${C.reset}` : `${C.yellow}尚未设置默认模型${C.reset}`}\n${verificationHeader()}`,
    showSearch: false,
    items: [
      { label: `${C.green}${C.bold}── 快速配置 ──${C.reset}`, disabled: true },
      { key: 'q', label: '常用 Provider 快速配置', desc: `${C.green}(推荐)${C.reset}`, value: 'quick' },

      { label: `${C.bold}── 按类别添加 ──${C.reset}`, disabled: true },
      { key: '1', label: '官方 API (按量付费)', desc: 'OpenAI / Claude / Gemini / DeepSeek / 千问 / 智谱 ...', value: 'group:official' },
      { key: '2', label: '订阅套餐 / Coding Plan / 账号登录', desc: '百炼 / GLM / Kimi Code / Copilot ...', value: 'group:plan' },
      { key: '3', label: '聚合平台 / 自定义 API', desc: 'OpenRouter / 硅基流动 / OpenAI 兼容 ...', value: 'group:aggregator' },
      { key: '4', label: '本地 / 局域网模型', desc: 'Ollama / vLLM / LM Studio', value: 'group:local' },

      { label: `${C.bold}── 模型管理 ──${C.reset}`, disabled: true },
      { key: '5', label: '查看模型与认证状态', desc: '', value: 'status' },
      { key: '6', label: '切换默认模型', desc: '', value: 'set-default' },
      { key: '7', label: '管理备用模型 (fallback)', desc: '', value: 'fallbacks' },
      { key: '8', label: '连通性测试', desc: '真实请求，验证账号能否调用', value: 'probe' },
      { key: '9', label: '删除凭据 / Provider', desc: '', value: 'remove' },

      { label: `${C.bold}── 其他 ──${C.reset}`, disabled: true },
      { key: 'w', label: '官方完整配置向导', desc: 'openclaw configure --section model', value: 'wizard' },
      { label: '', disabled: true },
      { key: '0', label: '返回', desc: '', value: 'back' },
    ],
  });
}

async function pickMethodFromGroup(groupId) {
  const entries = providers.menuEntries().filter((e) => e.group === groupId);
  if (!entries.length) return null;
  const keys = 'abcdefghijklmnoprstuvwxyz'.split('');
  const items = [];
  let ki = 0;
  for (const e of entries) {
    for (const m of e.methods) {
      const label = e.methods.length > 1 ? `${e.label} — ${m.label}` : e.label;
      items.push({ key: keys[ki++], label, desc: e.plugin ? `${C.dim}需官方插件${C.reset}` : '', value: m.ref });
    }
  }
  items.push({ label: '', disabled: true });
  items.push({ key: '0', label: '返回', desc: '', value: 'back' });
  const choice = await selectMenu({ title: entries[0].groupLabel, showSearch: true, items });
  return choice && choice.value !== 'back' ? choice.value : null;
}

async function pickQuickMethod() {
  const items = providers.quickEntries().map((q, i) => ({ key: String(i + 1), label: q.label, desc: '', value: q.ref }));
  items.push({ label: '', disabled: true });
  items.push({ key: '0', label: '返回', desc: '', value: 'back' });
  const choice = await selectMenu({ title: '常用 Provider 快速配置', showSearch: false, items });
  return choice && choice.value !== 'back' ? choice.value : null;
}

function printMethodIntro(f) {
  const p = f.provider;
  const m = f.method;
  console.log(`\n${C.bold}${p.label}${p.methods.length > 1 ? ` — ${m.label}` : ''}${C.reset}`);
  if (p.keyUrl) console.log(`${C.yellow}获取 Key: ${p.keyUrl}${C.reset}`);
  const docs = providers.docsUrl(p);
  if (docs) console.log(`${C.dim}文档: ${docs}${C.reset}`);
  if (m.baseUrl) console.log(`${C.dim}Base URL: ${m.baseUrl}${C.reset}`);
  if (p.note) console.log(`${C.cyan}说明: ${p.note}${C.reset}`);
  if (m.note) console.log(`${C.cyan}说明: ${m.note}${C.reset}`);
  if (m.keyHint) console.log(`${C.cyan}提示: ${m.keyHint}${C.reset}`);
  if (m.unverified) console.log(`${C.yellow}未实测: ${m.unverified}${C.reset}`);
  console.log('');
}

/** 插件缺失时征得同意后安装；返回 false 表示用户取消或安装失败 */
async function ensurePluginInteractive(f) {
  const pkg = f.provider.plugin;
  if (!pkg) return true;
  console.log(`${C.cyan}检查官方插件 ${pkg}...${C.reset}`);
  const st = providers.pluginStatus(pkg);
  if (st.installed) return true;
  if (st.error) console.log(`${C.yellow}插件状态查询失败: ${st.error}${C.reset}`);
  console.log(`${C.yellow}该 Provider 需要 OpenClaw 官方插件 ${pkg}，将通过 npm 下载安装 (版本与当前 OpenClaw 匹配)。${C.reset}`);
  const ok = await confirm({ prompt: '是否安装该插件?', defaultYes: true });
  if (!ok) return false;
  console.log(`${C.cyan}正在安装 ${pkg} (可能需要 1~3 分钟)...${C.reset}`);
  const r = providers.installPlugin(pkg);
  if (!r.ok) {
    console.log(`${C.red}插件安装失败: ${r.reason}${C.reset}\n`);
    return false;
  }
  console.log(`${C.green}✅ 插件已安装${C.reset}`);
  return true;
}

/**
 * 模型选择: 精选 + 动态发现 + 手动输入 + 保持当前默认。
 * 返回 { model } / { keep: true } / null(取消)。
 */
async function pickModel(providerId, curated, opts = {}) {
  let discovered = null;
  const current = getCurrentModel();
  while (true) {
    const keys = 'abcdefghijkmnoprstuvwxy'.split('');
    let ki = 0;
    const items = [];
    if (curated.length) {
      items.push({ label: `${C.bold}── 精选模型 ──${C.reset}`, disabled: true });
      for (const m of curated) items.push({ key: keys[ki++], label: m.id, desc: `${m.tier ? `[${m.tier}] ` : ''}${m.desc || ''}`, value: `m:${m.id}` });
    }
    if (discovered && discovered.models.length) {
      const known = new Set(curated.map((m) => m.id));
      const extra = discovered.models.filter((m) => !known.has(m.id));
      if (extra.length) {
        const title = discovered.source === 'cache' ? `OpenClaw 模型列表 (缓存 ${discovered.cachedAt || ''})` : 'OpenClaw 当前模型列表';
        items.push({ label: `${C.bold}── ${title} ──${C.reset}`, disabled: true });
        for (const m of extra) items.push({ key: keys[ki++], label: m.id, desc: m.name || '', value: `m:${m.id}` });
      }
    }
    items.push({ label: '', disabled: true });
    if (!discovered && providerId) items.push({ key: 'r', label: '从 OpenClaw 获取完整模型列表', desc: '动态发现', value: 'discover' });
    items.push({ key: 'z', label: '手动输入模型 ID', desc: '', value: 'manual' });
    if (opts.allowKeep && current) items.push({ key: 'k', label: '保持当前默认模型不变', desc: current, value: 'keep' });
    items.push({ key: '0', label: '取消', desc: '', value: 'back' });

    const choice = await selectMenu({ title: opts.title || '选择模型', showSearch: true, items });
    if (!choice || choice.value === 'back') return null;
    if (choice.value === 'keep') return { keep: true };
    if (choice.value === 'manual') {
      const v = await input({ prompt: '请输入模型 ID (不含 provider/ 前缀)', defaultValue: opts.defaultModel || '' });
      const t = v ? String(v).trim() : '';
      if (!t) continue;
      return { model: t };
    }
    if (choice.value === 'discover') {
      console.log(`\n${C.cyan}正在从 OpenClaw 获取模型列表 (路由器上可能需要 10~60 秒)...${C.reset}`);
      discovered = providers.discoverModels(providerId);
      if (discovered.source === 'none') {
        console.log(`${C.yellow}未获取到模型列表${discovered.reason ? `: ${discovered.reason}` : ''}，仍可使用精选列表或手动输入。${C.reset}`);
      } else {
        console.log(`${C.green}获取到 ${discovered.models.length} 个模型${discovered.source === 'cache' ? ' (来自缓存)' : ''}${C.reset}`);
      }
      if (discovered.hints.includes('auth-rejected')) {
        console.log(`${C.yellow}⚠️  上游报告该 Provider 的认证被拒绝: Key 可能无效或无权限。${C.reset}`);
      }
      console.log(`${C.dim}注意: 列表只代表上游登记的模型，不代表你的账号有权调用；请用「连通性测试」确认。${C.reset}\n`);
      continue;
    }
    return { model: choice.value.slice(2) };
  }
}

async function configureApiKeyMethod(f) {
  if (!(await ensurePluginInteractive(f))) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
  const key = await input({ prompt: `请输入 ${f.provider.label} API Key`, hidden: true });
  if (!key) { console.log(`\n${C.yellow}已取消${C.reset}\n`); return false; }
  console.log(`\n${C.cyan}正在写入凭据 (通过 OpenClaw 官方命令，Key 保存在认证库，不写入 openclaw.json)...${C.reset}`);
  const r = providers.applyApiKey(f.ref, key, { keepDefault: true, pluginConfirmed: true });
  if (!r.ok) {
    console.log(`${C.red}❌ 配置失败: ${r.reason}${C.reset}\n`);
    return false;
  }
  console.log(`${C.green}✅ ${f.provider.label} 凭据已保存${C.reset}`);
  printResultNotes(r);
  await chooseDefaultAfterAuth(f.method.provider, providers.curatedModels(f.method), f.method.defaultModel);
  return true;
}

async function chooseDefaultAfterAuth(providerId, curated, defaultModel) {
  const pick = await pickModel(providerId, curated, { title: `将哪个 ${providerId} 模型设为默认?`, allowKeep: true, defaultModel });
  if (!pick || pick.keep) {
    console.log(`${C.dim}默认模型保持为 ${getCurrentModel() || '未设置'}${C.reset}\n`);
    return;
  }
  const ref = `${providerId}/${pick.model}`;
  const s = providers.setDefault(ref);
  if (s.ok) console.log(`${C.green}✅ 默认模型已设为 ${ref}${C.reset}\n`);
  else console.log(`${C.red}❌ 设置默认模型失败: ${s.reason}${C.reset}\n`);
}

async function configureCustomMethod(f) {
  const m = f.method;
  const id = await input({ prompt: 'Provider ID (小写字母/数字/连字符)', defaultValue: m.customProviderId || (m.compatibility === 'anthropic' ? 'custom-anthropic' : 'custom') });
  if (!id) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
  const baseUrl = await input({ prompt: 'API Base URL', defaultValue: m.baseUrl || m.baseUrlDefault || '', placeholder: 'https://api.example.com/v1' });
  if (!baseUrl) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
  const model = await input({ prompt: '模型 ID', defaultValue: '', placeholder: m.modelHint || '' });
  if (!model) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
  const image = await confirm({ prompt: '该模型支持图片输入吗?', defaultYes: false });
  const key = await input({ prompt: m.keyOptional ? 'API Key (可留空)' : 'API Key', hidden: true, defaultValue: '' });
  if (key === null) { console.log(`\n${C.yellow}已取消${C.reset}\n`); return false; }
  if (!key && !m.keyOptional) {
    const cont = await confirm({ prompt: '\n未填写 API Key，若该 Provider 已存在将沿用原 Key，否则不带 Key 接入。继续?', defaultYes: false });
    if (!cont) return false;
  }
  const setDef = await confirm({ prompt: '\n设为默认模型?', defaultYes: true });
  console.log(`\n${C.cyan}正在写入...${C.reset}`);
  const r = providers.applyCustom({ providerId: String(id).trim(), baseUrl, model: String(model).trim(), compatibility: m.compatibility, image, keyOptional: true }, key || '', { setDefault: setDef });
  if (!r.ok) { console.log(`${C.red}❌ 配置失败: ${r.reason}${C.reset}\n`); return false; }
  console.log(`${C.green}✅ ${r.appended ? '已向现有 Provider 追加模型' : '自定义 Provider 已添加'}: ${r.provider}/${String(model).trim()}${C.reset}`);
  console.log(`${C.dim}   注意: 按上游设计，自定义 Provider 的 Key 明文保存在 openclaw.json${C.reset}`);
  printResultNotes(r);
  console.log(`${C.dim}   当前默认模型: ${r.primary || '未设置'}${C.reset}\n`);
  return true;
}

async function configureOllamaMethod(f) {
  const url = await input({ prompt: 'Ollama 地址', defaultValue: f.method.baseUrlDefault || 'http://127.0.0.1:11434' });
  if (!url) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
  const base = /^https?:\/\//.test(url) ? url.replace(/\/+$/, '').replace(/\/v1$/, '') : `http://${url.replace(/\/+$/, '')}`;
  let names = [];
  try {
    const out = execFileSync('curl', ['-sf', '--connect-timeout', '3', '--max-time', '6', `${base}/api/tags`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
    names = (JSON.parse(out).models || []).map((x) => x.name).filter(Boolean);
    console.log(`${C.green}✅ Ollama 已连接，发现 ${names.length} 个本地模型${C.reset}`);
  } catch {
    console.log(`${C.yellow}⚠️  无法连接 ${base}，上游写入时也会检测，不可达将被拒绝${C.reset}`);
  }
  let model = '';
  if (names.length) {
    const items = names.map((n, i) => ({ key: String(i + 1), label: n, desc: '', value: n }));
    items.push({ key: 'z', label: '手动输入模型名', desc: '', value: '__manual__' });
    const c = await selectMenu({ title: 'Ollama 模型', showSearch: true, items });
    if (!c) return false;
    model = c.value === '__manual__' ? await input({ prompt: '模型名', defaultValue: '' }) : c.value;
  } else {
    model = await input({ prompt: '模型名', placeholder: 'qwen3:8b' });
  }
  if (!model) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
  const setDef = await confirm({ prompt: '设为默认模型?', defaultYes: true });
  console.log(`\n${C.cyan}正在写入...${C.reset}`);
  const r = providers.applyOllama(base, String(model).trim(), { setDefault: setDef });
  if (!r.ok) { console.log(`${C.red}❌ 配置失败: ${r.reason}${C.reset}\n`); return false; }
  console.log(`${C.green}✅ Ollama 已配置${C.reset}`);
  printResultNotes(r);
  console.log(`${C.dim}   当前默认模型: ${r.primary || '未设置'}${C.reset}\n`);
  return true;
}

async function configureOAuthMethod(f) {
  console.log(`${C.cyan}即将启动 OpenClaw 官方登录流程，请按屏幕提示在浏览器中完成授权。${C.reset}\n`);
  const ok = await confirm({ prompt: '开始登录?', defaultYes: true });
  if (!ok) return false;
  const r = providers.login(f.ref);
  if (!r.ok) { console.log(`\n${C.yellow}${r.reason}${C.reset}\n`); return false; }
  console.log(`\n${C.green}✅ 登录完成${C.reset}`);
  await chooseDefaultAfterAuth(f.method.provider, providers.curatedModels(f.method), '');
  return true;
}

async function configureMethod(ref) {
  resetRenderCount();
  const f = providers.findMethod(ref);
  if (!f) { console.log(`${C.red}未知的接入方式: ${ref}${C.reset}`); return false; }
  printMethodIntro(f);
  switch (f.method.type) {
    case 'api-key': return configureApiKeyMethod(f);
    case 'custom': return configureCustomMethod(f);
    case 'local': return configureOllamaMethod(f);
    case 'oauth': return configureOAuthMethod(f);
    default:
      console.log(`${C.red}不支持的接入类型: ${f.method.type}${C.reset}`);
      return false;
  }
}

async function handleModelStatus() {
  resetRenderCount();
  console.log(`\n${C.cyan}正在读取模型与认证状态...${C.reset}`);
  const s = providers.status();
  if (!s.ok) console.log(`${C.red}读取失败: ${s.reason}${C.reset}`);
  console.log(`\n${C.bold}默认模型:${C.reset} ${s.defaultModel ? C.green + s.defaultModel : C.yellow + '未设置'}${C.reset}`);
  console.log(`${C.bold}备用模型:${C.reset} ${s.fallbacks.length ? s.fallbacks.join(', ') : C.dim + '无' + C.reset}`);
  console.log(`\n${C.bold}已保存的凭据:${C.reset}`);
  if (!s.profiles.length) console.log(`  ${C.dim}无${C.reset}`);
  for (const p of s.profiles) console.log(`  • ${p.id}  ${C.dim}(${p.provider}, ${p.type})${C.reset}`);
  console.log(`\n${C.bold}Provider 配置:${C.reset}`);
  if (!s.custom.length) console.log(`  ${C.dim}无${C.reset}`);
  for (const c of s.custom) {
    console.log(`  • ${c.id}  ${C.dim}${c.baseUrl || ''} ${c.api || ''}${c.hasKey ? ' [配置内含 Key]' : ''}${C.reset}`);
    if (c.models.length) console.log(`    ${C.dim}模型: ${c.models.join(', ')}${C.reset}`);
  }
  if (s.issues.length) {
    console.log(`\n${C.yellow}${C.bold}发现问题:${C.reset}`);
    for (const i of s.issues) console.log(`  ${C.yellow}• ${i}${C.reset}`);
  }
  console.log(`\n${C.dim}以上是本地凭据状态，不代表调用一定成功；请用「连通性测试」确认。${C.reset}\n`);
  await pause();
}

async function pickConfiguredModel(title) {
  const current = getCurrentModel();
  const refs = providers.configuredModels();
  const items = refs.map((r, i) => ({ key: i < 9 ? String(i + 1) : undefined, label: r, desc: r === current ? `${C.green}(当前默认)${C.reset}` : '', value: r }));
  items.push({ label: '', disabled: true });
  items.push({ key: 'z', label: '手动输入 provider/model', desc: '', value: '__manual__' });
  items.push({ key: '0', label: '取消', desc: '', value: 'back' });
  const c = await selectMenu({ title, showSearch: true, items });
  if (!c || c.value === 'back') return null;
  if (c.value === '__manual__') {
    const v = await input({ prompt: '模型引用 (provider/model)', defaultValue: '' });
    return v ? String(v).trim() : null;
  }
  return c.value;
}

async function handleSetDefaultModel() {
  resetRenderCount();
  console.log(`\n${C.bold}切换默认模型${C.reset}  当前: ${C.green}${getCurrentModel() || '未设置'}${C.reset}\n`);
  const ref = await pickConfiguredModel('选择默认模型');
  if (!ref) return false;
  const r = providers.setDefault(ref);
  if (r.ok) { console.log(`\n${C.green}✅ 默认模型已切换为 ${ref}${C.reset}\n`); return true; }
  console.log(`\n${C.red}❌ 切换失败: ${r.reason}${C.reset}\n`);
  return false;
}

async function handleFallbacks() {
  let changed = false;
  while (true) {
    resetRenderCount();
    const l = providers.fallbacks('list');
    const list = l.ok ? l.fallbacks : [];
    if (!l.ok) console.log(`${C.red}读取备用模型失败: ${l.reason}${C.reset}`);
    const c = await selectMenu({
      title: '管理备用模型 (fallback)',
      header: `${C.dim}默认模型不可用时按顺序尝试: ${list.length ? list.join(' → ') : '无'}${C.reset}`,
      showSearch: false,
      items: [
        { key: '1', label: '添加备用模型', desc: '', value: 'add' },
        { key: '2', label: '移除备用模型', desc: '', value: 'remove' },
        { key: '3', label: '清空备用模型', desc: '', value: 'clear' },
        { label: '', disabled: true },
        { key: '0', label: '返回', desc: '', value: 'back' },
      ],
    });
    if (!c || c.value === 'back') return changed;
    let r = null;
    if (c.value === 'add') {
      const ref = await pickConfiguredModel('选择要添加的备用模型');
      if (ref) r = providers.fallbacks('add', ref);
    } else if (c.value === 'remove') {
      if (!list.length) { console.log(`${C.yellow}没有备用模型${C.reset}`); continue; }
      const p = await selectMenu({ title: '移除哪个?', showSearch: false, items: list.map((x, i) => ({ key: String(i + 1), label: x, value: x })) });
      if (p) r = providers.fallbacks('remove', p.value);
    } else if (c.value === 'clear') {
      if (await confirm({ prompt: '确认清空所有备用模型?', defaultYes: false })) r = providers.fallbacks('clear');
    }
    if (r) {
      if (r.ok) { console.log(`${C.green}✅ 已更新${C.reset}`); changed = true; }
      else console.log(`${C.red}❌ 失败: ${r.reason}${C.reset}`);
    }
  }
}

async function handleProbe() {
  resetRenderCount();
  console.log(`\n${C.cyan}正在读取已配置的 Provider...${C.reset}`);
  const s = providers.status();
  const ids = [...new Set([...s.profiles.map((p) => p.provider), ...s.custom.map((c) => c.id)])].sort();
  if (!ids.length) { console.log(`${C.yellow}尚未配置任何 Provider${C.reset}\n`); await pause(); return; }
  const c = await selectMenu({ title: '测试哪个 Provider?', showSearch: true, items: ids.map((id, i) => ({ key: i < 9 ? String(i + 1) : undefined, label: id, value: id })) });
  if (!c) return;
  console.log(`\n${C.yellow}连通性测试会向 ${c.value} 发送真实请求 (每个模型约 8 个 token)，可能产生少量费用或触发限流。${C.reset}`);
  if (!(await confirm({ prompt: '继续?', defaultYes: true }))) return;
  console.log(`${C.cyan}测试中 (约 5~60 秒)...${C.reset}`);
  const r = providers.probe(c.value);
  if (!r.ok) {
    console.log(`${C.red}❌ 无法完成测试: ${r.reason}${C.reset}\n`);
  } else {
    for (const x of r.results) {
      const color = x.status === 'ok' ? C.green : C.red;
      console.log(`  ${color}${x.status === 'ok' ? '✅' : '❌'} ${x.model || c.value}  ${x.statusText}${x.latencyMs ? ` (${x.latencyMs} ms)` : ''}${C.reset}`);
      if (x.error) console.log(`     ${C.dim}${x.error}${C.reset}`);
    }
    console.log('');
  }
  await pause();
}

async function handleRemove() {
  resetRenderCount();
  const s = providers.status();
  const items = [];
  for (const p of s.profiles) items.push({ label: `删除凭据 ${p.id}`, desc: `${p.provider} / ${p.type}`, value: `auth:${p.id}` });
  for (const c of s.custom) items.push({ label: `删除 Provider 配置 ${c.id}`, desc: c.baseUrl, value: `prov:${c.id}` });
  if (!items.length) { console.log(`\n${C.yellow}没有可删除的凭据或 Provider${C.reset}\n`); await pause(); return false; }
  items.forEach((it, i) => { if (i < 9) it.key = String(i + 1); });
  items.push({ label: '', disabled: true });
  items.push({ key: '0', label: '返回', desc: '', value: 'back' });
  const c = await selectMenu({ title: '删除凭据 / Provider', showSearch: true, items });
  if (!c || c.value === 'back') return false;
  const [kind, id] = [c.value.slice(0, c.value.indexOf(':')), c.value.slice(c.value.indexOf(':') + 1)];
  console.log(`\n${C.red}将删除 ${id}${kind === 'prov' ? ' 的 Provider 配置及其模型白名单 (默认模型使用中时会拒绝)' : ' 这条凭据'}，此操作不可撤销。${C.reset}`);
  if (!(await confirm({ prompt: '确认删除?', defaultYes: false }))) return false;
  const r = kind === 'auth' ? providers.removeAuth(id) : providers.removeProvider(id);
  if (r.ok) {
    console.log(`${C.green}✅ 已删除${C.reset}`);
    if (r.removedFallbacks && r.removedFallbacks.length) console.log(`${C.dim}   同时移除了备用模型: ${r.removedFallbacks.join(', ')}${C.reset}`);
    console.log('');
    return true;
  }
  console.log(`${C.red}❌ 删除失败: ${r.reason}${C.reset}\n`);
  return false;
}

async function launchWizard() {
  resetRenderCount();
  console.log(`\n${C.cyan}启动官方完整模型配置向导...${C.reset}\n`);
  console.log(`${C.yellow}提示: ↑↓ 移动, Tab/空格 选中, 回车 确认${C.reset}\n`);
  try {
    enableAuthPlugins();
    await ocCmd('configure', '--section', 'model');
    return true;
  } catch (e) {
    console.log(`${C.yellow}配置向导已退出${C.reset}\n`);
    return false;
  }
}

async function handleModelConfig() {
  while (true) {
    const choice = await showModelMenu();
    if (!choice || choice.value === 'back') break;
    resetRenderCount();
    let changed = false;
    try {
      if (choice.value === 'quick') {
        const ref = await pickQuickMethod();
        if (ref) changed = await configureMethod(ref);
      } else if (choice.value.startsWith('group:')) {
        const ref = await pickMethodFromGroup(choice.value.slice(6));
        if (ref) changed = await configureMethod(ref);
      } else if (choice.value === 'status') {
        await handleModelStatus();
      } else if (choice.value === 'set-default') {
        changed = await handleSetDefaultModel();
      } else if (choice.value === 'fallbacks') {
        changed = await handleFallbacks();
      } else if (choice.value === 'probe') {
        await handleProbe();
      } else if (choice.value === 'remove') {
        changed = await handleRemove();
      } else if (choice.value === 'wizard') {
        changed = await launchWizard();
      }
    } catch (e) {
      console.log(`${C.red}操作失败: ${e.message}${C.reset}\n`);
      await pause();
    }
    if (changed) await askRestart();
  }
}

// 主菜单「设置活动模型」入口与模型管理中的「切换默认模型」共用实现
async function handleSetActiveModel() {
  if (await handleSetDefaultModel()) await askRestart();
}

// ═══════════════════════════════════════════════════════════════════════════
// 消息渠道处理 (对应 configure_channels 等函数)
// ═══════════════════════════════════════════════════════════════════════════

async function handleChannels() {
  while (true) {
    const choice = await showChannelsMenu();
    if (!choice || choice.value === 'back') break;

    resetRenderCount();

    switch (choice.value) {
      case 'qq': {
        console.log(`\n${C.bold}QQ 机器人配置${C.reset}\n`);
        console.log(`${C.yellow}获取 App ID 和 App Secret:${C.reset}`);
        console.log(`  1. 前往 ${C.cyan}https://q.qq.com/qqbot/openclaw/login.html${C.reset}`);
        console.log(`  2. 用手机 QQ 扫码注册/登录`);
        console.log(`  3. 创建机器人后复制 App ID 和 App Secret\n`);

        const appId = await input({ prompt: '请输入 QQ 机器人 App ID', placeholder: '' });
        if (!appId) { console.log(`${C.yellow}已取消${C.reset}`); break; }

        const appSecret = await input({ prompt: '请输入 QQ 机器人 App Secret', placeholder: '' });
        if (!appSecret) { console.log(`${C.yellow}已取消${C.reset}`); break; }

        // 写入配置
        const cfg = readConfig();
        if (!cfg.channels) cfg.channels = {};
        if (!cfg.channels.qqbot) cfg.channels.qqbot = {};
        cfg.channels.qqbot.appId = appId;
        cfg.channels.qqbot.clientSecret = appSecret;
        cfg.channels.qqbot.enabled = true;
        writeConfig(cfg);

        console.log(`\n${C.green}✅ QQ 机器人配置已保存${C.reset}\n`);
        await askRestart();
        break;
      }
      case 'telegram': {
        console.log(`\n${C.bold}Telegram Bot 配置${C.reset}\n`);
        console.log(`${C.yellow}获取 Bot Token:${C.reset}`);
        console.log(`  1. 打开 Telegram → 搜索 ${C.cyan}@BotFather${C.reset}`);
        console.log(`  2. 发送 ${C.cyan}/newbot${C.reset} → 按提示创建`);
        console.log(`  3. 复制生成的 Token\n`);

        const token = await input({ prompt: '请输入 Telegram Bot Token', placeholder: '123456:ABC...' });
        if (!token) { console.log(`${C.yellow}已取消${C.reset}`); break; }

        // 验证格式
        if (!/^[0-9]+:[A-Za-z0-9_-]+$/.test(token)) {
          console.log(`${C.red}✗ Token 格式错误${C.reset}`);
          console.log(`${C.yellow}正确格式: 123456789:ABCdefGHIjklMNOpqr${C.reset}\n`);
          break;
        }

        const cfg = readConfig();
        if (!cfg.channels) cfg.channels = {};
        if (!cfg.channels.telegram) cfg.channels.telegram = {};
        cfg.channels.telegram.botToken = token;
        writeConfig(cfg);

        console.log(`\n${C.green}✅ Telegram Bot Token 已保存${C.reset}\n`);
        await askRestart();
        break;
      }
      case 'discord': {
        console.log(`\n${C.bold}Discord Bot 配置${C.reset}\n`);
        console.log(`${C.yellow}获取 Bot Token:${C.cyan} https://discord.com/developers/applications${C.reset}\n`);

        const token = await input({ prompt: '请输入 Discord Bot Token', placeholder: '' });
        if (!token) { console.log(`${C.yellow}已取消${C.reset}`); break; }

        const cfg = readConfig();
        if (!cfg.channels) cfg.channels = {};
        if (!cfg.channels.discord) cfg.channels.discord = {};
        cfg.channels.discord.token = token;
        delete cfg.channels.discord.botToken;
        writeConfig(cfg);

        console.log(`\n${C.green}✅ Discord Bot Token 已保存${C.reset}\n`);
        await askRestart();
        break;
      }
      case 'feishu': {
        console.log(`\n${C.bold}飞书 Bot 配置${C.reset}\n`);
        console.log(`${C.cyan}即将执行飞书官方安装向导...${C.reset}\n`);

        const doInstall = await confirm({ prompt: '是否开始安装?', defaultYes: true });
        if (!doInstall) break;

        console.log(`\n${C.cyan}正在启动飞书安装向导...${C.reset}\n`);
        try {
          const npxBin = fs.existsSync(`${NODE_BASE}/bin/npx`) ? `${NODE_BASE}/bin/npx` : 'npx';
          await runCommand(npxBin, ['-y', '@larksuite/openclaw-lark-tools', 'install'], {
            interactive: true,
            cwd: OC_DATA,
            env: { HOME: OC_DATA, PATH: `${NODE_BASE}/bin:${process.env.PATH || ''}` }
          });
        } catch (e) {
          console.log(`${C.yellow}安装向导已退出${C.reset}\n`);
        }
        break;
      }
      case 'slack': {
        console.log(`\n${C.bold}Slack Bot 配置${C.reset}\n`);
        console.log(`${C.yellow}获取 Bot Token:${C.cyan} https://api.slack.com/apps${C.reset}\n`);

        const token = await input({ prompt: '请输入 Slack Bot Token (xoxb-...)', placeholder: '' });
        if (!token) { console.log(`${C.yellow}已取消${C.reset}`); break; }

        const cfg = readConfig();
        if (!cfg.channels) cfg.channels = {};
        if (!cfg.channels.slack) cfg.channels.slack = {};
        cfg.channels.slack.botToken = token;
        writeConfig(cfg);

        console.log(`\n${C.green}✅ Slack Bot Token 已保存${C.reset}\n`);
        await askRestart();
        break;
      }
      case 'whatsapp': {
        const gwToken = jsonGet('gateway.auth.token') || '';
        const gwPort = jsonGet('gateway.port') || '18789';
        console.log(`\n${C.yellow}WhatsApp 需要通过 Web 控制台扫码配对:${C.reset}`);
        console.log(`${C.cyan}http://<你的路由器IP>:${gwPort}/?token=${gwToken}${C.reset}`);
        console.log(`打开后进入 Channels → WhatsApp 扫码即可。\n`);
        await input({ prompt: '按回车继续', defaultValue: '' });
        break;
      }
      case 'telegram-pairing': {
        // 配对 (pairing) 与 Bot Token 配置是两件不同的事:
        //   - Token 配置 -> 上面的 'telegram' 分支 / channels add --bot-token
        //   - 用户配对   -> openclaw pairing list / pairing approve
        // 旧实现调用的 `models auth login-telegram-bot` 在 2026.6+ 已不存在
        // (实测报 Too many arguments for this command)，这里改为对齐上游
        // pairing 命令，与 oc-config.sh 的 telegram_pairing() 行为保持一致。
        console.log(`\n${C.bold}🤝 Telegram 配对助手${C.reset}\n`);

        const tgToken = jsonGet('channels.telegram.botToken');
        if (!tgToken) {
          console.log(`${C.yellow}未检测到 Telegram Bot Token，请先在「Telegram」中配置 Token。${C.reset}\n`);
          await input({ prompt: '按回车返回', defaultValue: '' });
          break;
        }

        // 先确认 Token 与网络可用，避免用户在配对环节盲等
        console.log(`${C.cyan}诊断 Telegram API 连通性...${C.reset}`);
        let botName = '';
        try {
          const probe = execSync(
            `curl -s --connect-timeout 5 --max-time 10 "https://api.telegram.org/bot${tgToken}/getMe"`,
            { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
          );
          if (/"ok"\s*:\s*true/.test(probe)) {
            const m = probe.match(/"username"\s*:\s*"([^"]+)"/);
            botName = m ? m[1] : '';
            console.log(`${C.green}✅ Telegram API 连通正常${botName ? ` — @${botName}` : ''}${C.reset}`);
          } else {
            console.log(`${C.red}❌ Telegram API 连通检测未通过${C.reset}`);
            console.log(`${C.yellow}   可能原因: Token 不正确、网络不通 或 Telegram 被屏蔽${C.reset}`);
            console.log(`${C.cyan}   建议: 重新配置 Token 或检查代理/网络设置${C.reset}\n`);
            await input({ prompt: '按回车返回', defaultValue: '' });
            break;
          }
        } catch {
          console.log(`${C.yellow}⚠️  无法完成连通性检测，继续尝试配对${C.reset}`);
        }

        console.log('');
        console.log(`${C.green}请在 Telegram 中向 Bot 发送 /start，然后回到这里继续${C.reset}`);
        console.log('');
        const go = await input({ prompt: '发送 /start 后按回车继续 (输入 q 退出)', defaultValue: '' });
        if (String(go).toLowerCase() === 'q') break;

        const approveCode = (code) => {
          const res = ocCmdCapture('pairing', 'approve', 'telegram', code);
          return res.ok || /approved|success|ok/i.test(res.stdout);
        };

        let paired = false;
        for (let attempt = 1; attempt <= 3 && !paired; attempt++) {
          console.log(`${C.cyan}检测配对请求... (第 ${attempt}/3 轮)${C.reset}`);
          const listed = ocCmdCapture('pairing', 'list', 'telegram', '--json');
          const codes = parsePairingCodes(listed.stdout);

          for (const code of codes) {
            console.log(`${C.cyan}发现配对请求: ${code}${C.reset}`);
            if (approveCode(code)) {
              console.log(`\n${C.green}${C.bold}🎉 Telegram 配对成功！${C.reset}`);
              paired = true;
            } else {
              console.log(`${C.yellow}配对码 ${code} 处理失败${C.reset}`);
            }
          }

          if (!paired && attempt < 3) {
            console.log(`${C.yellow}未检测到，等待 8 秒后重试...${C.reset}`);
            await new Promise((r) => setTimeout(r, 8000));
          }
        }

        if (!paired) {
          console.log('');
          console.log(`${C.yellow}未自动检测到配对请求。${C.reset}`);
          console.log(`${C.cyan}如果 Bot 已回复配对码，可手动输入 (回车跳过):${C.reset}`);
          const manual = await input({ prompt: '配对码', defaultValue: '' });
          if (manual) {
            if (approveCode(String(manual).trim())) {
              console.log(`${C.green}${C.bold}🎉 Telegram 配对成功！${C.reset}`);
              paired = true;
            } else {
              console.log(`${C.yellow}配对失败，请确认配对码是否正确或重新发送 /start${C.reset}`);
            }
          }
        }

        if (paired) {
          console.log(`\n${C.cyan}正在重启 Gateway 使配对生效...${C.reset}`);
          await restartGateway();
          console.log(`${C.green}✅ 现在可以在 Telegram 中与 Bot 对话了！${C.reset}\n`);
        } else {
          console.log('');
          await input({ prompt: '按回车返回', defaultValue: '' });
        }
        break;
      }
      case 'wizard': {
        resetRenderCount();
        console.log(`\n${C.cyan}启动官方渠道配置向导...${C.reset}\n`);
        console.log(`${C.yellow}提示: ↑↓ 移动, Tab/空格 选中, 回车 确认${C.reset}\n`);
        let ok = false;
        try {
          enableAuthPlugins();
          await ocCmd('configure', '--section', 'channels');
          ok = true;
        } catch (e) {
          console.log(`${C.yellow}配置向导已退出${C.reset}\n`);
        }
        if (ok) await askRestart();
        break;
      }
    }
  }
}

// ═══════════════════════════════════════════════════════════════════════════
// 健康检查 (对应 health_check)
// ═══════════════════════════════════════════════════════════════════════════

async function handleHealthCheck() {
  resetRenderCount();
  console.log(`\n${C.bold}健康检查${C.reset}\n`);

  // 验证配置文件
  console.log(`${C.cyan}验证配置文件格式...${C.reset}`);
  try {
    const result = await ocCmd('config', 'validate', '--json');
    const validateData = JSON.parse(result.stdout);
    if (validateData.valid) {
      console.log(`${C.green}✅ 配置文件格式有效${C.reset}\n`);
    } else if (validateData.errors && validateData.errors.length > 0) {
      console.log(`${C.red}❌ 配置文件存在错误:${C.reset}`);
      validateData.errors.forEach(e => console.log(`   ${C.yellow}• ${e.message}${C.reset}`));
      console.log('');
    }
  } catch (e) {
    console.log(`${C.yellow}⚠️ 无法验证配置文件${C.reset}\n`);
  }

  // 检查端口
  console.log(`${C.cyan}检查服务状态...${C.reset}`);
  try {
    await runCommand('/etc/init.d/openclaw', ['status_service']);
  } catch (e) {}

  console.log(`\n${C.cyan}提示: 查看详细日志请运行 logread -e openclaw${C.reset}`);
  await input({ prompt: '按回车继续', defaultValue: '' });
}

// ═══════════════════════════════════════════════════════════════════════════
// 显示当前配置 (对应 show_current_config)
// ═══════════════════════════════════════════════════════════════════════════

async function handleShowConfig() {
  resetRenderCount();

  const gwPort = jsonGet('gateway.port') || '18789';
  const gwBind = jsonGet('gateway.bind') || 'lan';
  const gwMode = jsonGet('gateway.mode') || 'local';
  const currentModel = getCurrentModel();

  console.log(`\n${C.green}┌──────────────────────────────────────────────────────────┐${C.reset}`);
  console.log(`${C.green}│${C.reset}  📋 ${C.bold}当前配置概览${C.reset}`);
  console.log(`${C.green}├──────────────────────────────────────────────────────────┤${C.reset}`);
  console.log(`${C.green}│${C.reset}  网关端口 ............ ${C.cyan}${gwPort}${C.reset}`);
  console.log(`${C.green}│${C.reset}  绑定模式 ............ ${C.cyan}${gwBind}${C.reset}`);
  console.log(`${C.green}│${C.reset}  运行模式 ............ ${C.cyan}${gwMode}${C.reset}`);
  console.log(`${C.green}│${C.reset}  活跃模型 ............ ${currentModel ? C.cyan + currentModel : C.yellow + '未配置'}${C.reset}`);

  // 渠道状态
  console.log(`${C.green}├──────────────────────────────────────────────────────────┤${C.reset}`);
  console.log(`${C.green}│${C.reset}  ${C.bold}渠道配置状态${C.reset}`);

  const tgToken = jsonGet('channels.telegram.botToken');
  const dcToken = jsonGet('channels.discord.token') || jsonGet('channels.discord.botToken');
  const fsAppId = jsonGet('channels.feishu.appId');
  const skToken = jsonGet('channels.slack.botToken');
  const qqAppId = jsonGet('channels.qqbot.appId');

  if (qqAppId) {
    console.log(`${C.green}│${C.reset}  QQ (qqbot) ......... ${C.green}✅ 已配置${C.reset} (AppID: ${qqAppId.slice(0, 8)}...)`);
  } else {
    console.log(`${C.green}│${C.reset}  QQ (qqbot) ......... ${C.yellow}❌ 未配置${C.reset}`);
  }
  if (tgToken) {
    console.log(`${C.green}│${C.reset}  Telegram ........... ${C.green}✅ 已配置${C.reset} (${tgToken.slice(0, 12)}...)`);
  } else {
    console.log(`${C.green}│${C.reset}  Telegram ........... ${C.yellow}❌ 未配置${C.reset}`);
  }
  if (dcToken) {
    console.log(`${C.green}│${C.reset}  Discord ............ ${C.green}✅ 已配置${C.reset}`);
  } else {
    console.log(`${C.green}│${C.reset}  Discord ............ ${C.yellow}❌ 未配置${C.reset}`);
  }
  if (fsAppId) {
    console.log(`${C.green}│${C.reset}  飞书 ............... ${C.green}✅ 已配置${C.reset} (AppID: ${fsAppId.slice(0, 6)}...)`);
  } else {
    console.log(`${C.green}│${C.reset}  飞书 ............... ${C.yellow}❌ 未配置${C.reset}`);
  }
  if (skToken) {
    console.log(`${C.green}│${C.reset}  Slack .............. ${C.green}✅ 已配置${C.reset}`);
  } else {
    console.log(`${C.green}│${C.reset}  Slack .............. ${C.yellow}❌ 未配置${C.reset}`);
  }

  console.log(`${C.green}└──────────────────────────────────────────────────────────┘${C.reset}\n`);

  await input({ prompt: '按回车继续', defaultValue: '' });
}

// ═══════════════════════════════════════════════════════════════════════════
// 设备配对管理 (Control UI / 浏览器配对审批)
// ═══════════════════════════════════════════════════════════════════════════

async function manageDevicePairing() {
  while (true) {
    resetRenderCount();
    console.log(`\n${C.bold}📱 设备配对管理 (Control UI / 浏览器配对审批)${C.reset}\n`);
    console.log(`${C.yellow}⚠️  风险提示：${C.reset}`);
    console.log(`${C.yellow}   批准设备配对后，该浏览器/客户端将获得 OpenClaw 网关的完全控制权限。${C.reset}`);
    console.log(`${C.yellow}   请确保在受信任的局域网环境，并仅在您本人正在连接时批准！${C.reset}\n`);

    const listed = ocCmdCapture('devices', 'list', '--json');
    let pending = [];
    let paired = [];
    try {
      const data = JSON.parse(listed.stdout);
      if (Array.isArray(data.pending)) pending = data.pending;
      if (Array.isArray(data.paired)) paired = data.paired;
    } catch (e) {
      const m = (listed.stdout || '').match(/(\{[\s\S]*"pending"[\s\S]*\})/);
      if (m) {
        try {
          const d = JSON.parse(m[1]);
          if (Array.isArray(d.pending)) pending = d.pending;
          if (Array.isArray(d.paired)) paired = d.paired;
        } catch (_) {}
      }
    }

    function renderPairedDevices(list) {
      console.log(`\n${C.bold}📋 已配对设备 (${list.length})${C.reset}\n`);
      if (list.length === 0) {
        console.log(`  ${C.dim}暂无已配对设备记录${C.reset}`);
      } else {
        list.forEach((d, idx) => {
          console.log(`  ${C.cyan}[${idx + 1}]${C.reset} 设备 ID: ${d.deviceId || ''}`);
          console.log(`      平台: ${d.platform || '未知'} | 客户端: ${d.clientId || ''} | IP: ${d.remoteIp || ''}`);
        });
      }
      console.log('');
    }

    if (pending.length > 0) {
      console.log(`${C.green}🔔 当前检测到 ${pending.length} 个待配对请求：${C.reset}\n`);
      pending.forEach((item, idx) => {
        const rid = item.requestId || '未知ID';
        const ip = item.remoteIp || item.ip || '未知IP';
        const client = item.clientId || item.clientMode || 'webchat';
        const plat = item.platform || '';
        const role = item.role || (item.roles && item.roles.join(',')) || 'operator';
        console.log(`  ${C.cyan}[${idx + 1}]${C.reset} 请求 ID: ${C.bold}${rid}${C.reset}`);
        console.log(`      来源 IP: ${C.green}${ip}${C.reset} | 客户端: ${client}${plat ? ' (' + plat + ')' : ''} | 角色: ${role}`);
      });
      console.log('');

      const choice = await select({
        title: '请选择操作',
        showSearch: false,
        items: [
          { key: '1', label: '一键批准所有待配对请求', desc: `共 ${pending.length} 个待审批`, value: 'approve-all' },
          { key: '2', label: '选择指定请求批准', desc: '', value: 'approve-select' },
          { key: '3', label: '刷新待配对列表', desc: '', value: 'refresh' },
          { key: '4', label: '查看已配对设备列表', desc: `当前已配对 ${paired.length} 台设备`, value: 'view-paired' },
          { label: '', disabled: true },
          { key: '0', label: '返回上级菜单', desc: '', value: 'back' },
        ],
      });

      if (!choice || choice.value === 'back') break;
      if (choice.value === 'refresh') continue;
      if (choice.value === 'view-paired') {
        renderPairedDevices(paired);
        await input({ prompt: '按回车继续', defaultValue: '' });
        continue;
      }

      if (choice.value === 'approve-all') {
        const ok = await confirm({
          message: `${C.yellow}确认一键批准全部 ${pending.length} 个设备配对请求吗？${C.reset}`,
          defaultValue: true,
        });
        if (ok) {
          console.log(`\n${C.cyan}正在批准设备配对...${C.reset}`);
          let success = 0;
          for (const item of pending) {
            const res = ocCmdCapture('devices', 'approve', item.requestId);
            if (res.ok || /approved|success/i.test(res.stdout)) {
              console.log(`${C.green}✅ 已批准: ${item.requestId} (${item.remoteIp || ''})${C.reset}`);
              success++;
            } else {
              console.log(`${C.red}❌ 批准失败: ${item.requestId} — ${res.stdout || res.stderr}${C.reset}`);
            }
          }
          fixStatePermissions();
          console.log(`\n${C.green}操作完成：成功 ${success}/${pending.length} 个${C.reset}`);
          await input({ prompt: '按回车继续', defaultValue: '' });
        }
      } else if (choice.value === 'approve-select') {
        const selectItems = pending.map((item, idx) => ({
          key: String(idx + 1),
          label: `批准: ${item.remoteIp || '设备'} (${(item.requestId || '').slice(0, 8)}...)`,
          desc: `IP: ${item.remoteIp || ''} | ${item.platform || ''}`,
          value: item.requestId,
        }));
        selectItems.push({ label: '', disabled: true });
        selectItems.push({ key: '0', label: '取消', desc: '', value: 'cancel' });

        const picked = await select({
          title: '请选择要批准的设备请求',
          showSearch: false,
          items: selectItems,
        });

        if (picked && picked.value !== 'cancel') {
          const res = ocCmdCapture('devices', 'approve', picked.value);
          if (res.ok || /approved|success/i.test(res.stdout)) {
            fixStatePermissions();
            console.log(`\n${C.green}✅ 成功批准设备请求: ${picked.value}${C.reset}`);
          } else {
            console.log(`\n${C.red}❌ 批准失败: ${res.stdout || res.stderr}${C.reset}`);
          }
          await input({ prompt: '按回车继续', defaultValue: '' });
        }
      }
    } else {
      console.log(`${C.dim}当前无待配对设备请求。${C.reset}`);
      console.log(`${C.dim}(在浏览器访问 OpenClaw Web 控制台时若提示「需要设备配对」，在此处刷新即可发现)${C.reset}\n`);

      const choice = await select({
        title: '设备配对管理',
        showSearch: false,
        items: [
          { key: '1', label: '刷新待配对列表', desc: '', value: 'refresh' },
          { key: '2', label: '手动输入 Request ID 批准', desc: '', value: 'manual' },
          { key: '3', label: '查看已配对设备列表', desc: `当前已配对 ${paired.length} 台设备`, value: 'view-paired' },
          { label: '', disabled: true },
          { key: '0', label: '返回上级菜单', desc: '', value: 'back' },
        ],
      });

      if (!choice || choice.value === 'back') break;
      if (choice.value === 'refresh') continue;

      if (choice.value === 'manual') {
        const reqId = await input({ prompt: '请输入待批准的 Request ID', defaultValue: '' });
        if (reqId && reqId.trim()) {
          const res = ocCmdCapture('devices', 'approve', reqId.trim());
          if (res.ok || /approved|success/i.test(res.stdout)) {
            fixStatePermissions();
            console.log(`\n${C.green}✅ 成功批准设备请求: ${reqId.trim()}${C.reset}`);
          } else {
            console.log(`\n${C.red}❌ 批准失败: ${res.stdout || res.stderr}${C.reset}`);
          }
          await input({ prompt: '按回车继续', defaultValue: '' });
        }
      } else if (choice.value === 'view-paired') {
        renderPairedDevices(paired);
        await input({ prompt: '按回车继续', defaultValue: '' });
      }
    }
  }
}

// ═══════════════════════════════════════════════════════════════════════════
// 高级配置处理 (对应 advanced_menu)
// ═══════════════════════════════════════════════════════════════════════════

async function handleAdvancedConfig() {
  while (true) {
    const choice = await showAdvancedMenu();
    if (!choice || choice.value === 'back') break;

    resetRenderCount();

    switch (choice.value) {
      case 'port': {
        const newPort = await input({
          prompt: '请输入 Gateway 端口',
          defaultValue: String(jsonGet('gateway.port') || '18789'),
        });
        if (newPort) {
          jsonSet('gateway.port', parseInt(newPort));
          try { execSync(`uci set openclaw.main.port="${newPort}" && uci commit openclaw`, { stdio: 'ignore' }); } catch {}
          console.log(`\n${C.green}✅ 端口已设置为 ${newPort}${C.reset}\n`);
          await askRestart();
        }
        break;
      }
      case 'bind': {
        const bindChoice = await select({
          title: '绑定地址选项',
          showSearch: false,
          items: [
            // 取值必须与 schema 的 gateway.bind 枚举一致:
            // auto/lan/loopback/custom/tailnet。旧选项 all 不被上游接受
            // (实测: gateway.bind: Invalid input)，监听所有接口用 custom。
            { key: '1', label: 'lan', desc: '仅 LAN 接口 (推荐)', value: 'lan' },
            { key: '2', label: 'loopback', desc: '仅本机访问', value: 'loopback' },
            { key: '3', label: 'auto', desc: '自动选择', value: 'auto' },
            { key: '4', label: 'custom', desc: '自定义地址 (0.0.0.0 = 所有接口)', value: 'custom' },
            { key: '5', label: 'tailnet', desc: 'Tailscale 网络', value: 'tailnet' },
          ],
        });
        if (bindChoice) {
          if (bindChoice.value === 'custom') {
            const host = await input({ prompt: '监听地址', defaultValue: jsonGet('gateway.customBindHost') || '0.0.0.0' });
            if (host) jsonSet('gateway.customBindHost', host);
          }
          jsonSet('gateway.bind', bindChoice.value);
          try { execSync(`uci set openclaw.main.bind="${bindChoice.value}" && uci commit openclaw`, { stdio: 'ignore' }); } catch {}
          console.log(`\n${C.green}✅ 绑定地址已设置为 ${bindChoice.value}${C.reset}\n`);
          await askRestart();
        }
        break;
      }
      case 'mode': {
        const modeChoice = await select({
          title: '运行模式选项',
          showSearch: false,
          items: [
            { key: '1', label: 'local', desc: '本地模式 (推荐)', value: 'local' },
            { key: '2', label: 'remote', desc: '远程模式', value: 'remote' },
          ],
        });
        if (modeChoice) {
          jsonSet('gateway.mode', modeChoice.value);
          console.log(`\n${C.green}✅ 运行模式已设置为 ${modeChoice.value}${C.reset}\n`);
          await askRestart();
        }
        break;
      }
      case 'loglevel': {
        const levelChoice = await select({
          title: '日志级别选项',
          showSearch: false,
          items: [
            // 取值与 schema 的 logging.level 枚举一致 (7 档)
            { key: '1', label: 'info', desc: '常规信息 (默认)', value: 'info' },
            { key: '2', label: 'warn', desc: '警告及以上', value: 'warn' },
            { key: '3', label: 'error', desc: '仅错误', value: 'error' },
            { key: '4', label: 'debug', desc: '详细调试', value: 'debug' },
            { key: '5', label: 'trace', desc: '最详细 (排障用)', value: 'trace' },
            { key: '6', label: 'fatal', desc: '仅致命错误', value: 'fatal' },
            { key: '7', label: 'silent', desc: '完全静默', value: 'silent' },
          ],
        });
        if (levelChoice) {
          // 正确键是顶层 logging.level；gateway.logLevel 不在 schema 中，
          // 写入会被上游忽略，表现为"显示已设置但从未生效"。
          jsonSet('logging.level', levelChoice.value);
          // 清理旧配置里可能残留的错误键，避免界面回显到失效值
          try {
            const cfg = readConfig();
            if (cfg.gateway && Object.prototype.hasOwnProperty.call(cfg.gateway, 'logLevel')) {
              delete cfg.gateway.logLevel;
              writeConfig(cfg);
            }
          } catch {}
          console.log(`\n${C.green}✅ 日志级别已设置为 ${levelChoice.value}${C.reset}\n`);
          await askRestart();
        }
        break;
      }
      case 'acp': {
        const acpChoice = await select({
          title: 'ACP Dispatch 选项',
          showSearch: false,
          items: [
            { key: '1', label: 'false', desc: '禁用 (推荐路由器使用)', value: 'false' },
            { key: '2', label: 'true', desc: '启用 (可能占用大量内存)', value: 'true' },
          ],
        });
        if (acpChoice) {
          jsonSet('acp.dispatch.enabled', acpChoice.value === 'true');
          console.log(`\n${C.green}✅ ACP Dispatch 已设置为 ${acpChoice.value}${C.reset}\n`);
          await askRestart();
        }
        break;
      }
      case 'wizard': {
        resetRenderCount();
        console.log(`\n${C.cyan}启动官方配置向导...${C.reset}\n`);
        console.log(`${C.yellow}提示: ↑↓ 移动, Tab/空格 选中, 回车 确认${C.reset}\n`);
        let ok = false;
        try {
          enableAuthPlugins();
          await ocCmd('configure');
          ok = true;
        } catch (e) {
          console.log(`${C.yellow}配置向导已退出${C.reset}\n`);
        }
        if (ok) await askRestart();
        break;
      }
      case 'view-json':
        console.log(`\n${C.cyan}配置文件路径: ${CONFIG_FILE}${C.reset}\n`);
        try {
          const content = fs.readFileSync(CONFIG_FILE, 'utf8');
          console.log(content);
        } catch (e) {
          console.log(`${C.red}无法读取配置文件${C.reset}`);
        }
        await input({ prompt: '按回车继续', defaultValue: '' });
        break;
      case 'edit':
        console.log(`\n${C.yellow}请在 SSH 终端中手动编辑配置文件:${C.reset}`);
        console.log(`  vi ${CONFIG_FILE}\n`);
        await input({ prompt: '按回车继续', defaultValue: '' });
        break;
      case 'backup':
        await handleBackup();
        break;
      case 'import': {
        const importPath = await input({
          prompt: '请输入备份文件路径',
          defaultValue: '',
        });
        if (importPath && fs.existsSync(importPath)) {
          try {
            fs.copyFileSync(importPath, CONFIG_FILE);
            execSync(`chown openclaw:openclaw "${CONFIG_FILE}" 2>/dev/null || true`, { stdio: 'ignore' });
            fixStatePermissions();
            console.log(`\n${C.green}✅ 配置已导入${C.reset}\n`);
            await askRestart();
          } catch (e) {
            console.log(`${C.red}导入失败: ${e.message}${C.reset}\n`);
          }
        } else {
          console.log(`${C.yellow}文件不存在${C.reset}\n`);
        }
        break;
      }
      case 'devices':
        await manageDevicePairing();
        break;
    }
  }
}

// ═══════════════════════════════════════════════════════════════════════════
// 重置配置处理 (对应 reset_to_defaults)
// ═══════════════════════════════════════════════════════════════════════════

async function handleReset() {
  while (true) {
    const choice = await showResetMenu();
    if (!choice || choice.value === 'back') break;

    resetRenderCount();

    switch (choice.value) {
      case 'gateway': {
        console.log(`\n${C.yellow}将重置: 网关端口→18789, 绑定→lan, 模式→local${C.reset}`);
        console.log(`${C.yellow}保留: 认证令牌、模型配置、消息渠道${C.reset}\n`);
        const ok = await confirm({ prompt: '确认恢复网关默认设置?', defaultYes: false });
        if (ok) {
          jsonSet('gateway.port', 18789);
          jsonSet('gateway.bind', 'lan');
          jsonSet('gateway.mode', 'local');
          jsonSet('gateway.controlUi.dangerouslyAllowHostHeaderOriginFallback', true);
          jsonSet('gateway.tailscale.mode', 'off');
          console.log(`\n${C.green}✅ 网关设置已恢复默认${C.reset}\n`);
          await askRestart();
        }
        break;
      }
      case 'models': {
        console.log(`\n${C.red}⚠️  将清除: 所有模型配置、API Key、活跃模型设置${C.reset}\n`);
        const ok = await confirm({ prompt: '确认清除所有模型配置?', defaultYes: false });
        if (ok) {
          // 凭据保存在上游认证库 (state/openclaw.sqlite)，通过官方 logout 逐条注销；
          // auth-profiles.json 已在 2026.9.x 退役，不再读写
          const failed = [];
          for (const p of providers.status().profiles) {
            const r = providers.removeAuth(p.id);
            if (!r.ok) failed.push(`${p.id}: ${r.reason}`);
          }
          const cfg = readConfig();
          delete cfg.models;
          if (cfg.agents?.defaults?.model) delete cfg.agents.defaults.model;
          if (cfg.agents?.defaults?.models) delete cfg.agents.defaults.models;
          writeConfig(cfg);
          if (failed.length) {
            console.log(`\n${C.yellow}以下凭据未能注销:${C.reset}`);
            failed.forEach((f) => console.log(`  ${C.yellow}• ${f}${C.reset}`));
          }
          console.log(`\n${C.green}✅ 模型配置已清除${C.reset}`);
          console.log(`${C.yellow}请通过菜单 [1] 重新配置 AI 模型${C.reset}\n`);
          await askRestart();
        }
        break;
      }
      case 'channels': {
        console.log(`\n${C.red}⚠️  将清除: 所有消息渠道配置 (Telegram/Discord/飞书等)${C.reset}\n`);
        const ok = await confirm({ prompt: '确认清除所有渠道配置?', defaultYes: false });
        if (ok) {
          const cfg = readConfig();
          delete cfg.channels;
          writeConfig(cfg);
          console.log(`\n${C.green}✅ 渠道配置已清除${C.reset}\n`);
          await askRestart();
        }
        break;
      }
      case 'full': {
        console.log(`\n${C.red}╔══════════════════════════════════════════════════════╗${C.reset}`);
        console.log(`${C.red}║  ⚠️  完全恢复出厂设置                               ║${C.reset}`);
        console.log(`${C.red}║  此操作将删除所有配置并重新初始化                    ║${C.reset}`);
        console.log(`${C.red}╚══════════════════════════════════════════════════════╝${C.reset}\n`);

        const confirmStr = await input({ prompt: '输入 RESET 确认恢复出厂设置', defaultValue: '' });
        if (confirmStr !== 'RESET') {
          console.log(`${C.cyan}已取消${C.reset}\n`);
          break;
        }

        // 执行恢复
        console.log(`\n${C.cyan}[1/5] 停止 Gateway...${C.reset}`);
        try { await runCommand('/etc/init.d/openclaw', ['stop']); } catch {}

        console.log(`${C.cyan}[2/5] 备份当前配置...${C.reset}`);
        const backupDir = `${OC_STATE_DIR}/backups`;
        const backupTs = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
        try {
          if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true }); try { execSync(`chown openclaw:openclaw "${backupDir}"`, { stdio: "ignore" }); } catch {}
          fs.copyFileSync(CONFIG_FILE, `${backupDir}/openclaw_${backupTs}.json`);
          console.log(`${C.green}   备份已保存: backups/openclaw_${backupTs}.json${C.reset}`);
        } catch {}

        console.log(`${C.cyan}[3/5] 重置配置...${C.reset}`);
        writeConfig({});

        console.log(`${C.cyan}[4/5] 重新初始化...${C.reset}`);
        // 生成新 token
        const crypto = require('crypto');
        const newToken = crypto.randomBytes(24).toString('hex');

        console.log(`${C.cyan}[5/5] 应用 OpenWrt 适配配置...${C.reset}`);
        jsonSet('gateway.port', 18789);
        jsonSet('gateway.bind', 'lan');
        jsonSet('gateway.mode', 'local');
        jsonSet('gateway.auth.mode', 'token');
        jsonSet('gateway.auth.token', newToken);
        jsonSet('gateway.controlUi.dangerouslyAllowHostHeaderOriginFallback', true);
        jsonSet('gateway.tailscale.mode', 'off');
        jsonSet('acp.dispatch.enabled', false);
        jsonSet('tools.profile', 'coding');

        try { execSync(`uci set openclaw.main.token="${newToken}" && uci commit openclaw`, { stdio: 'ignore' }); } catch {}

        console.log(`\n${C.green}✅ 出厂设置已恢复！${C.reset}\n`);
        console.log(`${C.cyan}新认证令牌: ${newToken}${C.reset}\n`);

        await restartGateway();
        break;
      }
    }
  }
}

// ═══════════════════════════════════════════════════════════════════════════
// 备份/还原处理 (对应 backup_restore_menu)
// ═══════════════════════════════════════════════════════════════════════════

async function handleBackup() {
  while (true) {
    const choice = await showBackupMenu();
    if (!choice || choice.value === 'back') break;

    resetRenderCount();
    const backupDir = `${OC_STATE_DIR}/backups`;
    try { if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true }); try { execSync(`chown openclaw:openclaw "${backupDir}"`, { stdio: "ignore" }); } catch {} } catch {}

    switch (choice.value) {
      case 'create-config': {
        console.log(`\n${C.cyan}正在创建配置备份...${C.reset}`);
        try {
          await ocCmd('backup', 'create', '--only-config', '--no-include-workspace');
          console.log(`${C.green}✅ 配置备份已创建${C.reset}\n`);
        } catch (e) {
          console.log(`${C.yellow}⚠️ 备份功能需要 OpenClaw v2026.3.8+${C.reset}\n`);
        }
        await input({ prompt: '按回车继续', defaultValue: '' });
        break;
      }
      case 'create-full': {
        console.log(`\n${C.cyan}正在创建完整备份...${C.reset}`);
        try {
          await ocCmd('backup', 'create', '--no-include-workspace');
          console.log(`${C.green}✅ 完整备份已创建${C.reset}\n`);
        } catch (e) {
          console.log(`${C.yellow}⚠️ 备份失败${C.reset}\n`);
        }
        await input({ prompt: '按回车继续', defaultValue: '' });
        break;
      }
      case 'verify': {
        const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.tar.gz')).sort().reverse();
        if (files.length === 0) {
          console.log(`${C.yellow}未找到备份文件${C.reset}\n`);
        } else {
          const latest = `${backupDir}/${files[0]}`;
          console.log(`${C.cyan}验证备份: ${latest}${C.reset}`);
          try {
            await ocCmd('backup', 'verify', latest);
          } catch {}
        }
        await input({ prompt: '按回车继续', defaultValue: '' });
        break;
      }
      case 'list': {
        const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.tar.gz') || f.endsWith('.json')).sort().reverse();
        if (files.length === 0) {
          console.log(`${C.yellow}暂无备份文件${C.reset}\n`);
        } else {
          console.log(`\n${C.bold}备份文件列表:${C.reset}`);
          files.slice(0, 10).forEach(f => {
            const stat = fs.statSync(`${backupDir}/${f}`);
            console.log(`  ${C.dim}${f} (${(stat.size / 1024).toFixed(1)} KB)${C.reset}`);
          });
          console.log(`${C.dim}\n备份目录: ${backupDir}${C.reset}\n`);
        }
        await input({ prompt: '按回车继续', defaultValue: '' });
        break;
      }
      case 'restore': {
        const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.json')).sort().reverse();
        if (files.length === 0) {
          console.log(`${C.yellow}未找到配置备份文件${C.reset}\n`);
          await input({ prompt: '按回车继续', defaultValue: '' });
          break;
        }

        const fileChoice = await select({
          title: '选择备份文件',
          showSearch: false,
          items: files.slice(0, 10).map((f, i) => ({
            key: String(i + 1),
            label: f,
            desc: '',
            value: f,
          })),
        });

        if (!fileChoice) break;

        const ok = await confirm({ prompt: '确认恢复此备份?', defaultYes: false });
        if (ok) {
          try {
            fs.copyFileSync(`${backupDir}/${fileChoice.value}`, CONFIG_FILE);
            console.log(`\n${C.green}✅ 配置已恢复${C.reset}\n`);
            await askRestart();
          } catch (e) {
            console.log(`${C.red}恢复失败: ${e.message}${C.reset}\n`);
          }
        }
        break;
      }
    }
  }
}

// ═══════════════════════════════════════════════════════════════════════════
// 主函数
// ═══════════════════════════════════════════════════════════════════════════

async function main() {
  const command = process.argv[2];

  if (command === 'model') {
    await handleModelConfig();
    return;
  }

  if (command === 'status') {
    await runCommand('/etc/init.d/openclaw', ['status_service']);
    return;
  }

  if (command === 'restart') {
    const ok = await confirm({ prompt: '确认重启 OpenClaw 服务?' });
    if (ok) await runCommand('/etc/init.d/openclaw', ['restart']);
    return;
  }

  // 交互式主菜单
  while (true) {
    const choice = await showMainMenu();

    if (!choice || choice.value === 'quit') {
      console.log(`\n${C.green}再见！${C.reset}\n`);
      break;
    }

    switch (choice.value) {
      case 'model':
        await handleModelConfig();
        break;
      case 'set-active-model':
        await handleSetActiveModel();
        break;
      case 'channels':
        await handleChannels();
        break;
      case 'health':
        await handleHealthCheck();
        break;
      case 'logs':
        resetRenderCount();
        console.log(`\n${C.cyan}=== OpenClaw 日志 ===${C.reset}\n`);
        await runCommand('logread', ['-e', 'openclaw']);
        console.log('');
        await input({ prompt: '按回车继续', defaultValue: '' });
        break;
      case 'restart':
        resetRenderCount();
        await restartGateway();
        break;
      case 'devices':
        await manageDevicePairing();
        break;
      case 'advanced':
        await handleAdvancedConfig();
        break;
      case 'reset':
        await handleReset();
        break;
      case 'show-config':
        await handleShowConfig();
        break;
      case 'backup':
        await handleBackup();
        break;
    }
  }
}

// 菜单引擎读过 stdin 后它仍处于 flowing 状态，不暂停的话进程不会退出，Web 终端会停在「再见」
main().then(() => process.stdin.pause()).catch(e => {
  if (e instanceof ConfigParseError) {
    // 配置损坏: 给出可直接执行的恢复步骤，而不是丢一句解析错误了事
    console.error(`\n${C.red}配置读取失败:${C.reset} ${e.message}\n`);
    console.error(configRecoveryHint());
    console.error('');
    process.exit(2);
  }
  console.error(`${C.red}错误:${C.reset}`, e.message);
  process.exit(1);
});