cursor-feedback 2.3.0 → 2.3.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.3.1](https://github.com/jianger666/cursor-feedback-extension/compare/v2.3.0...v2.3.1) (2026-07-06)
+
+
+### Bug Fixes
+
+* **mcp:** 重复投递去重去掉 90s 时间窗，wire id 精确识别 + 迟到重投结果重放 ([3eb6be5](https://github.com/jianger666/cursor-feedback-extension/commit/3eb6be5771feb56f11e09f6f61f96fd0dbf627da))
+
 ## [2.3.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.2.0...v2.3.0) (2026-07-04)
 
 

package/dist/mcp-server.js

@@ -148,6 +148,11 @@ class McpFeedbackServer {
         // stop() 防重入：server.close() 会触发 transport.onclose → 回调里又调 stop()，
         // 无标志位会无限递归直至 "Maximum call stack size exceeded"（日志曾刷出数万条 Stopping server...）
         this.stopping = false;
+        /**
+         * 已结束请求的结果缓存（wire id → 当时的结果）：供「迟到的重复投递」精确重放。
+         * 容量与时效都收紧（feedback 结果可能含 base64 图片，不能无限囤积）。
+         */
+        this.settledByWire = new Map();
         this.port = port;
         this.basePort = port;
         this.server = new index_js_1.Server({
@@ -224,14 +229,17 @@ class McpFeedbackServer {
             };
         });
         // 处理工具调用
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request, extra) => {
             // AI 发起调用，刷新活动时间，避免被 watchdog 误判为闲置
             this.lastActivityTime = Date.now();
             const { name, arguments: args } = request.params;
+            // JSON-RPC 请求 id（同一连接内唯一）：客户端把同一次 tool call 重复投递时若复用
+            // 同一 id，可据此做精确去重 / 结果重放（比 summary 内容启发式可靠）。
+            const wireKey = extra?.requestId !== undefined ? String(extra.requestId) : undefined;
             try {
                 switch (name) {
                     case 'interactive_feedback':
-                        return await this.handleInteractiveFeedback(args);
+                        return await this.handleInteractiveFeedback(args, wireKey);
                     case 'get_system_info':
                         return this.handleGetSystemInfo();
                     default:
@@ -252,8 +260,9 @@ class McpFeedbackServer {
     }
     /**
      * 处理交互式反馈请求
+     * @param wireKey 本次调用的 JSON-RPC 请求 id（用于重复投递的精确识别与结果重放）
      */
-    async handleInteractiveFeedback(args) {
+    async handleInteractiveFeedback(args, wireKey) {
         // 参数校验：project_directory 是必填项
         if (!args?.project_directory) {
             const receivedParams = JSON.stringify(args || {});
@@ -276,15 +285,29 @@ 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();
-        // 重复投递识别：同窗口 + 同 summary + 旧请求还很新 → 视为客户端/传输层对同一次调用的
-        // 重复投递（非新一轮），直接 join 旧等待共享结果：不发新卡、不顶旧请求（顶了会让
-        // 先到的那次调用收到 SUPERSEDED、AI 误以为被新会话取代而提前收尾）。
-        const dup = this.findDuplicatePending(projectDir, summary);
+        // 重复投递识别：客户端/传输层会把同一次 tool call 原样重复投递（实测某一时刻把进程内
+        // 所有 in-flight 调用各重投一遍，距原投递可晚至 3~8 分钟，无固定上限）。重复投递必须
+        // join 原等待共享结果，绝不能当新一轮：不发新卡、不顶旧请求——顶了会让原调用收到
+        // SUPERSEDED（AI 误以为被新会话取代而提前收尾），且重投开出的幽灵卡片没人认领，
+        // 用户回复它只会石沉大海。
+        const dup = this.findDuplicatePending(projectDir, summary, timeout, wireKey);
         if (dup) {
-            debugLog(`Duplicate delivery detected for request ${dup.id}; joining its wait instead of superseding`);
+            debugLog(`Duplicate delivery detected (matched by ${dup.via}) for request ${dup.id}; joining its wait instead of superseding`);
             const outcome = await new Promise((res) => dup.waiters.push(res));
+            this.rememberSettledWire(wireKey, outcome, dup.id);
             return this.outcomeToResult(outcome, dup.id);
         }
+        // 迟到的重复投递（原请求已结束）：同 wire id 精确命中已结束请求 → 原样重放当时的结果。
+        // 绝不能开新一轮：原调用早已返回、没人会认领新卡，用户回复只会丢失。
+        // 只按 wire id 匹配、绝不按 summary——AI 超时续期的新一轮常复用同一句 summary，
+        // 按内容重放旧超时会造成「新调用秒收超时 → 立即重调 → 又秒收」的快速空转。
+        if (wireKey) {
+            const settled = this.settledByWire.get(wireKey);
+            if (settled) {
+                debugLog(`Late duplicate delivery (wire id ${wireKey}) for settled request ${settled.requestId}; replaying its outcome`);
+                return this.outcomeToResult(settled.outcome, settled.requestId);
+            }
+        }
         // 作废上一轮残留的「僵尸」请求：单实例单窗口同时只应有一个活跃反馈请求。
         // 旧请求多半是对话被压缩 / 客户端取消后还卡在 await 的残留（要等 timeout 才自然结束），
         // 不清理会让 pendingCount 虚高、全局视角误判「多个窗口在等」
@@ -324,7 +347,8 @@ class McpFeedbackServer {
         }
         try {
             // 等待用户反馈
-            const outcome = await this.waitForFeedback(request, timeout * 1000);
+            const outcome = await this.waitForFeedback(request, timeout * 1000, wireKey);
+            this.rememberSettledWire(wireKey, outcome, requestId);
             return this.outcomeToResult(outcome, requestId);
         }
         catch (error) {
@@ -606,19 +630,49 @@ class McpFeedbackServer {
             this.pendingRequests.delete(reqId);
         }
     }
-    findDuplicatePending(projectDir, summary) {
+    /**
+     * 查找可 join 的「重复投递」等待，两级匹配：
+     * 1) wire id 精确匹配：同一条 JSON-RPC 请求（同 id）还在等待 → 必是重复投递；
+     * 2) 内容启发式：同窗口 + 同 summary + 同 timeout，且原请求仍在 pending（覆盖客户端
+     *    重投时换了新 wire id 的情况）。
+     * 内容启发式不设时间窗——旧实现的 90s 窗口被实测击穿（重投可晚至 3~8 分钟，无固定上限）。
+     * 不设窗口是安全的：pending 仍存活 = 原调用尚未返回 = 同一会话不可能已合法开启新一轮；
+     * 不同会话在同一窗口撞出一字不差的 summary + timeout 概率可忽略，即便撞上，
+     * join（双方共享同一份回复）也远比 supersede（悄悄掐掉别人的等待）安全。
+     */
+    findDuplicatePending(projectDir, summary, timeout, wireKey) {
         const owner = this.normalizePath(projectDir);
         for (const [id, pending] of this.pendingRequests) {
+            if (wireKey !== undefined && pending.wireId === wireKey) {
+                return { id, via: 'wire id', waiters: pending.waiters };
+            }
             if (this.normalizePath(pending.projectDir) !== owner)
                 continue;
             if (pending.request.summary !== summary)
                 continue;
-            if (Date.now() - pending.request.timestamp > McpFeedbackServer.DUP_JOIN_MS)
+            if (pending.request.timeout !== timeout)
                 continue;
-            return { id, waiters: pending.waiters };
+            return { id, via: 'content', waiters: pending.waiters };
         }
         return null;
     }
+    rememberSettledWire(wireKey, outcome, requestId) {
+        if (!wireKey)
+            return;
+        const now = Date.now();
+        this.settledByWire.set(wireKey, { outcome, requestId, at: now });
+        for (const [k, v] of this.settledByWire) {
+            if (now - v.at > McpFeedbackServer.SETTLED_WIRE_TTL_MS)
+                this.settledByWire.delete(k);
+        }
+        // Map 按插入序迭代，超限时先淘汰最早的
+        while (this.settledByWire.size > McpFeedbackServer.SETTLED_WIRE_MAX) {
+            const oldest = this.settledByWire.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.settledByWire.delete(oldest);
+        }
+    }
     /**
      * 把等待结果翻译成 MCP 工具响应（主等待与重复投递 join 的等待共用同一段收尾语义）。
      */
@@ -700,7 +754,7 @@ class McpFeedbackServer {
      * 等待用户反馈：注册 pending 并挂起，结果通过 waiters 广播——
      * 首个调用与后续 join 进来的重复投递调用都会收到同一份结果。
      */
-    waitForFeedback(request, timeoutMs) {
+    waitForFeedback(request, timeoutMs, wireKey) {
         return new Promise((resolve) => {
             const requestId = request.id;
             const projectDir = request.projectDir;
@@ -738,6 +792,7 @@ class McpFeedbackServer {
                 remainingMs: timeoutMs,
                 request,
                 waiters,
+                wireId: wireKey,
             });
             // 抢跑兑现：空窗期的面板提交（优先，用户显式点了发送）与飞书暂存消息，
             // 本轮 pending 一注册立即作为回复提交；最后是忙时队列里排队的追加消息
@@ -1930,12 +1985,8 @@ McpFeedbackServer.QUEUE_MAX = 100;
  *（只剩别的窗口在扫端口）→ 视为我的窗口已关、本实例是僵尸：不再上报 pending，避免污染全局计数。
  */
 McpFeedbackServer.OWNER_IDLE_MS = 12000;
-/**
- * 查找可 join 的「重复投递」等待：同窗口 + 同 summary + 注册时间在 DUP_JOIN_MS 内。
- * AI 每一轮的 summary 几乎不可能与上一轮一字不差，短窗口内完全相同基本可断定为
- * 客户端/传输层对同一次 tool call 的重复投递。
- */
-McpFeedbackServer.DUP_JOIN_MS = 90000;
+McpFeedbackServer.SETTLED_WIRE_TTL_MS = 10 * 60 * 1000;
+McpFeedbackServer.SETTLED_WIRE_MAX = 20;
 // 主函数
 async function main() {
     const port = 61927;

package/package.json

@@ -2,7 +2,7 @@
   "name": "cursor-feedback",
   "displayName": "Cursor Feedback",
   "description": "One Cursor conversation, unlimited AI interactions - Save your monthly request quota! Interactive feedback loop for AI chat via MCP",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "icon": "icon.png",
   "author": "jianger666",
   "license": "MIT",
@@ -147,7 +147,7 @@
     "watch": "tsc -watch -p ./",
     "lint": "eslint src --ext ts",
     "start:mcp": "node dist/mcp-server.js",
-    "test:smoke": "npm run compile && node scripts/smoke-queue.js",
+    "test:smoke": "npm run compile && node scripts/smoke-queue.js && node scripts/smoke-dup.js",
     "prepublishOnly": "npm run check-changelog && npm run compile",
     "check-changelog": "node scripts/check-changelog.js",
     "release": "standard-version",