@vrs-soft/wecom-aibot-mcp 2.3.3 → 2.4.1

package/README.md

@@ -4,34 +4,62 @@
 
 企业微信智能机器人 MCP 服务 - 让 Claude Code 通过微信远程审批和交互。
 
-## 功能
-
+**核心功能**：
 - 远程审批敏感操作（Bash/Write/Edit），微信卡片一键通过/拒绝
 - 离开电脑后通过微信下达任务，实时接收进度通知
-- 支持 Channel 模式（SSE 推送唤醒）和 HTTP 模式（心跳轮询）
-- 支持群聊 @机器人，自动回复到对应会话
-- 支持多机器人、多用户
+- 支持群聊 @机器人，多机器人、多用户并发
+- 代理企业微信文档 MCP，支持文档和智能表格操作
+
+---
+
+## 前置条件
+
+企业微信管理后台创建智能机器人，连接方式选「使用长连接」，记录 **Bot ID** 和 **Secret** 以及 **DocURL**（文档url）。
+
+---
 
 ## 安装
 
 ```bash
-npx @vrs-soft/wecom-aibot-mcp
+npx @vrs-soft/wecom-aibot-mcp --setup
 ```
 
-首次运行进入配置向导，完成后自动启动服务并写入 Claude Code MCP 配置。
+根据部署角色选择参数：
 
-**前置条件**：企业微信管理后台创建智能机器人，连接方式选「使用长连接」，记录 Bot ID 和 Secret。
+| 命令 | 角色 | 说明 |
+|------|------|------|
+| `--setup` | 交互式 | 询问本地 / 远程，自动引导 |
+| `--setup --server` | 服务器端 | 配置机器人 + Token，不写本机 MCP 配置 |
+| `--setup --channel` | Channel 客户端 | 连接远程 Server，写入 Channel MCP |
+| `--setup --server --channel` | 本地完整 | HTTP + Channel 全安装 |
 
-## 启动服务
+**Server 端安装后启动**：
 
 ```bash
-# 后台启动（常用）
-npx @vrs-soft/wecom-aibot-mcp --start
+npx @vrs-soft/wecom-aibot-mcp --http-only --start
+```
+
+**后台启动 / 停止（本地或 Server 端）**：
 
-# Channel 模式（需 claude.ai 直连账号）
-claude --dangerously-load-development-channels server:wecom-aibot-channel
+```bash
+npx @vrs-soft/wecom-aibot-mcp --start   # 后台启动
+npx @vrs-soft/wecom-aibot-mcp --stop    # 停止
 ```
 
+---
+
+## 运行模式对比
+
+| | Channel 模式 | HTTP 模式 |
+|-|-------------|----------|
+| 消息接收 | SSE 自动推送唤醒 | `/loop` 心跳轮询 |
+| 响应延迟 | 即时 | ≤1 分钟 |
+| 账号要求 | claude.ai 直连 | 任意（含 API 中转）|
+
+使用微信模式时告诉 Claude「**现在开始通过微信联系**」，会自动触发 `headless-mode` skill。
+
+---
+
 ## 常用命令
 
 | 命令 | 说明 |
@@ -40,60 +68,37 @@ claude --dangerously-load-development-channels server:wecom-aibot-channel
 | `--status` | 查看服务状态和机器人列表 |
 | `--config` | 修改默认机器人配置 |
 | `--add / --delete` | 添加/删除机器人 |
+| `--set-token [token]` | 设置 Auth Token（远程部署用） |
+| `--set-token --clear` | 清除 Auth Token |
 | `--debug` | 前台启动，输出调试日志 |
+| `--http-only` | 仅启动 HTTP MCP Server（服务器端用） |
+| `--channel-only` | 仅配置 Channel MCP（需 `MCP_URL` 环境变量） |
 | `--clean-cache` | 清空 CC 注册表缓存 |
 | `--upgrade` | 强制升级全局配置 |
 | `--uninstall` | 完全卸载 |
 
-## 运行模式
-
-| | Channel 模式 | HTTP 模式 |
-|-|-------------|----------|
-| 消息接收 | SSE 自动推送唤醒 | `/loop` 心跳轮询 |
-| 响应延迟 | 即时 | ≤1 分钟 |
-| 账号要求 | claude.ai 直连 | 任意（含 API 中转）|
-
-使用微信模式时告诉 Claude「现在开始通过微信联系」，会自动触发 `headless-mode` skill。
-
-## 配置说明
-
-机器人配置保存在 `~/.wecom-aibot-mcp/`，支持多个机器人并发：
-
-```bash
-npx @vrs-soft/wecom-aibot-mcp --add   # 添加机器人
-npx @vrs-soft/wecom-aibot-mcp --status # 查看占用情况
-```
-
 超时自动审批（默认 10 分钟）：在机器人配置中设置 `"autoApproveTimeout": 600`。
 
+---
+
 ## 故障排查
 
 ```bash
-# 检查服务
+# 检查服务是否运行
 curl http://127.0.0.1:18963/health
 
 # Channel 不可用（"Channels are not currently available"）
 # → 使用 API Key 或中转服务，改用 HTTP 模式
 
 # 端口占用
-lsof -i :18963 | grep LISTEN   # 找到 PID
+lsof -i :18963 | grep LISTEN
 kill <PID>
 
-# 清理断线残留
+# 清理断线残留的 ccId 注册
 npx @vrs-soft/wecom-aibot-mcp --clean-cache
 ```
 
-## 拆分部署
-
-HTTP MCP 跑在远程服务器，Channel 代理跑在本地：
-
-```bash
-# 远程服务器
-npx @vrs-soft/wecom-aibot-mcp --http-only --start
-
-# 本地
-MCP_URL=http://远程IP:18963 npx @vrs-soft/wecom-aibot-mcp --channel-only
-```
+---
 
 ## License
 

package/dist/bin.js

@@ -13,7 +13,7 @@ import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { runConfigWizard, loadConfig, saveConfig, deleteRobotConfigInteractive, uninstall, addMcpConfig, detectUserIdFromMessage, ensureHookInstalled, listAllRobots, ensureGlobalConfigs, } from './config-wizard.js';
+import { runConfigWizard, loadConfig, saveConfig, deleteRobotConfigInteractive, uninstall, addMcpConfig, detectUserIdFromMessage, ensureHookInstalled, listAllRobots, ensureGlobalConfigs, getAuthToken, setAuthToken, updateMcpAuthHeaders, runRemoteInstallWizard, VERSION, } from './config-wizard.js';
 import { initClient } from './client.js';
 import { registerTools } from './tools/index.js';
 import { startHttpServer, stopHttpServer, HTTP_PORT } from './http-server.js';
@@ -22,7 +22,6 @@ import { getAllConnectionStates } from './connection-manager.js';
 import { loadStats, cleanupOldLogs } from './connection-log.js';
 import { startKeepaliveMonitor, stopKeepaliveMonitor } from './keepalive-monitor.js';
 import { logger } from './logger.js';
-const VERSION = '2.0.0';
 const PID_FILE = path.join(os.homedir(), '.wecom-aibot-mcp', 'server.pid');
 function showHelp() {
     console.log(`
@@ -37,6 +36,10 @@ function showHelp() {
 选项:
   --help, -h      显示帮助信息
   --version, -v   显示版本号
+  --setup         安装向导（交互式，询问本地 / 远程）
+  --setup --server          服务器端安装（配置机器人 + Token）
+  --setup --channel         Channel 客户端安装（写入 Channel MCP）
+  --setup --server --channel  本地完整安装（HTTP + Channel）
   --upgrade       强制升级全局配置（覆盖 MCP 配置、权限、skill）
   --reinstall     重新安装全局配置（删除后重新写入，保留机器人配置）
   --start         启动 MCP Server（后台服务模式）
@@ -52,19 +55,17 @@ function showHelp() {
   --list          列出所有已配置的机器人及其占用状态
   --delete [名称] 删除指定的机器人配置（保留 MCP 配置）
   --uninstall     卸载并删除所有配置（包括 MCP 配置、hook、skill）
+  --set-token [token]  设置/清除 Auth Token（远程部署用，--set-token --clear 清除）
   --clean-cache   清空 CC 注册表缓存（清理异常断线残留的 ccId）
 
 使用流程:
-  1. 首次安装: npx @vrs-soft/wecom-aibot-mcp
-     （进入配置向导，完成后自动后台启动服务）
+  1. 安装:    npx @vrs-soft/wecom-aibot-mcp --setup
+     （根据角色选择参数：--server / --channel / 两者都传 / 不传交互选择）
 
-  2. 已有配置: npx @vrs-soft/wecom-aibot-mcp
-     （显示状态，提示使用 --start 启动）
-
-  3. 启动服务: npx @vrs-soft/wecom-aibot-mcp --start
+  2. 启动服务: npx @vrs-soft/wecom-aibot-mcp --start
      （后台启动 MCP HTTP Server）
 
-  4. 停止服务: npx @vrs-soft/wecom-aibot-mcp --stop
+  3. 停止服务: npx @vrs-soft/wecom-aibot-mcp --stop
 
 拆分部署（远程 HTTP + 本地 Channel）:
 
@@ -104,9 +105,21 @@ function showVersion() {
 function showStatus() {
     const allRobots = listAllRobots();
     const connections = getAllConnectionStates();
+    const authToken = getAuthToken();
     // 检查服务是否运行
     const serverRunning = isServerRunning();
-    console.log(`\n服务状态: ${serverRunning ? '✅ 运行中' : '❌ 未启动'}\n`);
+    console.log(`\n服务状态: ${serverRunning ? '✅ 运行中' : '❌ 未启动'}`);
+    // 显示 Auth Token 状态（带部分 token 显示）
+    if (authToken) {
+        const maskedToken = authToken.length > 12
+            ? `${authToken.slice(0, 8)}...${authToken.slice(-4)}`
+            : `${authToken.slice(0, 4)}...`;
+        console.log(`Auth Token: ✅ 已配置 (${maskedToken})`);
+    }
+    else {
+        console.log(`Auth Token: （未配置，本地部署无需 token）`);
+    }
+    console.log('');
     if (allRobots.length === 0) {
         console.log('尚未配置机器人，请运行 npx @vrs-soft/wecom-aibot-mcp 启动配置向导');
         return;
@@ -122,7 +135,8 @@ function showStatus() {
     for (const robot of allRobots) {
         const usage = robotUsage.get(robot.name);
         const statusTag = usage ? ` [使用中]` : '';
-        console.log(`    Bot名称：  ${robot.name}${statusTag}`);
+        const docTag = robot.doc_mcp_url ? ' [文档✅]' : '';
+        console.log(`    Bot名称：  ${robot.name}${statusTag}${docTag}`);
         console.log(`    Bot ID：   ${robot.botId}`);
         console.log(`    目标用户：${robot.targetUserId}`);
         if (usage) {
@@ -297,9 +311,9 @@ async function main() {
     // 确定安装模式
     const installMode = args.includes('--http-only') ? 'http-only' :
         args.includes('--channel-only') ? 'channel-only' : 'full';
-    // --reinstall 命令需要先删除再安装，跳过开头的 ensureGlobalConfigs
-    // --http-only 模式不需要写 MCP 配置
-    if (!args.includes('--reinstall') && !args.includes('--http-only')) {
+    // --reinstall / --http-only / --setup 命令跳过顶部 ensureGlobalConfigs
+    // （--setup 自己在向导完成后调用）
+    if (!args.includes('--reinstall') && !args.includes('--http-only') && !args.includes('--setup')) {
         // 强制覆盖所有全局配置（不依赖智能体）
         ensureGlobalConfigs(installMode);
     }
@@ -325,7 +339,7 @@ async function main() {
     // --reinstall 命令：删除所有全局配置（保留机器人配置）后重新安装
     if (args.includes('--reinstall')) {
         logger.log('\n[mcp] 重新安装全局配置...');
-        console.log('[mcp] 保留所有机器人配置: ~/.wecom-aibot-mcp/config.json 和 robot-*.json');
+        console.log('[mcp] 保留所有机器人配置: ~/.wecom-aibot-mcp/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 VERSION_FILE = path.join(os.homedir(), '.wecom-aibot-mcp', 'version.json');
@@ -413,6 +427,48 @@ async function main() {
         uninstall();
         process.exit(0);
     }
+    // --set-token 命令：设置/清除 Auth Token
+    if (args.includes('--set-token')) {
+        const tokenIndex = args.indexOf('--set-token');
+        const clearToken = args.includes('--clear');
+        if (clearToken) {
+            setAuthToken(undefined);
+            updateMcpAuthHeaders(undefined);
+            console.log('[mcp] ✅ Auth Token 已清除（服务端 + 客户端 MCP 配置）');
+            process.exit(0);
+        }
+        // 检查下一个参数是否是 token（不是另一个 --flag）
+        const nextArg = args[tokenIndex + 1];
+        const token = (nextArg && !nextArg.startsWith('--')) ? nextArg : undefined;
+        if (!token) {
+            // 交互式输入 token
+            const readline = await import('readline');
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const input = await new Promise((resolve) => {
+                rl.question('请输入 Auth Token（留空取消）: ', (answer) => {
+                    rl.close();
+                    resolve(answer.trim());
+                });
+            });
+            if (!input) {
+                console.log('[mcp] 已取消');
+                process.exit(0);
+            }
+            setAuthToken(input);
+            updateMcpAuthHeaders(input);
+            console.log('[mcp] ✅ Auth Token 已设置');
+            console.log(`[mcp] 服务端: ~/.wecom-aibot-mcp/server.json`);
+            console.log(`[mcp] 客户端: ~/.claude.json MCP headers 已同步`);
+            console.log(`[mcp] Token: ${input.slice(0, 8)}...${input.slice(-4)}`);
+        }
+        else {
+            setAuthToken(token);
+            updateMcpAuthHeaders(token);
+            console.log('[mcp] ✅ Auth Token 已设置');
+            console.log(`[mcp] Token: ${token.slice(0, 8)}...${token.slice(-4)}`);
+        }
+        process.exit(0);
+    }
     if (args.includes('--add')) {
         await addMcpConfig();
         process.exit(0);
@@ -429,9 +485,87 @@ async function main() {
         await startMcpServerForeground();
         return; // 保持运行，不 exit
     }
+    // --setup：统一安装向导
+    //   --setup                    → 交互式（询问本地 / 远程）
+    //   --setup --server           → 服务器端（机器人配置 + Token）
+    //   --setup --channel          → Channel 客户端（写入 Channel MCP）
+    //   --setup --server --channel → 本地完整安装（HTTP + Channel）
+    if (args.includes('--setup')) {
+        const wantServer = args.includes('--server');
+        const wantChannel = args.includes('--channel');
+        if (wantServer && wantChannel) {
+            // 本地完整安装
+            console.log('\n[setup] 本地完整安装模式\n');
+            const savedConfig = loadConfig();
+            if (!savedConfig?.botId)
+                await runConfigWizard();
+            ensureGlobalConfigs('full');
+            startMcpServerBackground();
+            console.log('[setup] 安装完成！请重启 Claude Code 以加载配置');
+        }
+        else if (wantServer) {
+            // 服务器端
+            console.log('\n[setup] Server 安装模式\n');
+            const savedConfig = loadConfig();
+            if (!savedConfig?.botId)
+                await runConfigWizard();
+            const readline = await import('readline');
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const token = await new Promise(resolve => rl.question('Auth Token（Client 端需填写相同 Token，留空跳过）: ', a => { rl.close(); resolve(a.trim()); }));
+            if (token)
+                setAuthToken(token);
+            console.log('\n[setup] Server 配置完成！');
+            console.log('  启动: npx @vrs-soft/wecom-aibot-mcp --http-only --start');
+        }
+        else if (wantChannel) {
+            // Channel 客户端
+            console.log('\n[setup] Channel Client 安装模式\n');
+            let mcpUrl = process.env.MCP_URL;
+            if (!mcpUrl) {
+                const readline = await import('readline');
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                mcpUrl = await new Promise(resolve => rl.question('远程服务器地址（如 https://your-server:18963）: ', a => { rl.close(); resolve(a.trim()); }));
+                if (!mcpUrl) {
+                    console.log('[setup] ❌ 地址不能为空');
+                    process.exit(1);
+                }
+                process.env.MCP_URL = mcpUrl;
+            }
+            if (!getAuthToken()) {
+                const readline = await import('readline');
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                const token = await new Promise(resolve => rl.question('Auth Token: ', a => { rl.close(); resolve(a.trim()); }));
+                if (token)
+                    setAuthToken(token);
+            }
+            ensureGlobalConfigs('channel-only');
+            console.log('[setup] Channel MCP 配置完成！请重启 Claude Code 以加载配置');
+        }
+        else {
+            // 交互式：1/2 模式选择
+            console.log('\n请选择安装模式：\n');
+            console.log('  1. 本地安装（完整功能：HTTP + Channel MCP）');
+            console.log('  2. 远程服务器（连接远程 HTTP MCP）\n');
+            const readline = await import('readline');
+            const modeChoice = await new Promise((resolve) => {
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                rl.question('请选择 (1/2，默认 1): ', a => { rl.close(); resolve(a.trim() || '1'); });
+            });
+            if (modeChoice === '2') {
+                await runRemoteInstallWizard();
+            }
+            else {
+                await runConfigWizard();
+                ensureGlobalConfigs('full');
+                startMcpServerBackground();
+            }
+        }
+        process.exit(0);
+    }
     // --channel：启动 Channel MCP 代理（stdio）
     // 注意：必须在 --debug 之前检查，否则 --channel --debug 会先触发 HTTP Server
-    if (args.includes('--channel')) {
+    // --setup --channel 已在上方处理，这里不拦截
+    if (args.includes('--channel') && !args.includes('--setup')) {
         // 检查 HTTP MCP 的 debug 标记文件
         const debugFile = path.join(os.homedir(), '.wecom-aibot-mcp', 'debug');
         const isDebug = fs.existsSync(debugFile) || args.includes('--debug');
@@ -509,12 +643,10 @@ async function main() {
             config = savedConfig;
         }
         else if (isInteractive) {
-            // TTY 模式下没有配置，启动配置向导
-            console.log('[config] 未找到配置，启动配置向导...\n');
-            const result = await runConfigWizard();
-            config = result.config;
-            instanceName = result.instanceName;
-            ranWizard = true;
+            // TTY 模式下没有配置：提示使用 --setup，不再隐式弹向导
+            console.log('[config] 未找到机器人配置。');
+            console.log('[config] 请运行: npx @vrs-soft/wecom-aibot-mcp --setup');
+            process.exit(1);
         }
         else {
             // 非 TTY 模式（MCP HTTP），必须有配置

package/dist/channel-server.js

@@ -15,7 +15,17 @@ import { z } from 'zod';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { VERSION } from './config-wizard.js';
 const MCP_URL = process.env.MCP_URL || 'http://127.0.0.1:18963';
+const MCP_AUTH_TOKEN = process.env.MCP_AUTH_TOKEN;
+// 构建带 auth 的 fetch headers
+function getAuthHeaders() {
+    const headers = {};
+    if (MCP_AUTH_TOKEN) {
+        headers['Authorization'] = `Bearer ${MCP_AUTH_TOKEN}`;
+    }
+    return headers;
+}
 // Channel 日志文件
 const CHANNEL_LOG_FILE = path.join(os.homedir(), '.wecom-aibot-mcp', 'channel.log');
 /**
@@ -53,6 +63,7 @@ async function initHttpSession() {
             headers: {
                 'Content-Type': 'application/json',
                 'Accept': 'application/json, text/event-stream',
+                ...getAuthHeaders(),
             },
             body: JSON.stringify({
                 jsonrpc: '2.0',
@@ -110,6 +121,7 @@ async function forwardToHttpMcp(toolName, params) {
             'Content-Type': 'application/json',
             'Accept': 'application/json, text/event-stream',
             'mcp-session-id': sessionId,
+            ...getAuthHeaders(),
         },
         body: JSON.stringify({
             jsonrpc: '2.0',
@@ -185,6 +197,7 @@ function connectSSE(ccId) {
             'Accept': 'text/event-stream',
             'Cache-Control': 'no-cache',
             'Connection': 'keep-alive',
+            ...getAuthHeaders(),
         },
     }).then(async (res) => {
         if (!res.ok) {
@@ -459,7 +472,9 @@ function registerChannelTools(server) {
     // ============================================
     server.tool('get_skill', '获取 headless-mode skill 文件内容，用于写入本地项目目录。远程部署时 HTTP MCP 可能不在本地，skill 文件需要从此接口获取。', {}, async () => {
         // 直接请求 HTTP MCP 的 /skill 端点
-        const res = await fetch(`${MCP_URL}/skill`);
+        const res = await fetch(`${MCP_URL}/skill`, {
+            headers: getAuthHeaders(),
+        });
         if (!res.ok) {
             return {
                 content: [{
@@ -576,7 +591,7 @@ export async function startChannelServer() {
     // 创建 MCP Server
     mcpServer = new McpServer({
         name: 'wecom-aibot-channel',
-        version: '2.0.0',
+        version: VERSION,
     }, {
         capabilities: {
             // 必须声明 experimental['claude/channel']，Claude Code 才会注册 notification listener

package/dist/client.d.ts

@@ -25,6 +25,12 @@ interface MessageRecord {
     chattype: 'single' | 'group';
     quoteContent?: string;
 }
+interface PendingMessage {
+    type: 'text' | 'approval';
+    content: any;
+    targetUser?: string;
+    timestamp: number;
+}
 declare class WecomClient extends EventEmitter {
     private wsClient;
     private approvals;
@@ -77,6 +83,10 @@ declare class WecomClient extends EventEmitter {
      * allow-once 消费后标记为已消费
      */
     consumeApproval(taskId: string): 'allow-once' | 'allow-always' | 'deny' | null;
+    /**
+     * 获取所有未解决的审批记录 Map（用于重连时迁移到新 client）
+     */
+    getUnresolvedApprovalMap(): Map<string, ApprovalRecord>;
     /**
      * 注入审批记录（MCP 重启恢复用）
      * 如果 taskId 已存在则跳过，避免覆盖用户已点击的结果
@@ -88,6 +98,15 @@ declare class WecomClient extends EventEmitter {
     cleanupMessages(maxAgeMs?: number): void;
     private flushPendingMessages;
     getPendingMessageCount(): number;
+    /**
+     * 取出所有待发送的审批消息并清空队列（用于 client 迁移）
+     * 仅迁移 approval 类型，text 通知类消息不需要迁移
+     */
+    takePendingApprovalMessages(): PendingMessage[];
+    /**
+     * 注入待发送消息（用于 client 迁移，新 client 连接后会自动重发）
+     */
+    injectPendingMessages(messages: PendingMessage[]): void;
     getReconnectStatus(): {
         wasReconnecting: boolean;
         attempt: number;
@@ -96,4 +115,4 @@ declare class WecomClient extends EventEmitter {
 }
 export declare function initClient(botId: string, secret: string, targetUserId: string, robotName: string): WecomClient;
 export declare function getClient(): WecomClient;
-export { WecomClient, ApprovalRecord, MessageRecord, MAX_PENDING_MESSAGES };
+export { WecomClient, ApprovalRecord, MessageRecord, PendingMessage, MAX_PENDING_MESSAGES };

package/dist/client.js

@@ -528,6 +528,18 @@ class WecomClient extends EventEmitter {
         }
         return approval.result;
     }
+    /**
+     * 获取所有未解决的审批记录 Map（用于重连时迁移到新 client）
+     */
+    getUnresolvedApprovalMap() {
+        const pending = new Map();
+        this.approvals.forEach((approval, taskId) => {
+            if (!approval.resolved) {
+                pending.set(taskId, approval);
+            }
+        });
+        return pending;
+    }
     /**
      * 注入审批记录（MCP 重启恢复用）
      * 如果 taskId 已存在则跳过，避免覆盖用户已点击的结果
@@ -607,6 +619,24 @@ class WecomClient extends EventEmitter {
     getPendingMessageCount() {
         return this.pendingMessages.length;
     }
+    /**
+     * 取出所有待发送的审批消息并清空队列（用于 client 迁移）
+     * 仅迁移 approval 类型，text 通知类消息不需要迁移
+     */
+    takePendingApprovalMessages() {
+        const approvalMessages = this.pendingMessages.filter(m => m.type === 'approval');
+        this.pendingMessages = this.pendingMessages.filter(m => m.type !== 'approval');
+        return approvalMessages;
+    }
+    /**
+     * 注入待发送消息（用于 client 迁移，新 client 连接后会自动重发）
+     */
+    injectPendingMessages(messages) {
+        if (messages.length === 0)
+            return;
+        this.pendingMessages.unshift(...messages);
+        logger.log(`[wecom] 注入待发送消息: ${messages.length} 条`);
+    }
     // 获取重连状态
     getReconnectStatus() {
         return {

package/dist/config-wizard.d.ts

@@ -6,7 +6,11 @@ export interface WecomConfig {
     nameTag?: string;
     doc_mcp_url?: string;
 }
+export declare const VERSION: string;
 export declare function loadConfig(): WecomConfig | null;
+export declare function getAuthToken(): string | undefined;
+export declare function setAuthToken(token: string | undefined): boolean;
+export declare function updateMcpAuthHeaders(token?: string): void;
 export declare function listAllMcpInstances(): Array<{
     name: string;
     config: WecomConfig;
@@ -31,10 +35,14 @@ export declare function getDocMcpUrl(robotName?: string): {
     error?: string;
 };
 export declare function ensureHookInstalled(): void;
-export declare function ensureGlobalConfigs(mode?: 'full' | 'http-only' | 'channel-only'): {
+export declare function ensureGlobalConfigs(mode?: 'full' | 'http-only' | 'channel-only' | 'remote' | 'remote-channel', remoteOptions?: {
+    url: string;
+    token: string;
+}): {
     upgraded: boolean;
     previousVersion?: string;
 };
+export declare function runRemoteInstallWizard(): Promise<'remote' | 'remote-channel' | 'server' | null>;
 export declare function saveConfig(config: WecomConfig, instanceName?: string): boolean;
 /**
  * 安装 headless-mode skill 到项目目录
@@ -64,7 +72,7 @@ export declare function detectUserIdFromMessage(client: any, timeoutSeconds?: nu
  *
  * 优先级：
  * 1. 环境变量（WECOM_BOT_ID, WECOM_SECRET, WECOM_TARGET_USER）
- * 2. 保存的配置文件（~/.wecom-aibot-mcp/config.json）
+ * 2. 保存的配置文件（~/.wecom-aibot-mcp/robot-*.json）
  * 3. 运行配置向导
  */
 export declare function getOrInitConfig(): Promise<WecomConfig>;

package/dist/config-wizard.js

@@ -4,7 +4,7 @@
  * 首次运行时引导用户配置 Bot ID、Secret 和默认目标用户
  *
  * 配置存储位置：
- * - 机器人配置：~/.wecom-aibot-mcp/config.json
+ * - 机器人配置：~/.wecom-aibot-mcp/robot-*.json
  * - MCP 配置：~/.claude.json (仅 URL)
  */
 import * as readline from 'readline';
@@ -14,8 +14,8 @@ import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { logger } from './logger.js';
 const CONFIG_DIR = path.join(os.homedir(), '.wecom-aibot-mcp');
-const BOT_CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const VERSION_FILE = path.join(CONFIG_DIR, 'version.json');
+const SERVER_CONFIG_FILE = path.join(CONFIG_DIR, 'server.json'); // HTTP Server 配置（auth token 等）
 const CLAUDE_CONFIG_FILE = path.join(os.homedir(), '.claude.json');
 const CLAUDE_SETTINGS_FILE = path.join(os.homedir(), '.claude', 'settings.local.json');
 const HOOK_SCRIPT_PATH = path.join(CONFIG_DIR, 'permission-hook.sh');
@@ -23,8 +23,8 @@ const TASK_COMPLETED_HOOK_SCRIPT_PATH = path.join(CONFIG_DIR, 'task-completed-ho
 // Skill 模板路径（包内）- 使用 fileURLToPath 确保跨平台兼容
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-// 版本号（从 package.json 读取）
-const VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8')).version;
+// 版本号（从 package.json 读取，全局共享）
+export const VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8')).version;
 const SKILL_TEMPLATE_DIR = path.join(__dirname, '..', 'skills', 'headless-mode');
 const SKILL_TEMPLATE_FILE = path.join(SKILL_TEMPLATE_DIR, 'SKILL.md');
 // MCP 工具权限列表（需要预授权以避免 headless 模式阻断）
@@ -37,12 +37,14 @@ function ensureConfigDir() {
         fs.mkdirSync(CONFIG_DIR, { recursive: true });
     }
 }
-// 从 ~/.wecom-aibot-mcp/config.json 读取已保存的配置
+// 从 ~/.wecom-aibot-mcp/robot-*.json 读取第一个有效配置
 export function loadConfig() {
     try {
-        // 从机器人配置文件读取
-        if (fs.existsSync(BOT_CONFIG_FILE)) {
-            const content = fs.readFileSync(BOT_CONFIG_FILE, 'utf-8');
+        if (!fs.existsSync(CONFIG_DIR))
+            return null;
+        const files = fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'));
+        for (const file of files) {
+            const content = fs.readFileSync(path.join(CONFIG_DIR, file), 'utf-8');
             const config = JSON.parse(content);
             if (config.botId && config.secret && config.targetUserId) {
                 const result = {
@@ -63,6 +65,71 @@ export function loadConfig() {
     }
     return null;
 }
+// 获取 HTTP Server 的 auth token（从 server.json 读取）
+export function getAuthToken() {
+    if (!fs.existsSync(SERVER_CONFIG_FILE))
+        return undefined;
+    try {
+        const config = JSON.parse(fs.readFileSync(SERVER_CONFIG_FILE, 'utf-8'));
+        return config.authToken || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// 设置/清除 HTTP Server 的 auth token（写入 server.json）
+export function setAuthToken(token) {
+    ensureConfigDir();
+    let config = {};
+    if (fs.existsSync(SERVER_CONFIG_FILE)) {
+        try {
+            config = JSON.parse(fs.readFileSync(SERVER_CONFIG_FILE, 'utf-8'));
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (token) {
+        config.authToken = token;
+    }
+    else {
+        delete config.authToken;
+        // 如果 config 为空，删除文件
+        if (Object.keys(config).length === 0) {
+            if (fs.existsSync(SERVER_CONFIG_FILE))
+                fs.unlinkSync(SERVER_CONFIG_FILE);
+            return true;
+        }
+    }
+    fs.writeFileSync(SERVER_CONFIG_FILE, JSON.stringify(config, null, 2));
+    return true;
+}
+// 更新 ~/.claude.json 中 wecom-aibot MCP 配置的 auth headers
+export function updateMcpAuthHeaders(token) {
+    if (!fs.existsSync(CLAUDE_CONFIG_FILE))
+        return;
+    try {
+        const content = fs.readFileSync(CLAUDE_CONFIG_FILE, 'utf-8');
+        const claudeConfig = JSON.parse(content);
+        if (!claudeConfig.mcpServers)
+            return;
+        // 更新所有 wecom-aibot 相关的 HTTP MCP 配置
+        for (const name of Object.keys(claudeConfig.mcpServers)) {
+            if (name.startsWith('wecom-aibot') && claudeConfig.mcpServers[name].type === 'http') {
+                if (token) {
+                    claudeConfig.mcpServers[name].headers = { Authorization: `Bearer ${token}` };
+                }
+                else {
+                    delete claudeConfig.mcpServers[name].headers;
+                }
+            }
+        }
+        fs.writeFileSync(CLAUDE_CONFIG_FILE, JSON.stringify(claudeConfig, null, 2));
+    }
+    catch {
+        // ignore
+    }
+}
 // 获取所有 wecom-aibot 相关的 MCP 实例
 export function listAllMcpInstances() {
     // 现在只有一个主配置文件
@@ -139,18 +206,8 @@ export function deleteRobotConfig(robotName) {
         }
         // 查找机器人对应的配置文件
         let configFile = null;
-        let isDefault = false;
-        // 检查是否是默认机器人（config.json）
-        if (fs.existsSync(BOT_CONFIG_FILE)) {
-            const config = JSON.parse(fs.readFileSync(BOT_CONFIG_FILE, 'utf-8'));
-            const name = config.nameTag || `机器人-${config.botId?.slice(0, 8) || 'unknown'}`;
-            if (name === robotName) {
-                configFile = BOT_CONFIG_FILE;
-                isDefault = true;
-            }
-        }
-        // 检查其他机器人配置文件
-        if (!configFile && fs.existsSync(CONFIG_DIR)) {
+        // 从 robot-*.json 中查找
+        if (fs.existsSync(CONFIG_DIR)) {
             const files = fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'));
             for (const file of files) {
                 const filePath = path.join(CONFIG_DIR, file);
@@ -166,30 +223,8 @@ export function deleteRobotConfig(robotName) {
             console.log(`[config] 未找到机器人 "${robotName}" 的配置文件`);
             return false;
         }
-        // 如果是默认机器人，需要处理迁移
-        if (isDefault) {
-            // 查找其他机器人配置文件
-            const otherRobotFiles = fs.existsSync(CONFIG_DIR)
-                ? fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'))
-                : [];
-            if (otherRobotFiles.length > 0) {
-                // 将第一个其他机器人提升为默认
-                const newDefaultFile = path.join(CONFIG_DIR, otherRobotFiles[0]);
-                const newDefaultConfig = JSON.parse(fs.readFileSync(newDefaultFile, 'utf-8'));
-                fs.writeFileSync(BOT_CONFIG_FILE, JSON.stringify(newDefaultConfig, null, 2));
-                fs.unlinkSync(newDefaultFile);
-                console.log(`[config] 已将 "${newDefaultConfig.nameTag || otherRobotFiles[0]}" 提升为默认机器人`);
-            }
-            else {
-                // 没有其他机器人，直接删除默认配置
-                fs.unlinkSync(BOT_CONFIG_FILE);
-                console.log('[config] 已删除最后一个机器人配置');
-            }
-        }
-        else {
-            // 不是默认机器人，直接删除
-            fs.unlinkSync(configFile);
-        }
+        // 直接删除
+        fs.unlinkSync(configFile);
         console.log(`[config] 已删除机器人: ${robotName}`);
         return true;
     }
@@ -302,7 +337,7 @@ export function uninstall() {
             logger.error('[config] 删除 headless 状态索引失败:', err);
         }
     }
-    // 删除整个配置目录（包括 config.json、robot-*.json、hook 脚本、日志等）
+    // 删除整个配置目录（包括 robot-*.json、hook 脚本、日志等）
     // 使用 recursive: true 和 force: true 确保完全删除
     if (fs.existsSync(CONFIG_DIR)) {
         try {
@@ -409,13 +444,14 @@ if ! echo "$HEALTH" | jq -e '.status == "ok"' > /dev/null 2>&1; then
   exit 0
 fi
 
-# 读取当前项目使用的机器人名称
+# 读取当前项目使用的机器人名称和 ccId
 ROBOT_NAME=$(jq -r '.robotName // empty' "$CONFIG_FILE" 2>/dev/null)
+CC_ID=$(jq -r '.ccId // empty' "$CONFIG_FILE" 2>/dev/null)
 
 # 发送审批请求（使用 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 robot_name "$ROBOT_NAME" \\
-  '{"tool_name":$tool_name,"tool_input":$tool_input,"projectDir":$project_dir,"robotName":$robot_name}')
+BODY=$(jq -n --arg tool_name "$TOOL_NAME" --argjson tool_input "$TOOL_INPUT" --arg project_dir "$PROJECT_DIR" --arg robot_name "$ROBOT_NAME" --arg cc_id "$CC_ID" \\
+  '{"tool_name":$tool_name,"tool_input":$tool_input,"projectDir":$project_dir,"robotName":$robot_name,"ccId":$cc_id}')
 
 log_debug "[$(date)] Sending approval request..."
 RESPONSE=$(curl -s -m 10 -X POST "http://127.0.0.1:$MCP_PORT/approve" \\
@@ -672,18 +708,10 @@ function writeMcpServerConfig(config, instanceName) {
             console.log(`[config] 已更新机器人配置: ${existingConfigFile}`);
         }
         else {
-            // 新配置：检查是否有默认配置文件
-            if (fs.existsSync(BOT_CONFIG_FILE)) {
-                // 有默认配置，创建新的 robot-*.json 文件
-                const newConfigPath = path.join(CONFIG_DIR, `robot-${Date.now()}.json`);
-                fs.writeFileSync(newConfigPath, JSON.stringify(botConfig, null, 2));
-                console.log(`[config] 已添加新机器人配置: ${newConfigPath}`);
-            }
-            else {
-                // 没有默认配置，写入 config.json
-                fs.writeFileSync(BOT_CONFIG_FILE, JSON.stringify(botConfig, null, 2));
-                console.log('[config] 已写入机器人配置 ~/.wecom-aibot-mcp/config.json');
-            }
+            // 新机器人：统一使用 robot-*.json
+            const newConfigPath = path.join(CONFIG_DIR, `robot-${Date.now()}.json`);
+            fs.writeFileSync(newConfigPath, JSON.stringify(botConfig, null, 2));
+            console.log(`[config] 已添加新机器人配置: ${newConfigPath}`);
         }
         // 2. 写入 MCP 配置到 ~/.claude.json（仅 URL）
         let claudeConfig = {};
@@ -707,7 +735,7 @@ function writeMcpServerConfig(config, instanceName) {
         logger.error('[config] 写入配置失败:', err);
         console.log('[config] ⚠️  请手动配置:');
         console.log('');
-        console.log('~/.wecom-aibot-mcp/config.json:');
+        console.log('~/.wecom-aibot-mcp/robot-*.json:');
         console.log(JSON.stringify({
             botId: config.botId,
             secret: config.secret,
@@ -751,6 +779,9 @@ export async function addMcpConfig() {
             console.log('Secret 不能为空');
             secret = await question(rl, 'Secret: ');
         }
+        // 获取文档 MCP URL（可选）
+        console.log('');
+        const docMcpUrl = await question(rl, '文档 MCP URL（可选，企业微信管理后台获取，留空跳过）: ');
         rl.close();
         // 检查是否已存在相同 botId 的配置
         const existingRobots = listAllRobots();
@@ -809,22 +840,14 @@ export async function addMcpConfig() {
             secret,
             targetUserId,
             nameTag: robotName,
+            ...(docMcpUrl ? { doc_mcp_url: docMcpUrl } : {}),
         };
         // 确保配置目录存在
         ensureConfigDir();
-        // 如果是第一个机器人，保存为默认配置
-        const defaultConfigPath = BOT_CONFIG_FILE;
+        // 统一使用 robot-*.json 格式
         const robotConfigPath = path.join(CONFIG_DIR, `robot-${Date.now()}.json`);
-        if (!fs.existsSync(defaultConfigPath)) {
-            // 第一个机器人作为默认
-            fs.writeFileSync(defaultConfigPath, JSON.stringify(robotConfig, null, 2));
-            console.log(`\n[config] ✅ 已设为默认机器人: ${robotName}`);
-        }
-        else {
-            // 后续机器人保存为独立文件
-            fs.writeFileSync(robotConfigPath, JSON.stringify(robotConfig, null, 2));
-            console.log(`\n[config] ✅ 已添加新机器人: ${robotName}`);
-        }
+        fs.writeFileSync(robotConfigPath, JSON.stringify(robotConfig, null, 2));
+        console.log(`\n[config] ✅ 已添加机器人: ${robotName}`);
         console.log(`[config] 用户 ID: ${targetUserId}`);
         // 列出所有机器人
         const robots = listAllRobots();
@@ -842,23 +865,7 @@ export async function addMcpConfig() {
 // 列出所有机器人配置
 export function listAllRobots() {
     const robots = [];
-    // 主配置文件（config.json）
-    if (fs.existsSync(BOT_CONFIG_FILE)) {
-        try {
-            const config = JSON.parse(fs.readFileSync(BOT_CONFIG_FILE, 'utf-8'));
-            const name = config.nameTag || `机器人-${config.botId?.slice(0, 8) || 'unknown'}`;
-            robots.push({
-                name,
-                botId: config.botId,
-                targetUserId: config.targetUserId,
-                ...(config.doc_mcp_url ? { doc_mcp_url: config.doc_mcp_url } : {}),
-            });
-        }
-        catch {
-            // ignore
-        }
-    }
-    // 其他机器人配置
+    // 所有机器人配置（统一 robot-*.json 格式）
     if (fs.existsSync(CONFIG_DIR)) {
         const files = fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'));
         for (const file of files) {
@@ -958,7 +965,7 @@ export function ensureHookInstalled() {
     writeTaskCompletedHookScript();
 }
 // 确保所有全局配置已写入（强制覆盖，不依赖智能体）
-export function ensureGlobalConfigs(mode = 'full') {
+export function ensureGlobalConfigs(mode = 'full', remoteOptions) {
     ensureConfigDir();
     // 读取已安装版本
     let previousVersion;
@@ -981,6 +988,64 @@ export function ensureGlobalConfigs(mode = 'full') {
         fs.writeFileSync(VERSION_FILE, JSON.stringify({ version: VERSION, installedAt: Date.now() }, null, 2));
         return { upgraded, previousVersion };
     }
+    // remote 模式：仅写入远程 HTTP MCP 配置（带 token headers），不装 Channel/Hook
+    if (mode === 'remote') {
+        if (!remoteOptions?.url || !remoteOptions?.token) {
+            console.log('[config] ❌ 远程模式需要提供 URL 和 Token');
+            return { upgraded: false, previousVersion };
+        }
+        let claudeConfig = {};
+        if (fs.existsSync(CLAUDE_CONFIG_FILE)) {
+            claudeConfig = JSON.parse(fs.readFileSync(CLAUDE_CONFIG_FILE, 'utf-8'));
+        }
+        if (!claudeConfig.mcpServers)
+            claudeConfig.mcpServers = {};
+        claudeConfig.mcpServers['wecom-aibot'] = {
+            type: 'http',
+            url: remoteOptions.url,
+            headers: { Authorization: `Bearer ${remoteOptions.token}` },
+        };
+        fs.writeFileSync(CLAUDE_CONFIG_FILE, JSON.stringify(claudeConfig, null, 2));
+        console.log('[config] remote 模式：已写入远程 HTTP MCP 配置（带 Token）');
+        fs.writeFileSync(VERSION_FILE, JSON.stringify({ version: VERSION, installedAt: Date.now() }, null, 2));
+        return { upgraded, previousVersion };
+    }
+    // remote-channel 模式：写入远程 HTTP MCP（带 token）+ Channel MCP
+    if (mode === 'remote-channel') {
+        if (!remoteOptions?.url || !remoteOptions?.token) {
+            console.log('[config] ❌ 远程模式需要提供 URL 和 Token');
+            return { upgraded: false, previousVersion };
+        }
+        let claudeConfig = {};
+        if (fs.existsSync(CLAUDE_CONFIG_FILE)) {
+            claudeConfig = JSON.parse(fs.readFileSync(CLAUDE_CONFIG_FILE, 'utf-8'));
+        }
+        if (!claudeConfig.mcpServers)
+            claudeConfig.mcpServers = {};
+        // HTTP MCP 配置（带 token）
+        claudeConfig.mcpServers['wecom-aibot'] = {
+            type: 'http',
+            url: remoteOptions.url,
+            headers: { Authorization: `Bearer ${remoteOptions.token}` },
+        };
+        // Channel MCP 配置（带 MCP_URL + MCP_AUTH_TOKEN）
+        const binPath = path.join(__dirname, 'bin.js');
+        claudeConfig.mcpServers['wecom-aibot-channel'] = {
+            command: 'node',
+            args: [binPath, '--channel'],
+            env: {
+                MCP_URL: remoteOptions.url,
+                MCP_AUTH_TOKEN: remoteOptions.token,
+            },
+        };
+        fs.writeFileSync(CLAUDE_CONFIG_FILE, JSON.stringify(claudeConfig, null, 2));
+        console.log('[config] remote-channel 模式：已写入 HTTP MCP + Channel MCP 配置（带 Token）');
+        // Channel 模式需要权限配置
+        writeMcpPermissions();
+        console.log('[config] 已写入权限配置到 ~/.claude/settings.local.json');
+        fs.writeFileSync(VERSION_FILE, JSON.stringify({ version: VERSION, installedAt: Date.now() }, null, 2));
+        return { upgraded, previousVersion };
+    }
     // 1. 强制写入 MCP 配置到 ~/.claude.json
     let claudeConfig = {};
     if (fs.existsSync(CLAUDE_CONFIG_FILE)) {
@@ -997,11 +1062,17 @@ export function ensureGlobalConfigs(mode = 'full') {
             console.log('[config] 请设置环境变量: MCP_URL=http://远程IP:18963');
             return { upgraded: false, previousVersion };
         }
-        // Channel MCP 配置：硬编码本地路径
+        // Channel MCP 配置：使用当前模块路径
+        const binPath = path.join(__dirname, 'bin.js');
+        const channelEnv = { MCP_URL: mcpUrl };
+        const authToken = getAuthToken();
+        if (authToken) {
+            channelEnv.MCP_AUTH_TOKEN = authToken;
+        }
         claudeConfig.mcpServers['wecom-aibot-channel'] = {
             command: 'node',
-            args: ['/Volumes/Mac_Data/VScode/wecom-aibot-mcp/dist/bin.js', '--channel'],
-            env: { MCP_URL: mcpUrl },
+            args: [binPath, '--channel'],
+            env: channelEnv,
         };
         console.log(`[config] Channel-only 模式：Channel MCP 使用本地路径`);
     }
@@ -1011,10 +1082,11 @@ export function ensureGlobalConfigs(mode = 'full') {
             type: 'http',
             url: 'http://127.0.0.1:18963/mcp',
         };
-        // Channel MCP 配置：硬编码本地路径
+        // Channel MCP 配置：使用当前模块路径
+        const binPath = path.join(__dirname, 'bin.js');
         claudeConfig.mcpServers['wecom-aibot-channel'] = {
             command: 'node',
-            args: ['/Volumes/Mac_Data/VScode/wecom-aibot-mcp/dist/bin.js', '--channel'],
+            args: [binPath, '--channel'],
             env: { MCP_URL: 'http://127.0.0.1:18963' },
         };
         console.log(`[config] full 模式：Channel MCP 使用本地路径`);
@@ -1029,7 +1101,69 @@ export function ensureGlobalConfigs(mode = 'full') {
     console.log(`[config] 已记录版本号: ${VERSION}`);
     return { upgraded, previousVersion };
 }
-// 保存配置（直接写入 ~/.claude.json）
+// 远程安装向导（交互式输入 URL + Token）
+export async function runRemoteInstallWizard() {
+    const rl = createRL();
+    const CLAUDE_CONFIG_FILE = path.join(os.homedir(), '.claude.json');
+    try {
+        // 检测本机是否有 ~/.claude.json（判断是 Client 还是 Server）
+        const hasClaudeConfig = fs.existsSync(CLAUDE_CONFIG_FILE);
+        if (!hasClaudeConfig) {
+            // Server 安装模式：本机无 ~/.claude.json，作为远程服务器
+            console.log('\n检测到本机无 ~/.claude.json → Server 安装模式\n');
+            console.log('  Server 端只需启动 HTTP MCP Server，不写入 MCP 配置');
+            console.log('  Client 端在其他机器上安装\n');
+            const confirm = await question(rl, '确认作为远程 Server 安装？(y/N): ');
+            if (confirm.toLowerCase() !== 'y') {
+                console.log('[config] 已取消');
+                return null;
+            }
+            // Server 不写入 ~/.claude.json，只提示启动命令
+            console.log('\n─────────────────────────────────────');
+            console.log('Server 安装完成！');
+            console.log('  启动命令: npx @anthropic/wecom-aibot-mcp --http-only --start');
+            console.log('  或者:     npm run start:http');
+            console.log('─────────────────────────────────────\n');
+            console.log('[config] Client 端请在其他机器运行安装程序连接本服务器\n');
+            return 'server';
+        }
+        // Client 安装模式：本机有 ~/.claude.json，作为客户端
+        console.log('\n检测到本机有 ~/.claude.json → Client 安装模式\n');
+        console.log('  请选择连接远程服务器的方式：\n');
+        console.log('  1. 仅 HTTP MCP（轮询模式）');
+        console.log('  2. HTTP MCP + Channel MCP（推荐，消息自动唤醒）\n');
+        const choice = await question(rl, '请选择 (1/2): ');
+        const mode = choice === '2' ? 'remote-channel' : 'remote';
+        let serverUrl = await question(rl, '远程服务器地址（如 https://your-server:18963）: ');
+        while (!serverUrl) {
+            console.log('服务器地址不能为空');
+            serverUrl = await question(rl, '远程服务器地址: ');
+        }
+        // 标准化 URL（去掉尾部斜杠）
+        serverUrl = serverUrl.replace(/\/+$/, '');
+        let token = await question(rl, 'Auth Token（必填，远程服务器需配置相同 Token）: ');
+        while (!token) {
+            console.log('Auth Token 不能为空');
+            token = await question(rl, 'Auth Token: ');
+        }
+        // 写入配置
+        ensureGlobalConfigs(mode, { url: serverUrl, token });
+        console.log('\n─────────────────────────────────────');
+        console.log('Client 配置完成！');
+        console.log(`  模式:       ${mode === 'remote-channel' ? 'HTTP + Channel' : '仅 HTTP'}`);
+        console.log(`  服务器:     ${serverUrl}`);
+        console.log(`  Auth Token: ${token.slice(0, 8)}...${token.slice(-4)}`);
+        console.log('─────────────────────────────────────\n');
+        if (mode === 'remote-channel') {
+            console.log('Channel 模式优势：微信消息自动唤醒 agent，无需主动轮询');
+        }
+        console.log('[config] 请重启 Claude Code 以加载最新配置\n');
+        return mode;
+    }
+    finally {
+        rl.close();
+    }
+}
 export function saveConfig(config, instanceName) {
     ensureConfigDir(); // 确保运行时文件目录存在
     // 写入 MCP Server 配置到 ~/.claude.json
@@ -1232,15 +1366,6 @@ export async function runConfigWizard() {
 }
 // 查找机器人配置文件路径（按名称）
 export function findRobotConfigFile(robotName) {
-    // 检查默认配置文件
-    if (fs.existsSync(BOT_CONFIG_FILE)) {
-        const config = JSON.parse(fs.readFileSync(BOT_CONFIG_FILE, 'utf-8'));
-        const name = config.nameTag || `机器人-${config.botId?.slice(0, 8) || 'unknown'}`;
-        if (name === robotName) {
-            return BOT_CONFIG_FILE;
-        }
-    }
-    // 检查其他机器人配置文件
     if (fs.existsSync(CONFIG_DIR)) {
         const files = fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'));
         for (const file of files) {
@@ -1256,14 +1381,6 @@ export function findRobotConfigFile(robotName) {
 }
 // 查找机器人配置文件路径（按 botId）
 export function findRobotConfigFileByBotId(botId) {
-    // 检查默认配置文件
-    if (fs.existsSync(BOT_CONFIG_FILE)) {
-        const config = JSON.parse(fs.readFileSync(BOT_CONFIG_FILE, 'utf-8'));
-        if (config.botId === botId) {
-            return BOT_CONFIG_FILE;
-        }
-    }
-    // 检查其他机器人配置文件
     if (fs.existsSync(CONFIG_DIR)) {
         const files = fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'));
         for (const file of files) {
@@ -1335,7 +1452,7 @@ export async function detectUserIdFromMessage(client, timeoutSeconds = 60) {
  *
  * 优先级：
  * 1. 环境变量（WECOM_BOT_ID, WECOM_SECRET, WECOM_TARGET_USER）
- * 2. 保存的配置文件（~/.wecom-aibot-mcp/config.json）
+ * 2. 保存的配置文件（~/.wecom-aibot-mcp/robot-*.json）
  * 3. 运行配置向导
  */
 export async function getOrInitConfig() {

package/dist/connection-manager.js

@@ -29,8 +29,8 @@ function findRobotConfig(robotName) {
     const robot = robots.find(r => r.name === robotName || r.botId === robotName || r.name.includes(robotName));
     if (!robot)
         return null;
-    // 搜索所有配置文件（config.json + robot-*.json）
-    const allFiles = ['config.json', ...fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'))];
+    // 搜索所有机器人配置文件（robot-*.json）
+    const allFiles = fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'));
     const files = allFiles.filter(f => fs.existsSync(path.join(CONFIG_DIR, f)));
     // 先按 botId 精确匹配找 secret
     for (const file of files) {
@@ -146,7 +146,22 @@ export async function getClient(robotName) {
     const robot = await findRobotConfig(state.robotName);
     if (robot) {
         logger.log(`[connection] 重连机器人: ${robot.name}`);
+        const oldClient = state.client;
+        // 迁移旧 client 的未解决审批记录和待发送审批消息
+        const pendingApprovals = oldClient.getUnresolvedApprovalMap();
+        const pendingApprovalMessages = oldClient.takePendingApprovalMessages();
+        // 先断开旧 client，防止旧 client 重连后与新 client 并存导致事件分流
+        oldClient.disconnect();
         state.client = new WecomClient(robot.botId, robot.secret, robot.targetUserId, robot.name);
+        // 注入审批记录，确保 Hook 轮询和用户点击仍能正常处理
+        pendingApprovals.forEach((approval, taskId) => {
+            state.client.injectApprovalRecord(taskId, {
+                toolName: approval.toolName,
+                toolInput: approval.toolInput,
+            });
+        });
+        // 注入待发送的审批卡片消息，新 client 连接后会自动重发
+        state.client.injectPendingMessages(pendingApprovalMessages);
         state.client.connect();
         const connected = await waitForConnection(state.client, 5000);
         if (connected) {

package/dist/daemon.js

@@ -47,23 +47,7 @@ class ConnectionDaemon {
     }
     loadAllRobots() {
         const robots = [];
-        // 主配置文件
-        const mainConfigPath = path.join(CONFIG_DIR, 'config.json');
-        if (fs.existsSync(mainConfigPath)) {
-            try {
-                const config = JSON.parse(fs.readFileSync(mainConfigPath, 'utf-8'));
-                robots.push({
-                    name: config.nameTag || 'default',
-                    botId: config.botId,
-                    secret: config.secret,
-                    targetUserId: config.targetUserId,
-                });
-            }
-            catch (err) {
-                this.log(`加载主配置失败: ${err}`);
-            }
-        }
-        // 机器人配置文件 (robot-*.json)
+        // 所有机器人配置（统一 robot-*.json 格式）
         const files = fs.readdirSync(CONFIG_DIR).filter(f => f.startsWith('robot-') && f.endsWith('.json'));
         for (const file of files) {
             try {

package/dist/http-server.js

@@ -23,7 +23,7 @@ import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { registerTools } from './tools/index.js';
 import { getClient, getConnectionState, getAllConnectionStates, connectAllRobots } from './connection-manager.js';
 import { subscribeWecomMessage, getSubscriberCount } from './message-bus.js';
-import { listAllRobots } from './config-wizard.js';
+import { listAllRobots, VERSION, getAuthToken } from './config-wizard.js';
 import { logger } from './logger.js';
 // ESM 兼容的 __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -185,7 +185,6 @@ export function getOnlineCcIds() {
 }
 // 使用 Map 存储多个待处理审批（按 taskId 索引）
 const pendingApprovals = new Map();
-const VERSION = '2.0.0';
 const transports = new Map();
 const sseClients = new Map(); // clientId -> SSEClient
 // 初始化 MCP Server（不再全局连接）
@@ -479,6 +478,16 @@ export async function startHttpServer(_server, port = HTTP_PORT) {
                 return;
             }
             const url = req.url || '/';
+            // Auth token 校验（排除 /health）
+            const authToken = getAuthToken();
+            if (authToken && url !== '/health') {
+                const authHeader = req.headers['authorization'];
+                if (authHeader !== `Bearer ${authToken}`) {
+                    res.writeHead(401, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Unauthorized' }));
+                    return;
+                }
+            }
             // MCP endpoint - 每个客户端一个独立的 server 和 transport
             // POST /mcp: 初始化或调用工具
             // GET /mcp: 建立 SSE 流
@@ -824,7 +833,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);
+        const taskId = await client.sendApprovalRequest(title, description, requestId, undefined, tool_input, ccId);
         logger.log(`[http] 审批请求已发送: ${taskId} (机器人: ${robotName})`);
         // 存储审批并启动超时计时器
         const entry = {
@@ -864,6 +873,9 @@ function handleApprovalStatus(_req, res, url) {
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ status: 'pending', result: 'pending' }));
             }
+        }).catch(() => {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'pending', result: 'pending' }));
         });
         return;
     }

package/dist/tools/index.js

@@ -20,7 +20,7 @@
  * - 从 Session 自动获取 robotName
  */
 import { z } from 'zod';
-import { listAllRobots, getDocMcpUrl, installSkill } from '../config-wizard.js';
+import { listAllRobots, getDocMcpUrl, installSkill, VERSION } from '../config-wizard.js';
 import { callDocTool } from '../doc-proxy.js';
 import { connectRobot, disconnectRobot, getClient, getConnectionState, } from '../connection-manager.js';
 import { registerCcId, unregisterCcId, getRobotByCcId, getProjectDirByCcId, generateCcId, } from '../http-server.js';
@@ -250,7 +250,7 @@ npx @vrs-soft/wecom-aibot-mcp
             content: [{
                     type: 'text',
                     text: JSON.stringify({
-                        version: '2.0.0',
+                        version: VERSION,
                         requirements: {
                             // 权限配置需求
                             permissions: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vrs-soft/wecom-aibot-mcp",
-  "version": "2.3.3",
+  "version": "2.4.1",
   "description": "企业微信智能机器人 MCP 服务 - Claude Code 审批通道",
   "type": "module",
   "main": "dist/index.js",