mcp-feedback-enhanced 0.1.45

package/README.md

@@ -0,0 +1,113 @@
+# MCP Feedback Enhanced Server
+
+**Version: 0.1.44**
+
+MCP Server component that connects to the VSCode Extension's WebSocket server to collect user feedback.
+
+## Architecture
+
+```
+┌─────────────────┐         ┌─────────────────┐
+│   Cursor/AI     │  stdio  │   MCP Server    │
+│   (AI Client)   │ ←────→  │   (This)        │
+└─────────────────┘         └────────┬────────┘
+                                     │ WebSocket
+                                     ▼
+                            ┌─────────────────┐
+                            │ VSCode Extension│
+                            │   (WS Server)   │
+                            └────────┬────────┘
+                                     │
+                                     ▼
+                            ┌─────────────────┐
+                            │ Feedback Panel  │
+                            │   (Webview)     │
+                            └─────────────────┘
+```
+
+## How It Works
+
+1. **Extension starts** → Creates WebSocket server → Writes `~/.config/mcp-feedback-enhanced/servers/<pid>.json`
+2. **MCP Server starts** → Waits for `interactive_feedback` call
+3. **AI calls tool** → MCP Server reads server files → Finds matching Extension by workspace path → Connects
+4. **User submits** → Feedback flows back to AI
+
+## Server Discovery
+
+MCP Server finds the correct Extension using multi-strategy matching:
+
+1. **Exact workspace match** - `project_directory` in server's `workspaces` array
+2. **Prefix match** - Project is inside a workspace directory
+3. **parentPid match** - Same parent process (backward compatibility)
+4. **Single server** - Only one server running
+5. **Most recent** - Last registered server
+
+## Tools
+
+### interactive_feedback
+
+Collect feedback from user through the VSCode sidebar panel.
+
+```typescript
+{
+  project_directory: string;  // Project path for context & server matching
+  summary: string;            // AI summary for user review
+  timeout?: number;           // Timeout in seconds (default: 600)
+}
+```
+
+### get_system_info
+
+Returns system environment information.
+
+## Configuration
+
+Add to `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "mcp-feedback-enhanced": {
+      "command": "node",
+      "args": ["/path/to/mcp-server/dist/index.js"],
+      "env": {
+        "MCP_FEEDBACK_DEBUG": "true"
+      },
+      "timeout": 89400,
+      "autoApprove": ["interactive_feedback"]
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MCP_FEEDBACK_DEBUG` | `false` | Enable debug logging to stderr |
+
+## Debug Mode
+
+Set `MCP_FEEDBACK_DEBUG=true` to see:
+- Server discovery process
+- WebSocket connection status
+- Message flow between components
+
+## Troubleshooting
+
+### "No MCP Feedback Extension found for project"
+
+1. Ensure VSCode extension is installed and activated
+2. Open the MCP Feedback panel (click sidebar icon)
+3. Check `~/.config/mcp-feedback-enhanced/servers/` for server files
+4. Verify your project path is in the `workspaces` array
+
+### Connection timeout
+
+1. Check if Extension's WebSocket server is running (port in server file)
+2. Verify no firewall blocking localhost connections
+3. Try reloading the Cursor window
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * MCP Feedback Server - TypeScript Implementation
+ *
+ * This server provides the interactive_feedback tool that collects
+ * user feedback through a VSCode extension sidebar panel.
+ *
+ * NEW ARCHITECTURE: MCP Server connects to Extension's WebSocket Server
+ * (instead of running its own WebSocket Server)
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,361 @@
+#!/usr/bin/env node
+/**
+ * MCP Feedback Server - TypeScript Implementation
+ *
+ * This server provides the interactive_feedback tool that collects
+ * user feedback through a VSCode extension sidebar panel.
+ *
+ * NEW ARCHITECTURE: MCP Server connects to Extension's WebSocket Server
+ * (instead of running its own WebSocket Server)
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import WebSocket from 'ws';
+import * as z from 'zod';
+import * as os from 'os';
+import * as fs from 'fs';
+import * as path from 'path';
+import { createRequire } from 'module';
+// Read version from package.json (ES module compatible)
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+const VERSION = packageJson.version || '0.0.0';
+// Configuration
+const DEBUG = process.env.MCP_FEEDBACK_DEBUG === 'true';
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'mcp-feedback-enhanced');
+const SERVERS_DIR = path.join(CONFIG_DIR, 'servers');
+const CONNECTION_TIMEOUT_MS = 5000; // 5 seconds to connect
+const HEARTBEAT_INTERVAL_MS = 30000; // 30 seconds heartbeat
+// Debug logging
+function debug(message) {
+    if (DEBUG) {
+        console.error(`[MCP Feedback] ${message}`);
+    }
+}
+// State
+let ws = null;
+let isConnected = false;
+let pendingFeedbackResolvers = new Map();
+/**
+ * Get all live Extension servers
+ */
+function getLiveServers() {
+    try {
+        if (!fs.existsSync(SERVERS_DIR)) {
+            debug('Servers directory not found');
+            return [];
+        }
+        const files = fs.readdirSync(SERVERS_DIR);
+        const servers = [];
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(SERVERS_DIR, file), 'utf-8'));
+                // Verify process is still alive
+                try {
+                    process.kill(data.pid, 0);
+                    servers.push({
+                        ...data,
+                        workspaces: data.workspaces || [] // Handle old format
+                    });
+                }
+                catch {
+                    // Process dead, skip
+                    debug(`Skipping dead server: pid=${data.pid}`);
+                }
+            }
+            catch {
+                // Skip invalid files
+            }
+        }
+        return servers;
+    }
+    catch (e) {
+        debug(`Error reading servers: ${e}`);
+        return [];
+    }
+}
+/**
+ * Find the best Extension server for a given project path
+ * Uses workspace matching as primary strategy
+ */
+function findExtensionForProject(projectPath) {
+    const servers = getLiveServers();
+    debug(`Looking for Extension for project: ${projectPath}`);
+    debug(`Found ${servers.length} live Extension server(s)`);
+    if (servers.length === 0) {
+        return null;
+    }
+    // Strategy 1: Exact workspace match
+    for (const server of servers) {
+        if (server.workspaces?.includes(projectPath)) {
+            debug(`✓ Exact workspace match: port=${server.port}`);
+            return server;
+        }
+    }
+    // Strategy 2: Prefix match (project is inside a workspace)
+    for (const server of servers) {
+        for (const ws of server.workspaces || []) {
+            if (projectPath.startsWith(ws + path.sep) || ws.startsWith(projectPath + path.sep)) {
+                debug(`✓ Prefix workspace match: port=${server.port}, workspace=${ws}`);
+                return server;
+            }
+        }
+    }
+    // Strategy 3: parentPid match (backward compatibility)
+    const myParentPid = process.ppid;
+    const parentMatch = servers.find(s => s.parentPid === myParentPid);
+    if (parentMatch) {
+        debug(`✓ parentPid match: port=${parentMatch.port}`);
+        return parentMatch;
+    }
+    // Strategy 4: Single server fallback
+    if (servers.length === 1) {
+        debug(`✓ Single server fallback: port=${servers[0].port}`);
+        return servers[0];
+    }
+    // Strategy 5: Most recent server
+    const sorted = servers.sort((a, b) => b.timestamp - a.timestamp);
+    debug(`✓ Using most recent server: port=${sorted[0].port}`);
+    debug(`  Available servers:`);
+    sorted.forEach(s => {
+        debug(`    - pid=${s.pid}, port=${s.port}, workspaces=${s.workspaces?.join(', ')}`);
+    });
+    return sorted[0];
+}
+// Track which server we're connected to
+let connectedPort = null;
+/**
+ * Connect to Extension's WebSocket Server for a specific project
+ */
+function connectToExtension(projectPath) {
+    return new Promise((resolve, reject) => {
+        const server = findExtensionForProject(projectPath);
+        if (!server) {
+            reject(new Error(`No MCP Feedback Extension found for project: ${projectPath}. Please ensure the extension is installed and a Cursor window is open with this project.`));
+            return;
+        }
+        const url = `ws://127.0.0.1:${server.port}/ws`;
+        debug(`Connecting to Extension at ${url} for project ${projectPath}`);
+        ws = new WebSocket(url);
+        ws.on('open', () => {
+            debug('Connected to Extension WebSocket Server');
+            isConnected = true;
+            connectedPort = server.port;
+            // Register as MCP Server
+            ws?.send(JSON.stringify({
+                type: 'register',
+                clientType: 'mcp-server',
+                pid: process.pid,
+                parentPid: process.ppid
+            }));
+            resolve();
+        });
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                handleMessage(message);
+            }
+            catch (e) {
+                debug(`Parse error: ${e}`);
+            }
+        });
+        ws.on('close', () => {
+            debug('Disconnected from Extension');
+            isConnected = false;
+            connectedPort = null;
+            ws = null;
+            // Reject all pending feedback requests
+            pendingFeedbackResolvers.forEach((resolver, sessionId) => {
+                clearTimeout(resolver.timeout);
+                resolver.reject(new Error('Connection to Extension lost'));
+            });
+            pendingFeedbackResolvers.clear();
+        });
+        ws.on('error', (err) => {
+            debug(`WebSocket error: ${err.message}`);
+            if (!isConnected) {
+                reject(err);
+            }
+        });
+        // Timeout for initial connection
+        setTimeout(() => {
+            if (!isConnected) {
+                ws?.close();
+                reject(new Error(`Connection timeout to ${url}`));
+            }
+        }, CONNECTION_TIMEOUT_MS);
+    });
+}
+/**
+ * Ensure connected to the right Extension for this project
+ */
+async function ensureConnectedForProject(projectPath) {
+    // Check if we need to reconnect (different project might need different Extension)
+    const server = findExtensionForProject(projectPath);
+    if (!server) {
+        throw new Error(`No MCP Feedback Extension found for project: ${projectPath}. Please open the project in Cursor with the MCP Feedback extension installed.`);
+    }
+    // If already connected to the right server, reuse connection
+    if (isConnected && ws?.readyState === WebSocket.OPEN && connectedPort === server.port) {
+        return;
+    }
+    // Close existing connection if any
+    if (ws) {
+        ws.close();
+        ws = null;
+        isConnected = false;
+        connectedPort = null;
+    }
+    // Connect to the right server
+    await connectToExtension(projectPath);
+}
+/**
+ * Handle messages from Extension
+ */
+function handleMessage(message) {
+    debug(`Received: ${message.type}`);
+    switch (message.type) {
+        case 'connection_established':
+            debug(`Connected to Extension v${message.version}`);
+            break;
+        case 'feedback_result':
+            // User submitted feedback
+            const resolver = pendingFeedbackResolvers.get(message.session_id);
+            if (resolver) {
+                clearTimeout(resolver.timeout);
+                resolver.resolve({
+                    feedback: message.feedback,
+                    images: message.images || []
+                });
+                pendingFeedbackResolvers.delete(message.session_id);
+            }
+            break;
+        case 'feedback_error':
+            // Error getting feedback
+            const errorResolver = pendingFeedbackResolvers.get(message.session_id);
+            if (errorResolver) {
+                clearTimeout(errorResolver.timeout);
+                errorResolver.reject(new Error(message.error));
+                pendingFeedbackResolvers.delete(message.session_id);
+            }
+            break;
+        case 'pong':
+            // Heartbeat response
+            break;
+    }
+}
+/**
+ * Request feedback from user via Extension
+ */
+async function requestFeedback(projectDirectory, summary, timeout) {
+    await ensureConnectedForProject(projectDirectory);
+    const sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    return new Promise((resolve, reject) => {
+        // Set timeout
+        const timeoutHandle = setTimeout(() => {
+            pendingFeedbackResolvers.delete(sessionId);
+            reject(new Error(`Feedback timeout after ${timeout} seconds`));
+        }, timeout * 1000);
+        // Store resolver
+        pendingFeedbackResolvers.set(sessionId, {
+            resolve,
+            reject,
+            timeout: timeoutHandle
+        });
+        // Send request to Extension
+        ws?.send(JSON.stringify({
+            type: 'feedback_request',
+            session_id: sessionId,
+            project_directory: projectDirectory,
+            summary,
+            timeout
+        }));
+        debug(`Feedback request sent: session=${sessionId}`);
+    });
+}
+// ============================================================================
+// MCP Server Setup
+// ============================================================================
+const server = new McpServer({
+    name: 'mcp-feedback-enhanced',
+    version: VERSION
+});
+// Register the interactive_feedback tool
+server.tool('interactive_feedback', 'Collect feedback from user through VSCode extension panel. The feedback panel will display the AI summary and wait for user input.', {
+    project_directory: z.string().describe('The project directory path for context'),
+    summary: z.string().describe('Summary of AI work completed for user review'),
+    timeout: z.number().optional().default(600).describe('Timeout in seconds (default: 600)')
+}, async ({ project_directory, summary, timeout }) => {
+    debug(`interactive_feedback called: project=${project_directory}`);
+    try {
+        const result = await requestFeedback(project_directory, summary, timeout || 600);
+        // Format response
+        let response = `User Feedback:\n${result.feedback}`;
+        if (result.images && result.images.length > 0) {
+            response += `\n\n[${result.images.length} image(s) attached]`;
+        }
+        return {
+            content: [{ type: 'text', text: response }]
+        };
+    }
+    catch (error) {
+        debug(`Feedback error: ${error.message}`);
+        return {
+            content: [{ type: 'text', text: `Error: ${error.message}` }],
+            isError: true
+        };
+    }
+});
+// Register get_system_info tool
+server.tool('get_system_info', 'Get system environment information', {}, async () => {
+    const info = {
+        platform: os.platform(),
+        hostname: os.hostname(),
+        user: os.userInfo().username,
+        homeDir: os.homedir(),
+        nodeVersion: process.version,
+        pid: process.pid,
+        parentPid: process.ppid,
+        extensionConnected: isConnected
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(info, null, 2) }]
+    };
+});
+// ============================================================================
+// Main Entry Point
+// ============================================================================
+async function main() {
+    debug('MCP Feedback Server starting...');
+    debug(`PID: ${process.pid}, Parent PID: ${process.ppid}`);
+    debug(`Version: ${VERSION}`);
+    // Log environment for debugging
+    if (DEBUG) {
+        console.error('[MCP Feedback] Environment:');
+        Object.keys(process.env).filter(k => k.includes('CURSOR') || k.includes('VSCODE') || k.includes('MCP')).forEach(k => console.error(`  ${k}=${process.env[k]}`));
+        // Show available servers
+        const servers = getLiveServers();
+        console.error(`[MCP Feedback] Available servers: ${servers.length}`);
+        servers.forEach(s => {
+            console.error(`  - port=${s.port}, workspaces=${s.workspaces?.join(', ')}`);
+        });
+    }
+    // Don't connect at startup - we'll connect on demand when interactive_feedback is called
+    // This allows us to use project_directory for server matching
+    // Start MCP server on stdio
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    debug('MCP Server running on stdio, will connect to Extension on first feedback request');
+    // Heartbeat to keep connection alive
+    setInterval(() => {
+        if (ws?.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: 'ping' }));
+        }
+    }, HEARTBEAT_INTERVAL_MS);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "mcp-feedback-enhanced",
+  "version": "0.1.45",
+  "description": "MCP Feedback Enhanced Server - Interactive feedback collection for AI assistants",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-feedback-enhanced": "dist/index.js",
+    "mcp-feedback-server": "dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "feedback",
+    "cursor",
+    "vscode",
+    "claude"
+  ],
+  "author": "Minidoracat",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Minidoracat/mcp-feedback-enhanced"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "ws": "^8.18.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.5.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}