@vrs-soft/wecom-aibot-mcp 1.5.0 → 2.3.0

package/dist/channel-server.test.js

@@ -0,0 +1,324 @@
+/**
+ * Channel MCP Proxy 单元测试
+ * 测试 SSE 消息接收和 notification 发送
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// 模拟 fetch
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+// 模拟 McpServer
+const mockNotification = vi.fn();
+const mockMcpServer = {
+    server: {
+        notification: mockNotification,
+    },
+};
+describe('Channel Server - SSE 消息接收', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockFetch.mockReset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('应该正确建立 SSE 连接', async () => {
+        // 模拟 SSE 响应
+        const mockSSEStream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(new TextEncoder().encode('event: connected\ndata: {"clientId":"test-123","ccId":"test"}\n\n'));
+                controller.close();
+            },
+        });
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            body: mockSSEStream,
+            headers: new Headers({
+                'Content-Type': 'text/event-stream',
+            }),
+        });
+        const response = await fetch('http://127.0.0.1:18963/sse/test-channel');
+        expect(response.ok).toBe(true);
+        expect(response.status).toBe(200);
+    });
+    it('应该正确解析 SSE 消息', async () => {
+        // 模拟 SSE 数据格式
+        const sseData = `event: message\ndata: {"type":"wecom_message","robotName":"CC","ccId":"test-channel","message":{"content":"测试消息","from":"LiuYang"}}\n\n`;
+        const lines = sseData.split('\n');
+        const messages = [];
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6);
+                try {
+                    const msg = JSON.parse(data);
+                    messages.push(msg);
+                }
+                catch (e) {
+                    // 解析失败
+                }
+            }
+        }
+        expect(messages.length).toBe(1);
+        expect(messages[0].type).toBe('wecom_message');
+        expect(messages[0].message.content).toBe('测试消息');
+    });
+    it('应该发送正确的 notification 格式', async () => {
+        // 模拟接收到的 SSE 消息
+        const sseMessage = {
+            type: 'wecom_message',
+            robotName: 'CC',
+            ccId: 'test-channel',
+            message: {
+                content: '你好',
+                from: 'LiuYang',
+                chatid: 'LiuYang',
+                chattype: 'single',
+                time: '2026-04-12T16:00:00.000Z',
+            },
+        };
+        // 构造 notification
+        const notification = {
+            method: 'notifications/claude/channel',
+            params: {
+                type: sseMessage.type,
+                content: sseMessage,
+            },
+        };
+        // 验证 notification 格式
+        expect(notification.method).toBe('notifications/claude/channel');
+        expect(notification.params.type).toBe('wecom_message');
+        expect(notification.params.content.message.content).toBe('你好');
+        // 模拟发送 notification
+        mockMcpServer.server.notification(notification);
+        expect(mockNotification).toHaveBeenCalledOnce();
+        expect(mockNotification).toHaveBeenCalledWith(notification);
+    });
+    it('应该处理多条 SSE 消息', async () => {
+        // 模拟多条 SSE 消息
+        const sseData = `
+event: message
+data: {"type":"wecom_message","message":{"content":"消息1"}}
+
+event: message
+data: {"type":"wecom_message","message":{"content":"消息2"}}
+
+`;
+        const lines = sseData.split('\n');
+        const messages = [];
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6);
+                try {
+                    messages.push(JSON.parse(data));
+                }
+                catch (e) { }
+            }
+        }
+        expect(messages.length).toBe(2);
+        expect(messages[0].message.content).toBe('消息1');
+        expect(messages[1].message.content).toBe('消息2');
+    });
+    it('应该处理 SSE 连接失败', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 404,
+        });
+        const response = await fetch('http://127.0.0.1:18963/sse/invalid-ccid');
+        expect(response.ok).toBe(false);
+        expect(response.status).toBe(404);
+    });
+    it('应该处理 SSE 流结束', async () => {
+        // 模拟 SSE 流正常结束
+        const mockSSEStream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(new TextEncoder().encode('event: connected\ndata: {"status":"ok"}\n\n'));
+                controller.close(); // 流结束
+            },
+        });
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            body: mockSSEStream,
+        });
+        const response = await fetch('http://127.0.0.1:18963/sse/test');
+        const reader = response.body?.getReader();
+        if (reader) {
+            const { done, value } = await reader.read();
+            expect(done).toBe(false); // 第一条消息
+            const { done: done2 } = await reader.read();
+            expect(done2).toBe(true); // 流结束
+        }
+    });
+});
+describe('Channel Server - HTTP MCP 转发', () => {
+    it('应该正确初始化 HTTP MCP session', async () => {
+        // 模拟 HTTP MCP initialize 响应
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            headers: new Headers({
+                'mcp-session-id': 'session-test-123',
+            }),
+        });
+        const response = await fetch('http://127.0.0.1:18963/mcp', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'initialize',
+                params: {
+                    protocolVersion: '2024-11-05',
+                    capabilities: {},
+                    clientInfo: { name: 'channel-proxy', version: '1.0' },
+                },
+                id: 1,
+            }),
+        });
+        const sessionId = response.headers.get('mcp-session-id');
+        expect(sessionId).toBe('session-test-123');
+    });
+    it('应该正确转发工具调用请求', async () => {
+        // 模拟 HTTP MCP tools/call 响应
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve('data: {"result":{"content":[{"type":"text","text":"消息已发送"}]}}\n\n'),
+        });
+        const response = await fetch('http://127.0.0.1:18963/mcp', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'mcp-session-id': 'session-test-123',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'tools/call',
+                params: {
+                    name: 'send_message',
+                    arguments: {
+                        content: '测试消息',
+                        cc_id: 'test-channel',
+                    },
+                },
+                id: 2,
+            }),
+        });
+        expect(response.ok).toBe(true);
+    });
+});
+describe('Channel Server - Notification 转发测试', () => {
+    it('应该正确转发 SSE 消息到 Claude Code notification', async () => {
+        // 模拟完整的 SSE → Notification 流程
+        // 1. SSE 消息数据
+        const sseRawData = `event: message\ndata: {"type":"wecom_message","robotName":"CC","ccId":"test-channel","message":{"content":"你好","from":"LiuYang","chatid":"LiuYang","chattype":"single","time":"2026-04-12T16:00:00.000Z"}}\n\n`;
+        // 2. 解析 SSE 数据
+        const lines = sseRawData.split('\n');
+        let parsedMessage = null;
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6);
+                parsedMessage = JSON.parse(data);
+                break;
+            }
+        }
+        expect(parsedMessage).not.toBeNull();
+        expect(parsedMessage.type).toBe('wecom_message');
+        // 3. 构造 notification
+        const notification = {
+            method: 'notifications/claude/channel',
+            params: {
+                type: parsedMessage.type,
+                content: parsedMessage,
+            },
+        };
+        // 4. 模拟发送 notification
+        mockMcpServer.server.notification(notification);
+        expect(mockNotification).toHaveBeenCalledOnce();
+        expect(mockNotification).toHaveBeenCalledWith(expect.objectContaining({
+            method: 'notifications/claude/channel',
+            params: expect.objectContaining({
+                type: 'wecom_message',
+                content: expect.objectContaining({
+                    message: expect.objectContaining({
+                        content: '你好',
+                    }),
+                }),
+            }),
+        }));
+    });
+    it('notification 应该包含完整的消息信息', async () => {
+        // 测试 notification 内容完整性
+        const fullMessage = {
+            type: 'wecom_message',
+            robotName: 'CC',
+            ccId: 'test-channel',
+            message: {
+                content: '完整测试消息',
+                from: 'LiuYang',
+                chatid: 'LiuYang',
+                chattype: 'single',
+                time: '2026-04-12T17:00:00.000Z',
+            },
+        };
+        const notification = {
+            method: 'notifications/claude/channel',
+            params: {
+                type: fullMessage.type,
+                content: fullMessage,
+            },
+        };
+        // 验证所有字段都存在
+        expect(notification.params.content.robotName).toBe('CC');
+        expect(notification.params.content.message.from).toBe('LiuYang');
+        expect(notification.params.content.message.chattype).toBe('single');
+    });
+    it('应该处理不同类型的 SSE 消息', async () => {
+        // 测试不同消息类型
+        const messageTypes = [
+            { type: 'wecom_message', expected: 'wecom_message' },
+            { type: 'approval_request', expected: 'approval_request' },
+            { type: 'connection_event', expected: 'connection_event' },
+        ];
+        for (const { type, expected } of messageTypes) {
+            const notification = {
+                method: 'notifications/claude/channel',
+                params: {
+                    type: type,
+                    content: { type },
+                },
+            };
+            expect(notification.params.type).toBe(expected);
+        }
+    });
+    it('应该在 mcpServer 为 null 时不发送 notification', async () => {
+        // 清除之前的 mock 调用
+        mockNotification.mockClear();
+        // 测试 mcpServer 未初始化的情况
+        // 当 mcpServer 为 null 时，代码会跳过 notification 发送
+        // 这里验证不会调用 mockNotification
+        // 预期不会调用 notification
+        expect(mockNotification).not.toHaveBeenCalled();
+    });
+    it('应该正确处理 SSE chunk 分片', async () => {
+        // 测试 SSE 数据分片到达的情况
+        const chunk1 = 'event: message\ndata: ';
+        const chunk2 = '{"type":"wecom_message","message":{"content":"分片测试"}}';
+        const chunk3 = '\n\n';
+        // 合并分片
+        const fullChunk = chunk1 + chunk2 + chunk3;
+        const lines = fullChunk.split('\n');
+        let parsedMessage = null;
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6);
+                try {
+                    parsedMessage = JSON.parse(data);
+                }
+                catch (e) {
+                    // 可能是不完整的 JSON
+                }
+            }
+        }
+        expect(parsedMessage).not.toBeNull();
+        expect(parsedMessage.message.content).toBe('分片测试');
+    });
+});

package/dist/client-pool.js

@@ -9,6 +9,7 @@
  * - 支持多机器人配置
  */
 import { WecomClient } from './client.js';
+import { logger } from './logger.js';
 // ClientPool 存储
 const clientPool = new Map();
 // key: projectDir
@@ -38,7 +39,7 @@ export function getOrCreateClient(projectDir, config) {
         // 存入 pool
         clientPool.set(projectDir, client);
         configCache.set(projectDir, config);
-        console.log(`[client-pool] 已创建 client: ${projectDir}`);
+        logger.log(`[client-pool] 已创建 client: ${projectDir}`);
     }
     return client;
 }
@@ -97,7 +98,7 @@ export function removeClient(projectDir) {
     if (client) {
         client.disconnect();
         clientPool.delete(projectDir);
-        console.log(`[client-pool] 已移除 client: ${projectDir}`);
+        logger.log(`[client-pool] 已移除 client: ${projectDir}`);
     }
 }
 /**
@@ -109,7 +110,7 @@ export function clearAll() {
     }
     clientPool.clear();
     configCache.clear();
-    console.log('[client-pool] 已清空所有 client');
+    logger.log('[client-pool] 已清空所有 client');
 }
 /**
  * 获取 client 状态统计

package/dist/client.js

@@ -14,6 +14,7 @@ import { EventEmitter } from 'events';
 import { logConnected, logAuthenticated, logDisconnected, logReconnecting, logError, } from './connection-log.js';
 import { publishWecomMessage } from './message-bus.js';
 import { hashOperation } from './utils/hash.js';
+import { logger } from './logger.js';
 // 最大待处理消息数量
 const MAX_PENDING_MESSAGES = 100;
 // 全局消息序号计数器
@@ -66,7 +67,7 @@ class WecomClient extends EventEmitter {
             // 重连成功后发送通知
             if (wasReconnecting) {
                 this.sendText('【系统】连接已恢复').catch(err => {
-                    console.error('[wecom] 发送恢复通知失败:', err);
+                    logger.error('wecom', `发送恢复通知失败: ${err}`);
                 });
                 // 刷新待发送消息队列
                 this.flushPendingMessages();
@@ -81,7 +82,7 @@ class WecomClient extends EventEmitter {
             if (this.disconnectNotifyCount < 1) {
                 this.disconnectNotifyCount++;
                 this.sendText('【系统】连接中断，正在重连...').catch(err => {
-                    console.error('[wecom] 发送断线通知失败:', err);
+                    logger.error('wecom', `发送断线通知失败: ${err}`);
                 });
             }
         });
@@ -93,16 +94,16 @@ class WecomClient extends EventEmitter {
             logError(err.message);
             // 检测授权相关错误（40058: invalid Request Parameter）
             if (err.message.includes('40058') || err.message.includes('invalid Request Parameter')) {
-                console.log('');
-                console.log('  ⚠️  机器人未授权或配置有误，请检查以下事项：');
-                console.log('');
-                console.log('  1. 新建机器人需要等待约 2 分钟同步时间，请稍后再试');
-                console.log('  2. 确认 Bot ID 和 Secret 是否正确');
-                console.log('  3. 完成机器人授权（任选其一）：');
-                console.log('     • 在电脑端企业微信APP中打开：机器人详情 → 可使用权限 → 授权');
-                console.log('     • 打开浏览器访问以下地址，使用手机企业微信扫码授权：');
-                console.log(`       ${this.getAuthUrl()}`);
-                console.log('');
+                logger.info('wecom', '');
+                logger.info('wecom', '  ⚠️  机器人未授权或配置有误，请检查以下事项：');
+                logger.info('wecom', '');
+                logger.info('wecom', '  1. 新建机器人需要等待约 2 分钟同步时间，请稍后再试');
+                logger.info('wecom', '  2. 确认 Bot ID 和 Secret 是否正确');
+                logger.info('wecom', '  3. 完成机器人授权（任选其一）：');
+                logger.info('wecom', '     • 在电脑端企业微信APP中打开：机器人详情 → 可使用权限 → 授权');
+                logger.info('wecom', '     • 打开浏览器访问以下地址，使用手机企业微信扫码授权：');
+                logger.info('wecom', `       ${this.getAuthUrl()}`);
+                logger.info('wecom', '');
             }
         });
         // 监听所有消息（存储到队列）
@@ -111,13 +112,12 @@ class WecomClient extends EventEmitter {
         });
         // 监听模板卡片事件（审批结果）
         this.wsClient.on('event.template_card_event', (frame) => {
-            console.log('[wecom] 收到 template_card_event 事件，完整 frame:');
-            console.log(JSON.stringify(frame, null, 2));
+            logger.log('wecom', `收到 template_card_event 事件: ${JSON.stringify(frame)}`);
             this.handleApprovalResponse(frame);
         });
         // 监听进入会话事件
         this.wsClient.on('event.enter_chat', (frame) => {
-            console.log('[wecom] 用户进入会话');
+            logger.log('wecom', '用户进入会话');
             this.wsClient.replyWelcome(frame, {
                 msgtype: 'text',
                 text: { content: '您好！Claude Code 审批通道已就绪。' },
@@ -129,7 +129,7 @@ class WecomClient extends EventEmitter {
         if (!body)
             return;
         // 打印完整消息结构（调试用）
-        console.log('[wecom] 收到消息帧:', JSON.stringify(body, null, 2).substring(0, 500));
+        logger.log('wecom', `收到消息帧: ${JSON.stringify(body).substring(0, 500)}`);
         const msgid = body.msgid;
         const from_userid = body.from?.userid || '';
         const msgtype = body.msgtype;
@@ -152,7 +152,7 @@ class WecomClient extends EventEmitter {
             quoteContent = body.quote.text.content;
         }
         if (quoteContent) {
-            console.log('[wecom] 检测到引用内容:', quoteContent.substring(0, 100));
+            logger.log('wecom', `检测到引用内容: ${quoteContent.substring(0, 100)}`);
         }
         if (content) {
             // v3.0: 添加消息序号和队列上限检查
@@ -170,11 +170,11 @@ class WecomClient extends EventEmitter {
             // v3.0: 检查队列上限
             if (this.messages.length >= MAX_PENDING_MESSAGES) {
                 const dropped = this.messages.shift();
-                console.warn(`[wecom] 消息队列已满，丢弃旧消息: ${dropped?.msgid}`);
+                logger.warn('wecom', `消息队列已满，丢弃旧消息: ${dropped?.msgid}`);
             }
             this.messages.push(msgRecord);
             const source = chattype === 'group' ? `群聊(${chatid})` : '单聊';
-            console.log(`[wecom] 收到${source}消息: ${from_userid} -> ${content.slice(0, 100)}`);
+            logger.log('wecom', `收到${source}消息: ${from_userid} -> ${content.slice(0, 100)}`);
             // 发布到消息总线（用于 SSE 推送）
             publishWecomMessage({
                 robotName: this.robotName,
@@ -190,19 +190,19 @@ class WecomClient extends EventEmitter {
     }
     handleApprovalResponse(frame) {
         const event = frame.body?.event;
-        console.log('[wecom] handleApprovalResponse body.event:', JSON.stringify(event));
+        logger.log('wecom', `handleApprovalResponse body.event: ${JSON.stringify(event)}`);
         if (!event) {
-            console.log('[wecom] event 为空，frame.body:', JSON.stringify(frame.body));
+            logger.log('wecom', `event 为空，frame.body: ${JSON.stringify(frame.body)}`);
             return;
         }
         // task_id 和 event_key 在 event.template_card_event 内部
         const cardEvent = event.template_card_event;
         const taskId = cardEvent?.task_id;
         const eventKey = cardEvent?.event_key; // 用户点击的按钮 key
-        console.log(`[wecom] taskId=${taskId}, eventKey=${eventKey}, approvals keys:`, [...this.approvals.keys()]);
+        logger.log('wecom', `taskId=${taskId}, eventKey=${eventKey}, approvals keys: ${[...this.approvals.keys()].join(',')}`);
         if (!taskId)
             return;
-        console.log(`[wecom] 收到审批响应: taskId=${taskId}, key=${eventKey}`);
+        logger.log('wecom', `收到审批响应: taskId=${taskId}, key=${eventKey}`);
         const approval = this.approvals.get(taskId);
         if (approval && !approval.resolved) {
             approval.resolved = true;
@@ -217,20 +217,20 @@ class WecomClient extends EventEmitter {
             const descInfo = approval.description ? `\n\n> ${approval.description}` : '';
             const content = `**审批结果**${toolInfo}\n\n${resultText}${descInfo}`;
             this.sendText(content).catch(err => {
-                console.error('[wecom] 发送审批确认失败:', err);
+                logger.error('wecom', `发送审批确认失败: ${err}`);
             });
         }
         else if (approval && approval.resolved) {
-            console.log(`[wecom] 审批已解决，跳过点击: ${taskId}, resolved=${approval.resolved}, result=${approval.result}`);
+            logger.log('wecom', `审批已解决，跳过点击: ${taskId}, resolved=${approval.resolved}, result=${approval.result}`);
         }
         else {
-            console.log(`[wecom] 审批记录不存在: ${taskId}`);
+            logger.log('wecom', `审批记录不存在: ${taskId}`);
         }
     }
     // 使用 reply 方法回复审批结果（会有引用效果）
     async replyApprovalResult(frame, content) {
         if (!this.connected) {
-            console.log('[wecom] 未连接，无法回复');
+            logger.log('wecom', '未连接，无法回复');
             return;
         }
         try {
@@ -238,10 +238,10 @@ class WecomClient extends EventEmitter {
                 msgtype: 'markdown',
                 markdown: { content },
             });
-            console.log(`[wecom] 已回复审批结果`);
+            logger.log('wecom', '已回复审批结果');
         }
         catch (err) {
-            console.error(`[wecom] 回复失败: ${err}`);
+            logger.error('wecom', `回复失败: ${err}`);
         }
     }
     // 连接
@@ -272,12 +272,12 @@ class WecomClient extends EventEmitter {
                 msgtype: 'markdown',
                 markdown: { content: '【系统消息】机器人配置验证成功，此消息可忽略。' },
             });
-            console.log(`[wecom] 用户验证成功: ${targetId}`);
+            logger.log('wecom', `用户验证成功: ${targetId}`);
             return { valid: true };
         }
         catch (err) {
             const errorMsg = err.message || String(err);
-            console.error(`[wecom] 用户验证失败: ${errorMsg}`);
+            logger.error('wecom', `用户验证失败: ${errorMsg}`);
             // 解析错误类型
             if (errorMsg.includes('93006') || errorMsg.includes('invalid chatid')) {
                 return { valid: false, error: '用户 ID 格式无效，请使用企业微信通讯录中的"账号"字段（通常是拼音格式，如 liuyang），不是中文名称' };
@@ -299,7 +299,7 @@ class WecomClient extends EventEmitter {
         const userId = targetUser || this.targetUserId;
         // 断线时将消息加入队列，等待重连后发送
         if (!this.connected) {
-            console.log('[wecom] 未连接，消息已加入队列');
+            logger.log('wecom', '未连接，消息已加入队列');
             this.pendingMessages.push({
                 type: 'text',
                 content,
@@ -313,11 +313,11 @@ class WecomClient extends EventEmitter {
                 msgtype: 'markdown',
                 markdown: { content },
             });
-            console.log(`[wecom] 已发送消息到 ${userId}`);
+            logger.log('wecom', `已发送消息到 ${userId}`);
             return true;
         }
         catch (err) {
-            console.error(`[wecom] 发送失败: ${err}`);
+            logger.error('wecom', `发送失败: ${err}`);
             // 发送失败也加入队列
             this.pendingMessages.push({
                 type: 'text',
@@ -340,7 +340,7 @@ class WecomClient extends EventEmitter {
             const operationHash = hashOperation(ccId ?? '', toolName, toolInput);
             const existing = this.findApprovalByHash(operationHash);
             if (existing) {
-                console.log(`[wecom] 复用已有审批: ${existing.taskId} (hash: ${operationHash.slice(0, 8)}...)`);
+                logger.log(`[wecom] 复用已有审批: ${existing.taskId} (hash: ${operationHash.slice(0, 8)}...)`);
                 return existing.taskId;
             }
         }
@@ -358,7 +358,7 @@ class WecomClient extends EventEmitter {
         });
         // 断线时将审批请求加入队列，等待重连后发送
         if (!this.connected) {
-            console.log('[wecom] 未连接，审批请求已加入队列');
+            logger.log('[wecom] 未连接，审批请求已加入队列');
             this.pendingMessages.push({
                 type: 'approval',
                 content: { title, description, requestId, targetUser: userId, taskId },
@@ -383,7 +383,7 @@ class WecomClient extends EventEmitter {
                 task_id: taskId,
             },
         });
-        console.log(`[wecom] 已发送审批请求到 ${userId}: ${taskId}`);
+        logger.log(`[wecom] 已发送审批请求到 ${userId}: ${taskId}`);
         return taskId;
     }
     // 发送排队的审批请求（使用已存在的 taskId）
@@ -391,11 +391,11 @@ class WecomClient extends EventEmitter {
         // 检查审批是否已解决
         const approval = this.approvals.get(taskId);
         if (!approval) {
-            console.log(`[wecom] 审批记录不存在: ${taskId}`);
+            logger.log(`[wecom] 审批记录不存在: ${taskId}`);
             return false;
         }
         if (approval.resolved) {
-            console.log(`[wecom] 审批已解决，跳过发送: ${taskId}`);
+            logger.log(`[wecom] 审批已解决，跳过发送: ${taskId}`);
             return false;
         }
         const userId = targetUser || this.targetUserId;
@@ -414,7 +414,7 @@ class WecomClient extends EventEmitter {
                 task_id: taskId,
             },
         });
-        console.log(`[wecom] 已发送排队审批请求到 ${userId}: ${taskId}`);
+        logger.log(`[wecom] 已发送排队审批请求到 ${userId}: ${taskId}`);
         return true;
     }
     // 获取审批结果（非阻塞，立即返回当前状态）
@@ -432,11 +432,11 @@ class WecomClient extends EventEmitter {
     setApprovalResult(taskId, result, reason) {
         const approval = this.approvals.get(taskId);
         if (!approval) {
-            console.log(`[wecom] 设置审批结果失败：记录不存在 ${taskId}`);
+            logger.log(`[wecom] 设置审批结果失败：记录不存在 ${taskId}`);
             return false;
         }
         if (approval.resolved) {
-            console.log(`[wecom] 设置审批结果失败：已解决 ${taskId}`);
+            logger.log(`[wecom] 设置审批结果失败：已解决 ${taskId}`);
             return false;
         }
         approval.resolved = true;
@@ -449,9 +449,9 @@ class WecomClient extends EventEmitter {
         const toolInfo = approval.toolName ? `: ${approval.toolName}` : '';
         const descInfo = approval.description ? `\n\n> ${approval.description}` : '';
         this.sendText(`**审批结果（超时自动决策）**${toolInfo}\n\n${resultText}${reasonText}${descInfo}`).catch(err => {
-            console.error('[wecom] 发送审批确认失败:', err);
+            logger.error('[wecom] 发送审批确认失败:', err);
         });
-        console.log(`[wecom] 超时自动决策已设置: ${taskId} → ${result}`);
+        logger.log(`[wecom] 超时自动决策已设置: ${taskId} → ${result}`);
         return true;
     }
     // 获取所有待处理的审批任务 ID（供 hook 轮询使用）
@@ -542,7 +542,7 @@ class WecomClient extends EventEmitter {
             toolName: partial.toolName,
             toolInput: partial.toolInput,
         });
-        console.log(`[wecom] 注入恢复审批记录: ${taskId}`);
+        logger.log(`[wecom] 注入恢复审批记录: ${taskId}`);
     }
     // 清理过期消息
     cleanupMessages(maxAgeMs = 300000) {
@@ -560,7 +560,7 @@ class WecomClient extends EventEmitter {
         if (this.pendingMessages.length === 0) {
             return;
         }
-        console.log(`[wecom] 刷新待发送消息队列: ${this.pendingMessages.length} 条`);
+        logger.log(`[wecom] 刷新待发送消息队列: ${this.pendingMessages.length} 条`);
         while (this.pendingMessages.length > 0 && this.connected) {
             const msg = this.pendingMessages.shift();
             if (!msg)
@@ -591,12 +591,12 @@ class WecomClient extends EventEmitter {
                             task_id: taskId,
                         },
                     });
-                    console.log(`[wecom] 重发审批请求: ${taskId}`);
+                    logger.log(`[wecom] 重发审批请求: ${taskId}`);
                 }
-                console.log(`[wecom] 重发消息成功: ${msg.type}`);
+                logger.log(`[wecom] 重发消息成功: ${msg.type}`);
             }
             catch (err) {
-                console.error(`[wecom] 重发消息失败: ${err}`);
+                logger.error(`[wecom] 重发消息失败: ${err}`);
             }
         }
     }