@adversity/coding-tool-x 2.2.0

package/src/commands/proxy-control.js

@@ -0,0 +1,258 @@
+const chalk = require('chalk');
+const http = require('http');
+const { loadConfig } = require('../config/loader');
+
+const CHANNEL_CONFIG = {
+  claude: {
+    name: 'Claude',
+    icon: '🟢',
+    apiPath: '/api/proxy'
+  },
+  codex: {
+    name: 'Codex',
+    icon: '🔵',
+    apiPath: '/api/codex-proxy'
+  },
+  gemini: {
+    name: 'Gemini',
+    icon: '🟣',
+    apiPath: '/api/gemini-proxy'
+  }
+};
+
+/**
+ * HTTP 请求辅助函数
+ */
+function httpRequest(method, path, data = null) {
+  const config = loadConfig();
+  const port = config.ports?.webUI || 10099;
+
+  return new Promise((resolve, reject) => {
+    const postData = data ? JSON.stringify(data) : null;
+    const options = {
+      hostname: 'localhost',
+      port: port,
+      path: path,
+      method: method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(postData && { 'Content-Length': Buffer.byteLength(postData) })
+      },
+      timeout: 5000
+    };
+
+    const req = http.request(options, (res) => {
+      let responseData = '';
+
+      res.on('data', (chunk) => {
+        responseData += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(responseData);
+          resolve({ data: json, status: res.statusCode });
+        } catch (err) {
+          reject(new Error('Invalid JSON response'));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(err);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    if (postData) {
+      req.write(postData);
+    }
+
+    req.end();
+  });
+}
+
+/**
+ * 检查 UI 服务是否运行
+ */
+async function checkUIService() {
+  try {
+    await httpRequest('GET', '/api/ping');
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * 启动代理
+ */
+async function handleProxyStart(channel) {
+  const channelInfo = CHANNEL_CONFIG[channel];
+  if (!channelInfo) {
+    console.error(chalk.red(`\n❌ 无效的渠道类型: ${channel}\n`));
+    console.log(chalk.gray('支持的渠道: claude, codex, gemini\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`\n🚀 启动 ${channelInfo.name} 代理服务...\n`));
+
+  // 检查 UI 服务
+  const uiRunning = await checkUIService();
+  if (!uiRunning) {
+    console.error(chalk.red('❌ UI 服务未运行\n'));
+    console.log(chalk.yellow('💡 请先启动 UI 服务:'));
+    console.log(chalk.gray('   ') + chalk.cyan('ctx start') + chalk.gray('  或  ') + chalk.cyan('ctx ui\n'));
+    process.exit(1);
+  }
+
+  try {
+    const response = await httpRequest('POST', `${channelInfo.apiPath}/start`);
+
+    if (response.data.success) {
+      console.log(chalk.green(`✅ ${channelInfo.name} 代理已启动\n`));
+      console.log(chalk.gray(`${channelInfo.icon} 代理端口: ${response.data.port}`));
+      console.log(chalk.gray(`🌐 代理地址: http://localhost:${response.data.port}\n`));
+    } else {
+      console.error(chalk.red(`❌ 启动失败: ${response.data.message}\n`));
+      process.exit(1);
+    }
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error(chalk.red('❌ 无法连接到 UI 服务\n'));
+      console.log(chalk.yellow('💡 请确保 UI 服务正在运行: ') + chalk.cyan('ctx start\n'));
+    } else {
+      console.error(chalk.red(`❌ 启动失败: ${error.message}\n`));
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * 停止代理
+ */
+async function handleProxyStop(channel) {
+  const channelInfo = CHANNEL_CONFIG[channel];
+  if (!channelInfo) {
+    console.error(chalk.red(`\n❌ 无效的渠道类型: ${channel}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`\n⏹️  停止 ${channelInfo.name} 代理服务...\n`));
+
+  const uiRunning = await checkUIService();
+  if (!uiRunning) {
+    console.error(chalk.red('❌ UI 服务未运行，无法停止代理\n'));
+    process.exit(1);
+  }
+
+  try {
+    const response = await httpRequest('POST', `${channelInfo.apiPath}/stop`);
+
+    if (response.data.success) {
+      console.log(chalk.green(`✅ ${channelInfo.name} 代理已停止\n`));
+    } else {
+      console.error(chalk.red(`❌ 停止失败: ${response.data.message}\n`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk.red(`❌ 停止失败: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * 重启代理
+ */
+async function handleProxyRestart(channel) {
+  const channelInfo = CHANNEL_CONFIG[channel];
+  if (!channelInfo) {
+    console.error(chalk.red(`\n❌ 无效的渠道类型: ${channel}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`\n🔄 重启 ${channelInfo.name} 代理服务...\n`));
+
+  await handleProxyStop(channel);
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  await handleProxyStart(channel);
+}
+
+/**
+ * 查看代理状态
+ */
+async function handleProxyStatus(channel) {
+  const channelInfo = CHANNEL_CONFIG[channel];
+  if (!channelInfo) {
+    console.error(chalk.red(`\n❌ 无效的渠道类型: ${channel}\n`));
+    process.exit(1);
+  }
+
+  const uiRunning = await checkUIService();
+  if (!uiRunning) {
+    console.log(chalk.bold.cyan(`\n╔══════════════════════════════════════╗`));
+    console.log(chalk.bold.cyan(`║      ${channelInfo.name} 代理服务状态           ║`));
+    console.log(chalk.bold.cyan(`╚══════════════════════════════════════╝\n`));
+    console.log(chalk.gray('  ❌ UI 服务未运行\n'));
+    console.log(chalk.yellow('💡 请先启动 UI 服务: ') + chalk.cyan('ctx start\n'));
+    return;
+  }
+
+  try {
+    const response = await httpRequest('GET', `${channelInfo.apiPath}/status`);
+    const status = response.data;
+
+    console.log(chalk.bold.cyan(`\n╔══════════════════════════════════════╗`));
+    console.log(chalk.bold.cyan(`║      ${channelInfo.name} 代理服务状态           ║`));
+    console.log(chalk.bold.cyan(`╚══════════════════════════════════════╝\n`));
+
+    if (status.running) {
+      console.log(chalk.green('  ✅ 状态: 运行中'));
+      console.log(chalk.gray(`  ${channelInfo.icon} 端口: ${status.port}`));
+      console.log(chalk.gray(`  🌐 地址: http://localhost:${status.port}`));
+      if (status.runtime) {
+        console.log(chalk.gray(`  ⏱️  运行时长: ${formatRuntime(status.runtime)}`));
+      }
+    } else {
+      console.log(chalk.gray('  ❌ 状态: 未运行'));
+    }
+
+    console.log(chalk.bold('\n💡 提示:'));
+    console.log(chalk.gray(`  • 使用 `) + chalk.cyan(`ctx ${channel} start`) + chalk.gray(` 启动代理`));
+    console.log(chalk.gray(`  • 使用 `) + chalk.cyan(`ctx logs ${channel}`) + chalk.gray(` 查看日志`));
+    console.log(chalk.gray(`  • 使用 `) + chalk.cyan(`ctx stats ${channel}`) + chalk.gray(` 查看统计\n`));
+  } catch (error) {
+    console.error(chalk.red(`❌ 查询状态失败: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * 格式化运行时长
+ */
+function formatRuntime(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) {
+    return `${days}天 ${hours % 24}小时`;
+  } else if (hours > 0) {
+    return `${hours}小时 ${minutes % 60}分钟`;
+  } else if (minutes > 0) {
+    return `${minutes}分钟`;
+  } else {
+    return `${seconds}秒`;
+  }
+}
+
+module.exports = {
+  handleProxyStart,
+  handleProxyStop,
+  handleProxyRestart,
+  handleProxyStatus
+};

package/src/commands/proxy.js

@@ -0,0 +1,152 @@
+const { startProxyServer, stopProxyServer, getProxyStatus } = require('../server/proxy-server');
+const {
+  setProxyConfig,
+  restoreSettings,
+  isProxyConfig,
+  settingsExists,
+  hasBackup
+} = require('../server/services/settings-manager');
+
+/**
+ * 启动代理
+ */
+async function handleProxyStart() {
+  try {
+    console.log('\n🚀 启动代理服务...\n');
+
+    // 1. 检查配置文件
+    if (!settingsExists()) {
+      console.error('❌ 未找到 Claude Code 配置文件');
+      console.log('请至少运行一次 Claude Code 以生成配置文件');
+      console.log('配置文件路径: ~/.claude/settings.json\n');
+      process.exit(1);
+    }
+
+    // 2. 检查是否已经是代理配置
+    if (isProxyConfig()) {
+      console.log('⚠️  已经配置为代理模式');
+    }
+
+    // 3. 启动代理服务器
+    const proxyResult = await startProxyServer();
+
+    if (!proxyResult.success) {
+      console.error('❌ 代理服务器启动失败\n');
+      process.exit(1);
+    }
+
+    console.log(`✅ 代理服务器已启动: http://127.0.0.1:${proxyResult.port}`);
+
+    // 4. 修改配置文件
+    const configResult = setProxyConfig(proxyResult.port);
+    console.log('✅ 配置文件已更新');
+
+    if (hasBackup()) {
+      console.log('✅ 原配置已备份');
+    }
+
+    console.log('\n代理服务运行中...');
+    console.log('现在可以使用 Claude Code，它将通过代理访问 API');
+    console.log('使用 Ctrl+C 停止服务（配置不会恢复）');
+    console.log('或使用 "ctx proxy stop" 停止并恢复配置\n');
+
+    // 保持进程运行
+    return new Promise(() => {
+      // 处理退出信号
+      process.on('SIGINT', async () => {
+        console.log('\n\n⚠️  收到退出信号');
+        console.log('提示: 配置文件未恢复，使用 "ctx proxy stop" 恢复配置\n');
+        process.exit(0);
+      });
+    });
+  } catch (error) {
+    console.error('❌ 启动代理失败:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * 停止代理
+ */
+async function handleProxyStop() {
+  try {
+    console.log('\n⏹️  停止代理服务...\n');
+
+    const status = getProxyStatus();
+
+    // 1. 停止代理服务器
+    if (status.running) {
+      await stopProxyServer();
+      console.log('✅ 代理服务器已停止');
+    } else {
+      console.log('⚠️  代理服务器未运行');
+    }
+
+    // 2. 恢复配置文件
+    if (hasBackup()) {
+      restoreSettings();
+      console.log('✅ 配置文件已恢复');
+    } else {
+      console.log('⚠️  未找到备份文件，配置未恢复');
+    }
+
+    console.log('\n✅ 代理已完全停止并清理\n');
+  } catch (error) {
+    console.error('❌ 停止代理失败:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * 显示代理状态
+ */
+function handleProxyStatus() {
+  const chalk = require('chalk');
+  console.log(chalk.bold.cyan('\n╔══════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║          代理服务状态          ║'));
+  console.log(chalk.bold.cyan('╚══════════════════════════════════════╝\n'));
+
+  const proxyStatus = getProxyStatus();
+  const configIsProxy = isProxyConfig();
+  const backup = hasBackup();
+
+  console.log(chalk.bold('代理服务器:'));
+  if (proxyStatus.running) {
+    console.log(chalk.green(`  ✅ 状态: 运行中`));
+    console.log(chalk.gray(`  📍 端口: ${proxyStatus.port}`));
+    console.log(chalk.gray(`  🌐 地址: http://127.0.0.1:${proxyStatus.port}`));
+  } else {
+    console.log(chalk.gray(`  ❌ 状态: 未运行`));
+  }
+
+  console.log(chalk.bold('\n配置文件:'));
+  console.log(`  代理模式: ${configIsProxy ? chalk.green('✅ 已启用') : chalk.gray('❌ 未启用')}`);
+  console.log(`  配置备份: ${backup ? chalk.green('✅ 存在') : chalk.gray('❌ 不存在')}`);
+
+  // 根据状态给出建议
+  console.log(chalk.bold('\n💡 建议操作:'));
+
+  if (proxyStatus.running && configIsProxy) {
+    console.log(chalk.green('  ✓ 代理正常运行，Claude Code 将通过代理访问 API'));
+    console.log(chalk.gray('  • 使用 Web UI (ctx ui) 可以动态管理渠道'));
+    console.log(chalk.gray('  • 使用 ctx proxy stop 停止代理并恢复配置'));
+  } else if (proxyStatus.running && !configIsProxy) {
+    console.log(chalk.yellow('  ⚠️  代理服务在运行，但配置未启用代理模式'));
+    console.log(chalk.gray('  • 配置可能被手动修改，建议运行: ctx proxy stop'));
+  } else if (!proxyStatus.running && configIsProxy) {
+    console.log(chalk.yellow('  ⚠️  配置为代理模式，但代理服务未运行'));
+    console.log(chalk.gray('  • Claude Code 可能无法正常工作'));
+    console.log(chalk.gray('  • 建议运行: ctx reset (恢复配置)'));
+  } else {
+    console.log(chalk.gray('  • 代理未运行，Claude Code 使用常规配置'));
+    console.log(chalk.gray('  • 如需启用动态切换，运行: ctx ui'));
+  }
+
+  console.log('\n');
+}
+
+module.exports = {
+  handleProxyStart,
+  handleProxyStop,
+  handleProxyStatus
+};

package/src/commands/resume.js

@@ -0,0 +1,137 @@
+// 恢复会话命令
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const { getSessionsDir } = require('../utils/session');
+
+/**
+ * 恢复会话
+ */
+async function resumeSession(config, sessionId, fork = false) {
+  // 构建命令参数
+  const args = ['-r', sessionId];
+  if (fork) {
+    args.push('--fork-session');
+  }
+
+  // 从会话文件中提取原始工作目录
+  const sessionFile = path.join(getSessionsDir(config), `${sessionId}.jsonl`);
+  let cwd = process.cwd();
+
+  try {
+    const fd = fs.openSync(sessionFile, 'r');
+    const buffer = Buffer.alloc(2048);
+    fs.readSync(fd, buffer, 0, 2048, 0);
+    fs.closeSync(fd);
+
+    const content = buffer.toString('utf8');
+    const lines = content.split('\n').slice(0, 5);
+
+    for (const line of lines) {
+      try {
+        const json = JSON.parse(line);
+        if (json.cwd) {
+          cwd = json.cwd;
+          break;
+        }
+      } catch (e) {
+        // 继续
+      }
+    }
+  } catch (e) {
+    // 使用当前目录
+  }
+
+  // 显示加载动画
+  const spinner = ora({
+    text: chalk.cyan('正在准备启动 Claude...'),
+    spinner: 'dots',
+  }).start();
+
+  // 等待 500ms，让用户看到加载状态
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  spinner.succeed(chalk.green('准备完成！\n'));
+
+  console.log(chalk.gray('━'.repeat(50)));
+  console.log(chalk.green.bold(`✨ 会话: ${sessionId.substring(0, 8)}`));
+  console.log(chalk.gray(`📁 目录: ${cwd}`));
+  console.log(chalk.gray('━'.repeat(50)) + '\n');
+
+  // 完全清理终端状态，避免输入冲突
+  if (process.stdin.isTTY && process.stdin.setRawMode) {
+    try {
+      process.stdin.setRawMode(false);
+    } catch (e) {
+      // 忽略
+    }
+  }
+
+  // 移除所有 stdin 监听器，防止残留事件
+  process.stdin.removeAllListeners();
+
+  // 添加错误处理器，防止 EIO 错误导致崩溃
+  process.stdin.on('error', (err) => {
+    // 忽略 EIO 错误（通常发生在 Ctrl+C 时）
+    if (err.code === 'EIO' || err.code === 'ENOTTY') {
+      // 安静退出
+      process.exit(0);
+    }
+  });
+
+  // 暂停输入流
+  process.stdin.pause();
+
+  // 再等待 100ms 确保终端状态稳定
+  await new Promise(resolve => setTimeout(resolve, 100));
+
+  // 使用 execSync 完全替代当前进程
+  // ct 会阻塞等待 claude 完成，然后一起退出
+  // Claude 独占终端，不会有输入冲突
+  try {
+    const command = `claude ${args.join(' ')}`;
+
+    // 切换到目标目录
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(cwd);
+    } catch (e) {
+      console.log(chalk.yellow(`\n⚠️  无法切换到目录: ${cwd}`));
+      console.log(chalk.gray(`将在当前目录启动\n`));
+    }
+
+    // execSync 会阻塞并完全接管终端
+    // 此时 ct 进程只是等待，不处理任何输入
+    execSync(command, {
+      stdio: 'inherit', // 完全继承 stdio，让 claude 控制终端
+    });
+
+    // 恢复目录
+    try {
+      process.chdir(originalCwd);
+    } catch (e) {
+      // 忽略
+    }
+
+    // Claude 正常退出 - 立即退出避免清理错误
+    process.exit(0);
+  } catch (error) {
+    // Claude 执行出错或被用户中断（Ctrl+C）
+    // 立即退出，不等待清理
+    if (error.status !== undefined) {
+      process.exit(error.status);
+    } else if (error.signal === 'SIGINT') {
+      // 用户按了 Ctrl+C，正常退出
+      process.exit(0);
+    } else {
+      console.log(chalk.red(`\n❌ 启动失败: ${error.message}`));
+      process.exit(1);
+    }
+  }
+}
+
+module.exports = {
+  resumeSession,
+};