cursor-mcp-feedback 2.0.0

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,241 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerAppTool, registerAppResource, RESOURCE_MIME_TYPE, } from "@modelcontextprotocol/ext-apps/server";
+import { z } from "zod";
+import * as os from "node:os";
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+import { log, logObj } from "./logger.js";
+import { createFreshSession, resolveSession, SESSIONS_DIR } from "./session-store.js";
+const DIST_DIR = import.meta.filename.endsWith(".ts")
+    ? path.join(import.meta.dirname, "dist")
+    : import.meta.dirname;
+const SETTINGS_FILE = path.join(os.homedir(), ".cursor-mcp-feedback-settings.json");
+const PENDING_DIR = path.join(os.homedir(), ".cursor-mcp-feedback");
+const PENDING_FILE = path.join(PENDING_DIR, "pending.json");
+const DEFAULT_SETTINGS = {
+    autoAppend: true,
+    autoAppendText: "After completing, call interactive_feedback to check in with me.",
+};
+async function saveSettings(settings) {
+    const current = await (async () => {
+        try {
+            return { ...DEFAULT_SETTINGS, ...JSON.parse(await fsPromises.readFile(SETTINGS_FILE, "utf-8")) };
+        }
+        catch {
+            return { ...DEFAULT_SETTINGS };
+        }
+    })();
+    const merged = { ...current, ...settings };
+    await fsPromises.writeFile(SETTINGS_FILE, JSON.stringify(merged, null, 2), "utf-8");
+    return merged;
+}
+const FEEDBACK_SUFFIX = '\n\n<!-- Read through all your active rules now. For each rule, check: am I following it? If you have forgotten any, Read ~/.cursor/rules/ before continuing. -->';
+const FEEDBACK_TIMEOUT_MS = (parseInt(process.env.MCP_FEEDBACK_TIMEOUT || "86400", 10)) * 1000;
+const CLEANUP_INTERVAL = 3600_000; // 1h
+export function createServer() {
+    const pendingResolves = new Map();
+    const pendingTimers = new Map();
+    const server = new McpServer({
+        name: "cursor-mcp-feedback",
+        version: "1.0.0",
+    });
+    const resourceUri = "ui://interactive-feedback/mcp-app.html";
+    // ── Global scanner: every 1s, scan for resolved files matching our Promises.
+    try {
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    }
+    catch { /* ignore */ }
+    const scanner = setInterval(() => {
+        // Log current pendingResolves map
+        const mapEntries = [...pendingResolves.entries()].map(([k]) => k.substring(0, 8) + "...");
+        // log(`scanner: pendingResolves=[${mapEntries.join(", ")}]`);
+        let files;
+        try {
+            files = fs.readdirSync(SESSIONS_DIR);
+        }
+        catch {
+            return;
+        }
+        for (const f of files) {
+            if (!f.endsWith(".json"))
+                continue;
+            const fp = path.join(SESSIONS_DIR, f);
+            const sid = path.basename(f, ".json");
+            const resolve = pendingResolves.get(sid);
+            if (!resolve)
+                continue; // no matching Promise in this process
+            try {
+                const raw = fs.readFileSync(fp, "utf-8");
+                const data = JSON.parse(raw);
+                if (data.status !== "resolved")
+                    continue;
+                log(`=== scanner: resolved file matches pending session === sid=${sid} file=${fp} content=${raw}`);
+                const t = pendingTimers.get(sid);
+                if (t) {
+                    clearTimeout(t);
+                    pendingTimers.delete(sid);
+                }
+                pendingResolves.delete(sid);
+                try {
+                    fs.unlinkSync(fp);
+                }
+                catch { /* ignore */ }
+                resolve({ feedback: data.feedback || "", images: data.images, userInput: data.userInput });
+                log(`  → Promise resolved for ${sid}`);
+            }
+            catch { /* skip bad files */ }
+        }
+    }, 1000);
+    scanner.unref();
+    // ── Cleanup stale files every hour
+    const cleanup = setInterval(() => {
+        const cutoff = Date.now() - FEEDBACK_TIMEOUT_MS;
+        let files;
+        try {
+            files = fs.readdirSync(SESSIONS_DIR);
+        }
+        catch {
+            return;
+        }
+        for (const f of files) {
+            if (!f.endsWith(".json"))
+                continue;
+            try {
+                const raw = fs.readFileSync(path.join(SESSIONS_DIR, f), "utf-8");
+                const data = JSON.parse(raw);
+                if (data.createdAt && data.createdAt < cutoff) {
+                    try {
+                        fs.unlinkSync(path.join(SESSIONS_DIR, f));
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+            catch {
+                try {
+                    fs.unlinkSync(path.join(SESSIONS_DIR, f));
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }, CLEANUP_INTERVAL);
+    cleanup.unref();
+    // Clean timers on process exit
+    process.once("beforeExit", () => { clearInterval(scanner); clearInterval(cleanup); });
+    // ── interactive_feedback ──
+    registerAppTool(server, "interactive_feedback", {
+        title: "Interactive Feedback",
+        description: "Request interactive feedback from the user.",
+        inputSchema: {
+            summary: z.string().describe("Summary of what you have done so far."),
+            sessionId: z.string().uuid("sessionId must be a valid UUID v4. Generate one via: node -e \"console.log(crypto.randomUUID())\"").describe("Unique session identifier. MUST generate a UUID v4 before each call to ensure uniqueness. Generate via: node -e \"console.log(crypto.randomUUID())\" | python3 -c \"import uuid; print(uuid.uuid4())\" | uuidgen"),
+        },
+        _meta: { ui: { resourceUri } },
+    }, async ({ summary, sessionId }) => {
+        createFreshSession(summary.trim(), sessionId);
+        const filePath = path.join(SESSIONS_DIR, `${sessionId}.json`);
+        let fileContent = "(unreadable)";
+        try {
+            fileContent = fs.readFileSync(filePath, "utf-8");
+        }
+        catch { }
+        log(`=== interactive_feedback === sessionId=${sessionId} file=${filePath} content=${fileContent}`);
+        let pollError;
+        let result;
+        try {
+            result = await new Promise((resolve, reject) => {
+                pendingResolves.set(sessionId, resolve);
+                const timer = setTimeout(() => {
+                    pendingResolves.delete(sessionId);
+                    pendingTimers.delete(sessionId);
+                    reject(new Error(`Feedback timeout (${FEEDBACK_TIMEOUT_MS / 1000}s)`));
+                }, FEEDBACK_TIMEOUT_MS);
+                timer.unref();
+                pendingTimers.set(sessionId, timer);
+            });
+        }
+        catch (e) {
+            pollError = e;
+        }
+        finally {
+            pendingTimers.delete(sessionId);
+            pendingResolves.delete(sessionId);
+        }
+        if (pollError)
+            throw pollError;
+        if (!result)
+            throw new Error("Feedback cancelled");
+        logObj("interactive_feedback: resolved", { sessionId });
+        const content = [
+            { type: "text", text: result.feedback + FEEDBACK_SUFFIX },
+            { type: "text", text: JSON.stringify({ _mcp_meta: true, sessionId, userInput: result.userInput ?? result.feedback }) },
+        ];
+        if (result.images) {
+            for (const img of result.images) {
+                content.push({ type: "image", data: img, mimeType: "image/png" });
+            }
+        }
+        return { content };
+    });
+    // ── submit_feedback: just write the file, nothing more. Scanner picks it up. ──
+    registerAppTool(server, "submit_feedback", {
+        title: "Submit Feedback",
+        description: "Submit user feedback.",
+        inputSchema: {
+            feedback: z.string().describe("The user's feedback text."),
+            images: z.array(z.string()).optional().describe("Optional base64-encoded PNG images."),
+            sessionId: z.string().optional().describe("Session ID."),
+        },
+        _meta: { ui: { resourceUri, visibility: ["app"] } },
+    }, async ({ feedback, images, sessionId: sid }) => {
+        let userInput = feedback;
+        let autoAppend = false;
+        let autoAppendText = "";
+        let skipAppend = false;
+        const settingsMatch = feedback.match(/<!--mcp-settings:(.*?)-->/s);
+        if (settingsMatch) {
+            try {
+                const embedded = JSON.parse(settingsMatch[1]);
+                autoAppend = embedded.autoAppend ?? false;
+                autoAppendText = embedded.autoAppendText || "";
+                skipAppend = embedded.skipAppend ?? false;
+                await saveSettings({ autoAppend, autoAppendText });
+            }
+            catch { /* ignore */ }
+            userInput = feedback.replace(/\s*<!--mcp-settings:.*?-->/s, "").trim();
+        }
+        let fullFeedback = userInput;
+        if (!skipAppend && autoAppend && autoAppendText.trim()) {
+            fullFeedback += "\n\n" + autoAppendText.trim();
+        }
+        log(`=== submit_feedback === sessionId=${sid || "(none)"} userInputLen=${userInput.length} fullLen=${fullFeedback.length}`);
+        if (sid) {
+            resolveSession(sid, fullFeedback, images ?? undefined, userInput);
+            const filePath = path.join(SESSIONS_DIR, `${sid}.json`);
+            let content = "(unreadable)";
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch { }
+            log(`  → resolved file=${filePath} content=${content}`);
+        }
+        return { content: [{ type: "text", text: "Feedback submitted." }] };
+    });
+    // ── get_system_info ──
+    server.tool("get_system_info", "Get system information.", {}, async () => {
+        return { content: [{ type: "text", text: JSON.stringify({ platform: process.platform, arch: process.arch, nodeVersion: process.version, homeDir: os.homedir() }, null, 2) }] };
+    });
+    // ── UI resource ──
+    registerAppResource(server, resourceUri, resourceUri, { mimeType: RESOURCE_MIME_TYPE }, async () => {
+        let html = await fsPromises.readFile(path.join(DIST_DIR, "mcp-app.html"), "utf-8");
+        let settings = { autoAppend: true, autoAppendText: DEFAULT_SETTINGS.autoAppendText };
+        try {
+            const raw = await fsPromises.readFile(SETTINGS_FILE, "utf-8");
+            settings = { ...settings, ...JSON.parse(raw) };
+        }
+        catch { /* use defaults */ }
+        html = html.replace("<head>", `<head><script id="mcp-feedback-settings" type="application/json">${JSON.stringify(settings)}</script>`);
+        return { contents: [{ uri: resourceUri, mimeType: RESOURCE_MIME_TYPE, text: html }] };
+    });
+    return server;
+}

package/dist/session-store.d.ts

@@ -0,0 +1,4 @@
+declare const SESSIONS_DIR: string;
+export { SESSIONS_DIR };
+export declare function createFreshSession(summary: string, sessionId: string): string;
+export declare function resolveSession(sessionId: string, feedback: string, images?: string[], userInput?: string): void;

package/dist/session-store.js

@@ -0,0 +1,76 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { logObj } from "./logger.js";
+const SESSIONS_DIR = path.join(os.homedir(), ".cursor-mcp-feedback", "sessions");
+export { SESSIONS_DIR };
+function ensureDir() {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+function sessionPath(sessionId) {
+    return path.join(SESSIONS_DIR, `${sessionId}.json`);
+}
+function writeSession(record) {
+    ensureDir();
+    fs.writeFileSync(sessionPath(record.sessionId), JSON.stringify(record, null, 2), "utf-8");
+}
+function listSessions() {
+    ensureDir();
+    try {
+        const files = fs.readdirSync(SESSIONS_DIR);
+        const sessions = [];
+        for (const f of files) {
+            if (!f.endsWith(".json"))
+                continue;
+            try {
+                const raw = fs.readFileSync(path.join(SESSIONS_DIR, f), "utf-8");
+                sessions.push(JSON.parse(raw));
+            }
+            catch { /* skip corrupt files */ }
+        }
+        return sessions;
+    }
+    catch {
+        return [];
+    }
+}
+function cleanExpiredSessions() {
+    const now = Date.now();
+    for (const s of listSessions()) {
+        if (s.status === "pending" && (now - s.createdAt) > 86400000) {
+            s.status = "timedout";
+            writeSession(s);
+            cleanupSession(s.sessionId);
+        }
+    }
+}
+function cleanupSession(sessionId) {
+    try {
+        fs.unlinkSync(sessionPath(sessionId));
+    }
+    catch { /* ignore */ }
+}
+// ── Public API ──
+export function createFreshSession(summary, sessionId) {
+    ensureDir();
+    cleanExpiredSessions();
+    writeSession({ sessionId, summary, createdAt: Date.now(), status: "pending" });
+    logObj("session-store: created:fresh", { sessionId, summaryLen: summary.length });
+    return sessionId;
+}
+export function resolveSession(sessionId, feedback, images, userInput) {
+    const sessions = listSessions();
+    const idx = sessions.findIndex(s => s.sessionId === sessionId && s.status === "pending");
+    if (idx !== -1) {
+        sessions[idx].status = "resolved";
+        sessions[idx].feedback = feedback;
+        sessions[idx].userInput = userInput;
+        if (images?.length)
+            sessions[idx].images = images;
+        writeSession(sessions[idx]);
+    }
+    else {
+        writeSession({ sessionId, summary: "", createdAt: Date.now(), status: "resolved", feedback, images, userInput });
+    }
+    logObj("session-store: resolved", { sessionId });
+}

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

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+// Cursor hook: session lifecycle + subagent protection.
+//
+// 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
+
+'use strict';
+
+const su = require('./session-utils');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (c) => { raw += c; });
+process.stdin.on('end', () => {
+  const event = process.argv[2];
+  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);
+    }
+    su.writeHookOutput({});
+    return;
+  }
+
+  if (event === 'subagentStop') {
+    const subagentId = input.subagent_id || input.conversation_id;
+    if (subagentId) su.removeSubagent(subagentId);
+    su.writeHookOutput({});
+    return;
+  }
+
+  if (event === 'beforeMCPExecution') {
+    const command = (input.command || '').toLowerCase();
+    const isFeedbackApp =
+      command.includes('cursor-mcp-feedback') &&
+      !command.includes('mcp-feedback-enhanced');
+
+    if (!isFeedbackApp) {
+      su.writeHookOutput({});
+      return;
+    }
+
+    const convId = input.conversation_id;
+    if (convId && su.isSubagent(convId)) {
+      su.writeHookOutput({
+        permission: 'deny',
+        user_message: '[Hook] Blocked cursor-mcp-feedback call from subagent',
+        agent_message:
+          'DENIED by beforeMCPExecution hook. ' +
+          'cursor-mcp-feedback tools are for the MAIN agent only. ' +
+          'Return your results as text in your final response instead.',
+      });
+    } else {
+      su.writeHookOutput({});
+    }
+    return;
+  }
+
+  if (event === 'afterMCPExecution') {
+    const convId = input.conversation_id;
+    const toolName = input.tool_name || '';
+
+    const isFeedback = toolName === 'interactive_feedback' || toolName === 'submit_feedback';
+    if (convId && isFeedback) {
+      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 {}
+
+      if (toolName === 'interactive_feedback') {
+        su.appendJsonl(eventsFile, {
+          type: 'feedback_request',
+          conversation_id: convId,
+          summary: toolInput.summary || '',
+          source: 'hook',
+          ts: input.start_time_ms || (Date.now() - 5000),
+        });
+        let feedbackText = '';
+        try {
+          const resultJson = typeof input.result_json === 'string' ? JSON.parse(input.result_json) : (input.result_json || {});
+          if (resultJson.isError) { /* skip error responses */ }
+          else {
+            const content = resultJson.content || [];
+            for (const item of content) {
+              if (item.type === 'text' && item.text) {
+                feedbackText = item.text
+                  .split('\n<!-- ')[0]
+                  .split('\nAfter completing, call interactive_feedback')[0]
+                  .trim();
+                break;
+              }
+            }
+          }
+        } catch {}
+        if (feedbackText) {
+          su.appendJsonl(eventsFile, {
+            type: 'feedback_response',
+            conversation_id: convId,
+            text: feedbackText.slice(0, 2000),
+            source: 'hook',
+            ts: Date.now(),
+          });
+        }
+      } else {
+        su.appendJsonl(eventsFile, {
+          type: 'feedback_response',
+          conversation_id: convId,
+          text: (toolInput.feedback || '').slice(0, 2000),
+          source: 'hook',
+          ts: Date.now(),
+        });
+      }
+    }
+    su.writeHookOutput({});
+    return;
+  }
+
+  su.writeHookOutput({});
+});

package/hooks/consume-pending.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// Cursor preToolUse hook: consume pending messages for the current session.
+//
+// 1. Read conversation_id from hook input
+// 2. If subagent → skip
+// 3. Check per-session pending (sessions/<conv_id>/pending.json)
+// 4. Fallback: check global pending (~/.cursor-mcp-feedback/pending.json)
+// 5. If messages found → deny tool, inject messages as agent_message
+// 6. Update session activity timestamp
+
+'use strict';
+
+const su = require('./session-utils');
+
+const ALLOWLIST = new Set([
+  'interactive_feedback', 'submit_feedback', 'manage_pending',
+  'task', 'read', 'readfile', 'glob', 'grep', 'semanticsearch',
+]);
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (c) => { raw += c; });
+process.stdin.on('end', () => {
+  let input;
+  try { input = JSON.parse(raw); } catch { input = {}; }
+
+  const toolName = (input.tool_name || '').toLowerCase();
+  if (ALLOWLIST.has(toolName)) {
+    su.writeHookOutput({});
+    return;
+  }
+
+  const convId = input.conversation_id;
+
+  if (convId && su.isSubagent(convId)) {
+    su.writeHookOutput({});
+    return;
+  }
+
+  // preToolUse is the primary session lifecycle driver.
+  // Lazy creation: if no session dir exists, create it.
+  // Activity update: always touch last_activity.
+  // Periodic cleanup: run stale session cleanup every ~5 minutes.
+  if (convId) {
+    su.ensureSession(convId, {
+      workspace: (input.workspace_roots || [])[0] || '',
+      mode: input.composer_mode || 'agent',
+      model: input.model || '',
+      transcript_path: input.transcript_path || null,
+    });
+    su.touchSessionActivity(convId);
+    su.maybeCleanup();
+  }
+
+  // Try per-session pending first
+  let consumed = null;
+  if (convId) {
+    consumed = su.consumeSessionPending(convId, toolName);
+  }
+
+  // Fallback to global pending
+  if (!consumed) {
+    const globalMsgs = su.readGlobalPending();
+    if (globalMsgs.length > 0) {
+      const combined = globalMsgs.map((m) => m.text || m).join('\n\n---\n\n');
+      su.writeGlobalPending([]);
+      consumed = { text: combined, count: globalMsgs.length };
+
+      if (convId) {
+        su.appendJsonl(
+          require('path').join(su.sessionDir(convId), 'events.jsonl'),
+          { type: 'pending_consumed', text: combined, count: consumed.count,
+            consumed_by_tool: toolName, source: 'global', ts: Date.now() }
+        );
+      }
+    }
+  }
+
+  if (consumed) {
+    su.writeHookOutput({
+      permission: 'deny',
+      user_message: `Pending message delivered (${consumed.count})`,
+      agent_message: `[User Feedback] The user has queued the following message(s) for you:\n\n${consumed.text}\n\nPlease address this feedback before continuing with your current task.`,
+    });
+  } else {
+    su.writeHookOutput({});
+  }
+});