aicodeswitch 2.0.8 → 2.0.9

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### 2.0.9 (2026-02-02)
+
 ### 2.0.8 (2026-02-02)
 
 ### 2.0.7 (2026-02-02)

package/CLAUDE.md

@@ -165,6 +165,12 @@ aicos version            # Show current version information
 - Access logs: System access records
 - Error logs: Error and exception records
 
+### Usage Limits Auto-Sync
+- **Service-Level Limits**: API services can have token and request count limits configured
+- **Auto-Sync to Rules**: When an API service's usage limits are modified, all rules using that service are automatically updated with the new limits
+- **Inheritance Detection**: When editing a rule, the system detects if the rule's limits match the service's limits and displays them as "inherited" (read-only)
+- **Manual Override**: Rules can be configured with custom limits that differ from the service defaults
+
 ## Development Tips
 
 1. **Environment Variables**: Copy `.env.example` to `.env` and modify as needed

package/bin/stop.js

@@ -18,9 +18,8 @@ const stop = async (options = {}) => {
 
   // 第一步：如果 PID 文件存在，优先通过 PID 文件停止服务器
   if (fs.existsSync(PID_FILE)) {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8'), 10);
     try {
-      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8'), 10);
-
       const processInfo = await getProcessInfo(pid);
       if (!silent) {
         console.log('\n' + chalk.gray(`Process found: ${chalk.white(pid)} (${chalk.gray(processInfo)})`));

package/dist/server/database.js

@@ -515,8 +515,47 @@ class DatabaseManager {
         if (result.changes > 0 && process.env.NODE_ENV === 'development') {
             console.log(`[DB] Updated service ${id}: ${service.name} -> ${service.apiUrl}`);
         }
+        // 如果更新成功，检查是否需要同步更新关联规则的超量限制
+        if (result.changes > 0) {
+            this.syncRulesWithServiceLimits(id, service);
+        }
         return result.changes > 0;
     }
+    /**
+     * 同步更新使用该服务的规则的超量限制
+     * 当API服务的超量限制修改时，自动更新所有使用该服务的规则
+     */
+    syncRulesWithServiceLimits(serviceId, service) {
+        // 获取所有使用该服务的规则
+        const rules = this.db.prepare('SELECT id FROM rules WHERE target_service_id = ?').all(serviceId);
+        if (rules.length === 0) {
+            return; // 没有规则使用此服务，无需同步
+        }
+        const now = Date.now();
+        const ruleIds = rules.map(r => r.id);
+        // Token超量限制同步
+        if (service.enableTokenLimit !== undefined || service.tokenLimit !== undefined ||
+            service.tokenResetInterval !== undefined || service.tokenResetBaseTime !== undefined) {
+            // 获取当前服务的最新配置
+            const currentService = this.db.prepare('SELECT enable_token_limit, token_limit, token_reset_interval, token_reset_base_time FROM api_services WHERE id = ?').get(serviceId);
+            if (currentService && currentService.enable_token_limit === 1) {
+                // 启用了Token超量限制，同步到所有规则
+                this.db.prepare('UPDATE rules SET token_limit = ?, reset_interval = ?, token_reset_base_time = ?, updated_at = ? WHERE target_service_id = ?').run(currentService.token_limit, currentService.token_reset_interval, currentService.token_reset_base_time, now, serviceId);
+                console.log(`[DB] Synced token limits for ${ruleIds.length} rule(s) using service ${serviceId}`);
+            }
+        }
+        // 请求次数超量限制同步
+        if (service.enableRequestLimit !== undefined || service.requestCountLimit !== undefined ||
+            service.requestResetInterval !== undefined || service.requestResetBaseTime !== undefined) {
+            // 获取当前服务的最新配置
+            const currentService = this.db.prepare('SELECT enable_request_limit, request_count_limit, request_reset_interval, request_reset_base_time FROM api_services WHERE id = ?').get(serviceId);
+            if (currentService && currentService.enable_request_limit === 1) {
+                // 启用了请求次数超量限制，同步到所有规则
+                this.db.prepare('UPDATE rules SET request_count_limit = ?, request_reset_interval = ?, request_reset_base_time = ?, updated_at = ? WHERE target_service_id = ?').run(currentService.request_count_limit, currentService.request_reset_interval, currentService.request_reset_base_time, now, serviceId);
+                console.log(`[DB] Synced request count limits for ${ruleIds.length} rule(s) using service ${serviceId}`);
+            }
+        }
+    }
     deleteAPIService(id) {
         const result = this.db.prepare('DELETE FROM api_services WHERE id = ?').run(id);
         return result.changes > 0;

package/dist/server/main.js

@@ -69,8 +69,8 @@ function getProxyAgent() {
 }
 const app = (0, express_1.default)();
 app.use((0, cors_1.default)());
-app.use(express_1.default.json({ limit: '10mb' }));
-app.use(express_1.default.urlencoded({ extended: true }));
+app.use(express_1.default.json({ limit: 'Infinity' }));
+app.use(express_1.default.urlencoded({ extended: true, limit: 'Infinity' }));
 const asyncHandler = (handler) => (req, res, next) => {
     Promise.resolve(handler(req, res, next)).catch(next);
 };
@@ -1391,6 +1391,16 @@ app.use((err, _req, res, _next) => {
     console.error(err);
     res.status(500).json({ error: err.message || 'Internal server error' });
 });
+// 全局未捕获异常处理 - 防止服务崩溃
+process.on('uncaughtException', (error) => {
+    console.error('[Uncaught Exception] 服务遇到未捕获的异常:', error);
+    console.error('[Uncaught Exception] 堆栈信息:', error.stack);
+    // 不退出进程，继续运行
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[Unhandled Rejection] 服务遇到未处理的 Promise 拒绝:', reason);
+    // 不退出进程，继续运行
+});
 start().catch((error) => {
     console.error('Failed to start server:', error);
     process.exit(1);

package/dist/server/proxy-server.js

@@ -643,8 +643,8 @@ class ProxyServer {
                     // 检查并重置到期的规则
                     this.dbManager.checkAndResetRuleIfNeeded(rule.id);
                     this.dbManager.checkAndResetRequestCountIfNeeded(rule.id);
-                    // 检查token限制
-                    if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit) {
+                    // 检查token限制（tokenLimit单位是k，需要乘以1000转换为实际token数）
+                    if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit * 1000) {
                         continue; // 跳过超限规则
                     }
                     // 检查请求次数限制
@@ -666,8 +666,8 @@ class ProxyServer {
                 // 检查并重置到期的规则
                 this.dbManager.checkAndResetRuleIfNeeded(rule.id);
                 this.dbManager.checkAndResetRequestCountIfNeeded(rule.id);
-                // 检查token限制
-                if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit) {
+                // 检查token限制（tokenLimit单位是k，需要乘以1000转换为实际token数）
+                if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit * 1000) {
                     continue; // 跳过超限规则
                 }
                 // 检查请求次数限制
@@ -687,8 +687,8 @@ class ProxyServer {
                 // 检查并重置到期的规则
                 this.dbManager.checkAndResetRuleIfNeeded(rule.id);
                 this.dbManager.checkAndResetRequestCountIfNeeded(rule.id);
-                // 检查token限制
-                if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit) {
+                // 检查token限制（tokenLimit单位是k，需要乘以1000转换为实际token数）
+                if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit * 1000) {
                     continue; // 跳过超限规则
                 }
                 // 检查请求次数限制
@@ -729,9 +729,9 @@ class ProxyServer {
         // 5. 过滤掉超过限制的规则（仅在有多个候选规则时）
         if (candidates.length > 1) {
             const filteredCandidates = candidates.filter(rule => {
-                // 检查token限制
+                // 检查token限制（tokenLimit单位是k，需要乘以1000转换为实际token数）
                 if (rule.tokenLimit && rule.totalTokensUsed !== undefined) {
-                    if (rule.totalTokensUsed >= rule.tokenLimit) {
+                    if (rule.totalTokensUsed >= rule.tokenLimit * 1000) {
                         return false;
                     }
                 }
@@ -1535,11 +1535,49 @@ class ProxyServer {
                             streamChunksForLog = eventCollector.getChunks();
                             void finalizeLog(res.statusCode);
                         });
-                        (0, stream_1.pipeline)(response.data, parser, eventCollector, converter, serializer, res, (error) => {
+                        // 监听 res 的错误事件
+                        res.on('error', (err) => {
+                            console.error('[Proxy] Response stream error:', err);
+                        });
+                        (0, stream_1.pipeline)(response.data, parser, eventCollector, converter, serializer, res, (error) => __awaiter(this, void 0, void 0, function* () {
                             if (error) {
-                                void finalizeLog(500, error.message);
+                                console.error('[Proxy] Pipeline error for claude-code:', error);
+                                // 记录到错误日志
+                                try {
+                                    yield this.dbManager.addErrorLog({
+                                        timestamp: Date.now(),
+                                        method: req.method,
+                                        path: req.path,
+                                        statusCode: 500,
+                                        errorMessage: error.message || 'Stream processing error',
+                                        errorStack: error.stack,
+                                        requestHeaders: this.normalizeHeaders(req.headers),
+                                        requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                                    });
+                                }
+                                catch (logError) {
+                                    console.error('[Proxy] Failed to log error:', logError);
+                                }
+                                // 尝试向客户端发送错误事件
+                                try {
+                                    if (!res.writableEnded) {
+                                        const errorEvent = `event: error\ndata: ${JSON.stringify({
+                                            type: 'error',
+                                            error: {
+                                                type: 'api_error',
+                                                message: 'Stream processing error occurred'
+                                            }
+                                        })}\n\n`;
+                                        res.write(errorEvent);
+                                        res.end();
+                                    }
+                                }
+                                catch (writeError) {
+                                    console.error('[Proxy] Failed to send error event:', writeError);
+                                }
+                                yield finalizeLog(500, error.message);
                             }
-                        });
+                        }));
                         return;
                     }
                     if (targetType === 'codex' && this.isClaudeSource(sourceType)) {
@@ -1566,17 +1604,55 @@ class ProxyServer {
                             streamChunksForLog = eventCollector.getChunks();
                             void finalizeLog(res.statusCode);
                         });
-                        (0, stream_1.pipeline)(response.data, parser, eventCollector, converter, serializer, res, (error) => {
+                        // 监听 res 的错误事件
+                        res.on('error', (err) => {
+                            console.error('[Proxy] Response stream error:', err);
+                        });
+                        (0, stream_1.pipeline)(response.data, parser, eventCollector, converter, serializer, res, (error) => __awaiter(this, void 0, void 0, function* () {
                             if (error) {
-                                void finalizeLog(500, error.message);
+                                console.error('[Proxy] Pipeline error for codex:', error);
+                                // 记录到错误日志
+                                try {
+                                    yield this.dbManager.addErrorLog({
+                                        timestamp: Date.now(),
+                                        method: req.method,
+                                        path: req.path,
+                                        statusCode: 500,
+                                        errorMessage: error.message || 'Stream processing error',
+                                        errorStack: error.stack,
+                                        requestHeaders: this.normalizeHeaders(req.headers),
+                                        requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                                    });
+                                }
+                                catch (logError) {
+                                    console.error('[Proxy] Failed to log error:', logError);
+                                }
+                                // 尝试向客户端发送错误事件
+                                try {
+                                    if (!res.writableEnded) {
+                                        const errorEvent = `data: ${JSON.stringify({
+                                            error: 'Stream processing error occurred'
+                                        })}\n\n`;
+                                        res.write(errorEvent);
+                                        res.end();
+                                    }
+                                }
+                                catch (writeError) {
+                                    console.error('[Proxy] Failed to send error event:', writeError);
+                                }
+                                yield finalizeLog(500, error.message);
                             }
-                        });
+                        }));
                         return;
                     }
                     // 默认stream处理(无转换)
                     const eventCollector = new chunk_collector_1.SSEEventCollectorTransform();
                     responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
                     this.copyResponseHeaders(responseHeaders, res);
+                    // 监听 res 的错误事件
+                    res.on('error', (err) => {
+                        console.error('[Proxy] Response stream error:', err);
+                    });
                     res.on('finish', () => {
                         streamChunksForLog = eventCollector.getChunks();
                         // 尝试从event collector中提取usage信息
@@ -1586,11 +1662,28 @@ class ProxyServer {
                         }
                         void finalizeLog(res.statusCode);
                     });
-                    (0, stream_1.pipeline)(response.data, eventCollector, res, (error) => {
+                    (0, stream_1.pipeline)(response.data, eventCollector, res, (error) => __awaiter(this, void 0, void 0, function* () {
                         if (error) {
-                            void finalizeLog(500, error.message);
+                            console.error('[Proxy] Pipeline error (default stream):', error);
+                            // 记录到错误日志
+                            try {
+                                yield this.dbManager.addErrorLog({
+                                    timestamp: Date.now(),
+                                    method: req.method,
+                                    path: req.path,
+                                    statusCode: 500,
+                                    errorMessage: error.message || 'Stream processing error',
+                                    errorStack: error.stack,
+                                    requestHeaders: this.normalizeHeaders(req.headers),
+                                    requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                                });
+                            }
+                            catch (logError) {
+                                console.error('[Proxy] Failed to log error:', logError);
+                            }
+                            yield finalizeLog(500, error.message);
                         }
-                    });
+                    }));
                     return;
                 }
                 let responseData = response.data;

package/dist/server/transformers/chunk-collector.js

@@ -8,20 +8,45 @@ const stream_1 = require("stream");
  */
 class ChunkCollectorTransform extends stream_1.Transform {
     constructor() {
-        super();
+        super({ writableObjectMode: true, readableObjectMode: true });
         Object.defineProperty(this, "chunks", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "errorEmitted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.on('error', (err) => {
+            console.error('[ChunkCollectorTransform] Stream error:', err);
+            this.errorEmitted = true;
+        });
     }
     _transform(chunk, _encoding, callback) {
-        // 收集chunk数据
-        this.chunks.push(chunk.toString('utf8'));
-        // 将chunk传递给下一个stream
-        this.push(chunk);
-        callback();
+        if (this.errorEmitted) {
+            callback();
+            return;
+        }
+        try {
+            // 收集chunk数据 - 支持对象和Buffer/string
+            if (typeof chunk === 'object' && chunk !== null && !Buffer.isBuffer(chunk)) {
+                this.chunks.push(JSON.stringify(chunk));
+            }
+            else {
+                this.chunks.push(chunk.toString('utf8'));
+            }
+            // 将chunk传递给下一个stream
+            this.push(chunk);
+            callback();
+        }
+        catch (error) {
+            console.error('[ChunkCollectorTransform] Error in _transform:', error);
+            callback();
+        }
     }
     /**
      * 获取收集的所有chunks
@@ -44,7 +69,7 @@ exports.ChunkCollectorTransform = ChunkCollectorTransform;
  */
 class SSEEventCollectorTransform extends stream_1.Transform {
     constructor() {
-        super();
+        super({ writableObjectMode: true, readableObjectMode: true });
         Object.defineProperty(this, "buffer", {
             enumerable: true,
             configurable: true,
@@ -66,22 +91,82 @@ class SSEEventCollectorTransform extends stream_1.Transform {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "errorEmitted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.on('error', (err) => {
+            console.error('[SSEEventCollectorTransform] Stream error:', err);
+            this.errorEmitted = true;
+        });
     }
     _transform(chunk, _encoding, callback) {
-        this.buffer += chunk.toString('utf8');
-        this.processBuffer();
-        // 将chunk传递给下一个stream
-        this.push(chunk);
-        callback();
+        if (this.errorEmitted) {
+            callback();
+            return;
+        }
+        try {
+            // 如果是对象（来自 SSEParserTransform），先转换为字符串格式进行处理
+            if (typeof chunk === 'object' && chunk !== null) {
+                const sseEvent = chunk;
+                const lines = [];
+                if (sseEvent.event)
+                    lines.push(`event: ${sseEvent.event}`);
+                if (sseEvent.id)
+                    lines.push(`id: ${sseEvent.id}`);
+                if (sseEvent.data !== undefined) {
+                    if (typeof sseEvent.data === 'string') {
+                        lines.push(`data: ${sseEvent.data}`);
+                    }
+                    else {
+                        lines.push(`data: ${JSON.stringify(sseEvent.data)}`);
+                    }
+                }
+                if (lines.length > 0) {
+                    this.currentEvent.rawLines.push(...lines);
+                    if (sseEvent.event)
+                        this.currentEvent.event = sseEvent.event;
+                    if (sseEvent.id)
+                        this.currentEvent.id = sseEvent.id;
+                    if (sseEvent.data !== undefined) {
+                        const dataStr = typeof sseEvent.data === 'string' ? sseEvent.data : JSON.stringify(sseEvent.data);
+                        this.currentEvent.dataLines.push(dataStr);
+                    }
+                    this.flushEvent();
+                }
+                // 将原始对象传递给下一个stream
+                this.push(chunk);
+            }
+            else {
+                // Buffer/string 模式
+                this.buffer += chunk.toString('utf8');
+                this.processBuffer();
+                // 将chunk传递给下一个stream
+                this.push(chunk);
+            }
+            callback();
+        }
+        catch (error) {
+            console.error('[SSEEventCollectorTransform] Error in _transform:', error);
+            callback();
+        }
     }
     _flush(callback) {
-        // 处理剩余的buffer
-        if (this.buffer.trim()) {
-            this.processBuffer();
+        try {
+            // 处理剩余的buffer
+            if (this.buffer.trim()) {
+                this.processBuffer();
+            }
+            // 刷新最后一个事件
+            this.flushEvent();
+            callback();
+        }
+        catch (error) {
+            console.error('[SSEEventCollectorTransform] Error in _flush:', error);
+            callback();
         }
-        // 刷新最后一个事件
-        this.flushEvent();
-        callback();
     }
     processBuffer() {
         const lines = this.buffer.split('\n');