cursor-mcp-feedback 2.0.3 → 2.0.5

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
 
@@ -138,7 +138,7 @@ On first startup (or `npm install -g`), the MCP server **automatically configure
 
 - **Cursor rule** (`~/.cursor/rules/cursor-mcp-feedback.mdc`) — instructs the agent to call `interactive_feedback`
 - **Cursor hooks** (`~/.cursor/hooks/`) — subagent protection + pending message delivery + event logging
-- **hooks.json entries** — registers `sessionStart`, `subagentStart`, `subagentStop`, `beforeMCPExecution`, `preToolUse`, `afterMCPExecution` hooks
+- **hooks.json entries** — registers `subagentStart`, `subagentStop`, `beforeMCPExecution`, `afterMCPExecution`, `preToolUse` hooks
 
 All auto-installed files are kept in sync on every startup (hash-based diffing, idempotent).
 
@@ -182,9 +182,9 @@ 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` | `subagentStart` | Increment active subagent counter for parent conversation |
+| `block-cursor-mcp-feedback.js` | `subagentStop` | Decrement active subagent counter |
+| `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,41 @@ 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: "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" } },
+        ];
+        const allSources = new Set([...entries.map((e) => e.hook._source), "cursor-mcp-feedback-block"]);
+        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/hooks/block-cursor-mcp-feedback.js

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
-// Cursor hook: session lifecycle + subagent protection.
+// Cursor hook: subagent protection + feedback event logging.
 //
 // Events (argv[2]):
-//   sessionStart         — create per-session directory & meta
-//   sessionEnd           — mark session inactive
-//   subagentStart        — record subagent to negative list
-//   subagentStop         — remove subagent
-//   beforeMCPExecution   — deny cursor-mcp-feedback calls from subagents
+//   subagentStart        — increment active subagent counter
+//   subagentStop         — decrement active subagent counter
+//   beforeMCPExecution   — deny cursor-mcp-feedback calls when subagents active
+//   afterMCPExecution    — log feedback events to events.jsonl
 
 'use strict';
 
@@ -20,45 +19,20 @@ process.stdin.on('end', () => {
   let input;
   try { input = JSON.parse(raw); } catch { input = {}; }
 
-  if (event === 'sessionStart') {
-    su.cleanupStaleSessions();
-    const convId = input.session_id || input.conversation_id;
-    if (convId) {
-      const workspace = (input.workspace_roots || [])[0] || '';
-      su.createSession(convId, {
-        workspace,
-        mode: input.composer_mode || 'agent',
-        model: input.model || '',
-        is_background: input.is_background_agent || false,
-        transcript_path: input.transcript_path || null,
-      });
-    }
-    su.writeHookOutput({});
-    return;
-  }
-
-  if (event === 'sessionEnd') {
-    const convId = input.session_id || input.conversation_id;
-    if (convId) {
-      su.endSession(convId, input.reason || 'unknown');
-    }
-    su.writeHookOutput({});
-    return;
-  }
-
   if (event === 'subagentStart') {
     const subagentId = input.subagent_id;
     const parentConvId = input.parent_conversation_id || input.conversation_id;
-    if (subagentId) {
-      su.recordSubagent(subagentId, parentConvId);
-    }
+    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;
   }
@@ -75,13 +49,14 @@ 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 — 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 {
@@ -100,6 +75,11 @@ process.stdin.on('end', () => {
 
     const isFeedback = toolName === 'interactive_feedback' || toolName === 'submit_feedback';
     if (convId && isFeedback) {
+      su.ensureSession(convId, {
+        workspace: (input.workspace_roots || [])[0] || '',
+        model: input.model || '',
+      });
+
       const eventsFile = require('path').join(su.sessionDir(convId), 'events.jsonl');
       let toolInput = {};
       try { toolInput = typeof input.tool_input === 'string' ? JSON.parse(input.tool_input) : (input.tool_input || {}); } catch {}

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.3",
+  "version": "2.0.5",
   "description": "MCP App for interactive feedback — renders a chat UI directly inside MCP hosts (Claude, Cursor, etc.)",
   "type": "module",
   "main": "dist/main.js",