aicodeswitch 5.1.3 → 5.2.1

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyResolver = void 0;
+class KeyResolver {
+    constructor(keyManager, policyManager) {
+        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
+        });
+        this.keyManager = keyManager;
+        this.policyManager = policyManager;
+    }
+    /**
+     * 尝试解析请求中的 API Key
+     * @returns 如果是 sk_ 开头的 Key，尝试解析；否则返回 null（走现有流程）
+     */
+    resolve(apiKeyValue) {
+        if (!apiKeyValue.startsWith('sk_')) {
+            return null; // 不是 AccessKey，走现有流程
+        }
+        // 查找 AccessKey
+        const accessKey = this.keyManager.findByApiKey(apiKeyValue);
+        if (!accessKey) {
+            return { error: { type: 'authentication_error', code: 'INVALID_API_KEY', message: '无效的 API Key', httpStatus: 401 } };
+        }
+        // 状态检查
+        if (accessKey.status !== 'active') {
+            return { error: { type: 'permission_error', code: 'KEY_DISABLED', message: '密钥已停用', httpStatus: 403 } };
+        }
+        // 策略检查
+        if (!accessKey.policyId) {
+            return { error: { type: 'permission_error', code: 'NO_POLICY_CONFIGURED', message: '密钥未配置策略', httpStatus: 403 } };
+        }
+        const policy = this.policyManager.get(accessKey.policyId);
+        if (!policy) {
+            return { error: { type: 'permission_error', code: 'POLICY_NOT_FOUND', message: '策略不存在', httpStatus: 403 } };
+        }
+        // 更新最后活跃时间
+        this.keyManager.updateLastActive(accessKey.id);
+        return { accessKey, policy };
+    }
+}
+exports.KeyResolver = KeyResolver;

package/dist/server/access-keys/key-session-tracker.js

@@ -0,0 +1,217 @@
+"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.KeySessionTracker = void 0;
+/**
+ * Key 级会话追踪器
+ * 每个 AccessKey 有独立的会话存储空间，与全局会话系统完全隔离
+ */
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+class KeySessionTracker {
+    constructor(dataPath) {
+        Object.defineProperty(this, "dataPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** 内存缓存 keyId → AccessKeySession[] */
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /** 写入锁 */
+        Object.defineProperty(this, "writeLocks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.dataPath = dataPath;
+    }
+    /** 初始化 */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessionsDir = path_1.default.join(this.dataPath, 'key-sessions');
+            yield promises_1.default.mkdir(sessionsDir, { recursive: true });
+        });
+    }
+    /** 创建或更新会话 */
+    upsertSession(keyId, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withWriteLock(keyId, () => __awaiter(this, void 0, void 0, function* () {
+                const sessions = yield this.loadSessions(keyId);
+                const existing = sessions.find(s => s.id === session.id);
+                if (existing) {
+                    // 更新已有会话
+                    existing.requestCount += 1;
+                    existing.totalTokens += session.totalTokens;
+                    existing.lastRequestAt = session.lastRequestAt;
+                    // 更新供应商/服务/模型信息为最新
+                    if (session.vendorId)
+                        existing.vendorId = session.vendorId;
+                    if (session.vendorName)
+                        existing.vendorName = session.vendorName;
+                    if (session.serviceId)
+                        existing.serviceId = session.serviceId;
+                    if (session.serviceName)
+                        existing.serviceName = session.serviceName;
+                    if (session.model)
+                        existing.model = session.model;
+                    // 标题仅在新会话时设置（保留第一次的标题）
+                }
+                else {
+                    // 创建新会话
+                    sessions.push({
+                        id: session.id,
+                        targetType: session.targetType,
+                        title: session.title,
+                        firstRequestAt: session.firstRequestAt,
+                        lastRequestAt: session.lastRequestAt,
+                        requestCount: 1,
+                        totalTokens: session.totalTokens,
+                        vendorId: session.vendorId,
+                        vendorName: session.vendorName,
+                        serviceId: session.serviceId,
+                        serviceName: session.serviceName,
+                        model: session.model,
+                    });
+                }
+                yield this.saveSessions(keyId, sessions);
+            }));
+        });
+    }
+    /** 获取密钥的会话列表（支持过滤+分页） */
+    getSessions(keyId, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = yield this.loadSessions(keyId);
+            // 过滤
+            let filtered = sessions;
+            if (options.targetType) {
+                filtered = filtered.filter(s => s.targetType === options.targetType);
+            }
+            if (options.search) {
+                const q = options.search.toLowerCase();
+                filtered = filtered.filter(s => (s.title && s.title.toLowerCase().includes(q)) ||
+                    s.id.toLowerCase().includes(q));
+            }
+            // 按 lastRequestAt 降序
+            filtered.sort((a, b) => b.lastRequestAt - a.lastRequestAt);
+            const total = filtered.length;
+            const offset = (options.page - 1) * options.pageSize;
+            const data = filtered.slice(offset, offset + options.pageSize);
+            return { data, total };
+        });
+    }
+    /** 获取密钥的会话总数 */
+    getSessionsCount(keyId, targetType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = yield this.loadSessions(keyId);
+            if (!targetType)
+                return sessions.length;
+            return sessions.filter(s => s.targetType === targetType).length;
+        });
+    }
+    /** 获取单个会话 */
+    getSession(keyId, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = yield this.loadSessions(keyId);
+            return sessions.find(s => s.id === sessionId) || null;
+        });
+    }
+    /** 删除单个会话 */
+    deleteSession(keyId, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let deleted = false;
+            yield this.withWriteLock(keyId, () => __awaiter(this, void 0, void 0, function* () {
+                const sessions = yield this.loadSessions(keyId);
+                const index = sessions.findIndex(s => s.id === sessionId);
+                if (index === -1)
+                    return;
+                sessions.splice(index, 1);
+                deleted = true;
+                yield this.saveSessions(keyId, sessions);
+            }));
+            return deleted;
+        });
+    }
+    /** 清空密钥的所有会话 */
+    clearSessions(keyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withWriteLock(keyId, () => __awaiter(this, void 0, void 0, function* () {
+                this.cache.set(keyId, []);
+                yield this.saveSessions(keyId, []);
+            }));
+        });
+    }
+    // ---- helpers ----
+    getKeySessionDir(keyId) {
+        return path_1.default.join(this.dataPath, 'key-sessions', keyId);
+    }
+    getKeySessionFilePath(keyId) {
+        return path_1.default.join(this.getKeySessionDir(keyId), 'sessions.json');
+    }
+    loadSessions(keyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cache.has(keyId)) {
+                return this.cache.get(keyId);
+            }
+            try {
+                const filePath = this.getKeySessionFilePath(keyId);
+                const data = yield promises_1.default.readFile(filePath, 'utf-8');
+                const sessions = JSON.parse(data);
+                this.cache.set(keyId, sessions);
+                return sessions;
+            }
+            catch (_a) {
+                const sessions = [];
+                this.cache.set(keyId, sessions);
+                return sessions;
+            }
+        });
+    }
+    saveSessions(keyId, sessions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cache.set(keyId, sessions);
+            const dir = this.getKeySessionDir(keyId);
+            yield promises_1.default.mkdir(dir, { recursive: true });
+            const filePath = this.getKeySessionFilePath(keyId);
+            const tmpPath = filePath + '.tmp';
+            yield promises_1.default.writeFile(tmpPath, JSON.stringify(sessions, null, 2), 'utf-8');
+            yield promises_1.default.rename(tmpPath, filePath);
+        });
+    }
+    withWriteLock(keyId, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 等待现有写入完成
+            while (this.writeLocks.has(keyId)) {
+                yield this.writeLocks.get(keyId);
+            }
+            const writePromise = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield fn();
+                }
+                finally {
+                    this.writeLocks.delete(keyId);
+                }
+            }))();
+            this.writeLocks.set(keyId, writePromise);
+            yield writePromise;
+        });
+    }
+}
+exports.KeySessionTracker = KeySessionTracker;

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

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessKeyManager = void 0;
+/**
+ * AccessKey 管理器
+ * 负责接入密钥的 CRUD 操作
+ */
+const crypto_1 = __importDefault(require("crypto"));
+class AccessKeyManager {
+    constructor() {
+        Object.defineProperty(this, "keys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        /** apiKeyHash → AccessKey 索引，用于 O(1) 查找 */
+        Object.defineProperty(this, "hashIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /** 从持久化数据加载 */
+    load(data) {
+        this.keys = data;
+        this.rebuildIndex();
+    }
+    /** 导出用于持久化 */
+    dump() {
+        return this.keys;
+    }
+    /** 重建内存索引 */
+    rebuildIndex() {
+        this.hashIndex.clear();
+        for (const key of this.keys) {
+            this.hashIndex.set(key.apiKeyHash, key);
+        }
+    }
+    /** 通过 apiKeyHash 查找 AccessKey */
+    findByHash(hash) {
+        return this.hashIndex.get(hash);
+    }
+    /** 通过 apiKey 值查找 AccessKey（计算 hash 后查找） */
+    findByApiKey(apiKey) {
+        const hash = AccessKeyManager.hashApiKey(apiKey);
+        return this.hashIndex.get(hash);
+    }
+    /** 获取所有密钥列表 */
+    list(filters) {
+        let result = this.keys;
+        if (filters === null || filters === void 0 ? void 0 : filters.status) {
+            result = result.filter(k => k.status === filters.status);
+        }
+        if (filters === null || filters === void 0 ? void 0 : filters.policyId) {
+            result = result.filter(k => k.policyId === filters.policyId);
+        }
+        if (filters === null || filters === void 0 ? void 0 : filters.search) {
+            const q = filters.search.toLowerCase();
+            result = result.filter(k => k.name.toLowerCase().includes(q) ||
+                (k.remark && k.remark.toLowerCase().includes(q)));
+        }
+        return result;
+    }
+    /** 获取密钥详情 */
+    get(id) {
+        return this.keys.find(k => k.id === id);
+    }
+    /** 创建密钥 */
+    create(data) {
+        const apiKey = AccessKeyManager.generateApiKey();
+        const apiKeyHash = AccessKeyManager.hashApiKey(apiKey);
+        const now = Date.now();
+        const key = {
+            id: `key_${crypto_1.default.randomUUID().replace(/-/g, '').slice(0, 12)}`,
+            name: data.name,
+            remark: data.remark,
+            apiKey,
+            apiKeyHash,
+            policyId: data.policyId,
+            status: 'active',
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.keys.push(key);
+        this.hashIndex.set(apiKeyHash, key);
+        return { key, apiKey };
+    }
+    /** 更新密钥 */
+    update(id, data) {
+        const key = this.keys.find(k => k.id === id);
+        if (!key)
+            return null;
+        if (data.name !== undefined)
+            key.name = data.name;
+        if (data.remark !== undefined)
+            key.remark = data.remark;
+        if (data.policyId !== undefined)
+            key.policyId = data.policyId;
+        if (data.status !== undefined)
+            key.status = data.status;
+        key.updatedAt = Date.now();
+        return key;
+    }
+    /** 删除密钥 */
+    delete(id) {
+        const index = this.keys.findIndex(k => k.id === id);
+        if (index === -1)
+            return false;
+        const key = this.keys[index];
+        this.hashIndex.delete(key.apiKeyHash);
+        this.keys.splice(index, 1);
+        return true;
+    }
+    /** 重新生成 API Key */
+    regenerate(id) {
+        const key = this.keys.find(k => k.id === id);
+        if (!key)
+            return null;
+        // 移除旧索引
+        this.hashIndex.delete(key.apiKeyHash);
+        // 生成新的
+        const apiKey = AccessKeyManager.generateApiKey();
+        const apiKeyHash = AccessKeyManager.hashApiKey(apiKey);
+        key.apiKey = apiKey;
+        key.apiKeyHash = apiKeyHash;
+        key.updatedAt = Date.now();
+        // 添加新索引
+        this.hashIndex.set(apiKeyHash, key);
+        return { apiKey, apiKeyHash };
+    }
+    /** 批量更新状态 */
+    batchUpdateStatus(keyIds, status) {
+        let count = 0;
+        for (const id of keyIds) {
+            const key = this.keys.find(k => k.id === id);
+            if (key) {
+                key.status = status;
+                key.updatedAt = Date.now();
+                count++;
+            }
+        }
+        return count;
+    }
+    /** 批量绑定策略 */
+    batchBindPolicy(keyIds, policyId) {
+        let count = 0;
+        for (const id of keyIds) {
+            const key = this.keys.find(k => k.id === id);
+            if (key) {
+                key.policyId = policyId;
+                key.updatedAt = Date.now();
+                count++;
+            }
+        }
+        return count;
+    }
+    /** 批量删除 */
+    batchDelete(keyIds) {
+        let count = 0;
+        for (const id of keyIds) {
+            const index = this.keys.findIndex(k => k.id === id);
+            if (index !== -1) {
+                const key = this.keys[index];
+                this.hashIndex.delete(key.apiKeyHash);
+                this.keys.splice(index, 1);
+                count++;
+            }
+        }
+        return count;
+    }
+    /** 更新最后活跃时间 */
+    updateLastActive(id) {
+        const key = this.keys.find(k => k.id === id);
+        if (key) {
+            key.lastActiveAt = Date.now();
+        }
+    }
+    /** 获取使用指定策略的密钥数量 */
+    countByPolicyId(policyId) {
+        return this.keys.filter(k => k.policyId === policyId).length;
+    }
+    /** 获取使用指定策略的密钥列表 */
+    listByPolicyId(policyId) {
+        return this.keys.filter(k => k.policyId === policyId);
+    }
+    /** 掩码化 API Key */
+    static maskApiKey(apiKey) {
+        if (apiKey.length <= 8)
+            return 'sk_****';
+        return apiKey.slice(0, 4) + '****' + apiKey.slice(-4);
+    }
+    /** 生成 sk_ 前缀的 API Key */
+    static generateApiKey() {
+        return 'sk_' + crypto_1.default.randomBytes(24).toString('hex');
+    }
+    /** 计算 API Key 的哈希值 */
+    static hashApiKey(apiKey) {
+        return crypto_1.default.createHash('sha256').update(apiKey).digest('hex').slice(0, 16);
+    }
+}
+exports.AccessKeyManager = AccessKeyManager;

package/dist/server/access-keys/policy-manager.js

@@ -0,0 +1,144 @@
+"use strict";
+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.PolicyManager = void 0;
+/**
+ * Policy 策略管理器
+ * 负责策略的 CRUD 操作
+ */
+const crypto_1 = __importDefault(require("crypto"));
+class PolicyManager {
+    constructor() {
+        Object.defineProperty(this, "policies", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    /** 从持久化数据加载 */
+    load(data) {
+        this.policies = data;
+    }
+    /** 导出用于持久化 */
+    dump() {
+        return this.policies;
+    }
+    /** 获取所有策略 */
+    list() {
+        return this.policies;
+    }
+    /** 获取策略详情 */
+    get(id) {
+        return this.policies.find(p => p.id === id);
+    }
+    /** 创建策略 */
+    create(data) {
+        const now = Date.now();
+        const policy = Object.assign(Object.assign({}, data), { id: `pol_${crypto_1.default.randomUUID().replace(/-/g, '').slice(0, 12)}`, createdAt: now, updatedAt: now });
+        this.policies.push(policy);
+        return policy;
+    }
+    /** 更新策略 */
+    update(id, data) {
+        const policy = this.policies.find(p => p.id === id);
+        if (!policy)
+            return null;
+        // 更新字段
+        const updatableFields = [
+            'name', 'description', 'routeId',
+            'dailyTokenLimit', 'weeklyTokenLimit', 'monthlyTokenLimit',
+            'customTokenLimit', 'customTokenResetHours',
+            'dailyRequestLimit', 'weeklyRequestLimit', 'monthlyRequestLimit',
+            'customRequestLimit', 'customRequestResetHours',
+            'rpmLimit', 'concurrentLimit',
+            'allowedModels', 'blockedModels',
+        ];
+        for (const field of updatableFields) {
+            if (data[field] !== undefined) {
+                policy[field] = data[field];
+            }
+        }
+        policy.updatedAt = Date.now();
+        return policy;
+    }
+    /** 删除策略 */
+    delete(id) {
+        const index = this.policies.findIndex(p => p.id === id);
+        if (index === -1)
+            return false;
+        this.policies.splice(index, 1);
+        return true;
+    }
+    /** 复制策略 */
+    duplicate(id) {
+        const source = this.policies.find(p => p.id === id);
+        if (!source)
+            return null;
+        const { id: _id, createdAt: _ca, updatedAt: _ua } = source, rest = __rest(source, ["id", "createdAt", "updatedAt"]);
+        return this.create(Object.assign(Object.assign({}, rest), { name: `${source.name} (副本)` }));
+    }
+    /** 获取策略预览信息 */
+    getPreview(id) {
+        const policy = this.policies.find(p => p.id === id);
+        if (!policy)
+            return null;
+        return { policy };
+    }
+    /** 获取预置策略模板 */
+    static getTemplates() {
+        return [
+            {
+                name: '不限策略',
+                description: '不限制任何用量，适合信任用户',
+                config: { name: '不限策略' },
+            },
+            {
+                name: '轻度限制',
+                description: '月 Token 限额 5000k，日请求 500 次',
+                config: {
+                    name: '轻度限制',
+                    monthlyTokenLimit: 5000,
+                    dailyRequestLimit: 500,
+                },
+            },
+            {
+                name: '中度限制',
+                description: '月 Token 限额 2000k，日 Token 限额 200k，日请求 200 次，RPM 10',
+                config: {
+                    name: '中度限制',
+                    dailyTokenLimit: 200,
+                    monthlyTokenLimit: 2000,
+                    dailyRequestLimit: 200,
+                    rpmLimit: 10,
+                },
+            },
+            {
+                name: '严格限制',
+                description: '月 Token 限额 500k，日 Token 限额 50k，日请求 50 次，RPM 5，并发 2',
+                config: {
+                    name: '严格限制',
+                    dailyTokenLimit: 50,
+                    monthlyTokenLimit: 500,
+                    dailyRequestLimit: 50,
+                    rpmLimit: 5,
+                    concurrentLimit: 2,
+                },
+            },
+        ];
+    }
+}
+exports.PolicyManager = PolicyManager;