aicodeswitch 5.2.12 → 5.2.13

package/README.md

@@ -192,8 +192,6 @@ aicodeswitch内部，会根据“源类型”来转换数据。例如，你的
 目前仅支持以下配置：
 
 ```
-# aicodeswitch的服务IP
-HOST=127.0.0.1
 # aicodeswitch的服务端口
 PORT=4567
 
@@ -202,6 +200,12 @@ PORT=4567
 # AUTH=
 ```
 
+> 服务监听地址由 AUTH 模式自动决定，无需也无法通过配置修改：
+> - AUTH 关闭：仅监听 `127.0.0.1`（本机访问）
+> - AUTH 开启：监听 `0.0.0.0`（允许远端 AccessKey 客户端连接）
+>
+> 写入本地编程工具（Claude Code / Codex）配置文件的地址、以及 UI / CLI 展示的访问地址，统一使用 `127.0.0.1`。
+
 ## 常见问题
 
 ### 1\. 如何切换供应商？

package/UPGRADE.md

@@ -1,6 +1,7 @@
-升级到 v5.0.0 版本将会有破坏性影响，你需要注意：
+升级到 v6.0.0 版本将会有破坏性影响，你需要注意：
 
-* 我们移除了 `Deepseek` 类型的服务，它原本的 `reasoning_content` 特殊字段已被合并进入 `chat completions` 类型，升级会自动完成数据库迁移，你不需要手动修改。
-* 我们启用了新的数据流格式转化器，请你实时关注新版本，如遇到问题，我们会实时修复发布新版本。
-* 我们对路由管理进行了升级，现在你可以将 aicodeswitch 使用于其他**任意的编程工具**，之需要填写对应的 API 即可。升级后，路由本身不再绑定claude-code/codex，你需要在Claude Code配置、Codex配置中，激活想要用来服务的路由，让这两个最重要的编程工具能够正常工作（我们会在升级过程中帮你自动迁移数据库，因此，你不需要手动处理）。
+* 我们升级了日志系统，以解决老的日志系统所带来的存储问题。新日志系统会迁移你的日志数据，但是，为了确保日志数据不丢失，我们会在下一个版本中才删除老的日志文件，这也就意味着你的电脑上可能同时存在两份日志文件，占用空间。为了节约你的电脑磁盘空间，你可以在运行一段时间感觉正常之后，删除 `~/.aicodeswitch/fs-db/logs` 目录来移除老的日志文件。
 
+本次升级带来了新的大功能：
+
+* 「任务雷达」功能，帮助你时刻掌握当前任务状态，历史任务分布，通过对任务雷达的分析，你可以掌握自己的编程习惯，从而作出适当的调整。

package/bin/utils/get-server.js

@@ -36,16 +36,16 @@ const getServerInfo = () => {
     path.join(os.homedir(), '.aicodeswitch', 'aicodeswitch.conf')
   ];
 
-  let host = '127.0.0.1';
+  // 监听地址现由 AUTH 模式决定（AUTH 开→0.0.0.0 / AUTH 关→127.0.0.1），HOST 已忽略；
+  // 本机 dashboard 的访问地址恒为回环地址，CLI 展示与自动打开统一用 127.0.0.1。
+  const host = '127.0.0.1';
   let port = 4567;
 
   for (const dotenvPath of possiblePaths) {
     if (fs.existsSync(dotenvPath)) {
       const content = fs.readFileSync(dotenvPath, 'utf-8');
-      const hostMatch = content.match(/HOST=(.+)/);
       const portMatch = content.match(/PORT=(.+)/);
 
-      if (hostMatch) host = hostMatch[1].trim();
       if (portMatch) port = parseInt(portMatch[1].trim(), 10);
       break;
     }

package/dist/server/access-keys/index.js

@@ -27,7 +27,7 @@ const key_logger_1 = require("./key-logger");
 const key_session_tracker_1 = require("./key-session-tracker");
 const key_resolver_1 = require("./key-resolver");
 class AccessKeyModule {
-    constructor(dataPath) {
+    constructor(dataPath, logStore) {
         Object.defineProperty(this, "keyManager", {
             enumerable: true,
             configurable: true,
@@ -94,7 +94,7 @@ class AccessKeyModule {
         this.policyManager = new policy_manager_1.PolicyManager();
         this.quotaChecker = new quota_checker_1.QuotaChecker();
         this.usageTracker = new usage_tracker_1.UsageTracker(dataPath);
-        this.keyLogger = new key_logger_1.KeyLogger(dataPath);
+        this.keyLogger = new key_logger_1.KeyLogger(dataPath, logStore);
         this.keySessionTracker = new key_session_tracker_1.KeySessionTracker(dataPath);
         this.keyResolver = new key_resolver_1.KeyResolver(this.keyManager, this.policyManager);
     }

package/dist/server/access-keys/key-logger.js

@@ -8,353 +8,107 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyLogger = void 0;
-/**
- * Key 级日志管理器
- * 每个 AccessKey 有独立的日志空间，完全与现有日志系统隔离
- */
-const path_1 = __importDefault(require("path"));
-const promises_1 = __importDefault(require("fs/promises"));
-const crypto_1 = __importDefault(require("crypto"));
+const LOG_RETENTION_DAYS = 30;
 class KeyLogger {
-    constructor(dataPath) {
-        Object.defineProperty(this, "dataPath", {
+    constructor(_dataPath, logStore) {
+        Object.defineProperty(this, "logStore", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        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
-        });
-        /** 分片索引缓存 keyId → LogShardIndex[] */
-        Object.defineProperty(this, "shardIndexCache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        /** 分片写入锁 */
-        Object.defineProperty(this, "shardWriteLocks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        this.dataPath = dataPath;
+        this.logStore = logStore;
     }
-    /** 初始化 */
+    /** 初始化（存储由 LogStore 统一管理，此处保留为兼容空方法） */
     initialize() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logsDir = path_1.default.join(this.dataPath, 'key-logs');
-            yield promises_1.default.mkdir(logsDir, { recursive: true });
+            // no-op
         });
     }
-    /** 写入一条日志 */
+    ns(keyId) {
+        return `key:${keyId}`;
+    }
+    /** 写入一条日志（追加写，O(单条)） */
     addLog(keyId, keyName, logData) {
         return __awaiter(this, void 0, void 0, function* () {
-            const log = Object.assign(Object.assign({}, logData), { id: crypto_1.default.randomUUID(), keyId,
+            const log = Object.assign(Object.assign({}, logData), { keyId,
                 keyName });
-            const keyDir = this.getKeyLogDir(keyId);
-            yield promises_1.default.mkdir(keyDir, { recursive: true });
-            const index = yield this.getShardIndex(keyId);
-            const now = new Date();
-            const dateStr = `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, '0')}-${String(now.getUTCDate()).padStart(2, '0')}`;
-            // 找到或创建当前分片
-            let targetShard = null;
-            for (const shard of index) {
-                if (shard.date === dateStr && shard.count < 1000) {
-                    // 检查文件大小
-                    try {
-                        const stat = yield promises_1.default.stat(path_1.default.join(keyDir, shard.filename));
-                        if (stat.size < this.MAX_SHARD_SIZE) {
-                            targetShard = shard;
-                            break;
-                        }
-                    }
-                    catch (_a) {
-                        targetShard = shard;
-                        break;
-                    }
-                }
-            }
-            if (!targetShard) {
-                // 创建新分片
-                const seq = index.filter(s => s.date === dateStr).length + 1;
-                targetShard = {
-                    filename: seq === 1 ? `logs-${dateStr}.json` : `logs-${dateStr}-${String(seq).padStart(3, '0')}.json`,
-                    date: dateStr,
-                    startTime: Date.now(),
-                    endTime: Date.now(),
-                    count: 0,
-                };
-                index.push(targetShard);
+            // 保留原 id（如有）或由 LogStore 生成
+            if (!log.id) {
+                log.id = undefined; // 让 LogStore.append 生成 UUID
             }
-            // 写入日志（带锁）
-            yield this.writeToShard(keyId, targetShard, log);
-            // 更新索引
-            targetShard.count += 1;
-            targetShard.endTime = Date.now();
-            yield this.saveShardIndex(keyId, index);
+            yield this.logStore.append(this.ns(keyId), log);
         });
     }
-    /** 获取 Key 的日志列表（分页 + 过滤） */
+    /** 获取 Key 的日志列表（分页 + 日期/类型/搜索过滤） */
     getLogs(keyId, options) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const index = yield this.getShardIndex(keyId);
-            let filteredShards = index;
-            if (options.startDate) {
-                filteredShards = filteredShards.filter(s => s.date >= options.startDate);
-            }
-            if (options.endDate) {
-                filteredShards = filteredShards.filter(s => s.date <= options.endDate);
-            }
-            const needsFilter = !!(options.contentType || options.search);
-            const searchLower = (_a = options.search) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-            // 计算分页偏移
             const offset = (options.page - 1) * options.pageSize;
             const limit = options.pageSize;
-            // 如果不需要细粒度过滤，使用快速分片级分页
-            if (!needsFilter) {
-                const total = filteredShards.reduce((sum, s) => sum + s.count, 0);
-                const allLogs = [];
-                let skipped = 0;
-                let collected = 0;
-                for (let i = filteredShards.length - 1; i >= 0 && collected < limit; i++) {
-                    const shard = filteredShards[i];
-                    const logs = yield this.readShardFile(keyId, shard.filename);
-                    const reversed = logs.reverse();
-                    for (const log of reversed) {
-                        if (skipped < offset) {
-                            skipped++;
-                            continue;
-                        }
-                        allLogs.push(log);
-                        collected++;
-                        if (collected >= limit)
-                            break;
-                    }
-                }
-                return { data: allLogs, total };
-            }
-            // 需要细粒度过滤：先收集所有匹配日志，再分页
-            const matchedLogs = [];
-            for (let i = filteredShards.length - 1; i >= 0; i--) {
-                const shard = filteredShards[i];
-                const logs = yield this.readShardFile(keyId, shard.filename);
-                const reversed = logs.reverse();
-                for (const log of reversed) {
-                    // 类型过滤
-                    if (options.contentType && log.contentType !== options.contentType)
-                        continue;
-                    // 搜索过滤（匹配路径、模型）
-                    if (searchLower) {
-                        const path = (log.path || '').toLowerCase();
-                        const model = (log.requestModel || log.targetModel || '').toLowerCase();
-                        const error = (log.error || '').toLowerCase();
-                        if (!path.includes(searchLower) && !model.includes(searchLower) && !error.includes(searchLower))
-                            continue;
-                    }
-                    matchedLogs.push(log);
-                }
-            }
-            const total = matchedLogs.length;
-            const data = matchedLogs.slice(offset, offset + limit);
-            return { data, total };
-        });
-    }
-    /** 清理过期日志 */
-    cleanupOldLogs() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const logsDir = path_1.default.join(this.dataPath, 'key-logs');
-            let keyDirs;
-            try {
-                keyDirs = yield promises_1.default.readdir(logsDir);
-            }
-            catch (_a) {
-                return;
-            }
-            const cutoffTime = Date.now() - this.LOG_RETENTION_DAYS * 24 * 3600 * 1000;
-            for (const keyId of keyDirs) {
-                const keyDir = path_1.default.join(logsDir, keyId);
-                const stat = yield promises_1.default.stat(keyDir);
-                if (!stat.isDirectory())
-                    continue;
-                const index = yield this.getShardIndex(keyId);
-                let changed = false;
-                for (let i = index.length - 1; i >= 0; i--) {
-                    if (index[i].endTime < cutoffTime) {
-                        // 删除过期分片文件
-                        try {
-                            yield promises_1.default.unlink(path_1.default.join(keyDir, index[i].filename));
-                        }
-                        catch ( /* ignore */_b) { /* ignore */ }
-                        index.splice(i, 1);
-                        changed = true;
-                    }
-                }
-                if (changed) {
-                    yield this.saveShardIndex(keyId, index);
+            const since = options.startDate ? Date.parse(options.startDate) : undefined;
+            const until = options.endDate ? Date.parse(options.endDate) + 86400000 - 1 : undefined;
+            const contentType = options.contentType;
+            const searchLower = (_a = options.search) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const match = (log) => {
+                if (contentType && log.contentType !== contentType)
+                    return false;
+                if (searchLower) {
+                    const p = (log.path || '').toLowerCase();
+                    const m = (log.requestModel || log.targetModel || '').toLowerCase();
+                    const e = (log.error || '').toLowerCase();
+                    if (!p.includes(searchLower) && !m.includes(searchLower) && !e.includes(searchLower))
+                        return false;
                 }
-            }
-        });
-    }
-    /** 获取 Key 的日志总数 */
-    getLogsCount(keyId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = yield this.getShardIndex(keyId);
-            return index.reduce((sum, s) => sum + s.count, 0);
+                return true;
+            };
+            const needFilter = !!(contentType || searchLower);
+            if (!needFilter && since == null && until == null) {
+                // 纯分页：用 getRecent + count
+                const [data, total] = yield Promise.all([
+                    this.logStore.getRecent(this.ns(keyId), { limit, offset }),
+                    this.logStore.count(this.ns(keyId)),
+                ]);
+                return { data: data, total };
+            }
+            const { data, total } = yield this.logStore.getFiltered(this.ns(keyId), {
+                since: Number.isFinite(since) ? since : undefined,
+                until: Number.isFinite(until) ? until : undefined,
+                match: needFilter ? match : undefined,
+                limit,
+                offset,
+            });
+            return { data: data, total };
         });
     }
-    /** 按 sessionId 过滤日志（用于密钥会话的日志查询） */
+    /** 按 sessionId 过滤日志（用于密钥会话的日志查询，字节偏移随机读） */
     getLogsBySessionId(keyId_1, sessionId_1) {
         return __awaiter(this, arguments, void 0, function* (keyId, sessionId, limit = 10000) {
-            const index = yield this.getShardIndex(keyId);
-            const allLogs = [];
-            // 从最新的分片开始扫描
-            for (let i = index.length - 1; i >= 0 && allLogs.length < limit; i--) {
-                const shard = index[i];
-                const logs = yield this.readShardFile(keyId, shard.filename);
-                for (let j = logs.length - 1; j >= 0 && allLogs.length < limit; j--) {
-                    if (this.logBelongsToSession(logs[j], sessionId)) {
-                        allLogs.push(logs[j]);
-                    }
-                }
-            }
-            // 按时间正序排列（用于对话视图）
-            return allLogs.sort((a, b) => a.timestamp - b.timestamp);
+            const logs = yield this.logStore.getBySession(this.ns(keyId), sessionId, { limit });
+            // 按 timestamp 正序（对话视图所需）
+            return logs.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
         });
     }
-    /** 判断日志是否属于指定会话 */
-    logBelongsToSession(log, sessionId) {
-        var _a;
-        // Codex: 检查 headers 中的 session-id
-        const headers = log.headers;
-        if (headers) {
-            const sid = headers['session-id'] || headers['session_id'];
-            if (typeof sid === 'string' && sid === sessionId)
-                return true;
-            if (Array.isArray(sid) && sid[0] === sessionId)
-                return true;
-        }
-        // Claude Code: 检查 body.metadata.user_id
-        if (log.body) {
-            try {
-                const body = typeof log.body === 'string' ? JSON.parse(log.body) : log.body;
-                const rawUserId = (_a = body === null || body === void 0 ? void 0 : body.metadata) === null || _a === void 0 ? void 0 : _a.user_id;
-                if (rawUserId) {
-                    // 复用 ProxyServer 的 session ID 提取逻辑
-                    let extractedId = null;
-                    try {
-                        const parsed = JSON.parse(rawUserId);
-                        if (parsed && typeof parsed === 'object' && parsed.session_id) {
-                            extractedId = parsed.session_id;
-                        }
-                    }
-                    catch (_b) {
-                        extractedId = rawUserId;
-                    }
-                    if (extractedId === sessionId)
-                        return true;
-                }
-            }
-            catch ( /* ignore */_c) { /* ignore */ }
-        }
-        return false;
-    }
-    // ---- helpers ----
-    getKeyLogDir(keyId) {
-        return path_1.default.join(this.dataPath, 'key-logs', keyId);
-    }
-    getShardIndexPath(keyId) {
-        return path_1.default.join(this.getKeyLogDir(keyId), 'logs-index.json');
-    }
-    getShardIndex(keyId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.shardIndexCache.has(keyId)) {
-                return this.shardIndexCache.get(keyId);
-            }
-            try {
-                const data = yield promises_1.default.readFile(this.getShardIndexPath(keyId), 'utf-8');
-                const parsed = JSON.parse(data);
-                // 防御性过滤：确保返回有效数组，剔除 null/undefined 或缺少 filename 的条目
-                const index = Array.isArray(parsed)
-                    ? parsed.filter((s) => s != null && typeof s === 'object' && 'filename' in s)
-                    : [];
-                this.shardIndexCache.set(keyId, index);
-                return index;
-            }
-            catch (_a) {
-                const index = [];
-                this.shardIndexCache.set(keyId, index);
-                return index;
-            }
-        });
-    }
-    saveShardIndex(keyId, index) {
+    /** 获取 Key 的日志总数 */
+    getLogsCount(keyId) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.shardIndexCache.set(keyId, index);
-            const filePath = this.getShardIndexPath(keyId);
-            const tmpPath = filePath + '.tmp';
-            yield promises_1.default.writeFile(tmpPath, JSON.stringify(index, null, 2), 'utf-8');
-            yield promises_1.default.rename(tmpPath, filePath);
+            return this.logStore.count(this.ns(keyId));
         });
     }
-    writeToShard(keyId, shard, log) {
+    /** 清理所有 AccessKey 的过期日志（30 天，整文件删除） */
+    cleanupOldLogs() {
         return __awaiter(this, void 0, void 0, function* () {
-            const lockKey = `${keyId}:${shard.filename}`;
-            // 等待现有写入完成
-            while (this.shardWriteLocks.has(lockKey)) {
-                yield this.shardWriteLocks.get(lockKey);
-            }
-            const writePromise = (() => __awaiter(this, void 0, void 0, function* () {
+            for (const nsName of this.logStore.listNamespaces()) {
+                if (!nsName.startsWith('key:'))
+                    continue;
                 try {
-                    const keyDir = this.getKeyLogDir(keyId);
-                    const shardPath = path_1.default.join(keyDir, shard.filename);
-                    let logs = [];
-                    try {
-                        const data = yield promises_1.default.readFile(shardPath, 'utf-8');
-                        logs = JSON.parse(data);
-                    }
-                    catch (_a) {
-                        // 新文件
-                    }
-                    logs.push(log);
-                    const tmpPath = shardPath + '.tmp';
-                    yield promises_1.default.writeFile(tmpPath, JSON.stringify(logs), 'utf-8');
-                    yield promises_1.default.rename(tmpPath, shardPath);
+                    yield this.logStore.retain(nsName, LOG_RETENTION_DAYS);
                 }
-                finally {
-                    this.shardWriteLocks.delete(lockKey);
+                catch (_a) {
+                    // 忽略单个 key 失败
                 }
-            }))();
-            this.shardWriteLocks.set(lockKey, writePromise);
-            yield writePromise;
-        });
-    }
-    readShardFile(keyId, filename) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const shardPath = path_1.default.join(this.getKeyLogDir(keyId), filename);
-            try {
-                const data = yield promises_1.default.readFile(shardPath, 'utf-8');
-                return JSON.parse(data);
-            }
-            catch (_a) {
-                return [];
             }
         });
     }