aicodeswitch 3.0.1 → 3.0.3

package/README.md

@@ -18,8 +18,6 @@ AI Code Switch 是帮助你在本地管理 AI 编程工具接入大模型的工
 npm install -g aicodeswitch
 ```
 
-**注意：**由于工具依赖sqlite和leveldb作为数据存储，在安装过程中，会执行这两个数据库的编译，如果你是在windows电脑上安装，你需要安装 visual studio 2017 以上版本，才能正常编译数据库，macos 和 linux 系统中一般都自带了编译工具，因此大部分情况下都能正确编译。
-
 ### 使用方法
 
 **启动服务**
@@ -143,6 +141,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/bin/restore.js

@@ -8,7 +8,11 @@ const ora = require('ora');
 // 停用所有激活的路由（直接操作数据库文件）
 const deactivateAllRoutes = () => {
   const appDir = path.join(os.homedir(), '.aicodeswitch');
-  const routesFilePath = path.join(appDir, 'data', 'routes.json');
+  const primaryRoutesFilePath = path.join(appDir, 'fs-db', 'routes.json');
+  const legacyRoutesFilePath = path.join(appDir, 'data', 'routes.json');
+  const routesFilePath = fs.existsSync(primaryRoutesFilePath)
+    ? primaryRoutesFilePath
+    : legacyRoutesFilePath;
 
   // 如果数据文件不存在，说明没有路由需要停用
   if (!fs.existsSync(routesFilePath)) {
@@ -19,14 +23,23 @@ const deactivateAllRoutes = () => {
     // 读取路由数据
     const routesData = JSON.parse(fs.readFileSync(routesFilePath, 'utf-8'));
 
-    if (!Array.isArray(routesData)) {
+    let routes = [];
+    let payload = routesData;
+
+    if (Array.isArray(routesData)) {
+      routes = routesData;
+      payload = routesData;
+    } else if (routesData && typeof routesData === 'object' && Array.isArray(routesData.routes)) {
+      routes = routesData.routes;
+      payload = { ...routesData, routes };
+    } else {
       return { success: false, error: 'Invalid routes data format' };
     }
 
     let deactivatedCount = 0;
 
     // 将所有激活的路由设置为停用状态
-    routesData.forEach(route => {
+    routes.forEach(route => {
       if (route.isActive === true) {
         route.isActive = false;
         deactivatedCount++;
@@ -34,7 +47,7 @@ const deactivateAllRoutes = () => {
     });
 
     // 保存修改后的数据
-    fs.writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2));
+    fs.writeFileSync(routesFilePath, JSON.stringify(payload, null, 2));
 
     return { success: true, deactivatedCount };
   } catch (err) {
@@ -281,4 +294,4 @@ const restore = async () => {
   console.log('\n');
 };
 
-module.exports = restore;
+module.exports = restore;

package/dist/server/config-metadata.js

@@ -7,12 +7,23 @@ exports.cleanupInvalidMetadata = exports.checkCodexConfigStatus = exports.checkC
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+/**
+ * 获取元数据目录
+ */
+const getMetadataDirs = () => {
+    const homeDir = os_1.default.homedir();
+    return {
+        primary: path_1.default.join(homeDir, '.aicodeswitch', 'fs-db'),
+        legacy: path_1.default.join(homeDir, '.aicodeswitch', 'data'),
+    };
+};
 /**
  * 获取元数据文件路径
  */
-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 getMetadataFilePath = (configType, useLegacy = false) => {
+    const dirs = getMetadataDirs();
+    const baseDir = useLegacy ? dirs.legacy : dirs.primary;
+    return path_1.default.join(baseDir, `.${configType}-metadata.json`);
 };
 /**
  * 保存配置元数据
@@ -40,11 +51,29 @@ exports.saveMetadata = saveMetadata;
 const loadMetadata = (configType) => {
     try {
         const metadataPath = getMetadataFilePath(configType);
-        if (!fs_1.default.existsSync(metadataPath)) {
-            return null;
+        if (fs_1.default.existsSync(metadataPath)) {
+            const content = fs_1.default.readFileSync(metadataPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        // 兼容旧路径
+        const legacyPath = getMetadataFilePath(configType, true);
+        if (fs_1.default.existsSync(legacyPath)) {
+            const content = fs_1.default.readFileSync(legacyPath, 'utf-8');
+            const metadata = JSON.parse(content);
+            // 尝试迁移到新路径
+            try {
+                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');
+            }
+            catch (error) {
+                console.warn(`Failed to migrate metadata for ${configType}:`, error);
+            }
+            return metadata;
         }
-        const content = fs_1.default.readFileSync(metadataPath, 'utf-8');
-        return JSON.parse(content);
+        return null;
     }
     catch (error) {
         console.error(`Failed to load metadata for ${configType}:`, error);
@@ -58,9 +87,13 @@ exports.loadMetadata = loadMetadata;
 const deleteMetadata = (configType) => {
     try {
         const metadataPath = getMetadataFilePath(configType);
+        const legacyPath = getMetadataFilePath(configType, true);
         if (fs_1.default.existsSync(metadataPath)) {
             fs_1.default.unlinkSync(metadataPath);
         }
+        if (fs_1.default.existsSync(legacyPath)) {
+            fs_1.default.unlinkSync(legacyPath);
+        }
         return true;
     }
     catch (error) {

package/dist/server/database-factory.js

@@ -89,9 +89,10 @@ class DatabaseFactory {
      * 自动检测并创建数据库实例
      * 优先使用文件系统数据库，如果存在旧的 SQLite 数据库则自动迁移
      */
-    static createAuto(dataPath) {
+    static createAuto(dataPath, legacyDataPath) {
         return __awaiter(this, void 0, void 0, function* () {
             const fs = yield Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const legacyPath = legacyDataPath && legacyDataPath !== dataPath ? legacyDataPath : null;
             // 检查迁移完成标记文件
             const migrationMarkerPath = path_1.default.join(dataPath, '.migration-completed');
             const hasMigrationMarker = yield fs.access(migrationMarkerPath)
@@ -112,6 +113,58 @@ class DatabaseFactory {
                 console.log('[Database] Using existing filesystem database (no migration marker)');
                 return this.create(dataPath, 'filesystem');
             }
+            // 如果新目录为空，尝试从旧 data 目录迁移文件系统数据库
+            if (legacyPath) {
+                const legacyFsDbExists = yield fs.access(path_1.default.join(legacyPath, 'config.json'))
+                    .then(() => true)
+                    .catch(() => false);
+                if (legacyFsDbExists) {
+                    console.log('[Database] Found legacy filesystem database, migrating to new directory...');
+                    try {
+                        yield migrateToFs.migrateLegacyFsData(legacyPath, dataPath);
+                        yield fs.writeFile(migrationMarkerPath, new Date().toISOString(), 'utf-8');
+                        console.log('[Database] Legacy filesystem database migration completed');
+                        return this.create(dataPath, 'filesystem');
+                    }
+                    catch (error) {
+                        console.error('[Database] Legacy filesystem migration failed:', error);
+                        console.log('[Database] Falling back to create new filesystem database');
+                    }
+                }
+            }
+            // 如果新目录为空，检查旧 data 目录是否存在 SQLite 数据库
+            if (legacyPath) {
+                const legacySqliteExists = yield fs.access(path_1.default.join(legacyPath, 'app.db'))
+                    .then(() => true)
+                    .catch(() => false);
+                if (legacySqliteExists) {
+                    console.log('[Database] Found legacy SQLite database, migrating to new filesystem directory...');
+                    try {
+                        yield migrateToFs.migrateToFileSystem(legacyPath, dataPath);
+                        console.log('[Database] Verifying migration...');
+                        const verification = yield migrateToFs.verifyMigration(dataPath);
+                        if (verification.success) {
+                            console.log('[Database] ✅ Migration verified successfully');
+                            if (verification.warnings.length > 0) {
+                                console.log('[Database] Warnings:', verification.warnings);
+                            }
+                            yield fs.writeFile(migrationMarkerPath, new Date().toISOString(), 'utf-8');
+                            console.log('[Database] Migration marker file created:', migrationMarkerPath);
+                        }
+                        else {
+                            console.error('[Database] ❌ Migration verification failed');
+                            console.error('[Database] Errors:', verification.errors);
+                            throw new Error('Migration verification failed');
+                        }
+                        console.log('[Database] Migration completed, using filesystem database');
+                        return this.create(dataPath, 'filesystem');
+                    }
+                    catch (error) {
+                        console.error('[Database] Migration failed:', error);
+                        console.log('[Database] Creating new filesystem database');
+                    }
+                }
+            }
             // 检查是否存在旧的 SQLite 数据库
             const sqliteDbExists = yield fs.access(path_1.default.join(dataPath, 'app.db'))
                 .then(() => true)

package/dist/server/database.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -441,14 +452,25 @@ class DatabaseManager {
     // Vendor operations
     getVendors() {
         const rows = this.db.prepare('SELECT * FROM vendors ORDER BY sort_order DESC, created_at DESC').all();
-        return rows.map((row) => ({
-            id: row.id,
-            name: row.name,
-            description: row.description,
-            sortOrder: row.sort_order,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        }));
+        return rows.map((row) => {
+            const vendorId = row.id;
+            // 获取该供应商的所有服务
+            const services = this.getAPIServices(vendorId);
+            // 移除服务中的 vendorId 字段
+            const servicesWithoutVendorId = services.map((_a) => {
+                var { vendorId } = _a, service = __rest(_a, ["vendorId"]);
+                return service;
+            });
+            return {
+                id: row.id,
+                name: row.name,
+                description: row.description,
+                sortOrder: row.sort_order,
+                services: servicesWithoutVendorId, // 添加嵌套的 services 数组
+                createdAt: row.created_at,
+                updatedAt: row.updated_at,
+            };
+        });
     }
     createVendor(vendor) {
         const id = crypto_1.default.randomUUID();
@@ -1311,7 +1333,7 @@ class DatabaseManager {
                 return {
                     serviceId,
                     serviceName: (serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.name) || 'Unknown',
-                    vendorName: serviceInfo ? vendorMap.get(serviceInfo.vendorId) || 'Unknown' : 'Unknown',
+                    vendorName: serviceInfo && serviceInfo.vendorId ? (vendorMap.get(serviceInfo.vendorId) || 'Unknown') : 'Unknown',
                     totalRequests: stats.requests,
                     totalTokens: stats.tokens,
                     avgResponseTime: stats.requests > 0 ? Math.round(stats.responseTime / stats.requests) : 0,