aicodeswitch 4.0.0 → 4.0.2

package/dist/server/auth.js

@@ -10,14 +10,20 @@ exports.verifyToken = verifyToken;
 exports.authMiddleware = authMiddleware;
 const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 const crypto_1 = __importDefault(require("crypto"));
-const AUTH_CODE = process.env.AUTH || '';
-const JWT_SECRET = process.env.JWT_SECRET || (AUTH_CODE ? crypto_1.default.createHash('sha256').update(AUTH_CODE).digest('hex') : '');
+// 延迟读取 process.env.AUTH，避免模块加载时 dotenv 尚未执行导致值始终为空
+function getAuthCode() {
+    return process.env.AUTH || '';
+}
+function getJwtSecret() {
+    const authCode = getAuthCode();
+    return process.env.JWT_SECRET || (authCode ? crypto_1.default.createHash('sha256').update(authCode).digest('hex') : '');
+}
 const TOKEN_EXPIRY = '7d'; // 7天有效期
 /**
  * 检查是否启用鉴权
  */
 function isAuthEnabled() {
-    return AUTH_CODE.trim().length > 0;
+    return getAuthCode().trim().length > 0;
 }
 /**
  * 验证鉴权码
@@ -26,7 +32,7 @@ function verifyAuthCode(authCode) {
     if (!isAuthEnabled()) {
         return true; // 未启用鉴权,直接通过
     }
-    return authCode === AUTH_CODE;
+    return authCode === getAuthCode();
 }
 /**
  * 生成 JWT Token
@@ -35,14 +41,14 @@ function generateToken() {
     const payload = {
         authenticated: true,
     };
-    return jsonwebtoken_1.default.sign(payload, JWT_SECRET, { expiresIn: TOKEN_EXPIRY });
+    return jsonwebtoken_1.default.sign(payload, getJwtSecret(), { expiresIn: TOKEN_EXPIRY });
 }
 /**
  * 验证 JWT Token
  */
 function verifyToken(token) {
     try {
-        jsonwebtoken_1.default.verify(token, JWT_SECRET);
+        jsonwebtoken_1.default.verify(token, getJwtSecret());
         return true;
     }
     catch (error) {

package/dist/server/fs-database.js

@@ -56,6 +56,7 @@ class FileSystemDatabaseManager {
     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 sessionLogIndexFile() { return path_1.default.join(this.dataPath, 'session-log-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'); }
@@ -133,6 +134,42 @@ class FileSystemDatabaseManager {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "sessionLogIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "sessionLogIndexDirty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "sessionLogIndexDirtyCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "sessionLogIndexFlushTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "SESSION_LOG_INDEX_FLUSH_DELAY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 3000
+        });
+        Object.defineProperty(this, "SESSION_LOG_INDEX_FLUSH_THRESHOLD", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
         Object.defineProperty(this, "errorLogs", {
             enumerable: true,
             configurable: true,
@@ -242,6 +279,8 @@ class FileSystemDatabaseManager {
                 this.loadStatistics(),
                 this.loadMCPs(),
             ]);
+            // 会话日志索引依赖 logShardsIndex，必须在 loadLogsIndex 之后
+            yield this.loadSessionLogIndex();
         });
     }
     loadVendors() {
@@ -571,6 +610,96 @@ class FileSystemDatabaseManager {
             yield promises_1.default.writeFile(this.logsIndexFile, JSON.stringify(this.logShardsIndex, null, 2));
         });
     }
+    /**
+     * 加载会话日志索引，若不存在则从现有日志全量构建
+     */
+    loadSessionLogIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(this.sessionLogIndexFile, 'utf-8');
+                const parsed = JSON.parse(data);
+                this.sessionLogIndex = new Map(Object.entries(parsed));
+                console.log(`[Database] Session log index loaded: ${this.sessionLogIndex.size} sessions`);
+            }
+            catch (_a) {
+                // 索引文件不存在，从现有日志全量构建
+                console.log('[Database] Session log index not found, building from existing logs...');
+                yield this.buildSessionLogIndex();
+            }
+        });
+    }
+    /**
+     * 从所有现有日志分片全量构建会话日志索引（首次启动或迁移用）
+     */
+    buildSessionLogIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sessionLogIndex.clear();
+            for (const shard of this.logShardsIndex) {
+                const shardLogs = yield this.loadLogShard(shard.filename);
+                for (let i = 0; i < shardLogs.length; i++) {
+                    const sessionId = this.extractSessionIdFromLog(shardLogs[i]);
+                    if (sessionId) {
+                        let refs = this.sessionLogIndex.get(sessionId);
+                        if (!refs) {
+                            refs = [];
+                            this.sessionLogIndex.set(sessionId, refs);
+                        }
+                        refs.push({ filename: shard.filename, index: i, timestamp: shardLogs[i].timestamp });
+                    }
+                }
+            }
+            if (this.sessionLogIndex.size > 0) {
+                yield this.saveSessionLogIndexNow();
+                console.log(`[Database] Session log index built: ${this.sessionLogIndex.size} sessions indexed`);
+            }
+        });
+    }
+    /**
+     * 将会话日志索引写入磁盘
+     */
+    saveSessionLogIndexNow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const obj = {};
+            for (const [key, refs] of this.sessionLogIndex) {
+                obj[key] = refs;
+            }
+            yield promises_1.default.writeFile(this.sessionLogIndexFile, JSON.stringify(obj));
+        });
+    }
+    /**
+     * 标记索引脏数据，触发防抖写盘
+     */
+    scheduleSessionLogIndexFlush() {
+        this.sessionLogIndexDirty = true;
+        this.sessionLogIndexDirtyCount++;
+        // 达到阈值立即刷盘
+        if (this.sessionLogIndexDirtyCount >= this.SESSION_LOG_INDEX_FLUSH_THRESHOLD) {
+            this.flushSessionLogIndex();
+            return;
+        }
+        // 防抖定时器
+        if (!this.sessionLogIndexFlushTimer) {
+            this.sessionLogIndexFlushTimer = setTimeout(() => {
+                this.flushSessionLogIndex();
+            }, this.SESSION_LOG_INDEX_FLUSH_DELAY);
+        }
+    }
+    /**
+     * 立即将索引刷盘（关闭时调用）
+     */
+    flushSessionLogIndex() {
+        if (this.sessionLogIndexFlushTimer) {
+            clearTimeout(this.sessionLogIndexFlushTimer);
+            this.sessionLogIndexFlushTimer = null;
+        }
+        if (this.sessionLogIndexDirty) {
+            this.sessionLogIndexDirty = false;
+            this.sessionLogIndexDirtyCount = 0;
+            this.saveSessionLogIndexNow().catch(err => {
+                console.error('[Database] Failed to flush session log index:', err);
+            });
+        }
+    }
     /**
      * 迁移旧的 logs.json 文件到新的分片格式
      */
@@ -683,6 +812,18 @@ class FileSystemDatabaseManager {
             this.logShardsIndex = this.logShardsIndex.filter(s => !toDelete.includes(s.filename));
             if (toDelete.length > 0) {
                 yield this.saveLogsIndex();
+                // 同步清理会话日志索引中被删除分片的条目
+                const deleteSet = new Set(toDelete);
+                for (const [sid, refs] of this.sessionLogIndex) {
+                    const remaining = refs.filter(r => !deleteSet.has(r.filename));
+                    if (remaining.length === 0) {
+                        this.sessionLogIndex.delete(sid);
+                    }
+                    else if (remaining.length < refs.length) {
+                        this.sessionLogIndex.set(sid, remaining);
+                    }
+                }
+                yield this.saveSessionLogIndexNow();
             }
         });
     }
@@ -1413,6 +1554,17 @@ class FileSystemDatabaseManager {
             yield this.updateStatistics(logWithId);
             // 清除计数缓存
             this.logsCountCache = null;
+            // 更新会话日志索引
+            const sessionId = this.extractSessionIdFromLog(logWithId);
+            if (sessionId) {
+                let refs = this.sessionLogIndex.get(sessionId);
+                if (!refs) {
+                    refs = [];
+                    this.sessionLogIndex.set(sessionId, refs);
+                }
+                refs.push({ filename, index: shardLogs.length - 1, timestamp: logWithId.timestamp });
+                this.scheduleSessionLogIndexFlush();
+            }
         });
     }
     getLogs() {
@@ -2381,8 +2533,37 @@ class FileSystemDatabaseManager {
     }
     getLogsBySessionId(sessionId_1) {
         return __awaiter(this, arguments, void 0, function* (sessionId, limit = 100) {
+            const refs = this.sessionLogIndex.get(sessionId);
+            // 有索引：仅加载相关分片，按 index 直接取值
+            if (refs && refs.length > 0) {
+                // 按 filename 分组，避免重复加载同一分片
+                const shardMap = new Map();
+                for (const ref of refs) {
+                    let indices = shardMap.get(ref.filename);
+                    if (!indices) {
+                        indices = [];
+                        shardMap.set(ref.filename, indices);
+                    }
+                    indices.push(ref.index);
+                }
+                const logs = [];
+                for (const [filename, indices] of shardMap) {
+                    try {
+                        const shardLogs = yield this.loadLogShard(filename);
+                        for (const idx of indices) {
+                            if (idx >= 0 && idx < shardLogs.length) {
+                                logs.push(shardLogs[idx]);
+                            }
+                        }
+                    }
+                    catch (_a) {
+                        // 分片文件可能已被清理，跳过
+                    }
+                }
+                return logs.sort((a, b) => b.timestamp - a.timestamp).slice(0, limit);
+            }
+            // 无索引（兼容旧数据）：回退到全扫描
             const allLogs = [];
-            // 遍历所有分片
             for (const shard of this.logShardsIndex) {
                 const shardLogs = yield this.loadLogShard(shard.filename);
                 const filtered = shardLogs.filter(log => this.isLogBelongsToSession(log, sessionId));
@@ -2405,22 +2586,73 @@ class FileSystemDatabaseManager {
             try {
                 // body 可能是对象（已解析）或字符串（未解析）
                 const body = typeof log.body === 'string' ? JSON.parse(log.body) : log.body;
-                if (((_b = body.metadata) === null || _b === void 0 ? void 0 : _b.user_id) === sessionId) {
-                    return true;
+                if ((_b = body.metadata) === null || _b === void 0 ? void 0 : _b.user_id) {
+                    const userId = body.metadata.user_id;
+                    // 兼容新旧格式：新版本为 JSON 字符串，旧版本为纯字符串
+                    let extractedSessionId = null;
+                    try {
+                        const parsed = JSON.parse(userId);
+                        if (parsed && typeof parsed === 'object' && parsed.session_id) {
+                            extractedSessionId = parsed.session_id;
+                        }
+                    }
+                    catch (_c) {
+                        // 不是 JSON，按旧版本纯字符串处理
+                        extractedSessionId = userId;
+                    }
+                    if (extractedSessionId === sessionId) {
+                        return true;
+                    }
                 }
             }
-            catch (_c) {
+            catch (_d) {
                 // 忽略解析错误
             }
         }
         return false;
     }
+    /**
+     * 从日志条目中提取 sessionId（用于索引）
+     * Codex: headers['session_id']
+     * Claude Code: body.metadata.user_id（兼容新旧格式）
+     */
+    extractSessionIdFromLog(log) {
+        var _a, _b;
+        // Codex: headers 中的 session_id
+        const headerSessionId = (_a = log.headers) === null || _a === void 0 ? void 0 : _a['session_id'];
+        if (typeof headerSessionId === 'string')
+            return headerSessionId;
+        // Claude Code: body 中的 metadata.user_id
+        if (log.body) {
+            try {
+                const body = typeof log.body === 'string' ? JSON.parse(log.body) : log.body;
+                if ((_b = body.metadata) === null || _b === void 0 ? void 0 : _b.user_id) {
+                    const userId = body.metadata.user_id;
+                    try {
+                        const parsed = JSON.parse(userId);
+                        if (parsed && typeof parsed === 'object' && parsed.session_id) {
+                            return parsed.session_id;
+                        }
+                    }
+                    catch (_c) {
+                        return userId;
+                    }
+                }
+            }
+            catch (_d) {
+                // 忽略解析错误
+            }
+        }
+        return null;
+    }
     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);
+            this.sessionLogIndex.delete(sessionId);
+            this.scheduleSessionLogIndexFlush();
             yield this.saveSessions();
             return true;
         });
@@ -2428,6 +2660,8 @@ class FileSystemDatabaseManager {
     clearSessions() {
         return __awaiter(this, void 0, void 0, function* () {
             this.sessions = [];
+            this.sessionLogIndex.clear();
+            this.scheduleSessionLogIndexFlush();
             yield this.saveSessions();
         });
     }
@@ -2542,8 +2776,8 @@ class FileSystemDatabaseManager {
     }
     // Close method for compatibility (no-op for filesystem database)
     close() {
-        // 文件系统数据库不需要关闭连接
-        // 所有数据已经持久化到文件
+        // 刷盘会话日志索引
+        this.flushSessionLogIndex();
     }
 }
 exports.FileSystemDatabaseManager = FileSystemDatabaseManager;

package/dist/server/main.js

@@ -1082,6 +1082,32 @@ const registerRoutes = (dbManager, proxyServer) => {
             res.status(500).json({ error: 'Failed to clear blacklist' });
         }
     })));
+    // 获取所有规则的当前状态
+    app.get('/api/rules/status', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        // 获取所有规则
+        const allRules = dbManager.getRules();
+        // 获取有状态记录的规则
+        const statusMap = rules_status_service_1.rulesStatusBroadcaster.getAllRuleStatuses();
+        // 将数组转换为 Map 以便快速查找
+        const statusMapByRuleId = new Map(statusMap.map(status => [status.ruleId, status]));
+        // 合并所有规则的状态
+        const allStatuses = allRules.map(rule => {
+            const existingStatus = statusMapByRuleId.get(rule.id);
+            if (existingStatus) {
+                // 如果有状态记录，返回记录的状态
+                return existingStatus;
+            }
+            else {
+                // 如果没有状态记录，返回默认的 idle 状态
+                return {
+                    ruleId: rule.id,
+                    status: 'idle',
+                    timestamp: Date.now(),
+                };
+            }
+        });
+        res.json(allStatuses);
+    })));
     // 清除规则的错误状态（广播 idle 状态给所有客户端）
     app.post('/api/rules/:id/clear-status', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
         const { id } = req.params;
@@ -1100,7 +1126,7 @@ const registerRoutes = (dbManager, proxyServer) => {
             res.status(404).json({ error: 'Route not found' });
             return;
         }
-        // 广播 idle 状态给所有客户端
+        // 标记规则为 idle 状态
         rules_status_service_1.rulesStatusBroadcaster.markRuleIdle(route.id, id);
         res.json({ success: true });
     })));
@@ -1946,32 +1972,24 @@ const start = () => __awaiter(void 0, void 0, void 0, function* () {
     });
     // 创建 WebSocket 服务器用于工具安装
     const toolInstallWss = (0, websocket_service_1.createToolInstallationWSServer)();
-    // 创建 WebSocket 服务器用于规则状态
-    const rulesStatusWss = (0, rules_status_service_1.createRulesStatusWSServer)();
     // 设置黑名单检查函数，用于在规则状态同步时检查黑名单是否已过期
     rules_status_service_1.rulesStatusBroadcaster.setBlacklistChecker((serviceId, routeId, contentType) => __awaiter(void 0, void 0, void 0, function* () {
         // 检查服务��否在黑名单中
         const isBlacklisted = yield dbManager.isServiceBlacklisted(serviceId, routeId, contentType);
         return isBlacklisted;
     }));
-    // 将 WebSocket 服务器附加到 HTTP 服务器
+    // 将 WebSocket 服务器附加到 HTTP 服务器（仅用于工具安装）
     server.on('upgrade', (request, socket, head) => {
         if (request.url === '/api/tools/install') {
             toolInstallWss.handleUpgrade(request, socket, head, (ws) => {
                 toolInstallWss.emit('connection', ws, request);
             });
         }
-        else if (request.url === '/api/rules/status') {
-            rulesStatusWss.handleUpgrade(request, socket, head, (ws) => {
-                rulesStatusWss.emit('connection', ws, request);
-            });
-        }
         else {
             socket.destroy();
         }
     });
     console.log(`WebSocket server for tool installation attached to ws://${host}:${port}/api/tools/install`);
-    console.log(`WebSocket server for rules status attached to ws://${host}:${port}/api/rules/status`);
     let isShuttingDown = false;
     let shutdownPromise = null;
     const shutdown = (signal) => __awaiter(void 0, void 0, void 0, function* () {