aicodeswitch 1.0.0

package/dist/server/auth.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthEnabled = isAuthEnabled;
+exports.verifyAuthCode = verifyAuthCode;
+exports.generateToken = generateToken;
+exports.verifyToken = verifyToken;
+exports.authMiddleware = authMiddleware;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const crypto_1 = __importDefault(require("crypto"));
+const AUTH_CODE = process.env.AUTH || '';
+const JWT_SECRET = process.env.JWT_SECRET || (AUTH_CODE ? crypto_1.default.createHash('sha256').update(AUTH_CODE).digest('hex') : '');
+const TOKEN_EXPIRY = '7d'; // 7天有效期
+/**
+ * 检查是否启用鉴权
+ */
+function isAuthEnabled() {
+    return AUTH_CODE.trim().length > 0;
+}
+/**
+ * 验证鉴权码
+ */
+function verifyAuthCode(authCode) {
+    if (!isAuthEnabled()) {
+        return true; // 未启用鉴权,直接通过
+    }
+    return authCode === AUTH_CODE;
+}
+/**
+ * 生成 JWT Token
+ */
+function generateToken() {
+    const payload = {
+        authenticated: true,
+    };
+    return jsonwebtoken_1.default.sign(payload, JWT_SECRET, { expiresIn: TOKEN_EXPIRY });
+}
+/**
+ * 验证 JWT Token
+ */
+function verifyToken(token) {
+    try {
+        jsonwebtoken_1.default.verify(token, JWT_SECRET);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Express 中间件: 验证 JWT Token
+ *
+ * 如果未启用鉴权,直接放行
+ * 如果启用鉴权但 token 无效,返回 401
+ */
+function authMiddleware(req, res, next) {
+    // 如果未启用鉴权,直接放行
+    if (!isAuthEnabled()) {
+        next();
+        return;
+    }
+    // 从 Authorization header 中提取 token
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        res.status(401).json({ error: 'Unauthorized: Missing or invalid token' });
+        return;
+    }
+    const token = authHeader.substring(7); // 移除 "Bearer " 前缀
+    if (verifyToken(token)) {
+        next();
+    }
+    else {
+        res.status(401).json({ error: 'Unauthorized: Invalid or expired token' });
+    }
+}

package/dist/server/database.js

@@ -0,0 +1,480 @@
+"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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseManager = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const level_1 = require("level");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
+class DatabaseManager {
+    constructor(dataPath) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logDb", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "accessLogDb", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "errorLogDb", {
+            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' });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.createTables();
+            yield this.ensureDefaultConfig();
+        });
+    }
+    createTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS vendors (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+       CREATE TABLE IF NOT EXISTS api_services (
+         id TEXT PRIMARY KEY,
+         vendor_id TEXT NOT NULL,
+         name TEXT NOT NULL,
+         api_url TEXT NOT NULL,
+         api_key TEXT NOT NULL,
+         timeout INTEGER,
+         source_type TEXT,
+         supported_models TEXT,
+         created_at INTEGER NOT NULL,
+         updated_at INTEGER NOT NULL,
+         FOREIGN KEY (vendor_id) REFERENCES vendors(id) ON DELETE CASCADE
+       );
+
+       CREATE TABLE IF NOT EXISTS routes (
+         id TEXT PRIMARY KEY,
+         name TEXT NOT NULL,
+         description TEXT,
+         target_type TEXT NOT NULL CHECK(target_type IN ('claude-code', 'codex')),
+         is_active INTEGER DEFAULT 0,
+         created_at INTEGER NOT NULL,
+         updated_at INTEGER NOT NULL
+       );
+
+      CREATE TABLE IF NOT EXISTS rules (
+        id TEXT PRIMARY KEY,
+        route_id TEXT NOT NULL,
+        content_type TEXT NOT NULL CHECK(content_type IN ('default', 'background', 'thinking', 'long-context', 'image-understanding')),
+        target_service_id TEXT NOT NULL,
+        target_model TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        FOREIGN KEY (route_id) REFERENCES routes(id) ON DELETE CASCADE,
+        FOREIGN KEY (target_service_id) REFERENCES api_services(id) ON DELETE CASCADE,
+        UNIQUE(route_id, content_type)
+      );
+
+      CREATE TABLE IF NOT EXISTS config (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+    }
+    ensureDefaultConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = this.db.prepare('SELECT * FROM config WHERE key = ?').get('app_config');
+            if (!config) {
+                const defaultConfig = {
+                    enableLogging: true,
+                    logRetentionDays: 7,
+                    maxLogSize: 1000,
+                    apiKey: '',
+                };
+                this.db.prepare('INSERT INTO config (key, value) VALUES (?, ?)').run('app_config', JSON.stringify(defaultConfig));
+            }
+        });
+    }
+    // Vendor operations
+    getVendors() {
+        const rows = this.db.prepare('SELECT * FROM vendors ORDER BY created_at DESC').all();
+        return rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    createVendor(vendor) {
+        const id = crypto_1.default.randomUUID();
+        const now = Date.now();
+        this.db
+            .prepare('INSERT INTO vendors (id, name, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?)')
+            .run(id, vendor.name, vendor.description || null, now, now);
+        return Object.assign(Object.assign({}, vendor), { id, createdAt: now, updatedAt: now });
+    }
+    updateVendor(id, vendor) {
+        const now = Date.now();
+        const result = this.db
+            .prepare('UPDATE vendors SET name = ?, description = ?, updated_at = ? WHERE id = ?')
+            .run(vendor.name, vendor.description || null, now, id);
+        return result.changes > 0;
+    }
+    deleteVendor(id) {
+        const result = this.db.prepare('DELETE FROM vendors WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    // API Service operations
+    getAPIServices(vendorId) {
+        const query = vendorId
+            ? 'SELECT * FROM api_services WHERE vendor_id = ? ORDER BY created_at DESC'
+            : 'SELECT * FROM api_services ORDER BY created_at DESC';
+        const stmt = vendorId ? this.db.prepare(query).bind(vendorId) : this.db.prepare(query);
+        const rows = stmt.all();
+        return rows.map((row) => ({
+            id: row.id,
+            vendorId: row.vendor_id,
+            name: row.name,
+            apiUrl: row.api_url,
+            apiKey: row.api_key,
+            timeout: row.timeout,
+            sourceType: row.source_type,
+            supportedModels: row.supported_models ? row.supported_models.split(',').map((model) => model.trim()).filter((model) => model.length > 0) : undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    createAPIService(service) {
+        const id = crypto_1.default.randomUUID();
+        const now = Date.now();
+        this.db
+            .prepare('INSERT INTO api_services (id, vendor_id, name, api_url, api_key, timeout, source_type, supported_models, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(id, service.vendorId, service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, now, now);
+        return Object.assign(Object.assign({}, service), { id, createdAt: now, updatedAt: now });
+    }
+    updateAPIService(id, service) {
+        const now = Date.now();
+        const result = this.db
+            .prepare('UPDATE api_services SET name = ?, api_url = ?, api_key = ?, timeout = ?, source_type = ?, supported_models = ?, updated_at = ? WHERE id = ?')
+            .run(service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, now, id);
+        return result.changes > 0;
+    }
+    deleteAPIService(id) {
+        const result = this.db.prepare('DELETE FROM api_services WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    // Route operations
+    getRoutes() {
+        const rows = this.db.prepare('SELECT * FROM routes ORDER BY created_at DESC').all();
+        return rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            targetType: row.target_type,
+            isActive: row.is_active === 1,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    createRoute(route) {
+        const id = crypto_1.default.randomUUID();
+        const now = Date.now();
+        this.db
+            .prepare('INSERT INTO routes (id, name, description, target_type, is_active, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+            .run(id, route.name, route.description || null, route.targetType, route.isActive ? 1 : 0, now, now);
+        return Object.assign(Object.assign({}, route), { id, createdAt: now, updatedAt: now });
+    }
+    updateRoute(id, route) {
+        const now = Date.now();
+        const result = this.db
+            .prepare('UPDATE routes SET name = ?, description = ?, target_type = ?, updated_at = ? WHERE id = ?')
+            .run(route.name, route.description || null, route.targetType, now, id);
+        return result.changes > 0;
+    }
+    deleteRoute(id) {
+        const result = this.db.prepare('DELETE FROM routes WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    activateRoute(id) {
+        const route = this.getRoutes().find(r => r.id === id);
+        if (route) {
+            this.db.prepare('UPDATE routes SET is_active = 0 WHERE target_type = ?').run(route.targetType);
+            const result = this.db.prepare('UPDATE routes SET is_active = 1 WHERE id = ?').run(id);
+            return result.changes > 0;
+        }
+        return false;
+    }
+    deactivateRoute(id) {
+        const result = this.db.prepare('UPDATE routes SET is_active = 0 WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    // Rule operations
+    getRules(routeId) {
+        const query = routeId
+            ? 'SELECT * FROM rules WHERE route_id = ? ORDER BY created_at DESC'
+            : 'SELECT * FROM rules ORDER BY created_at DESC';
+        const stmt = routeId ? this.db.prepare(query).bind(routeId) : this.db.prepare(query);
+        const rows = stmt.all();
+        return rows.map((row) => ({
+            id: row.id,
+            routeId: row.route_id,
+            contentType: row.content_type,
+            targetServiceId: row.target_service_id,
+            targetModel: row.target_model,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    createRule(route) {
+        const id = crypto_1.default.randomUUID();
+        const now = Date.now();
+        this.db
+            .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, target_model, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+            .run(id, route.routeId, route.contentType, route.targetServiceId, route.targetModel || null, now, now);
+        return Object.assign(Object.assign({}, route), { id, createdAt: now, updatedAt: now });
+    }
+    updateRule(id, route) {
+        const now = Date.now();
+        const result = this.db
+            .prepare('UPDATE rules SET content_type = ?, target_service_id = ?, target_model = ?, updated_at = ? WHERE id = ?')
+            .run(route.contentType, route.targetServiceId, route.targetModel || null, now, id);
+        return result.changes > 0;
+    }
+    deleteRule(id) {
+        const result = this.db.prepare('DELETE FROM rules WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    // Log operations
+    addLog(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = crypto_1.default.randomUUID();
+            yield this.logDb.put(id, JSON.stringify(Object.assign(Object.assign({}, log), { id })));
+        });
+    }
+    getLogs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 100, offset = 0) {
+            var _a, e_1, _b, _c;
+            const logs = [];
+            let count = 0;
+            try {
+                for (var _d = true, _e = __asyncValues(this.logDb.iterator({ reverse: true })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const [, value] = _c;
+                    if (count >= offset && logs.length < limit) {
+                        logs.push(JSON.parse(value));
+                    }
+                    count++;
+                    if (logs.length >= limit)
+                        break;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return logs;
+        });
+    }
+    clearLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.logDb.clear();
+        });
+    }
+    // Access log operations
+    addAccessLog(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = crypto_1.default.randomUUID();
+            yield this.accessLogDb.put(id, JSON.stringify(Object.assign(Object.assign({}, log), { id })));
+        });
+    }
+    getAccessLogs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 100, offset = 0) {
+            var _a, e_2, _b, _c;
+            const logs = [];
+            let count = 0;
+            try {
+                for (var _d = true, _e = __asyncValues(this.accessLogDb.iterator({ reverse: true })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const [, value] = _c;
+                    if (count >= offset && logs.length < limit) {
+                        logs.push(JSON.parse(value));
+                    }
+                    count++;
+                    if (logs.length >= limit)
+                        break;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return logs;
+        });
+    }
+    clearAccessLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accessLogDb.clear();
+        });
+    }
+    // Error log operations
+    addErrorLog(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = crypto_1.default.randomUUID();
+            yield this.errorLogDb.put(id, JSON.stringify(Object.assign(Object.assign({}, log), { id })));
+        });
+    }
+    getErrorLogs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 100, offset = 0) {
+            var _a, e_3, _b, _c;
+            const logs = [];
+            let count = 0;
+            try {
+                for (var _d = true, _e = __asyncValues(this.errorLogDb.iterator({ reverse: true })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const [, value] = _c;
+                    if (count >= offset && logs.length < limit) {
+                        logs.push(JSON.parse(value));
+                    }
+                    count++;
+                    if (logs.length >= limit)
+                        break;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            return logs;
+        });
+    }
+    clearErrorLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.errorLogDb.clear();
+        });
+    }
+    // Config operations
+    getConfig() {
+        const row = this.db.prepare('SELECT value FROM config WHERE key = ?').get('app_config');
+        return row ? JSON.parse(row.value) : null;
+    }
+    updateConfig(config) {
+        const result = this.db
+            .prepare('UPDATE config SET value = ? WHERE key = ?')
+            .run(JSON.stringify(config), 'app_config');
+        return result.changes > 0;
+    }
+    // Export/Import operations
+    exportData(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exportData = {
+                version: '1.0.0',
+                exportDate: Date.now(),
+                vendors: this.getVendors(),
+                apiServices: this.getAPIServices(),
+                routes: this.getRoutes(),
+                rules: this.getRules(),
+                config: this.getConfig(),
+            };
+            const jsonData = JSON.stringify(exportData);
+            const encrypted = crypto_js_1.default.AES.encrypt(jsonData, password).toString();
+            return encrypted;
+        });
+    }
+    importData(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);
+                // Clear existing data
+                this.db.prepare('DELETE FROM rules').run();
+                this.db.prepare('DELETE FROM routes').run();
+                this.db.prepare('DELETE FROM api_services').run();
+                this.db.prepare('DELETE FROM vendors').run();
+                // Import vendors
+                for (const vendor of importData.vendors) {
+                    this.db
+                        .prepare('INSERT INTO vendors (id, name, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?)')
+                        .run(vendor.id, vendor.name, vendor.description || null, vendor.createdAt, vendor.updatedAt);
+                }
+                // Import API services
+                for (const service of importData.apiServices) {
+                    this.db
+                        .prepare('INSERT INTO api_services (id, vendor_id, name, api_url, api_key, timeout, source_type, supported_models, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+                        .run(service.id, service.vendorId, service.name, service.apiUrl, service.apiKey, service.timeout || null, service.sourceType || null, service.supportedModels ? service.supportedModels.join(',') : null, service.createdAt, service.updatedAt);
+                }
+                // Import routes
+                for (const route of importData.routes) {
+                    this.db
+                        .prepare('INSERT INTO routes (id, name, description, target_type, is_active, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+                        .run(route.id, route.name, route.description || null, route.targetType, route.isActive ? 1 : 0, route.createdAt, route.updatedAt);
+                }
+                // Import rules
+                for (const rule of importData.rules) {
+                    this.db
+                        .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)')
+                        .run(rule.id, rule.routeId, rule.contentType || 'default', rule.targetServiceId, rule.createdAt, rule.updatedAt);
+                }
+                // Update config
+                this.updateConfig(importData.config);
+                return true;
+            }
+            catch (error) {
+                console.error('Import error:', error);
+                return false;
+            }
+        });
+    }
+    close() {
+        this.db.close();
+        this.logDb.close();
+    }
+}
+exports.DatabaseManager = DatabaseManager;