aicodeswitch 2.1.6 → 3.0.1

package/README.md

@@ -10,10 +10,6 @@ AI Code Switch 是帮助你在本地管理 AI 编程工具接入大模型的工
 - 视频演示：[https://www.bilibili.com/video/BV1uEznBuEJd/](https://www.bilibili.com/video/BV1uEznBuEJd/?from=github)
 - 1分钟让Claude Code接入GLM国产模型：[https://www.bilibili.com/video/BV1a865B8ErA/](https://www.bilibili.com/video/BV1a865B8ErA/)
 
-## 桌面版
-
-桌面端应用下载：[https://github.com/tangshuang/aicodeswitch/releases](https://github.com/tangshuang/aicodeswitch/releases)
-
 ## 命令行工具
 
 ### 安装
@@ -22,6 +18,8 @@ AI Code Switch 是帮助你在本地管理 AI 编程工具接入大模型的工
 npm install -g aicodeswitch
 ```
 
+**注意：**由于工具依赖sqlite和leveldb作为数据存储，在安装过程中，会执行这两个数据库的编译，如果你是在windows电脑上安装，你需要安装 visual studio 2017 以上版本，才能正常编译数据库，macos 和 linux 系统中一般都自带了编译工具，因此大部分情况下都能正确编译。
+
 ### 使用方法
 
 **启动服务**

package/UPGRADE.md

@@ -0,0 +1,5 @@
+本次升级将会有破坏性影响，你需要注意：
+
+* 升级后，不再使用数据库来持久化数据，而是使用json文件，你可以通过直接阅读json文件来查看数据
+* 升级后，你需要重启服务，让新的数据持久化系统生效
+* 升级后，如果遇到问题，不要惊慌，你可以直接重新安装老版本，老版本仍然使用原来的数据库文件，你可以先把老版本的数据备份后，安装新版本再来恢复数据

package/bin/restore.js

@@ -5,6 +5,43 @@ const chalk = require('chalk');
 const boxen = require('boxen');
 const ora = require('ora');
 
+// 停用所有激活的路由（直接操作数据库文件）
+const deactivateAllRoutes = () => {
+  const appDir = path.join(os.homedir(), '.aicodeswitch');
+  const routesFilePath = path.join(appDir, 'data', 'routes.json');
+
+  // 如果数据文件不存在，说明没有路由需要停用
+  if (!fs.existsSync(routesFilePath)) {
+    return { success: true, deactivatedCount: 0, reason: 'no_data_file' };
+  }
+
+  try {
+    // 读取路由数据
+    const routesData = JSON.parse(fs.readFileSync(routesFilePath, 'utf-8'));
+
+    if (!Array.isArray(routesData)) {
+      return { success: false, error: 'Invalid routes data format' };
+    }
+
+    let deactivatedCount = 0;
+
+    // 将所有激活的路由设置为停用状态
+    routesData.forEach(route => {
+      if (route.isActive === true) {
+        route.isActive = false;
+        deactivatedCount++;
+      }
+    });
+
+    // 保存修改后的数据
+    fs.writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2));
+
+    return { success: true, deactivatedCount };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+};
+
 // 恢复 Claude Code 配置
 const restoreClaudeConfig = () => {
   const results = {
@@ -218,6 +255,25 @@ const restore = async () => {
     showRestoreResult('codex', codexResults);
   }
 
+  // 停用所有激活的路由
+  console.log('');
+  const routesSpinner = ora({
+    text: chalk.yellow('Deactivating all active routes...'),
+    color: 'yellow'
+  }).start();
+
+  const routesResult = deactivateAllRoutes();
+
+  if (routesResult.success) {
+    if (routesResult.deactivatedCount > 0) {
+      routesSpinner.succeed(chalk.green(`Deactivated ${routesResult.deactivatedCount} active route(s)`));
+    } else {
+      routesSpinner.info(chalk.gray('No active routes to deactivate'));
+    }
+  } else {
+    routesSpinner.fail(chalk.red(`Failed to deactivate routes: ${routesResult.error}`));
+  }
+
   console.log('');
   console.log(chalk.cyan('💡 Tips:\n'));
   console.log(chalk.white('  • Restart server:   ') + chalk.cyan('aicos restart'));

package/dist/server/database-factory.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseFactory = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_database_1 = require("./fs-database");
+const migrateToFs = __importStar(require("./migrate-to-fs"));
+/**
+ * 数据库工厂
+ * 根据配置创建相应的数据库实例
+ */
+class DatabaseFactory {
+    /**
+     * 创建数据库实例
+     * @param dataPath 数据存储路径
+     * @param type 数据库类型，默认使用文件系统
+     */
+    static create(dataPath_1) {
+        return __awaiter(this, arguments, void 0, function* (dataPath, type = 'filesystem') {
+            if (type === 'filesystem') {
+                const db = new fs_database_1.FileSystemDatabaseManager(dataPath);
+                yield db.initialize();
+                return db;
+            }
+            // 如果用户明确要求使用 SQLite，尝试加载
+            if (type === 'sqlite') {
+                try {
+                    const { DatabaseManager } = yield Promise.resolve().then(() => __importStar(require('./database.js')));
+                    const db = new DatabaseManager(dataPath);
+                    yield db.initialize();
+                    return db;
+                }
+                catch (error) {
+                    console.error('[Database] Failed to load SQLite database, falling back to filesystem:', error);
+                    console.log('[Database] Using filesystem database instead');
+                    const db = new fs_database_1.FileSystemDatabaseManager(dataPath);
+                    yield db.initialize();
+                    return db;
+                }
+            }
+            throw new Error(`Unknown database type: ${type}`);
+        });
+    }
+    /**
+     * 自动检测并创建数据库实例
+     * 优先使用文件系统数据库，如果存在旧的 SQLite 数据库则自动迁移
+     */
+    static createAuto(dataPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fs = yield Promise.resolve().then(() => __importStar(require('fs/promises')));
+            // 检查迁移完成标记文件
+            const migrationMarkerPath = path_1.default.join(dataPath, '.migration-completed');
+            const hasMigrationMarker = yield fs.access(migrationMarkerPath)
+                .then(() => true)
+                .catch(() => false);
+            // 检查是否存在文件系统数据库
+            const fsDbExists = yield fs.access(path_1.default.join(dataPath, 'config.json'))
+                .then(() => true)
+                .catch(() => false);
+            // 如果存在迁移标记且文件系统数据库存在，使用文件系统数据库
+            if (hasMigrationMarker && fsDbExists) {
+                console.log('[Database] Migration marker found, using filesystem database');
+                return this.create(dataPath, 'filesystem');
+            }
+            // 如果不存在迁移标记但存在文件系统数据库，可能是用户手动删除了标记
+            // 这种情况下仍然使用文件系统数据库（避免数据丢失）
+            if (fsDbExists) {
+                console.log('[Database] Using existing filesystem database (no migration marker)');
+                return this.create(dataPath, 'filesystem');
+            }
+            // 检查是否存在旧的 SQLite 数据库
+            const sqliteDbExists = yield fs.access(path_1.default.join(dataPath, 'app.db'))
+                .then(() => true)
+                .catch(() => false);
+            if (sqliteDbExists) {
+                console.log('[Database] Found old SQLite database, migrating to filesystem...');
+                try {
+                    // 执行迁移
+                    yield migrateToFs.migrateToFileSystem(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);
+                        }
+                        // 只有在验证成功后才创建标记文件
+                        const migrationMarkerPath = path_1.default.join(dataPath, '.migration-completed');
+                        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');
+                }
+                catch (error) {
+                    console.error('[Database] Migration failed:', error);
+                    console.log('[Database] Creating new filesystem database');
+                    // 迁移失败时，原始数据库文件保持不变
+                    // 用户可以使用老版本继续运行，或手动重新配置
+                }
+            }
+            else {
+                console.log('[Database] No existing database found, creating new filesystem database');
+            }
+            return this.create(dataPath, 'filesystem');
+        });
+    }
+}
+exports.DatabaseFactory = DatabaseFactory;