cursor-mcp-feedback 2.0.2 → 2.0.4

package/README.md

@@ -32,7 +32,7 @@ When an AI agent calls the `interactive_feedback` tool, a feedback panel appears
 ### Cursor Integration
 
 - **Auto-install** — MCP server config, Cursor rules, and hooks are all auto-configured on first startup
-- **Subagent protection** — hooks prevent subagents from calling `interactive_feedback`
+- **Subagent protection** — hooks use per-conversation reference counting (`subagentStart`/`subagentStop`) to block feedback calls when subagents are active
 - **Session lifecycle** — automatic session tracking via hooks (`sessionStart`, `preToolUse`, etc.)
 - **Event logging** — all interactions logged to `events.jsonl` per session for chat history
 
@@ -99,11 +99,17 @@ npm run build
 
 ```bash
 cd floating-app
-swift build -c release
-# Binary: .build/release/MCPPending
+
+# Option A: Build DMG for distribution
+./build-dmg.sh        # Creates CursorMCPFeedback.dmg (~800KB)
+# DMG contains: .app + Install.command (handles xattr) + /Applications shortcut
+
+# Option B: Build .app directly
+./build-app.sh        # Creates CursorMCPFeedback.app
+cp -r CursorMCPFeedback.app /Applications/
 ```
 
-To auto-launch on login, add `.build/release/MCPPending` to System Settings > General > Login Items, or run manually.
+To auto-launch on login, add `CursorMCPFeedback` to System Settings > General > Login Items.
 
 ### CLI: Queue Pending Messages
 
@@ -176,9 +182,12 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
 
 | Hook | Event | Purpose |
 |------|-------|---------|
-| `block-cursor-mcp-feedback.js` | `subagentStart` | Record subagent_id to negative list |
-| `block-cursor-mcp-feedback.js` | `subagentStop` | Remove subagent_id on completion |
-| `block-cursor-mcp-feedback.js` | `beforeMCPExecution` | Deny cursor-mcp-feedback calls from subagents |
+| `block-cursor-mcp-feedback.js` | `sessionStart` | Create per-session directory & metadata |
+| `block-cursor-mcp-feedback.js` | `sessionEnd` | Mark session inactive, reset subagent counter |
+| `block-cursor-mcp-feedback.js` | `subagentStart` | Increment active subagent counter for parent conversation |
+| `block-cursor-mcp-feedback.js` | `subagentStop` | Decrement active subagent counter |
+| `block-cursor-mcp-feedback.js` | `preToolUse` | Deny feedback tool calls when subagents are active (matcher: `MCP:interactive_feedback\|MCP:submit_feedback`) |
+| `block-cursor-mcp-feedback.js` | `beforeMCPExecution` | Deny cursor-mcp-feedback MCP calls when subagents are active |
 | `block-cursor-mcp-feedback.js` | `afterMCPExecution` | Log feedback_request/response events to events.jsonl |
 | `consume-pending.js` | `preToolUse` | Consume pending messages and inject as agent feedback |
 

package/dist/main.js

@@ -93,68 +93,44 @@ function installCursorHooks() {
         catch {
             config = { version: 1, hooks: {} };
         }
-        const SOURCE_TAG = "cursor-mcp-feedback";
         const node = process.execPath;
         const blockHook = path.join(hooksDir, "block-cursor-mcp-feedback.js");
         const pendingHook = path.join(hooksDir, "consume-pending.js");
-        const entries = {
-            sessionStart: {
-                command: `${node} ${blockHook} sessionStart`,
-                _source: SOURCE_TAG,
-            },
-            sessionEnd: {
-                command: `${node} ${blockHook} sessionEnd`,
-                _source: SOURCE_TAG,
-            },
-            subagentStart: {
-                command: `${node} ${blockHook} subagentStart`,
-                _source: SOURCE_TAG,
-            },
-            subagentStop: {
-                command: `${node} ${blockHook} subagentStop`,
-                _source: SOURCE_TAG,
-            },
-            beforeMCPExecution: {
-                command: `${node} ${blockHook} beforeMCPExecution`,
-                failClosed: true,
-                _source: SOURCE_TAG,
-            },
-            preToolUse: {
-                command: `${node} ${pendingHook}`,
-                _source: SOURCE_TAG,
-            },
-            afterMCPExecution: {
-                command: `${node} ${blockHook} afterMCPExecution`,
-                _source: SOURCE_TAG,
-            },
-        };
-        let changed = false;
-        // Remove stale entries from events no longer in `entries` (e.g. sessionStart → subagentStart migration)
-        for (const [event, arr] of Object.entries(config.hooks)) {
-            if (entries[event])
-                continue;
-            const idx = arr.findIndex((h) => h._source === SOURCE_TAG);
-            if (idx >= 0) {
-                arr.splice(idx, 1);
-                changed = true;
+        // Each entry has a unique _source tag for idempotent upsert.
+        // Multiple entries per event are supported via distinct _source values.
+        const entries = [
+            { event: "sessionStart", hook: { command: `${node} ${blockHook} sessionStart`, _source: "cursor-mcp-feedback" } },
+            { event: "sessionEnd", hook: { command: `${node} ${blockHook} sessionEnd`, _source: "cursor-mcp-feedback" } },
+            { event: "subagentStart", hook: { command: `${node} ${blockHook} subagentStart`, _source: "cursor-mcp-feedback" } },
+            { event: "subagentStop", hook: { command: `${node} ${blockHook} subagentStop`, _source: "cursor-mcp-feedback" } },
+            { event: "beforeMCPExecution", hook: { command: `${node} ${blockHook} beforeMCPExecution`, failClosed: true, _source: "cursor-mcp-feedback" } },
+            { event: "afterMCPExecution", hook: { command: `${node} ${blockHook} afterMCPExecution`, _source: "cursor-mcp-feedback" } },
+            { event: "preToolUse", hook: { command: `${node} ${pendingHook}`, _source: "cursor-mcp-feedback" } },
+            { event: "preToolUse", hook: { command: `${node} ${blockHook} preToolUse`, matcher: "MCP:interactive_feedback|MCP:submit_feedback", failClosed: true, _source: "cursor-mcp-feedback-block" } },
+        ];
+        const allSources = new Set(entries.map((e) => e.hook._source));
+        const before = JSON.stringify(config);
+        // First pass: remove ALL our entries from every event (clean slate)
+        for (const arr of Object.values(config.hooks)) {
+            for (let i = arr.length - 1; i >= 0; i--) {
+                if (allSources.has(arr[i]._source)) {
+                    arr.splice(i, 1);
+                }
             }
         }
-        for (const [event, entry] of Object.entries(entries)) {
+        // Second pass: add desired entries
+        for (const { event, hook } of entries) {
             if (!config.hooks[event])
                 config.hooks[event] = [];
-            const arr = config.hooks[event];
-            const idx = arr.findIndex((h) => h._source === SOURCE_TAG);
-            if (idx >= 0) {
-                if (JSON.stringify(arr[idx]) !== JSON.stringify(entry)) {
-                    arr[idx] = entry;
-                    changed = true;
-                }
-            }
-            else {
-                arr.push(entry);
-                changed = true;
+            config.hooks[event].push(hook);
+        }
+        // Clean up empty arrays
+        for (const [event, arr] of Object.entries(config.hooks)) {
+            if (arr.length === 0) {
+                delete config.hooks[event];
             }
         }
+        const changed = JSON.stringify(config) !== before;
         if (changed) {
             fs.writeFileSync(hooksJsonPath, JSON.stringify(config, null, 2) + "\n");
             log("Cursor hooks.json updated for cursor-mcp-feedback");

package/dist/session-store.js

@@ -54,8 +54,17 @@ function cleanupSession(sessionId) {
 export function createFreshSession(summary, sessionId) {
     ensureDir();
     cleanExpiredSessions();
-    writeSession({ sessionId, summary, createdAt: Date.now(), status: "pending" });
-    logObj("session-store: created:fresh", { sessionId, summaryLen: summary.length });
+    let conversationId;
+    try {
+        const callerFile = path.join(os.homedir(), ".cursor-mcp-feedback", "current-feedback-caller.json");
+        const caller = JSON.parse(fs.readFileSync(callerFile, "utf8"));
+        if (caller.conversation_id && Date.now() - caller.ts < 10000) {
+            conversationId = caller.conversation_id;
+        }
+    }
+    catch { /* ignore */ }
+    writeSession({ sessionId, summary, createdAt: Date.now(), status: "pending", conversation_id: conversationId });
+    logObj("session-store: created:fresh", { sessionId, summaryLen: summary.length, conversationId: conversationId || "unknown" });
     return sessionId;
 }
 export function resolveSession(sessionId, feedback, images, userInput) {

package/hooks/block-cursor-mcp-feedback.js

@@ -41,6 +41,7 @@ process.stdin.on('end', () => {
     const convId = input.session_id || input.conversation_id;
     if (convId) {
       su.endSession(convId, input.reason || 'unknown');
+      su.resetActiveSubagents(convId);
     }
     su.writeHookOutput({});
     return;
@@ -52,17 +53,52 @@ process.stdin.on('end', () => {
     if (subagentId) {
       su.recordSubagent(subagentId, parentConvId);
     }
+    if (parentConvId) {
+      su.incrementActiveSubagents(parentConvId);
+    }
     su.writeHookOutput({});
     return;
   }
 
   if (event === 'subagentStop') {
     const subagentId = input.subagent_id || input.conversation_id;
+    const parentConvId = input.parent_conversation_id || input.conversation_id;
     if (subagentId) su.removeSubagent(subagentId);
+    if (parentConvId) {
+      su.decrementActiveSubagents(parentConvId);
+    }
     su.writeHookOutput({});
     return;
   }
 
+  if (event === 'preToolUse') {
+    const toolName = (input.tool_name || '').toLowerCase();
+    const isFeedbackTool =
+      toolName.includes('interactive_feedback') ||
+      toolName.includes('submit_feedback');
+
+    if (!isFeedbackTool) {
+      su.writeHookOutput({});
+      return;
+    }
+
+    const convId = input.conversation_id;
+    if (convId && su.hasActiveSubagents(convId)) {
+      su.writeHookOutput({
+        permission: 'deny',
+        user_message: '[Hook] Blocked feedback tool call — subagent(s) active',
+        agent_message:
+          'DENIED by preToolUse hook. ' +
+          'cursor-mcp-feedback tools are for the MAIN agent only. ' +
+          'Active subagents detected for this conversation. ' +
+          'Return your results as text in your final response instead.',
+      });
+    } else {
+      su.writeHookOutput({});
+    }
+    return;
+  }
+
   if (event === 'beforeMCPExecution') {
     const command = (input.command || '').toLowerCase();
     const isFeedbackApp =
@@ -75,16 +111,21 @@ process.stdin.on('end', () => {
     }
 
     const convId = input.conversation_id;
-    if (convId && su.isSubagent(convId)) {
+    if (convId && su.hasActiveSubagents(convId)) {
       su.writeHookOutput({
         permission: 'deny',
-        user_message: '[Hook] Blocked cursor-mcp-feedback call from subagent',
+        user_message: '[Hook] Blocked cursor-mcp-feedback call — subagent(s) active',
         agent_message:
           'DENIED by beforeMCPExecution hook. ' +
           'cursor-mcp-feedback tools are for the MAIN agent only. ' +
+          'Active subagents detected for this conversation. ' +
           'Return your results as text in your final response instead.',
       });
     } else {
+      if (convId) {
+        const callerFile = require('path').join(su.BASE_DIR, 'current-feedback-caller.json');
+        su.writeJson(callerFile, { conversation_id: convId, ts: Date.now() });
+      }
       su.writeHookOutput({});
     }
     return;

package/hooks/session-utils.js

@@ -223,6 +223,48 @@ function isSubagent(convId) {
   return !!data[convId];
 }
 
+// ── Active subagent counter (per conversation) ──
+
+const ACTIVE_COUNTER_FILE = path.join(BASE_DIR, "active-subagent-counts.json");
+
+function incrementActiveSubagents(convId) {
+  const data = readJson(ACTIVE_COUNTER_FILE, {});
+  const entry = data[convId] || { count: 0, ts: Date.now() };
+  entry.count = Math.max(0, entry.count) + 1;
+  entry.ts = Date.now();
+  data[convId] = entry;
+  const FOUR_HOURS = 4 * 60 * 60 * 1000;
+  for (const [k, v] of Object.entries(data)) {
+    if (Date.now() - (v.ts || 0) > FOUR_HOURS) delete data[k];
+  }
+  writeJson(ACTIVE_COUNTER_FILE, data);
+}
+
+function decrementActiveSubagents(convId) {
+  const data = readJson(ACTIVE_COUNTER_FILE, {});
+  const entry = data[convId];
+  if (!entry) return;
+  entry.count = Math.max(0, entry.count - 1);
+  entry.ts = Date.now();
+  data[convId] = entry;
+  writeJson(ACTIVE_COUNTER_FILE, data);
+}
+
+function hasActiveSubagents(convId) {
+  const data = readJson(ACTIVE_COUNTER_FILE, {});
+  const entry = data[convId];
+  if (!entry) return false;
+  const FOUR_HOURS = 4 * 60 * 60 * 1000;
+  if (Date.now() - (entry.ts || 0) > FOUR_HOURS) return false;
+  return entry.count > 0;
+}
+
+function resetActiveSubagents(convId) {
+  const data = readJson(ACTIVE_COUNTER_FILE, {});
+  delete data[convId];
+  writeJson(ACTIVE_COUNTER_FILE, data);
+}
+
 // ── Most recent active session ──
 
 function getMostRecentSession() {
@@ -259,6 +301,7 @@ module.exports = {
   updateActiveList, markSessionInactive, touchSessionActivity,
   readSessionPending, writeSessionPending, addSessionPending, consumeSessionPending,
   recordSubagent, removeSubagent, isSubagent,
+  incrementActiveSubagents, decrementActiveSubagents, hasActiveSubagents, resetActiveSubagents,
   getMostRecentSession, readGlobalPending, writeGlobalPending,
   readHookInput, writeHookOutput,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-mcp-feedback",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "MCP App for interactive feedback — renders a chat UI directly inside MCP hosts (Claude, Cursor, etc.)",
   "type": "module",
   "main": "dist/main.js",