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

package/README.md

@@ -1,5 +1,7 @@
 # @vrs-soft/wecom-aibot-mcp
 
+中文 | [English](README_EN.md)
+
 企业微信智能机器人 MCP 服务 - Claude Code 远程审批通道
 
 > 通过企业微信智能机器人实现 Claude Code 的远程审批和消息推送，离开电脑也能处理决策请求。
@@ -9,7 +11,6 @@
 - 🔐 **远程审批**：敏感操作通过微信卡片审批，支持"允许一次/拒绝"
 - 💬 **双向通信**：任务进度、完成通知实时推送到微信
 - 📱 **Headless 模式**：离开电脑时切换到微信交互，长轮询实时接收消息
-- 🔄 **智能代批**：超时自动审批，项目内操作允许，删除操作拒绝
 - 🤖 **多机器人支持**：支持配置多个机器人，团队场景下多人独立使用
 - 🌐 **HTTP Transport**：使用 HTTP 传输，支持多实例共享服务
 
@@ -143,6 +144,7 @@ npx @vrs-soft/wecom-aibot-mcp
 | `npx @vrs-soft/wecom-aibot-mcp --add` | 添加新机器人 |
 | `npx @vrs-soft/wecom-aibot-mcp --delete` | 删除机器人配置 |
 | `npx @vrs-soft/wecom-aibot-mcp --uninstall` | 完全卸载 |
+| `npx @vrs-soft/wecom-aibot-mcp --debug` | 前台启动（输出调试日志） |
 
 ### 添加新机器人
 
@@ -290,6 +292,36 @@ Claude：执行命令，发送结果到群聊
 }
 ```
 
+### 超时审批配置
+
+在 `~/.wecom-aibot-mcp/config.json` 中可配置审批超时时间：
+
+```json
+{
+  "botId": "bot-xxx",
+  "secret": "sec-yyy",
+  "targetUserId": "user1",
+  "nameTag": "机器人1",
+  "autoApproveTimeout": 600
+}
+```
+
+- `autoApproveTimeout`: 审批超时时间（秒），默认 600 秒（10 分钟）
+- 超时后，项目目录内的操作会自动允许，项目外的操作会自动拒绝
+
+### 调试模式
+
+使用 `--debug` 启动可在终端查看 hook 脚本的调试日志：
+
+```bash
+npx @vrs-soft/wecom-aibot-mcp --debug
+```
+
+调试日志会输出到 stderr，包括：
+- 审批请求拦截信息
+- 超时时间配置
+- 操作类型判断详情
+
 ## 故障排查
 
 ### 认证失败（错误码 40058）

package/dist/bin.js

@@ -13,13 +13,15 @@ import { spawn } from 'child_process';
 import * as fs from 'fs';
 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 { runConfigWizard, loadConfig, saveConfig, deleteConfig, deleteMcpConfigInteractive, uninstall, addMcpConfig, detectUserIdFromMessage, ensureHookInstalled, listAllRobots, ensureGlobalConfigs, } 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';
-const VERSION = '1.2.0';
+const VERSION = '1.4.2';
 const PID_FILE = path.join(os.homedir(), '.wecom-aibot-mcp', 'server.pid');
 function showHelp() {
     console.log(`
@@ -34,8 +36,11 @@ function showHelp() {
 选项:
   --help, -h      显示帮助信息
   --version, -v   显示版本号
+  --upgrade       强制升级全局配置（覆盖 MCP 配置、权限、skill）
+  --reinstall     重新安装全局配置（删除后重新写入，保留机器人配置）
   --start         启动 MCP Server（后台服务模式）
   --stop          停止 MCP Server
+  --debug         前台启动 MCP Server（日志直接输出到终端，用于调试）
   --status        显示服务状态和机器人配置
   --config        重新配置默认机器人（修改 Bot ID / Secret / 目标用户）
   --add           添加新的机器人配置（多机器人场景）
@@ -116,8 +121,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 +151,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 +196,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 +210,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,9 +254,15 @@ 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);
+    // --reinstall 命令需要先删除再安装，跳过开头的 ensureGlobalConfigs
+    if (!args.includes('--reinstall')) {
+        // 强制覆盖所有全局配置（不依赖智能体）
+        ensureGlobalConfigs();
+    }
     // 解析命令行参数
     if (args.includes('--help') || args.includes('-h')) {
         showHelp();
@@ -248,6 +272,75 @@ async function main() {
         showVersion();
         process.exit(0);
     }
+    // --upgrade 命令：强制升级全局配置（已在启动时执行，这里显示结果）
+    if (args.includes('--upgrade')) {
+        console.log('\n[mcp] ✅ 全局配置已更新完成！');
+        console.log('[mcp] 配置位置:');
+        console.log('  - ~/.claude.json (MCP Server 配置)');
+        console.log('  - ~/.claude/settings.local.json (权限和 Hook)');
+        console.log('  - ~/.claude/skills/headless-mode/ (Skill)');
+        console.log('  - ~/.wecom-aibot-mcp/version.json (版本记录)');
+        console.log('\n[mcp] 请重启 Claude Code 以加载最新配置');
+        process.exit(0);
+    }
+    // --reinstall 命令：删除所有全局配置（保留机器人配置）后重新安装
+    if (args.includes('--reinstall')) {
+        console.log('\n[mcp] 重新安装全局配置...');
+        console.log('[mcp] 保留所有机器人配置: ~/.wecom-aibot-mcp/config.json 和 robot-*.json');
+        const CLAUDE_CONFIG_FILE = path.join(os.homedir(), '.claude.json');
+        const CLAUDE_SETTINGS_FILE = path.join(os.homedir(), '.claude', 'settings.local.json');
+        const SKILL_DIR = path.join(os.homedir(), '.claude', 'skills', 'headless-mode');
+        const VERSION_FILE = path.join(os.homedir(), '.wecom-aibot-mcp', 'version.json');
+        const HOOK_SCRIPT = path.join(os.homedir(), '.wecom-aibot-mcp', 'permission-hook.sh');
+        // 1. 删除 ~/.claude.json 中的 wecom-aibot 配置
+        if (fs.existsSync(CLAUDE_CONFIG_FILE)) {
+            const content = fs.readFileSync(CLAUDE_CONFIG_FILE, 'utf-8');
+            const config = JSON.parse(content);
+            if (config.mcpServers?.['wecom-aibot']) {
+                delete config.mcpServers['wecom-aibot'];
+                fs.writeFileSync(CLAUDE_CONFIG_FILE, JSON.stringify(config, null, 2));
+                console.log('[mcp] 已删除 ~/.claude.json 中的 wecom-aibot 配置');
+            }
+        }
+        // 2. 删除 ~/.claude/settings.local.json 中的权限和 Hook
+        if (fs.existsSync(CLAUDE_SETTINGS_FILE)) {
+            const content = fs.readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8');
+            const config = JSON.parse(content);
+            if (config.permissions?.allow) {
+                config.permissions.allow = config.permissions.allow.filter((p) => !p.startsWith('mcp__wecom-aibot__'));
+                console.log('[mcp] 已删除 wecom-aibot 工具权限');
+            }
+            if (config.hooks?.PermissionRequest) {
+                config.hooks.PermissionRequest = config.hooks.PermissionRequest.filter((h) => !h.hooks?.some?.((hook) => hook.command?.includes?.('wecom-aibot-mcp')));
+                if (config.hooks.PermissionRequest.length === 0) {
+                    delete config.hooks.PermissionRequest;
+                }
+                console.log('[mcp] 已删除 PermissionRequest hook');
+            }
+            fs.writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(config, null, 2));
+        }
+        // 3. 删除 skill 目录
+        if (fs.existsSync(SKILL_DIR)) {
+            fs.rmSync(SKILL_DIR, { recursive: true });
+            console.log('[mcp] 已删除 ~/.claude/skills/headless-mode/');
+        }
+        // 4. 删除版本文件
+        if (fs.existsSync(VERSION_FILE)) {
+            fs.unlinkSync(VERSION_FILE);
+            console.log('[mcp] 已删除 ~/.wecom-aibot-mcp/version.json');
+        }
+        // 5. 删除 hook 脚本
+        if (fs.existsSync(HOOK_SCRIPT)) {
+            fs.unlinkSync(HOOK_SCRIPT);
+            console.log('[mcp] 已删除 ~/.wecom-aibot-mcp/permission-hook.sh');
+        }
+        // 6. 重新安装全局配置
+        console.log('\n[mcp] 正在重新安装...');
+        ensureGlobalConfigs();
+        console.log('\n[mcp] ✅ 重新安装完成！');
+        console.log('[mcp] 请重启 Claude Code 以加载最新配置');
+        process.exit(0);
+    }
     if (args.includes('--status') || args.includes('--list')) {
         showStatus();
         process.exit(0);
@@ -277,11 +370,22 @@ 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 退出');
+        // 写入 debug 标记文件，hook 脚本检测后日志输出到 stderr
+        const debugFile = path.join(os.homedir(), '.wecom-aibot-mcp', 'debug');
+        fs.writeFileSync(debugFile, 'true');
+        await startMcpServerForeground();
+        // 退出时删除标记文件
+        fs.unlinkSync(debugFile);
+        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.d.ts

@@ -23,6 +23,10 @@ export declare function listAllRobots(): Array<{
     targetUserId: string;
 }>;
 export declare function ensureHookInstalled(): void;
+export declare function ensureGlobalConfigs(): {
+    upgraded: boolean;
+    previousVersion?: string;
+};
 export declare function saveConfig(config: WecomConfig, instanceName?: string): void;
 /**
  * 安装 headless-mode skill 到项目目录