aicodeswitch 5.1.3 → 5.2.1

package/README.md

@@ -10,6 +10,7 @@ AI Code Switch 是帮助你在本地管理 AI 编程工具接入大模型的工
 
 - 视频演示：[https://www.bilibili.com/video/BV1uEznBuEJd/](https://www.bilibili.com/video/BV1uEznBuEJd/?from=github)
 - 1分钟让Claude Code接入GLM国产模型：[https://www.bilibili.com/video/BV1a865B8ErA/](https://www.bilibili.com/video/BV1a865B8ErA/)
+- 1分钟让Codex接入免费模型Agnes：[https://www.bilibili.com/video/BV1tQ7Q63Eva/](https://www.bilibili.com/video/BV1tQ7Q63Eva/) Codex接入Deepseek可参考该方法实现
 
 ## 功能要点
 

package/bin/restore.js

@@ -5,6 +5,7 @@ const chalk = require('chalk');
 const boxen = require('boxen');
 const ora = require('ora');
 const { parseToml, stringifyToml, mergeJsonSettings, mergeTomlSettings, atomicWriteFile } = require('./utils/config-helpers');
+const { CLAUDE_SETTINGS_MANAGED_FIELDS, CLAUDE_JSON_MANAGED_FIELDS, CODEX_CONFIG_MANAGED_FIELDS, CODEX_AUTH_MANAGED_FIELDS } = require('./utils/managed-fields');
 const { isServerRunning, getServerInfo } = require('./utils/get-server');
 const { findPidByPort } = require('./utils/port-utils');
 
@@ -85,12 +86,19 @@ const restoreClaudeConfig = () => {
           }
         }
 
+        // 防御性清理：移除 currentSettings 中 ANTHROPIC_API_KEY 的空值，
+        // 防止旧版本代理写入的空值覆盖 backup 中的真实 Key
+        if (currentSettings?.env?.ANTHROPIC_API_KEY === '' && backupSettings?.env?.ANTHROPIC_API_KEY) {
+          delete currentSettings.env.ANTHROPIC_API_KEY;
+          if (Object.keys(currentSettings.env).length === 0) {
+            delete currentSettings.env;
+          }
+        }
+
         const mergedSettings = mergeJsonSettings(
           backupSettings,
           currentSettings,
-          ['env.ANTHROPIC_AUTH_TOKEN', 'env.ANTHROPIC_BASE_URL', 'env.API_TIMEOUT_MS',
-             'env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC', 'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
-             'permissions', 'skipDangerousModePermissionPrompt']
+          CLAUDE_SETTINGS_MANAGED_FIELDS
         );
 
         atomicWriteFile(claudeSettingsPath, JSON.stringify(mergedSettings, null, 2));
@@ -127,7 +135,7 @@ const restoreClaudeConfig = () => {
         const mergedJson = mergeJsonSettings(
           backupJson,
           currentJson,
-          ['hasCompletedOnboarding', 'mcpServers']
+          CLAUDE_JSON_MANAGED_FIELDS
         );
 
         atomicWriteFile(claudeJsonPath, JSON.stringify(mergedJson, null, 2));
@@ -176,8 +184,7 @@ const restoreCodexConfig = () => {
         const mergedConfig = mergeTomlSettings(
           backupConfig,
           currentConfig,
-          ['model_provider', 'model', 'model_reasoning_effort', 'disable_response_storage',
-             'preferred_auth_method', 'requires_openai_auth', 'enableRouteSelection', 'model_providers.aicodeswitch']
+          CODEX_CONFIG_MANAGED_FIELDS
         );
 
         atomicWriteFile(codexConfigPath, stringifyToml(mergedConfig));
@@ -214,7 +221,7 @@ const restoreCodexConfig = () => {
         const mergedAuth = mergeJsonSettings(
           backupAuth,
           currentAuth,
-          ['OPENAI_API_KEY']
+          CODEX_AUTH_MANAGED_FIELDS
         );
 
         atomicWriteFile(codexAuthPath, JSON.stringify(mergedAuth, null, 2));

package/bin/utils/managed-fields.js

@@ -0,0 +1,62 @@
+/**
+ * 管理字段定义（CLI 侧）
+ * 必须与 src/server/config-managed-fields.ts 保持同步
+ */
+
+/**
+ * Claude Code settings.json 管理字段列表
+ */
+const CLAUDE_SETTINGS_MANAGED_FIELDS = [
+  'env.ANTHROPIC_AUTH_TOKEN',
+  'env.ANTHROPIC_API_KEY',
+  'env.ANTHROPIC_BASE_URL',
+  'env.API_TIMEOUT_MS',
+  'env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC',
+  'env.CLAUDE_CODE_MAX_RETRIES',
+  'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
+  'env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE',
+  'env.ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'env.ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'env.ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'permissions',
+  'skipDangerousModePermissionPrompt',
+  'effortLevel',
+  'model',
+];
+
+/**
+ * Claude Code .claude.json 管理字段列表
+ */
+const CLAUDE_JSON_MANAGED_FIELDS = [
+  'hasCompletedOnboarding',
+  'mcpServers',
+];
+
+/**
+ * Codex config.toml 管理字段列表
+ */
+const CODEX_CONFIG_MANAGED_FIELDS = [
+  'model_provider',
+  'model',
+  'model_reasoning_effort',
+  'disable_response_storage',
+  'preferred_auth_method',
+  'requires_openai_auth',
+  'enableRouteSelection',
+  'model_providers.aicodeswitch',
+  'mcp_servers',
+];
+
+/**
+ * Codex auth.json 管理字段列表
+ */
+const CODEX_AUTH_MANAGED_FIELDS = [
+  'OPENAI_API_KEY',
+];
+
+module.exports = {
+  CLAUDE_SETTINGS_MANAGED_FIELDS,
+  CLAUDE_JSON_MANAGED_FIELDS,
+  CODEX_CONFIG_MANAGED_FIELDS,
+  CODEX_AUTH_MANAGED_FIELDS,
+};

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

@@ -0,0 +1,173 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessKeyModule = void 0;
+/**
+ * AccessKey 模块入口
+ * 统一导出所有子模块，并提供模块级别的初始化和持久化方法
+ */
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const manager_1 = require("./manager");
+const policy_manager_1 = require("./policy-manager");
+const quota_checker_1 = require("./quota-checker");
+const usage_tracker_1 = require("./usage-tracker");
+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) {
+        Object.defineProperty(this, "keyManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "policyManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "quotaChecker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "usageTracker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keyLogger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keySessionTracker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keyResolver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "accessKeysFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "policiesFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "flushTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.accessKeysFile = path_1.default.join(dataPath, 'access-keys.json');
+        this.policiesFile = path_1.default.join(dataPath, 'policies.json');
+        this.keyManager = new manager_1.AccessKeyManager();
+        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.keySessionTracker = new key_session_tracker_1.KeySessionTracker(dataPath);
+        this.keyResolver = new key_resolver_1.KeyResolver(this.keyManager, this.policyManager);
+    }
+    /** 初始化模块 */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 加载持久化数据
+            const [keys, policies] = yield Promise.all([
+                this.loadJsonFile(this.accessKeysFile, []),
+                this.loadJsonFile(this.policiesFile, []),
+            ]);
+            this.keyManager.load(keys);
+            this.policyManager.load(policies);
+            // 初始化子模块
+            yield Promise.all([
+                this.usageTracker.initialize(),
+                this.keyLogger.initialize(),
+                this.keySessionTracker.initialize(),
+            ]);
+            // 启动自动刷新
+            this.usageTracker.startAutoFlush();
+            this.startAutoSave();
+            console.log(`[AccessKey] Module initialized: ${keys.length} keys, ${policies.length} policies`);
+        });
+    }
+    /** 保存所有数据到磁盘 */
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([
+                this.saveJsonFile(this.accessKeysFile, this.keyManager.dump()),
+                this.saveJsonFile(this.policiesFile, this.policyManager.dump()),
+                this.usageTracker.flush(),
+            ]);
+        });
+    }
+    /** 关闭模块 */
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.flushTimer) {
+                clearInterval(this.flushTimer);
+                this.flushTimer = null;
+            }
+            this.usageTracker.stopAutoFlush();
+            yield this.save();
+            console.log('[AccessKey] Module shutdown completed');
+        });
+    }
+    /** 标记数据已修改，需要保存 */
+    markDirty() {
+        // 下一个自动保存周期会处理
+    }
+    startAutoSave() {
+        this.flushTimer = setInterval(() => {
+            this.save().catch(err => console.error('[AccessKey] Auto save error:', err));
+        }, 5000);
+    }
+    loadJsonFile(filePath, defaultValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield promises_1.default.readFile(filePath, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch (_a) {
+                return defaultValue;
+            }
+        });
+    }
+    saveJsonFile(filePath, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tmpPath = filePath + '.tmp';
+            yield promises_1.default.writeFile(tmpPath, JSON.stringify(data, null, 2), 'utf-8');
+            yield promises_1.default.rename(tmpPath, filePath);
+        });
+    }
+}
+exports.AccessKeyModule = AccessKeyModule;

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

@@ -0,0 +1,362 @@
+"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 __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"));
+class KeyLogger {
+    constructor(dataPath) {
+        Object.defineProperty(this, "dataPath", {
+            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;
+    }
+    /** 初始化 */
+    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 });
+        });
+    }
+    /** 写入一条日志 */
+    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,
+                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);
+            }
+            // 写入日志（带锁）
+            yield this.writeToShard(keyId, targetShard, log);
+            // 更新索引
+            targetShard.count += 1;
+            targetShard.endTime = Date.now();
+            yield this.saveShardIndex(keyId, index);
+        });
+    }
+    /** 获取 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);
+                }
+            }
+        });
+    }
+    /** 获取 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);
+        });
+    }
+    /** 按 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);
+        });
+    }
+    /** 判断日志是否属于指定会话 */
+    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) {
+        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);
+        });
+    }
+    writeToShard(keyId, shard, log) {
+        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* () {
+                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);
+                }
+                finally {
+                    this.shardWriteLocks.delete(lockKey);
+                }
+            }))();
+            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 [];
+            }
+        });
+    }
+}
+exports.KeyLogger = KeyLogger;