aicodeswitch 3.0.2 → 3.0.4

package/README.md

@@ -105,6 +105,7 @@ Codex的配置覆盖逻辑一模一样。
 *   Claude Chat
 *   Claude Code
 *   DeepSeek Chat
+*   Gemini
 
 **有什么用？**
 
@@ -141,6 +142,12 @@ aicodeswitch内部，会根据“源类型”来转换数据。例如，你的
 
 当同一请求类型配置多个规则时,系统会按排序优先使用第一个，如果某个服务报错(4xx/5xx)或请求超时，将自动切换到下一个可用规则，确保你可以正常使用coding工具。
 
+### 数据转流
+
+支持将openai的流式响应数据转换成Claude Code的流式数据，并支持实时转换，从而可以让你使用支持openAI的API服务来在Claude Code中使用。
+
+*不过，需要注意，如果你的API服务商不支持tools，或者所支持的max_tokens太小，是无法在Claude Code中使用的。*
+
 ## Skills管理
 
 你可以在 aicodeswitch 中集中统一管理 skills，把skills分发给claude code和codex，随时启用和停用skills。

package/dist/server/fs-database.js

@@ -137,6 +137,18 @@ class FileSystemDatabaseManager {
             writable: true,
             value: this.createEmptyStatistics()
         });
+        Object.defineProperty(this, "contentTypeDistributionInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "contentTypeDistributionInitializing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         // 缓存机制
         Object.defineProperty(this, "logsCountCache", {
             enumerable: true,
@@ -169,6 +181,16 @@ class FileSystemDatabaseManager {
             writable: true,
             value: 30
         });
+        // Export/Import operations
+        /**
+         * 当前支持的导出数据版本
+         */
+        Object.defineProperty(this, "CURRENT_EXPORT_VERSION", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: '3.0.0'
+        });
         this.dataPath = dataPath;
     }
     initialize() {
@@ -252,12 +274,7 @@ class FileSystemDatabaseManager {
                 }
                 // 保存新的 vendors.json
                 yield this.saveVendors();
-                // 备份旧文件
-                const timestamp = Date.now();
-                const backupFile = path_1.default.join(this.dataPath, `services.json.backup.${timestamp}`);
-                yield promises_1.default.rename(oldServicesFile, backupFile);
                 console.log(`[Database] 迁移完成：${migratedCount} 个服务已迁移`);
-                console.log(`[Database] 旧的 services.json 已备份到 ${backupFile}`);
             }
             catch (err) {
                 if (err.code === 'ENOENT') {
@@ -376,18 +393,6 @@ class FileSystemDatabaseManager {
             if (routesFileFormat !== 'combined' || merged || (routesFileFormat === 'combined' && !hasRulesInRoutesFile)) {
                 yield this.saveRoutesData();
             }
-            // 备份旧的 rules.json 文件
-            if (oldRulesExists) {
-                try {
-                    const timestamp = Date.now();
-                    const backupFile = path_1.default.join(this.dataPath, `rules.json.backup.${timestamp}`);
-                    yield promises_1.default.rename(oldRulesFile, backupFile);
-                    console.log(`[Database] 旧的 rules.json 已备份到 ${backupFile}`);
-                }
-                catch (error) {
-                    console.error('[Database] 备份 rules.json 失败:', error);
-                }
-            }
         });
     }
     loadConfig() {
@@ -522,10 +527,6 @@ class FileSystemDatabaseManager {
                 // 保存索引
                 yield this.saveLogsIndex();
                 console.log(`[Database] Successfully migrated ${migratedCount} log entries to ${this.logShardsIndex.length} shard(s)`);
-                // 备份旧文件
-                const backupFile = path_1.default.join(this.dataPath, 'logs.json.backup');
-                yield promises_1.default.rename(oldLogsFile, backupFile);
-                console.log(`[Database] Old logs.json backed up to ${backupFile}`);
             }
             catch (err) {
                 if (err.code === 'ENOENT') {
@@ -668,9 +669,11 @@ class FileSystemDatabaseManager {
             try {
                 const data = yield promises_1.default.readFile(this.statisticsFile, 'utf-8');
                 this.statistics = JSON.parse(data);
+                this.contentTypeDistributionInitialized = this.statistics.contentTypeDistribution.length > 0;
             }
             catch (_a) {
                 this.statistics = this.createEmptyStatistics();
+                this.contentTypeDistributionInitialized = false;
                 // 创建空文件
                 yield this.saveStatistics();
             }
@@ -1165,7 +1168,8 @@ class FileSystemDatabaseManager {
     addLog(log) {
         return __awaiter(this, void 0, void 0, function* () {
             const id = crypto_1.default.randomUUID();
-            const logWithId = Object.assign(Object.assign({}, log), { id });
+            const contentType = this.resolveLogContentType(log);
+            const logWithId = Object.assign(Object.assign({}, log), { contentType, id });
             // 获取目标分片文件名
             const filename = yield this.getLogShardFilename(logWithId.timestamp);
             // 加载现有分片数据
@@ -1368,23 +1372,153 @@ class FileSystemDatabaseManager {
             return true;
         });
     }
-    // Export/Import operations
+    /**
+     * 验证供应商数据格式
+     */
+    validateVendor(vendor, index) {
+        if (!vendor || typeof vendor !== 'object') {
+            return { valid: false, error: `供应商[${index}] 不是有效的对象` };
+        }
+        if (!vendor.id || typeof vendor.id !== 'string') {
+            return { valid: false, error: `供应商[${index}] 缺少有效的 id 字段` };
+        }
+        if (!vendor.name || typeof vendor.name !== 'string') {
+            return { valid: false, error: `供应商[${index}](${vendor.id}) 缺少有效的 name 字段` };
+        }
+        if (!Array.isArray(vendor.services)) {
+            return { valid: false, error: `供应商[${index}](${vendor.id}) 的 services 不是数组` };
+        }
+        for (let i = 0; i < vendor.services.length; i++) {
+            const service = vendor.services[i];
+            if (!service || typeof service !== 'object') {
+                return { valid: false, error: `供应商[${index}](${vendor.id}) 的服务[${i}] 不是有效的对象` };
+            }
+            if (!service.id || typeof service.id !== 'string') {
+                return { valid: false, error: `供应商[${index}](${vendor.id}) 的服务[${i}] 缺少有效的 id 字段` };
+            }
+            if (!service.name || typeof service.name !== 'string') {
+                return { valid: false, error: `供应商[${index}](${vendor.id}) 的服务[${i}] 缺少有效的 name 字段` };
+            }
+            if (!service.apiUrl || typeof service.apiUrl !== 'string') {
+                return { valid: false, error: `供应商[${index}](${vendor.id}) 的服务[${i}] 缺少有效的 apiUrl 字段` };
+            }
+            if (!service.apiKey || typeof service.apiKey !== 'string') {
+                return { valid: false, error: `供应商[${index}](${vendor.id}) 的服务[${i}] 缺少有效的 apiKey 字段` };
+            }
+        }
+        return { valid: true };
+    }
+    /**
+     * 验证路由数据格式
+     */
+    validateRoute(route, index) {
+        if (!route || typeof route !== 'object') {
+            return { valid: false, error: `路由[${index}] 不是有效的对象` };
+        }
+        if (!route.id || typeof route.id !== 'string') {
+            return { valid: false, error: `路由[${index}] 缺少有效的 id 字段` };
+        }
+        if (!route.name || typeof route.name !== 'string') {
+            return { valid: false, error: `路由[${index}](${route.id}) 缺少有效的 name 字段` };
+        }
+        if (!route.targetType || !['claude-code', 'codex'].includes(route.targetType)) {
+            return { valid: false, error: `路由[${index}](${route.id}) 的 targetType 必须是 'claude-code' 或 'codex'` };
+        }
+        if (typeof route.isActive !== 'boolean') {
+            return { valid: false, error: `路由[${index}](${route.id}) 的 isActive 必须是布尔值` };
+        }
+        return { valid: true };
+    }
+    /**
+     * 验证规则数据格式
+     */
+    validateRule(rule, index) {
+        if (!rule || typeof rule !== 'object') {
+            return { valid: false, error: `规则[${index}] 不是有效的对象` };
+        }
+        if (!rule.id || typeof rule.id !== 'string') {
+            return { valid: false, error: `规则[${index}] 缺少有效的 id 字段` };
+        }
+        if (!rule.routeId || typeof rule.routeId !== 'string') {
+            return { valid: false, error: `规则[${index}](${rule.id}) 缺少有效的 routeId 字段` };
+        }
+        if (!rule.targetServiceId || typeof rule.targetServiceId !== 'string') {
+            return { valid: false, error: `规则[${index}](${rule.id}) 缺少有效的 targetServiceId 字段` };
+        }
+        const validContentTypes = ['default', 'background', 'thinking', 'long-context', 'image-understanding', 'model-mapping'];
+        if (!rule.contentType || !validContentTypes.includes(rule.contentType)) {
+            return { valid: false, error: `规则[${index}](${rule.id}) 的 contentType 无效` };
+        }
+        return { valid: true };
+    }
+    /**
+     * 验证配置数据格式
+     */
+    validateConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return { valid: false, error: 'config 不是有效的对象' };
+        }
+        return { valid: true };
+    }
+    /**
+     * 验证导出数据格式（严格校验）
+     */
+    validateExportData(data) {
+        if (!data || typeof data !== 'object') {
+            return { valid: false, error: '数据不是有效的对象' };
+        }
+        // 检查必需字段是否存在
+        if (!data.version || typeof data.version !== 'string') {
+            return { valid: false, error: '缺少有效的 version 字段' };
+        }
+        // 检查版本是否匹配当前版本
+        if (data.version !== this.CURRENT_EXPORT_VERSION) {
+            return { valid: false, error: `数据版本 ${data.version} 与当前支持的版本 ${this.CURRENT_EXPORT_VERSION} 不匹配。请使用相同版本的系统导出数据。` };
+        }
+        if (!data.exportDate || typeof data.exportDate !== 'number') {
+            return { valid: false, error: '缺少有效的 exportDate 字段' };
+        }
+        // 检查 vendors
+        if (!Array.isArray(data.vendors)) {
+            return { valid: false, error: 'vendors 不是数组' };
+        }
+        for (let i = 0; i < data.vendors.length; i++) {
+            const result = this.validateVendor(data.vendors[i], i);
+            if (!result.valid)
+                return result;
+        }
+        // 检查 routes
+        if (!Array.isArray(data.routes)) {
+            return { valid: false, error: 'routes 不是数组' };
+        }
+        for (let i = 0; i < data.routes.length; i++) {
+            const result = this.validateRoute(data.routes[i], i);
+            if (!result.valid)
+                return result;
+        }
+        // 检查 rules
+        if (!Array.isArray(data.rules)) {
+            return { valid: false, error: 'rules 不是数组' };
+        }
+        for (let i = 0; i < data.rules.length; i++) {
+            const result = this.validateRule(data.rules[i], i);
+            if (!result.valid)
+                return result;
+        }
+        // 检查 config
+        const configResult = this.validateConfig(data.config);
+        if (!configResult.valid)
+            return configResult;
+        return { valid: true };
+    }
     exportData(password) {
         return __awaiter(this, void 0, void 0, function* () {
-            // 扁平化所有服务（兼容旧格式）
-            const allServices = [];
-            for (const vendor of this.vendors) {
-                if (vendor.services) {
-                    // 为每个服务添加 vendorId（兼容旧格式）
-                    const servicesWithVendorId = vendor.services.map(s => (Object.assign(Object.assign({}, s), { vendorId: vendor.id })));
-                    allServices.push(...servicesWithVendorId);
-                }
-            }
+            // 只导出当前格式，不再兼容旧格式
             const exportData = {
-                version: '2.0.0', // 更新版本号
+                version: this.CURRENT_EXPORT_VERSION,
                 exportDate: Date.now(),
                 vendors: this.vendors,
-                apiServices: allServices, // 兼容旧格式
+                apiServices: [], // 保留字段以兼容类型定义，但内容为空
                 routes: this.routes,
                 rules: this.rules,
                 config: this.config,
@@ -1394,49 +1528,184 @@ class FileSystemDatabaseManager {
             return encrypted;
         });
     }
-    importData(encryptedData, password) {
+    /**
+     * 预览导入数据
+     */
+    previewImportData(encryptedData, password) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const decrypted = crypto_js_1.default.AES.decrypt(encryptedData, password);
-                const jsonData = decrypted.toString(crypto_js_1.default.enc.Utf8);
-                const importData = JSON.parse(jsonData);
-                // 检测数据版本
-                const isNewFormat = importData.vendors.some((v) => v.services);
-                if (isNewFormat || importData.version >= '2.0.0') {
-                    // 新格式：直接使用 vendors（已包含 services）
-                    this.vendors = importData.vendors;
+                // 解密
+                let jsonData;
+                try {
+                    const decrypted = crypto_js_1.default.AES.decrypt(encryptedData, password);
+                    jsonData = decrypted.toString(crypto_js_1.default.enc.Utf8);
+                    if (!jsonData) {
+                        return { success: false, message: '解密失败：密码错误或数据损坏' };
+                    }
                 }
-                else {
-                    // 旧格式：需要重建 services 关系
-                    const { vendors, apiServices } = importData;
-                    // 构建 vendorId -> services 映射
-                    const servicesByVendor = new Map();
-                    for (const service of apiServices) {
-                        if (!service.vendorId)
-                            continue;
-                        if (!servicesByVendor.has(service.vendorId)) {
-                            servicesByVendor.set(service.vendorId, []);
-                        }
-                        const { vendorId } = service, serviceWithoutVendorId = __rest(service, ["vendorId"]);
-                        servicesByVendor.get(service.vendorId).push(serviceWithoutVendorId);
+                catch (error) {
+                    return { success: false, message: '解密失败：密码错误或数据格式错误' };
+                }
+                // 解析 JSON
+                let importData;
+                try {
+                    importData = JSON.parse(jsonData);
+                }
+                catch (error) {
+                    return { success: false, message: '数据解析失败：不是有效的 JSON 格式' };
+                }
+                // 验证数据格式
+                const validation = this.validateExportData(importData);
+                if (!validation.valid) {
+                    return { success: false, message: `数据验证失败：${validation.error}` };
+                }
+                // 计算服务数量
+                const servicesCount = importData.vendors.reduce((sum, v) => { var _a; return sum + (((_a = v.services) === null || _a === void 0 ? void 0 : _a.length) || 0); }, 0);
+                return {
+                    success: true,
+                    data: {
+                        vendors: importData.vendors.length,
+                        services: servicesCount,
+                        routes: importData.routes.length,
+                        rules: importData.rules.length,
+                        exportDate: importData.exportDate,
+                        version: importData.version,
+                    }
+                };
+            }
+            catch (error) {
+                console.error('Preview import error:', error);
+                return { success: false, message: `预览失败：${error instanceof Error ? error.message : '未知错误'}` };
+            }
+        });
+    }
+    importData(encryptedData, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 解密
+                let jsonData;
+                try {
+                    const decrypted = crypto_js_1.default.AES.decrypt(encryptedData, password);
+                    jsonData = decrypted.toString(crypto_js_1.default.enc.Utf8);
+                    if (!jsonData) {
+                        return { success: false, message: '导入失败', details: '解密失败：密码错误或数据损坏' };
                     }
-                    // 合并到 vendors
-                    this.vendors = vendors.map((vendor) => (Object.assign(Object.assign({}, vendor), { services: servicesByVendor.get(vendor.id) || [] })));
                 }
-                this.routes = importData.routes;
-                this.rules = importData.rules;
-                this.config = importData.config;
+                catch (error) {
+                    return { success: false, message: '导入失败', details: '解密失败：密码错误或数据格式错误' };
+                }
+                // 解析 JSON
+                let importData;
+                try {
+                    importData = JSON.parse(jsonData);
+                }
+                catch (error) {
+                    return { success: false, message: '导入失败', details: '数据解析失败：不是有效的 JSON 格式' };
+                }
+                // 验证数据格式
+                const validation = this.validateExportData(importData);
+                if (!validation.valid) {
+                    return { success: false, message: '导入失败', details: `数据验证失败：${validation.error}` };
+                }
+                // 导入数据（更新 updatedAt）
+                const now = Date.now();
+                this.vendors = importData.vendors.map((v) => (Object.assign(Object.assign({}, v), { updatedAt: now })));
+                this.routes = importData.routes.map((r) => (Object.assign(Object.assign({}, r), { updatedAt: now })));
+                this.rules = importData.rules.map((r) => (Object.assign(Object.assign({}, r), { updatedAt: now })));
+                this.config = Object.assign(Object.assign({}, importData.config), { updatedAt: now });
+                // 保存数据
                 yield Promise.all([
                     this.saveVendors(),
-                    // 删除: this.saveServices(),
                     this.saveRoutes(),
                     this.saveConfig(),
                 ]);
-                return true;
+                const servicesCount = this.vendors.reduce((sum, v) => { var _a; return sum + (((_a = v.services) === null || _a === void 0 ? void 0 : _a.length) || 0); }, 0);
+                return {
+                    success: true,
+                    message: '导入成功',
+                    details: `已导入 ${this.vendors.length} 个供应商、${servicesCount} 个服务、${this.routes.length} 个路由、${this.rules.length} 个规则`
+                };
             }
             catch (error) {
                 console.error('Import error:', error);
-                return false;
+                return {
+                    success: false,
+                    message: '导入失败',
+                    details: error instanceof Error ? error.message : '未知错误'
+                };
+            }
+        });
+    }
+    inferContentTypeFromLog(log) {
+        var _a, _b;
+        const requestModel = ((_a = log.requestModel) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+        let bodyText = '';
+        if (typeof log.body === 'string') {
+            bodyText = log.body;
+        }
+        else if (log.body !== undefined) {
+            try {
+                bodyText = JSON.stringify(log.body);
+            }
+            catch (_c) {
+                bodyText = '';
+            }
+        }
+        const lowerBody = bodyText.toLowerCase();
+        if (lowerBody.includes('image') || lowerBody.includes('base64')) {
+            return 'image-understanding';
+        }
+        if (requestModel.includes('think')) {
+            return 'thinking';
+        }
+        if ((((_b = log.usage) === null || _b === void 0 ? void 0 : _b.inputTokens) || 0) > 12000) {
+            return 'long-context';
+        }
+        return 'default';
+    }
+    resolveLogContentType(log) {
+        if (log.contentType) {
+            return log.contentType;
+        }
+        if (log.ruleId) {
+            const rule = this.getRule(log.ruleId);
+            if (rule === null || rule === void 0 ? void 0 : rule.contentType) {
+                return rule.contentType;
+            }
+        }
+        return this.inferContentTypeFromLog(log);
+    }
+    ensureContentTypeDistribution() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.contentTypeDistributionInitialized || this.contentTypeDistributionInitializing) {
+                return;
+            }
+            this.contentTypeDistributionInitializing = true;
+            try {
+                if (this.logShardsIndex.length === 0) {
+                    this.contentTypeDistributionInitialized = true;
+                    return;
+                }
+                const counts = new Map();
+                let totalRequests = 0;
+                for (const shard of this.logShardsIndex) {
+                    const shardLogs = yield this.loadLogShard(shard.filename);
+                    for (const log of shardLogs) {
+                        totalRequests++;
+                        const contentType = this.resolveLogContentType(log);
+                        counts.set(contentType, (counts.get(contentType) || 0) + 1);
+                    }
+                }
+                this.statistics.contentTypeDistribution = Array.from(counts.entries()).map(([contentType, count]) => ({
+                    contentType,
+                    count,
+                    percentage: totalRequests > 0 ? Math.round((count / totalRequests) * 100) : 0,
+                }));
+                this.contentTypeDistributionInitialized = true;
+                yield this.saveStatistics();
+            }
+            finally {
+                this.contentTypeDistributionInitializing = false;
             }
         });
     }
@@ -1539,6 +1808,19 @@ class FileSystemDatabaseManager {
                 modelStats.avgResponseTime =
                     (modelStats.avgResponseTime * (modelStats.totalRequests - 1) + responseTime) / modelStats.totalRequests;
             }
+            // 更新 contentTypeDistribution
+            const resolvedContentType = this.resolveLogContentType(log);
+            let contentTypeStats = this.statistics.contentTypeDistribution.find(s => s.contentType === resolvedContentType);
+            if (!contentTypeStats) {
+                contentTypeStats = { contentType: resolvedContentType, count: 0, percentage: 0 };
+                this.statistics.contentTypeDistribution.push(contentTypeStats);
+            }
+            contentTypeStats.count++;
+            const totalRequests = this.statistics.overview.totalRequests;
+            for (const entry of this.statistics.contentTypeDistribution) {
+                entry.percentage = totalRequests > 0 ? Math.round((entry.count / totalRequests) * 100) : 0;
+            }
+            this.contentTypeDistributionInitialized = true;
             // 更新 timeline
             const date = new Date(log.timestamp).toISOString().split('T')[0];
             let timelineStats = this.statistics.timeline.find(t => t.date === date);
@@ -1566,6 +1848,7 @@ class FileSystemDatabaseManager {
      */
     getStatistics() {
         return __awaiter(this, arguments, void 0, function* (days = 30) {
+            yield this.ensureContentTypeDistribution();
             const now = Date.now();
             const startTime = now - days * 24 * 60 * 60 * 1000;
             // 过滤 timeline 数据
@@ -1662,7 +1945,8 @@ class FileSystemDatabaseManager {
         // 检查 body 中的 metadata.user_id（Claude Code）
         if (log.body) {
             try {
-                const body = JSON.parse(log.body);
+                // body 可能是对象（已解析）或字符串（未解析）
+                const body = typeof log.body === 'string' ? JSON.parse(log.body) : log.body;
                 if (((_b = body.metadata) === null || _b === void 0 ? void 0 : _b.user_id) === sessionId) {
                     return true;
                 }

package/dist/server/main.js

@@ -1274,10 +1274,16 @@ ${instruction}
         const data = yield dbManager.exportData(password);
         res.json({ data });
     })));
+    // 导入数据预览
+    app.post('/api/import/preview', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const { encryptedData, password } = req.body;
+        const result = yield dbManager.previewImportData(encryptedData, password);
+        res.json(result);
+    })));
     app.post('/api/import', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
         const { encryptedData, password } = req.body;
         const result = yield dbManager.importData(encryptedData, password);
-        if (result) {
+        if (result.success) {
             yield proxyServer.reloadRoutes();
         }
         res.json(result);