mcp-feedback-enhanced 0.1.65 → 0.1.67

package/dist/index.js

@@ -169,7 +169,7 @@ function getLiveServers() {
  * Now async to support port connectivity checks
  */
 async function findExtensionForProjectAsync(projectPath) {
-    const servers = await getLiveServersAsync();
+    let servers = await getLiveServersAsync();
     debug(`Looking for Extension for project: ${projectPath}`);
     debug(`Found ${servers.length} live Extension server(s) with valid ports`);
     if (servers.length === 0) {
@@ -178,15 +178,40 @@ async function findExtensionForProjectAsync(projectPath) {
     // Get MCP server's CURSOR_TRACE_ID (if running in Cursor)
     const myTraceId = process.env['CURSOR_TRACE_ID'] || '';
     debug(`My CURSOR_TRACE_ID: ${myTraceId || '(not set)'}`);
-    // Strategy 0: CURSOR_TRACE_ID match (HIGHEST PRIORITY - same Cursor window)
+    // Strategy 0: CURSOR_TRACE_ID match - but only if UNIQUE match
+    // (Multiple windows can share the same trace ID, so we need workspace matching as tiebreaker)
     if (myTraceId) {
-        const traceMatch = servers.find(s => s.cursorTraceId === myTraceId);
-        if (traceMatch) {
-            debug(`✓ CURSOR_TRACE_ID match: port=${traceMatch.port}, traceId=${myTraceId}`);
-            return traceMatch;
+        const traceMatches = servers.filter(s => s.cursorTraceId === myTraceId);
+        if (traceMatches.length === 1) {
+            // Unique trace ID match - perfect!
+            debug(`✓ CURSOR_TRACE_ID unique match: port=${traceMatches[0].port}`);
+            return traceMatches[0];
+        }
+        else if (traceMatches.length > 1) {
+            // Multiple servers with same trace ID - use workspace matching among them
+            debug(`Multiple servers (${traceMatches.length}) with same CURSOR_TRACE_ID, using workspace match`);
+            // Try exact workspace match among trace-matched servers
+            const exactMatch = traceMatches.find(s => s.workspaces?.includes(projectPath));
+            if (exactMatch) {
+                debug(`✓ CURSOR_TRACE_ID + workspace match: port=${exactMatch.port}`);
+                return exactMatch;
+            }
+            // Try prefix match among trace-matched servers
+            for (const server of traceMatches) {
+                for (const ws of server.workspaces || []) {
+                    if (projectPath.startsWith(ws + path.sep) || ws.startsWith(projectPath + path.sep)) {
+                        debug(`✓ CURSOR_TRACE_ID + prefix match: port=${server.port}`);
+                        return server;
+                    }
+                }
+            }
+            // Fall back to most recent among trace-matched servers
+            const sorted = traceMatches.sort((a, b) => b.timestamp - a.timestamp);
+            debug(`✓ CURSOR_TRACE_ID + most recent: port=${sorted[0].port}`);
+            return sorted[0];
         }
     }
-    // Strategy 1: Exact workspace match + traceId filter if available
+    // Strategy 1: Exact workspace match (when no trace ID or no trace match)
     const workspaceMatches = servers.filter(s => s.workspaces?.includes(projectPath));
     if (workspaceMatches.length === 1) {
         debug(`✓ Exact workspace match (single): port=${workspaceMatches[0].port}`);
@@ -235,14 +260,31 @@ function findExtensionForProject(projectPath) {
     const servers = getLiveServers();
     if (servers.length === 0)
         return null;
-    // Strategy 0: CURSOR_TRACE_ID match (highest priority)
+    // Strategy 0: CURSOR_TRACE_ID match - but only if UNIQUE
     const myTraceId = process.env['CURSOR_TRACE_ID'] || '';
     if (myTraceId) {
-        const traceMatch = servers.find(s => s.cursorTraceId === myTraceId);
-        if (traceMatch)
-            return traceMatch;
+        const traceMatches = servers.filter(s => s.cursorTraceId === myTraceId);
+        if (traceMatches.length === 1) {
+            return traceMatches[0];
+        }
+        else if (traceMatches.length > 1) {
+            // Multiple servers with same trace ID - try workspace match among them
+            const exactMatch = traceMatches.find(s => s.workspaces?.includes(projectPath));
+            if (exactMatch)
+                return exactMatch;
+            // Prefix match among trace-matched
+            for (const server of traceMatches) {
+                for (const ws of server.workspaces || []) {
+                    if (projectPath.startsWith(ws + path.sep) || ws.startsWith(projectPath + path.sep)) {
+                        return server;
+                    }
+                }
+            }
+            // Most recent among trace-matched
+            return traceMatches.sort((a, b) => b.timestamp - a.timestamp)[0];
+        }
     }
-    // Strategy 1: Exact workspace match
+    // Strategy 1: Exact workspace match (when no trace ID or no trace match)
     const workspaceMatches = servers.filter(s => s.workspaces?.includes(projectPath));
     if (workspaceMatches.length >= 1) {
         return workspaceMatches.sort((a, b) => b.timestamp - a.timestamp)[0];
@@ -414,43 +456,232 @@ function handleMessage(message) {
             break;
     }
 }
+// Track tried servers to avoid retry loops
+let triedServerPorts = new Set();
 /**
  * Request feedback from user via Extension
- * Falls back to browser if extension is not available
+ * Uses single-connection with fast retry strategy:
+ * - Sorts servers by relevance (workspace match, most recent)
+ * - Tries one server at a time
+ * - If rejected (PROJECT_NOT_IN_WINDOW or no webview), immediately tries next
+ * - Falls back to browser if all fail
  */
 async function requestFeedback(projectDirectory, summary, timeout, agentName) {
-    // Try to connect to extension first
-    try {
-        await ensureConnectedForProject(projectDirectory);
-    }
-    catch (e) {
-        // Extension not available, fall back to browser
-        debug(`Extension not available, falling back to browser: ${e.message}`);
+    // Reset tried servers
+    triedServerPorts.clear();
+    // Get all servers sorted by relevance
+    const servers = await getSortedServers(projectDirectory);
+    if (servers.length === 0) {
+        debug('No Extension servers found, falling back to browser');
         return requestFeedbackViaBrowser(projectDirectory, summary, timeout);
     }
+    debug(`Found ${servers.length} server(s), trying in order of relevance...`);
+    // Try servers one by one until success
+    return tryServersSequentially(servers, projectDirectory, summary, timeout, agentName);
+}
+/**
+ * Get servers sorted by relevance for the project
+ */
+async function getSortedServers(projectPath) {
+    const servers = await getLiveServersAsync();
+    if (servers.length === 0) {
+        return [];
+    }
+    // Calculate workspace frequency for uniqueness bonus
+    const workspaceFrequency = new Map();
+    servers.forEach(s => {
+        s.workspaces?.forEach(ws => {
+            workspaceFrequency.set(ws, (workspaceFrequency.get(ws) || 0) + 1);
+        });
+    });
+    // Score each server
+    const scored = servers.map(server => {
+        let score = 0;
+        let reasons = [];
+        // 1. FOCUSED WINDOW (+500) - Highest priority!
+        if (server.focused) {
+            score += 500;
+            reasons.push('focused');
+        }
+        // 2. Workspace UNIQUENESS bonus (+1000)
+        // If this project is ONLY in this server's workspaces, huge bonus
+        if (server.workspaces?.includes(projectPath)) {
+            const freq = workspaceFrequency.get(projectPath) || 1;
+            if (freq === 1) {
+                score += 1000;
+                reasons.push('unique-ws');
+            }
+            else {
+                score += 100;
+                reasons.push('shared-ws');
+            }
+        }
+        // 3. Prefix match (+50)
+        for (const ws of server.workspaces || []) {
+            if (projectPath.startsWith(ws + path.sep)) {
+                score += 50;
+                reasons.push('prefix');
+                break;
+            }
+        }
+        // 4. CURSOR_TRACE_ID match (+10) - Low priority since often shared
+        const myTraceId = process.env['CURSOR_TRACE_ID'] || '';
+        if (myTraceId && server.cursorTraceId === myTraceId) {
+            score += 10;
+            reasons.push('trace');
+        }
+        // 5. More recent timestamp (tiny bonus)
+        score += server.timestamp / (10 ** 14);
+        return { server, score, reasons };
+    });
+    // Sort by score descending
+    scored.sort((a, b) => b.score - a.score);
+    debug(`Server scores:`);
+    scored.forEach(s => {
+        debug(`  port=${s.server.port} score=${s.score.toFixed(0)} [${s.reasons.join(', ')}]`);
+    });
+    return scored.map(s => s.server);
+}
+/**
+ * Try servers one by one until success or all fail
+ */
+async function tryServersSequentially(servers, projectDirectory, summary, timeout, agentName) {
+    for (const server of servers) {
+        // Skip already tried servers
+        if (triedServerPorts.has(server.port)) {
+            continue;
+        }
+        triedServerPorts.add(server.port);
+        debug(`Trying server port ${server.port}...`);
+        try {
+            const result = await tryServerOnce(server, projectDirectory, summary, timeout, agentName);
+            return result;
+        }
+        catch (err) {
+            const errorMessage = err.message || '';
+            // These errors mean we should try next server
+            if (errorMessage === 'PROJECT_NOT_IN_WINDOW' ||
+                errorMessage.includes('No feedback panel') ||
+                errorMessage.includes('Connection failed')) {
+                debug(`Server ${server.port} rejected: ${errorMessage}, trying next...`);
+                continue;
+            }
+            // Other errors (timeout, user cancelled) should propagate
+            throw err;
+        }
+    }
+    // All servers failed, fall back to browser
+    debug('All servers failed, falling back to browser');
+    return requestFeedbackViaBrowser(projectDirectory, summary, timeout);
+}
+/**
+ * Try a single server, returns result or throws error
+ */
+async function tryServerOnce(server, projectDirectory, summary, timeout, agentName) {
+    const url = `ws://127.0.0.1:${server.port}/ws`;
     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`));
+        let conn = null;
+        let resolved = false;
+        const cleanup = () => {
+            if (conn && conn.readyState === WebSocket.OPEN) {
+                conn.close();
+            }
+        };
+        // Timeout for this attempt (use a shorter timeout for connection phase)
+        const connectionTimeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                cleanup();
+                reject(new Error('Connection failed'));
+            }
+        }, CONNECTION_TIMEOUT_MS);
+        // Overall timeout
+        const overallTimeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                cleanup();
+                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,
-            agent_name: agentName // For multi-agent display
-        }));
-        debug(`Feedback request sent: session=${sessionId}, agent=${agentName || 'default'}`);
+        try {
+            conn = new WebSocket(url);
+            conn.on('open', () => {
+                clearTimeout(connectionTimeout);
+                debug(`Connected to server port ${server.port}`);
+                // Register
+                conn.send(JSON.stringify({
+                    type: 'register',
+                    clientType: 'mcp-server',
+                    pid: process.pid,
+                    parentPid: process.ppid
+                }));
+                // Send feedback request
+                conn.send(JSON.stringify({
+                    type: 'feedback_request',
+                    session_id: sessionId,
+                    project_directory: projectDirectory,
+                    summary,
+                    timeout,
+                    agent_name: agentName
+                }));
+                debug(`Feedback request sent: session=${sessionId}`);
+            });
+            conn.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    debug(`Received from port ${server.port}: ${message.type}`);
+                    switch (message.type) {
+                        case 'feedback_result':
+                            if (message.session_id === sessionId && !resolved) {
+                                resolved = true;
+                                clearTimeout(overallTimeout);
+                                cleanup();
+                                resolve({
+                                    feedback: message.feedback,
+                                    images: message.images || []
+                                });
+                            }
+                            break;
+                        case 'feedback_error':
+                            if (message.session_id === sessionId && !resolved) {
+                                resolved = true;
+                                clearTimeout(overallTimeout);
+                                cleanup();
+                                reject(new Error(message.error));
+                            }
+                            break;
+                    }
+                }
+                catch (e) {
+                    debug(`Parse error: ${e}`);
+                }
+            });
+            conn.on('error', (err) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(connectionTimeout);
+                    clearTimeout(overallTimeout);
+                    reject(new Error(`Connection failed: ${err.message}`));
+                }
+            });
+            conn.on('close', () => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(connectionTimeout);
+                    clearTimeout(overallTimeout);
+                    reject(new Error('Connection closed'));
+                }
+            });
+        }
+        catch (e) {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(connectionTimeout);
+                clearTimeout(overallTimeout);
+                reject(new Error(`Connection failed: ${e}`));
+            }
+        }
     });
 }
 // ============================================================================

package/package.json

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