aicodeswitch 3.0.3 → 3.0.4

package/README.md

@@ -105,6 +105,7 @@ Codex的配置覆盖逻辑一模一样。
 *   Claude Chat
 *   Claude Code
 *   DeepSeek Chat
+*   Gemini
 
 **有什么用？**
 

package/dist/server/fs-database.js

@@ -181,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() {
@@ -1362,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,
@@ -1388,49 +1528,111 @@ 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 : '未知错误'
+                };
             }
         });
     }

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);