cursor-feedback 1.1.1 → 2.0.0

package/dist/mcp-server.js

@@ -56,6 +56,17 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const http = __importStar(require("http"));
 const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const feishu_js_1 = require("./feishu.js");
+// ⚠️ MCP stdio 协议要求 stdout 只承载 JSON-RPC 消息。第三方库（尤其飞书 SDK 的内置 logger，
+// 输出形如 "[info]: [...]"）会用 console.log/info/debug 往 stdout 打日志，一旦混入就会让
+// Cursor 端 JSON 解析失败、连接进入 failed（表现为 "Not connected"）。这里在进程最早期把这三个
+// 统一重定向到 stderr，保证 stdout 纯净。
+// 注：warn/error 在 Node 中本就走 stderr；MCP SDK 用 process.stdout.write 直接发消息，不经 console，故不受影响。
+console.log = (...args) => console.error(...args);
+console.info = (...args) => console.error(...args);
+console.debug = (...args) => console.error(...args);
 // 调试日志输出到 stderr（不影响 stdio 通信）
 function debugLog(message) {
     const timestamp = new Date().toISOString();
@@ -71,17 +82,46 @@ class McpFeedbackServer {
         this.pendingRequests = new Map();
         // 当前反馈请求
         this.currentRequest = null;
+        // 飞书桥接（可选；未配置时不加载 SDK、零开销）
+        this.feishu = new feishu_js_1.FeishuBridge();
+        this.feishuRoutingSetup = false;
+        /**
+         * 抢跑暂存：用户在「上一轮反馈刚结束、下一轮卡片还没注册」的空窗里直接发来的「无主」消息。
+         * 暂存后等下一轮 pending 一注册立即兑现，避免回复石沉大海（修复用户反馈的竞态 bug）。
+         */
+        this.stashedInbound = null;
+        // 最近一次被飞书回复 resolve 的请求：供插件端精确区分「飞书回复」与「超时」，
+        // 避免超时续期（request 也会短暂为 null）被误判成飞书回复而错误重置面板。
+        this.lastFeishuResolved = null;
+        // 超时续期开关真相源：磁盘（UI 改过、跨窗口共享、重启保留）> env MCP_AUTO_RETRY > 默认开。
+        // 由 POST /api/settings/autoRetry 广播写入，不再从轮询 query 同步（曾致多窗口互相覆盖抖动）。
+        // null = 没被磁盘/UI 覆盖，poll 时回退环境变量 / 默认值。
+        this.autoRetryOverride = null;
+        // server 级设置的磁盘持久化路径（与飞书凭证同目录，跨进程/重启共享真相源）
+        this.settingsStorePath = path.join(os.homedir(), '.cursor-feedback', 'settings.json');
         // 所属工作区（只在 AI 调用 feedback 时设置）
         // 只有来自同一工作区的轮询才会更新活动时间
         this.ownerWorkspace = null;
+        // Cursor 在 spawn 本 MCP server 时注入的「真实所属工作区」，精确指向发起对话的那个窗口。
+        // 这是可靠的归属信号：AI 传的 project_directory 可能被填成对话里聊到的另一个项目，
+        // 用它路由会把反馈发到错误窗口、当前窗口收不到（用户反馈的 bug）。拿不到时回退到 AI 传参。
+        this.realWorkspace = (process.env.WORKSPACE_FOLDER_PATHS || '').split(',')[0].trim() || null;
         // Server 启动时间
         this.startTime = Date.now();
         // 最近一次活动时间（任意 HTTP 轮询 / MCP 调用都会刷新）
         // 用于 watchdog 判定是否所有 Cursor 窗口都已关闭
         this.lastActivityTime = Date.now();
+        // 「我的窗口」最近一次轮询时间：仅被「workspace 匹配本实例归属」的插件轮询刷新。
+        // 关键：lastActivityTime 会被任意 HTTP（含别的活跃窗口对全端口的扫描）刷新，无法识别僵尸——
+        // 别的窗口的端口扫描会给已关窗口的残留 server 续命。改用本字段判定「我的窗口是否还开着」。
+        this.lastOwnerPollTime = Date.now();
+        // 是否曾收到过「我的窗口」的插件轮询：区分「Cursor 插件环境」与「无插件 host（如 Claude Desktop）」。
+        // 只有曾被自己窗口插件轮询过的实例，才用 lastOwnerPollTime 判定僵尸 / 退出，避免误杀无插件 host。
+        this.everOwnerPolled = false;
         // 看门狗定时器（兜底退出，防止进程残留 / CPU 占满）
         this.watchdogTimer = null;
         this.port = port;
+        this.basePort = port;
         this.server = new index_js_1.Server({
             name: 'cursor-feedback-server',
             version: '0.0.1',
@@ -91,6 +131,7 @@ class McpFeedbackServer {
             },
         });
         this.setupHandlers();
+        this.setupFeishuRouting();
     }
     setupHandlers() {
         // 列出可用工具
@@ -114,18 +155,20 @@ class McpFeedbackServer {
 用户消息 → 你工作 → 调用此工具（附带摘要）→ 用户反馈 → 你工作 → 再次调用此工具 → ...
 
 参数：
-    project_directory: 【必填】项目目录的绝对路径，用于正确匹配项目窗口
+    project_directory: 【必填】当前所在项目空间的根目录绝对路径（指你打开的工作区，不是对话里聊到的项目）
     summary: AI 工作摘要，供用户查看（支持 Markdown）
     timeout: 等待用户反馈的超时时间（秒），默认 300 秒（5 分钟）
 
 返回：
-    用户反馈内容（文字/图片/文件路径），或 timeout/cancelled 状态`,
+    - 正常：用户反馈内容（文字/图片/文件路径）
+    - 超时续期信号：返回内容以 [TIMEOUT_KEEP_WAITING] 开头时，表示用户暂未回复（注意：这是超时，不是取消），你必须立即用相同 project_directory 再次调用本工具继续等待，不要结束对话
+    - 超时结束：以 [TIMEOUT_END] 开头时（用户已关闭续期），可以结束本轮`,
                         inputSchema: {
                             type: 'object',
                             properties: {
                                 project_directory: {
                                     type: 'string',
-                                    description: 'Project directory absolute path (REQUIRED - must be the absolute path of current workspace for correct project matching)',
+                                    description: 'Absolute path of the root of the project workspace you are currently in (REQUIRED) — the workspace that is open, not a project merely discussed in the conversation. 【当前所在项目空间的根目录，指你打开的工作区】',
                                 },
                                 summary: {
                                     type: 'string',
@@ -194,7 +237,9 @@ class McpFeedbackServer {
                 isError: true,
             };
         }
-        const projectDir = args.project_directory;
+        // 归属以 Cursor 注入的真实工作区为准（修复：AI 把 project_directory 传成对话里聊到的
+        // 另一个项目时，反馈会发到错误窗口、当前窗口收不到）。拿不到 env 时才回退到 AI 传参。
+        const projectDir = this.realWorkspace || args.project_directory;
         // summary 支持别名 message
         const summary = args?.summary || args?.message || '我已完成您的请求。';
         // 超时时间优先级：环境变量 > 工具参数 > 默认值（300秒）
@@ -202,9 +247,13 @@ class McpFeedbackServer {
         const envTimeout = process.env.MCP_FEEDBACK_TIMEOUT ? parseInt(process.env.MCP_FEEDBACK_TIMEOUT, 10) : null;
         const timeout = envTimeout || args?.timeout || 300;
         const requestId = this.generateRequestId();
+        // 作废上一轮残留的「僵尸」请求：单实例单窗口同时只应有一个活跃反馈请求。
+        // 旧请求多半是对话被压缩 / 客户端取消后还卡在 await 的残留（要等 timeout 才自然结束），
+        // 不清理会让 pendingCount 虚高、全局视角误判「多个窗口在等」
+        //（即你看到的两个一模一样的 cursor-feedback-extension）。
+        this.cancelStalePending();
         // AI 调用 feedback 时设置 ownerWorkspace（这是唯一正确的时机）
-        const normalize = (p) => p.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
-        this.ownerWorkspace = normalize(projectDir);
+        this.ownerWorkspace = this.normalizePath(projectDir);
         debugLog(`Owner workspace set to: ${this.ownerWorkspace}`);
         // 创建反馈请求
         this.currentRequest = {
@@ -219,16 +268,25 @@ class McpFeedbackServer {
         debugLog(`Project: ${projectDir}`);
         debugLog(`Timeout: ${timeout}s`);
         debugLog(`Waiting for VS Code extension to collect feedback...`);
+        // 飞书：已配置则推送一张反馈请求卡片（失败不影响插件主流程）
+        if (this.feishu.isConfigured()) {
+            this.feishu.sendFeedbackCard(requestId, summary, projectDir).catch(() => { });
+        }
         try {
             // 等待用户反馈
             const result = await this.waitForFeedback(requestId, timeout * 1000);
             if (!result) {
-                debugLog('Feedback request timed out or cancelled');
-                // MCP_AUTO_RETRY 环境变量控制是否显示重试指示，默认 true
-                const autoRetry = process.env.MCP_AUTO_RETRY !== 'false';
+                debugLog('Feedback wait window elapsed without user input');
+                // 超时续期开关：MCP_AUTO_RETRY=false 时关闭（超时即结束），默认开启（超时返回续期提醒）。
+                // 关键：这里【绝不能】说成 "cancelled"——那会让 AI 误以为用户主动取消而结束对话，
+                // 这正是“超时后 AI 直接收尾、不再续命”的根因。改为明确区分“超时 ≠ 取消”。
+                // 优先用 UI 开关（autoRetryOverride），未设置时回退到环境变量 / 默认开启
+                const autoRetry = this.autoRetryOverride !== null
+                    ? this.autoRetryOverride
+                    : (process.env.MCP_AUTO_RETRY !== 'false');
                 const timeoutMessage = autoRetry
-                    ? 'User cancelled the feedback or timeout. 【必须立即重新调用此工具继续等待用户反馈】'
-                    : 'User cancelled the feedback or timeout.';
+                    ? '[TIMEOUT_KEEP_WAITING] No feedback was submitted within the wait window. This is a TIMEOUT, NOT a cancellation — the user is most likely still away from the keyboard. You MUST immediately call the interactive_feedback tool again with the same project_directory to keep waiting. Do NOT end the conversation, do NOT summarize the task as finished. Only stop calling it when the user EXPLICITLY tells you to stop. 【这是超时续期，并非用户取消：请立即用相同 project_directory 再次调用 interactive_feedback 继续等待，不要结束对话、不要当作任务完成。】'
+                    : '[TIMEOUT_END] No feedback was submitted within the wait window and timeout auto-continue is disabled (MCP_AUTO_RETRY=false). You may end this turn now. 【超时未收到反馈，且已关闭超时续期（MCP_AUTO_RETRY=false），可以结束本轮。】';
                 return {
                     content: [
                         {
@@ -292,8 +350,200 @@ class McpFeedbackServer {
             };
         }
         finally {
-            this.currentRequest = null;
+            // 只清自己的 currentRequest：被 cancelStalePending 提前作废的旧（僵尸）请求，其 finally 触发时
+            // currentRequest 可能已是新一轮请求，绝不能误清空（否则刚发起的请求会被旧请求的收尾抹掉）。
+            if (this.currentRequest?.id === requestId)
+                this.currentRequest = null;
+            // 仅清「待回复」计数，保留卡片 message_id 映射：用户回复一张已结束（超时/已提交/已回复）的
+            // 旧卡片时仍能被 resolveParent 命中、回执「已结束」，不会因映射丢失被当成陌生卡片广播、石沉大海。
+            this.feishu.clearPending(requestId);
+        }
+    }
+    /**
+     * 配置飞书消息路由：用户在飞书回复 → 匹配 requestId → resolve 本地 pending 或跨实例转发。
+     */
+    setupFeishuRouting() {
+        if (this.feishuRoutingSetup)
+            return;
+        this.feishuRoutingSetup = true;
+        this.feishu.setOnReply(async (reply) => {
+            const { parentId, text, chatId } = reply;
+            const messageId = reply.messageId || '';
+            const images = reply.images || [];
+            const files = reply.files || [];
+            // 文本、图片、文件任一非空都算有效反馈（此前只认文本，导致纯图片/文件被丢弃）
+            if (!text && images.length === 0 && files.length === 0)
+                return;
+            if (parentId) {
+                // 用户「回复」了某条卡片 → 用 parent_id 精确路由
+                const reqId = this.feishu.resolveParent(parentId);
+                if (reqId) {
+                    // 这张卡片是本实例发出的
+                    if (this.pendingRequests.has(reqId)) {
+                        this.submitFromFeishu(reqId, text, chatId, images, files, messageId);
+                    }
+                    else {
+                        // 卡片是本实例发的，但请求已结束（超时 / 已回复）→ 明确告知，不必广播
+                        this.feishu.replyText(chatId, '这条反馈已经结束了（可能已超时或已被回复）。');
+                    }
+                }
+                else {
+                    // 不是本实例发出的卡片 → 广播给其他窗口的 server
+                    this.broadcastFeishuInbound(parentId, text, chatId, images, files, messageId);
+                }
+                return;
+            }
+            // 无 parent_id（用户直接发消息，未指明卡片）→ 需要「全局视角」：
+            // 飞书消息只会推给某一个窗口的 server，而各窗口各自维护 pending；只看本实例会误判
+            // （每个窗口都以为自己唯一），导致多窗口时被随机一个窗口抢走。故先跨实例汇总全局再决策。
+            const localPending = this.feishu.listPending();
+            const remote = await this.queryRemotePending();
+            const remoteCount = remote.reduce((n, r) => n + r.list.length, 0);
+            const globalCount = localPending.length + remoteCount;
+            if (globalCount === 0) {
+                // 抢跑兜底：此刻全局无人等待，但很可能 AI 正要发起下一轮（卡片还没注册）。
+                // 暂存到收到消息的本实例，等下一轮 pending 注册时立即兑现。
+                this.stashedInbound = { text, chatId, images, files, at: Date.now(), messageId };
+                // 轻回执：先给消息加 ✅ 表情（无未读）；兑现到具体任务时不再重复回执
+                this.feishu.reactDone(messageId || undefined, chatId);
+            }
+            else if (globalCount === 1) {
+                if (localPending.length === 1) {
+                    // 唯一的等待就在本窗口 → 直接给
+                    this.submitFromFeishu(localPending[0].requestId, text, chatId, images, files, messageId);
+                }
+                else {
+                    // 唯一的等待在另一个窗口 → 转发让它认领
+                    const target = remote.find((r) => r.list.length === 1);
+                    if (target)
+                        this.forwardOrphan(target.port, text, chatId, images, files, messageId);
+                }
+            }
+            else {
+                // 多个窗口在等 → 不猜。项目名可能重复（同一项目开多窗口），逐项列出也无法区分，
+                // 故不逐项列，直接引导用户去点想回复的那张卡片——回复哪张就精确回到哪个窗口。
+                this.feishu.replyText(chatId, `当前有 ${globalCount} 个窗口在等反馈，没法自动判断你要回复哪个。\n请直接在你想回复的那张卡片上点「回复」再发，回复哪张就回到哪个窗口。`);
+            }
+        });
+    }
+    projectName(dir) {
+        return dir.replace(/\\/g, '/').replace(/\/+$/, '').split('/').pop() || dir;
+    }
+    /** 归一化路径用于跨进程/跨平台比对（统一斜杠、去尾斜杠、小写） */
+    normalizePath(p) {
+        return (p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+    }
+    /** 飞书回复命中某 requestId → resolve 该 pending，并回执用户 */
+    submitFromFeishu(requestId, text, chatId, images = [], attachedFiles = [], ackMessageId) {
+        const pending = this.pendingRequests.get(requestId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        pending.resolve({
+            interactive_feedback: text,
+            images,
+            attachedFiles,
+            project_directory: this.currentRequest?.projectDir || '',
+        });
+        this.pendingRequests.delete(requestId);
+        this.feishu.clearPending(requestId);
+        this.lastFeishuResolved = { id: requestId, at: Date.now() };
+        debugLog(`Feedback resolved from Feishu for request: ${requestId} ` +
+            `(images=${images.length}, files=${attachedFiles.length})`);
+        // 轻回执：给用户消息加 ✅ 表情，不产生新的未读消息（方案B）。
+        // ackMessageId 为 undefined 表示回执已在别处完成（如抢跑暂存时已 react），跳过。
+        if (ackMessageId !== undefined && chatId) {
+            this.feishu.reactDone(ackMessageId || undefined, chatId);
+        }
+    }
+    /** 把飞书回复广播给其他窗口的 server（跨实例路由兜底） */
+    broadcastFeishuInbound(parentId, text, chatId, images = [], attachedFiles = [], messageId) {
+        const body = JSON.stringify({ parentId, text, chatId, images, attachedFiles, messageId });
+        for (let p = this.basePort; p < this.basePort + McpFeedbackServer.PORT_SCAN_RANGE; p++) {
+            if (p === this.port)
+                continue;
+            const req = http.request({
+                hostname: '127.0.0.1',
+                port: p,
+                path: '/api/feishu/inbound',
+                method: 'POST',
+                timeout: 2000,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            }, (res) => {
+                res.on('data', () => { });
+                res.on('end', () => { });
+            });
+            req.on('error', () => { });
+            req.on('timeout', () => req.destroy());
+            req.write(body);
+            req.end();
+        }
+    }
+    /**
+     * 向其他窗口的 server 查询各自的 pending 列表（仅项目名，用于全局视角判断 + 提示文案）。
+     * 用于无 parent_id 的「无主消息」：飞书只推给一个窗口，需汇总全局才能正确决策。
+     */
+    queryRemotePending() {
+        const ports = [];
+        for (let p = this.basePort; p < this.basePort + McpFeedbackServer.PORT_SCAN_RANGE; p++) {
+            if (p !== this.port)
+                ports.push(p);
+        }
+        return Promise.all(ports.map((port) => this.fetchRemotePending(port)));
+    }
+    fetchRemotePending(port) {
+        return new Promise((resolve) => {
+            const req = http.request({ hostname: '127.0.0.1', port, path: '/api/feishu/pending', method: 'GET', timeout: 1500 }, (res) => {
+                let body = '';
+                res.on('data', (chunk) => { body += chunk.toString(); });
+                res.on('end', () => {
+                    try {
+                        const j = JSON.parse(body);
+                        resolve({ port, list: Array.isArray(j.list) ? j.list : [] });
+                    }
+                    catch {
+                        resolve({ port, list: [] });
+                    }
+                });
+            });
+            req.on('error', () => resolve({ port, list: [] }));
+            req.on('timeout', () => { req.destroy(); resolve({ port, list: [] }); });
+            req.end();
+        });
+    }
+    /** 把「无主消息」转发给全局唯一持有 pending 的那个远程窗口，让它认领提交 */
+    forwardOrphan(port, text, chatId, images = [], attachedFiles = [], messageId) {
+        const body = JSON.stringify({ text, chatId, images, attachedFiles, messageId });
+        const req = http.request({
+            hostname: '127.0.0.1',
+            port,
+            path: '/api/feishu/inbound-orphan',
+            method: 'POST',
+            timeout: 2000,
+            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+        }, (res) => { res.on('data', () => { }); res.on('end', () => { }); });
+        req.on('error', () => { });
+        req.on('timeout', () => req.destroy());
+        req.write(body);
+        req.end();
+    }
+    /**
+     * 作废本实例所有未决的反馈请求（在每次新请求进来时调用）。
+     * 单个 server 实例服务单个 Cursor 窗口的单个对话，同时只应有一个活跃反馈请求；
+     * resolve(null) 让旧的 await 自然返回走超时分支，其 finally 因 id 不匹配不会误清新请求。
+     */
+    cancelStalePending() {
+        if (this.pendingRequests.size === 0)
+            return;
+        for (const [reqId, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.resolve(null);
+            this.feishu.clearPending(reqId);
         }
+        this.pendingRequests.clear();
     }
     /**
      * 等待用户反馈
@@ -303,6 +553,7 @@ class McpFeedbackServer {
             const timeout = setTimeout(() => {
                 debugLog(`Request ${requestId} timed out`);
                 this.pendingRequests.delete(requestId);
+                // 飞书侧的清理统一交给 handleInteractiveFeedback 的 finally（clearPending），这里不再重复。
                 resolve(null);
             }, timeoutMs);
             this.pendingRequests.set(requestId, {
@@ -310,8 +561,26 @@ class McpFeedbackServer {
                 reject: () => resolve(null),
                 timeout
             });
+            // 抢跑兑现：用户在空窗期「无主」发来的消息已被暂存，本轮 pending 一注册立即作为回复提交
+            this.tryConsumeStash(requestId);
         });
     }
+    /**
+     * 抢跑暂存兑现：若存在近期「无主」飞书消息，立即作为指定请求的回复提交。
+     * 超过 STASH_TTL_MS 的暂存视为与当前任务无关，直接丢弃。
+     */
+    tryConsumeStash(requestId) {
+        const stash = this.stashedInbound;
+        if (!stash)
+            return;
+        this.stashedInbound = null;
+        if (Date.now() - stash.at > McpFeedbackServer.STASH_TTL_MS) {
+            debugLog('Stashed inbound expired, dropped');
+            return;
+        }
+        debugLog(`Consuming stashed inbound for request: ${requestId}`);
+        this.submitFromFeishu(requestId, stash.text, stash.chatId, stash.images, stash.files);
+    }
     /**
      * 处理获取系统信息请求
      */
@@ -357,7 +626,7 @@ class McpFeedbackServer {
      * 生成唯一的请求 ID
      */
     generateRequestId() {
-        return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        return `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
     }
     /**
      * 检查端口是否被我们的 MCP Server 占用，如果是则请求关闭
@@ -442,23 +711,41 @@ class McpFeedbackServer {
                 try {
                     // 任何来自插件的 HTTP 请求都视为 Cursor 仍存活的心跳（供 watchdog 判定）
                     this.lastActivityTime = Date.now();
-                    // 设置 CORS 头
-                    res.setHeader('Access-Control-Allow-Origin', '*');
-                    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-                    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+                    // 不设置 CORS 头：本地 API 仅供本插件（Node http 客户端，不受同源策略限制）调用。
+                    // 去掉 Access-Control-Allow-Origin: * 后，同机浏览器里的恶意网页无法跨域读取
+                    // /api/feedback/current（可能含 AI summary 中的代码），靠浏览器同源策略兜底。
                     if (req.method === 'OPTIONS') {
-                        res.writeHead(200);
+                        res.writeHead(204);
                         res.end();
                         return;
                     }
                     // 获取当前反馈请求
                     if (req.method === 'GET' && req.url?.startsWith('/api/feedback/current')) {
+                        // autoRetry 不再从轮询 query 同步（曾致多窗口互相覆盖、抖动）：
+                        // 改由 POST /api/settings/autoRetry 广播 + 磁盘真相源，poll 只回读做 UI 回显。
+                        try {
+                            const u = new URL(req.url, 'http://127.0.0.1');
+                            // 「我的窗口」心跳：仅当轮询带的 workspace 匹配本实例归属时刷新。
+                            // 别的活跃窗口对全端口的扫描虽刷 lastActivityTime，但 workspace 不匹配、不刷此字段，
+                            // 故已关窗口的残留 server 不会被别人续命，可被 watchdog / 僵尸自检识别。
+                            const ws = this.normalizePath(u.searchParams.get('workspace') || '');
+                            if (ws && (ws === this.ownerWorkspace || ws === this.normalizePath(this.realWorkspace || ''))) {
+                                this.lastOwnerPollTime = Date.now();
+                                this.everOwnerPolled = true;
+                            }
+                        }
+                        catch {
+                            // 忽略解析错误
+                        }
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        // 返回当前请求、ownerWorkspace 和 startTime
+                        // 返回当前请求、ownerWorkspace、startTime，以及当前生效的 autoRetry（供 UI 初始同步）
                         res.end(JSON.stringify({
                             request: this.currentRequest || null,
                             ownerWorkspace: this.ownerWorkspace,
                             startTime: this.startTime,
+                            autoRetry: this.autoRetryOverride !== null ? this.autoRetryOverride : (process.env.MCP_AUTO_RETRY !== 'false'),
+                            feishu: this.feishu.getStatus(),
+                            feishuResolvedId: (this.lastFeishuResolved && Date.now() - this.lastFeishuResolved.at < 30000) ? this.lastFeishuResolved.id : null,
                         }));
                         return;
                     }
@@ -478,6 +765,7 @@ class McpFeedbackServer {
                                     clearTimeout(pending.timeout);
                                     pending.resolve(feedback);
                                     this.pendingRequests.delete(requestId);
+                                    // 飞书侧清理同样交给 finally（clearPending）统一处理，这里不再重复。
                                     res.writeHead(200, { 'Content-Type': 'application/json' });
                                     res.end(JSON.stringify({ success: true }));
                                 }
@@ -495,6 +783,128 @@ class McpFeedbackServer {
                         });
                         return;
                     }
+                    // 配置飞书（来自插件 UI；凭证未变只补 chatId，变了则重建长连接）
+                    if (req.method === 'POST' && req.url === '/api/feishu/config') {
+                        let body = '';
+                        req.on('data', (chunk) => { body += chunk.toString(); });
+                        req.on('end', () => {
+                            (async () => {
+                                try {
+                                    const cfg = JSON.parse(body);
+                                    // 凭证以磁盘为全局真相源：用户改/删 → 持久化（touched=true）+ configure。
+                                    // 多窗口下插件会把同一份 POST 给所有 server，各自写同一磁盘文件、行为一致；
+                                    // 不再回退 env——用户主动清空就是空（touched 标记让重启后也尊重，不被 env 复活）。
+                                    this.feishu.writePersistedConfig({
+                                        appId: cfg.appId || '',
+                                        appSecret: cfg.appSecret || '',
+                                        enabled: cfg.enabled,
+                                        ackReaction: cfg.ackReaction,
+                                        touched: true,
+                                    });
+                                    await this.feishu.configure(cfg);
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ success: true, status: this.feishu.getStatus() }));
+                                }
+                                catch {
+                                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ error: 'Invalid config' }));
+                                }
+                            })();
+                        });
+                        return;
+                    }
+                    // 超时续期开关（来自插件 UI；磁盘做真相源，跨窗口/重启一致；不再走轮询 query）
+                    if (req.method === 'POST' && req.url === '/api/settings/autoRetry') {
+                        let body = '';
+                        req.on('data', (chunk) => { body += chunk.toString(); });
+                        req.on('end', () => {
+                            try {
+                                const { autoRetry } = JSON.parse(body);
+                                if (typeof autoRetry === 'boolean') {
+                                    this.autoRetryOverride = autoRetry;
+                                    this.writePersistedSettings({ autoRetry });
+                                }
+                                res.writeHead(200, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ success: true, autoRetry: this.autoRetryOverride }));
+                            }
+                            catch {
+                                res.writeHead(400, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: 'Invalid body' }));
+                            }
+                        });
+                        return;
+                    }
+                    // 解除飞书绑定（用户「删绑定」后重新发消息即可重新绑定）
+                    if (req.method === 'POST' && req.url === '/api/feishu/unbind') {
+                        this.feishu.unbind();
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: true, status: this.feishu.getStatus() }));
+                        return;
+                    }
+                    // 跨实例转发的飞书回复（由其他窗口的 server 广播过来）
+                    if (req.method === 'POST' && req.url === '/api/feishu/inbound') {
+                        let body = '';
+                        req.on('data', (chunk) => { body += chunk.toString(); });
+                        req.on('end', () => {
+                            try {
+                                const { parentId, text, chatId, images, attachedFiles, messageId } = JSON.parse(body);
+                                const reqId = this.feishu.resolveParent(parentId);
+                                if (reqId && this.pendingRequests.has(reqId)) {
+                                    this.submitFromFeishu(reqId, text, chatId, images || [], attachedFiles || [], messageId || '');
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ handled: true }));
+                                }
+                                else {
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ handled: false }));
+                                }
+                            }
+                            catch {
+                                res.writeHead(400);
+                                res.end('{}');
+                            }
+                        });
+                        return;
+                    }
+                    // 查询本实例当前 pending 列表（供其他窗口做「全局视角」汇总；只暴露项目名）
+                    if (req.method === 'GET' && req.url === '/api/feishu/pending') {
+                        // 僵尸自检：本实例曾被自己窗口插件轮询，但已久未收到（只剩别的窗口在扫端口）→ 我的窗口已关，
+                        // 不再上报 pending，避免污染全局计数（用户反馈的「没开两个窗口却显示 2 个同名」即源于此）。
+                        const ownerGone = this.everOwnerPolled &&
+                            Date.now() - this.lastOwnerPollTime > McpFeedbackServer.OWNER_IDLE_MS;
+                        const list = ownerGone
+                            ? []
+                            : this.feishu.listPending().map((p) => ({ projectName: this.projectName(p.projectDir) }));
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ count: list.length, list }));
+                        return;
+                    }
+                    // 接收「无主消息」转发：仅当本实例恰好持有唯一 pending 时认领提交
+                    if (req.method === 'POST' && req.url === '/api/feishu/inbound-orphan') {
+                        let body = '';
+                        req.on('data', (chunk) => { body += chunk.toString(); });
+                        req.on('end', () => {
+                            try {
+                                const { text, chatId, images, attachedFiles, messageId } = JSON.parse(body);
+                                if (this.feishu.pendingCount() === 1) {
+                                    const only = this.feishu.theOnlyPendingId();
+                                    if (only) {
+                                        this.submitFromFeishu(only, text, chatId, images || [], attachedFiles || [], messageId || '');
+                                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                                        res.end(JSON.stringify({ claimed: true }));
+                                        return;
+                                    }
+                                }
+                                res.writeHead(200, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ claimed: false }));
+                            }
+                            catch {
+                                res.writeHead(400);
+                                res.end('{}');
+                            }
+                        });
+                        return;
+                    }
                     // 健康检查
                     if (req.method === 'GET' && req.url === '/api/health') {
                         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -534,7 +944,12 @@ class McpFeedbackServer {
             });
             this.httpServer.on('error', async (err) => {
                 if (err.code === 'EADDRINUSE') {
-                    // 端口被占用，使用下一个端口（不关闭旧的 MCP Server，支持多项目独立运行）
+                    // 端口被占用，使用下一个端口（不关闭旧的 MCP Server，支持多项目独立运行）。
+                    // 限制在扫描范围内：超出则放弃，避免 server 端口跑到插件扫描不到的区间导致失联。
+                    if (this.port - this.basePort >= McpFeedbackServer.PORT_SCAN_RANGE - 1) {
+                        reject(new Error(`No free port in scan range ${this.basePort}-${this.basePort + McpFeedbackServer.PORT_SCAN_RANGE - 1}`));
+                        return;
+                    }
                     debugLog(`Port ${this.port} is already in use, trying next port...`);
                     this.httpServer?.close();
                     this.port++;
@@ -550,6 +965,45 @@ class McpFeedbackServer {
             });
         });
     }
+    /**
+     * 从 mcp.json 的 env 读取飞书默认配置。
+     * 服务于「没有 webview 面板」的 MCP host（如 Claude Desktop / CLI）：它们无法用插件 UI 配飞书，
+     * 只能在 mcp.json 里配 FEISHU_*。优先级：插件 UI（非空凭证）> 这里的 env > 代码默认（开关全开）。
+     */
+    /** 读取持久化的 server 设置（无文件返回 null）。 */
+    readPersistedSettings() {
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.settingsStorePath, 'utf-8'));
+            return raw && typeof raw === 'object' ? raw : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** 持久化 server 设置到磁盘（merge 写入，跨进程共享、重启不丢）。 */
+    writePersistedSettings(patch) {
+        try {
+            const cur = this.readPersistedSettings() || {};
+            const next = { ...cur, ...patch };
+            fs.mkdirSync(path.dirname(this.settingsStorePath), { recursive: true });
+            fs.writeFileSync(this.settingsStorePath, JSON.stringify(next), 'utf-8');
+        }
+        catch {
+            // 持久化失败不影响运行
+        }
+    }
+    readFeishuEnvConfig() {
+        const appId = (process.env.FEISHU_APP_ID || '').trim();
+        const appSecret = (process.env.FEISHU_APP_SECRET || '').trim();
+        if (!appId || !appSecret)
+            return null;
+        return {
+            appId,
+            appSecret,
+            enabled: process.env.FEISHU_ENABLED !== 'false',
+            ackReaction: process.env.FEISHU_ACK !== 'false',
+        };
+    }
     /**
      * 启动服务器
      */
@@ -558,9 +1012,33 @@ class McpFeedbackServer {
             debugLog('Starting MCP Feedback Server...');
             // 启动 HTTP 服务器
             await this.startHttpServer();
+            // 飞书凭证优先级：用户在面板配过（磁盘持久化、跨窗口共享、含主动清空）> mcp.json env > 不启用。
+            // 磁盘有 touched 记录就尊重它（哪怕凭证为空 = 用户主动清空，也不被 env 复活）；
+            // 没碰过才回退 env（无面板的 host 靠 env 启用）。
+            const persisted = this.feishu.readPersistedConfig();
+            if (persisted && persisted.touched) {
+                this.feishu.configure(persisted).catch(() => { });
+            }
+            else {
+                const envFeishu = this.readFeishuEnvConfig();
+                if (envFeishu) {
+                    this.feishu.configure(envFeishu).catch(() => { });
+                }
+            }
+            // 超时续期开关同款优先级：磁盘（UI 改过、跨窗口共享）> env MCP_AUTO_RETRY > 默认开。
+            const settings = this.readPersistedSettings();
+            if (settings && typeof settings.autoRetry === 'boolean') {
+                this.autoRetryOverride = settings.autoRetry;
+            }
             // 启动 MCP stdio 传输
             const transport = new stdio_js_1.StdioServerTransport();
             await this.server.connect(transport);
+            // stdio 关闭（Cursor reload / 关窗 / 重启该 MCP）→ 立即退出，避免旧进程残留堆积
+            transport.onclose = () => {
+                debugLog('stdio transport closed, exiting...');
+                this.stop();
+                setTimeout(() => process.exit(0), 100);
+            };
             // 启动看门狗兜底退出（防止 Cursor 关闭后进程残留 / CPU 占满）
             this.startWatchdog();
             debugLog('MCP Server started successfully');
@@ -601,6 +1079,14 @@ class McpFeedbackServer {
                 this.stop();
                 process.exit(0);
             }
+            // 防线 3：本实例曾被自己窗口插件轮询，但久未再收到（只剩别的活跃窗口在扫端口刷 lastActivityTime）
+            // → 我的窗口已关、本实例是僵尸 → 退出，避免持续被全局 pending 计数误算成「另一个在等的窗口」。
+            const ownerIdle = Date.now() - this.lastOwnerPollTime;
+            if (this.everOwnerPolled && ownerIdle > IDLE_TIMEOUT) {
+                debugLog(`Owner window idle for ${ownerIdle}ms, stale instance, exiting...`);
+                this.stop();
+                process.exit(0);
+            }
         }, 5000);
         // 不让 watchdog 自身阻止进程的自然退出
         this.watchdogTimer.unref();
@@ -631,6 +1117,14 @@ class McpFeedbackServer {
         debugLog('Server stopped');
     }
 }
+McpFeedbackServer.PORT_SCAN_RANGE = 20; // 与插件端扫描范围保持一致
+/** 抢跑暂存有效期：超过则视为与当前任务无关，丢弃 */
+McpFeedbackServer.STASH_TTL_MS = 8000;
+/**
+ * 「我的窗口」判定为已关闭的空闲阈值：本实例曾被自己窗口插件轮询，但超过此时长没再收到
+ *（只剩别的窗口在扫端口）→ 视为我的窗口已关、本实例是僵尸：不再上报 pending，避免污染全局计数。
+ */
+McpFeedbackServer.OWNER_IDLE_MS = 12000;
 // 主函数
 async function main() {
     const port = 61927;