aicodeswitch 3.9.3 → 4.0.0

package/dist/server/database.js

@@ -1,1609 +0,0 @@
-"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 __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;
-    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, "errorLogDb", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "blacklistDb", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // 缓存机制：总数查询缓存
-        Object.defineProperty(this, "logsCountCache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "errorLogsCountCache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "CACHE_TTL", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 1000
-        }); // 1秒缓存TTL
-        this.db = new better_sqlite3_1.default(path_1.default.join(dataPath, 'app.db'));
-        // 启用外键约束（SQLite 默认禁用，必须手动启用才能使 ON DELETE CASCADE 生效）
-        this.db.pragma('foreign_keys = ON');
-        // 配置数据库以确保实时读取最新数据
-        // WAL 模式 + normal 同步模式: 提供最佳的并发性和实时性
-        this.db.pragma('journal_mode = WAL');
-        this.db.pragma('synchronous = NORMAL');
-        // 确保读取操作不会看到旧的数据快照
-        // 在 WAL 模式下,默认情况下读取操作不会阻塞写入操作
-        // 设置 read_uncommitted = 0 确保读取最新提交的数据
-        this.db.pragma('read_uncommitted = 0');
-        this.logDb = new level_1.Level(path_1.default.join(dataPath, '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* () {
-            this.createTables();
-            yield this.runMigrations();
-            yield this.ensureDefaultConfig();
-        });
-    }
-    runMigrations() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const columns = this.db.pragma('table_info(api_services)');
-            // 检查是否有旧的 max_output_tokens 字段（单值版本）
-            const hasOldMaxOutputTokens = columns.some((col) => col.name === 'max_output_tokens');
-            // 检查是否已经有新的 model_limits 字段（JSON 版本）
-            const hasModelLimits = columns.some((col) => col.name === 'model_limits');
-            if (!hasModelLimits) {
-                if (hasOldMaxOutputTokens) {
-                    // 如果有旧字段，先删除旧字段（SQLite 不支持 ALTER TABLE DROP COLUMN，需要重建表）
-                    console.log('[DB] Running migration: Replacing max_output_tokens with model_limits');
-                    yield this.migrateMaxOutputTokensToModelLimits();
-                }
-                else {
-                    // 直接添加新字段
-                    console.log('[DB] Running migration: Adding model_limits column to api_services table');
-                    this.db.exec('ALTER TABLE api_services ADD COLUMN model_limits TEXT;');
-                    console.log('[DB] Migration completed: model_limits column added');
-                }
-            }
-            // 检查vendors表是否有sort_order字段
-            const vendorsColumns = this.db.pragma('table_info(vendors)');
-            const hasSortOrder = vendorsColumns.some((col) => col.name === 'sort_order');
-            if (!hasSortOrder) {
-                console.log('[DB] Running migration: Adding sort_order column to vendors table');
-                this.db.exec('ALTER TABLE vendors ADD COLUMN sort_order INTEGER DEFAULT 0;');
-                console.log('[DB] Migration completed: sort_order column added to vendors');
-            }
-            // 检查rules表是否有token相关字段
-            const rulesColumns = this.db.pragma('table_info(rules)');
-            const hasTokenLimit = rulesColumns.some((col) => col.name === 'token_limit');
-            const hasTotalTokensUsed = rulesColumns.some((col) => col.name === 'total_tokens_used');
-            const hasResetInterval = rulesColumns.some((col) => col.name === 'reset_interval');
-            const hasLastResetAt = rulesColumns.some((col) => col.name === 'last_reset_at');
-            if (!hasTokenLimit) {
-                console.log('[DB] Running migration: Adding token_limit column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN token_limit INTEGER;');
-                console.log('[DB] Migration completed: token_limit column added');
-            }
-            if (!hasTotalTokensUsed) {
-                console.log('[DB] Running migration: Adding total_tokens_used column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN total_tokens_used INTEGER DEFAULT 0;');
-                console.log('[DB] Migration completed: total_tokens_used column added');
-            }
-            if (!hasResetInterval) {
-                console.log('[DB] Running migration: Adding reset_interval column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN reset_interval INTEGER;');
-                console.log('[DB] Migration completed: reset_interval column added');
-            }
-            if (!hasLastResetAt) {
-                console.log('[DB] Running migration: Adding last_reset_at column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN last_reset_at INTEGER;');
-                console.log('[DB] Migration completed: last_reset_at column added');
-            }
-            // 检查rules表是否有timeout字段
-            const hasRuleTimeout = rulesColumns.some((col) => col.name === 'timeout');
-            if (!hasRuleTimeout) {
-                console.log('[DB] Running migration: Adding timeout column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN timeout INTEGER;');
-                console.log('[DB] Migration completed: timeout column added to rules');
-            }
-            // 检查api_services表是否有timeout字段，如果有则移除
-            const hasServiceTimeout = columns.some((col) => col.name === 'timeout');
-            if (hasServiceTimeout) {
-                console.log('[DB] Running migration: Removing timeout column from api_services table');
-                yield this.migrateRemoveServiceTimeout();
-                console.log('[DB] Migration completed: timeout column removed from api_services');
-            }
-            // 检查api_services表是否有enable_proxy字段
-            const hasEnableProxy = columns.some((col) => col.name === 'enable_proxy');
-            if (!hasEnableProxy) {
-                console.log('[DB] Running migration: Adding enable_proxy column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN enable_proxy INTEGER DEFAULT 0;');
-                console.log('[DB] Migration completed: enable_proxy column added');
-            }
-            // 检查rules表是否有请求次数相关字段
-            const hasRequestCountLimit = rulesColumns.some((col) => col.name === 'request_count_limit');
-            const hasTotalRequestsUsed = rulesColumns.some((col) => col.name === 'total_requests_used');
-            const hasRequestResetInterval = rulesColumns.some((col) => col.name === 'request_reset_interval');
-            const hasRequestLastResetAt = rulesColumns.some((col) => col.name === 'request_last_reset_at');
-            if (!hasRequestCountLimit) {
-                console.log('[DB] Running migration: Adding request_count_limit column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN request_count_limit INTEGER;');
-                console.log('[DB] Migration completed: request_count_limit column added');
-            }
-            if (!hasTotalRequestsUsed) {
-                console.log('[DB] Running migration: Adding total_requests_used column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN total_requests_used INTEGER DEFAULT 0;');
-                console.log('[DB] Migration completed: total_requests_used column added');
-            }
-            if (!hasRequestResetInterval) {
-                console.log('[DB] Running migration: Adding request_reset_interval column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN request_reset_interval INTEGER;');
-                console.log('[DB] Migration completed: request_reset_interval column added');
-            }
-            if (!hasRequestLastResetAt) {
-                console.log('[DB] Running migration: Adding request_last_reset_at column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN request_last_reset_at INTEGER;');
-                console.log('[DB] Migration completed: request_last_reset_at column added');
-            }
-            // 检查rules表是否有request_reset_base_time字段
-            const hasRequestResetBaseTime = rulesColumns.some((col) => col.name === 'request_reset_base_time');
-            if (!hasRequestResetBaseTime) {
-                console.log('[DB] Running migration: Adding request_reset_base_time column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN request_reset_base_time INTEGER;');
-                console.log('[DB] Migration completed: request_reset_base_time column added');
-            }
-            // 检查rules表是否有token_reset_base_time字段
-            const hasTokenResetBaseTime = rulesColumns.some((col) => col.name === 'token_reset_base_time');
-            if (!hasTokenResetBaseTime) {
-                console.log('[DB] Running migration: Adding token_reset_base_time column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN token_reset_base_time INTEGER;');
-                console.log('[DB] Migration completed: token_reset_base_time column added');
-            }
-            // 检查api_services表是否有超量配置相关字段
-            // Token超量配置
-            const hasEnableTokenLimit = columns.some((col) => col.name === 'enable_token_limit');
-            if (!hasEnableTokenLimit) {
-                console.log('[DB] Running migration: Adding enable_token_limit column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN enable_token_limit INTEGER DEFAULT 0;');
-                console.log('[DB] Migration completed: enable_token_limit column added');
-            }
-            const hasServiceTokenLimit = columns.some((col) => col.name === 'token_limit');
-            if (!hasServiceTokenLimit) {
-                console.log('[DB] Running migration: Adding token_limit column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN token_limit INTEGER;');
-                console.log('[DB] Migration completed: token_limit column added');
-            }
-            const hasTokenResetInterval = columns.some((col) => col.name === 'token_reset_interval');
-            if (!hasTokenResetInterval) {
-                console.log('[DB] Running migration: Adding token_reset_interval column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN token_reset_interval INTEGER;');
-                console.log('[DB] Migration completed: token_reset_interval column added');
-            }
-            const hasServiceTokenResetBaseTime = columns.some((col) => col.name === 'token_reset_base_time');
-            if (!hasServiceTokenResetBaseTime) {
-                console.log('[DB] Running migration: Adding token_reset_base_time column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN token_reset_base_time INTEGER;');
-                console.log('[DB] Migration completed: token_reset_base_time column added');
-            }
-            // 请求次数超量配置
-            const hasEnableRequestLimit = columns.some((col) => col.name === 'enable_request_limit');
-            if (!hasEnableRequestLimit) {
-                console.log('[DB] Running migration: Adding enable_request_limit column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN enable_request_limit INTEGER DEFAULT 0;');
-                console.log('[DB] Migration completed: enable_request_limit column added');
-            }
-            const hasServiceRequestCountLimit = columns.some((col) => col.name === 'request_count_limit');
-            if (!hasServiceRequestCountLimit) {
-                console.log('[DB] Running migration: Adding request_count_limit column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN request_count_limit INTEGER;');
-                console.log('[DB] Migration completed: request_count_limit column added');
-            }
-            const hasServiceRequestResetInterval = columns.some((col) => col.name === 'request_reset_interval');
-            if (!hasServiceRequestResetInterval) {
-                console.log('[DB] Running migration: Adding request_reset_interval column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN request_reset_interval INTEGER;');
-                console.log('[DB] Migration completed: request_reset_interval column added');
-            }
-            const hasServiceRequestResetBaseTime = columns.some((col) => col.name === 'request_reset_base_time');
-            if (!hasServiceRequestResetBaseTime) {
-                console.log('[DB] Running migration: Adding request_reset_base_time column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN request_reset_base_time INTEGER;');
-                console.log('[DB] Migration completed: request_reset_base_time column added');
-            }
-            // 检查api_services表是否有auth_type字段
-            const hasAuthType = columns.some((col) => col.name === 'auth_type');
-            if (!hasAuthType) {
-                console.log('[DB] Running migration: Adding auth_type column to api_services table');
-                this.db.exec('ALTER TABLE api_services ADD COLUMN auth_type TEXT DEFAULT NULL;');
-                console.log('[DB] Migration completed: auth_type column added');
-            }
-            // 检查rules表是否有is_disabled字段（临时屏蔽功能）
-            const hasIsDisabled = rulesColumns.some((col) => col.name === 'is_disabled');
-            if (!hasIsDisabled) {
-                console.log('[DB] Running migration: Adding is_disabled column to rules table');
-                this.db.exec('ALTER TABLE rules ADD COLUMN is_disabled INTEGER DEFAULT 0;');
-                console.log('[DB] Migration completed: is_disabled column added');
-            }
-        });
-    }
-    migrateMaxOutputTokensToModelLimits() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // SQLite 不支持直接删除列，需要重建表
-            // 先临时禁用外键约束
-            this.db.pragma('foreign_keys = OFF');
-            this.db.exec(`
-      CREATE TABLE api_services_new (
-        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,
-        model_limits TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        FOREIGN KEY (vendor_id) REFERENCES vendors(id) ON DELETE CASCADE
-      );
-
-      INSERT INTO api_services_new
-      SELECT
-        id, vendor_id, name, api_url, api_key, timeout, source_type, supported_models,
-        NULL, -- model_limits 设为 NULL，旧数据需要手动配置
-        created_at, updated_at
-      FROM api_services;
-
-      DROP TABLE api_services;
-      ALTER TABLE api_services_new RENAME TO api_services;
-    `);
-            // 重新启用外键约束
-            this.db.pragma('foreign_keys = ON');
-            console.log('[DB] Migration completed: Replaced max_output_tokens with model_limits');
-        });
-    }
-    migrateRemoveServiceTimeout() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // SQLite 不支持直接删除列，需要重建表
-            this.db.pragma('foreign_keys = OFF');
-            this.db.exec(`
-      CREATE TABLE api_services_new (
-        id TEXT PRIMARY KEY,
-        vendor_id TEXT NOT NULL,
-        name TEXT NOT NULL,
-        api_url TEXT NOT NULL,
-        api_key TEXT NOT NULL,
-        source_type TEXT,
-        supported_models TEXT,
-        model_limits TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        FOREIGN KEY (vendor_id) REFERENCES vendors(id) ON DELETE CASCADE
-      );
-
-      INSERT INTO api_services_new (id, vendor_id, name, api_url, api_key, source_type, supported_models, model_limits, created_at, updated_at)
-      SELECT id, vendor_id, name, api_url, api_key, source_type, supported_models, model_limits, created_at, updated_at
-      FROM api_services;
-
-      DROP TABLE api_services;
-      ALTER TABLE api_services_new RENAME TO api_services;
-    `);
-            this.db.pragma('foreign_keys = ON');
-        });
-    }
-    createTables() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS vendors (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        description TEXT,
-        sort_order INTEGER DEFAULT 0,
-        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,
-         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', 'model-mapping', 'high-iq')),
-        target_service_id TEXT NOT NULL,
-        target_model TEXT,
-        replaced_model TEXT,
-        sort_order INTEGER DEFAULT 0,
-        timeout INTEGER,
-        token_limit INTEGER,
-        total_tokens_used INTEGER DEFAULT 0,
-        reset_interval INTEGER,
-        last_reset_at INTEGER,
-        token_reset_base_time INTEGER,
-        request_count_limit INTEGER,
-        total_requests_used INTEGER DEFAULT 0,
-        request_reset_interval INTEGER,
-        request_last_reset_at INTEGER,
-        request_reset_base_time INTEGER,
-        is_disabled INTEGER DEFAULT 0,
-        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
-      );
-
-      CREATE TABLE IF NOT EXISTS config (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        target_type TEXT NOT NULL CHECK(target_type IN ('claude-code', 'codex')),
-        title TEXT,
-        first_request_at INTEGER NOT NULL,
-        last_request_at INTEGER NOT NULL,
-        request_count INTEGER DEFAULT 1,
-        total_tokens INTEGER DEFAULT 0,
-        vendor_id TEXT,
-        vendor_name TEXT,
-        service_id TEXT,
-        service_name TEXT,
-        model TEXT
-      );
-    `);
-    }
-    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: 30,
-                    maxLogSize: 100000,
-                    apiKey: '',
-                    enableFailover: true, // 默认启用智能故障切换
-                    proxyEnabled: false, // 默认不启用代理
-                    proxyUrl: '',
-                    proxyUsername: '',
-                    proxyPassword: '',
-                };
-                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 sort_order DESC, created_at DESC').all();
-        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();
-        const now = Date.now();
-        this.db
-            .prepare('INSERT INTO vendors (id, name, description, sort_order, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)')
-            .run(id, vendor.name, vendor.description || null, vendor.sortOrder || 0, 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 = ?, sort_order = ?, updated_at = ? WHERE id = ?')
-            .run(vendor.name, vendor.description || null, vendor.sortOrder !== undefined ? vendor.sortOrder : 0, 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';
-        // 不缓存 prepared statement,每次重新创建以确保读取最新数据
-        const stmt = this.db.prepare(query);
-        const rows = vendorId ? stmt.all(vendorId) : stmt.all();
-        const services = rows.map((row) => ({
-            id: row.id,
-            vendorId: row.vendor_id,
-            name: row.name,
-            apiUrl: row.api_url,
-            apiKey: row.api_key,
-            sourceType: row.source_type,
-            authType: row.auth_type,
-            supportedModels: row.supported_models ? row.supported_models.split(',').map((model) => model.trim()).filter((model) => model.length > 0) : undefined,
-            modelLimits: row.model_limits ? JSON.parse(row.model_limits) : undefined,
-            enableProxy: row.enable_proxy === 1,
-            // Token超量配置
-            enableTokenLimit: row.enable_token_limit === 1,
-            tokenLimit: row.token_limit,
-            tokenResetInterval: row.token_reset_interval,
-            tokenResetBaseTime: row.token_reset_base_time,
-            // 请求次数超量配置
-            enableRequestLimit: row.enable_request_limit === 1,
-            requestCountLimit: row.request_count_limit,
-            requestResetInterval: row.request_reset_interval,
-            requestResetBaseTime: row.request_reset_base_time,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        }));
-        // 调试日志: 记录读取的服务信息
-        if (process.env.NODE_ENV === 'development' && services.length > 0) {
-            console.log(`[DB] Read ${services.length} services from database, first service: ${services[0].name} -> ${services[0].apiUrl}`);
-        }
-        return services;
-    }
-    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, source_type, auth_type, supported_models, model_limits, enable_proxy, enable_token_limit, token_limit, token_reset_interval, token_reset_base_time, enable_request_limit, request_count_limit, request_reset_interval, request_reset_base_time, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-            .run(id, service.vendorId, service.name, service.apiUrl, service.apiKey, service.sourceType || null, service.authType || null, service.supportedModels ? service.supportedModels.join(',') : null, service.modelLimits ? JSON.stringify(service.modelLimits) : null, service.enableProxy ? 1 : 0, service.enableTokenLimit ? 1 : 0, service.tokenLimit || null, service.tokenResetInterval || null, service.tokenResetBaseTime || null, service.enableRequestLimit ? 1 : 0, service.requestCountLimit || null, service.requestResetInterval || null, service.requestResetBaseTime || 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 vendor_id = ?, name = ?, api_url = ?, api_key = ?, source_type = ?, auth_type = ?, supported_models = ?, model_limits = ?, enable_proxy = ?, enable_token_limit = ?, token_limit = ?, token_reset_interval = ?, token_reset_base_time = ?, enable_request_limit = ?, request_count_limit = ?, request_reset_interval = ?, request_reset_base_time = ?, updated_at = ? WHERE id = ?')
-            .run(service.vendorId, service.name, service.apiUrl, service.apiKey, service.sourceType || null, service.authType || null, service.supportedModels ? service.supportedModels.join(',') : null, service.modelLimits ? JSON.stringify(service.modelLimits) : null, service.enableProxy !== undefined ? (service.enableProxy ? 1 : 0) : null, service.enableTokenLimit !== undefined ? (service.enableTokenLimit ? 1 : 0) : null, service.tokenLimit !== undefined ? service.tokenLimit : null, service.tokenResetInterval !== undefined ? service.tokenResetInterval : null, service.tokenResetBaseTime !== undefined ? service.tokenResetBaseTime : null, service.enableRequestLimit !== undefined ? (service.enableRequestLimit ? 1 : 0) : null, service.requestCountLimit !== undefined ? service.requestCountLimit : null, service.requestResetInterval !== undefined ? service.requestResetInterval : null, service.requestResetBaseTime !== undefined ? service.requestResetBaseTime : null, now, id);
-        // 调试日志: 记录更新操作
-        if (result.changes > 0 && process.env.NODE_ENV === 'development') {
-            console.log(`[DB] Updated service ${id}: ${service.name} -> ${service.apiUrl}`);
-        }
-        // 如果更新成功，检查是否需要同步更新关联规则的超量限制
-        if (result.changes > 0) {
-            this.syncRulesWithServiceLimits(id, service);
-        }
-        return result.changes > 0;
-    }
-    /**
-     * 同步更新使用该服务的规则的超量限制
-     * 当API服务的超量限制修改时，自动更新所有使用该服务的规则
-     */
-    syncRulesWithServiceLimits(serviceId, service) {
-        // 获取所有使用该服务的规则
-        const rules = this.db.prepare('SELECT id FROM rules WHERE target_service_id = ?').all(serviceId);
-        if (rules.length === 0) {
-            return; // 没有规则使用此服务，无需同步
-        }
-        const now = Date.now();
-        const ruleIds = rules.map(r => r.id);
-        // Token超量限制同步
-        if (service.enableTokenLimit !== undefined || service.tokenLimit !== undefined ||
-            service.tokenResetInterval !== undefined || service.tokenResetBaseTime !== undefined) {
-            // 获取当前服务的最新配置
-            const currentService = this.db.prepare('SELECT enable_token_limit, token_limit, token_reset_interval, token_reset_base_time FROM api_services WHERE id = ?').get(serviceId);
-            if (currentService && currentService.enable_token_limit === 1) {
-                // 启用了Token超量限制，同步到所有规则
-                this.db.prepare('UPDATE rules SET token_limit = ?, reset_interval = ?, token_reset_base_time = ?, updated_at = ? WHERE target_service_id = ?').run(currentService.token_limit, currentService.token_reset_interval, currentService.token_reset_base_time, now, serviceId);
-                console.log(`[DB] Synced token limits for ${ruleIds.length} rule(s) using service ${serviceId}`);
-            }
-        }
-        // 请求次数超量限制同步
-        if (service.enableRequestLimit !== undefined || service.requestCountLimit !== undefined ||
-            service.requestResetInterval !== undefined || service.requestResetBaseTime !== undefined) {
-            // 获取当前服务的最新配置
-            const currentService = this.db.prepare('SELECT enable_request_limit, request_count_limit, request_reset_interval, request_reset_base_time FROM api_services WHERE id = ?').get(serviceId);
-            if (currentService && currentService.enable_request_limit === 1) {
-                // 启用了请求次数超量限制，同步到所有规则
-                this.db.prepare('UPDATE rules SET request_count_limit = ?, request_reset_interval = ?, request_reset_base_time = ?, updated_at = ? WHERE target_service_id = ?').run(currentService.request_count_limit, currentService.request_reset_interval, currentService.request_reset_base_time, now, serviceId);
-                console.log(`[DB] Synced request count limits for ${ruleIds.length} rule(s) using service ${serviceId}`);
-            }
-        }
-    }
-    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;
-    }
-    deactivateAllRoutes() {
-        const result = this.db.prepare('UPDATE routes SET is_active = 0 WHERE is_active = 1').run();
-        return result.changes;
-    }
-    // Rule operations
-    getRules(routeId) {
-        const query = routeId
-            ? 'SELECT * FROM rules WHERE route_id = ? ORDER BY sort_order DESC, created_at DESC'
-            : 'SELECT * FROM rules ORDER BY sort_order DESC, 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,
-            replacedModel: row.replaced_model,
-            sortOrder: row.sort_order,
-            timeout: row.timeout,
-            tokenLimit: row.token_limit,
-            totalTokensUsed: row.total_tokens_used,
-            resetInterval: row.reset_interval,
-            lastResetAt: row.last_reset_at,
-            tokenResetBaseTime: row.token_reset_base_time,
-            requestCountLimit: row.request_count_limit,
-            totalRequestsUsed: row.total_requests_used,
-            requestResetInterval: row.request_reset_interval,
-            requestLastResetAt: row.request_last_reset_at,
-            requestResetBaseTime: row.request_reset_base_time,
-            isDisabled: row.is_disabled === 1,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        }));
-    }
-    getRule(id) {
-        const row = this.db.prepare('SELECT * FROM rules WHERE id = ?').get(id);
-        if (!row)
-            return undefined;
-        return {
-            id: row.id,
-            routeId: row.route_id,
-            contentType: row.content_type,
-            targetServiceId: row.target_service_id,
-            targetModel: row.target_model,
-            replacedModel: row.replaced_model,
-            sortOrder: row.sort_order,
-            timeout: row.timeout,
-            tokenLimit: row.token_limit,
-            totalTokensUsed: row.total_tokens_used,
-            resetInterval: row.reset_interval,
-            lastResetAt: row.last_reset_at,
-            tokenResetBaseTime: row.token_reset_base_time,
-            requestCountLimit: row.request_count_limit,
-            totalRequestsUsed: row.total_requests_used,
-            requestResetInterval: row.request_reset_interval,
-            requestLastResetAt: row.request_last_reset_at,
-            requestResetBaseTime: row.request_reset_base_time,
-            isDisabled: row.is_disabled === 1,
-            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, replaced_model, sort_order, timeout, token_limit, total_tokens_used, reset_interval, last_reset_at, token_reset_base_time, request_count_limit, total_requests_used, request_reset_interval, request_last_reset_at, request_reset_base_time, is_disabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-            .run(id, route.routeId, route.contentType, route.targetServiceId, route.targetModel || null, route.replacedModel || null, route.sortOrder || 0, route.timeout || null, route.tokenLimit || null, route.totalTokensUsed || 0, route.resetInterval || null, route.lastResetAt || null, route.tokenResetBaseTime || null, route.requestCountLimit || null, route.totalRequestsUsed || 0, route.requestResetInterval || null, route.requestLastResetAt || null, route.requestResetBaseTime || null, route.isDisabled ? 1 : 0, 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 = ?, replaced_model = ?, sort_order = ?, timeout = ?, token_limit = ?, reset_interval = ?, token_reset_base_time = ?, request_count_limit = ?, request_reset_interval = ?, request_reset_base_time = ?, is_disabled = ?, updated_at = ? WHERE id = ?')
-            .run(route.contentType, route.targetServiceId, route.targetModel || null, route.replacedModel || null, route.sortOrder || 0, route.timeout !== undefined ? route.timeout : null, route.tokenLimit !== undefined ? route.tokenLimit : null, route.resetInterval !== undefined ? route.resetInterval : null, route.tokenResetBaseTime !== undefined ? route.tokenResetBaseTime : null, route.requestCountLimit !== undefined ? route.requestCountLimit : null, route.requestResetInterval !== undefined ? route.requestResetInterval : null, route.requestResetBaseTime !== undefined ? route.requestResetBaseTime : null, route.isDisabled !== undefined ? (route.isDisabled ? 1 : 0) : 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;
-    }
-    /**
-     * 切换规则的临时屏蔽状态
-     * @param ruleId 规则ID
-     * @returns 是否成功
-     */
-    toggleRuleDisabled(ruleId) {
-        const rule = this.getRule(ruleId);
-        if (!rule) {
-            return { success: false, isDisabled: false };
-        }
-        const now = Date.now();
-        const newDisabledState = !rule.isDisabled;
-        const result = this.db
-            .prepare('UPDATE rules SET is_disabled = ?, updated_at = ? WHERE id = ?')
-            .run(newDisabledState ? 1 : 0, now, ruleId);
-        return {
-            success: result.changes > 0,
-            isDisabled: newDisabledState
-        };
-    }
-    /**
-     * 增加规则的token使用量
-     * @param ruleId 规则ID
-     * @param tokensUsed 使用的token数量
-     * @returns 是否成功
-     */
-    incrementRuleTokenUsage(ruleId, tokensUsed) {
-        const result = this.db
-            .prepare('UPDATE rules SET total_tokens_used = total_tokens_used + ? WHERE id = ?')
-            .run(tokensUsed, ruleId);
-        return result.changes > 0;
-    }
-    /**
-     * 重置规则的token使用量
-     * @param ruleId 规则ID
-     * @returns 是否成功
-     */
-    resetRuleTokenUsage(ruleId) {
-        const now = Date.now();
-        const result = this.db
-            .prepare('UPDATE rules SET total_tokens_used = 0, last_reset_at = ? WHERE id = ?')
-            .run(now, ruleId);
-        return result.changes > 0;
-    }
-    /**
-     * 检查并重置到期的规则
-     * 如果规则设置了reset_interval且已经到了重置时间，则自动重置token使用量
-     * @param ruleId 规则ID
-     * @returns 是否进行了重置
-     */
-    checkAndResetRuleIfNeeded(ruleId) {
-        const rule = this.db
-            .prepare('SELECT reset_interval, last_reset_at, token_reset_base_time FROM rules WHERE id = ?')
-            .get(ruleId);
-        if (!rule || !rule.reset_interval) {
-            return false; // 没有设置重置间隔
-        }
-        const now = Date.now();
-        const resetIntervalMs = rule.reset_interval * 60 * 60 * 1000; // 小时转毫秒
-        const baseTime = rule.token_reset_base_time;
-        const lastResetAt = rule.last_reset_at || 0;
-        // 场景1: 设置了时间基点
-        if (baseTime) {
-            if (now >= baseTime) {
-                this.resetRuleTokenUsageWithBaseTime(ruleId, baseTime);
-                return true;
-            }
-            return false;
-        }
-        // 场景2: 未设置时间基点，使用原始逻辑（向后兼容）
-        if (now - lastResetAt >= resetIntervalMs) {
-            this.resetRuleTokenUsage(ruleId);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * 重置规则的Token使用量（带时间基点更新）
-     */
-    resetRuleTokenUsageWithBaseTime(ruleId, currentBaseTime) {
-        const now = Date.now();
-        const rule = this.db
-            .prepare('SELECT reset_interval FROM rules WHERE id = ?')
-            .get(ruleId);
-        if (!rule || !rule.reset_interval) {
-            return false;
-        }
-        const resetIntervalMs = rule.reset_interval * 60 * 60 * 1000;
-        // 计算下一个时间基点
-        let nextBaseTime = currentBaseTime;
-        while (nextBaseTime <= now) {
-            nextBaseTime += resetIntervalMs;
-        }
-        const result = this.db
-            .prepare('UPDATE rules SET total_tokens_used = 0, last_reset_at = ?, token_reset_base_time = ? WHERE id = ?')
-            .run(now, nextBaseTime, ruleId);
-        return result.changes > 0;
-    }
-    /**
-     * 增加规则的请求次数
-     * @param ruleId 规则ID
-     * @param count 增加的次数
-     * @returns 是否成功
-     */
-    incrementRuleRequestCount(ruleId, count) {
-        const result = this.db
-            .prepare('UPDATE rules SET total_requests_used = total_requests_used + ? WHERE id = ?')
-            .run(count, ruleId);
-        return result.changes > 0;
-    }
-    /**
-     * 重置规则的请求次数
-     * @param ruleId 规则ID
-     * @returns 是否成功
-     */
-    resetRuleRequestCount(ruleId) {
-        const now = Date.now();
-        const result = this.db
-            .prepare('UPDATE rules SET total_requests_used = 0, request_last_reset_at = ? WHERE id = ?')
-            .run(now, ruleId);
-        return result.changes > 0;
-    }
-    /**
-     * 检查并重置到期的规则（请求次数）
-     * 如果规则设置了request_reset_interval且已经到了重置时间，则自动重置请求次数
-     * @param ruleId 规则ID
-     * @returns 是否进行了重置
-     */
-    checkAndResetRequestCountIfNeeded(ruleId) {
-        const rule = this.db
-            .prepare('SELECT request_reset_interval, request_last_reset_at, request_reset_base_time FROM rules WHERE id = ?')
-            .get(ruleId);
-        if (!rule || !rule.request_reset_interval) {
-            return false; // 没有设置重置间隔
-        }
-        const now = Date.now();
-        const resetIntervalMs = rule.request_reset_interval * 60 * 60 * 1000; // 小时转毫秒
-        const baseTime = rule.request_reset_base_time;
-        const lastResetAt = rule.request_last_reset_at || 0;
-        // 场景1: 设置了时间基点
-        if (baseTime) {
-            if (now >= baseTime) {
-                this.resetRuleRequestCountWithBaseTime(ruleId, baseTime);
-                return true;
-            }
-            return false;
-        }
-        // 场景2: 未设置时间基点，使用原始逻辑（向后兼容）
-        if (now - lastResetAt >= resetIntervalMs) {
-            this.resetRuleRequestCount(ruleId);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * 重置规则的请求次数（带时间基点更新）
-     */
-    resetRuleRequestCountWithBaseTime(ruleId, currentBaseTime) {
-        const now = Date.now();
-        const rule = this.db
-            .prepare('SELECT request_reset_interval FROM rules WHERE id = ?')
-            .get(ruleId);
-        if (!rule || !rule.request_reset_interval) {
-            return false;
-        }
-        const resetIntervalMs = rule.request_reset_interval * 60 * 60 * 1000;
-        // 计算下一个时间基点
-        let nextBaseTime = currentBaseTime;
-        while (nextBaseTime <= now) {
-            nextBaseTime += resetIntervalMs;
-        }
-        const result = this.db
-            .prepare('UPDATE rules SET total_requests_used = 0, request_last_reset_at = ?, request_reset_base_time = ? WHERE id = ?')
-            .run(now, nextBaseTime, ruleId);
-        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 })));
-            // 清除缓存
-            this.logsCountCache = null;
-        });
-    }
-    getLogs() {
-        return __awaiter(this, arguments, void 0, function* (limit = 100, offset = 0) {
-            var _a, e_1, _b, _c;
-            const allLogs = [];
-            try {
-                for (var _d = true, _e = __asyncValues(this.logDb.iterator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const [, value] = _c;
-                    allLogs.push(JSON.parse(value));
-                }
-            }
-            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; }
-            }
-            // Sort by timestamp in descending order (newest first)
-            allLogs.sort((a, b) => b.timestamp - a.timestamp);
-            // Apply offset and limit
-            return allLogs.slice(offset, offset + limit);
-        });
-    }
-    clearLogs() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.logDb.clear();
-            // 清除缓存
-            this.logsCountCache = null;
-        });
-    }
-    // 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 })));
-            // 清除缓存
-            this.errorLogsCountCache = null;
-        });
-    }
-    getErrorLogs() {
-        return __awaiter(this, arguments, void 0, function* (limit = 100, offset = 0) {
-            var _a, e_2, _b, _c;
-            const allLogs = [];
-            try {
-                for (var _d = true, _e = __asyncValues(this.errorLogDb.iterator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const [, value] = _c;
-                    allLogs.push(JSON.parse(value));
-                }
-            }
-            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; }
-            }
-            // Sort by timestamp in descending order (newest first)
-            allLogs.sort((a, b) => b.timestamp - a.timestamp);
-            // Apply offset and limit
-            return allLogs.slice(offset, offset + limit);
-        });
-    }
-    clearErrorLogs() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.errorLogDb.clear();
-            // 清除缓存
-            this.errorLogsCountCache = null;
-        });
-    }
-    /**
-     * 获取请求日志总数（带缓存）
-     */
-    getLogsCount() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_3, _b, _c;
-            const now = Date.now();
-            if (this.logsCountCache && now - this.logsCountCache.timestamp < this.CACHE_TTL) {
-                return this.logsCountCache.count;
-            }
-            let count = 0;
-            try {
-                for (var _d = true, _e = __asyncValues(this.logDb.iterator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const _ = _c;
-                    count++;
-                }
-            }
-            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; }
-            }
-            this.logsCountCache = { count, timestamp: now };
-            return count;
-        });
-    }
-    /**
-     * 获取错误日志总数（带缓存）
-     */
-    getErrorLogsCount() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_4, _b, _c;
-            const now = Date.now();
-            if (this.errorLogsCountCache && now - this.errorLogsCountCache.timestamp < this.CACHE_TTL) {
-                return this.errorLogsCountCache.count;
-            }
-            let count = 0;
-            try {
-                for (var _d = true, _e = __asyncValues(this.errorLogDb.iterator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const _ = _c;
-                    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; }
-            }
-            this.errorLogsCountCache = { count, timestamp: now };
-            return count;
-        });
-    }
-    // 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, errorType) {
-        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;
-                entry.errorType = errorType;
-                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,
-                        errorType,
-                    };
-                    yield this.blacklistDb.put(key, JSON.stringify(entry));
-                }
-                else {
-                    throw error;
-                }
-            }
-        });
-    }
-    removeFromBlacklist(serviceId, routeId, contentType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = `${routeId}:${contentType}:${serviceId}`;
-            yield this.blacklistDb.del(key);
-        });
-    }
-    cleanupExpiredBlacklist() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_5, _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_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_5) throw e_5.error; }
-            }
-            return count;
-        });
-    }
-    // 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, sort_order, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)')
-                        .run(vendor.id, vendor.name, vendor.description || null, vendor.sortOrder || 0, 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, source_type, auth_type, supported_models, model_limits, enable_proxy, enable_token_limit, token_limit, token_reset_interval, token_reset_base_time, enable_request_limit, request_count_limit, request_reset_interval, request_reset_base_time, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-                        .run(service.id, service.vendorId, service.name, service.apiUrl, service.apiKey, service.sourceType || null, service.authType || null, service.supportedModels ? service.supportedModels.join(',') : null, service.modelLimits ? JSON.stringify(service.modelLimits) : null, service.enableProxy ? 1 : 0, service.enableTokenLimit ? 1 : 0, service.tokenLimit || null, service.tokenResetInterval || null, service.tokenResetBaseTime || null, service.enableRequestLimit ? 1 : 0, service.requestCountLimit || null, service.requestResetInterval || null, service.requestResetBaseTime || 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, target_model, replaced_model, sort_order, timeout, token_limit, total_tokens_used, reset_interval, last_reset_at, token_reset_base_time, request_count_limit, total_requests_used, request_reset_interval, request_last_reset_at, request_reset_base_time, is_disabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-                        .run(rule.id, rule.routeId, rule.contentType || 'default', rule.targetServiceId, rule.targetModel || null, rule.replacedModel || null, rule.sortOrder || 0, rule.timeout || null, rule.tokenLimit || null, rule.totalTokensUsed || 0, rule.resetInterval || null, rule.lastResetAt || null, rule.tokenResetBaseTime || null, rule.requestCountLimit || null, rule.totalRequestsUsed || 0, rule.requestResetInterval || null, rule.requestLastResetAt || null, rule.requestResetBaseTime || null, rule.isDisabled ? 1 : 0, rule.createdAt, rule.updatedAt);
-                }
-                // Update config
-                this.updateConfig(importData.config);
-                return true;
-            }
-            catch (error) {
-                console.error('Import error:', error);
-                return false;
-            }
-        });
-    }
-    // Statistics operations
-    getStatistics() {
-        return __awaiter(this, arguments, void 0, function* (days = 30) {
-            var _a, e_6, _b, _c, _d, e_7, _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_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (!_z && !_a && (_b = _0.return)) yield _b.call(_0);
-                }
-                finally { if (e_6) throw e_6.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_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (!_2 && !_d && (_e = _3.return)) yield _e.call(_3);
-                }
-                finally { if (e_7) throw e_7.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 && 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,
-                };
-            });
-            // 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,
-                },
-            };
-        });
-    }
-    getRuleBlacklistStatus(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 null;
-                }
-                return entry;
-            }
-            catch (error) {
-                if (error.code === 'LEVEL_NOT_FOUND') {
-                    return null;
-                }
-                throw error;
-            }
-        });
-    }
-    // Session operations
-    /**
-     * 创建或更新 session
-     * 当有新的请求日志时调用此方法来更新 session 信息
-     */
-    upsertSession(session) {
-        const now = Date.now();
-        const existing = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(session.id);
-        if (existing) {
-            // 更新现有 session
-            this.db.prepare(`
-        UPDATE sessions SET
-          last_request_at = ?,
-          request_count = request_count + 1,
-          total_tokens = total_tokens + ?,
-          vendor_id = ?,
-          vendor_name = ?,
-          service_id = ?,
-          service_name = ?,
-          model = ?
-        WHERE id = ?
-      `).run(now, session.totalTokens || 0, session.vendorId || null, session.vendorName || null, session.serviceId || null, session.serviceName || null, session.model || null, session.id);
-        }
-        else {
-            // 创建新 session
-            this.db.prepare(`
-        INSERT INTO sessions (id, target_type, title, first_request_at, last_request_at, request_count, total_tokens, vendor_id, vendor_name, service_id, service_name, model)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(session.id, session.targetType, session.title || null, session.firstRequestAt, now, 1, session.totalTokens || 0, session.vendorId || null, session.vendorName || null, session.serviceId || null, session.serviceName || null, session.model || null);
-        }
-    }
-    /**
-     * 获取所有 sessions
-     */
-    getSessions(limit = 100, offset = 0) {
-        const rows = this.db.prepare('SELECT * FROM sessions ORDER BY last_request_at DESC LIMIT ? OFFSET ?').all(limit, offset);
-        return rows.map((row) => ({
-            id: row.id,
-            targetType: row.target_type,
-            title: row.title,
-            firstRequestAt: row.first_request_at,
-            lastRequestAt: row.last_request_at,
-            requestCount: row.request_count,
-            totalTokens: row.total_tokens,
-            vendorId: row.vendor_id,
-            vendorName: row.vendor_name,
-            serviceId: row.service_id,
-            serviceName: row.service_name,
-            model: row.model,
-        }));
-    }
-    /**
-     * 根据 session ID 获取 session
-     */
-    getSession(id) {
-        const row = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
-        if (!row)
-            return null;
-        return {
-            id: row.id,
-            targetType: row.target_type,
-            title: row.title,
-            firstRequestAt: row.first_request_at,
-            lastRequestAt: row.last_request_at,
-            requestCount: row.request_count,
-            totalTokens: row.total_tokens,
-            vendorId: row.vendor_id,
-            vendorName: row.vendor_name,
-            serviceId: row.service_id,
-            serviceName: row.service_name,
-            model: row.model,
-        };
-    }
-    /**
-     * 获取 sessions 总数
-     */
-    getSessionsCount() {
-        const result = this.db.prepare('SELECT COUNT(*) as count FROM sessions').get();
-        return result.count;
-    }
-    /**
-     * 删除指定 session
-     */
-    deleteSession(id) {
-        const result = this.db.prepare('DELETE FROM sessions WHERE id = ?').run(id);
-        return result.changes > 0;
-    }
-    /**
-     * 清空所有 sessions
-     */
-    clearSessions() {
-        this.db.prepare('DELETE FROM sessions').run();
-    }
-    /**
-     * 获取指定 session 的请求日志
-     * @param sessionId session ID
-     * @param limit 限制数量
-     */
-    getLogsBySessionId(sessionId_1) {
-        return __awaiter(this, arguments, void 0, function* (sessionId, limit = 100) {
-            var _a, e_8, _b, _c;
-            // 从 LevelDB 中读取所有日志
-            const allLogs = [];
-            try {
-                for (var _d = true, _e = __asyncValues(this.logDb.iterator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const [, value] = _c;
-                    const log = JSON.parse(value);
-                    // 检查日志是否属于该 session（通过 headers 中的 session_id 或 body 中的 metadata.user_id）
-                    if (this.isLogBelongsToSession(log, sessionId)) {
-                        allLogs.push(log);
-                    }
-                }
-            }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_8) throw e_8.error; }
-            }
-            // 按时间倒序排序并限制数量
-            allLogs.sort((a, b) => b.timestamp - a.timestamp);
-            return allLogs.slice(0, limit);
-        });
-    }
-    /**
-     * 检查日志是否属于指定 session
-     */
-    isLogBelongsToSession(log, sessionId) {
-        var _a, _b;
-        // 检查 headers 中的 session_id（Codex）
-        if (((_a = log.headers) === null || _a === void 0 ? void 0 : _a['session_id']) === sessionId) {
-            return true;
-        }
-        // 检查 body 中的 metadata.user_id（Claude Code）
-        if (log.body) {
-            try {
-                const body = JSON.parse(log.body);
-                if (((_b = body.metadata) === null || _b === void 0 ? void 0 : _b.user_id) === sessionId) {
-                    return true;
-                }
-            }
-            catch (_c) {
-                // 忽略解析错误
-            }
-        }
-        return false;
-    }
-    close() {
-        this.db.close();
-        this.logDb.close();
-        this.errorLogDb.close();
-        this.blacklistDb.close();
-    }
-}
-exports.DatabaseManager = DatabaseManager;