mcp-feedback-enhanced 0.1.45 → 0.1.55

package/dist/index.js

@@ -15,6 +15,7 @@ import * as z from 'zod';
 import * as os from 'os';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as net from 'net';
 import { createRequire } from 'module';
 // Read version from package.json (ES module compatible)
 const require = createRequire(import.meta.url);
@@ -26,6 +27,9 @@ 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
+const PORT_CHECK_TIMEOUT_MS = 1000; // 1 second to check port
+const MAX_RECONNECT_ATTEMPTS = 3;
+const RECONNECT_DELAY_MS = 2000;
 // Debug logging
 function debug(message) {
     if (DEBUG) {
@@ -37,7 +41,88 @@ let ws = null;
 let isConnected = false;
 let pendingFeedbackResolvers = new Map();
 /**
- * Get all live Extension servers
+ * Check if a port is actually accepting connections
+ */
+function checkPortConnectivity(port) {
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        let resolved = false;
+        const cleanup = () => {
+            if (!resolved) {
+                resolved = true;
+                socket.destroy();
+            }
+        };
+        socket.setTimeout(PORT_CHECK_TIMEOUT_MS);
+        socket.on('connect', () => {
+            cleanup();
+            resolve(true);
+        });
+        socket.on('error', () => {
+            cleanup();
+            resolve(false);
+        });
+        socket.on('timeout', () => {
+            cleanup();
+            resolve(false);
+        });
+        socket.connect(port, '127.0.0.1');
+    });
+}
+/**
+ * Get all live Extension servers (with port connectivity check)
+ */
+async function getLiveServersAsync() {
+    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);
+                    // Also check if port is actually responding (fixes stale port bug)
+                    const portOk = await checkPortConnectivity(data.port);
+                    if (portOk) {
+                        servers.push({
+                            ...data,
+                            workspaces: data.workspaces || []
+                        });
+                    }
+                    else {
+                        debug(`Skipping server with unresponsive port: pid=${data.pid}, port=${data.port}`);
+                        // Remove stale server file
+                        try {
+                            fs.unlinkSync(path.join(SERVERS_DIR, file));
+                            debug(`Removed stale server file: ${file}`);
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
+                catch {
+                    debug(`Skipping dead server: pid=${data.pid}`);
+                }
+            }
+            catch {
+                // Skip invalid files
+            }
+        }
+        return servers;
+    }
+    catch (e) {
+        debug(`Error reading servers: ${e}`);
+        return [];
+    }
+}
+/**
+ * Get all live Extension servers (sync version for backward compat)
  */
 function getLiveServers() {
     try {
@@ -79,11 +164,12 @@ function getLiveServers() {
 /**
  * Find the best Extension server for a given project path
  * Uses workspace matching as primary strategy
+ * Now async to support port connectivity checks
  */
-function findExtensionForProject(projectPath) {
-    const servers = getLiveServers();
+async function findExtensionForProjectAsync(projectPath) {
+    const servers = await getLiveServersAsync();
     debug(`Looking for Extension for project: ${projectPath}`);
-    debug(`Found ${servers.length} live Extension server(s)`);
+    debug(`Found ${servers.length} live Extension server(s) with valid ports`);
     if (servers.length === 0) {
         return null;
     }
@@ -124,25 +210,77 @@ function findExtensionForProject(projectPath) {
     });
     return sorted[0];
 }
+/**
+ * Find the best Extension server (sync version for debug/startup)
+ */
+function findExtensionForProject(projectPath) {
+    const servers = getLiveServers();
+    if (servers.length === 0)
+        return null;
+    // Same matching logic but sync
+    for (const server of servers) {
+        if (server.workspaces?.includes(projectPath))
+            return server;
+    }
+    for (const server of servers) {
+        for (const ws of server.workspaces || []) {
+            if (projectPath.startsWith(ws + path.sep) || ws.startsWith(projectPath + path.sep)) {
+                return server;
+            }
+        }
+    }
+    const parentMatch = servers.find(s => s.parentPid === process.ppid);
+    if (parentMatch)
+        return parentMatch;
+    if (servers.length === 1)
+        return servers[0];
+    return servers.sort((a, b) => b.timestamp - a.timestamp)[0];
+}
 // Track which server we're connected to
 let connectedPort = null;
+let lastProjectPath = '';
 /**
  * Connect to Extension's WebSocket Server for a specific project
+ * With retry logic for handling stale connections
  */
-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;
+async function connectToExtensionWithRetry(projectPath, maxRetries = MAX_RECONNECT_ATTEMPTS) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            await connectToExtension(projectPath);
+            return; // Success
+        }
+        catch (err) {
+            lastError = err;
+            debug(`Connection attempt ${attempt}/${maxRetries} failed: ${err.message}`);
+            if (attempt < maxRetries) {
+                // Wait before retry with exponential backoff
+                const delay = RECONNECT_DELAY_MS * attempt;
+                debug(`Retrying in ${delay}ms...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
         }
-        const url = `ws://127.0.0.1:${server.port}/ws`;
-        debug(`Connecting to Extension at ${url} for project ${projectPath}`);
+    }
+    throw lastError || new Error('Connection failed after retries');
+}
+/**
+ * Connect to Extension's WebSocket Server for a specific project
+ */
+async function connectToExtension(projectPath) {
+    // Use async version to check port connectivity
+    const server = await findExtensionForProjectAsync(projectPath);
+    if (!server) {
+        throw 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.`);
+    }
+    const url = `ws://127.0.0.1:${server.port}/ws`;
+    debug(`Connecting to Extension at ${url} for project ${projectPath}`);
+    return new Promise((resolve, reject) => {
         ws = new WebSocket(url);
         ws.on('open', () => {
             debug('Connected to Extension WebSocket Server');
             isConnected = true;
             connectedPort = server.port;
+            lastProjectPath = projectPath;
             // Register as MCP Server
             ws?.send(JSON.stringify({
                 type: 'register',
@@ -163,15 +301,15 @@ function connectToExtension(projectPath) {
         });
         ws.on('close', () => {
             debug('Disconnected from Extension');
+            const wasConnected = isConnected;
             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();
+            // Only reject pending if we were previously connected (unexpected disconnect)
+            if (wasConnected && pendingFeedbackResolvers.size > 0) {
+                debug(`Connection lost with ${pendingFeedbackResolvers.size} pending requests`);
+                // Don't reject immediately - the next feedback request will trigger reconnect
+            }
         });
         ws.on('error', (err) => {
             debug(`WebSocket error: ${err.message}`);
@@ -190,26 +328,28 @@ function connectToExtension(projectPath) {
 }
 /**
  * Ensure connected to the right Extension for this project
+ * With automatic reconnection and retry
  */
 async function ensureConnectedForProject(projectPath) {
-    // Check if we need to reconnect (different project might need different Extension)
-    const server = findExtensionForProject(projectPath);
+    // Use async version to check port connectivity
+    const server = await findExtensionForProjectAsync(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 already connected to the right server and connection is open, reuse
     if (isConnected && ws?.readyState === WebSocket.OPEN && connectedPort === server.port) {
         return;
     }
     // Close existing connection if any
     if (ws) {
+        debug('Closing existing connection for reconnect');
         ws.close();
         ws = null;
         isConnected = false;
         connectedPort = null;
     }
-    // Connect to the right server
-    await connectToExtension(projectPath);
+    // Connect with retry logic
+    await connectToExtensionWithRetry(projectPath);
 }
 /**
  * Handle messages from Extension
@@ -249,7 +389,7 @@ function handleMessage(message) {
 /**
  * Request feedback from user via Extension
  */
-async function requestFeedback(projectDirectory, summary, timeout) {
+async function requestFeedback(projectDirectory, summary, timeout, agentName) {
     await ensureConnectedForProject(projectDirectory);
     const sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
     return new Promise((resolve, reject) => {
@@ -270,9 +410,10 @@ async function requestFeedback(projectDirectory, summary, timeout) {
             session_id: sessionId,
             project_directory: projectDirectory,
             summary,
-            timeout
+            timeout,
+            agent_name: agentName // For multi-agent display
         }));
-        debug(`Feedback request sent: session=${sessionId}`);
+        debug(`Feedback request sent: session=${sessionId}, agent=${agentName || 'default'}`);
     });
 }
 // ============================================================================
@@ -286,19 +427,30 @@ const server = new McpServer({
 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}`);
+    timeout: z.number().optional().default(600).describe('Timeout in seconds (default: 600)'),
+    agent_name: z.string().optional().describe('Display name for this agent/chat (e.g. "Chat 1", "Refactor Task")')
+}, async ({ project_directory, summary, timeout, agent_name }) => {
+    debug(`interactive_feedback called: project=${project_directory}, agent=${agent_name || 'default'}`);
     try {
-        const result = await requestFeedback(project_directory, summary, timeout || 600);
-        // Format response
-        let response = `User Feedback:\n${result.feedback}`;
+        const result = await requestFeedback(project_directory, summary, timeout || 600, agent_name);
+        // Build content array with text and images
+        const content = [{ type: 'text', text: `User Feedback:\n${result.feedback}` }];
+        // Add images as MCP image content items
         if (result.images && result.images.length > 0) {
-            response += `\n\n[${result.images.length} image(s) attached]`;
+            debug(`Processing ${result.images.length} image(s)`);
+            for (const img of result.images) {
+                // img is { name: string, data: string (base64) }
+                if (img && img.data) {
+                    content.push({
+                        type: 'image',
+                        data: img.data,
+                        mimeType: 'image/png' // Default to PNG; could infer from name
+                    });
+                    debug(`Added image: ${img.name || 'unnamed'}`);
+                }
+            }
         }
-        return {
-            content: [{ type: 'text', text: response }]
-        };
+        return { content };
     }
     catch (error) {
         debug(`Feedback error: ${error.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-feedback-enhanced",
-  "version": "0.1.45",
+  "version": "0.1.55",
   "description": "MCP Feedback Enhanced Server - Interactive feedback collection for AI assistants",
   "type": "module",
   "main": "dist/index.js",