aicodeswitch 1.3.8 → 1.4.0

package/CLAUDE.md

@@ -40,6 +40,10 @@ npm link                 # Link local package for CLI testing
 aicos start              # Start the proxy server
 aicos stop               # Stop the proxy server
 aicos restart            # Restart the proxy server
+aicos ui                 # Open web UI in browser (starts server if needed)
+aicos update             # Update to the latest version and restart
+aicos restore            # Restore original configuration files
+aicos version            # Show current version information
 ```
 
 ## Architecture
@@ -180,3 +184,9 @@ aicos restart            # Restart the proxy server
 - **HTTP Client**: Axios
 - **Encryption**: CryptoJS (AES)
 - **CLI**: Yargs-like custom implementation
+
+## Development
+
+* 使用yarn作为包管理器，请使用yarn安装依赖。
+* 前端依赖库安装在devDependencies中，请使用yarn install --dev安装。
+* 所有对话请使用中文。生成代码中的文案及相关注释根据代码原本的语言生成。

package/README.md

@@ -30,6 +30,12 @@ aicos stop
 **进入管理界面**
 
 ```
+# 自动启动服务和打开界面
+aicos ui
+```
+
+```
+# 手动在浏览器打开管理界面
 http://127.0.0.1:4567
 ```
 

package/bin/cli.js

@@ -12,6 +12,7 @@ const commands = {
   update: () => require(path.join(__dirname, 'update')),
   restore: () => require(path.join(__dirname, 'restore')),
   version: () => require(path.join(__dirname, 'version')),
+  ui: () => require(path.join(__dirname, 'ui')),
 };
 
 if (!command || !commands[command]) {
@@ -22,6 +23,7 @@ Commands:
   start      Start the AI Code Switch server
   stop       Stop the AI Code Switch server
   restart    Restart the AI Code Switch server
+  ui         Open the web UI in browser (starts server if needed)
   update     Update to the latest version and restart
   restore    Restore original configuration files
   version    Show current version information
@@ -30,6 +32,7 @@ Example:
   aicos start
   aicos stop
   aicos restart
+  aicos ui
   aicos update
   aicos restore
   aicos restore claude-code

package/bin/restore.js

@@ -220,7 +220,7 @@ const restore = async () => {
 
   console.log('');
   console.log(chalk.cyan('💡 Tips:\n'));
-  console.log(chalk.white('  • Write config:  ') + chalk.cyan('aicos write-config [target]'));
+  console.log(chalk.white('  • Restart server:   ') + chalk.cyan('aicos restart'));
   console.log(chalk.white('  • Start server:   ') + chalk.cyan('aicos start'));
   console.log('\n');
 };

package/bin/ui.js

@@ -0,0 +1,173 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const PID_FILE = path.join(os.homedir(), '.aicodeswitch', 'server.pid');
+const LOG_FILE = path.join(os.homedir(), '.aicodeswitch', 'server.log');
+
+// 确保目录存在
+const ensureDir = (filePath) => {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+};
+
+const isServerRunning = () => {
+  if (!fs.existsSync(PID_FILE)) {
+    return false;
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8'), 10);
+    // 检查进程是否存在
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // 进程不存在,删除过期的 PID 文件
+    fs.unlinkSync(PID_FILE);
+    return false;
+  }
+};
+
+const getServerInfo = () => {
+  // 尝试多个可能的配置文件位置
+  const possiblePaths = [
+    path.join(os.homedir(), '.aicodeswitch', '.env'),
+    path.join(os.homedir(), '.aicodeswitch', 'aicodeswitch.conf')
+  ];
+
+  let host = '127.0.0.1';
+  let port = 4567;
+
+  for (const dotenvPath of possiblePaths) {
+    if (fs.existsSync(dotenvPath)) {
+      const content = fs.readFileSync(dotenvPath, 'utf-8');
+      const hostMatch = content.match(/HOST=(.+)/);
+      const portMatch = content.match(/PORT=(.+)/);
+
+      if (hostMatch) host = hostMatch[1].trim();
+      if (portMatch) port = parseInt(portMatch[1].trim(), 10);
+      break;
+    }
+  }
+
+  return { host, port };
+};
+
+const startServer = async () => {
+  const spinner = ora({
+    text: chalk.cyan('Starting AI Code Switch server...'),
+    color: 'cyan'
+  }).start();
+
+  ensureDir(PID_FILE);
+  ensureDir(LOG_FILE);
+
+  // 找到 main.js 的路径
+  const serverPath = path.join(__dirname, '..', 'dist', 'server', 'main.js');
+
+  if (!fs.existsSync(serverPath)) {
+    spinner.fail(chalk.red('Server file not found!'));
+    console.log(chalk.yellow(`\nPlease run ${chalk.cyan('npm run build')} first.\n`));
+    process.exit(1);
+  }
+
+  // 启动服务器进程 - 完全分离
+  // 打开日志文件用于输出
+  const logFd = fs.openSync(LOG_FILE, 'a');
+
+  const serverProcess = spawn('node', [serverPath], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd]  // 使用文件描述符
+  });
+
+  // 关闭文件描述符(子进程会保持打开)
+  fs.closeSync(logFd);
+
+  // 保存 PID
+  fs.writeFileSync(PID_FILE, serverProcess.pid.toString());
+
+  // 分离进程,让父进程可以退出
+  serverProcess.unref();
+
+  // 等待服务器启动
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  // 检查服务器是否成功启动
+  if (fs.existsSync(PID_FILE)) {
+    try {
+      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8'), 10);
+      process.kill(pid, 0);
+      spinner.succeed(chalk.green('Server started successfully!'));
+      return true;
+    } catch (err) {
+      spinner.fail(chalk.red('Failed to start server!'));
+      console.log(chalk.yellow(`\nCheck logs: ${chalk.cyan(LOG_FILE)}\n`));
+      return false;
+    }
+  } else {
+    spinner.fail(chalk.red('Failed to start server!'));
+    console.log(chalk.yellow(`\nCheck logs: ${chalk.cyan(LOG_FILE)}\n`));
+    return false;
+  }
+};
+
+const openBrowser = (url) => {
+  const platform = os.platform();
+  let command;
+
+  if (platform === 'darwin') {
+    command = 'open';
+  } else if (platform === 'win32') {
+    command = 'start';
+  } else {
+    // Linux and others
+    command = 'xdg-open';
+  }
+
+  const child = spawn(command, [url], {
+    detached: true,
+    stdio: 'ignore'
+  });
+
+  child.unref();
+};
+
+const openUI = async () => {
+  console.log('\n');
+
+  const running = isServerRunning();
+
+  if (!running) {
+    console.log(chalk.yellow('⚠ Server is not running, starting server first...\n'));
+    const started = await startServer();
+    if (!started) {
+      console.log(chalk.red('\n✗ Failed to start server, cannot open UI\n'));
+      process.exit(1);
+    }
+  } else {
+    console.log(chalk.green('✓ Server is already running\n'));
+  }
+
+  const { host, port } = getServerInfo();
+  const url = `http://${host}:${port}`;
+
+  console.log(chalk.cyan('🌐 Opening browser...'));
+  console.log(chalk.white('   URL: ') + chalk.cyan.bold(url) + '\n');
+
+  try {
+    openBrowser(url);
+    console.log(chalk.green('✓ Browser opened successfully!\n'));
+  } catch (err) {
+    console.log(chalk.yellow('⚠ Failed to open browser automatically'));
+    console.log(chalk.white('  Please open this URL manually: ') + chalk.cyan.bold(url) + '\n');
+  }
+
+  process.exit(0);
+};
+
+module.exports = openUI();

package/dist/server/database.js

@@ -51,10 +51,17 @@ class DatabaseManager {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "blacklistDb", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.db = new better_sqlite3_1.default(path_1.default.join(dataPath, 'app.db'));
         this.logDb = new level_1.Level(path_1.default.join(dataPath, 'logs'), { valueEncoding: 'json' });
         this.accessLogDb = new level_1.Level(path_1.default.join(dataPath, 'access-logs'), { valueEncoding: 'json' });
         this.errorLogDb = new level_1.Level(path_1.default.join(dataPath, 'error-logs'), { valueEncoding: 'json' });
+        this.blacklistDb = new level_1.Level(path_1.default.join(dataPath, 'service-blacklist'), { valueEncoding: 'json' });
     }
     initialize() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -125,6 +132,7 @@ class DatabaseManager {
                     logRetentionDays: 7,
                     maxLogSize: 1000,
                     apiKey: '',
+                    enableFailover: true, // 默认启用智能故障切换
                 };
                 this.db.prepare('INSERT INTO config (key, value) VALUES (?, ?)').run('app_config', JSON.stringify(defaultConfig));
             }
@@ -401,6 +409,93 @@ class DatabaseManager {
             yield this.errorLogDb.clear();
         });
     }
+    // Service blacklist operations
+    isServiceBlacklisted(serviceId, routeId, contentType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = `${routeId}:${contentType}:${serviceId}`;
+            try {
+                const value = yield this.blacklistDb.get(key);
+                const entry = JSON.parse(value);
+                // 检查是否过期
+                if (Date.now() > entry.expiresAt) {
+                    // 已过期,删除记录
+                    yield this.blacklistDb.del(key);
+                    return false;
+                }
+                return true;
+            }
+            catch (error) {
+                if (error.code === 'LEVEL_NOT_FOUND') {
+                    return false;
+                }
+                throw error;
+            }
+        });
+    }
+    addToBlacklist(serviceId, routeId, contentType, errorMessage, statusCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = `${routeId}:${contentType}:${serviceId}`;
+            const now = Date.now();
+            try {
+                // 尝试读取现有记录
+                const existing = yield this.blacklistDb.get(key);
+                const entry = JSON.parse(existing);
+                // 更新现有记录
+                entry.blacklistedAt = now;
+                entry.expiresAt = now + 10 * 60 * 1000; // 10分钟
+                entry.errorCount++;
+                entry.lastError = errorMessage;
+                entry.lastStatusCode = statusCode;
+                yield this.blacklistDb.put(key, JSON.stringify(entry));
+            }
+            catch (error) {
+                if (error.code === 'LEVEL_NOT_FOUND') {
+                    // 创建新记录
+                    const entry = {
+                        serviceId,
+                        routeId,
+                        contentType,
+                        blacklistedAt: now,
+                        expiresAt: now + 10 * 60 * 1000,
+                        errorCount: 1,
+                        lastError: errorMessage,
+                        lastStatusCode: statusCode,
+                    };
+                    yield this.blacklistDb.put(key, JSON.stringify(entry));
+                }
+                else {
+                    throw error;
+                }
+            }
+        });
+    }
+    cleanupExpiredBlacklist() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_4, _b, _c;
+            const now = Date.now();
+            let count = 0;
+            try {
+                for (var _d = true, _e = __asyncValues(this.blacklistDb.iterator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const [key, value] = _c;
+                    const entry = JSON.parse(value);
+                    if (now > entry.expiresAt) {
+                        yield this.blacklistDb.del(key);
+                        count++;
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            return count;
+        });
+    }
     // Config operations
     getConfig() {
         const row = this.db.prepare('SELECT value FROM config WHERE key = ?').get('app_config');
@@ -474,9 +569,235 @@ class DatabaseManager {
             }
         });
     }
+    // Statistics operations
+    getStatistics() {
+        return __awaiter(this, arguments, void 0, function* (days = 30) {
+            var _a, e_5, _b, _c, _d, e_6, _e, _f;
+            var _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+            const now = Date.now();
+            const startTime = now - days * 24 * 60 * 60 * 1000;
+            // Get all logs within the time period
+            const allLogs = [];
+            try {
+                for (var _z = true, _0 = __asyncValues(this.logDb.iterator()), _1; _1 = yield _0.next(), _a = _1.done, !_a; _z = true) {
+                    _c = _1.value;
+                    _z = false;
+                    const [, value] = _c;
+                    const log = JSON.parse(value);
+                    if (log.timestamp >= startTime) {
+                        allLogs.push(log);
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (!_z && !_a && (_b = _0.return)) yield _b.call(_0);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            // Get all error logs
+            const errorLogs = [];
+            const recentErrorLogs = [];
+            const recentTime = now - 24 * 60 * 60 * 1000; // 24 hours ago
+            try {
+                for (var _2 = true, _3 = __asyncValues(this.errorLogDb.iterator()), _4; _4 = yield _3.next(), _d = _4.done, !_d; _2 = true) {
+                    _f = _4.value;
+                    _2 = false;
+                    const [, value] = _f;
+                    const log = JSON.parse(value);
+                    errorLogs.push(log);
+                    if (log.timestamp >= recentTime) {
+                        recentErrorLogs.push(log);
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (!_2 && !_d && (_e = _3.return)) yield _e.call(_3);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            // Get vendors and services for mapping
+            const vendors = this.getVendors();
+            const vendorMap = new Map(vendors.map(v => [v.id, v.name]));
+            const services = this.getAPIServices();
+            const serviceMap = new Map(services.map(s => [s.id, { name: s.name, vendorId: s.vendorId }]));
+            // Calculate overview
+            const totalRequests = allLogs.length;
+            const successRequests = allLogs.filter(log => log.statusCode && log.statusCode >= 200 && log.statusCode < 400).length;
+            const totalInputTokens = allLogs.reduce((sum, log) => { var _a; return sum + (((_a = log.usage) === null || _a === void 0 ? void 0 : _a.inputTokens) || 0); }, 0);
+            const totalOutputTokens = allLogs.reduce((sum, log) => { var _a; return sum + (((_a = log.usage) === null || _a === void 0 ? void 0 : _a.outputTokens) || 0); }, 0);
+            const totalCacheReadTokens = allLogs.reduce((sum, log) => { var _a; return sum + (((_a = log.usage) === null || _a === void 0 ? void 0 : _a.cacheReadInputTokens) || 0); }, 0);
+            const totalTokens = allLogs.reduce((sum, log) => {
+                var _a, _b, _c;
+                if ((_a = log.usage) === null || _a === void 0 ? void 0 : _a.totalTokens)
+                    return sum + log.usage.totalTokens;
+                return sum + (((_b = log.usage) === null || _b === void 0 ? void 0 : _b.inputTokens) || 0) + (((_c = log.usage) === null || _c === void 0 ? void 0 : _c.outputTokens) || 0);
+            }, 0);
+            const avgResponseTime = allLogs.length > 0
+                ? allLogs.reduce((sum, log) => sum + (log.responseTime || 0), 0) / allLogs.length
+                : 0;
+            const successRate = totalRequests > 0 ? (successRequests / totalRequests) * 100 : 0;
+            // Calculate coding time (estimate based on tokens and requests)
+            // Assume average reading speed: 250 tokens/minute, coding speed: 100 tokens/minute
+            const totalCodingTime = Math.round(totalInputTokens / 250 + totalOutputTokens / 100);
+            // Group by target type
+            const byTargetTypeMap = new Map();
+            for (const log of allLogs) {
+                const key = log.targetType || 'unknown';
+                if (!byTargetTypeMap.has(key)) {
+                    byTargetTypeMap.set(key, { requests: 0, tokens: 0, responseTime: 0 });
+                }
+                const stats = byTargetTypeMap.get(key);
+                stats.requests++;
+                stats.tokens += ((_g = log.usage) === null || _g === void 0 ? void 0 : _g.totalTokens) || (((_h = log.usage) === null || _h === void 0 ? void 0 : _h.inputTokens) || 0) + (((_j = log.usage) === null || _j === void 0 ? void 0 : _j.outputTokens) || 0);
+                stats.responseTime += log.responseTime || 0;
+            }
+            const byTargetType = Array.from(byTargetTypeMap.entries()).map(([targetType, stats]) => ({
+                targetType: targetType,
+                totalRequests: stats.requests,
+                totalTokens: stats.tokens,
+                avgResponseTime: stats.requests > 0 ? Math.round(stats.responseTime / stats.requests) : 0,
+            }));
+            // Group by vendor
+            const byVendorMap = new Map();
+            for (const log of allLogs) {
+                const key = log.vendorId || 'unknown';
+                if (!byVendorMap.has(key)) {
+                    byVendorMap.set(key, { requests: 0, tokens: 0, responseTime: 0 });
+                }
+                const stats = byVendorMap.get(key);
+                stats.requests++;
+                stats.tokens += ((_k = log.usage) === null || _k === void 0 ? void 0 : _k.totalTokens) || (((_l = log.usage) === null || _l === void 0 ? void 0 : _l.inputTokens) || 0) + (((_m = log.usage) === null || _m === void 0 ? void 0 : _m.outputTokens) || 0);
+                stats.responseTime += log.responseTime || 0;
+            }
+            const byVendor = Array.from(byVendorMap.entries()).map(([vendorId, stats]) => ({
+                vendorId,
+                vendorName: vendorMap.get(vendorId) || 'Unknown',
+                totalRequests: stats.requests,
+                totalTokens: stats.tokens,
+                avgResponseTime: stats.requests > 0 ? Math.round(stats.responseTime / stats.requests) : 0,
+            }));
+            // Group by service
+            const byServiceMap = new Map();
+            for (const log of allLogs) {
+                const key = log.targetServiceId || 'unknown';
+                if (!byServiceMap.has(key)) {
+                    byServiceMap.set(key, { requests: 0, tokens: 0, responseTime: 0 });
+                }
+                const stats = byServiceMap.get(key);
+                stats.requests++;
+                stats.tokens += ((_o = log.usage) === null || _o === void 0 ? void 0 : _o.totalTokens) || (((_p = log.usage) === null || _p === void 0 ? void 0 : _p.inputTokens) || 0) + (((_q = log.usage) === null || _q === void 0 ? void 0 : _q.outputTokens) || 0);
+                stats.responseTime += log.responseTime || 0;
+            }
+            const byService = Array.from(byServiceMap.entries()).map(([serviceId, stats]) => {
+                const serviceInfo = serviceMap.get(serviceId);
+                return {
+                    serviceId,
+                    serviceName: (serviceInfo === null || serviceInfo === void 0 ? void 0 : serviceInfo.name) || 'Unknown',
+                    vendorName: serviceInfo ? vendorMap.get(serviceInfo.vendorId) || 'Unknown' : 'Unknown',
+                    totalRequests: stats.requests,
+                    totalTokens: stats.tokens,
+                    avgResponseTime: stats.requests > 0 ? Math.round(stats.responseTime / stats.requests) : 0,
+                };
+            });
+            // Group by model
+            const byModelMap = new Map();
+            for (const log of allLogs) {
+                const key = log.targetModel || 'unknown';
+                if (!byModelMap.has(key)) {
+                    byModelMap.set(key, { requests: 0, tokens: 0, responseTime: 0 });
+                }
+                const stats = byModelMap.get(key);
+                stats.requests++;
+                stats.tokens += ((_r = log.usage) === null || _r === void 0 ? void 0 : _r.totalTokens) || (((_s = log.usage) === null || _s === void 0 ? void 0 : _s.inputTokens) || 0) + (((_t = log.usage) === null || _t === void 0 ? void 0 : _t.outputTokens) || 0);
+                stats.responseTime += log.responseTime || 0;
+            }
+            const byModel = Array.from(byModelMap.entries()).map(([modelName, stats]) => ({
+                modelName,
+                totalRequests: stats.requests,
+                totalTokens: stats.tokens,
+                avgResponseTime: stats.requests > 0 ? Math.round(stats.responseTime / stats.requests) : 0,
+            }));
+            // Timeline data (by day)
+            const timelineMap = new Map();
+            for (const log of allLogs) {
+                const date = new Date(log.timestamp).toISOString().split('T')[0];
+                if (!timelineMap.has(date)) {
+                    timelineMap.set(date, { requests: 0, tokens: 0, inputTokens: 0, outputTokens: 0 });
+                }
+                const stats = timelineMap.get(date);
+                stats.requests++;
+                stats.inputTokens += ((_u = log.usage) === null || _u === void 0 ? void 0 : _u.inputTokens) || 0;
+                stats.outputTokens += ((_v = log.usage) === null || _v === void 0 ? void 0 : _v.outputTokens) || 0;
+                stats.tokens += ((_w = log.usage) === null || _w === void 0 ? void 0 : _w.totalTokens) || (((_x = log.usage) === null || _x === void 0 ? void 0 : _x.inputTokens) || 0) + (((_y = log.usage) === null || _y === void 0 ? void 0 : _y.outputTokens) || 0);
+            }
+            const timeline = Array.from(timelineMap.entries())
+                .map(([date, stats]) => ({
+                date,
+                totalRequests: stats.requests,
+                totalTokens: stats.tokens,
+                totalInputTokens: stats.inputTokens,
+                totalOutputTokens: stats.outputTokens,
+            }))
+                .sort((a, b) => a.date.localeCompare(b.date));
+            // Content type distribution (infer from request patterns)
+            const contentTypeMap = new Map();
+            for (const log of allLogs) {
+                // Infer content type from request characteristics
+                let contentType = 'default';
+                if (log.body && (log.body.includes('image') || log.body.includes('base64'))) {
+                    contentType = 'image-understanding';
+                }
+                else if (log.requestModel && log.requestModel.toLowerCase().includes('think')) {
+                    contentType = 'thinking';
+                }
+                else if (log.usage && log.usage.inputTokens > 12000) {
+                    contentType = 'long-context';
+                }
+                contentTypeMap.set(contentType, (contentTypeMap.get(contentType) || 0) + 1);
+            }
+            const contentTypeDistribution = Array.from(contentTypeMap.entries()).map(([contentType, count]) => ({
+                contentType,
+                count,
+                percentage: totalRequests > 0 ? Math.round((count / totalRequests) * 100) : 0,
+            }));
+            return {
+                overview: {
+                    totalRequests,
+                    totalTokens,
+                    totalInputTokens,
+                    totalOutputTokens,
+                    totalCacheReadTokens,
+                    totalVendors: vendors.length,
+                    totalServices: services.length,
+                    totalRoutes: this.getRoutes().length,
+                    totalRules: this.getRules().length,
+                    avgResponseTime: Math.round(avgResponseTime),
+                    successRate: Math.round(successRate * 10) / 10,
+                    totalCodingTime,
+                },
+                byTargetType,
+                byVendor,
+                byService,
+                byModel,
+                timeline,
+                contentTypeDistribution,
+                errors: {
+                    totalErrors: errorLogs.length,
+                    recentErrors: recentErrorLogs.length,
+                },
+            };
+        });
+    }
     close() {
         this.db.close();
         this.logDb.close();
+        this.accessLogDb.close();
+        this.errorLogDb.close();
+        this.blacklistDb.close();
     }
 }
 exports.DatabaseManager = DatabaseManager;

package/dist/server/main.js

@@ -21,6 +21,7 @@ const database_1 = require("./database");
 const proxy_server_1 = require("./proxy-server");
 const os_1 = __importDefault(require("os"));
 const auth_1 = require("./auth");
+const version_check_1 = require("./version-check");
 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 });
@@ -44,6 +45,12 @@ const writeClaudeConfig = (dbManager) => __awaiter(void 0, void 0, void 0, funct
         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');
+            return false;
+        }
         if (fs_1.default.existsSync(claudeSettingsPath)) {
             fs_1.default.renameSync(claudeSettingsPath, claudeSettingsBakPath);
         }
@@ -60,7 +67,6 @@ 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');
-        const claudeJsonBakPath = path_1.default.join(homeDir, '.claude.json.bak');
         if (fs_1.default.existsSync(claudeJsonPath)) {
             fs_1.default.renameSync(claudeJsonPath, claudeJsonBakPath);
         }
@@ -86,6 +92,12 @@ const writeCodexConfig = (dbManager) => __awaiter(void 0, void 0, void 0, functi
         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');
+            return false;
+        }
         if (fs_1.default.existsSync(codexConfigPath)) {
             fs_1.default.renameSync(codexConfigPath, codexConfigBakPath);
         }
@@ -107,7 +119,6 @@ requires_openai_auth = true
         fs_1.default.writeFileSync(codexConfigPath, codexConfig);
         // Codex auth.json
         const codexAuthPath = path_1.default.join(codexDir, 'auth.json');
-        const codexAuthBakPath = path_1.default.join(codexDir, 'auth.json.bak');
         if (fs_1.default.existsSync(codexAuthPath)) {
             fs_1.default.renameSync(codexAuthPath, codexAuthBakPath);
         }
@@ -351,6 +362,15 @@ const registerRoutes = (dbManager, proxyServer) => {
         }
         res.json(result);
     })));
+    app.get('/api/version/check', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const versionInfo = yield (0, version_check_1.checkVersionUpdate)();
+        res.json(versionInfo);
+    })));
+    app.get('/api/statistics', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const days = typeof req.query.days === 'string' ? parseInt(req.query.days, 10) : 30;
+        const stats = yield dbManager.getStatistics(days);
+        res.json(stats);
+    })));
     app.use(express_1.default.static(path_1.default.resolve(__dirname, '../ui')));
 };
 const start = () => __awaiter(void 0, void 0, void 0, function* () {