aicodeswitch 3.9.3 → 4.0.0

package/README.md

@@ -14,11 +14,11 @@ AI Code Switch 是帮助你在本地管理 AI 编程工具接入大模型的工
 
 * 可登记任意的大模型API接口服务，让你可以在一个面板管理你的大模型厂商
 * 供应商API一键切换：可以注册多个供应商的多个API接口，当想要切换供应商时，只需要点击一个按钮就可以立即切换
-* 自动配置：无需你手动去修改claude code或codex的系统配置文件，aicodeswitch自动帮你修改，你只要启动它，似乎claude code或codex就尽在掌握
+* 自动配置：无需你手动去修改claude code或codex的系统配置文件，aicodeswitch自动帮你修改，你只要启动它，无需配置claude code或codex就可以让它们正常工作
 * 一键配置供应商，省去复杂的供应商配置流程
 * API转流：将兼容openai接口标准的模型，轻松接入到claude code中，支持将符合openai、anthropic、gemini的数据格式转发给claude code或codex
 * 按需代理：根据请求类型，让不同的模型来处理不同的任务，节省成本，基于该特性，可以让glm等原生非多模态模型支持图像识别
-* 智能故障切换：当API服务发生故障时，智能切换到其他API服务进行尝试，特别适用于中转服务商
+* 智能故障切换：当API服务发生故障时，智能切换到其他API服务进行尝试，无需手动切换，特别适用于中转服务商
 * 代理：针对无法直接访问的模型服务，例如地区被ban，支持设置代理来解决
 * tokens超量限制：避免其中一个服务商的用量超过限制，浪费了钱，适合有免费额度的服务商
 * 次数超量限制：次数到达一定量后，切换其他服务商，适合coding plan的服务商
@@ -29,7 +29,8 @@ AI Code Switch 是帮助你在本地管理 AI 编程工具接入大模型的工
 * 导入和导出：一键备份数据，在多太电脑间共享aicodeswitch配置
 * 自定义API Key，支持B/S架构，让aicodeswitch成为在线服务，提供给团队使用
 * 数据完全本地，自主可控
-* 特殊语法：在发送的提示词最前面添加!!来直接切换为高智商模型服务，简单快捷
+* 特殊语法：在发送的提示词最前面添加`[!]`来直接切换为高智商模型服务，简单快捷
+* 服务端部署，可随时随地使用
 
 ## 桌面客户端
 
@@ -79,15 +80,15 @@ http://127.0.0.1:4567
 
 **配置供应商**
 
-*   什么是供应商？
-*   供应商配置有什么用？
+* 什么是供应商？
+* 供应商配置有什么用？
 
 具体请看下方文档。
 
 **路由配置**
 
-*   什么是路由？
-*   什么是路由规则？
+* 什么是路由？
+* 什么是路由规则？
 
 具体请看下方文档。
 
@@ -115,22 +116,22 @@ Codex的配置覆盖逻辑一模一样。
 
 通过将你所有的AI服务商统一起来管理，可以帮你：
 
-1.  避免频繁修改配置文件，通过aicodeswitch，可以一键切换到不同的供应商的AI服务API
-2.  通过aicodeswitch，将不同供应商的接口数据，转换为工具可以正确使用的接口数据格式，也就是说，你可以将Claude Code接入遵循openai的接口数据协议的其他接口
-3.  避免你忘记曾经注册过那些供应商
-4.  充分榨干不怎么用的供应商的服务，避免充值后不怎么用浪费了
+1. 避免频繁修改配置文件，通过aicodeswitch，可以一键切换到不同的供应商的AI服务API
+2. 通过aicodeswitch，将不同供应商的接口数据，转换为工具可以正确使用的接口数据格式，也就是说，你可以将Claude Code接入遵循openai的接口数据协议的其他接口
+3. 避免你忘记曾经注册过那些供应商
+4. 充分榨干不怎么用的供应商的服务，避免充值后不怎么用浪费了
 
 ### 什么事API服务的“源类型”
 
 供应商接口返回的数据格式标准类型，目前支持以下几种：
 
-*   OpenAI Chat
-*   OpenAI Code
-*   OpenAI Responses
-*   Claude Chat
-*   Claude Code
-*   DeepSeek Chat
-*   Gemini
+* OpenAI(Responses API标准)
+* OpenAI Chat (Chat Completions API标准)
+* DeepSeek Chat（reasoning_content标准）
+* Claude
+* Claude Chat
+* Gemini
+* Gemini Chat
 
 **有什么用？**
 
@@ -140,7 +141,7 @@ aicodeswitch内部，会根据“源类型”来转换数据。例如，你的
 
 ### 什么是路由？
 
-路由是aicodeswitch的核心功能，它负责将不同的对象（目前指Claude Code和Codex）的请求，路由到不同的供应商API服务上。
+路由是aicodeswitch的核心功能，它负责将不同的对象工具（目前指Claude Code和Codex）的请求，路由到不同的供应商API服务上。
 
 ### 什么是“客户端工具”？
 
@@ -189,16 +190,16 @@ aicodeswitch内部，会根据“源类型”来转换数据。例如，你的
 
 **请求日志**：所有 API 请求的详细记录
 
-*   请求来源和目标
-*   请求内容和响应
-*   耗时和状态码
-*   错误信息（如有）
+* 请求来源和目标
+* 请求内容和响应
+* 耗时和状态码
+* 错误信息（如有）
 
 **错误日志**：错误和异常记录
 
-*   错误类型
-*   错误详情
-*   发生时间
+* 错误类型
+* 错误详情
+* 发生时间
 
 **会话日志**：按照会话session来汇集日志
 
@@ -242,17 +243,17 @@ PORT=4567
 
 ## 我的开源
 
-*   [PCM](https://github.com/tangshuang/pcm): 用户意图识别、精准上下文、多线对话的Agent系统
-*   [Lan Transfer](https://github.com/tangshuang/lan-transfer): 免费高效的局域网文件互传工具
-*   [MCP Bone](https://github.com/tangshuang/mcp-bone): 远程托管的MCP服管理工具
-*   [Anys](https://github.com/tangshuang/anys): 免费前端监控kit
-*   [WebCut](https://github.com/tangshuang/webcut): 免费开源的网页端视频剪辑UI框架
-*   [indb](https://github.com/tangshuang/indb): 网页端轻量kv数据库操作库
-*   [Formast](https://github.com/tangshuang/formast): 复杂业务场景下的企业级JSON驱动表单框架
+* [PCM](https://github.com/tangshuang/pcm): 用户意图识别、精准上下文、多线对话的Agent系统
+* [Lan Transfer](https://github.com/tangshuang/lan-transfer): 免费高效的局域网文件互传工具
+* [MCP Bone](https://github.com/tangshuang/mcp-bone): 远程托管的MCP服管理工具
+* [Anys](https://github.com/tangshuang/anys): 免费前端监控kit
+* [WebCut](https://github.com/tangshuang/webcut): 免费开源的网页端视频剪辑UI框架
+* [indb](https://github.com/tangshuang/indb): 网页端轻量kv数据库操作库
+* [Formast](https://github.com/tangshuang/formast): 复杂业务场景下的企业级JSON驱动表单框架
 
 ## 关联资源
 
-*   [Claude Code 深度教程](https://claudecode.tangshuang.net): 100%免费的Claude Code入门到精通教程
+* [Claude Code 深度教程](https://claudecode.tangshuang.net): 100%免费的Claude Code入门到精通教程
 
 ## 支持我
 
@@ -264,8 +265,8 @@ PORT=4567
 
 此项目采用双许可证模式：
 
-*   **开源使用**：项目默认采用 GPL 3.0 许可证，允许个人免费使用、修改和分发，但所有衍生品必须开源。
-*   **商业使用**：如果您希望商业化使用而不遵守 GPL 条款（例如闭源销售），请联系我们购买单独的商业许可证。
+* **开源使用**：项目默认采用 GPL 3.0 许可证，允许个人免费使用、修改和分发，但所有衍生品必须开源。
+* **商业使用**：如果您希望商业化使用而不遵守 GPL 条款（例如闭源销售），请联系我们购买单独的商业许可证。
 
 ## 技术支持
 

package/UPGRADE.md

@@ -1,5 +1,7 @@
 本次升级将会有破坏性影响，你需要注意：
 
-* 升级后，不再使用数据库来持久化数据，而是使用json文件，你可以通过直接阅读json文件来查看数据
-* 升级后，你需要重启服务，让新的数据持久化系统生效
-* 升级后，如果遇到问题，不要惊慌，你可以直接重新安装老版本，老版本仍然使用原来的数据库文件，你可以先把老版本的数据备份后，安装新版本再来恢复数据
+* 对于API服务，你需要进行检查，OpenAI 类型的服务，请检查 `baseUrl` 是否以 `/v1` 结尾，如果是，请移除。
+* 对codex/claude-code的配置覆盖逻辑，不再与“是否激活路由”绑定，而是在启动服务时写入覆盖并备份，停止服务时恢复备份。
+* 升级后，一旦你启动 AICodeSwitch，就可以统计到所有请求，让你的AI编程统计数据更准确。
+* 由于Codex升级后，数据结构有了较大的变化，导致我们的转流可能存在问题，请为Codex使用复合Responses API标准的接口（注：部分国内厂商实现的responses接口不够完善，部分工具不支持）。
+* 升级后，数据版本会变更，如果重启后没有看到原来的数据，需退回上一个版本，导出数据后重新升级，并导入备份的数据。

package/bin/restore.js

@@ -4,6 +4,9 @@ const os = require('os');
 const chalk = require('chalk');
 const boxen = require('boxen');
 const ora = require('ora');
+const { parseToml, stringifyToml, mergeJsonSettings, mergeTomlSettings, atomicWriteFile } = require('./utils/config-helpers');
+const { isServerRunning, getServerInfo } = require('./utils/get-server');
+const { findPidByPort } = require('./utils/port-utils');
 
 // 停用所有激活的路由（直接操作数据库文件）
 const deactivateAllRoutes = () => {
@@ -55,7 +58,7 @@ const deactivateAllRoutes = () => {
   }
 };
 
-// 恢复 Claude Code 配置
+// 恢复 Claude Code 配置（使用智能合并）
 const restoreClaudeConfig = () => {
   const results = {
     restored: [],
@@ -69,13 +72,33 @@ const restoreClaudeConfig = () => {
     const claudeSettingsPath = path.join(claudeDir, 'settings.json');
     const claudeSettingsBakPath = path.join(claudeDir, 'settings.json.aicodeswitch_backup');
 
-    // Restore settings.json
+    // Restore settings.json（智能合并）
     if (fs.existsSync(claudeSettingsBakPath)) {
-      if (fs.existsSync(claudeSettingsPath)) {
-        fs.unlinkSync(claudeSettingsPath);
+      try {
+        const backupSettings = JSON.parse(fs.readFileSync(claudeSettingsBakPath, 'utf-8'));
+        let currentSettings = {};
+        if (fs.existsSync(claudeSettingsPath)) {
+          try {
+            currentSettings = JSON.parse(fs.readFileSync(claudeSettingsPath, 'utf-8'));
+          } catch (e) {
+            // 忽略解析错误
+          }
+        }
+
+        const mergedSettings = mergeJsonSettings(
+          backupSettings,
+          currentSettings,
+          ['env.ANTHROPIC_AUTH_TOKEN', 'env.ANTHROPIC_BASE_URL', 'env.API_TIMEOUT_MS',
+             'env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC', 'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
+             'permissions', 'skipDangerousModePermissionPrompt']
+        );
+
+        atomicWriteFile(claudeSettingsPath, JSON.stringify(mergedSettings, null, 2));
+        fs.unlinkSync(claudeSettingsBakPath);
+        results.restored.push('settings.json');
+      } catch (error) {
+        results.errors.push({ file: 'settings.json', error: error.message });
       }
-      fs.renameSync(claudeSettingsBakPath, claudeSettingsPath);
-      results.restored.push('settings.json');
     } else {
       results.notFound.push('settings.json.aicodeswitch_backup');
     }
@@ -88,13 +111,31 @@ const restoreClaudeConfig = () => {
     const claudeJsonPath = path.join(homeDir, '.claude.json');
     const claudeJsonBakPath = path.join(homeDir, '.claude.json.aicodeswitch_backup');
 
-    // Restore .claude.json
+    // Restore .claude.json（智能合并）
     if (fs.existsSync(claudeJsonBakPath)) {
-      if (fs.existsSync(claudeJsonPath)) {
-        fs.unlinkSync(claudeJsonPath);
+      try {
+        const backupJson = JSON.parse(fs.readFileSync(claudeJsonBakPath, 'utf-8'));
+        let currentJson = {};
+        if (fs.existsSync(claudeJsonPath)) {
+          try {
+            currentJson = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf-8'));
+          } catch (e) {
+            // 忽略解析错误
+          }
+        }
+
+        const mergedJson = mergeJsonSettings(
+          backupJson,
+          currentJson,
+          ['hasCompletedOnboarding', 'mcpServers']
+        );
+
+        atomicWriteFile(claudeJsonPath, JSON.stringify(mergedJson, null, 2));
+        fs.unlinkSync(claudeJsonBakPath);
+        results.restored.push('.claude.json');
+      } catch (error) {
+        results.errors.push({ file: '.claude.json', error: error.message });
       }
-      fs.renameSync(claudeJsonBakPath, claudeJsonPath);
-      results.restored.push('.claude.json');
     } else {
       results.notFound.push('.claude.json.aicodeswitch_backup');
     }
@@ -105,7 +146,7 @@ const restoreClaudeConfig = () => {
   return results;
 };
 
-// 恢复 Codex 配置
+// 恢复 Codex 配置（使用智能合并）
 const restoreCodexConfig = () => {
   const results = {
     restored: [],
@@ -119,13 +160,32 @@ const restoreCodexConfig = () => {
     const codexConfigPath = path.join(codexDir, 'config.toml');
     const codexConfigBakPath = path.join(codexDir, 'config.toml.aicodeswitch_backup');
 
-    // Restore config.toml
+    // Restore config.toml（智能合并）
     if (fs.existsSync(codexConfigBakPath)) {
-      if (fs.existsSync(codexConfigPath)) {
-        fs.unlinkSync(codexConfigPath);
+      try {
+        const backupConfig = parseToml(fs.readFileSync(codexConfigBakPath, 'utf-8'));
+        let currentConfig = {};
+        if (fs.existsSync(codexConfigPath)) {
+          try {
+            currentConfig = parseToml(fs.readFileSync(codexConfigPath, 'utf-8'));
+          } catch (e) {
+            // 忽略解析错误
+          }
+        }
+
+        const mergedConfig = mergeTomlSettings(
+          backupConfig,
+          currentConfig,
+          ['model_provider', 'model', 'model_reasoning_effort', 'disable_response_storage',
+             'preferred_auth_method', 'requires_openai_auth', 'enableRouteSelection', 'model_providers.aicodeswitch']
+        );
+
+        atomicWriteFile(codexConfigPath, stringifyToml(mergedConfig));
+        fs.unlinkSync(codexConfigBakPath);
+        results.restored.push('config.toml');
+      } catch (error) {
+        results.errors.push({ file: 'config.toml', error: error.message });
       }
-      fs.renameSync(codexConfigBakPath, codexConfigPath);
-      results.restored.push('config.toml');
     } else {
       results.notFound.push('config.toml.aicodeswitch_backup');
     }
@@ -138,13 +198,31 @@ const restoreCodexConfig = () => {
     const codexAuthPath = path.join(homeDir, '.codex', 'auth.json');
     const codexAuthBakPath = path.join(homeDir, '.codex', 'auth.json.aicodeswitch_backup');
 
-    // Restore auth.json
+    // Restore auth.json（智能合并）
     if (fs.existsSync(codexAuthBakPath)) {
-      if (fs.existsSync(codexAuthPath)) {
-        fs.unlinkSync(codexAuthPath);
+      try {
+        const backupAuth = JSON.parse(fs.readFileSync(codexAuthBakPath, 'utf-8'));
+        let currentAuth = {};
+        if (fs.existsSync(codexAuthPath)) {
+          try {
+            currentAuth = JSON.parse(fs.readFileSync(codexAuthPath, 'utf-8'));
+          } catch (e) {
+            // 忽略解析错误
+          }
+        }
+
+        const mergedAuth = mergeJsonSettings(
+          backupAuth,
+          currentAuth,
+          ['OPENAI_API_KEY']
+        );
+
+        atomicWriteFile(codexAuthPath, JSON.stringify(mergedAuth, null, 2));
+        fs.unlinkSync(codexAuthBakPath);
+        results.restored.push('auth.json');
+      } catch (error) {
+        results.errors.push({ file: 'auth.json', error: error.message });
       }
-      fs.renameSync(codexAuthBakPath, codexAuthPath);
-      results.restored.push('auth.json');
     } else {
       results.notFound.push('auth.json.aicodeswitch_backup');
     }
@@ -243,6 +321,32 @@ const restore = async () => {
     process.exit(1);
   }
 
+  // 服务运行中时，禁止执行手动 restore，避免中断当前代理服务
+  const { host, port } = getServerInfo();
+  const runningPid = await findPidByPort(port);
+  const runningByPidFile = isServerRunning();
+
+  if (runningByPidFile || runningPid) {
+    const pidText = runningPid ? `${runningPid}` : 'unknown';
+    const message = chalk.yellow.bold('⚠ Restore skipped: server is running\n\n') +
+      chalk.white('Detected running server: ') +
+      chalk.cyan(`http://${host}:${port}`) +
+      chalk.white(` (PID: ${pidText})\n\n`) +
+      chalk.white('Please run ') + chalk.cyan.bold('aicos stop') +
+      chalk.white(' first.\n') +
+      chalk.white('The ') + chalk.cyan.bold('stop') +
+      chalk.white(' command will automatically restore configuration files.\n');
+
+    console.log(boxen(message, {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'yellow'
+    }));
+    console.log('');
+    return;
+  }
+
   // 恢复配置
   if (target === 'claude-code' || !target) {
     const spinner = ora({

package/bin/start.js

@@ -27,39 +27,31 @@ const start = async (options = {}) => {
   const { host, port } = getServerInfo();
   if (isServerRunning() || await findPidByPort(port)) {
     if (!silent) {
-      if (!silent) {
-        console.log(boxen(
-          chalk.yellow.bold('⚠ Server is already running!\n\n') +
-          chalk.white(`URL: `) + chalk.cyan.bold(`http://${host}:${port}\n\n`) +
-          chalk.white('Use ') + chalk.cyan('aicos restart') + chalk.white(' to restart the server.\n'),
-          {
-            padding: 1,
-            margin: 1,
-            borderStyle: 'round',
-            borderColor: 'yellow'
-          }
-        ));
-        console.log('');
-      }
-
-      if (callback) {
-        callback();
-      }
+      console.log(boxen(
+        chalk.yellow.bold('⚠ Server is already running!\n\n') +
+        chalk.white('URL: ') + chalk.cyan.bold(`http://${host}:${port}\n\n`) +
+        chalk.white('Use ') + chalk.cyan('aicos restart') + chalk.white(' to restart the server.\n'),
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: 'round',
+          borderColor: 'yellow'
+        }
+      ));
+      console.log('');
+    }
 
-      if (!noExit) {
-        process.exit(0);
-      }
+    if (callback) {
+      callback();
+    }
 
-      return true;
+    if (!noExit) {
+      process.exit(0);
     }
-    if (callback) callback();
-    if (!noExit) process.exit(0);
+
     return true;
   }
 
-
-  // 启动服务器
-
   const spinner = ora({
     text: chalk.cyan('Starting AI Code Switch server...'),
     color: 'cyan',
@@ -79,12 +71,11 @@ const start = async (options = {}) => {
   }
 
   // 启动服务器进程 - 完全分离
-  // 打开日志文件用于输出
   const logFd = fs.openSync(LOG_FILE, 'a');
 
   const serverProcess = spawn('node', [serverPath], {
     detached: true,
-    stdio: ['ignore', logFd, logFd]  // 使用文件描述符
+    stdio: ['ignore', logFd, logFd]
   });
 
   // 关闭文件描述符(子进程会保持打开)
@@ -104,13 +95,13 @@ const start = async (options = {}) => {
     try {
       const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8'), 10);
       process.kill(pid, 0);
+
       if (!silent) {
         spinner.succeed(chalk.green('Server started successfully!'));
 
-        const { host, port } = getServerInfo();
-        const url = `http://${host}:${port}`;
+        const { host: runningHost, port: runningPort } = getServerInfo();
+        const url = `http://${runningHost}:${runningPort}`;
 
-        // 显示漂亮的启动信息
         console.log(boxen(
           chalk.green.bold('🚀 AI Code Switch Server\n\n') +
           chalk.white('Status:  ') + chalk.green.bold('● Running\n') +
@@ -133,9 +124,7 @@ const start = async (options = {}) => {
         console.log('\n');
       }
 
-      // (callback)
       if (callback) callback();
-      // 立即退出,返回控制台
       if (!noExit) process.exit(0);
       return true;
     } catch (err) {
@@ -144,13 +133,12 @@ const start = async (options = {}) => {
       if (!noExit) process.exit(1);
       return false;
     }
-  } else {
-    spinner.fail(chalk.red('Failed to start server!'));
-    console.log(chalk.yellow(`\nCheck logs: ${chalk.cyan(LOG_FILE)}\n`));
-    if (!noExit) process.exit(1);
-    return false;
   }
+
+  spinner.fail(chalk.red('Failed to start server!'));
+  console.log(chalk.yellow(`\nCheck logs: ${chalk.cyan(LOG_FILE)}\n`));
+  if (!noExit) process.exit(1);
+  return false;
 };
 
-// 导出辅助函数供其他模块使用
-module.exports = start;
+module.exports = start;

package/bin/stop.js

@@ -25,7 +25,7 @@ const stop = async (options = {}) => {
         console.log('\n' + chalk.gray(`Process found: ${chalk.white(pid)} (${chalk.gray(processInfo)})`));
       }
 
-      // 尝试终止进程
+      // 尝试终止进程（服务端会在 SIGTERM/SIGINT 时执行配置恢复）
       process.kill(pid, 'SIGTERM');
 
       // 等待进程停止
@@ -58,7 +58,7 @@ const stop = async (options = {}) => {
     catch (err) {
       // 进程不存在
       if (err.code === 'ESRCH') {
-          spinner.warn(chalk.yellow(`PID ${pid} not found!`));
+        spinner.warn(chalk.yellow(`PID ${pid} not found!`));
       }
       else {
         spinner.fail(chalk.red(`\nError: ${err.message}\n`));
@@ -115,4 +115,4 @@ const showStoppedMessage = () => {
   console.log(chalk.white('Use ') + chalk.cyan('aicos start') + chalk.white(' to start the server again.\n'));
 };
 
-module.exports = stop;
+module.exports = stop;