aicodeswitch 1.0.0

package/dist/server/main.js

@@ -0,0 +1,382 @@
+"use strict";
+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 });
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const database_1 = require("./database");
+const proxy_server_1 = require("./proxy-server");
+const os_1 = __importDefault(require("os"));
+const auth_1 = require("./auth");
+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 });
+}
+const host = process.env.HOST || '127.0.0.1';
+const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 4567;
+const dataDir = process.env.DATA_DIR ? path_1.default.resolve(process.cwd(), process.env.DATA_DIR) : path_1.default.join(os_1.default.homedir(), '.aicodeswitch/data');
+const app = (0, express_1.default)();
+app.use((0, cors_1.default)());
+app.use(express_1.default.json({ limit: '10mb' }));
+app.use(express_1.default.urlencoded({ extended: true }));
+const asyncHandler = (handler) => (req, res, next) => {
+    Promise.resolve(handler(req, res, next)).catch(next);
+};
+const writeClaudeConfig = (dbManager) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const homeDir = os_1.default.homedir();
+        const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 4567;
+        const config = dbManager.getConfig();
+        // Claude Code settings.json
+        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');
+        if (fs_1.default.existsSync(claudeSettingsPath)) {
+            fs_1.default.renameSync(claudeSettingsPath, claudeSettingsBakPath);
+        }
+        if (!fs_1.default.existsSync(claudeDir)) {
+            fs_1.default.mkdirSync(claudeDir, { recursive: true });
+        }
+        const claudeSettings = {
+            env: {
+                ANTHROPIC_AUTH_TOKEN: config.apiKey || "api_key",
+                ANTHROPIC_BASE_URL: `http://${host}:${port}/claude-code`,
+                API_TIMEOUT_MS: "3000000"
+            },
+            hasCompletedOnboarding: true
+        };
+        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);
+        }
+        const claudeJson = {
+            hasCompletedOnboarding: true
+        };
+        fs_1.default.writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2));
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to write Claude config files:', error);
+        return false;
+    }
+});
+const writeCodexConfig = (dbManager) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const homeDir = os_1.default.homedir();
+        const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 4567;
+        const config = dbManager.getConfig();
+        // Codex config.toml
+        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');
+        if (fs_1.default.existsSync(codexConfigPath)) {
+            fs_1.default.renameSync(codexConfigPath, codexConfigBakPath);
+        }
+        if (!fs_1.default.existsSync(codexDir)) {
+            fs_1.default.mkdirSync(codexDir, { recursive: true });
+        }
+        const codexConfig = `model_provider = "aicodeswitch"
+model = "gpt-5.1-codex"
+model_reasoning_effort = "high"
+disable_response_storage = true
+
+
+[model_providers.aicodeswitch]
+name = "aicodeswitch"
+base_url = "http://${host}:${port}/codex"
+wire_api = "responses"
+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);
+        }
+        const codexAuth = {
+            OPENAI_API_KEY: config.apiKey || "api_key"
+        };
+        fs_1.default.writeFileSync(codexAuthPath, JSON.stringify(codexAuth, null, 2));
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to write Codex config files:', error);
+        return false;
+    }
+});
+const restoreClaudeConfig = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const homeDir = os_1.default.homedir();
+        // Restore Claude Code settings.json
+        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');
+        if (fs_1.default.existsSync(claudeSettingsBakPath)) {
+            if (fs_1.default.existsSync(claudeSettingsPath)) {
+                fs_1.default.unlinkSync(claudeSettingsPath);
+            }
+            fs_1.default.renameSync(claudeSettingsBakPath, claudeSettingsPath);
+        }
+        // Restore 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(claudeJsonBakPath)) {
+            if (fs_1.default.existsSync(claudeJsonPath)) {
+                fs_1.default.unlinkSync(claudeJsonPath);
+            }
+            fs_1.default.renameSync(claudeJsonBakPath, claudeJsonPath);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to restore Claude config files:', error);
+        return false;
+    }
+});
+const restoreCodexConfig = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const homeDir = os_1.default.homedir();
+        // Restore Codex config.toml
+        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');
+        if (fs_1.default.existsSync(codexConfigBakPath)) {
+            if (fs_1.default.existsSync(codexConfigPath)) {
+                fs_1.default.unlinkSync(codexConfigPath);
+            }
+            fs_1.default.renameSync(codexConfigBakPath, codexConfigPath);
+        }
+        // Restore 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(codexAuthBakPath)) {
+            if (fs_1.default.existsSync(codexAuthPath)) {
+                fs_1.default.unlinkSync(codexAuthPath);
+            }
+            fs_1.default.renameSync(codexAuthBakPath, codexAuthPath);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to restore Codex config files:', error);
+        return false;
+    }
+});
+const checkClaudeBackupExists = () => {
+    try {
+        const homeDir = os_1.default.homedir();
+        const claudeSettingsBakPath = path_1.default.join(homeDir, '.claude', 'settings.json.bak');
+        const claudeJsonBakPath = path_1.default.join(homeDir, '.claude.json.bak');
+        return fs_1.default.existsSync(claudeSettingsBakPath) || fs_1.default.existsSync(claudeJsonBakPath);
+    }
+    catch (error) {
+        console.error('Failed to check Claude backup files:', error);
+        return false;
+    }
+};
+const checkCodexBackupExists = () => {
+    try {
+        const homeDir = os_1.default.homedir();
+        const codexConfigBakPath = path_1.default.join(homeDir, '.codex', 'config.toml.bak');
+        const codexAuthBakPath = path_1.default.join(homeDir, '.codex', 'auth.json.bak');
+        return fs_1.default.existsSync(codexConfigBakPath) || fs_1.default.existsSync(codexAuthBakPath);
+    }
+    catch (error) {
+        console.error('Failed to check Codex backup files:', error);
+        return false;
+    }
+};
+const registerRoutes = (dbManager, proxyServer) => {
+    app.get('/health', (_req, res) => res.json({ status: 'ok' }));
+    // 鉴权相关路由 - 公开访问
+    app.get('/api/auth/status', (_req, res) => {
+        const response = { enabled: (0, auth_1.isAuthEnabled)() };
+        res.json(response);
+    });
+    app.post('/api/auth/login', (req, res) => {
+        const { authCode } = req.body;
+        if (!authCode) {
+            res.status(400).json({ error: 'Auth code is required' });
+            return;
+        }
+        if ((0, auth_1.verifyAuthCode)(authCode)) {
+            const token = (0, auth_1.generateToken)();
+            const response = { token };
+            res.json(response);
+        }
+        else {
+            res.status(401).json({ error: 'Invalid auth code' });
+        }
+    });
+    // 鉴权中间件 - 保护所有 /api/* 路由 (除了 /api/auth/*)
+    app.use('/api', (req, res, next) => {
+        if (req.path.startsWith('/auth/')) {
+            next(); // /api/auth/* 路由不需要鉴权
+        }
+        else {
+            (0, auth_1.authMiddleware)(req, res, next);
+        }
+    });
+    app.get('/api/vendors', (_req, res) => res.json(dbManager.getVendors()));
+    app.post('/api/vendors', (req, res) => res.json(dbManager.createVendor(req.body)));
+    app.put('/api/vendors/:id', (req, res) => res.json(dbManager.updateVendor(req.params.id, req.body)));
+    app.delete('/api/vendors/:id', (req, res) => res.json(dbManager.deleteVendor(req.params.id)));
+    app.get('/api/services', (req, res) => {
+        const vendorId = typeof req.query.vendorId === 'string' ? req.query.vendorId : undefined;
+        res.json(dbManager.getAPIServices(vendorId));
+    });
+    app.post('/api/services', (req, res) => res.json(dbManager.createAPIService(req.body)));
+    app.put('/api/services/:id', (req, res) => res.json(dbManager.updateAPIService(req.params.id, req.body)));
+    app.delete('/api/services/:id', (req, res) => res.json(dbManager.deleteAPIService(req.params.id)));
+    app.get('/api/routes', (_req, res) => res.json(dbManager.getRoutes()));
+    app.post('/api/routes', (req, res) => res.json(dbManager.createRoute(req.body)));
+    app.put('/api/routes/:id', (req, res) => res.json(dbManager.updateRoute(req.params.id, req.body)));
+    app.delete('/api/routes/:id', (req, res) => res.json(dbManager.deleteRoute(req.params.id)));
+    app.post('/api/routes/:id/activate', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = dbManager.activateRoute(req.params.id);
+        if (result) {
+            yield proxyServer.reloadRoutes();
+        }
+        res.json(result);
+    })));
+    app.post('/api/routes/:id/deactivate', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = dbManager.deactivateRoute(req.params.id);
+        if (result) {
+            yield proxyServer.reloadRoutes();
+        }
+        res.json(result);
+    })));
+    app.get('/api/rules', (req, res) => {
+        const routeId = typeof req.query.routeId === 'string' ? req.query.routeId : undefined;
+        res.json(dbManager.getRules(routeId));
+    });
+    app.post('/api/rules', (req, res) => res.json(dbManager.createRule(req.body)));
+    app.put('/api/rules/:id', (req, res) => res.json(dbManager.updateRule(req.params.id, req.body)));
+    app.delete('/api/rules/:id', (req, res) => res.json(dbManager.deleteRule(req.params.id)));
+    app.get('/api/logs', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const rawLimit = typeof req.query.limit === 'string' ? parseInt(req.query.limit, 10) : NaN;
+        const rawOffset = typeof req.query.offset === 'string' ? parseInt(req.query.offset, 10) : NaN;
+        const limit = Number.isFinite(rawLimit) ? rawLimit : 100;
+        const offset = Number.isFinite(rawOffset) ? rawOffset : 0;
+        const logs = yield dbManager.getLogs(limit, offset);
+        res.json(logs);
+    })));
+    app.delete('/api/logs', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        yield dbManager.clearLogs();
+        res.json(true);
+    })));
+    app.get('/api/access-logs', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const rawLimit = typeof req.query.limit === 'string' ? parseInt(req.query.limit, 10) : NaN;
+        const rawOffset = typeof req.query.offset === 'string' ? parseInt(req.query.offset, 10) : NaN;
+        const limit = Number.isFinite(rawLimit) ? rawLimit : 100;
+        const offset = Number.isFinite(rawOffset) ? rawOffset : 0;
+        const logs = yield dbManager.getAccessLogs(limit, offset);
+        res.json(logs);
+    })));
+    app.delete('/api/access-logs', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        yield dbManager.clearAccessLogs();
+        res.json(true);
+    })));
+    app.get('/api/error-logs', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const rawLimit = typeof req.query.limit === 'string' ? parseInt(req.query.limit, 10) : NaN;
+        const rawOffset = typeof req.query.offset === 'string' ? parseInt(req.query.offset, 10) : NaN;
+        const limit = Number.isFinite(rawLimit) ? rawLimit : 100;
+        const offset = Number.isFinite(rawOffset) ? rawOffset : 0;
+        const logs = yield dbManager.getErrorLogs(limit, offset);
+        res.json(logs);
+    })));
+    app.delete('/api/error-logs', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        yield dbManager.clearErrorLogs();
+        res.json(true);
+    })));
+    app.get('/api/config', (_req, res) => res.json(dbManager.getConfig()));
+    app.put('/api/config', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const config = req.body;
+        const result = dbManager.updateConfig(config);
+        if (result) {
+            yield proxyServer.updateConfig(config);
+        }
+        res.json(result);
+    })));
+    app.post('/api/write-config/claude', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield writeClaudeConfig(dbManager);
+        res.json(result);
+    })));
+    app.post('/api/write-config/codex', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield writeCodexConfig(dbManager);
+        res.json(result);
+    })));
+    app.post('/api/restore-config/claude', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield restoreClaudeConfig();
+        res.json(result);
+    })));
+    app.post('/api/restore-config/codex', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield restoreCodexConfig();
+        res.json(result);
+    })));
+    app.get('/api/check-backup/claude', (_req, res) => {
+        res.json({ exists: checkClaudeBackupExists() });
+    });
+    app.get('/api/check-backup/codex', (_req, res) => {
+        res.json({ exists: checkCodexBackupExists() });
+    });
+    app.post('/api/export', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const { password } = req.body;
+        const data = yield dbManager.exportData(password);
+        res.json({ data });
+    })));
+    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) {
+            yield proxyServer.reloadRoutes();
+        }
+        res.json(result);
+    })));
+    app.use(express_1.default.static(path_1.default.resolve(__dirname, '../ui')));
+};
+const start = () => __awaiter(void 0, void 0, void 0, function* () {
+    fs_1.default.mkdirSync(dataDir, { recursive: true });
+    const dbManager = new database_1.DatabaseManager(dataDir);
+    yield dbManager.initialize();
+    const proxyServer = new proxy_server_1.ProxyServer(dbManager, app);
+    // Register admin routes first
+    registerRoutes(dbManager, proxyServer);
+    // Initialize proxy server and register proxy routes last
+    yield proxyServer.initialize();
+    const adminServer = app.listen(port, host, () => {
+        console.log(`Admin server running on http://${host}:${port}`);
+    });
+    const shutdown = () => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('Shutting down server...');
+        dbManager.close();
+        adminServer.close(() => process.exit(0));
+    });
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+});
+app.use((err, _req, res, _next) => {
+    console.error(err);
+    res.status(500).json({ error: err.message || 'Internal server error' });
+});
+start().catch((error) => {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+});