@vrs-soft/wecom-aibot-mcp 1.3.0 → 1.4.0

package/dist/bin.js

@@ -15,7 +15,9 @@ import * as path from 'path';
 import * as os from 'os';
 import { runConfigWizard, loadConfig, saveConfig, deleteConfig, deleteMcpConfigInteractive, uninstall, addMcpConfig, detectUserIdFromMessage, ensureHookInstalled, listAllRobots, } from './config-wizard.js';
 import { initClient } from './client.js';
+import { registerTools } from './tools/index.js';
 import { startHttpServer, stopHttpServer, HTTP_PORT } from './http-server.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { getAllConnectionStates } from './connection-manager.js';
 import { loadStats, cleanupOldLogs } from './connection-log.js';
 import { startKeepaliveMonitor, stopKeepaliveMonitor } from './keepalive-monitor.js';
@@ -36,6 +38,7 @@ function showHelp() {
   --version, -v   显示版本号
   --start         启动 MCP Server（后台服务模式）
   --stop          停止 MCP Server
+  --debug         前台启动 MCP Server（日志直接输出到终端，用于调试）
   --status        显示服务状态和机器人配置
   --config        重新配置默认机器人（修改 Bot ID / Secret / 目标用户）
   --add           添加新的机器人配置（多机器人场景）
@@ -116,8 +119,10 @@ function isServerRunning() {
         return true;
     }
     catch {
-        // 进程不存在，清理 PID 文件
-        fs.unlinkSync(PID_FILE);
+        // 进程不存在，清理 PID 文件（可能已被进程自身删除）
+        if (fs.existsSync(PID_FILE)) {
+            fs.unlinkSync(PID_FILE);
+        }
         return false;
     }
 }
@@ -144,13 +149,18 @@ function stopServer() {
                 break;
             }
         }
-        fs.unlinkSync(PID_FILE);
+        // 进程退出后删除 PID 文件（如果还存在）
+        if (fs.existsSync(PID_FILE)) {
+            fs.unlinkSync(PID_FILE);
+        }
         console.log('[mcp] 服务已停止');
         return true;
     }
     catch (err) {
         console.error('[mcp] 停止服务失败:', err);
-        fs.unlinkSync(PID_FILE);
+        if (fs.existsSync(PID_FILE)) {
+            fs.unlinkSync(PID_FILE);
+        }
         return false;
     }
 }
@@ -184,6 +194,12 @@ async function startMcpServerForeground() {
     // 加载统计并清理旧日志
     loadStats();
     cleanupOldLogs(1 / 24);
+    // 创建 MCP Server
+    const server = new McpServer({
+        name: 'wecom-aibot-mcp',
+        version: VERSION,
+    });
+    registerTools(server);
     // 启动 HTTP 服务
     console.log('');
     console.log('  ╔════════════════════════════════════════════════════════╗');
@@ -192,7 +208,7 @@ async function startMcpServerForeground() {
     console.log('  ╚════════════════════════════════════════════════════════╝');
     console.log('');
     console.log(`[mcp] 启动 MCP HTTP Server (端口: ${HTTP_PORT})...`);
-    await startHttpServer();
+    await startHttpServer(server);
     startKeepaliveMonitor();
     console.log(`[mcp] MCP Server 已就绪`);
     console.log(`[mcp] HTTP endpoint: http://127.0.0.1:${HTTP_PORT}/mcp`);
@@ -236,6 +252,7 @@ function startMcpServerBackground() {
     console.log(`[mcp] HTTP endpoint: http://127.0.0.1:18963/mcp`);
     console.log('[mcp] 健康检查: curl http://127.0.0.1:18963/health');
     console.log('[mcp] 停止服务: npx @vrs-soft/wecom-aibot-mcp --stop');
+    console.log('[mcp] 调试模式: npx @vrs-soft/wecom-aibot-mcp --debug');
 }
 async function main() {
     const args = process.argv.slice(2);
@@ -277,11 +294,17 @@ async function main() {
         await deleteMcpConfigInteractive(instanceName);
         process.exit(0);
     }
-    // --start --foreground：前台启动（内部调用）
+    // --start --foreground：前台启动（内部调用，输出到日志文件）
     if (args.includes('--start') && args.includes('--foreground')) {
         await startMcpServerForeground();
         return; // 保持运行，不 exit
     }
+    // --debug：前台启动，日志直接输出到终端
+    if (args.includes('--debug')) {
+        console.log('[mcp] Debug 模式：前台运行，Ctrl+C 退出');
+        await startMcpServerForeground();
+        return;
+    }
     // --start：后台启动
     if (args.includes('--start')) {
         startMcpServerBackground();

package/dist/client.d.ts

@@ -8,6 +8,7 @@ interface ApprovalRecord {
     toolName?: string;
     toolInput?: Record<string, unknown>;
     projectDir?: string;
+    description?: string;
     lastKeepaliveMinute?: number;
     keepaliveCount?: number;
     operationHash?: string;
@@ -36,11 +37,13 @@ declare class WecomClient extends EventEmitter {
     private wasReconnecting;
     private reconnectAttempt;
     private lastDisconnectTime;
+    private disconnectNotifyCount;
     constructor(botId: string, secret: string, targetUserId: string, robotName: string);
     getAuthUrl(): string;
     private setupEventHandlers;
     private handleMessage;
     private handleApprovalResponse;
+    private replyApprovalResult;
     connect(): void;
     disconnect(): void;
     isConnected(): boolean;
@@ -54,6 +57,7 @@ declare class WecomClient extends EventEmitter {
     ccId?: string): Promise<string>;
     sendQueuedApproval(taskId: string, title: string, description: string, targetUser?: string): Promise<boolean>;
     getApprovalResult(taskId: string): 'pending' | 'allow-once' | 'allow-always' | 'deny';
+    setApprovalResult(taskId: string, result: 'allow-once' | 'deny', reason?: string): boolean;
     getPendingApprovals(): string[];
     getPendingApprovalsRecords(): ApprovalRecord[];
     getApprovalRecord(taskId: string): ApprovalRecord | undefined;
@@ -91,7 +95,5 @@ declare class WecomClient extends EventEmitter {
     };
 }
 export declare function initClient(botId: string, secret: string, targetUserId: string, robotName: string): WecomClient;
-export declare function getClient(robotName?: string): WecomClient;
-export declare function getAllClients(): Map<string, WecomClient>;
-export declare function disconnectClient(robotName: string): boolean;
+export declare function getClient(): WecomClient;
 export { WecomClient, ApprovalRecord, MessageRecord, MAX_PENDING_MESSAGES };

package/dist/client.js

@@ -30,6 +30,7 @@ class WecomClient extends EventEmitter {
     wasReconnecting = false; // 跟踪是否处于重连状态
     reconnectAttempt = 0; // 重连尝试次数
     lastDisconnectTime = 0; // 最后断线时间
+    disconnectNotifyCount = 0; // 断线通知次数（最多1次）
     constructor(botId, secret, targetUserId, robotName) {
         super();
         this.botId = botId;
@@ -60,6 +61,7 @@ class WecomClient extends EventEmitter {
             this.connected = true;
             this.wasReconnecting = false;
             this.reconnectAttempt = 0;
+            this.disconnectNotifyCount = 0; // 重连成功后重置断线通知计数
             logAuthenticated();
             // 重连成功后发送通知
             if (wasReconnecting) {
@@ -75,10 +77,13 @@ class WecomClient extends EventEmitter {
             this.wasReconnecting = true;
             this.lastDisconnectTime = Date.now();
             logDisconnected(reason);
-            // 发送断线通知
-            this.sendText('【系统】连接中断，正在重连...').catch(err => {
-                console.error('[wecom] 发送断线通知失败:', err);
-            });
+            // 断线通知最多发1次
+            if (this.disconnectNotifyCount < 1) {
+                this.disconnectNotifyCount++;
+                this.sendText('【系统】连接中断，正在重连...').catch(err => {
+                    console.error('[wecom] 发送断线通知失败:', err);
+                });
+            }
         });
         this.wsClient.on('reconnecting', (attempt) => {
             this.reconnectAttempt = attempt;
@@ -106,7 +111,8 @@ class WecomClient extends EventEmitter {
         });
         // 监听模板卡片事件（审批结果）
         this.wsClient.on('event.template_card_event', (frame) => {
-            console.log('[wecom] 收到 template_card_event 事件');
+            console.log('[wecom] 收到 template_card_event 事件，完整 frame:');
+            console.log(JSON.stringify(frame, null, 2));
             this.handleApprovalResponse(frame);
         });
         // 监听进入会话事件
@@ -184,23 +190,18 @@ class WecomClient extends EventEmitter {
     }
     handleApprovalResponse(frame) {
         const event = frame.body?.event;
-        if (!event)
-            return;
-        // 调试：打印完整事件结构
-        console.log('[wecom] 审批事件原始结构:', JSON.stringify(event).substring(0, 500));
-        // task_id 和 event_key 可能在 event 层级（SDK 扁平化）
-        // 也可能嵌套在 template_card_event 对象内（WeChat 原始结构）
-        let taskId = event.task_id;
-        let eventKey = event.event_key;
-        // 如果直接找不到，尝试嵌套结构
-        if (!taskId && event.template_card_event) {
-            taskId = event.template_card_event.task_id;
-            eventKey = event.template_card_event.event_key;
-        }
-        if (!taskId) {
-            console.log('[wecom] 审批事件未找到 task_id，事件 keys:', Object.keys(event));
+        console.log('[wecom] handleApprovalResponse body.event:', JSON.stringify(event));
+        if (!event) {
+            console.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()]);
+        if (!taskId)
+            return;
         console.log(`[wecom] 收到审批响应: taskId=${taskId}, key=${eventKey}`);
         const approval = this.approvals.get(taskId);
         if (approval && !approval.resolved) {
@@ -213,10 +214,35 @@ class WecomClient extends EventEmitter {
                 : eventKey === 'allow-always' ? '✅ 已允许（永久）'
                     : '❌ 已拒绝';
             const toolInfo = approval.toolName ? `: ${approval.toolName}` : '';
-            this.sendText(`**审批结果**${toolInfo}\n\n${resultText}`).catch(err => {
+            const descInfo = approval.description ? `\n\n> ${approval.description}` : '';
+            const content = `**审批结果**${toolInfo}\n\n${resultText}${descInfo}`;
+            this.sendText(content).catch(err => {
                 console.error('[wecom] 发送审批确认失败:', err);
             });
         }
+        else if (approval && approval.resolved) {
+            console.log(`[wecom] 审批已解决，跳过点击: ${taskId}, resolved=${approval.resolved}, result=${approval.result}`);
+        }
+        else {
+            console.log(`[wecom] 审批记录不存在: ${taskId}`);
+        }
+    }
+    // 使用 reply 方法回复审批结果（会有引用效果）
+    async replyApprovalResult(frame, content) {
+        if (!this.connected) {
+            console.log('[wecom] 未连接，无法回复');
+            return;
+        }
+        try {
+            await this.wsClient.reply(frame, {
+                msgtype: 'markdown',
+                markdown: { content },
+            });
+            console.log(`[wecom] 已回复审批结果`);
+        }
+        catch (err) {
+            console.error(`[wecom] 回复失败: ${err}`);
+        }
     }
     // 连接
     connect() {
@@ -313,7 +339,7 @@ class WecomClient extends EventEmitter {
         if (toolInput && toolName) {
             const operationHash = hashOperation(ccId ?? '', toolName, toolInput);
             const existing = this.findApprovalByHash(operationHash);
-            if (existing && !existing.resolved) {
+            if (existing) {
                 console.log(`[wecom] 复用已有审批: ${existing.taskId} (hash: ${operationHash.slice(0, 8)}...)`);
                 return existing.taskId;
             }
@@ -327,6 +353,7 @@ class WecomClient extends EventEmitter {
             timestamp: Date.now(),
             toolName,
             toolInput,
+            description, // 保存审批请求原文
             operationHash,
         });
         // 断线时将审批请求加入队列，等待重连后发送
@@ -401,6 +428,32 @@ class WecomClient extends EventEmitter {
         }
         return 'pending';
     }
+    // 手动设置审批结果（供 Hook 超时自动决策使用）
+    setApprovalResult(taskId, result, reason) {
+        const approval = this.approvals.get(taskId);
+        if (!approval) {
+            console.log(`[wecom] 设置审批结果失败：记录不存在 ${taskId}`);
+            return false;
+        }
+        if (approval.resolved) {
+            console.log(`[wecom] 设置审批结果失败：已解决 ${taskId}`);
+            return false;
+        }
+        approval.resolved = true;
+        approval.result = result;
+        approval.timestamp = Date.now();
+        this.emit('approval_resolved', { taskId, result });
+        // 发送确认消息给用户（包含超时原因和原文引用）
+        const resultText = result === 'deny' ? '❌ 已拒绝' : '✅ 已允许';
+        const reasonText = reason ? `\n\n原因：${reason}` : '';
+        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);
+        });
+        console.log(`[wecom] 超时自动决策已设置: ${taskId} → ${result}`);
+        return true;
+    }
     // 获取所有待处理的审批任务 ID（供 hook 轮询使用）
     getPendingApprovals() {
         return Array.from(this.approvals.entries())
@@ -560,46 +613,20 @@ class WecomClient extends EventEmitter {
         };
     }
 }
-// 多实例支持（按 robotName 索引）
-const instances = new Map();
+// 单例实例
+let instance = null;
 export function initClient(botId, secret, targetUserId, robotName) {
-    // 如果该机器人已存在，先断开旧连接
-    if (instances.has(robotName)) {
-        instances.get(robotName).disconnect();
+    if (instance) {
+        instance.disconnect();
     }
-    const client = new WecomClient(botId, secret, targetUserId, robotName);
-    client.connect();
-    instances.set(robotName, client);
-    return client;
+    instance = new WecomClient(botId, secret, targetUserId, robotName);
+    instance.connect();
+    return instance;
 }
-export function getClient(robotName) {
-    if (robotName) {
-        const client = instances.get(robotName);
-        if (!client) {
-            throw new Error(`WecomClient 未初始化：机器人 "${robotName}" 不存在`);
-        }
-        return client;
-    }
-    // 无参数时返回第一个实例（向后兼容）
-    if (instances.size === 0) {
+export function getClient() {
+    if (!instance) {
         throw new Error('WecomClient 未初始化，请先调用 initClient');
     }
-    const first = instances.values().next().value;
-    if (!first) {
-        throw new Error('WecomClient 未初始化');
-    }
-    return first;
-}
-export function getAllClients() {
-    return instances;
-}
-export function disconnectClient(robotName) {
-    const client = instances.get(robotName);
-    if (client) {
-        client.disconnect();
-        instances.delete(robotName);
-        return true;
-    }
-    return false;
+    return instance;
 }
 export { WecomClient, MAX_PENDING_MESSAGES };

package/dist/config-wizard.js

@@ -252,7 +252,7 @@ function writeHookScript() {
 # HTTP Transport 版本
 #
 # 固定端口: 18963
-# 直接检查 $(pwd)/.claude/headless.json
+# 检查 $(pwd)/.claude/wecom-aibot.json 的 wechatMode 和 autoApprove 字段
 
 MCP_PORT=18963
 
@@ -273,12 +273,18 @@ case "$TOOL_NAME" in
     ;;
 esac
 
-# 直接检查项目目录的 headless 状态文件
+# 检查项目目录的微信模式配置文件
 PROJECT_DIR=$(pwd)
-HEADLESS_FILE="$PROJECT_DIR/.claude/headless.json"
+CONFIG_FILE="$PROJECT_DIR/.claude/wecom-aibot.json"
 
-# 不在 headless 模式
-if [[ ! -f "$HEADLESS_FILE" ]]; then
+# 配置文件不存在，不在微信模式
+if [[ ! -f "$CONFIG_FILE" ]]; then
+  exit 0
+fi
+
+# 检查 wechatMode 是否为 true（微信模式开关）
+WECHAT_MODE=$(jq -r '.wechatMode // false' "$CONFIG_FILE" 2>/dev/null)
+if [[ "$WECHAT_MODE" != "true" ]]; then
   exit 0
 fi
 
@@ -288,17 +294,10 @@ if ! echo "$HEALTH" | jq -e '.status == "ok"' > /dev/null 2>&1; then
   exit 0
 fi
 
-# 从 headless.json 提取 ccId（优先 agentName，回退 ccId）
-CC_ID=$(jq -r '.agentName // .ccId // empty' "$HEADLESS_FILE" 2>/dev/null)
-
-# 发送审批请求（包含 ccId 用于路由）
+# 发送审批请求（使用 pwd 作为 projectDir）
 TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}')
-BODY=$(jq -n \\
-  --arg tool_name "$TOOL_NAME" \\
-  --argjson tool_input "$TOOL_INPUT" \\
-  --arg project_dir "$PROJECT_DIR" \\
-  --arg cc_id "$CC_ID" \\
-  '{"tool_name":$tool_name,"tool_input":$tool_input,"projectDir":$project_dir,"ccId":$cc_id}')
+BODY=$(jq -n --arg tool_name "$TOOL_NAME" --argjson tool_input "$TOOL_INPUT" --arg project_dir "$PROJECT_DIR" \\
+  '{"tool_name":$tool_name,"tool_input":$tool_input,"projectDir":$project_dir}')
 
 RESPONSE=$(curl -s -m 10 -X POST "http://127.0.0.1:$MCP_PORT/approve" \\
   -H "Content-Type: application/json" \\
@@ -329,22 +328,44 @@ while [[ $POLL_COUNT -lt $MAX_POLL ]]; do
   fi
 done
 
-# 超时处理：智能代批
+# 超时处理：根据 autoApprove 决定行为
+# autoApprove: false → 继续等待（无限轮询）
+# autoApprove: true → 智能代批
+
+AUTO_APPROVE=$(jq -r '.autoApprove // false' "$CONFIG_FILE" 2>/dev/null)
+if [[ "$AUTO_APPROVE" != "true" ]]; then
+  # autoApprove 关闭，继续无限等待用户响应
+  while true; do
+    sleep 2
+    STATUS=$(curl -s -m 3 "http://127.0.0.1:$MCP_PORT/approval_status/$TASK_ID" 2>/dev/null)
+    RESULT=$(echo "$STATUS" | jq -r '.result // empty')
+
+    if [[ "$RESULT" == "allow-once" || "$RESULT" == "allow-always" ]]; then
+      printf '%s\\n' '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow"}}}'
+      exit 0
+    elif [[ "$RESULT" == "deny" ]]; then
+      printf '%s\\n' '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"deny","message":"用户拒绝"}}}'
+      exit 0
+    fi
+  done
+fi
+
+# autoApprove: true，执行智能代批
 # 规则：删除命令→拒绝，项目内操作→允许，项目外操作→拒绝
 
 # 检查是否是删除命令
 IS_DELETE=0
 if [[ "$TOOL_NAME" == "Bash" ]]; then
   CMD=$(echo "$TOOL_INPUT" | jq -r '.command // empty')
-  if [[ "$CMD" =~ ^rm\\ ]] || [[ "$CMD" =~ \\ rm\\ ]] || \
-     [[ "$CMD" =~ ^rmdir\\ ]] || [[ "$CMD" =~ \\ rmdir\\ ]] || \
-     [[ "$CMD" =~ ^unlink\\ ]] || [[ "$CMD" =~ rm\\ -rf ]]; then
+  if [[ "$CMD" == rm* ]] || [[ "$CMD" == *" rm "* ]] || [[ "$CMD" == *"-rf"* ]]; then
     IS_DELETE=1
   fi
 fi
 
 # 删除操作 → 永远拒绝
 if [[ $IS_DELETE -eq 1 ]]; then
+  # 通知 MCP Server 发送微信消息
+  curl -s -m 5 -X POST "http://127.0.0.1:$MCP_PORT/approval_timeout/$TASK_ID" -H "Content-Type: application/json" -d '{"result":"deny","reason":"超时自动拒绝：删除操作需人工确认"}' > /dev/null 2>&1 &
   printf '%s\\n' '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"deny","message":"超时自动拒绝：删除操作需人工确认"}}}'
   exit 0
 fi
@@ -355,12 +376,7 @@ IS_IN_PROJECT=0
 case "$TOOL_NAME" in
   Bash)
     CMD=$(echo "$TOOL_INPUT" | jq -r '.command // empty')
-    if [[ "$CMD" == *"$PROJECT_DIR"* ]] || \
-       [[ "$CMD" =~ ^\\./ ]] || \
-       [[ "$CMD" =~ ^npm\\ ]] || \
-       [[ "$CMD" =~ ^npx\\ ]] || \
-       [[ "$CMD" =~ ^git\\ ]] || \
-       [[ "$CMD" =~ ^node\\ ]]; then
+    if [[ "$CMD" == *"$PROJECT_DIR"* ]] || [[ "$CMD" == ./* ]] || [[ "$CMD" == npm* ]] || [[ "$CMD" == npx* ]] || [[ "$CMD" == git* ]] || [[ "$CMD" == node* ]]; then
       IS_IN_PROJECT=1
     fi
     ;;
@@ -382,8 +398,12 @@ esac
 
 # 根据项目内/外决策
 if [[ $IS_IN_PROJECT -eq 1 ]]; then
+  # 通知 MCP Server 发送微信消息
+  curl -s -m 5 -X POST "http://127.0.0.1:$MCP_PORT/approval_timeout/$TASK_ID" -H "Content-Type: application/json" -d '{"result":"allow-once","reason":"超时自动允许：项目内操作"}' > /dev/null 2>&1 &
   printf '%s\\n' '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow","message":"超时自动允许：项目内操作"}}}'
 else
+  # 通知 MCP Server 发送微信消息
+  curl -s -m 5 -X POST "http://127.0.0.1:$MCP_PORT/approval_timeout/$TASK_ID" -H "Content-Type: application/json" -d '{"result":"deny","reason":"超时自动拒绝：项目外操作需人工确认"}' > /dev/null 2>&1 &
   printf '%s\\n' '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"deny","message":"超时自动拒绝：项目外操作需人工确认"}}}'
 fi
 `;

package/dist/connection-log.d.ts

@@ -4,7 +4,7 @@
  * 记录 WebSocket 连接状态变化，便于分析连接问题
  */
 interface ConnectionRecord {
-    event: 'connected' | 'authenticated' | 'disconnected' | 'reconnecting' | 'error' | 'warn';
+    event: 'connected' | 'authenticated' | 'disconnected' | 'reconnecting' | 'error';
     timestamp: string;
     isoTime: string;
     reason?: string;
@@ -28,7 +28,6 @@ export declare function logAuthenticated(): void;
 export declare function logDisconnected(reason: string): void;
 export declare function logReconnecting(attempt: number): void;
 export declare function logError(errorMessage: string): void;
-export declare function logWarn(message: string): void;
 export declare function getStats(): ConnectionStats;
 export declare function getRecentLogs(count?: number): ConnectionRecord[];
 export declare function cleanupOldLogs(daysToKeep?: number): void;

package/dist/connection-log.js

@@ -160,16 +160,6 @@ export function logError(errorMessage) {
     writeLog(record);
     updateStats(record);
 }
-export function logWarn(message) {
-    const now = new Date();
-    const record = {
-        event: 'warn',
-        timestamp: now.toISOString().replace('T', ' ').slice(0, 19),
-        isoTime: now.toISOString(),
-        errorMessage: message,
-    };
-    writeLog(record);
-}
 // 获取当前统计
 export function getStats() {
     return { ...stats };

package/dist/connection-manager.js

@@ -19,8 +19,6 @@ import { WecomClient } from './client.js';
 import { listAllRobots } from './config-wizard.js';
 // 连接池：robotName → ConnectionState
 const connectionPool = new Map();
-// 空闲超时：30 分钟无活跃自动断开
-const INACTIVE_TIMEOUT = 30 * 60 * 1000;
 const CONFIG_DIR = path.join(os.homedir(), '.wecom-aibot-mcp');
 /**
  * 根据机器人名称查找配置
@@ -124,7 +122,6 @@ export async function connectRobot(robotName, agentName) {
         robotName: robot.name,
         client,
         connectedAt: Date.now(),
-        lastActive: Date.now(),
         agentName,
     };
     connectionPool.set(robot.name, state);
@@ -153,9 +150,8 @@ export async function getClient(robotName) {
     if (!state) {
         return null;
     }
-    // 如果已连接，更新 lastActive 并返回
+    // 如果已连接，直接返回
     if (state.client.isConnected()) {
-        state.lastActive = Date.now();
         return state.client;
     }
     // 断开了，尝试重连
@@ -245,19 +241,3 @@ export async function connectAllRobots() {
         }
     }
 }
-/**
- * 清理空闲连接（30 分钟无活跃自动断开）
- * 每 5 分钟调用一次
- */
-function cleanupIdleConnections() {
-    const now = Date.now();
-    for (const [robotName, state] of connectionPool) {
-        if (now - state.lastActive > INACTIVE_TIMEOUT) {
-            console.log(`[connection] 断开空闲机器人: ${robotName}（${Math.floor((now - state.lastActive) / 60000)} 分钟无活跃）`);
-            state.client.disconnect();
-            connectionPool.delete(robotName);
-        }
-    }
-}
-// 启动空闲连接清理定时器（5 分钟）
-setInterval(cleanupIdleConnections, 5 * 60 * 1000).unref();

package/dist/http-server.d.ts

@@ -2,26 +2,37 @@
  * HTTP 服务模块
  *
  * 提供以下端点：
- * - POST /mcp - MCP Streamable HTTP endpoint
+ * - POST /mcp - MCP Streamable HTTP endpoint (stateful session mode)
  * - POST /approve - 审批请求
  * - GET /approval_status/:taskId - 审批状态查询
  * - GET /health - 健康检查
  * - GET /state - 系统状态查询
  *
- * 架构：使用 ccId 直接管理，不使用 sessionId 业务层概念。
- * MCP 协议层的 sessionId 由 SDK 内部管理，不暴露给业务逻辑。
+ * v2.0 架构变更：
+ * - 使用 Session 管理，不再使用 projectDir
+ * - Session → robotName → WebSocket Connection
  */
-export declare const HTTP_PORT: number;
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const HTTP_PORT = 18963;
 export declare const HOOK_SCRIPT_PATH: string;
-export declare function registerActiveCcId(ccId: string): void;
-export declare function unregisterActiveCcId(ccId: string): void;
-export declare function hasActiveHeadlessSession(): boolean;
-export declare function getFirstActiveCcId(): {
-    ccId: string;
+interface SessionData {
     robotName: string;
-} | null;
+    agentName?: string;
+    ccId: string;
+    createdAt: number;
+}
 export declare function generateCcId(): string;
-export declare function pushMessageToAllClients(robotName: string, message: {
+export declare function setSessionData(sessionId: string, data: SessionData): void;
+export declare function getSessionData(sessionId: string): SessionData | null;
+export declare function getSessionDataById(sessionId: string | undefined): SessionData | null;
+export declare function deleteSession(sessionId: string): void;
+export declare function hasActiveHeadlessSession(): boolean;
+export declare function getFirstActiveSession(): {
+    sessionId: string;
+    data: SessionData;
+} | null;
+export declare function findSessionByRobotName(robotName: string): string | null;
+export declare function pushMessageToSession(robotName: string, message: {
     msgid: string;
     content: string;
     from_userid: string;
@@ -32,7 +43,13 @@ export declare function pushMessageToAllClients(robotName: string, message: {
 export interface ApprovalRequest {
     tool_name: string;
     tool_input: Record<string, unknown>;
+    projectDir?: string;
+    ccId?: string;
 }
-export declare function startHttpServer(port?: number): Promise<void>;
+export declare function registerCcId(ccId: string, robotName: string): void;
+export declare function unregisterCcId(ccId: string): void;
+export declare function getRobotByCcId(ccId: string): string | null;
+export declare function startHttpServer(_server: McpServer, port?: number): Promise<void>;
 export declare function stopHttpServer(): void;
 export declare function cleanupPortFile(): void;
+export {};