coding-tool-x 3.2.0

package/src/commands/toggle-proxy.js

@@ -0,0 +1,247 @@
+// 动态切换开关命令
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { loadConfig } = require('../config/loader');
+const SETTINGS_MANAGERS = {
+  claude: () => require('../server/services/settings-manager'),
+  codex: () => require('../server/services/codex-settings-manager'),
+  gemini: () => require('../server/services/gemini-settings-manager'),
+  opencode: () => require('../server/services/opencode-settings-manager')
+};
+
+/**
+ * 获取当前类型的代理服务
+ */
+function getProxyServices(cliType) {
+  if (cliType === 'claude') {
+    const { getProxyStatus, startProxyServer, stopProxyServer } = require('../server/proxy-server');
+    return { getProxyStatus, startProxyServer, stopProxyServer, defaultPort: 20088 };
+  } else if (cliType === 'codex') {
+    const { getCodexProxyStatus, startCodexProxyServer, stopCodexProxyServer } = require('../server/codex-proxy-server');
+    return {
+      getProxyStatus: getCodexProxyStatus,
+      startProxyServer: startCodexProxyServer,
+      stopProxyServer: stopCodexProxyServer,
+      defaultPort: 20089
+    };
+  } else if (cliType === 'gemini') {
+    const { getGeminiProxyStatus, startGeminiProxyServer, stopGeminiProxyServer } = require('../server/gemini-proxy-server');
+    return {
+      getProxyStatus: getGeminiProxyStatus,
+      startProxyServer: startGeminiProxyServer,
+      stopProxyServer: stopGeminiProxyServer,
+      defaultPort: 20090
+    };
+  } else if (cliType === 'opencode') {
+    const { getOpenCodeProxyStatus, startOpenCodeProxyServer, stopOpenCodeProxyServer } = require('../server/opencode-proxy-server');
+    return {
+      getProxyStatus: getOpenCodeProxyStatus,
+      startProxyServer: startOpenCodeProxyServer,
+      stopProxyServer: stopOpenCodeProxyServer,
+      defaultPort: 20091
+    };
+  }
+}
+
+function getSettingsManager(cliType) {
+  const loader = SETTINGS_MANAGERS[cliType] || SETTINGS_MANAGERS.claude;
+  const manager = loader();
+  return {
+    setProxyConfig: manager.setProxyConfig,
+    restoreSettings: manager.restoreSettings,
+    hasBackup: manager.hasBackup
+  };
+}
+
+/**
+ * 切换动态切换功能
+ */
+async function handleToggleProxy() {
+  const config = loadConfig();
+  const cliType = config.currentCliType || 'claude';
+  const services = getProxyServices(cliType);
+  if (!services) {
+    console.log(chalk.red(`\n❌ 当前 CLI 类型 (${cliType}) 暂不支持动态切换\n`));
+    return;
+  }
+
+  const proxyStatus = services.getProxyStatus();
+
+  if (proxyStatus.running) {
+    // 当前代理正在运行，提示关闭
+    await handleStopProxy(cliType, services);
+  } else {
+    // 当前代理未运行，提示开启
+    await handleStartProxy(cliType, services);
+  }
+}
+
+/**
+ * 开启动态切换
+ */
+async function handleStartProxy(cliType, services) {
+  console.clear();
+  console.log(chalk.bold.cyan('\n╔═══════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║        开启动态切换        ║'));
+  console.log(chalk.bold.cyan('╚═══════════════════════════════════════╝\n'));
+
+  const toolNameMap = {
+    claude: 'Claude Code',
+    codex: 'Codex',
+    gemini: 'Gemini',
+    opencode: 'OpenCode'
+  };
+  const toolName = toolNameMap[cliType] || 'Claude Code';
+  const defaultPort = services.defaultPort;
+
+  console.log(chalk.cyan('动态切换功能说明:'));
+  console.log(chalk.gray('• 开启后会在本地启动一个代理服务'));
+  console.log(chalk.gray(`• 可以在不重启 ${toolName} 的情况下动态管理渠道`));
+  console.log(chalk.gray('• 通过 Web UI 或"渠道管理"功能快速调整启用的线路'));
+  console.log(chalk.gray(`• 代理服务地址: http://127.0.0.1:${defaultPort}\n`));
+
+  console.log(chalk.yellow('⚠️  重要提示:'));
+  console.log(chalk.yellow('• 开启期间请勿关闭 CLI 终端窗口'));
+  console.log(chalk.yellow('• 如果异常关闭导致代理失效，请运行: ctx reset'));
+  console.log(chalk.yellow('• 或使用主菜单的"恢复默认配置"功能\n'));
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: '是否开启动态切换？',
+      default: true,
+    },
+  ]);
+
+  if (!confirm) {
+    console.log(chalk.gray('\n已取消\n'));
+    return;
+  }
+
+  try {
+    console.log(chalk.cyan('\n🚀 正在启动代理服务...\n'));
+
+    // 启动代理服务器
+    const proxyResult = await services.startProxyServer();
+
+    if (!proxyResult.success) {
+      throw new Error('代理服务器启动失败');
+    }
+
+    console.log(chalk.green(`✅ 代理服务已启动: http://127.0.0.1:${proxyResult.port}`));
+
+    // 修改配置文件
+    const settingsManager = getSettingsManager(cliType);
+    settingsManager.setProxyConfig(proxyResult.port);
+    console.log(chalk.green('✅ 配置文件已更新'));
+
+    if (settingsManager.hasBackup()) {
+      console.log(chalk.green('✅ 原配置已备份'));
+    }
+
+    console.log(chalk.cyan('\n💡 动态切换已启用！'));
+    console.log(chalk.gray(`   现在可以通过"渠道管理"功能快速调整，无需重启 ${toolName}\n`));
+
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: '按回车继续...',
+      },
+    ]);
+  } catch (error) {
+    console.log(chalk.red(`\n❌ 启动失败: ${error.message}\n`));
+
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: '按回车继续...',
+      },
+    ]);
+  }
+}
+
+/**
+ * 关闭动态切换
+ */
+async function handleStopProxy(cliType, services) {
+  console.clear();
+  console.log(chalk.bold.cyan('\n╔═══════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║        关闭动态切换        ║'));
+  console.log(chalk.bold.cyan('╚═══════════════════════════════════════╝\n'));
+
+  const toolNameMap = {
+    claude: 'Claude Code',
+    codex: 'Codex',
+    gemini: 'Gemini',
+    opencode: 'OpenCode'
+  };
+  const toolName = toolNameMap[cliType] || 'Claude Code';
+  const proxyStatus = services.getProxyStatus();
+
+  console.log(chalk.cyan('当前状态:'));
+  console.log(chalk.gray(`• 代理服务: ${chalk.green('运行中')}`));
+  console.log(chalk.gray(`• 代理端口: ${proxyStatus.port}`));
+  console.log(chalk.gray(`• 代理地址: http://127.0.0.1:${proxyStatus.port}\n`));
+
+  console.log(chalk.yellow('关闭后:'));
+  console.log(chalk.gray('• 代理服务将被停止'));
+  console.log(chalk.gray('• 配置将恢复到关闭前的状态'));
+  console.log(chalk.gray(`• 之后管理渠道将需要重启 ${toolName}\n`));
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: '是否关闭动态切换？',
+      default: false,
+    },
+  ]);
+
+  if (!confirm) {
+    console.log(chalk.gray('\n已取消\n'));
+    return;
+  }
+
+  try {
+    console.log(chalk.cyan('\n⏹️  正在停止代理服务...\n'));
+
+    // 停止代理服务器
+    await services.stopProxyServer();
+    console.log(chalk.green('✅ 代理服务已停止'));
+
+    // 恢复配置文件
+    const settingsManager = getSettingsManager(cliType);
+    if (settingsManager.hasBackup()) {
+      settingsManager.restoreSettings();
+      console.log(chalk.green('✅ 配置文件已恢复'));
+    }
+
+    console.log(chalk.cyan('\n💡 动态切换已关闭'));
+    console.log(chalk.gray(`   现在调整渠道需要重启 ${toolName} 才能生效\n`));
+
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: '按回车继续...',
+      },
+    ]);
+  } catch (error) {
+    console.log(chalk.red(`\n❌ 停止失败: ${error.message}\n`));
+
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: '按回车继续...',
+      },
+    ]);
+  }
+}
+
+module.exports = {
+  handleToggleProxy,
+};

package/src/commands/ui.js

@@ -0,0 +1,99 @@
+const chalk = require('chalk');
+const { startServer } = require('../server');
+const open = require('open');
+const { getProxyStatus } = require('../server/proxy-server');
+const { loadConfig } = require('../config/loader');
+
+async function handleUI() {
+  // 检查是否为 daemon 模式（PM2 启动）
+  const isDaemon = process.argv.includes('--daemon');
+
+  // 检查是否启用 LAN 访问 (--host 标志)
+  const enableHost = process.argv.includes('--host');
+  const host = enableHost ? '0.0.0.0' : '127.0.0.1';
+
+  if (!isDaemon) {
+    console.clear();
+    console.log(chalk.cyan.bold('\n🌐 启动 Coding-Tool Web UI...\n'));
+    if (enableHost) {
+      console.log(chalk.yellow('⚠️  LAN 访问已启用 (--host)\n'));
+    }
+  }
+
+  // 从配置加载端口
+  const config = loadConfig();
+  const port = config.ports?.webUI || 19999;
+  const url = `http://localhost:${port}`;
+
+  try {
+    await startServer(port, host);
+
+    // 自动打开浏览器（仅非 daemon 模式）
+    if (!isDaemon) {
+      setTimeout(async () => {
+        try {
+          await open(url);
+          console.log(chalk.green(`✅ 已在浏览器中打开: ${url}\n`));
+        } catch (err) {
+          console.log(chalk.yellow(`💡 请手动打开: ${url}\n`));
+        }
+      }, 1000);
+    }
+
+    // 处理退出信号（仅非 daemon 模式）
+    if (!isDaemon) {
+      process.on('SIGINT', async () => {
+        console.log(chalk.yellow('\n\n👋 正在停止服务器...\n'));
+
+      // 检查代理状态并询问是否停止
+      try {
+        const proxyStatus = getProxyStatus();
+        if (proxyStatus.running) {
+          console.log(chalk.yellow('⚠️  检测到代理服务正在运行'));
+          console.log(chalk.gray('   - 代理端口: ' + proxyStatus.port));
+          console.log(chalk.gray('   - 如需保持代理运行，请直接关闭此窗口\n'));
+
+          // 自动停止代理（3秒后）
+          console.log(chalk.cyan('⏳ 将在 3 秒后自动停止代理服务...'));
+          console.log(chalk.gray('   按 Ctrl+C 再次可立即退出并保持代理运行\n'));
+
+          let stopProxy = true;
+          const secondSigint = () => {
+            stopProxy = false;
+            process.off('SIGINT', secondSigint);
+          };
+          process.on('SIGINT', secondSigint);
+
+          await new Promise(resolve => setTimeout(resolve, 3000));
+          process.off('SIGINT', secondSigint);
+
+          if (stopProxy) {
+            const { stopProxyServer } = require('../server/proxy-server');
+            await stopProxyServer();
+            console.log(chalk.green('✅ 代理服务已停止\n'));
+          } else {
+            console.log(chalk.yellow('⚠️  代理服务保持运行状态'));
+            console.log(chalk.gray('   - 如需停止，请运行: ctx proxy stop\n'));
+          }
+        }
+      } catch (err) {
+        // 忽略错误
+      }
+
+      console.log(chalk.green('✅ Web UI 已停止\n'));
+      process.exit(0);
+    });
+
+      console.log(chalk.gray('按 Ctrl+C 停止服务器'));
+    } else {
+      // Daemon 模式：保持运行
+      console.log(chalk.green(`✅ Coding-Tool 服务已在后台启动 (端口: ${port})`));
+    }
+
+  } catch (error) {
+    console.error(chalk.red('启动服务器失败:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { handleUI };

package/src/commands/update.js

@@ -0,0 +1,97 @@
+const { spawn } = require('child_process');
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const semver = require('semver');
+const chalk = require('chalk');
+const packageInfo = require('../../package.json');
+
+const execAsync = promisify(exec);
+
+async function getLatestVersion(packageName) {
+  const { stdout } = await execAsync(`npm view ${packageName} version --json`, { timeout: 15000 });
+  const parsed = JSON.parse(stdout.trim());
+  if (typeof parsed === 'string') return parsed;
+  throw new Error('无法解析 npm 返回的版本号');
+}
+
+function runNpmInstall(packageName, version) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('npm', ['install', '-g', `${packageName}@${version}`], {
+      stdio: 'inherit'
+    });
+
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`npm install 失败，退出码 ${code}`));
+      }
+    });
+  });
+}
+
+async function handleUpdate(options = {}) {
+  const checkOnly = options.checkOnly === true;
+  const packageCandidates = Array.from(new Set([
+    packageInfo.name,
+    'coding-tool-x'
+  ].filter(Boolean)));
+  const currentVersion = packageInfo.version;
+
+  console.log(chalk.cyan('\n🔍 检查更新中...\n'));
+
+  let latestVersion;
+  let packageName = packageCandidates[0];
+  try {
+    let lastError = null;
+    for (const candidate of packageCandidates) {
+      try {
+        latestVersion = await getLatestVersion(candidate);
+        packageName = candidate;
+        lastError = null;
+        break;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    if (!latestVersion) {
+      throw lastError || new Error('无法获取最新版本');
+    }
+  } catch (error) {
+    console.error(chalk.red(`❌ 检查更新失败: ${error.message}`));
+    console.log(chalk.gray('💡 可手动执行: npm view coding-tool-x version'));
+    return;
+  }
+
+  if (!semver.valid(currentVersion) || !semver.valid(latestVersion)) {
+    console.log(chalk.yellow(`⚠️  版本格式异常，当前: ${currentVersion}, 最新: ${latestVersion}`));
+    return;
+  }
+
+  if (!semver.gt(latestVersion, currentVersion)) {
+    console.log(chalk.green(`✅ 已是最新版本: ${currentVersion}\n`));
+    return;
+  }
+
+  console.log(chalk.yellow(`发现新版本: ${currentVersion} -> ${latestVersion}`));
+  if (checkOnly) {
+    console.log(chalk.gray(`\n可执行更新命令: npm install -g ${packageName}@${latestVersion}\n`));
+    return;
+  }
+
+  console.log(chalk.cyan('\n⬇️  正在更新...\n'));
+
+  try {
+    await runNpmInstall(packageName, latestVersion);
+    console.log(chalk.green(`\n✅ 更新完成: ${latestVersion}`));
+    console.log(chalk.gray('请重新打开终端或重新执行 ctx --version 验证版本。\n'));
+  } catch (error) {
+    console.error(chalk.red(`\n❌ 更新失败: ${error.message}`));
+    console.log(chalk.gray(`💡 可手动执行: npm install -g ${packageName}@${latestVersion}\n`));
+  }
+}
+
+module.exports = {
+  handleUpdate
+};