aicodeswitch 2.0.3 → 2.0.5

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### 2.0.5 (2026-01-27)
+
+### 2.0.4 (2026-01-27)
+
 ### 2.0.3 (2026-01-27)
 
 ### 2.0.2 (2026-01-27)

package/bin/restore.js

@@ -17,7 +17,7 @@ const restoreClaudeConfig = () => {
     const homeDir = os.homedir();
     const claudeDir = path.join(homeDir, '.claude');
     const claudeSettingsPath = path.join(claudeDir, 'settings.json');
-    const claudeSettingsBakPath = path.join(claudeDir, 'settings.json.bak');
+    const claudeSettingsBakPath = path.join(claudeDir, 'settings.json.aicodeswitch_backup');
 
     // Restore settings.json
     if (fs.existsSync(claudeSettingsBakPath)) {
@@ -27,7 +27,7 @@ const restoreClaudeConfig = () => {
       fs.renameSync(claudeSettingsBakPath, claudeSettingsPath);
       results.restored.push('settings.json');
     } else {
-      results.notFound.push('settings.json.bak');
+      results.notFound.push('settings.json.aicodeswitch_backup');
     }
   } catch (err) {
     results.errors.push({ file: 'settings.json', error: err.message });
@@ -36,7 +36,7 @@ const restoreClaudeConfig = () => {
   try {
     const homeDir = os.homedir();
     const claudeJsonPath = path.join(homeDir, '.claude.json');
-    const claudeJsonBakPath = path.join(homeDir, '.claude.json.bak');
+    const claudeJsonBakPath = path.join(homeDir, '.claude.json.aicodeswitch_backup');
 
     // Restore .claude.json
     if (fs.existsSync(claudeJsonBakPath)) {
@@ -46,7 +46,7 @@ const restoreClaudeConfig = () => {
       fs.renameSync(claudeJsonBakPath, claudeJsonPath);
       results.restored.push('.claude.json');
     } else {
-      results.notFound.push('.claude.json.bak');
+      results.notFound.push('.claude.json.aicodeswitch_backup');
     }
   } catch (err) {
     results.errors.push({ file: '.claude.json', error: err.message });
@@ -67,7 +67,7 @@ const restoreCodexConfig = () => {
     const homeDir = os.homedir();
     const codexDir = path.join(homeDir, '.codex');
     const codexConfigPath = path.join(codexDir, 'config.toml');
-    const codexConfigBakPath = path.join(codexDir, 'config.toml.bak');
+    const codexConfigBakPath = path.join(codexDir, 'config.toml.aicodeswitch_backup');
 
     // Restore config.toml
     if (fs.existsSync(codexConfigBakPath)) {
@@ -77,7 +77,7 @@ const restoreCodexConfig = () => {
       fs.renameSync(codexConfigBakPath, codexConfigPath);
       results.restored.push('config.toml');
     } else {
-      results.notFound.push('config.toml.bak');
+      results.notFound.push('config.toml.aicodeswitch_backup');
     }
   } catch (err) {
     results.errors.push({ file: 'config.toml', error: err.message });
@@ -86,7 +86,7 @@ const restoreCodexConfig = () => {
   try {
     const homeDir = os.homedir();
     const codexAuthPath = path.join(homeDir, '.codex', 'auth.json');
-    const codexAuthBakPath = path.join(homeDir, '.codex', 'auth.json.bak');
+    const codexAuthBakPath = path.join(homeDir, '.codex', 'auth.json.aicodeswitch_backup');
 
     // Restore auth.json
     if (fs.existsSync(codexAuthBakPath)) {
@@ -96,7 +96,7 @@ const restoreCodexConfig = () => {
       fs.renameSync(codexAuthBakPath, codexAuthPath);
       results.restored.push('auth.json');
     } else {
-      results.notFound.push('auth.json.bak');
+      results.notFound.push('auth.json.aicodeswitch_backup');
     }
   } catch (err) {
     results.errors.push({ file: 'auth.json', error: err.message });

package/dist/server/config-metadata.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupInvalidMetadata = exports.checkCodexConfigStatus = exports.checkClaudeConfigStatus = exports.deleteMetadata = exports.loadMetadata = exports.saveMetadata = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+/**
+ * 获取元数据文件路径
+ */
+const getMetadataFilePath = (configType) => {
+    const dataDir = path_1.default.join(os_1.default.homedir(), '.aicodeswitch/data');
+    return path_1.default.join(dataDir, `.${configType}-metadata.json`);
+};
+/**
+ * 保存配置元数据
+ */
+const saveMetadata = (metadata) => {
+    try {
+        const metadataPath = getMetadataFilePath(metadata.configType);
+        const dataDir = path_1.default.dirname(metadataPath);
+        // 确保目录存在
+        if (!fs_1.default.existsSync(dataDir)) {
+            fs_1.default.mkdirSync(dataDir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8');
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to save metadata for ${metadata.configType}:`, error);
+        return false;
+    }
+};
+exports.saveMetadata = saveMetadata;
+/**
+ * 读取配置元数据
+ */
+const loadMetadata = (configType) => {
+    try {
+        const metadataPath = getMetadataFilePath(configType);
+        if (!fs_1.default.existsSync(metadataPath)) {
+            return null;
+        }
+        const content = fs_1.default.readFileSync(metadataPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.error(`Failed to load metadata for ${configType}:`, error);
+        return null;
+    }
+};
+exports.loadMetadata = loadMetadata;
+/**
+ * 删除配置元数据
+ */
+const deleteMetadata = (configType) => {
+    try {
+        const metadataPath = getMetadataFilePath(configType);
+        if (fs_1.default.existsSync(metadataPath)) {
+            fs_1.default.unlinkSync(metadataPath);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to delete metadata for ${configType}:`, error);
+        return false;
+    }
+};
+exports.deleteMetadata = deleteMetadata;
+/**
+ * 计算文件的 SHA256 hash
+ */
+const calculateFileHash = (filePath) => {
+    try {
+        if (!fs_1.default.existsSync(filePath)) {
+            return null;
+        }
+        const crypto = require('crypto');
+        const content = fs_1.default.readFileSync(filePath, 'utf-8');
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+    catch (error) {
+        console.error(`Failed to calculate hash for ${filePath}:`, error);
+        return null;
+    }
+};
+/**
+ * 检查 Claude 配置文件是否包含我们的代理特征
+ */
+const isClaudeProxyConfig = (filePath) => {
+    var _a;
+    try {
+        if (!fs_1.default.existsSync(filePath)) {
+            return false;
+        }
+        const content = fs_1.default.readFileSync(filePath, 'utf-8');
+        const config = JSON.parse(content);
+        // 检查是否包含我们的 ANTHROPIC_BASE_URL 配置
+        // 用户可能会修改端口,所以我们只检查主机名部分
+        const baseUrl = (_a = config.env) === null || _a === void 0 ? void 0 : _a.ANTHROPIC_BASE_URL;
+        if (baseUrl && typeof baseUrl === 'string') {
+            // 允许的格式: http://127.0.0.1:4567/claude-code 或 http://localhost:4567/claude-code
+            return /https?:\/\/(127\.0\.0\.1|localhost)(:\d+)?\/claude-code/.test(baseUrl);
+        }
+        return false;
+    }
+    catch (error) {
+        console.error(`Failed to check Claude config:`, error);
+        return false;
+    }
+};
+/**
+ * 检查 Codex 配置文件是否包含我们的代理特征
+ */
+const isCodexProxyConfig = (configPath) => {
+    try {
+        // 检查 config.toml
+        if (fs_1.default.existsSync(configPath)) {
+            const content = fs_1.default.readFileSync(configPath, 'utf-8');
+            // 检查是否包含我们的 model_provider 和 base_url 配置
+            const hasModelProvider = content.includes('model_provider = "aicodeswitch"');
+            const hasBaseUrl = /base_url = "https?:\/\/(127\.0\.0\.1|localhost)(:\d+)?\/codex"/.test(content);
+            if (hasModelProvider && hasBaseUrl) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        console.error(`Failed to check Codex config:`, error);
+        return false;
+    }
+};
+/**
+ * 检查 Claude 配置状态
+ */
+const checkClaudeConfigStatus = () => {
+    var _a;
+    const homeDir = os_1.default.homedir();
+    const settingsPath = path_1.default.join(homeDir, '.claude/settings.json');
+    const settingsBakPath = path_1.default.join(homeDir, '.claude/settings.json.aicodeswitch_backup');
+    const claudeJsonBakPath = path_1.default.join(homeDir, '.claude.json.aicodeswitch_backup');
+    // 检查备份文件是否存在
+    const hasBackup = fs_1.default.existsSync(settingsBakPath) || fs_1.default.existsSync(claudeJsonBakPath);
+    // 尝试加载元数据
+    const metadata = (0, exports.loadMetadata)('claude');
+    if (metadata) {
+        // 如果元数据存在,进行详细检查
+        const currentHash = calculateFileHash(settingsPath);
+        const isProxyConfig = isClaudeProxyConfig(settingsPath);
+        // 检查是否被修改
+        let isModified = false;
+        if (currentHash && ((_a = metadata.files[0]) === null || _a === void 0 ? void 0 : _a.currentHash)) {
+            isModified = currentHash !== metadata.files[0].currentHash;
+        }
+        // 如果当前配置不是我们的代理配置,说明用户已经恢复或修改了
+        const isOverwritten = isProxyConfig;
+        return {
+            isOverwritten,
+            isModified,
+            hasBackup,
+            metadata
+        };
+    }
+    // 如果元数据不存在,降级到简单检查
+    if (hasBackup) {
+        // 有备份文件,但没有元数据(可能是旧版本)
+        // 检查当前配置是否是我们的代理配置
+        const isProxyConfig = isClaudeProxyConfig(settingsPath);
+        return {
+            isOverwritten: isProxyConfig,
+            isModified: false, // 无法判断是否被修改
+            hasBackup
+        };
+    }
+    // 没有备份也没有元数据
+    // 检查当前配置是否恰好是我们的代理配置
+    const isProxyConfig = isClaudeProxyConfig(settingsPath);
+    return {
+        isOverwritten: isProxyConfig,
+        isModified: false,
+        hasBackup: false
+    };
+};
+exports.checkClaudeConfigStatus = checkClaudeConfigStatus;
+/**
+ * 检查 Codex 配置状态
+ */
+const checkCodexConfigStatus = () => {
+    var _a;
+    const homeDir = os_1.default.homedir();
+    const configPath = path_1.default.join(homeDir, '.codex/config.toml');
+    const configBakPath = path_1.default.join(homeDir, '.codex/config.toml.aicodeswitch_backup');
+    const authBakPath = path_1.default.join(homeDir, '.codex/auth.json.aicodeswitch_backup');
+    // 检查备份文件是否存在
+    const hasBackup = fs_1.default.existsSync(configBakPath) || fs_1.default.existsSync(authBakPath);
+    // 尝试加载元数据
+    const metadata = (0, exports.loadMetadata)('codex');
+    if (metadata) {
+        // 如果元数据存在,进行详细检查
+        const currentHash = calculateFileHash(configPath);
+        const isProxyConfig = isCodexProxyConfig(configPath);
+        // 检查是否被修改
+        let isModified = false;
+        if (currentHash && ((_a = metadata.files[0]) === null || _a === void 0 ? void 0 : _a.currentHash)) {
+            isModified = currentHash !== metadata.files[0].currentHash;
+        }
+        // 如果当前配置不是我们的代理配置,说明用户已经恢复或修改了
+        const isOverwritten = isProxyConfig;
+        return {
+            isOverwritten,
+            isModified,
+            hasBackup,
+            metadata
+        };
+    }
+    // 如果元数据不存在,降级到简单检查
+    if (hasBackup) {
+        // 有备份文件,但没有元数据(可能是旧版本)
+        // 检查当前配置是否是我们的代理配置
+        const isProxyConfig = isCodexProxyConfig(configPath);
+        return {
+            isOverwritten: isProxyConfig,
+            isModified: false, // 无法判断是否被修改
+            hasBackup
+        };
+    }
+    // 没有备份也没有元数据
+    // 检查当前配置是否恰好是我们的代理配置
+    const isProxyConfig = isCodexProxyConfig(configPath);
+    return {
+        isOverwritten: isProxyConfig,
+        isModified: false,
+        hasBackup: false
+    };
+};
+exports.checkCodexConfigStatus = checkCodexConfigStatus;
+/**
+ * 清理无效的元数据
+ * 当备份文件不存在但元数据存在时,说明状态不一致,需要清理
+ */
+const cleanupInvalidMetadata = (configType) => {
+    try {
+        const metadata = (0, exports.loadMetadata)(configType);
+        if (!metadata) {
+            return true; // 没有元数据,无需清理
+        }
+        // 检查备份文件是否还存在
+        const hasAnyBackup = metadata.files.some(file => fs_1.default.existsSync(file.backupPath));
+        if (!hasAnyBackup) {
+            // 备份文件都不存在了,删除元数据
+            console.warn(`Cleaning up invalid metadata for ${configType}: no backup files found`);
+            return (0, exports.deleteMetadata)(configType);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to cleanup metadata for ${configType}:`, error);
+        return false;
+    }
+};
+exports.cleanupInvalidMetadata = cleanupInvalidMetadata;

package/dist/server/main.js

@@ -24,6 +24,7 @@ const os_1 = __importDefault(require("os"));
 const auth_1 = require("./auth");
 const version_check_1 = require("./version-check");
 const utils_1 = require("./utils");
+const config_metadata_1 = require("./config-metadata");
 const dotenvPath = path_1.default.resolve(os_1.default.homedir(), '.aicodeswitch/aicodeswitch.conf');
 if (fs_1.default.existsSync(dotenvPath)) {
     dotenv_1.default.config({ path: dotenvPath });
@@ -46,15 +47,28 @@ const writeClaudeConfig = (dbManager) => __awaiter(void 0, void 0, void 0, funct
         // Claude Code settings.json
         const claudeDir = path_1.default.join(homeDir, '.claude');
         const claudeSettingsPath = path_1.default.join(claudeDir, 'settings.json');
-        const claudeSettingsBakPath = path_1.default.join(claudeDir, 'settings.json.bak');
-        const claudeJsonBakPath = path_1.default.join(homeDir, '.claude.json.bak');
-        // Check if any backup file already exists
-        if (fs_1.default.existsSync(claudeSettingsBakPath) || fs_1.default.existsSync(claudeJsonBakPath)) {
-            console.error('Claude backup files already exist, refusing to overwrite');
+        const claudeSettingsBakPath = path_1.default.join(claudeDir, 'settings.json.aicodeswitch_backup');
+        const claudeJsonBakPath = path_1.default.join(homeDir, '.claude.json.aicodeswitch_backup');
+        // 使用新的配置状态检测来判断是否可以写入
+        const configStatus = (0, config_metadata_1.checkClaudeConfigStatus)();
+        // 只有当当前配置已经是代理配置时，才拒绝写入
+        if (configStatus.isOverwritten) {
+            console.error('Claude config has already been overwritten. Please restore the original config first.');
             return false;
         }
-        if (fs_1.default.existsSync(claudeSettingsPath)) {
-            fs_1.default.renameSync(claudeSettingsPath, claudeSettingsBakPath);
+        // 如果 .aicodeswitch_backup 文件不存在，才进行备份（避免覆盖已有备份）
+        let originalSettingsHash = undefined;
+        if (!fs_1.default.existsSync(claudeSettingsBakPath)) {
+            // 计算原始配置文件的 hash(如果存在)
+            if (fs_1.default.existsSync(claudeSettingsPath)) {
+                originalSettingsHash = (0, crypto_1.createHash)('sha256').update(fs_1.default.readFileSync(claudeSettingsPath, 'utf-8')).digest('hex');
+                // 备份当前配置文件
+                fs_1.default.renameSync(claudeSettingsPath, claudeSettingsBakPath);
+            }
+        }
+        else {
+            // .aicodeswitch_backup 已存在，直接使用现有的备份文件
+            console.log('Backup file already exists, skipping backup step');
         }
         if (!fs_1.default.existsSync(claudeDir)) {
             fs_1.default.mkdirSync(claudeDir, { recursive: true });
@@ -69,8 +83,11 @@ const writeClaudeConfig = (dbManager) => __awaiter(void 0, void 0, void 0, funct
         fs_1.default.writeFileSync(claudeSettingsPath, JSON.stringify(claudeSettings, null, 2));
         // Claude Code .claude.json
         const claudeJsonPath = path_1.default.join(homeDir, '.claude.json');
-        if (fs_1.default.existsSync(claudeJsonPath)) {
-            fs_1.default.renameSync(claudeJsonPath, claudeJsonBakPath);
+        // 同样处理 .claude.json 的备份
+        if (!fs_1.default.existsSync(claudeJsonBakPath)) {
+            if (fs_1.default.existsSync(claudeJsonPath)) {
+                fs_1.default.renameSync(claudeJsonPath, claudeJsonBakPath);
+            }
         }
         let claudeJson = {};
         if (fs_1.default.existsSync(claudeJsonPath)) {
@@ -78,6 +95,26 @@ const writeClaudeConfig = (dbManager) => __awaiter(void 0, void 0, void 0, funct
         }
         claudeJson.hasCompletedOnboarding = true;
         fs_1.default.writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2));
+        // 保存元数据
+        const currentSettingsHash = (0, crypto_1.createHash)('sha256').update(fs_1.default.readFileSync(claudeSettingsPath, 'utf-8')).digest('hex');
+        const metadata = {
+            configType: 'claude',
+            timestamp: Date.now(),
+            originalHash: originalSettingsHash,
+            proxyMarker: `http://${host}:${port}/claude-code`,
+            files: [
+                {
+                    originalPath: claudeSettingsPath,
+                    backupPath: claudeSettingsBakPath,
+                    currentHash: currentSettingsHash
+                },
+                {
+                    originalPath: claudeJsonPath,
+                    backupPath: claudeJsonBakPath
+                }
+            ]
+        };
+        (0, config_metadata_1.saveMetadata)(metadata);
         return true;
     }
     catch (error) {
@@ -93,15 +130,28 @@ const writeCodexConfig = (dbManager) => __awaiter(void 0, void 0, void 0, functi
         // Codex config.toml
         const codexDir = path_1.default.join(homeDir, '.codex');
         const codexConfigPath = path_1.default.join(codexDir, 'config.toml');
-        const codexConfigBakPath = path_1.default.join(codexDir, 'config.toml.bak');
-        const codexAuthBakPath = path_1.default.join(codexDir, 'auth.json.bak');
-        // Check if any backup file already exists
-        if (fs_1.default.existsSync(codexConfigBakPath) || fs_1.default.existsSync(codexAuthBakPath)) {
-            console.error('Codex backup files already exist, refusing to overwrite');
+        const codexConfigBakPath = path_1.default.join(codexDir, 'config.toml.aicodeswitch_backup');
+        const codexAuthBakPath = path_1.default.join(codexDir, 'auth.json.aicodeswitch_backup');
+        // 使用新的配置状态检测来判断是否可以写入
+        const configStatus = (0, config_metadata_1.checkCodexConfigStatus)();
+        // 只有当当前配置已经是代理配置时，才拒绝写入
+        if (configStatus.isOverwritten) {
+            console.error('Codex config has already been overwritten. Please restore the original config first.');
             return false;
         }
-        if (fs_1.default.existsSync(codexConfigPath)) {
-            fs_1.default.renameSync(codexConfigPath, codexConfigBakPath);
+        // 如果 .aicodeswitch_backup 文件不存在，才进行备份（避免覆盖已有备份）
+        let originalConfigHash = undefined;
+        if (!fs_1.default.existsSync(codexConfigBakPath)) {
+            // 计算原始配置文件的 hash(如果存在)
+            if (fs_1.default.existsSync(codexConfigPath)) {
+                originalConfigHash = (0, crypto_1.createHash)('sha256').update(fs_1.default.readFileSync(codexConfigPath, 'utf-8')).digest('hex');
+                // 备份当前配置文件
+                fs_1.default.renameSync(codexConfigPath, codexConfigBakPath);
+            }
+        }
+        else {
+            // .aicodeswitch_backup 已存在，直接使用现有的备份文件
+            console.log('Backup file already exists, skipping backup step');
         }
         if (!fs_1.default.existsSync(codexDir)) {
             fs_1.default.mkdirSync(codexDir, { recursive: true });
@@ -121,13 +171,36 @@ requires_openai_auth = true
         fs_1.default.writeFileSync(codexConfigPath, codexConfig);
         // Codex auth.json
         const codexAuthPath = path_1.default.join(codexDir, 'auth.json');
-        if (fs_1.default.existsSync(codexAuthPath)) {
-            fs_1.default.renameSync(codexAuthPath, codexAuthBakPath);
+        // 同样处理 auth.json 的备份
+        if (!fs_1.default.existsSync(codexAuthBakPath)) {
+            if (fs_1.default.existsSync(codexAuthPath)) {
+                fs_1.default.renameSync(codexAuthPath, codexAuthBakPath);
+            }
         }
         const codexAuth = {
             OPENAI_API_KEY: config.apiKey || "api_key"
         };
         fs_1.default.writeFileSync(codexAuthPath, JSON.stringify(codexAuth, null, 2));
+        // 保存元数据
+        const currentConfigHash = (0, crypto_1.createHash)('sha256').update(fs_1.default.readFileSync(codexConfigPath, 'utf-8')).digest('hex');
+        const metadata = {
+            configType: 'codex',
+            timestamp: Date.now(),
+            originalHash: originalConfigHash,
+            proxyMarker: `http://${host}:${port}/codex`,
+            files: [
+                {
+                    originalPath: codexConfigPath,
+                    backupPath: codexConfigBakPath,
+                    currentHash: currentConfigHash
+                },
+                {
+                    originalPath: codexAuthPath,
+                    backupPath: codexAuthBakPath
+                }
+            ]
+        };
+        (0, config_metadata_1.saveMetadata)(metadata);
         return true;
     }
     catch (error) {
@@ -141,7 +214,7 @@ const restoreClaudeConfig = () => __awaiter(void 0, void 0, void 0, function* ()
         // Restore Claude Code settings.json
         const claudeDir = path_1.default.join(homeDir, '.claude');
         const claudeSettingsPath = path_1.default.join(claudeDir, 'settings.json');
-        const claudeSettingsBakPath = path_1.default.join(claudeDir, 'settings.json.bak');
+        const claudeSettingsBakPath = path_1.default.join(claudeDir, 'settings.json.aicodeswitch_backup');
         if (fs_1.default.existsSync(claudeSettingsBakPath)) {
             if (fs_1.default.existsSync(claudeSettingsPath)) {
                 fs_1.default.unlinkSync(claudeSettingsPath);
@@ -150,13 +223,15 @@ const restoreClaudeConfig = () => __awaiter(void 0, void 0, void 0, function* ()
         }
         // Restore Claude Code .claude.json
         const claudeJsonPath = path_1.default.join(homeDir, '.claude.json');
-        const claudeJsonBakPath = path_1.default.join(homeDir, '.claude.json.bak');
+        const claudeJsonBakPath = path_1.default.join(homeDir, '.claude.json.aicodeswitch_backup');
         if (fs_1.default.existsSync(claudeJsonBakPath)) {
             if (fs_1.default.existsSync(claudeJsonPath)) {
                 fs_1.default.unlinkSync(claudeJsonPath);
             }
             fs_1.default.renameSync(claudeJsonBakPath, claudeJsonPath);
         }
+        // 删除元数据
+        (0, config_metadata_1.deleteMetadata)('claude');
         return true;
     }
     catch (error) {
@@ -170,7 +245,7 @@ const restoreCodexConfig = () => __awaiter(void 0, void 0, void 0, function* ()
         // Restore Codex config.toml
         const codexDir = path_1.default.join(homeDir, '.codex');
         const codexConfigPath = path_1.default.join(codexDir, 'config.toml');
-        const codexConfigBakPath = path_1.default.join(codexDir, 'config.toml.bak');
+        const codexConfigBakPath = path_1.default.join(codexDir, 'config.toml.aicodeswitch_backup');
         if (fs_1.default.existsSync(codexConfigBakPath)) {
             if (fs_1.default.existsSync(codexConfigPath)) {
                 fs_1.default.unlinkSync(codexConfigPath);
@@ -179,13 +254,15 @@ const restoreCodexConfig = () => __awaiter(void 0, void 0, void 0, function* ()
         }
         // Restore Codex auth.json
         const codexAuthPath = path_1.default.join(codexDir, 'auth.json');
-        const codexAuthBakPath = path_1.default.join(codexDir, 'auth.json.bak');
+        const codexAuthBakPath = path_1.default.join(codexDir, 'auth.json.aicodeswitch_backup');
         if (fs_1.default.existsSync(codexAuthBakPath)) {
             if (fs_1.default.existsSync(codexAuthPath)) {
                 fs_1.default.unlinkSync(codexAuthPath);
             }
             fs_1.default.renameSync(codexAuthBakPath, codexAuthPath);
         }
+        // 删除元数据
+        (0, config_metadata_1.deleteMetadata)('codex');
         return true;
     }
     catch (error) {
@@ -195,10 +272,12 @@ const restoreCodexConfig = () => __awaiter(void 0, void 0, void 0, function* ()
 });
 const checkClaudeBackupExists = () => {
     try {
-        const homeDir = os_1.default.homedir();
-        const claudeSettingsBakPath = path_1.default.join(homeDir, '.claude', 'settings.json.bak');
-        const claudeJsonBakPath = path_1.default.join(homeDir, '.claude.json.bak');
-        return fs_1.default.existsSync(claudeSettingsBakPath) || fs_1.default.existsSync(claudeJsonBakPath);
+        // 清理可能的无效元数据
+        (0, config_metadata_1.cleanupInvalidMetadata)('claude');
+        // 使用新的配置状态检测
+        const status = (0, config_metadata_1.checkClaudeConfigStatus)();
+        // 返回是否已被覆盖(用于向后兼容)
+        return status.isOverwritten;
     }
     catch (error) {
         console.error('Failed to check Claude backup files:', error);
@@ -207,10 +286,12 @@ const checkClaudeBackupExists = () => {
 };
 const checkCodexBackupExists = () => {
     try {
-        const homeDir = os_1.default.homedir();
-        const codexConfigBakPath = path_1.default.join(homeDir, '.codex', 'config.toml.bak');
-        const codexAuthBakPath = path_1.default.join(homeDir, '.codex', 'auth.json.bak');
-        return fs_1.default.existsSync(codexConfigBakPath) || fs_1.default.existsSync(codexAuthBakPath);
+        // 清理可能的无效元数据
+        (0, config_metadata_1.cleanupInvalidMetadata)('codex');
+        // 使用新的配置状态检测
+        const status = (0, config_metadata_1.checkCodexConfigStatus)();
+        // 返回是否已被覆盖(用于向后兼容)
+        return status.isOverwritten;
     }
     catch (error) {
         console.error('Failed to check Codex backup files:', error);
@@ -396,6 +477,15 @@ const registerRoutes = (dbManager, proxyServer) => {
     app.get('/api/check-backup/codex', (_req, res) => {
         res.json({ exists: checkCodexBackupExists() });
     });
+    // 新的详细配置状态 API 端点
+    app.get('/api/config-status/claude', (_req, res) => {
+        const status = (0, config_metadata_1.checkClaudeConfigStatus)();
+        res.json(status);
+    });
+    app.get('/api/config-status/codex', (_req, res) => {
+        const status = (0, config_metadata_1.checkCodexConfigStatus)();
+        res.json(status);
+    });
     app.post('/api/export', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
         const { password } = req.body;
         const data = yield dbManager.exportData(password);

package/dist/server/proxy-server.js

@@ -1127,14 +1127,40 @@ class ProxyServer {
             }
         });
     }
+    /**
+     * 对敏感的 header 值进行脱敏处理
+     * @param key header 键（小写）
+     * @param value header 值
+     * @returns 脱敏后的值，如果 header 是敏感的则返回 32 个 *
+     */
+    sanitizeHeaderValue(key, value) {
+        // 需要脱敏的敏感 header 列表（不区分大小写）
+        const sensitiveHeaders = [
+            'authorization', // Bearer token
+            'x-api-key', // API key
+            'api-key', // API key
+            'apikey', // API key
+            'x-openai-api-key', // OpenAI API key
+            'openai-api-key', // OpenAI API key
+            'anthropic-api-key', // Anthropic API key
+            'access-token', // Access token
+            'x-anthropic-api-key', // Anthropic API key
+            'refresh-token', // Refresh token
+        ];
+        // 检查是否是敏感 header
+        if (sensitiveHeaders.includes(key)) {
+            return '********************************';
+        }
+        return value;
+    }
     normalizeHeaders(headers) {
         const normalized = {};
         for (const [key, value] of Object.entries(headers)) {
             if (typeof value === 'string') {
-                normalized[key] = value;
+                normalized[key] = this.sanitizeHeaderValue(key.toLowerCase(), value);
             }
             else if (Array.isArray(value)) {
-                normalized[key] = value.join(', ');
+                normalized[key] = this.sanitizeHeaderValue(key.toLowerCase(), value.join(', '));
             }
         }
         return normalized;
@@ -1144,13 +1170,13 @@ class ProxyServer {
         for (const [key, value] of Object.entries(headers)) {
             if (value !== null && value !== undefined) {
                 if (typeof value === 'string') {
-                    normalized[key] = value;
+                    normalized[key] = this.sanitizeHeaderValue(key.toLowerCase(), value);
                 }
                 else if (Array.isArray(value)) {
-                    normalized[key] = value.join(', ');
+                    normalized[key] = this.sanitizeHeaderValue(key.toLowerCase(), value.join(', '));
                 }
                 else {
-                    normalized[key] = String(value);
+                    normalized[key] = this.sanitizeHeaderValue(key.toLowerCase(), String(value));
                 }
             }
         }