aicodeswitch 2.1.6 → 3.0.2

package/dist/server/fs-database.js

@@ -0,0 +1,1752 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemDatabaseManager = void 0;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const crypto_1 = __importDefault(require("crypto"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
+/**
+ * 基于文件系统的数据库管理器
+ * 使用 JSON 文件存储数据，无需编译依赖
+ */
+class FileSystemDatabaseManager {
+    // 文件路径
+    get vendorsFile() { return path_1.default.join(this.dataPath, 'vendors.json'); }
+    get servicesFile() { return path_1.default.join(this.dataPath, 'services.json'); }
+    get routesFile() { return path_1.default.join(this.dataPath, 'routes.json'); }
+    get rulesFile() { return path_1.default.join(this.dataPath, 'rules.json'); } // legacy
+    get configFile() { return path_1.default.join(this.dataPath, 'config.json'); }
+    get sessionsFile() { return path_1.default.join(this.dataPath, 'sessions.json'); }
+    get logsDir() { return path_1.default.join(this.dataPath, 'logs'); }
+    get logsIndexFile() { return path_1.default.join(this.dataPath, 'logs-index.json'); }
+    get errorLogsFile() { return path_1.default.join(this.dataPath, 'error-logs.json'); }
+    get blacklistFile() { return path_1.default.join(this.dataPath, 'blacklist.json'); }
+    get statisticsFile() { return path_1.default.join(this.dataPath, 'statistics.json'); }
+    // 创建空的统计数据结构
+    createEmptyStatistics() {
+        return {
+            overview: {
+                totalRequests: 0,
+                totalTokens: 0,
+                totalInputTokens: 0,
+                totalOutputTokens: 0,
+                totalCacheReadTokens: 0,
+                totalVendors: 0,
+                totalServices: 0,
+                totalRoutes: 0,
+                totalRules: 0,
+                avgResponseTime: 0,
+                successRate: 100,
+                totalCodingTime: 0,
+            },
+            byTargetType: [],
+            byVendor: [],
+            byService: [],
+            byModel: [],
+            timeline: [],
+            contentTypeDistribution: [],
+            errors: {
+                totalErrors: 0,
+                recentErrors: 0,
+            },
+        };
+    }
+    constructor(dataPath) {
+        Object.defineProperty(this, "dataPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vendors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        // 移除独立的 apiServices 存储，现在作为 vendor 的属性
+        Object.defineProperty(this, "routes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "rules", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "sessions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "logShardsIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "errorLogs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "blacklist", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // 持久化统计数据
+        Object.defineProperty(this, "statistics", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: this.createEmptyStatistics()
+        });
+        // 缓存机制
+        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
+        });
+        // 日志分片配置
+        Object.defineProperty(this, "MAX_SHARD_SIZE", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10 * 1024 * 1024
+        }); // 10MB
+        Object.defineProperty(this, "LOG_RETENTION_DAYS", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 30
+        });
+        this.dataPath = dataPath;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 确保数据目录存在
+            yield promises_1.default.mkdir(this.dataPath, { recursive: true });
+            // 加载所有数据
+            yield this.loadAllData();
+            // 确保默认配置
+            yield this.ensureDefaultConfig();
+        });
+    }
+    loadAllData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([
+                this.loadVendors(), // loadVendors 内部会处理旧 services.json 的迁移
+                // 删除: this.loadServices(),
+                this.loadRoutes(),
+                this.loadConfig(),
+                this.loadSessions(),
+                this.loadLogsIndex(),
+                this.loadErrorLogs(),
+                this.loadBlacklist(),
+                this.loadStatistics(),
+            ]);
+        });
+    }
+    loadVendors() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(this.vendorsFile, 'utf-8');
+                this.vendors = JSON.parse(data);
+            }
+            catch (_a) {
+                this.vendors = [];
+            }
+            // 兼容性检查：如果存在旧的 services.json，自动迁移
+            yield this.migrateServicesIfNeeded();
+        });
+    }
+    /**
+     * 检测并迁移旧的 services.json 到新结构
+     * 旧格式：vendors.json 和 services.json 分离
+     * 新格式：vendors.json 包含嵌套的 services 数组
+     */
+    migrateServicesIfNeeded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const oldServicesFile = this.servicesFile;
+            try {
+                yield promises_1.default.access(oldServicesFile);
+                console.log('[Database] 发现旧的 services.json 文件，开始迁移到新结构...');
+                // 读取旧服务数据
+                const servicesData = yield promises_1.default.readFile(oldServicesFile, 'utf-8');
+                const oldServices = JSON.parse(servicesData);
+                console.log(`[Database] 准备迁移 ${oldServices.length} 个服务...`);
+                // 按 vendorId 分组
+                const servicesByVendor = new Map();
+                for (const service of oldServices) {
+                    if (!service.vendorId) {
+                        console.warn(`[Database] 跳过没有 vendorId 的服务: ${service.id}`);
+                        continue;
+                    }
+                    if (!servicesByVendor.has(service.vendorId)) {
+                        servicesByVendor.set(service.vendorId, []);
+                    }
+                    // 移除 vendorId 字段，因为现在通过父级关系隐式关联
+                    const { vendorId } = service, serviceWithoutVendorId = __rest(service, ["vendorId"]);
+                    servicesByVendor.get(service.vendorId).push(serviceWithoutVendorId);
+                }
+                // 合并到 vendors 数组
+                let migratedCount = 0;
+                for (const vendor of this.vendors) {
+                    const services = servicesByVendor.get(vendor.id);
+                    if (services) {
+                        vendor.services = services;
+                        migratedCount += services.length;
+                    }
+                    else {
+                        vendor.services = [];
+                    }
+                }
+                // 保存新的 vendors.json
+                yield this.saveVendors();
+                // 备份旧文件
+                const timestamp = Date.now();
+                const backupFile = path_1.default.join(this.dataPath, `services.json.backup.${timestamp}`);
+                yield promises_1.default.rename(oldServicesFile, backupFile);
+                console.log(`[Database] 迁移完成：${migratedCount} 个服务已迁移`);
+                console.log(`[Database] 旧的 services.json 已备份到 ${backupFile}`);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    // 旧文件不存在，这是正常的（新安装或已迁移）
+                    return;
+                }
+                console.error('[Database] 迁移 services 时出错:', err);
+            }
+        });
+    }
+    saveVendors() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 确保每个供应商都有 services 数组
+            const normalizedVendors = this.vendors.map(v => (Object.assign(Object.assign({}, v), { services: v.services || [] })));
+            yield promises_1.default.writeFile(this.vendorsFile, JSON.stringify(normalizedVendors, null, 2));
+        });
+    }
+    // loadServices 和 saveServices 已移除
+    // 服务现在作为供应商的属性存储在 vendors.json 中
+    // 迁移逻辑见 migrateServicesIfNeeded() 方法
+    loadRoutes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let routesFileFormat = 'missing';
+            let routesFromFile = [];
+            let rulesFromFile = [];
+            let hasRulesInRoutesFile = false;
+            try {
+                const data = yield promises_1.default.readFile(this.routesFile, 'utf-8');
+                const parsed = JSON.parse(data);
+                if (Array.isArray(parsed)) {
+                    routesFileFormat = 'array';
+                    routesFromFile = parsed;
+                }
+                else if (parsed && typeof parsed === 'object') {
+                    routesFileFormat = 'combined';
+                    routesFromFile = Array.isArray(parsed.routes) ? parsed.routes : [];
+                    if (Array.isArray(parsed.rules)) {
+                        rulesFromFile = parsed.rules;
+                        hasRulesInRoutesFile = true;
+                    }
+                }
+                else {
+                    routesFileFormat = 'unknown';
+                }
+            }
+            catch (_a) {
+                routesFileFormat = 'missing';
+            }
+            this.routes = routesFromFile;
+            this.rules = rulesFromFile;
+            // 兼容旧的 rules.json 文件（迁移到 routes.json 的 rules 属性）
+            yield this.migrateRulesIfNeeded(routesFileFormat, hasRulesInRoutesFile);
+        });
+    }
+    saveRoutesData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = {
+                routes: this.routes,
+                rules: this.rules,
+            };
+            yield promises_1.default.writeFile(this.routesFile, JSON.stringify(payload, null, 2));
+        });
+    }
+    saveRoutes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.saveRoutesData();
+        });
+    }
+    saveRules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.saveRoutesData();
+        });
+    }
+    /**
+     * 检测并迁移旧的 rules.json 到 routes.json 的 rules 属性
+     * 旧格式：routes.json + rules.json 分离
+     * 新格式：routes.json 内包含 { routes, rules }
+     */
+    migrateRulesIfNeeded(routesFileFormat, hasRulesInRoutesFile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const oldRulesFile = this.rulesFile;
+            const oldRulesExists = yield promises_1.default.access(oldRulesFile)
+                .then(() => true)
+                .catch(() => false);
+            let merged = false;
+            if (oldRulesExists) {
+                try {
+                    const data = yield promises_1.default.readFile(oldRulesFile, 'utf-8');
+                    const oldRules = JSON.parse(data);
+                    if (Array.isArray(oldRules)) {
+                        if (this.rules.length > 0) {
+                            const mergedMap = new Map();
+                            oldRules.forEach((rule, index) => {
+                                const key = (rule === null || rule === void 0 ? void 0 : rule.id) || `legacy-${index}`;
+                                if (!mergedMap.has(key)) {
+                                    mergedMap.set(key, rule);
+                                }
+                            });
+                            this.rules.forEach((rule, index) => {
+                                const key = (rule === null || rule === void 0 ? void 0 : rule.id) || `current-${index}`;
+                                mergedMap.set(key, rule);
+                            });
+                            this.rules = Array.from(mergedMap.values());
+                        }
+                        else {
+                            this.rules = oldRules;
+                        }
+                        merged = true;
+                    }
+                }
+                catch (error) {
+                    console.error('[Database] 迁移 rules.json 时出错:', error);
+                }
+            }
+            // 如果 routes.json 还是旧格式/缺失，或从旧 rules.json 合并过数据，或缺少 rules 字段，则写入新格式
+            if (routesFileFormat !== 'combined' || merged || (routesFileFormat === 'combined' && !hasRulesInRoutesFile)) {
+                yield this.saveRoutesData();
+            }
+            // 备份旧的 rules.json 文件
+            if (oldRulesExists) {
+                try {
+                    const timestamp = Date.now();
+                    const backupFile = path_1.default.join(this.dataPath, `rules.json.backup.${timestamp}`);
+                    yield promises_1.default.rename(oldRulesFile, backupFile);
+                    console.log(`[Database] 旧的 rules.json 已备份到 ${backupFile}`);
+                }
+                catch (error) {
+                    console.error('[Database] 备份 rules.json 失败:', error);
+                }
+            }
+        });
+    }
+    loadConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(this.configFile, 'utf-8');
+                this.config = JSON.parse(data);
+            }
+            catch (_a) {
+                this.config = null;
+            }
+        });
+    }
+    saveConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield promises_1.default.writeFile(this.configFile, JSON.stringify(this.config, null, 2));
+        });
+    }
+    loadSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(this.sessionsFile, 'utf-8');
+                this.sessions = JSON.parse(data);
+            }
+            catch (_a) {
+                this.sessions = [];
+                // 创建空文件
+                yield this.saveSessions();
+            }
+        });
+    }
+    saveSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield promises_1.default.writeFile(this.sessionsFile, JSON.stringify(this.sessions, null, 2));
+        });
+    }
+    loadLogsIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(this.logsIndexFile, 'utf-8');
+                this.logShardsIndex = JSON.parse(data);
+            }
+            catch (_a) {
+                this.logShardsIndex = [];
+                yield this.saveLogsIndex();
+            }
+            // 检查并迁移旧的 logs.json 文件
+            yield this.migrateOldLogsIfNeeded();
+            // 清理旧日志分片
+            yield this.cleanupOldLogShards();
+        });
+    }
+    saveLogsIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield promises_1.default.writeFile(this.logsIndexFile, JSON.stringify(this.logShardsIndex, null, 2));
+        });
+    }
+    /**
+     * 迁移旧的 logs.json 文件到新的分片格式
+     */
+    migrateOldLogsIfNeeded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const oldLogsFile = path_1.default.join(this.dataPath, 'logs.json');
+            try {
+                // 检查旧日志文件是否存在
+                yield promises_1.default.access(oldLogsFile);
+                console.log('[Database] Found old logs.json file, migrating to shard format...');
+                // 读取旧日志
+                const data = yield promises_1.default.readFile(oldLogsFile, 'utf-8');
+                const oldLogs = JSON.parse(data);
+                if (oldLogs.length === 0) {
+                    console.log('[Database] Old logs.json is empty, skipping migration');
+                    yield promises_1.default.unlink(oldLogsFile); // 删除空文件
+                    return;
+                }
+                console.log(`[Database] Migrating ${oldLogs.length} log entries...`);
+                // 按日期分组日志
+                const logsByDate = new Map();
+                for (const log of oldLogs) {
+                    const date = new Date(log.timestamp).toISOString().split('T')[0];
+                    if (!logsByDate.has(date)) {
+                        logsByDate.set(date, []);
+                    }
+                    logsByDate.get(date).push(log);
+                }
+                // 为每个日期创建分片
+                let migratedCount = 0;
+                for (const [date, logs] of logsByDate.entries()) {
+                    // 如果单日日志超过大小限制，需要进一步分片
+                    let currentShardLogs = [];
+                    let currentShardSize = 0;
+                    let shardIndex = 0;
+                    for (const log of logs) {
+                        const logSize = JSON.stringify(log).length;
+                        // 检查是否需要创建新分片
+                        if (currentShardSize + logSize > this.MAX_SHARD_SIZE && currentShardLogs.length > 0) {
+                            // 保存当前分片
+                            const filename = shardIndex === 0 ? `logs-${date}.json` : `logs-${date}-${shardIndex}.json`;
+                            yield this.saveLogShard(filename, currentShardLogs);
+                            // 更新索引
+                            const timestamps = currentShardLogs.map(l => l.timestamp);
+                            this.logShardsIndex.push({
+                                filename,
+                                date,
+                                startTime: Math.min(...timestamps),
+                                endTime: Math.max(...timestamps),
+                                count: currentShardLogs.length
+                            });
+                            migratedCount += currentShardLogs.length;
+                            currentShardLogs = [];
+                            currentShardSize = 0;
+                            shardIndex++;
+                        }
+                        currentShardLogs.push(log);
+                        currentShardSize += logSize;
+                    }
+                    // 保存最后一个分片
+                    if (currentShardLogs.length > 0) {
+                        const filename = shardIndex === 0 ? `logs-${date}.json` : `logs-${date}-${shardIndex}.json`;
+                        yield this.saveLogShard(filename, currentShardLogs);
+                        const timestamps = currentShardLogs.map(l => l.timestamp);
+                        this.logShardsIndex.push({
+                            filename,
+                            date,
+                            startTime: Math.min(...timestamps),
+                            endTime: Math.max(...timestamps),
+                            count: currentShardLogs.length
+                        });
+                        migratedCount += currentShardLogs.length;
+                    }
+                }
+                // 保存索引
+                yield this.saveLogsIndex();
+                console.log(`[Database] Successfully migrated ${migratedCount} log entries to ${this.logShardsIndex.length} shard(s)`);
+                // 备份旧文件
+                const backupFile = path_1.default.join(this.dataPath, 'logs.json.backup');
+                yield promises_1.default.rename(oldLogsFile, backupFile);
+                console.log(`[Database] Old logs.json backed up to ${backupFile}`);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    // 旧文件不存在，这是正常的
+                    return;
+                }
+                console.error('[Database] Error migrating old logs:', err);
+            }
+        });
+    }
+    cleanupOldLogShards() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            const cutoffTime = now - this.LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+            // 找出需要删除的分片
+            const toDelete = [];
+            for (const shard of this.logShardsIndex) {
+                if (shard.endTime < cutoffTime) {
+                    toDelete.push(shard.filename);
+                }
+            }
+            // 删除旧分片文件
+            for (const filename of toDelete) {
+                try {
+                    const filepath = path_1.default.join(this.logsDir, filename);
+                    yield promises_1.default.unlink(filepath);
+                }
+                catch (err) {
+                    console.error(`Failed to delete old log shard ${filename}:`, err);
+                }
+            }
+            // 更新索引
+            this.logShardsIndex = this.logShardsIndex.filter(s => !toDelete.includes(s.filename));
+            if (toDelete.length > 0) {
+                yield this.saveLogsIndex();
+            }
+        });
+    }
+    getLogShardFilename(timestamp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const date = new Date(timestamp);
+            const dateStr = date.toISOString().split('T')[0]; // YYYY-MM-DD
+            // 查找当天的现有分片
+            const existingShards = this.logShardsIndex.filter(s => s.date === dateStr);
+            // 检查最后一个分片的大小
+            for (const shard of existingShards.reverse()) {
+                const filepath = path_1.default.join(this.logsDir, shard.filename);
+                try {
+                    const stats = yield promises_1.default.stat(filepath);
+                    if (stats.size < this.MAX_SHARD_SIZE) {
+                        return shard.filename;
+                    }
+                }
+                catch (_a) {
+                    // 文件不存在，继续查找
+                    continue;
+                }
+            }
+            // 创建新分片
+            const shardIndex = existingShards.length;
+            const filename = shardIndex === 0 ? `logs-${dateStr}.json` : `logs-${dateStr}-${shardIndex}.json`;
+            return filename;
+        });
+    }
+    loadLogShard(filename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filepath = path_1.default.join(this.logsDir, filename);
+            try {
+                const data = yield promises_1.default.readFile(filepath, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch (_a) {
+                return [];
+            }
+        });
+    }
+    saveLogShard(filename, logs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filepath = path_1.default.join(this.logsDir, filename);
+            yield promises_1.default.mkdir(this.logsDir, { recursive: true });
+            yield promises_1.default.writeFile(filepath, JSON.stringify(logs, null, 2));
+        });
+    }
+    loadErrorLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(this.errorLogsFile, 'utf-8');
+                this.errorLogs = JSON.parse(data);
+                // 兼容旧的 response 字段名，迁移到 responseBody
+                let needsSave = false;
+                for (const log of this.errorLogs) {
+                    if (log.response !== undefined && !log.responseBody) {
+                        log.responseBody = log.response;
+                        delete log.response;
+                        needsSave = true;
+                    }
+                }
+                if (needsSave) {
+                    yield this.saveErrorLogs();
+                }
+            }
+            catch (_a) {
+                this.errorLogs = [];
+                // 创建空文件
+                yield this.saveErrorLogs();
+            }
+        });
+    }
+    saveErrorLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield promises_1.default.writeFile(this.errorLogsFile, JSON.stringify(this.errorLogs, null, 2));
+            this.errorLogsCountCache = null;
+        });
+    }
+    loadBlacklist() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(this.blacklistFile, 'utf-8');
+                const entries = JSON.parse(data);
+                this.blacklist = new Map(entries.map(e => [
+                    `${e.routeId}:${e.contentType}:${e.serviceId}`,
+                    e
+                ]));
+            }
+            catch (_a) {
+                this.blacklist = new Map();
+                // 创建空文件
+                yield this.saveBlacklist();
+            }
+        });
+    }
+    saveBlacklist() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = Array.from(this.blacklist.values());
+            yield promises_1.default.writeFile(this.blacklistFile, JSON.stringify(entries, null, 2));
+        });
+    }
+    loadStatistics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(this.statisticsFile, 'utf-8');
+                this.statistics = JSON.parse(data);
+            }
+            catch (_a) {
+                this.statistics = this.createEmptyStatistics();
+                // 创建空文件
+                yield this.saveStatistics();
+            }
+        });
+    }
+    saveStatistics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield promises_1.default.writeFile(this.statisticsFile, JSON.stringify(this.statistics, null, 2));
+        });
+    }
+    ensureDefaultConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.config) {
+                this.config = {
+                    enableLogging: true,
+                    logRetentionDays: 30,
+                    maxLogSize: 100000,
+                    apiKey: '',
+                    enableFailover: true,
+                    proxyEnabled: false,
+                    proxyUrl: '',
+                    proxyUsername: '',
+                    proxyPassword: '',
+                };
+                yield this.saveConfig();
+            }
+        });
+    }
+    // Vendor operations
+    getVendors() {
+        return [...this.vendors].sort((a, b) => {
+            if (b.sortOrder !== a.sortOrder) {
+                return (b.sortOrder || 0) - (a.sortOrder || 0);
+            }
+            return b.createdAt - a.createdAt;
+        });
+    }
+    // 新增：获取单个供应商（带服务）
+    getVendor(id) {
+        return this.vendors.find(v => v.id === id);
+    }
+    createVendor(vendor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('[数据库] 创建供应商，输入数据:', JSON.stringify(vendor, null, 2));
+            const id = crypto_1.default.randomUUID();
+            const now = Date.now();
+            const newVendor = Object.assign(Object.assign({}, vendor), { id, services: vendor.services || [], createdAt: now, updatedAt: now });
+            console.log('[数据库] 创建供应商，返回数据:', JSON.stringify(newVendor, null, 2));
+            this.vendors.push(newVendor);
+            yield this.saveVendors();
+            return newVendor;
+        });
+    }
+    updateVendor(id, vendor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.vendors.findIndex(v => v.id === id);
+            if (index === -1)
+                return false;
+            const now = Date.now();
+            this.vendors[index] = Object.assign(Object.assign(Object.assign({}, this.vendors[index]), vendor), { id, services: vendor.services !== undefined ? vendor.services : this.vendors[index].services, updatedAt: now });
+            yield this.saveVendors();
+            return true;
+        });
+    }
+    deleteVendor(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.vendors.findIndex(v => v.id === id);
+            if (index === -1)
+                return false;
+            // 检查是否有服务被规则使用
+            const vendor = this.vendors[index];
+            const serviceIds = (vendor.services || []).map(s => s.id);
+            const rulesUsingServices = this.rules.filter(r => serviceIds.includes(r.targetServiceId));
+            if (rulesUsingServices.length > 0) {
+                throw new Error(`无法删除供应商：有 ${rulesUsingServices.length} 个规则正在使用该供应商的服务`);
+            }
+            this.vendors.splice(index, 1);
+            yield this.saveVendors();
+            return true;
+        });
+    }
+    // API Service operations
+    getAPIServices(vendorId) {
+        if (vendorId) {
+            const vendor = this.vendors.find(v => v.id === vendorId);
+            if (!vendor)
+                return [];
+            // 返回指定供应商的服务，并添加 vendorId
+            return (vendor.services || []).map(service => (Object.assign(Object.assign({}, service), { vendorId: vendor.id // 添加 vendorId 以便前端使用
+             })));
+        }
+        // 返回所有供应商的所有服务（扁平化），并添加 vendorId
+        const allServices = [];
+        for (const vendor of this.vendors) {
+            if (vendor.services) {
+                const servicesWithVendorId = vendor.services.map(service => (Object.assign(Object.assign({}, service), { vendorId: vendor.id // 添加 vendorId 以便前端使用
+                 })));
+                allServices.push(...servicesWithVendorId);
+            }
+        }
+        return allServices.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    // 新增：通过 ID 获取服务
+    getAPIService(id) {
+        var _a;
+        for (const vendor of this.vendors) {
+            const service = (_a = vendor.services) === null || _a === void 0 ? void 0 : _a.find(s => s.id === id);
+            if (service) {
+                return service;
+            }
+        }
+        return undefined;
+    }
+    // 新增：获取服务所属的供应商
+    getVendorByServiceId(serviceId) {
+        var _a;
+        for (const vendor of this.vendors) {
+            if ((_a = vendor.services) === null || _a === void 0 ? void 0 : _a.some(s => s.id === serviceId)) {
+                return vendor;
+            }
+        }
+        return undefined;
+    }
+    createAPIService(service) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('[数据库] 创建服务，输入数据:', JSON.stringify(service, null, 2));
+            // 从 vendorId 找到供应商
+            const vendorId = service.vendorId;
+            if (!vendorId) {
+                throw new Error('创建服务时必须提供 vendorId');
+            }
+            const vendor = this.vendors.find(v => v.id === vendorId);
+            if (!vendor) {
+                throw new Error(`供应商不存在: ${vendorId}`);
+            }
+            // 移除 vendorId 字段（数据存储时不需要）
+            const _a = service, { vendorId: _ } = _a, serviceData = __rest(_a, ["vendorId"]);
+            const id = crypto_1.default.randomUUID();
+            const now = Date.now();
+            const newService = Object.assign(Object.assign({}, serviceData), { id, createdAt: now, updatedAt: now });
+            console.log('[数据库] 创建服务，最终数据:', JSON.stringify(newService, null, 2));
+            if (!vendor.services) {
+                vendor.services = [];
+            }
+            vendor.services.push(newService);
+            // 更新供应商的 updatedAt 时间
+            vendor.updatedAt = now;
+            yield this.saveVendors();
+            console.log('[数据库] 服务已保存，当前总数:', vendor.services.length);
+            return Object.assign(Object.assign({}, newService), { vendorId });
+        });
+    }
+    updateAPIService(id, service) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 查找服务所属的供应商
+            const vendor = this.getVendorByServiceId(id);
+            if (!vendor)
+                return false;
+            const index = vendor.services.findIndex(s => s.id === id);
+            if (index === -1)
+                return false;
+            const now = Date.now();
+            vendor.services[index] = Object.assign(Object.assign(Object.assign({}, vendor.services[index]), service), { id, updatedAt: now });
+            // 更新供应商的 updatedAt 时间
+            vendor.updatedAt = now;
+            yield this.saveVendors();
+            // 同步规则的超量限制
+            yield this.syncRulesWithServiceLimits(id, service);
+            return true;
+        });
+    }
+    deleteAPIService(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 查找服务所属的供应商
+            const vendor = this.getVendorByServiceId(id);
+            if (!vendor)
+                return false;
+            const index = vendor.services.findIndex(s => s.id === id);
+            if (index === -1)
+                return false;
+            // 检查是否有规则正在使用此服务
+            const rulesUsingService = this.rules.filter(r => r.targetServiceId === id);
+            if (rulesUsingService.length > 0) {
+                throw new Error(`无法删除服务：有 ${rulesUsingService.length} 个规则正在使用此服务`);
+            }
+            vendor.services.splice(index, 1);
+            // 更新供应商的 updatedAt 时间
+            vendor.updatedAt = Date.now();
+            yield this.saveVendors();
+            return true;
+        });
+    }
+    syncRulesWithServiceLimits(serviceId, _service) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const relatedRules = this.rules.filter(r => r.targetServiceId === serviceId);
+            if (relatedRules.length === 0)
+                return;
+            const now = Date.now();
+            const currentService = this.getAPIService(serviceId);
+            if (!currentService)
+                return;
+            let updated = false;
+            // Token超量限制同步
+            if (currentService.enableTokenLimit) {
+                for (const rule of relatedRules) {
+                    rule.tokenLimit = currentService.tokenLimit;
+                    rule.resetInterval = currentService.tokenResetInterval;
+                    rule.tokenResetBaseTime = currentService.tokenResetBaseTime;
+                    rule.updatedAt = now;
+                    updated = true;
+                }
+            }
+            // 请求次数超量限制同步
+            if (currentService.enableRequestLimit) {
+                for (const rule of relatedRules) {
+                    rule.requestCountLimit = currentService.requestCountLimit;
+                    rule.requestResetInterval = currentService.requestResetInterval;
+                    rule.requestResetBaseTime = currentService.requestResetBaseTime;
+                    rule.updatedAt = now;
+                    updated = true;
+                }
+            }
+            if (updated) {
+                yield this.saveRules();
+            }
+        });
+    }
+    // Route operations
+    getRoutes() {
+        return this.routes.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    createRoute(route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = crypto_1.default.randomUUID();
+            const now = Date.now();
+            const newRoute = Object.assign(Object.assign({}, route), { id, createdAt: now, updatedAt: now });
+            this.routes.push(newRoute);
+            yield this.saveRoutes();
+            return newRoute;
+        });
+    }
+    updateRoute(id, route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.routes.findIndex(r => r.id === id);
+            if (index === -1)
+                return false;
+            const now = Date.now();
+            this.routes[index] = Object.assign(Object.assign(Object.assign({}, this.routes[index]), route), { id, updatedAt: now });
+            yield this.saveRoutes();
+            return true;
+        });
+    }
+    deleteRoute(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.routes.findIndex(r => r.id === id);
+            if (index === -1)
+                return false;
+            // 删除关联的规则
+            this.rules = this.rules.filter(r => r.routeId !== id);
+            yield this.saveRules();
+            this.routes.splice(index, 1);
+            yield this.saveRoutes();
+            return true;
+        });
+    }
+    activateRoute(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const route = this.routes.find(r => r.id === id);
+            if (!route)
+                return false;
+            // 停用同类型的其他路由
+            for (const r of this.routes) {
+                if (r.targetType === route.targetType) {
+                    r.isActive = r.id === id;
+                }
+            }
+            yield this.saveRoutes();
+            return true;
+        });
+    }
+    deactivateRoute(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const route = this.routes.find(r => r.id === id);
+            if (!route)
+                return false;
+            route.isActive = false;
+            yield this.saveRoutes();
+            return true;
+        });
+    }
+    deactivateAllRoutes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let count = 0;
+            for (const route of this.routes) {
+                if (route.isActive) {
+                    route.isActive = false;
+                    count++;
+                }
+            }
+            if (count > 0) {
+                yield this.saveRoutes();
+            }
+            return count;
+        });
+    }
+    // Rule operations
+    getRules(routeId) {
+        const rules = routeId
+            ? this.rules.filter(r => r.routeId === routeId)
+            : this.rules;
+        return rules.sort((a, b) => {
+            if (b.sortOrder !== a.sortOrder) {
+                return (b.sortOrder || 0) - (a.sortOrder || 0);
+            }
+            return b.createdAt - a.createdAt;
+        });
+    }
+    getRule(id) {
+        return this.rules.find(r => r.id === id);
+    }
+    createRule(rule) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = crypto_1.default.randomUUID();
+            const now = Date.now();
+            const newRule = Object.assign(Object.assign({}, rule), { id, totalTokensUsed: rule.totalTokensUsed || 0, totalRequestsUsed: rule.totalRequestsUsed || 0, isDisabled: rule.isDisabled || false, createdAt: now, updatedAt: now });
+            this.rules.push(newRule);
+            yield this.saveRules();
+            return newRule;
+        });
+    }
+    updateRule(id, rule) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.rules.findIndex(r => r.id === id);
+            if (index === -1)
+                return false;
+            const now = Date.now();
+            this.rules[index] = Object.assign(Object.assign(Object.assign({}, this.rules[index]), rule), { id, updatedAt: now });
+            yield this.saveRules();
+            return true;
+        });
+    }
+    deleteRule(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.rules.findIndex(r => r.id === id);
+            if (index === -1)
+                return false;
+            this.rules.splice(index, 1);
+            yield this.saveRules();
+            return true;
+        });
+    }
+    toggleRuleDisabled(ruleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule) {
+                return { success: false, isDisabled: false };
+            }
+            rule.isDisabled = !rule.isDisabled;
+            rule.updatedAt = Date.now();
+            yield this.saveRules();
+            return {
+                success: true,
+                isDisabled: rule.isDisabled
+            };
+        });
+    }
+    incrementRuleTokenUsage(ruleId, tokensUsed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule)
+                return false;
+            rule.totalTokensUsed = (rule.totalTokensUsed || 0) + tokensUsed;
+            yield this.saveRules();
+            return true;
+        });
+    }
+    resetRuleTokenUsage(ruleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule)
+                return false;
+            rule.totalTokensUsed = 0;
+            rule.lastResetAt = Date.now();
+            yield this.saveRules();
+            return true;
+        });
+    }
+    checkAndResetRuleIfNeeded(ruleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule || !rule.resetInterval)
+                return false;
+            const now = Date.now();
+            const resetIntervalMs = rule.resetInterval * 60 * 60 * 1000;
+            const baseTime = rule.tokenResetBaseTime;
+            const lastResetAt = rule.lastResetAt || 0;
+            if (baseTime) {
+                if (now >= baseTime) {
+                    yield this.resetRuleTokenUsageWithBaseTime(ruleId, baseTime);
+                    return true;
+                }
+                return false;
+            }
+            if (now - lastResetAt >= resetIntervalMs) {
+                yield this.resetRuleTokenUsage(ruleId);
+                return true;
+            }
+            return false;
+        });
+    }
+    resetRuleTokenUsageWithBaseTime(ruleId, currentBaseTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule || !rule.resetInterval)
+                return false;
+            const now = Date.now();
+            const resetIntervalMs = rule.resetInterval * 60 * 60 * 1000;
+            let nextBaseTime = currentBaseTime;
+            while (nextBaseTime <= now) {
+                nextBaseTime += resetIntervalMs;
+            }
+            rule.totalTokensUsed = 0;
+            rule.lastResetAt = now;
+            rule.tokenResetBaseTime = nextBaseTime;
+            yield this.saveRules();
+            return true;
+        });
+    }
+    incrementRuleRequestCount(ruleId, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule)
+                return false;
+            rule.totalRequestsUsed = (rule.totalRequestsUsed || 0) + count;
+            yield this.saveRules();
+            return true;
+        });
+    }
+    resetRuleRequestCount(ruleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule)
+                return false;
+            rule.totalRequestsUsed = 0;
+            rule.requestLastResetAt = Date.now();
+            yield this.saveRules();
+            return true;
+        });
+    }
+    checkAndResetRequestCountIfNeeded(ruleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule || !rule.requestResetInterval)
+                return false;
+            const now = Date.now();
+            const resetIntervalMs = rule.requestResetInterval * 60 * 60 * 1000;
+            const baseTime = rule.requestResetBaseTime;
+            const lastResetAt = rule.requestLastResetAt || 0;
+            if (baseTime) {
+                if (now >= baseTime) {
+                    yield this.resetRuleRequestCountWithBaseTime(ruleId, baseTime);
+                    return true;
+                }
+                return false;
+            }
+            if (now - lastResetAt >= resetIntervalMs) {
+                yield this.resetRuleRequestCount(ruleId);
+                return true;
+            }
+            return false;
+        });
+    }
+    resetRuleRequestCountWithBaseTime(ruleId, currentBaseTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rule = this.rules.find(r => r.id === ruleId);
+            if (!rule || !rule.requestResetInterval)
+                return false;
+            const now = Date.now();
+            const resetIntervalMs = rule.requestResetInterval * 60 * 60 * 1000;
+            let nextBaseTime = currentBaseTime;
+            while (nextBaseTime <= now) {
+                nextBaseTime += resetIntervalMs;
+            }
+            rule.totalRequestsUsed = 0;
+            rule.requestLastResetAt = now;
+            rule.requestResetBaseTime = nextBaseTime;
+            yield this.saveRules();
+            return true;
+        });
+    }
+    // Log operations
+    addLog(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = crypto_1.default.randomUUID();
+            const logWithId = Object.assign(Object.assign({}, log), { id });
+            // 获取目标分片文件名
+            const filename = yield this.getLogShardFilename(logWithId.timestamp);
+            // 加载现有分片数据
+            let shardLogs = yield this.loadLogShard(filename);
+            // 添加新日志
+            shardLogs.push(logWithId);
+            // 保存分片
+            yield this.saveLogShard(filename, shardLogs);
+            // 更新索引
+            const date = new Date(logWithId.timestamp).toISOString().split('T')[0];
+            let shardIndex = this.logShardsIndex.find(s => s.filename === filename);
+            if (shardIndex) {
+                shardIndex.count = shardLogs.length;
+                shardIndex.endTime = Math.max(shardIndex.endTime, logWithId.timestamp);
+            }
+            else {
+                this.logShardsIndex.push({
+                    filename,
+                    date,
+                    startTime: logWithId.timestamp,
+                    endTime: logWithId.timestamp,
+                    count: 1
+                });
+            }
+            yield this.saveLogsIndex();
+            // 同时更新统计数据
+            yield this.updateStatistics(logWithId);
+            // 清除计数缓存
+            this.logsCountCache = null;
+        });
+    }
+    getLogs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 100, offset = 0) {
+            // 按分片索引倒序排列（最新的在前）
+            const sortedShards = [...this.logShardsIndex].sort((a, b) => b.endTime - a.endTime);
+            const allLogs = [];
+            let currentOffset = 0;
+            // 遍历分片直到收集足够的日志
+            for (const shard of sortedShards) {
+                if (currentOffset + shard.count <= offset) {
+                    // 跳过整个分片
+                    currentOffset += shard.count;
+                    continue;
+                }
+                const shardLogs = yield this.loadLogShard(shard.filename);
+                // 计算需要从该分片取出的日志范围
+                let startIndex = 0;
+                if (currentOffset < offset) {
+                    startIndex = offset - currentOffset;
+                }
+                const remainingCount = limit - allLogs.length;
+                const endIndex = Math.min(startIndex + remainingCount, shardLogs.length);
+                // 添加日志到结果
+                allLogs.push(...shardLogs.slice(startIndex, endIndex));
+                currentOffset += shard.count;
+                if (allLogs.length >= limit) {
+                    break;
+                }
+            }
+            // 按时间戳倒序排序
+            return allLogs.sort((a, b) => b.timestamp - a.timestamp);
+        });
+    }
+    clearLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 删除所有日志分片文件
+            for (const shard of this.logShardsIndex) {
+                try {
+                    const filepath = path_1.default.join(this.logsDir, shard.filename);
+                    yield promises_1.default.unlink(filepath);
+                }
+                catch (err) {
+                    console.error(`Failed to delete log shard ${shard.filename}:`, err);
+                }
+            }
+            // 清空索引
+            this.logShardsIndex = [];
+            yield this.saveLogsIndex();
+            // 清除计数缓存
+            this.logsCountCache = null;
+        });
+    }
+    getLogsCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            if (this.logsCountCache && now - this.logsCountCache.timestamp < this.CACHE_TTL) {
+                return this.logsCountCache.count;
+            }
+            const count = this.logShardsIndex.reduce((sum, shard) => sum + shard.count, 0);
+            this.logsCountCache = { count, timestamp: now };
+            return count;
+        });
+    }
+    // Error log operations
+    addErrorLog(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = crypto_1.default.randomUUID();
+            this.errorLogs.push(Object.assign(Object.assign({}, log), { id }));
+            yield this.saveErrorLogs();
+        });
+    }
+    getErrorLogs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 100, offset = 0) {
+            const sorted = [...this.errorLogs].sort((a, b) => b.timestamp - a.timestamp);
+            return sorted.slice(offset, offset + limit);
+        });
+    }
+    clearErrorLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.errorLogs = [];
+            yield this.saveErrorLogs();
+        });
+    }
+    getErrorLogsCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            if (this.errorLogsCountCache && now - this.errorLogsCountCache.timestamp < this.CACHE_TTL) {
+                return this.errorLogsCountCache.count;
+            }
+            const count = this.errorLogs.length;
+            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}`;
+            const entry = this.blacklist.get(key);
+            if (!entry)
+                return false;
+            if (Date.now() > entry.expiresAt) {
+                this.blacklist.delete(key);
+                yield this.saveBlacklist();
+                return false;
+            }
+            return true;
+        });
+    }
+    addToBlacklist(serviceId, routeId, contentType, errorMessage, statusCode, errorType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = `${routeId}:${contentType}:${serviceId}`;
+            const now = Date.now();
+            const existing = this.blacklist.get(key);
+            if (existing) {
+                existing.blacklistedAt = now;
+                existing.expiresAt = now + 10 * 60 * 1000;
+                existing.errorCount++;
+                existing.lastError = errorMessage;
+                existing.lastStatusCode = statusCode;
+                existing.errorType = errorType;
+            }
+            else {
+                this.blacklist.set(key, {
+                    serviceId,
+                    routeId,
+                    contentType,
+                    blacklistedAt: now,
+                    expiresAt: now + 10 * 60 * 1000,
+                    errorCount: 1,
+                    lastError: errorMessage,
+                    lastStatusCode: statusCode,
+                    errorType,
+                });
+            }
+            yield this.saveBlacklist();
+        });
+    }
+    removeFromBlacklist(serviceId, routeId, contentType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = `${routeId}:${contentType}:${serviceId}`;
+            this.blacklist.delete(key);
+            yield this.saveBlacklist();
+        });
+    }
+    cleanupExpiredBlacklist() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            let count = 0;
+            for (const [key, entry] of this.blacklist.entries()) {
+                if (now > entry.expiresAt) {
+                    this.blacklist.delete(key);
+                    count++;
+                }
+            }
+            if (count > 0) {
+                yield this.saveBlacklist();
+            }
+            return count;
+        });
+    }
+    // Config operations
+    getConfig() {
+        return this.config;
+    }
+    updateConfig(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.config = config;
+            yield this.saveConfig();
+            return true;
+        });
+    }
+    // Export/Import operations
+    exportData(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 扁平化所有服务（兼容旧格式）
+            const allServices = [];
+            for (const vendor of this.vendors) {
+                if (vendor.services) {
+                    // 为每个服务添加 vendorId（兼容旧格式）
+                    const servicesWithVendorId = vendor.services.map(s => (Object.assign(Object.assign({}, s), { vendorId: vendor.id })));
+                    allServices.push(...servicesWithVendorId);
+                }
+            }
+            const exportData = {
+                version: '2.0.0', // 更新版本号
+                exportDate: Date.now(),
+                vendors: this.vendors,
+                apiServices: allServices, // 兼容旧格式
+                routes: this.routes,
+                rules: this.rules,
+                config: this.config,
+            };
+            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);
+                // 检测数据版本
+                const isNewFormat = importData.vendors.some((v) => v.services);
+                if (isNewFormat || importData.version >= '2.0.0') {
+                    // 新格式：直接使用 vendors（已包含 services）
+                    this.vendors = importData.vendors;
+                }
+                else {
+                    // 旧格式：需要重建 services 关系
+                    const { vendors, apiServices } = importData;
+                    // 构建 vendorId -> services 映射
+                    const servicesByVendor = new Map();
+                    for (const service of apiServices) {
+                        if (!service.vendorId)
+                            continue;
+                        if (!servicesByVendor.has(service.vendorId)) {
+                            servicesByVendor.set(service.vendorId, []);
+                        }
+                        const { vendorId } = service, serviceWithoutVendorId = __rest(service, ["vendorId"]);
+                        servicesByVendor.get(service.vendorId).push(serviceWithoutVendorId);
+                    }
+                    // 合并到 vendors
+                    this.vendors = vendors.map((vendor) => (Object.assign(Object.assign({}, vendor), { services: servicesByVendor.get(vendor.id) || [] })));
+                }
+                this.routes = importData.routes;
+                this.rules = importData.rules;
+                this.config = importData.config;
+                yield Promise.all([
+                    this.saveVendors(),
+                    // 删除: this.saveServices(),
+                    this.saveRoutes(),
+                    this.saveConfig(),
+                ]);
+                return true;
+            }
+            catch (error) {
+                console.error('Import error:', error);
+                return false;
+            }
+        });
+    }
+    // Statistics operations
+    /**
+     * 更新统计数据 - 在每次添加日志时调用
+     */
+    updateStatistics(log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const vendors = this.getVendors();
+            const services = this.getAPIServices();
+            // 更新 overview 数据
+            this.statistics.overview.totalRequests++;
+            this.statistics.overview.totalVendors = vendors.length;
+            this.statistics.overview.totalServices = services.length;
+            this.statistics.overview.totalRoutes = this.getRoutes().length;
+            this.statistics.overview.totalRules = this.getRules().length;
+            // 更新 tokens 统计
+            const inputTokens = ((_a = log.usage) === null || _a === void 0 ? void 0 : _a.inputTokens) || 0;
+            const outputTokens = ((_b = log.usage) === null || _b === void 0 ? void 0 : _b.outputTokens) || 0;
+            const cacheTokens = ((_c = log.usage) === null || _c === void 0 ? void 0 : _c.cacheReadInputTokens) || 0;
+            const totalTokens = ((_d = log.usage) === null || _d === void 0 ? void 0 : _d.totalTokens) || (inputTokens + outputTokens);
+            this.statistics.overview.totalInputTokens += inputTokens;
+            this.statistics.overview.totalOutputTokens += outputTokens;
+            this.statistics.overview.totalCacheReadTokens += cacheTokens;
+            this.statistics.overview.totalTokens += totalTokens;
+            // 更新平均响应时间
+            const currentAvg = this.statistics.overview.avgResponseTime;
+            const responseTime = log.responseTime || 0;
+            this.statistics.overview.avgResponseTime =
+                (currentAvg * (this.statistics.overview.totalRequests - 1) + responseTime) / this.statistics.overview.totalRequests;
+            // 更新成功率
+            if (log.statusCode && log.statusCode >= 400) {
+                const successCount = Math.round(this.statistics.overview.totalRequests * this.statistics.overview.successRate / 100);
+                this.statistics.overview.successRate = ((successCount) / this.statistics.overview.totalRequests) * 100;
+            }
+            // 更新编程时长
+            this.statistics.overview.totalCodingTime = Math.round(this.statistics.overview.totalInputTokens / 250 +
+                this.statistics.overview.totalOutputTokens / 100);
+            // 更新 byTargetType
+            if (log.targetType) {
+                let targetTypeStats = this.statistics.byTargetType.find(s => s.targetType === log.targetType);
+                if (!targetTypeStats) {
+                    targetTypeStats = { targetType: log.targetType, totalRequests: 0, totalTokens: 0, avgResponseTime: 0 };
+                    this.statistics.byTargetType.push(targetTypeStats);
+                }
+                targetTypeStats.totalRequests++;
+                targetTypeStats.totalTokens += totalTokens;
+                targetTypeStats.avgResponseTime =
+                    (targetTypeStats.avgResponseTime * (targetTypeStats.totalRequests - 1) + responseTime) / targetTypeStats.totalRequests;
+            }
+            // 更新 byVendor
+            if (log.vendorId) {
+                let vendorStats = this.statistics.byVendor.find(s => s.vendorId === log.vendorId);
+                if (!vendorStats) {
+                    vendorStats = {
+                        vendorId: log.vendorId,
+                        vendorName: log.vendorName || 'Unknown',
+                        totalRequests: 0,
+                        totalTokens: 0,
+                        avgResponseTime: 0
+                    };
+                    this.statistics.byVendor.push(vendorStats);
+                }
+                vendorStats.totalRequests++;
+                vendorStats.totalTokens += totalTokens;
+                vendorStats.avgResponseTime =
+                    (vendorStats.avgResponseTime * (vendorStats.totalRequests - 1) + responseTime) / vendorStats.totalRequests;
+            }
+            // 更新 byService
+            if (log.targetServiceId) {
+                let serviceStats = this.statistics.byService.find(s => s.serviceId === log.targetServiceId);
+                if (!serviceStats) {
+                    serviceStats = {
+                        serviceId: log.targetServiceId,
+                        serviceName: log.targetServiceName || 'Unknown',
+                        vendorName: log.vendorName || 'Unknown',
+                        totalRequests: 0,
+                        totalTokens: 0,
+                        avgResponseTime: 0
+                    };
+                    this.statistics.byService.push(serviceStats);
+                }
+                serviceStats.totalRequests++;
+                serviceStats.totalTokens += totalTokens;
+                serviceStats.avgResponseTime =
+                    (serviceStats.avgResponseTime * (serviceStats.totalRequests - 1) + responseTime) / serviceStats.totalRequests;
+            }
+            // 更新 byModel
+            if (log.requestModel || log.targetModel) {
+                const modelName = log.requestModel || log.targetModel || 'Unknown';
+                let modelStats = this.statistics.byModel.find(s => s.modelName === modelName);
+                if (!modelStats) {
+                    modelStats = { modelName, totalRequests: 0, totalTokens: 0, avgResponseTime: 0 };
+                    this.statistics.byModel.push(modelStats);
+                }
+                modelStats.totalRequests++;
+                modelStats.totalTokens += totalTokens;
+                modelStats.avgResponseTime =
+                    (modelStats.avgResponseTime * (modelStats.totalRequests - 1) + responseTime) / modelStats.totalRequests;
+            }
+            // 更新 timeline
+            const date = new Date(log.timestamp).toISOString().split('T')[0];
+            let timelineStats = this.statistics.timeline.find(t => t.date === date);
+            if (!timelineStats) {
+                timelineStats = {
+                    date,
+                    totalRequests: 0,
+                    totalTokens: 0,
+                    totalInputTokens: 0,
+                    totalOutputTokens: 0
+                };
+                this.statistics.timeline.push(timelineStats);
+            }
+            timelineStats.totalRequests++;
+            timelineStats.totalTokens += totalTokens;
+            timelineStats.totalInputTokens += inputTokens;
+            timelineStats.totalOutputTokens += outputTokens;
+            // 保存统计数据
+            yield this.saveStatistics();
+        });
+    }
+    /**
+     * 获取统计数据 - 从持久化的统计数据中读取
+     * @param days - 用于过滤 timeline 数据的天数
+     */
+    getStatistics() {
+        return __awaiter(this, arguments, void 0, function* (days = 30) {
+            const now = Date.now();
+            const startTime = now - days * 24 * 60 * 60 * 1000;
+            // 过滤 timeline 数据
+            const filteredTimeline = this.statistics.timeline.filter(t => {
+                const timelineDate = new Date(t.date).getTime();
+                return timelineDate >= startTime;
+            });
+            // 计算最近24小时的错误数
+            const recentErrors = this.errorLogs.filter(log => log.timestamp >= now - 24 * 60 * 60 * 1000).length;
+            return Object.assign(Object.assign({}, this.statistics), { timeline: filteredTimeline, errors: {
+                    totalErrors: this.errorLogs.length,
+                    recentErrors,
+                } });
+        });
+    }
+    /**
+     * 清空统计数据 - 重置所有统计数据为初始状态
+     */
+    resetStatistics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.statistics = this.createEmptyStatistics();
+            yield this.saveStatistics();
+        });
+    }
+    // Session operations
+    getOrCreateSession(sessionId, targetType, title) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let session = this.sessions.find(s => s.id === sessionId);
+            if (!session) {
+                const now = Date.now();
+                session = {
+                    id: sessionId,
+                    targetType,
+                    title,
+                    firstRequestAt: now,
+                    lastRequestAt: now,
+                    requestCount: 1,
+                    totalTokens: 0,
+                };
+                this.sessions.push(session);
+                yield this.saveSessions();
+            }
+            return session;
+        });
+    }
+    updateSession(sessionId, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.sessions.find(s => s.id === sessionId);
+            if (!session)
+                return false;
+            Object.assign(session, updates);
+            yield this.saveSessions();
+            return true;
+        });
+    }
+    getSessions(targetType_1) {
+        return __awaiter(this, arguments, void 0, function* (targetType, limit = 100, offset = 0) {
+            let filtered = targetType
+                ? this.sessions.filter(s => s.targetType === targetType)
+                : this.sessions;
+            filtered = filtered.sort((a, b) => b.lastRequestAt - a.lastRequestAt);
+            return filtered.slice(offset, offset + limit);
+        });
+    }
+    getSessionsCount(targetType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (targetType) {
+                return this.sessions.filter(s => s.targetType === targetType).length;
+            }
+            return this.sessions.length;
+        });
+    }
+    getLogsBySessionId(sessionId_1) {
+        return __awaiter(this, arguments, void 0, function* (sessionId, limit = 100) {
+            const allLogs = [];
+            // 遍历所有分片
+            for (const shard of this.logShardsIndex) {
+                const shardLogs = yield this.loadLogShard(shard.filename);
+                const filtered = shardLogs.filter(log => this.isLogBelongsToSession(log, sessionId));
+                allLogs.push(...filtered);
+            }
+            return allLogs.sort((a, b) => b.timestamp - a.timestamp).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;
+    }
+    deleteSession(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.sessions.findIndex(s => s.id === sessionId);
+            if (index === -1)
+                return false;
+            this.sessions.splice(index, 1);
+            yield this.saveSessions();
+            return true;
+        });
+    }
+    clearSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sessions = [];
+            yield this.saveSessions();
+        });
+    }
+    // 新增方法：获取单个 session
+    getSession(id) {
+        return this.sessions.find(s => s.id === id) || null;
+    }
+    // 新增方法：创建或更新 session
+    upsertSession(session) {
+        const now = Date.now();
+        const existing = this.sessions.find(s => s.id === session.id);
+        if (existing) {
+            // 更新现有 session
+            existing.lastRequestAt = now;
+            existing.requestCount++;
+            existing.totalTokens += session.totalTokens || 0;
+            existing.vendorId = session.vendorId;
+            existing.vendorName = session.vendorName;
+            existing.serviceId = session.serviceId;
+            existing.serviceName = session.serviceName;
+            existing.model = session.model;
+        }
+        else {
+            // 创建新 session
+            this.sessions.push({
+                id: session.id,
+                targetType: session.targetType,
+                title: session.title,
+                firstRequestAt: session.firstRequestAt,
+                lastRequestAt: now,
+                requestCount: 1,
+                totalTokens: session.totalTokens || 0,
+                vendorId: session.vendorId,
+                vendorName: session.vendorName,
+                serviceId: session.serviceId,
+                serviceName: session.serviceName,
+                model: session.model,
+            });
+        }
+        // 异步保存（不阻塞）
+        this.saveSessions().catch(console.error);
+    }
+    // 新增方法：获取规则黑名单状态
+    getRuleBlacklistStatus(serviceId, routeId, contentType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = `${routeId}:${contentType}:${serviceId}`;
+            const entry = this.blacklist.get(key);
+            if (!entry)
+                return null;
+            if (Date.now() > entry.expiresAt) {
+                this.blacklist.delete(key);
+                yield this.saveBlacklist();
+                return null;
+            }
+            return entry;
+        });
+    }
+    // Close method for compatibility (no-op for filesystem database)
+    close() {
+        // 文件系统数据库不需要关闭连接
+        // 所有数据已经持久化到文件
+    }
+}
+exports.FileSystemDatabaseManager = FileSystemDatabaseManager;