cursor-mcp-feedback 2.0.0

package/dist/main.js

@@ -0,0 +1,438 @@
+#!/usr/bin/env node
+/**
+ * MCP Feedback App entry point.
+ *
+ * Modes:
+ *   --stdio   : stdio transport (default, for Claude Desktop / Cursor)
+ *   --http    : HTTP transport on port 3001 (for Claude Web / remote testing)
+ *
+ * The blocking feedback pattern (interactive_feedback waits for submit_feedback)
+ * requires a persistent connection, so stdio is the primary transport.
+ * HTTP mode creates a new server per request for stateless tool calls.
+ */
+import { createServer } from "./server.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+import { log, logError } from "./logger.js";
+function getSrcDir() {
+    return import.meta.filename.endsWith(".ts")
+        ? import.meta.dirname
+        : path.dirname(import.meta.filename);
+}
+function syncFile(sourceFile, targetFile, label) {
+    if (!fs.existsSync(sourceFile))
+        return;
+    const srcHash = crypto.createHash("md5").update(fs.readFileSync(sourceFile)).digest("hex");
+    if (fs.existsSync(targetFile)) {
+        const tgtHash = crypto.createHash("md5").update(fs.readFileSync(targetFile)).digest("hex");
+        if (srcHash === tgtHash)
+            return;
+        fs.copyFileSync(sourceFile, targetFile);
+        log(`${label} updated (hash changed) at ${targetFile}`);
+    }
+    else {
+        fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+        fs.copyFileSync(sourceFile, targetFile);
+        log(`${label} installed to ${targetFile}`);
+    }
+}
+function installCursorRule() {
+    try {
+        const src = path.join(getSrcDir(), "..", "rules", "cursor-mcp-feedback.mdc");
+        const dst = path.join(os.homedir(), ".cursor", "rules", "cursor-mcp-feedback.mdc");
+        syncFile(src, dst, "Cursor rule");
+    }
+    catch { /* non-critical */ }
+}
+function installCursorMcpConfig() {
+    try {
+        const mcpJsonPath = path.join(os.homedir(), ".cursor", "mcp.json");
+        let config;
+        try {
+            config = JSON.parse(fs.readFileSync(mcpJsonPath, "utf8"));
+        }
+        catch {
+            config = { mcpServers: {} };
+        }
+        const mainJs = path.join(getSrcDir(), "..", "dist", "main.js");
+        const resolvedMain = fs.realpathSync(mainJs);
+        const desired = {
+            command: process.execPath,
+            args: [resolvedMain],
+            timeout: 86400,
+            env: { MCP_FEEDBACK_TIMEOUT: "86400" },
+        };
+        const existing = config.mcpServers["cursor-mcp-feedback"];
+        if (existing && JSON.stringify(existing) === JSON.stringify(desired))
+            return;
+        config.mcpServers["cursor-mcp-feedback"] = desired;
+        fs.writeFileSync(mcpJsonPath, JSON.stringify(config, null, 2) + "\n");
+        log("Cursor mcp.json updated for cursor-mcp-feedback");
+    }
+    catch (err) {
+        logError("mcp.json install failed: " + err);
+    }
+}
+function installCursorHooks() {
+    try {
+        const hooksDir = path.join(os.homedir(), ".cursor", "hooks");
+        const hookScripts = ["session-utils.js", "block-cursor-mcp-feedback.js", "consume-pending.js"];
+        for (const script of hookScripts) {
+            const src = path.join(getSrcDir(), "..", "hooks", script);
+            const dst = path.join(hooksDir, script);
+            syncFile(src, dst, `Cursor hook (${script})`);
+            try {
+                fs.chmodSync(dst, 0o755);
+            }
+            catch { /* ignore */ }
+        }
+        const hooksJsonPath = path.join(os.homedir(), ".cursor", "hooks.json");
+        let config;
+        try {
+            config = JSON.parse(fs.readFileSync(hooksJsonPath, "utf8"));
+        }
+        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;
+            }
+        }
+        for (const [event, entry] of Object.entries(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;
+            }
+        }
+        if (changed) {
+            fs.writeFileSync(hooksJsonPath, JSON.stringify(config, null, 2) + "\n");
+            log("Cursor hooks.json updated for cursor-mcp-feedback");
+        }
+    }
+    catch (err) {
+        logError("Hook install failed: " + err);
+    }
+}
+function migrateOldData() {
+    try {
+        const oldDir = path.join(os.homedir(), ".mcp-feedback-app");
+        const newDir = path.join(os.homedir(), ".cursor-mcp-feedback");
+        if (fs.existsSync(oldDir) && !fs.existsSync(newDir)) {
+            fs.renameSync(oldDir, newDir);
+            log("Migrated data directory from .mcp-feedback-app to .cursor-mcp-feedback");
+        }
+        const oldLog = path.join(os.homedir(), ".mcp-feedback-app.log");
+        const newLog = path.join(os.homedir(), ".cursor-mcp-feedback.log");
+        if (fs.existsSync(oldLog) && !fs.existsSync(newLog)) {
+            fs.renameSync(oldLog, newLog);
+        }
+        const oldSettings = path.join(os.homedir(), ".mcp-feedback-app-settings.json");
+        const newSettings = path.join(os.homedir(), ".cursor-mcp-feedback-settings.json");
+        if (fs.existsSync(oldSettings) && !fs.existsSync(newSettings)) {
+            fs.renameSync(oldSettings, newSettings);
+        }
+        const oldRule = path.join(os.homedir(), ".cursor", "rules", "mcp-feedback-app.mdc");
+        if (fs.existsSync(oldRule))
+            fs.unlinkSync(oldRule);
+        const oldHook = path.join(os.homedir(), ".cursor", "hooks", "block-mcp-feedback-app.js");
+        if (fs.existsSync(oldHook))
+            fs.unlinkSync(oldHook);
+        const hooksJsonPath = path.join(os.homedir(), ".cursor", "hooks.json");
+        try {
+            const hc = JSON.parse(fs.readFileSync(hooksJsonPath, "utf8"));
+            let hChanged = false;
+            for (const arr of Object.values(hc.hooks || {})) {
+                const idx = arr.findIndex((h) => h._source === "mcp-feedback-app");
+                if (idx >= 0) {
+                    arr.splice(idx, 1);
+                    hChanged = true;
+                }
+            }
+            if (hChanged)
+                fs.writeFileSync(hooksJsonPath, JSON.stringify(hc, null, 2) + "\n");
+        }
+        catch { /* ignore */ }
+        const mcpJsonPath = path.join(os.homedir(), ".cursor", "mcp.json");
+        try {
+            const mc = JSON.parse(fs.readFileSync(mcpJsonPath, "utf8"));
+            if (mc.mcpServers?.["mcp-feedback-app"]) {
+                delete mc.mcpServers["mcp-feedback-app"];
+                fs.writeFileSync(mcpJsonPath, JSON.stringify(mc, null, 2) + "\n");
+            }
+        }
+        catch { /* ignore */ }
+    }
+    catch { /* non-critical */ }
+}
+const BASE_DIR = path.join(os.homedir(), ".cursor-mcp-feedback");
+const SESSIONS_DIR = path.join(BASE_DIR, "sessions");
+const ACTIVE_FILE = path.join(BASE_DIR, "active-sessions.json");
+const GLOBAL_PENDING = path.join(BASE_DIR, "pending.json");
+function readJsonCli(file, fallback) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJsonCli(file, data) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+function formatAgo(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m`;
+    return `${Math.floor(s / 3600)}h`;
+}
+function resolveSessionId(explicit) {
+    if (explicit)
+        return explicit;
+    const sessions = readJsonCli(ACTIVE_FILE, []);
+    if (sessions.length === 0)
+        return null;
+    sessions.sort((a, b) => (b.last_activity || 0) - (a.last_activity || 0));
+    return sessions[0].id;
+}
+function pendingFile(sessionId) {
+    return path.join(SESSIONS_DIR, sessionId, "pending.json");
+}
+const args = process.argv.slice(2);
+// ── CLI: queue subcommand ──
+if (args[0] === "queue") {
+    const sub = args[1];
+    const sessionFlag = args.indexOf("--session");
+    const explicitSession = sessionFlag >= 0 ? args[sessionFlag + 1] : undefined;
+    if (sub === "sessions") {
+        const sessions = readJsonCli(ACTIVE_FILE, []);
+        if (sessions.length === 0) {
+            console.log("No active sessions.");
+        }
+        else {
+            console.log(`${sessions.length} active session(s):`);
+            for (const s of sessions) {
+                const dir = s.workspace ? path.basename(s.workspace) : "?";
+                const ago = formatAgo(Date.now() - (s.last_activity || 0));
+                console.log(`  ${s.id.slice(0, 8)}  ${dir}  (${s.mode}, ${ago} ago)`);
+            }
+        }
+        process.exit(0);
+    }
+    if (!sub || sub === "list") {
+        const sid = resolveSessionId(explicitSession);
+        if (!sid) {
+            const global = readJsonCli(GLOBAL_PENDING, []);
+            if (global.length === 0)
+                console.log("No active sessions and no global pending messages.");
+            else {
+                console.log(`${global.length} global pending message(s):`);
+                for (const m of global)
+                    console.log(`  [${formatAgo(Date.now() - m.createdAt)} ago] ${m.text}`);
+            }
+        }
+        else {
+            const msgs = readJsonCli(pendingFile(sid), []);
+            console.log(`Session ${sid.slice(0, 8)} — ${msgs.length} pending message(s):`);
+            for (const m of msgs)
+                console.log(`  [${formatAgo(Date.now() - m.createdAt)} ago] ${m.text}`);
+        }
+        process.exit(0);
+    }
+    if (sub === "clear") {
+        const sid = resolveSessionId(explicitSession);
+        if (sid) {
+            writeJsonCli(pendingFile(sid), []);
+            console.log(`Session ${sid.slice(0, 8)} pending messages cleared.`);
+        }
+        else {
+            writeJsonCli(GLOBAL_PENDING, []);
+            console.log("Global pending messages cleared.");
+        }
+        process.exit(0);
+    }
+    // Default: add message
+    const filteredArgs = args.slice(1).filter((_, i) => {
+        const absI = i + 1;
+        return absI !== args.indexOf("--session") && absI !== args.indexOf("--session") + 1;
+    });
+    const text = filteredArgs.join(" ");
+    if (!text) {
+        console.error("Usage: cursor-mcp-feedback queue <message> [--session <id>]");
+        process.exit(1);
+    }
+    const sid = resolveSessionId(explicitSession);
+    if (sid) {
+        const msgs = readJsonCli(pendingFile(sid), []);
+        msgs.push({ id: crypto.randomUUID(), text, createdAt: Date.now() });
+        writeJsonCli(pendingFile(sid), msgs);
+        console.log(`Queued to session ${sid.slice(0, 8)}: "${text}" (${msgs.length} total)`);
+    }
+    else {
+        const msgs = readJsonCli(GLOBAL_PENDING, []);
+        msgs.push({ id: crypto.randomUUID(), text, createdAt: Date.now() });
+        writeJsonCli(GLOBAL_PENDING, msgs);
+        console.log(`Queued (global): "${text}" (${msgs.length} total)`);
+    }
+    process.exit(0);
+}
+if (args.includes("--install-only")) {
+    try {
+        migrateOldData();
+        installCursorRule();
+        installCursorMcpConfig();
+        installCursorHooks();
+        log("install-only: auto-configuration completed");
+    }
+    catch { /* non-critical */ }
+    process.exit(0);
+}
+const useHttp = args.includes("--http");
+if (useHttp) {
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    const express = (await import("express")).default;
+    const cors = (await import("cors")).default;
+    const app = express();
+    app.use(cors());
+    app.use(express.json());
+    // Persist transport sessions so each MCP client gets its own server instance.
+    // This isolates pendingSessions per client — submit_feedback from client A
+    // cannot accidentally resolve client B's interactive_feedback.
+    const sessions = new Map();
+    let seenNewIds = new Set();
+    app.all("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        // Route to existing session (non-initialization requests)
+        if (sessionId && sessions.has(sessionId)) {
+            if (!seenNewIds.has(sessionId)) {
+                seenNewIds.add(sessionId);
+                log(`http: routing established session ${sessionId} (${sessions.size} active)`);
+            }
+            const transport = sessions.get(sessionId);
+            try {
+                await transport.handleRequest(req, res, req.body);
+            }
+            catch (error) {
+                logError(`http: request error on session ${sessionId}: ${error}`);
+                if (!res.headersSent) {
+                    res.status(500).json({
+                        jsonrpc: "2.0",
+                        error: { code: -32603, message: "Internal server error" },
+                        id: null,
+                    });
+                }
+            }
+            return;
+        }
+        // New session: create a fresh server (with isolated pendingSessions)
+        const server = createServer();
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => crypto.randomUUID(),
+            onsessionclosed: (sid) => {
+                if (sid) {
+                    log("http: session closed " + sid);
+                    sessions.delete(sid);
+                }
+            },
+        });
+        try {
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+            // After initialization, the transport will have a sessionId — persist it
+            if (transport.sessionId) {
+                sessions.set(transport.sessionId, transport);
+                log(`http: new session ${transport.sessionId} (${sessions.size} active)`);
+            }
+        }
+        catch (error) {
+            logError("http: initialization error: " + error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: { code: -32603, message: "Internal server error" },
+                    id: null,
+                });
+            }
+        }
+    });
+    const port = parseInt(process.env.PORT || "3001", 10);
+    app.listen(port, () => {
+        log(`http: server listening on http://localhost:${port}/mcp`);
+    });
+}
+else {
+    const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    try {
+        migrateOldData();
+        installCursorRule();
+        installCursorMcpConfig();
+        installCursorHooks();
+        const server = createServer();
+        const transport = new StdioServerTransport();
+        transport.onclose = () => {
+            log("stdio: transport closed");
+        };
+        await server.connect(transport);
+        log("stdio: server started");
+    }
+    catch (err) {
+        logError("stdio: fatal error: " + err);
+        process.exit(1);
+    }
+}