mcp-feedback-enhanced 0.1.64 → 0.1.67

package/dist/index.js

@@ -16,7 +16,9 @@ import * as os from 'os';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as net from 'net';
+import * as http from 'http';
 import { createRequire } from 'module';
+import { exec } from 'child_process';
 // Read version from package.json (ES module compatible)
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
@@ -167,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) {
@@ -176,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}`);
@@ -233,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];
@@ -412,34 +456,529 @@ function handleMessage(message) {
             break;
     }
 }
+// Track tried servers to avoid retry loops
+let triedServerPorts = new Set();
 /**
  * Request feedback from user via Extension
+ * 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) {
-    await ensureConnectedForProject(projectDirectory);
+    // 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
+        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}`));
+            }
+        }
+    });
+}
+// ============================================================================
+// Browser Fallback
+// ============================================================================
+/**
+ * Open system default browser
+ */
+function openBrowser(url) {
+    const platform = os.platform();
+    let cmd;
+    if (platform === 'darwin') {
+        cmd = `open "${url}"`;
+    }
+    else if (platform === 'win32') {
+        cmd = `start "" "${url}"`;
+    }
+    else {
+        cmd = `xdg-open "${url}"`;
+    }
+    exec(cmd, (error) => {
+        if (error) {
+            debug(`Failed to open browser: ${error.message}`);
+        }
+    });
+}
+/**
+ * Generate HTML page for browser feedback
+ */
+function generateBrowserHtml(summary, port) {
+    const escapedSummary = summary
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/\n/g, '<br>');
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MCP Feedback</title>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #1e1e1e;
+            color: #d4d4d4;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+        }
+        .container {
+            max-width: 800px;
+            width: 100%;
+            background: #252526;
+            border-radius: 12px;
+            box-shadow: 0 8px 32px rgba(0,0,0,0.3);
+            overflow: hidden;
+        }
+        .header {
+            background: #007acc;
+            padding: 16px 24px;
+            display: flex;
+            align-items: center;
+            gap: 12px;
+        }
+        .header h1 {
+            font-size: 18px;
+            font-weight: 600;
+            color: white;
+        }
+        .header .icon { font-size: 24px; }
+        .content { padding: 24px; }
+        .ai-message {
+            background: #2d2d2d;
+            border: 1px solid #3c3c3c;
+            border-radius: 8px;
+            padding: 16px;
+            margin-bottom: 20px;
+            max-height: 400px;
+            overflow-y: auto;
+            line-height: 1.6;
+        }
+        .label {
+            font-size: 12px;
+            color: #888;
+            margin-bottom: 8px;
+            display: flex;
+            align-items: center;
+            gap: 6px;
+        }
+        .quick-btns {
+            display: flex;
+            gap: 8px;
+            margin-bottom: 16px;
+            flex-wrap: wrap;
+        }
+        .quick-btn {
+            padding: 8px 16px;
+            background: transparent;
+            border: 1px solid #3c3c3c;
+            color: #d4d4d4;
+            border-radius: 20px;
+            cursor: pointer;
+            font-size: 13px;
+            transition: all 0.2s;
+        }
+        .quick-btn:hover {
+            background: #3c3c3c;
+            border-color: #569cd6;
+        }
+        textarea {
+            width: 100%;
+            min-height: 120px;
+            padding: 12px;
+            background: #2d2d2d;
+            border: 1px solid #3c3c3c;
+            border-radius: 8px;
+            color: #d4d4d4;
+            font-size: 14px;
+            font-family: inherit;
+            resize: vertical;
+            margin-bottom: 16px;
+        }
+        textarea:focus {
+            outline: none;
+            border-color: #007acc;
+        }
+        .submit-btn {
+            width: 100%;
+            padding: 14px;
+            background: #007acc;
+            border: none;
+            border-radius: 8px;
+            color: white;
+            font-size: 15px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: background 0.2s;
+        }
+        .submit-btn:hover { background: #0098ff; }
+        .submit-btn:disabled {
+            background: #3c3c3c;
+            cursor: not-allowed;
+        }
+        .success {
+            text-align: center;
+            padding: 40px;
+        }
+        .success .icon { font-size: 48px; margin-bottom: 16px; }
+        .success h2 { color: #4ec9b0; margin-bottom: 8px; }
+        .success p { color: #888; }
+    </style>
+</head>
+<body>
+    <div class="container" id="feedbackForm">
+        <div class="header">
+            <span class="icon">💬</span>
+            <h1>MCP Feedback</h1>
+        </div>
+        <div class="content">
+            <div class="label">🤖 AI Summary</div>
+            <div class="ai-message">${escapedSummary}</div>
+            
+            <div class="label">💬 Your Feedback</div>
+            <div class="quick-btns">
+                <button class="quick-btn" onclick="setFeedback('Continue')">▶️ Continue</button>
+                <button class="quick-btn" onclick="setFeedback('Looks good')">👍 Good</button>
+                <button class="quick-btn" onclick="setFeedback('Please fix it')">🔧 Fix</button>
+                <button class="quick-btn" onclick="setFeedback('Stop')">⏹️ Stop</button>
+            </div>
+            <textarea id="feedback" placeholder="Type your feedback here..."></textarea>
+            <button class="submit-btn" id="submitBtn" onclick="submitFeedback()">Send Feedback</button>
+        </div>
+    </div>
+    
+    <div class="container" id="successMsg" style="display: none;">
+        <div class="success">
+            <div class="icon">✅</div>
+            <h2>Feedback Sent!</h2>
+            <p>You can close this window now.</p>
+        </div>
+    </div>
+    
+    <script>
+        function setFeedback(text) {
+            document.getElementById('feedback').value = text;
+        }
+        
+        async function submitFeedback() {
+            const feedback = document.getElementById('feedback').value.trim();
+            if (!feedback) {
+                alert('Please enter your feedback');
+                return;
+            }
+            
+            const btn = document.getElementById('submitBtn');
+            btn.disabled = true;
+            btn.textContent = 'Sending...';
+            
+            try {
+                const response = await fetch('/submit', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ feedback })
+                });
+                
+                if (response.ok) {
+                    document.getElementById('feedbackForm').style.display = 'none';
+                    document.getElementById('successMsg').style.display = 'block';
+                } else {
+                    throw new Error('Submit failed');
+                }
+            } catch (e) {
+                btn.disabled = false;
+                btn.textContent = 'Send Feedback';
+                alert('Failed to send feedback. Please try again.');
+            }
+        }
+    </script>
+</body>
+</html>`;
+}
+/**
+ * Request feedback via browser (fallback when extension not available)
+ */
+async function requestFeedbackViaBrowser(projectDirectory, summary, timeout) {
+    return new Promise((resolve, reject) => {
+        // Find available port
+        const server = http.createServer();
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                reject(new Error('Failed to start HTTP server'));
+                return;
+            }
+            const port = address.port;
+            debug(`Browser feedback server started on port ${port}`);
+            let feedbackReceived = false;
+            // Handle requests
+            server.on('request', (req, res) => {
+                if (req.method === 'GET' && req.url === '/') {
+                    // Serve HTML page
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(generateBrowserHtml(summary, port));
+                }
+                else if (req.method === 'POST' && req.url === '/submit') {
+                    // Handle feedback submission
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', () => {
+                        try {
+                            const data = JSON.parse(body);
+                            feedbackReceived = true;
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ success: true }));
+                            // Close server and resolve
+                            setTimeout(() => {
+                                server.close();
+                                resolve({
+                                    feedback: data.feedback || '',
+                                    images: []
+                                });
+                            }, 1000);
+                        }
+                        catch (e) {
+                            res.writeHead(400);
+                            res.end('Invalid request');
+                        }
+                    });
+                }
+                else {
+                    res.writeHead(404);
+                    res.end('Not found');
+                }
+            });
+            // Open browser
+            const url = `http://127.0.0.1:${port}`;
+            debug(`Opening browser: ${url}`);
+            openBrowser(url);
+            // Timeout
+            const timeoutHandle = setTimeout(() => {
+                if (!feedbackReceived) {
+                    server.close();
+                    reject(new Error(`Browser feedback timeout after ${timeout} seconds`));
+                }
+            }, timeout * 1000);
+            server.on('close', () => {
+                clearTimeout(timeoutHandle);
+            });
+        });
+        server.on('error', (err) => {
+            reject(new Error(`Failed to start browser feedback server: ${err.message}`));
         });
-        // 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'}`);
     });
 }
 // ============================================================================

package/package.json

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