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

package/dist/http-server.js

@@ -15,35 +15,44 @@
 import * as http from 'http';
 import * as path from 'path';
 import * as os from 'os';
+import * as fs from 'fs';
+import { fileURLToPath } from 'url';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { registerTools } from './tools/index.js';
 import { getClient, getConnectionState, getAllConnectionStates, connectAllRobots } from './connection-manager.js';
-import { subscribeWecomMessage } from './message-bus.js';
+import { subscribeWecomMessage, getSubscriberCount } from './message-bus.js';
 import { listAllRobots } from './config-wizard.js';
+import { logger } from './logger.js';
+// ESM 兼容的 __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 // 固定端口
 export const HTTP_PORT = 18963;
 // Hook 脚本路径
 export const HOOK_SCRIPT_PATH = path.join(os.homedir(), '.wecom-aibot-mcp', 'permission-hook.sh');
 let httpServer = null;
 let startTime = 0;
-// ccId 序号计数器
-let sessionIndex = 0;
 // Session ID 生成器（MCP SSE 使用）
 function generateSessionId() {
     return `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
 }
-// ccId 生成器（基于序号）
-export function generateCcId() {
-    sessionIndex++;
-    return `cc-${sessionIndex}`;
+// 从 agentName 生成简化的 ccId 名称
+function sanitizeAgentName(agentName) {
+    // 简化名称：移除特殊字符，限制长度
+    return agentName.replace(/[^a-zA-Z0-9\u4e00-\u9fa5_-]/g, '').slice(0, 20);
 }
-// 推送微信消息到 MCP 客户端（通过 SSE）
+// ccId 生成器（基于 agentName）- 不自动编号
+export function generateCcId(agentName) {
+    const name = agentName ? sanitizeAgentName(agentName) : 'cc';
+    return name; // 直接返回名称，不添加编号
+}
+// 推送微信消息到 MCP 客户端（通过 SSE notification）
 export async function pushMessageToSession(robotName, message) {
     // 推送给所有活跃的 session
     if (transports.size === 0) {
-        console.log('[http] 无活跃 session，无法推送消息');
+        logger.log('[http] 无活跃 session，无法推送消息');
         return;
     }
     // 广播给所有连接的客户端
@@ -66,25 +75,95 @@ export async function pushMessageToSession(robotName, message) {
                     }),
                 },
             });
-            console.log(`[http] 已推送消息到 session ${sessionId}`);
+            logger.log(`[http] 已推送消息到 session ${sessionId}`);
+        }
+        catch (err) {
+            logger.error(`[http] 推送消息到 session ${sessionId} 失败:`, err);
+        }
+    }
+}
+// 推送微信消息到 SSE 客户端（Channel 模式，按 ccId 精准推送）
+export async function pushMessageToSSEClient(robotName, message, targetCcId) {
+    // 推送给匹配的 SSE 客户端
+    if (sseClients.size === 0) {
+        logger.log('[http] 无 SSE 客户端连接，无法推送消息');
+        return;
+    }
+    // 找到匹配的 SSE 客户端
+    for (const [clientId, client] of sseClients) {
+        // 按 ccId 匹配或广播给所有同机器人客户端
+        if (targetCcId && client.ccId !== targetCcId) {
+            continue;
+        }
+        if (client.robotName !== robotName) {
+            continue;
+        }
+        try {
+            const data = JSON.stringify({
+                type: 'wecom_message',
+                robotName,
+                ccId: targetCcId || client.ccId,
+                message: {
+                    content: message.content,
+                    from: message.from_userid,
+                    chatid: message.chatid,
+                    chattype: message.chattype,
+                    time: new Date(message.timestamp).toISOString(),
+                },
+            });
+            client.res.write(`event: message\ndata: ${data}\n\n`);
+            logger.log(`[http] SSE 推送成功: clientId=${clientId}, ccId=${targetCcId || client.ccId}`);
         }
         catch (err) {
-            console.error(`[http] 推送消息到 session ${sessionId} 失败:`, err);
+            logger.error(`[http] SSE 推送失败: clientId=${clientId}`, err);
+            sseClients.delete(clientId);
         }
     }
 }
 const ccIdRegistry = new Map();
-export function registerCcId(ccId, robotName, agentName) {
-    ccIdRegistry.set(ccId, { robotName, agentName });
-    console.log(`[ccid] 注册: ${ccId} → ${robotName} (${agentName || 'unknown'})`);
+// 超时阈值：30 分钟未活跃的 ccId 视为离线
+const CCID_STALE_TIMEOUT = 30 * 60 * 1000;
+// 清理超时的 ccId 条目
+function cleanStaleCcIds() {
+    const now = Date.now();
+    for (const [id, entry] of ccIdRegistry) {
+        if (now - entry.lastOnline > CCID_STALE_TIMEOUT) {
+            ccIdRegistry.delete(id);
+            logger.log(`[ccid] 清理超时条目: ${id} (离线 ${Math.round((now - entry.lastOnline) / 60000)} 分钟)`);
+        }
+    }
+}
+// 注册 ccId。重连场景（config 文件已存在）直接覆盖更新；
+// 首次注册时先清理超时条目。始终返回 success=true，不做冲突拦截。
+export function registerCcId(ccId, robotName, agentName, mode, projectDir, isReconnect) {
+    if (isReconnect || ccIdRegistry.has(ccId)) {
+        // 重连：直接覆盖，更新 lastOnline
+        logger.log(`[ccid] 重连: ${ccId} → ${robotName}`);
+    }
+    else {
+        // 首次注册：先清理超时条目
+        cleanStaleCcIds();
+        logger.log(`[ccid] 注册: ${ccId} → ${robotName} (${agentName || 'unknown'}, mode: ${mode || 'http'})`);
+    }
+    ccIdRegistry.set(ccId, { robotName, agentName, mode, projectDir, lastOnline: Date.now() });
+    return { success: true, ccId };
 }
 export function unregisterCcId(ccId) {
     ccIdRegistry.delete(ccId);
-    console.log(`[ccid] 注销: ${ccId}`);
+    logger.log(`[ccid] 注销: ${ccId}`);
+}
+export function clearCcIdRegistry() {
+    const entries = Array.from(ccIdRegistry.keys());
+    ccIdRegistry.clear();
+    logger.log(`[ccid] 清空注册表: 共清理 ${entries.length} 条 (${entries.join(', ')})`);
+    return { cleared: entries.length, entries };
 }
 export function getRobotByCcId(ccId) {
     return ccIdRegistry.get(ccId)?.robotName || null;
 }
+export function getProjectDirByCcId(ccId) {
+    return ccIdRegistry.get(ccId)?.projectDir || null;
+}
 export function getCCRegistryEntry(ccId) {
     return ccIdRegistry.get(ccId) || null;
 }
@@ -105,8 +184,9 @@ export function getOnlineCcIds() {
 }
 // 使用 Map 存储多个待处理审批（按 taskId 索引）
 const pendingApprovals = new Map();
-const VERSION = '1.2.0';
+const VERSION = '2.0.0';
 const transports = new Map();
+const sseClients = new Map(); // clientId -> SSEClient
 // 初始化 MCP Server（不再全局连接）
 function initMcpServer() {
     // 订阅消息总线，实现 SSE 推送
@@ -122,75 +202,226 @@ function createMcpServerInstance() {
     }, {
         capabilities: {
             logging: {}, // 支持服务端主动推送日志消息
+            experimental: {
+                'claude/channel': {}, // 支持 Channel 模式 SSE 推送
+            },
         }
     });
     registerTools(server);
     return server;
 }
-// 处理微信消息（路由给对应的 Session）
-function handleWecomMessage(msg) {
-    if (transports.size === 0) {
-        console.log('[http] 无活跃 MCP session，跳过消息处理');
-        return;
-    }
+// 处理微信消息（根据 mode 选择推送方式）
+async function handleWecomMessage(msg) {
     // 查找匹配的 CC（基于引用内容中的 ccId）
     const targetCcId = extractCcIdFromQuote(msg.quoteContent);
+    // 优先检查 SSE 客户端（Channel 模式）
+    // 先尝试精准匹配（有 targetCcId）
     if (targetCcId) {
-        // 有引用，SSE 推送给对应的 CC
-        console.log(`[http] 消息路由给 ${targetCcId}`);
-        pushMessageToSession(msg.robotName, {
-            msgid: msg.msgid,
-            content: msg.content,
-            from_userid: msg.from_userid,
-            chatid: msg.chatid,
-            chattype: msg.chattype,
-            timestamp: msg.timestamp,
-        });
+        const entry = getCCRegistryEntry(targetCcId);
+        if (entry?.mode === 'channel') {
+            logger.log(`[http] Channel 模式精准匹配，SSE 推送给 ${targetCcId}`);
+            await pushMessageToSSEClient(msg.robotName, {
+                msgid: msg.msgid,
+                content: msg.content,
+                from_userid: msg.from_userid,
+                chatid: msg.chatid,
+                chattype: msg.chattype,
+                timestamp: msg.timestamp,
+            }, targetCcId);
+            return;
+        }
     }
-    else if (getCCCount() === 1) {
-        // 只有一个 CC 在线，直接推送（无需引用）
-        console.log(`[http] 单 CC 模式，直接推送`);
-        pushMessageToSession(msg.robotName, {
-            msgid: msg.msgid,
-            content: msg.content,
-            from_userid: msg.from_userid,
-            chatid: msg.chatid,
-            chattype: msg.chattype,
-            timestamp: msg.timestamp,
-        });
+    // 检查 SSE 客户端数量（按 robotName）
+    const matchingSseClients = [];
+    for (const [clientId, client] of sseClients) {
+        if (client.robotName === msg.robotName) {
+            matchingSseClients.push({ clientId, ccId: client.ccId });
+        }
     }
-    else if (getCCCount() > 1) {
-        // 多 CC 在线但无引用：先尝试按 from_userid 匹配机器人的 targetUserId
-        const matchedCcId = findCcIdByTargetUserId(msg.from_userid);
-        if (matchedCcId) {
-            console.log(`[http] 多 CC 模式，按 from_userid 路由给 ${matchedCcId}`);
-            pushMessageToSession(msg.robotName, {
+    if (matchingSseClients.length > 0) {
+        // 有 SSE 客户端连接
+        if (matchingSseClients.length === 1) {
+            // 单个 SSE 客户端，直接推送
+            const { clientId, ccId } = matchingSseClients[0];
+            logger.log(`[http] 单 SSE 客户端 ${clientId}，直接推送`);
+            await pushMessageToSSEClient(msg.robotName, {
                 msgid: msg.msgid,
                 content: msg.content,
                 from_userid: msg.from_userid,
                 chatid: msg.chatid,
                 chattype: msg.chattype,
                 timestamp: msg.timestamp,
-            });
+            }, ccId);
+            return;
+        }
+        // 多个 SSE 客户端，需要引用路由
+        if (targetCcId) {
+            // 有引用，精准推送
+            const matched = matchingSseClients.find(c => c.ccId === targetCcId);
+            if (matched) {
+                logger.log(`[http] 多 SSE 客户端，引用匹配 ${targetCcId}，精准推送`);
+                await pushMessageToSSEClient(msg.robotName, {
+                    msgid: msg.msgid,
+                    content: msg.content,
+                    from_userid: msg.from_userid,
+                    chatid: msg.chatid,
+                    chattype: msg.chattype,
+                    timestamp: msg.timestamp,
+                }, targetCcId);
+                return;
+            }
+        }
+        // 无引用，尝试按 from_userid 匹配（2v2 场景）
+        const matchedCcId = findCcIdByTargetUserId(msg.from_userid);
+        if (matchedCcId) {
+            const matched = matchingSseClients.find(c => c.ccId === matchedCcId);
+            if (matched) {
+                logger.log(`[http] 多 SSE 客户端，按 from_userid 路由给 ${matchedCcId}`);
+                await pushMessageToSSEClient(msg.robotName, {
+                    msgid: msg.msgid,
+                    content: msg.content,
+                    from_userid: msg.from_userid,
+                    chatid: msg.chatid,
+                    chattype: msg.chattype,
+                    timestamp: msg.timestamp,
+                }, matchedCcId);
+                return;
+            }
+        }
+        // 无法确定目标 CC，发送引用提示
+        logger.log('[http] 多 SSE 客户端，无引用匹配，发送提示');
+        await sendNoReferencePrompt(msg);
+        return;
+    }
+    // 无 SSE 客户端，走 HTTP 模式 notification 推送
+    if (transports.size === 0) {
+        logger.log('[http] 无活跃 MCP session，跳过消息处理');
+        return;
+    }
+    const subscriberCount = getSubscriberCount(msg.robotName);
+    logger.log(`[http] 机器人 ${msg.robotName} 订阅数: ${subscriberCount}`);
+    if (subscriberCount === 0) {
+        logger.log('[http] 无订阅者，跳过消息处理');
+        return;
+    }
+    if (subscriberCount === 1) {
+        // 只有一个订阅者，直接广播（SSE 检查已在前面完成）
+        logger.log('[http] 单订阅者 HTTP 模式，直接广播');
+        for (const [sessionId, sessEntry] of transports) {
+            try {
+                await sessEntry.server.server.notification({
+                    method: 'notifications/message',
+                    params: {
+                        level: 'info',
+                        data: JSON.stringify({
+                            type: 'wecom_message',
+                            robotName: msg.robotName,
+                            message: {
+                                content: msg.content,
+                                from: msg.from_userid,
+                                chatid: msg.chatid,
+                                chattype: msg.chattype,
+                                time: new Date(msg.timestamp).toISOString(),
+                                quoteContent: msg.quoteContent,
+                            },
+                        }),
+                    },
+                });
+                logger.log(`[http] 已推送消息到 session ${sessionId}`);
+            }
+            catch (err) {
+                logger.error(`[http] 推送失败 session ${sessionId}:`, err);
+            }
+        }
+        return;
+    }
+    // 多订阅者模式：检查 ccId 引用
+    logger.log(`[http] 多订阅者模式，目标 ccId: ${targetCcId || '无'}`);
+    if (targetCcId) {
+        // 有明确的 ccId 引用，广播给所有 session（订阅者会自己过滤）
+        logger.log(`[http] 引用匹配 ${targetCcId}，广播消息`);
+        for (const [sessionId, sessEntry] of transports) {
+            try {
+                await sessEntry.server.server.notification({
+                    method: 'notifications/message',
+                    params: {
+                        level: 'info',
+                        data: JSON.stringify({
+                            type: 'wecom_message',
+                            robotName: msg.robotName,
+                            targetCcId, // 标记目标 ccId
+                            message: {
+                                content: msg.content,
+                                from: msg.from_userid,
+                                chatid: msg.chatid,
+                                chattype: msg.chattype,
+                                time: new Date(msg.timestamp).toISOString(),
+                                quoteContent: msg.quoteContent,
+                            },
+                        }),
+                    },
+                });
+                logger.log(`[http] 已推送消息到 session ${sessionId} (目标: ${targetCcId})`);
+            }
+            catch (err) {
+                logger.error(`[http] 推送失败 session ${sessionId}:`, err);
+            }
+        }
+    }
+    else {
+        // 无 ccId 引用，尝试按 from_userid 匹配（2v2 场景）
+        const matchedCcId = findCcIdByTargetUserId(msg.from_userid);
+        if (matchedCcId) {
+            logger.log(`[http] 多订阅者模式，按 from_userid 路由给 ${matchedCcId}`);
+            const matchedEntry = getCCRegistryEntry(matchedCcId);
+            if (matchedEntry?.mode === 'channel') {
+                // Channel 模式：SSE 推送
+                await pushMessageToSSEClient(msg.robotName, {
+                    msgid: msg.msgid,
+                    content: msg.content,
+                    from_userid: msg.from_userid,
+                    chatid: msg.chatid,
+                    chattype: msg.chattype,
+                    timestamp: msg.timestamp,
+                }, matchedCcId);
+            }
+            else {
+                // HTTP 模式：notification 推送
+                for (const [sessionId, sessEntry] of transports) {
+                    try {
+                        await sessEntry.server.server.notification({
+                            method: 'notifications/message',
+                            params: {
+                                level: 'info',
+                                data: JSON.stringify({
+                                    type: 'wecom_message',
+                                    robotName: msg.robotName,
+                                    targetCcId: matchedCcId,
+                                    message: {
+                                        content: msg.content,
+                                        from: msg.from_userid,
+                                        chatid: msg.chatid,
+                                        chattype: msg.chattype,
+                                        time: new Date(msg.timestamp).toISOString(),
+                                        quoteContent: msg.quoteContent,
+                                    },
+                                }),
+                            },
+                        });
+                    }
+                    catch (err) {
+                        logger.error(`[http] 推送失败 session ${sessionId}:`, err);
+                    }
+                }
+            }
         }
         else {
             // 无法确定目标 CC，发送引用提示
-            console.log(`[http] 多 CC 模式，无引用，发送提示`);
-            sendNoReferencePrompt(msg);
+            logger.log('[http] 无引用匹配，发送提示');
+            await sendNoReferencePrompt(msg);
         }
     }
 }
-// 从引用内容提取 ccId
-function extractCcIdFromQuote(quoteContent) {
-    if (!quoteContent)
-        return null;
-    // 匹配格式：【cc-1】或【cc-2】等
-    const match = quoteContent.match(/【(cc-\d+)】/);
-    if (match) {
-        return match[1]; // 返回 ccId（如 cc-1）
-    }
-    return null;
-}
 // 根据 from_userid 匹配 ccId（2v2 场景：每个用户对应一个 CC）
 function findCcIdByTargetUserId(fromUserId) {
     const allRobots = listAllRobots();
@@ -202,18 +433,27 @@ function findCcIdByTargetUserId(fromUserId) {
     }
     return null;
 }
+// 从引用内容提取 ccId（匹配任意格式）
+function extractCcIdFromQuote(quoteContent) {
+    if (!quoteContent)
+        return null;
+    const match = quoteContent.match(/【([^】]+)】/);
+    return match ? match[1] : null;
+}
 // 无引用消息提示
 async function sendNoReferencePrompt(msg) {
     const client = await getClient(msg.robotName);
     if (!client)
         return;
-    const onlineList = getOnlineCcIds().map(id => `• ${id}`).join('\n');
+    const onlineList = getOnlineCcIds();
+    if (onlineList.length === 0)
+        return; // 没有 CC 在线，不发提示
     const reply = `检测到多个 Claude Code 会话在线，请引用回复指明接收者。
 
 当前在线：
-${onlineList}
+${onlineList.map(id => `• 【${id}】`).join('\n')}
 
-示例：引用【${getOnlineCcIds()[0]}】的消息后回复`;
+示例：引用【${onlineList[0]}】的消息后回复`;
     await client.sendText(reply);
 }
 export async function startHttpServer(_server, port = HTTP_PORT) {
@@ -244,19 +484,19 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                         // 没有 session ID，返回 405 表示不支持匿名 SSE
                         // 客户端会先发送 POST 初始化，然后带着 session ID 来 GET
                         if (!sessionId) {
-                            console.log('[http] GET /mcp: 无 session ID，返回 405');
+                            logger.log('[http] GET /mcp: 无 session ID，返回 405');
                             res.writeHead(405, { 'Content-Type': 'text/plain' });
                             res.end('Method Not Allowed: Session ID required for SSE stream');
                             return;
                         }
                         const entry = transports.get(sessionId);
                         if (!entry) {
-                            console.log(`[http] GET /mcp: session ${sessionId} not found`);
+                            logger.log(`[http] GET /mcp: session ${sessionId} not found`);
                             res.writeHead(404, { 'Content-Type': 'text/plain' });
                             res.end('Session not found');
                             return;
                         }
-                        console.log(`[http] 建立 SSE 流: session ${sessionId}`);
+                        logger.log(`[http] 建立 SSE 流: session ${sessionId}`);
                         await entry.transport.handleRequest(req, res);
                         return;
                     }
@@ -286,7 +526,7 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                             const newTransport = new StreamableHTTPServerTransport({
                                 sessionIdGenerator: generateSessionId,
                                 onsessioninitialized: (sid) => {
-                                    console.log(`[http] Session 初始化: ${sid}`);
+                                    logger.log(`[http] Session 初始化: ${sid}`);
                                     transports.set(sid, { transport: newTransport, server: newServer });
                                 },
                             });
@@ -294,7 +534,7 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                             newTransport.onclose = () => {
                                 const sid = newTransport.sessionId;
                                 if (sid) {
-                                    console.log(`[http] Session 关闭: ${sid}`);
+                                    logger.log(`[http] Session 关闭: ${sid}`);
                                     transports.delete(sid);
                                 }
                             };
@@ -323,7 +563,7 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                     }
                 }
                 catch (err) {
-                    console.error('[http] MCP 请求处理失败:', err);
+                    logger.error('[http] MCP 请求处理失败:', err);
                     if (!res.headersSent) {
                         res.writeHead(500, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ error: err.message }));
@@ -351,6 +591,11 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                 handleStateQuery(req, res);
                 return;
             }
+            // SSE endpoint for Channel 模式
+            if (req.method === 'GET' && url.startsWith('/sse/')) {
+                handleSSEConnect(req, res, url);
+                return;
+            }
             if (req.method === 'POST' && url === '/notify') {
                 await handleNotify(req, res);
                 return;
@@ -363,9 +608,15 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                 await handlePushNotification(req, res);
                 return;
             }
+            if (req.method === 'POST' && url === '/admin/clean-cache') {
+                const result = clearCcIdRegistry();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, ...result }));
+                return;
+            }
             // 临时调试端点：手动进入 headless 模式
             if (req.method === 'POST' && url === '/debug/enter_headless') {
-                const ccId = generateCcId();
+                const ccId = `debug-${Date.now()}`;
                 registerCcId(ccId, 'ClaudeCode', '调试用户');
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
@@ -373,7 +624,23 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                     ccId,
                     message: '已进入 headless 模式（调试）'
                 }));
-                console.log(`[http] [DEBUG] 进入 headless 模式: ccId: ${ccId}`);
+                logger.log(`[http] [DEBUG] 进入 headless 模式: ccId: ${ccId}`);
+                return;
+            }
+            // Skill 文件下载 endpoint（支持远程部署）
+            if (req.method === 'GET' && url === '/skill') {
+                const skillPath = path.join(__dirname, '..', 'skills', 'headless-mode', 'SKILL.md');
+                if (fs.existsSync(skillPath)) {
+                    const content = fs.readFileSync(skillPath, 'utf-8');
+                    res.writeHead(200, { 'Content-Type': 'text/markdown; charset=utf-8' });
+                    res.end(content);
+                    logger.log(`[http] Skill 文件已下载`);
+                }
+                else {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Skill 文件不存在' }));
+                    logger.error(`[http] Skill 文件不存在: ${skillPath}`);
+                }
                 return;
             }
             // 临时调试端点：退出 headless 模式
@@ -381,13 +648,38 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                 ccIdRegistry.clear();
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ status: 'exited', message: '已退出 headless 模式（调试）' }));
-                console.log(`[http] [DEBUG] 退出 headless 模式`);
+                logger.log(`[http] [DEBUG] 退出 headless 模式`);
+                return;
+            }
+            // 调试端点：模拟发送微信消息（测试 SSE 推送）
+            if (req.method === 'POST' && url === '/debug/test_message') {
+                const body = await readRequestBody(req);
+                const params = JSON.parse(body);
+                const robotName = params.robotName || 'CC';
+                const content = params.content || '测试消息';
+                const ccId = params.ccId;
+                // 模拟微信消息
+                const testMsg = {
+                    robotName,
+                    msgid: `test_${Date.now()}`,
+                    content,
+                    from_userid: 'TestUser',
+                    chatid: 'TestUser',
+                    chattype: 'single',
+                    timestamp: Date.now(),
+                    quoteContent: ccId ? `【${ccId}】` : undefined, // 模拟引用指定 ccId
+                };
+                // 发布到消息总线
+                logger.log(`[http] [DEBUG] 模拟发送微信消息: robotName=${robotName}, content=${content}, ccId=${ccId}`);
+                handleWecomMessage(testMsg);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: 'sent', message: '测试消息已发送', ccId }));
                 return;
             }
             // 调试端点：模拟断开指定机器人的连接（不删除状态，保留待发送队列）
             if (req.method === 'POST' && url.startsWith('/debug/disconnect/')) {
                 const robotName = decodeURIComponent(url.replace('/debug/disconnect/', ''));
-                console.log(`[http] [DEBUG] 模拟断开机器人: ${robotName}`);
+                logger.log(`[http] [DEBUG] 模拟断开机器人: ${robotName}`);
                 const client = await getClient(robotName);
                 if (client) {
                     client.disconnect();
@@ -403,7 +695,7 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
             // 调试端点：触发重连（通过 getClient 自动重连）
             if (req.method === 'POST' && url.startsWith('/debug/reconnect/')) {
                 const robotName = decodeURIComponent(url.replace('/debug/reconnect/', ''));
-                console.log(`[http] [DEBUG] 触发重连机器人: ${robotName}`);
+                logger.log(`[http] [DEBUG] 触发重连机器人: ${robotName}`);
                 const client = await getClient(robotName);
                 if (client && client.isConnected()) {
                     res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -461,8 +753,8 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
             }
         });
         httpServer.listen(port, '127.0.0.1', async () => {
-            console.log(`[http] MCP Server 已启动: http://127.0.0.1:${port}`);
-            console.log(`[http] MCP endpoint: http://127.0.0.1:${port}/mcp (stateless mode)`);
+            logger.log(`[http] MCP Server 已启动: http://127.0.0.1:${port}`);
+            logger.log(`[http] MCP endpoint: http://127.0.0.1:${port}/mcp (stateless mode)`);
             // 自动连接所有配置的机器人
             await connectAllRobots();
             resolve();
@@ -473,7 +765,7 @@ export function stopHttpServer() {
     if (httpServer) {
         httpServer.close();
         httpServer = null;
-        console.log('[http] HTTP Server 已停止');
+        logger.log('[http] HTTP Server 已停止');
     }
 }
 async function handleApprovalRequest(req, res) {
@@ -485,12 +777,12 @@ async function handleApprovalRequest(req, res) {
         const { ccId, robotName: requestedRobotName } = request;
         if (requestedRobotName) {
             robotName = requestedRobotName;
-            console.log(`[http] 审批路由: 请求指定 robotName=${robotName}`);
+            logger.log(`[http] 审批路由: 请求指定 robotName=${robotName}`);
         }
         else if (ccId) {
             robotName = getRobotByCcId(ccId);
             if (robotName) {
-                console.log(`[http] 审批路由: ccId=${ccId} → ${robotName}`);
+                logger.log(`[http] 审批路由: ccId=${ccId} → ${robotName}`);
             }
         }
         if (!robotName) {
@@ -498,7 +790,7 @@ async function handleApprovalRequest(req, res) {
             const connectedRobot = states.find(s => s.connected);
             if (connectedRobot) {
                 robotName = connectedRobot.robotName;
-                console.log(`[http] 审批路由: 回退到第一个已连接机器人 ${robotName}`);
+                logger.log(`[http] 审批路由: 回退到第一个已连接机器人 ${robotName}`);
             }
         }
         if (!robotName) {
@@ -527,7 +819,7 @@ async function handleApprovalRequest(req, res) {
         const title = `【待审批】${tool_name}`;
         const requestId = `hook_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
         const taskId = await client.sendApprovalRequest(title, description, requestId);
-        console.log(`[http] 审批请求已发送: ${taskId} (机器人: ${robotName})`);
+        logger.log(`[http] 审批请求已发送: ${taskId} (机器人: ${robotName})`);
         // 存储审批并启动超时计时器
         const entry = {
             taskId,
@@ -543,7 +835,7 @@ async function handleApprovalRequest(req, res) {
         res.end(JSON.stringify({ taskId, status: 'pending' }));
     }
     catch (err) {
-        console.error('[http] 审批请求处理失败:', err);
+        logger.error('[http] 审批请求处理失败:', err);
         res.writeHead(400, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: err.message }));
     }
@@ -616,8 +908,49 @@ function handleHealthCheck(_req, res) {
         uptime: Math.floor((Date.now() - startTime) / 1000),
         websocket: { connected: state.connected, robotName: state.robotName },
         headless: hasActiveSession ? { mode: 'HEADLESS' } : { mode: 'NORMAL' },
+        sseClients: sseClients.size, // Channel 模式客户端数
+        ccIds: getOnlineCcIds(), // 当前注册的 ccId
     }, null, 2));
 }
+// SSE 连接处理（Channel 模式）
+function handleSSEConnect(req, res, url) {
+    const ccId = decodeURIComponent(url.replace('/sse/', ''));
+    const entry = getCCRegistryEntry(ccId);
+    if (!entry) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end(`CC ${ccId} not found`);
+        return;
+    }
+    const clientId = `${ccId}_${Date.now()}`;
+    // 设置 SSE headers
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+    });
+    // 注册 SSE 客户端
+    sseClients.set(clientId, {
+        res,
+        ccId,
+        robotName: entry.robotName,
+    });
+    logger.log(`[http] SSE 客户端连接: clientId=${clientId}, ccId=${ccId}, robotName=${entry.robotName}`);
+    // 发送连接确认
+    res.write(`event: connected\ndata: {"clientId":"${clientId}","ccId":"${ccId}"}\n\n`);
+    // 心跳机制：每 15 秒发送注释行保持连接活跃
+    const heartbeatInterval = setInterval(() => {
+        // SSE 注释行（以冒号开头）会被客户端忽略，但保持连接
+        res.write(': heartbeat\n\n');
+        logger.log(`[http] SSE 心跳发送: clientId=${clientId}`);
+    }, 15000);
+    // 处理客户端断开
+    req.on('close', () => {
+        clearInterval(heartbeatInterval);
+        sseClients.delete(clientId);
+        logger.log(`[http] SSE 客户端断开: clientId=${clientId}`);
+    });
+}
 function handleStateQuery(_req, res) {
     const state = getConnectionState();
     const connections = getAllConnectionStates();
@@ -677,14 +1010,14 @@ async function handlePushNotification(req, res) {
                 sent++;
             }
             catch (err) {
-                console.error(`[http] 推送到 session ${sessionId} 失败:`, err);
+                logger.error(`[http] 推送到 session ${sessionId} 失败:`, err);
             }
         }
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ success: true, method: method || 'notifications/message', sessions: sent }));
     }
     catch (err) {
-        console.error('[http] 推送通知失败:', err);
+        logger.error('[http] 推送通知失败:', err);
         res.writeHead(500, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: err.message }));
     }
@@ -738,5 +1071,5 @@ function readRequestBody(req) {
     });
 }
 export function cleanupPortFile() {
-    console.log('[http] 使用固定端口:', HTTP_PORT);
+    logger.log('[http] 使用固定端口:', HTTP_PORT);
 }