aicodeswitch 2.0.10 → 2.0.11

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.11 (2026-02-03)
+
 ### 2.0.10 (2026-02-03)
 
 ### 2.0.9 (2026-02-02)

package/CLAUDE.md

@@ -139,7 +139,7 @@ aicos version            # Show current version information
   - `image-understanding`: Requests with image content
   - `thinking`: Requests with reasoning/thinking signals
   - `long-context`: Requests with large context (≥12000 chars or ≥8000 max tokens)
-  - `background`: Background/priority requests
+  - `background`: Background/priority requests, including `/count_tokens` endpoint requests and token counting requests with `{"role": "user", "content": "count"}`
   - `default`: All other requests
 
 ### Request Transformation
@@ -164,6 +164,9 @@ aicos version            # Show current version information
 - Request logs: Detailed API call records with token usage
 - Access logs: System access records
 - Error logs: Error and exception records (includes upstream request information when available)
+- **Data Sanitization**:
+  - Sensitive authentication fields (api_key, authorization, password, secret, etc.) are automatically masked in the UI
+  - Technical fields like `max_tokens`, `input_tokens`, `output_tokens` are NOT masked - they are legitimate API parameters
 - **Session Management**:
   - Tracks user sessions based on session ID (Claude Code: `metadata.user_id`, Codex: `headers.session_id`)
   - Auto-generates session title from first user message content:

package/dist/server/main.js

@@ -25,6 +25,9 @@ const os_1 = __importDefault(require("os"));
 const auth_1 = require("./auth");
 const version_check_1 = require("./version-check");
 const utils_1 = require("./utils");
+const tools_service_1 = require("./tools-service");
+const websocket_service_1 = require("./websocket-service");
+const rules_status_service_1 = require("./rules-status-service");
 const config_metadata_1 = require("./config-metadata");
 const config_1 = require("./config");
 const appDir = path_1.default.join(os_1.default.homedir(), '.aicodeswitch');
@@ -1356,6 +1359,19 @@ ${instruction}
             res.json({ success: false });
         }
     })));
+    // 工具安装检测相关路由
+    app.get('/api/tools/status', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('[API] GET /api/tools/status - 获取工具安装状态');
+        try {
+            const status = yield (0, tools_service_1.getToolsInstallationStatus)();
+            console.log('[API] 工具安装状态:', status);
+            res.json(status);
+        }
+        catch (error) {
+            console.error('[API] 获取工具状态失败:', error);
+            res.status(500).json({ error: '获取工具状态失败' });
+        }
+    })));
 };
 const start = () => __awaiter(void 0, void 0, void 0, function* () {
     fs_1.default.mkdirSync(dataDir, { recursive: true });
@@ -1377,6 +1393,28 @@ const start = () => __awaiter(void 0, void 0, void 0, function* () {
     const server = app.listen(port, host, () => {
         console.log(`Admin server running on http://${host}:${port}`);
     });
+    // 创建 WebSocket 服务器用于工具安装
+    const toolInstallWss = (0, websocket_service_1.createToolInstallationWSServer)();
+    // 创建 WebSocket 服务器用于规则状态
+    const rulesStatusWss = (0, rules_status_service_1.createRulesStatusWSServer)();
+    // 将 WebSocket 服务器附加到 HTTP 服务器
+    server.on('upgrade', (request, socket, head) => {
+        if (request.url === '/api/tools/install') {
+            toolInstallWss.handleUpgrade(request, socket, head, (ws) => {
+                toolInstallWss.emit('connection', ws, request);
+            });
+        }
+        else if (request.url === '/api/rules/status') {
+            rulesStatusWss.handleUpgrade(request, socket, head, (ws) => {
+                rulesStatusWss.emit('connection', ws, request);
+            });
+        }
+        else {
+            socket.destroy();
+        }
+    });
+    console.log(`WebSocket server for tool installation attached to ws://${host}:${port}/api/tools/install`);
+    console.log(`WebSocket server for rules status attached to ws://${host}:${port}/api/rules/status`);
     const shutdown = () => __awaiter(void 0, void 0, void 0, function* () {
         console.log('Shutting down server...');
         dbManager.close();

package/dist/server/proxy-server.js

@@ -51,6 +51,7 @@ const stream_1 = require("stream");
 const crypto_1 = __importDefault(require("crypto"));
 const streaming_1 = require("./transformers/streaming");
 const chunk_collector_1 = require("./transformers/chunk-collector");
+const rules_status_service_1 = require("./rules-status-service");
 const claude_openai_1 = require("./transformers/claude-openai");
 const SUPPORTED_TARGETS = ['claude-code', 'codex'];
 class ProxyServer {
@@ -762,6 +763,10 @@ class ProxyServer {
         const body = req.body;
         if (!body)
             return 'default';
+        // 检查是否为 count_tokens 请求（后台类型）
+        if (req.path.includes('/count_tokens')) {
+            return 'background';
+        }
         const explicitType = this.getExplicitContentType(req, body);
         if (explicitType) {
             return explicitType;
@@ -890,6 +895,17 @@ class ProxyServer {
     }
     hasBackgroundSignal(body) {
         var _a, _b, _c;
+        // 检测 count tokens 请求：messages 只有一条，role 为 "user"，content 为 "count"
+        const messages = body === null || body === void 0 ? void 0 : body.messages;
+        if (Array.isArray(messages) && messages.length === 1) {
+            const firstMessage = messages[0];
+            if ((firstMessage === null || firstMessage === void 0 ? void 0 : firstMessage.role) === 'user' &&
+                ((firstMessage === null || firstMessage === void 0 ? void 0 : firstMessage.content) === 'count' ||
+                    (typeof (firstMessage === null || firstMessage === void 0 ? void 0 : firstMessage.content) === 'string' && firstMessage.content.trim() === 'count'))) {
+                return true;
+            }
+        }
+        // 检测其他后台信号
         const candidates = [
             body === null || body === void 0 ? void 0 : body.background,
             (_a = body === null || body === void 0 ? void 0 : body.metadata) === null || _a === void 0 ? void 0 : _a.background,
@@ -1359,6 +1375,8 @@ class ProxyServer {
             let streamChunksForLog;
             let upstreamRequestForLog;
             let actuallyUsedProxy = false; // 标记是否实际使用了代理
+            // 标记规则正在使用
+            rules_status_service_1.rulesStatusBroadcaster.markRuleInUse(route.id, rule.id);
             const finalizeLog = (statusCode, error) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 if (logged)
@@ -1428,6 +1446,11 @@ class ProxyServer {
                     const totalTokens = (usageForLog.inputTokens || 0) + (usageForLog.outputTokens || 0);
                     if (totalTokens > 0) {
                         this.dbManager.incrementRuleTokenUsage(rule.id, totalTokens);
+                        // 获取更新后的规则数据并广播
+                        const updatedRule = this.dbManager.getRule(rule.id);
+                        if (updatedRule) {
+                            rules_status_service_1.rulesStatusBroadcaster.broadcastUsageUpdate(rule.id, updatedRule.totalTokensUsed || 0, updatedRule.totalRequestsUsed || 0);
+                        }
                     }
                 }
                 // 更新规则的请求次数（只在成功请求时更新）
@@ -1437,6 +1460,11 @@ class ProxyServer {
                     // 检查是否是重复请求（如网络重试）
                     if (!this.isRequestProcessed(requestHash)) {
                         this.dbManager.incrementRuleRequestCount(rule.id, 1);
+                        // 获取更新后的规则数据并广播
+                        const updatedRule = this.dbManager.getRule(rule.id);
+                        if (updatedRule) {
+                            rules_status_service_1.rulesStatusBroadcaster.broadcastUsageUpdate(rule.id, updatedRule.totalTokensUsed || 0, updatedRule.totalRequestsUsed || 0);
+                        }
                     }
                     // 定期清理过期缓存
                     if (Math.random() < 0.01) { // 1%概率清理，避免每次都清理
@@ -1698,7 +1726,6 @@ class ProxyServer {
                     });
                     res.on('finish', () => {
                         streamChunksForLog = eventCollector.getChunks();
-                        console.log('[Proxy] Default stream request finished, collected chunks:', (streamChunksForLog === null || streamChunksForLog === void 0 ? void 0 : streamChunksForLog.length) || 0);
                         // 尝试从event collector中提取usage信息
                         const extractedUsage = eventCollector.extractUsage();
                         if (extractedUsage) {

package/dist/server/rules-status-service.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RulesStatusWS = exports.rulesStatusBroadcaster = exports.RulesStatusBroadcaster = void 0;
+exports.createRulesStatusWSServer = createRulesStatusWSServer;
+// @ts-ignore - ws 类型声明可能需要手动安装 @types/ws
+const ws_1 = require("ws");
+/**
+ * 规则状态 WebSocket 连接管理
+ */
+class RulesStatusWS {
+    constructor(ws, req) {
+        Object.defineProperty(this, "ws", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ws = ws;
+        console.log(`[RulesStatusWS] 新的 WebSocket 连接: ${req.socket.remoteAddress}`);
+        this.ws.on('close', () => {
+            console.log(`[RulesStatusWS] WebSocket 连接关闭`);
+        });
+        this.ws.on('error', (err) => {
+            console.error(`[RulesStatusWS] WebSocket 错误:`, err);
+        });
+    }
+    /**
+     * 发送规则状态消息到客户端
+     */
+    sendStatus(message) {
+        if (this.ws.readyState === ws_1.WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+}
+exports.RulesStatusWS = RulesStatusWS;
+/**
+ * 规则状态广播服务
+ * 管理所有连接的客户端，负责广播规则使用状态
+ */
+class RulesStatusBroadcaster {
+    constructor() {
+        Object.defineProperty(this, "clients", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "activeRules", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        }); // routeId -> Set of ruleIds
+        Object.defineProperty(this, "ruleTimeouts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "INACTIVITY_TIMEOUT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 30000
+        }); // 30秒无活动后标记为空闲
+    }
+    /**
+     * 添加客户端
+     */
+    addClient(client) {
+        this.clients.add(client);
+        console.log(`[RulesStatusBroadcaster] 客户端已连接，当前客户端数: ${this.clients.size}`);
+    }
+    /**
+     * 移除客户端
+     */
+    removeClient(client) {
+        this.clients.delete(client);
+        console.log(`[RulesStatusBroadcaster] 客户端已断开，当前客户端数: ${this.clients.size}`);
+    }
+    /**
+     * 标记规则正在使用
+     */
+    markRuleInUse(routeId, ruleId) {
+        // 添加到活动规则集合
+        if (!this.activeRules.has(routeId)) {
+            this.activeRules.set(routeId, new Set());
+        }
+        this.activeRules.get(routeId).add(ruleId);
+        // 清除之前的超时定时器
+        const timeoutKey = `${routeId}:${ruleId}`;
+        const existingTimeout = this.ruleTimeouts.get(timeoutKey);
+        if (existingTimeout) {
+            clearTimeout(existingTimeout);
+        }
+        // 广播状态
+        this.broadcastStatus({
+            type: 'rule_status',
+            data: {
+                ruleId,
+                status: 'in_use',
+                timestamp: Date.now(),
+            },
+        });
+        // 设置超时定时器，如果30秒内没有新活动则标记为空闲
+        const timeout = setTimeout(() => {
+            this.markRuleIdle(routeId, ruleId);
+        }, this.INACTIVITY_TIMEOUT);
+        this.ruleTimeouts.set(timeoutKey, timeout);
+    }
+    /**
+     * 标记规则空闲
+     */
+    markRuleIdle(routeId, ruleId) {
+        const timeoutKey = `${routeId}:${ruleId}`;
+        // 清除超时定时器
+        const existingTimeout = this.ruleTimeouts.get(timeoutKey);
+        if (existingTimeout) {
+            clearTimeout(existingTimeout);
+            this.ruleTimeouts.delete(timeoutKey);
+        }
+        // 从活动规则集合中移除
+        if (this.activeRules.has(routeId)) {
+            this.activeRules.get(routeId).delete(ruleId);
+            if (this.activeRules.get(routeId).size === 0) {
+                this.activeRules.delete(routeId);
+            }
+        }
+        // 广播空闲状态
+        this.broadcastStatus({
+            type: 'rule_status',
+            data: {
+                ruleId,
+                status: 'idle',
+                timestamp: Date.now(),
+            },
+        });
+    }
+    /**
+     * 广播规则使用量更新
+     */
+    broadcastUsageUpdate(ruleId, totalTokensUsed, totalRequestsUsed) {
+        this.broadcastStatus({
+            type: 'rule_status',
+            data: {
+                ruleId,
+                status: 'in_use',
+                totalTokensUsed,
+                totalRequestsUsed,
+                timestamp: Date.now(),
+            },
+        });
+    }
+    /**
+     * 广播消息到所有客户端
+     */
+    broadcastStatus(message) {
+        const deadClients = [];
+        this.clients.forEach((client) => {
+            try {
+                client.sendStatus(message);
+            }
+            catch (error) {
+                console.error('[RulesStatusBroadcaster] 发送消息失败:', error);
+                deadClients.push(client);
+            }
+        });
+        // 清理断开的客户端
+        deadClients.forEach((client) => {
+            this.removeClient(client);
+        });
+    }
+    /**
+     * 获取当前活动的规则列表
+     */
+    getActiveRules() {
+        return new Map(this.activeRules);
+    }
+}
+exports.RulesStatusBroadcaster = RulesStatusBroadcaster;
+// 全局单例
+exports.rulesStatusBroadcaster = new RulesStatusBroadcaster();
+/**
+ * 创建 WebSocket 服务器用于规则状态
+ */
+function createRulesStatusWSServer() {
+    const wss = new ws_1.WebSocketServer({ noServer: true });
+    wss.on('connection', (ws, req) => {
+        const wsHandler = new RulesStatusWS(ws, req);
+        exports.rulesStatusBroadcaster.addClient(wsHandler);
+        ws.on('close', () => {
+            exports.rulesStatusBroadcaster.removeClient(wsHandler);
+        });
+    });
+    return wss;
+}

package/dist/server/tools-service.js

@@ -0,0 +1,202 @@
+"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.getToolsInstallationStatus = getToolsInstallationStatus;
+exports.installTool = installTool;
+const child_process_1 = require("child_process");
+const os_1 = __importDefault(require("os"));
+/**
+ * 检测工具是否已安装
+ */
+function checkToolInstalled(toolName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(`[ToolsService] 开始检测工具: ${toolName}`);
+        return new Promise((resolve) => {
+            var _a, _b;
+            const command = toolName === 'claude-code' ? 'claude' : 'codex';
+            console.log(`[ToolsService] 执行命令: ${command} --version`);
+            const child = (0, child_process_1.spawn)(command, ['--version'], {
+                shell: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                stdout += data.toString();
+                console.log(`[ToolsService] ${toolName} stdout:`, data.toString());
+            });
+            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+                stderr += data.toString();
+                console.log(`[ToolsService] ${toolName} stderr:`, data.toString());
+            });
+            child.on('close', (code) => {
+                console.log(`[ToolsService] ${toolName} 进程退出，退出码: ${code}`);
+                if (code === 0) {
+                    // 尝试从输出中提取版本号
+                    const versionMatch = stdout.match(/(\d+\.\d+\.\d+)/) || stderr.match(/(\d+\.\d+\.\d+)/);
+                    resolve({
+                        installed: true,
+                        version: versionMatch ? versionMatch[1] : 'unknown',
+                    });
+                }
+                else {
+                    resolve({ installed: false });
+                }
+            });
+            child.on('error', (err) => {
+                console.log(`[ToolsService] ${toolName} 检测出错:`, err);
+                resolve({ installed: false });
+            });
+            // 10秒超时
+            setTimeout(() => {
+                console.log(`[ToolsService] ${toolName} 检测超时`);
+                child.kill();
+                resolve({ installed: false });
+            }, 10000);
+        });
+    });
+}
+/**
+ * 获取工具的安装命令
+ */
+function getInstallCommand(toolName) {
+    const platform = os_1.default.platform();
+    const tool = toolName === 'claude-code' ? '@anthropic-ai/claude-code' : '@openai/codex';
+    if (platform === 'win32') {
+        return `npm install -g ${tool}`;
+    }
+    else {
+        // macOS 和 Linux 需要 sudo
+        return `sudo npm install -g ${tool}`;
+    }
+}
+/**
+ * 检测所有工具的安装状态
+ */
+function getToolsInstallationStatus() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [claudeCodeStatus, codexStatus] = yield Promise.all([
+            checkToolInstalled('claude-code'),
+            checkToolInstalled('codex'),
+        ]);
+        return {
+            claudeCode: Object.assign(Object.assign({}, claudeCodeStatus), { installCommand: claudeCodeStatus.installed ? undefined : getInstallCommand('claude-code') }),
+            codex: Object.assign(Object.assign({}, codexStatus), { installCommand: codexStatus.installed ? undefined : getInstallCommand('codex') }),
+        };
+    });
+}
+/**
+ * 执行工具安装
+ */
+function installTool(toolName, callbacks) {
+    var _a, _b;
+    const command = getInstallCommand(toolName);
+    const platform = os_1.default.platform();
+    console.log(`[ToolsService] ========== 开始安装 ${toolName} ==========`);
+    console.log(`[ToolsService] 操作系统: ${platform}`);
+    console.log(`[ToolsService] 安装命令: ${command}`);
+    // 立即发送启动消息，让前端快速进入 terminal 界面
+    callbacks.onData(`\n========== 开始安装 ${toolName} ==========\n`);
+    callbacks.onData(`操作系统: ${platform}\n`);
+    callbacks.onData(`执行命令: ${command}\n`);
+    callbacks.onData(`进程启动中...\n\n`);
+    // 在 macOS/Linux 上，需要使用 sudo 并且可能需要输入密码
+    // 在 Windows 上直接使用 cmd 执行 npm 命令
+    let child;
+    if (platform === 'win32') {
+        // Windows: 使用 cmd.exe 执行命令
+        console.log(`[ToolsService] Windows 环境，使用 cmd.exe`);
+        child = (0, child_process_1.spawn)('cmd.exe', ['/c', command], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: false,
+            windowsHide: true, // 隐藏命令行窗口
+        });
+    }
+    else {
+        // Unix: 使用 sh 执行命令
+        console.log(`[ToolsService] Unix 环境，使用 sh`);
+        child = (0, child_process_1.spawn)('sh', ['-c', command], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: false,
+        });
+    }
+    console.log(`[ToolsService] 子进程 PID: ${child.pid}`);
+    // 立即发送进程信息
+    callbacks.onData(`子进程已创建 (PID: ${child.pid})\n`);
+    callbacks.onData(`等待 npm 输出...\n\n`);
+    // 设置超时：30分钟后自动终止
+    const timeout = 30 * 60 * 1000;
+    const timeoutHandle = setTimeout(() => {
+        console.error(`[ToolsService] ${toolName} 安装超时 (${timeout}ms)，终止进程`);
+        child.kill('SIGTERM');
+        callbacks.onError(`\n安装超时 (${timeout / 60000} 分钟)，请检查网络连接或手动执行命令：\n${command}\n`);
+    }, timeout);
+    let hasReceivedData = false;
+    (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+        const output = data.toString();
+        if (!hasReceivedData) {
+            console.log(`[ToolsService] ${toolName} 首次收到 stdout 数据`);
+            hasReceivedData = true;
+        }
+        console.log(`[ToolsService] ${toolName} stdout:`, output.slice(0, 200)); // 只记录前200字符
+        callbacks.onData(output);
+    });
+    (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+        const output = data.toString();
+        if (!hasReceivedData) {
+            console.log(`[ToolsService] ${toolName} 首次收到 stderr 数据`);
+            hasReceivedData = true;
+        }
+        console.log(`[ToolsService] ${toolName} stderr:`, output.slice(0, 200)); // 只记录前200字符
+        callbacks.onError(output);
+    });
+    child.on('close', (code) => {
+        clearTimeout(timeoutHandle);
+        console.log(`[ToolsService] ${toolName} 安装进程关闭，退出码: ${code}`);
+        if (code === 0) {
+            callbacks.onData(`\n========== 安装完成 ==========\n`);
+        }
+        else if (code === null) {
+            callbacks.onError(`\n========== 安装被终止 ==========\n`);
+        }
+        else {
+            callbacks.onError(`\n========== 安装失败 (退出码: ${code}) ==========\n`);
+        }
+        callbacks.onClose(code);
+    });
+    child.on('error', (err) => {
+        clearTimeout(timeoutHandle);
+        console.error(`[ToolsService] ${toolName} 安装进程错误:`, err);
+        callbacks.onError(`启动安装进程失败: ${err.message}\n`);
+        callbacks.onError(`错误详情: ${err}\n`);
+        callbacks.onClose(null);
+    });
+    // 处理进程退出信号
+    child.on('exit', (_code, signal) => {
+        clearTimeout(timeoutHandle);
+        if (signal) {
+            console.log(`[ToolsService] ${toolName} 进程被信号终止: ${signal}`);
+            callbacks.onError(`\n安装进程被信号终止: ${signal}\n`);
+        }
+    });
+    // 如果10秒后还没有收到任何数据，发送提示
+    setTimeout(() => {
+        if (!hasReceivedData) {
+            console.log(`[ToolsService] ${toolName} 10秒内未收到输出，发送等待提示`);
+            callbacks.onData(`[提示] 正在连接 npm 服务器，这可能需要一些时间...\n`);
+            callbacks.onData(`[提示] 如果持续无响应，请检查网络连接或 npm 配置\n\n`);
+        }
+    }, 10000);
+    return child;
+}