polydev-ai 1.9.14 → 1.9.16

package/mcp/stdio-wrapper.js

@@ -300,6 +300,10 @@ class StdioMCPWrapper {
     // Pending session file for surviving restarts
     this.PENDING_SESSION_FILE = path.join(os.homedir(), '.polydev-pending-session');
     
+    // MCP client info (set during initialize handshake)
+    // Used to detect which IDE is running us and exclude its CLI to avoid recursive calls
+    this.clientInfo = null;
+    
     // Initialize CLI Manager for local CLI functionality
     // Disable StatusReporter - it's redundant (updateCliStatusInDatabase handles DB updates via /api/cli-status-update)
     // and causes 401 errors because /api/mcp uses different auth than /api/cli-status-update
@@ -363,6 +367,12 @@ class StdioMCPWrapper {
     try {
       switch (method) {
         case 'initialize':
+          // Capture client info to detect which IDE is running us
+          // This lets us exclude its CLI to avoid recursive calls (e.g., Claude Code → claude_code CLI)
+          this.clientInfo = params?.clientInfo || null;
+          if (this.clientInfo) {
+            console.error(`[Stdio Wrapper] IDE detected: ${this.clientInfo.name} v${this.clientInfo.version || 'unknown'}`);
+          }
           return {
             jsonrpc: '2.0',
             id,
@@ -990,11 +1000,10 @@ Token will be saved automatically after login.`
           perspectivesSection += ` (${perspectiveCount} active)`;
           
           // Show providers in order with their selected models
-          for (let i = 0; i < modelPrefs.allProviders.length; i++) {
-            const p = modelPrefs.allProviders[i];
+          for (const p of modelPrefs.allProviders) {
             const providerName = p.provider.charAt(0).toUpperCase() + p.provider.slice(1);
             const source = p.cliId ? 'CLI' : (p.tier ? `Credits/${p.tier}` : 'API');
-            perspectivesSection += `\n  ${i + 1}. ${providerName.padEnd(12)} ${p.model} [${source}]`;
+            perspectivesSection += `\n  ${providerName.padEnd(12)} ${p.model} [${source}]`;
           }
         } else {
           perspectivesSection += '\n  (none configured - using defaults)';
@@ -1412,271 +1421,46 @@ Error: ${error.message}`
 </html>`;
   }
 
-  async forwardToRemoteServer(request) {
-    console.error(`[Stdio Wrapper] Forwarding request to remote server`);
-
-    try {
-      // Use AbortController for timeout if available, otherwise rely on fetch timeout
-      const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
-      const timeoutId = controller ? setTimeout(() => controller.abort(), 240000) : null; // 240s timeout
-
-      const response = await fetch('https://www.polydev.ai/api/mcp', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.userToken}`,
-          'User-Agent': 'polydev-stdio-wrapper/1.0.0'
-        },
-        body: JSON.stringify(request),
-        ...(controller ? { signal: controller.signal } : {})
-      });
-
-      if (timeoutId) clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error(`[Stdio Wrapper] Remote server error: ${response.status} - ${errorText}`);
-
-        // Handle 401 specifically - token expired/invalid, trigger re-auth
-        if (response.status === 401) {
-          console.error('[Polydev] Remote API returned 401, auto-triggering re-authentication...');
-          return await this.triggerReAuth(request.id, 'Authentication expired. Re-authenticating...');
-        }
-
-        return {
-          jsonrpc: '2.0',
-          id: request.id,
-          error: {
-            code: -32603,
-            message: `Remote server error: ${response.status} - ${errorText}`
-          }
-        };
-      }
-
-      const result = await response.json();
-      console.error(`[Stdio Wrapper] Got response from remote server`);
-      return result;
-    } catch (error) {
-      console.error(`[Stdio Wrapper] Network error:`, error.message);
-      return {
-        jsonrpc: '2.0',
-        id: request.id,
-        error: {
-          code: -32603,
-          message: `Network error: ${error.message}`
-        }
-      };
-    }
-  }
-
   /**
-   * Check if a tool is a CLI tool that should be handled locally
+   * Get the CLI ID to exclude based on the current IDE client.
+   * Prevents recursive calls (e.g., Claude Code calling claude_code CLI which spawns another Claude Code).
+   * Returns null if no CLI should be excluded.
    */
-  isCliTool(toolName) {
-    const cliTools = [
-      'force_cli_detection',
-      'get_cli_status', 
-      'send_cli_prompt',
-      'polydev.force_cli_detection',
-      'polydev.get_cli_status', 
-      'polydev.send_cli_prompt'
-    ];
-    return cliTools.includes(toolName);
-  }
-
-  /**
-   * Handle get_perspectives with local CLIs + remote perspectives
-   */
-  async handleGetPerspectivesWithCLIs(params, id) {
-    console.error(`[Stdio Wrapper] Handling get_perspectives with local CLIs + remote`);
+  getExcludedCliForCurrentIDE() {
+    if (!this.clientInfo?.name) return null;
     
-    try {
-      // Use existing localSendCliPrompt logic which already:
-      // 1. Checks all local CLIs
-      // 2. Calls remote perspectives
-      // 3. Combines results
-      const result = await this.localSendCliPrompt(params.arguments);
-      
-      // Check if result indicates auth failure (from forwardToRemoteServer 401 handling)
-      const resultText = result.content || this.formatCliResponse(result);
-      if (result.result?.content?.[0]?.text?.includes('RE-AUTHENTICATION REQUIRED')) {
-        // Auth failure already handled with re-auth response - pass through
-        return result;
-      }
-      
-      return {
-        jsonrpc: '2.0',
-        id,
-        result: {
-          content: [
-            {
-              type: 'text',
-              text: resultText
-            }
-          ]
-        }
-      };
-
-    } catch (error) {
-      console.error(`[Stdio Wrapper] get_perspectives error:`, error);
-      
-      // Check if error is auth-related
-      const errMsg = (error.message || '').toLowerCase();
-      if (errMsg.includes('401') || errMsg.includes('unauthorized') || errMsg.includes('auth') || errMsg.includes('token')) {
-        console.error('[Polydev] Perspectives auth error, auto-triggering re-authentication...');
-        return await this.triggerReAuth(id, 'Authentication expired. Re-authenticating...');
-      }
-      
-      return {
-        jsonrpc: '2.0',
-        id,
-        error: {
-          code: -32603,
-          message: error.message
-        }
-      };
-    }
-  }
-
-  /**
-   * Handle CLI tools locally without remote server calls
-   */
-  async handleLocalCliTool(request) {
-    const { method, params, id } = request;
-    const { name: toolName, arguments: args } = params;
-
-    console.error(`[Stdio Wrapper] Handling local CLI tool: ${toolName}`);
-
-    try {
-      let result;
-
-      switch (toolName) {
-        case 'force_cli_detection':
-        case 'polydev.force_cli_detection':
-          result = await this.localForceCliDetection(args);
-          break;
-        
-        case 'get_cli_status':
-        case 'polydev.get_cli_status':
-          result = await this.localGetCliStatus(args);
-          break;
-        
-        case 'send_cli_prompt':
-        case 'polydev.send_cli_prompt':
-          result = await this.localSendCliPrompt(args);
-          break;
-        
-        default:
-          throw new Error(`Unknown CLI tool: ${toolName}`);
-      }
-
-      return {
-        jsonrpc: '2.0',
-        id,
-        result: {
-          content: [
-            {
-              type: 'text',
-              text: this.formatCliResponse(result)
-            }
-          ]
-        }
-      };
-
-    } catch (error) {
-      console.error(`[Stdio Wrapper] CLI tool error:`, error);
-      return {
-        jsonrpc: '2.0',
-        id,
-        error: {
-          code: -32603,
-          message: error.message
-        }
-      };
-    }
-  }
-
-  /**
-   * Local CLI detection implementation with database updates
-   */
-  async localForceCliDetection(args) {
-    console.error(`[Stdio Wrapper] Local CLI detection with model detection started`);
+    const clientName = this.clientInfo.name.toLowerCase();
     
-    try {
-      const providerId = args.provider_id; // Optional - detect specific provider
-      
-      // Force detection using CLI Manager (no remote API calls)
-      const results = await this.cliManager.forceCliDetection(providerId);
-      console.error(`[Stdio Wrapper] CLI detection results:`, JSON.stringify(results, null, 2));
-      
-      // Save status locally to file-based cache
-      await this.saveLocalCliStatus(results);
-
-      // Update database with CLI status
-      await this.updateCliStatusInDatabase(results);
-      
-      return {
-        success: true,
-        results,
-        message: `Local CLI detection completed for ${providerId || 'all providers'}`,
-        timestamp: new Date().toISOString(),
-        local_only: true
-      };
-
-    } catch (error) {
-      console.error('[Stdio Wrapper] Local CLI detection error:', error);
-      return {
-        success: false,
-        error: error.message,
-        timestamp: new Date().toISOString(),
-        local_only: true
-      };
-    }
-  }
-
-  /**
-   * Local CLI status retrieval
-   */
-  async localGetCliStatus(args) {
-    console.error(`[Stdio Wrapper] Local CLI status retrieval`);
+    // Map known IDE client names to their corresponding CLI IDs
+    // These are the clientInfo.name values sent during MCP initialize handshake
+    const ideToCliMap = {
+      // Claude Code variants
+      'claude-code': 'claude_code',
+      'claude_code': 'claude_code',
+      'claude code': 'claude_code',
+      'claudecode': 'claude_code',
+      // Cursor (uses Claude under the hood but is a separate IDE)
+      // Don't exclude any CLI for Cursor since it's not calling itself
+      // Gemini CLI / Google IDX
+      'gemini-cli': 'gemini_cli',
+      'gemini_cli': 'gemini_cli',
+      // Codex CLI / OpenAI
+      'codex-cli': 'codex_cli',
+      'codex_cli': 'codex_cli',
+      'codex': 'codex_cli',
+    };
     
-    try {
-      const providerId = args.provider_id;
-      let results = {};
-
-      if (providerId) {
-        // Get specific provider status
-        const status = await this.cliManager.getCliStatus(providerId);
-        results = status;
-      } else {
-        // Get all providers status
-        const providers = this.cliManager.getProviders();
-        for (const provider of providers) {
-          const status = await this.cliManager.getCliStatus(provider.id);
-          results[provider.id] = status;
-        }
-      }
-
-      // Update database with current status
-      await this.updateCliStatusInDatabase(results);
-
-      return {
-        success: true,
-        results,
-        message: 'Local CLI status retrieved successfully',
-        timestamp: new Date().toISOString(),
-        local_only: true
-      };
-
-    } catch (error) {
-      console.error('[Stdio Wrapper] Local CLI status error:', error);
-      return {
-        success: false,
-        error: error.message,
-        timestamp: new Date().toISOString(),
-        local_only: true
-      };
+    // Direct match first
+    if (ideToCliMap[clientName]) {
+      return ideToCliMap[clientName];
     }
+    
+    // Fuzzy match: check if client name contains known patterns
+    if (clientName.includes('claude')) return 'claude_code';
+    if (clientName.includes('gemini')) return 'gemini_cli';
+    if (clientName.includes('codex')) return 'codex_cli';
+    
+    return null;
   }
 
   /**
@@ -1765,14 +1549,26 @@ Error: ${error.message}`
         // CLI priority order: Claude Code first, then Gemini, then Codex
         const cliPriorityOrder = ['claude_code', 'gemini_cli', 'codex_cli'];
         
+        // Detect if we should exclude the current IDE's CLI to avoid recursive calls
+        const excludedCli = this.getExcludedCliForCurrentIDE();
+        if (excludedCli) {
+          console.error(`[Stdio Wrapper] Excluding CLI '${excludedCli}' (current IDE: ${this.clientInfo?.name}) to avoid recursive calls`);
+        }
+        
         // Build merged provider list: CLIs first, then API-only
         const finalProviders = [];
         const usedProviderNames = new Set();
         
-        // STEP 1: Add ALL available CLIs first (in priority order) - they're FREE
+        // STEP 1: Add ALL available CLIs (in priority order) - they're FREE
+        // Don't limit to maxPerspectives here — we run all CLIs in parallel
+        // and take the first maxPerspectives successes (fast-collect pattern)
+        // Skip the CLI that matches the current IDE to avoid recursive calls
         for (const cliId of cliPriorityOrder) {
-          if (finalProviders.length >= maxPerspectives) break;
           if (!availableClis.includes(cliId)) continue;
+          if (cliId === excludedCli) {
+            console.error(`[Stdio Wrapper] [CLI-FIRST] Skipping ${cliId} (same as current IDE — would cause recursive call)`);
+            continue;
+          }
           
           const providerName = cliToProviderMap[cliId];
           usedProviderNames.add(providerName);
@@ -1788,7 +1584,7 @@ Error: ${error.message}`
           
           finalProviders.push({
             provider: providerName,
-            model: configuredProvider?.model || null, // null = use CLI's default model
+            model: configuredProvider?.model || null, // null = use CLI default model
             cliId: cliId,
             source: 'cli',
             tier: null // CLIs don't use credits tiers
@@ -1817,7 +1613,7 @@ Error: ${error.message}`
           console.error(`[Stdio Wrapper] [CLI-FIRST] Added API/credits: ${normalizedProvider} (${p.model})${p.tier ? ` [${p.tier}]` : ''}`);
         }
         
-        console.error(`[Stdio Wrapper] Final provider list (${finalProviders.length}/${maxPerspectives}): ${finalProviders.map(p => `${p.provider}[${p.source}]`).join(', ')}`);
+        console.error(`[Stdio Wrapper] Final provider list (${finalProviders.length}, need ${maxPerspectives}): ${finalProviders.map(p => `${p.provider}[${p.source}]`).join(', ')}`);
         
         // Separate into CLI entries (local execution) vs API entries (remote execution)
         const cliProviderEntries = finalProviders.filter(p => p.source === 'cli');
@@ -1825,7 +1621,8 @@ Error: ${error.message}`
         
         console.error(`[Stdio Wrapper] Provider breakdown: CLI=${cliProviderEntries.map(p => p.cliId).join(', ') || 'none'}, API-only=${apiOnlyProviders.map(p => p.provider).join(', ') || 'none'}`);
         
-        // Run all CLI prompts concurrently
+        // Run ALL CLI prompts concurrently with fast-collect pattern
+        // Resolves once we have maxPerspectives successes (don't wait for slow CLIs)
         if (cliProviderEntries.length > 0) {
           const cliPromises = cliProviderEntries.map(async (providerEntry) => {
             try {
@@ -1866,7 +1663,10 @@ Error: ${error.message}`
               };
             }
           });
-          localResults = await Promise.all(cliPromises);
+          
+          // Fast-collect: resolve early once we have maxPerspectives successes OR all complete
+          localResults = await this.collectFirstNSuccesses(cliPromises, maxPerspectives);
+          console.error(`[Stdio Wrapper] Fast-collect: got ${localResults.filter(r => r.success).length} successful, ${localResults.filter(r => !r.success).length} failed out of ${cliPromises.length} CLIs`);
         }
         
         // Store API-only providers info for remote API call
@@ -1941,6 +1741,42 @@ Error: ${error.message}`
     }
   }
 
+  /**
+   * Collect results from parallel promises, resolving early once we have N successes
+   * This avoids waiting for slow/timed-out CLIs when we already have enough results
+   * @param {Promise[]} promises - Array of promises to collect from
+   * @param {number} needed - Number of successful results needed
+   * @returns {Promise<Array>} Array of results (may include failures if not enough successes)
+   */
+  collectFirstNSuccesses(promises, needed) {
+    return new Promise((resolve) => {
+      const results = [];
+      let successCount = 0;
+      let completedCount = 0;
+      let resolved = false;
+      
+      if (promises.length === 0) {
+        resolve([]);
+        return;
+      }
+      
+      for (const promise of promises) {
+        promise.then(result => {
+          if (resolved) return;
+          results.push(result);
+          if (result.success) successCount++;
+          completedCount++;
+          
+          // Resolve early if we have enough successes OR all promises done
+          if (successCount >= needed || completedCount >= promises.length) {
+            resolved = true;
+            resolve([...results]); // Copy to prevent mutation from late arrivals
+          }
+        });
+      }
+    });
+  }
+
   /**
    * Get all available and authenticated CLI providers
    * Uses user's provider order from dashboard (display_order) instead of hardcoded order
@@ -2278,54 +2114,6 @@ Error: ${error.message}`
   combineAllCliAndPerspectives(localResults, perspectivesResult, args) {
     // Ensure perspectivesResult is always an object to prevent undefined errors
     const safePersp = perspectivesResult || { success: false, error: 'No response from perspectives server' };
-
-    const combinedResult = {
-      success: true,
-      timestamp: new Date().toISOString(),
-      mode: args.mode,
-      local_cli_count: localResults.length,
-      sections: {
-        local: localResults,
-        remote: safePersp
-      }
-    };
-
-    // Check if any local CLIs succeeded
-    const successfulClis = localResults.filter(result => result.success);
-    const hasSomeLocalSuccess = successfulClis.length > 0;
-
-    // Determine overall success and content
-    if (hasSomeLocalSuccess && safePersp.success) {
-      combinedResult.content = this.formatMultipleCliResponse(localResults, safePersp, false);
-      combinedResult.tokens_used = successfulClis.reduce((total, cli) => total + (cli.tokens_used || 0), 0);
-      combinedResult.latency_ms = Math.max(...successfulClis.map(cli => cli.latency_ms || 0));
-    } else if (!hasSomeLocalSuccess && safePersp.success) {
-      // Complete fallback case - no local CLIs worked
-      combinedResult.content = this.formatMultipleCliResponse(localResults, safePersp, true);
-      combinedResult.fallback_used = true;
-      combinedResult.tokens_used = 0; // No local tokens used
-    } else if (hasSomeLocalSuccess && !safePersp.success) {
-      // Local CLIs succeeded, remote failed
-      combinedResult.content = this.formatMultipleCliResponse(localResults, safePersp, false);
-      combinedResult.tokens_used = successfulClis.reduce((total, cli) => total + (cli.tokens_used || 0), 0);
-      combinedResult.latency_ms = Math.max(...successfulClis.map(cli => cli.latency_ms || 0));
-    } else {
-      // Both failed
-      combinedResult.success = false;
-      const cliErrors = localResults.map(cli => `${cli.provider_id}: ${cli.error || 'Unknown error'}`).join('; ');
-      const perspectivesError = safePersp.error || 'Unknown remote error';
-      combinedResult.error = `All local CLIs failed: ${cliErrors}; Perspectives also failed: ${perspectivesError}`;
-    }
-
-    return combinedResult;
-  }
-
-  /**
-   * Format multiple CLI responses with remote perspectives
-   */
-  formatMultipleCliResponse(localResults, perspectivesResult, isFallback) {
-    // Safety check - ensure perspectivesResult is always an object
-    const safePersp = perspectivesResult || { success: false, error: 'No perspectives data' };
     let formatted = '';
 
     // Show all local CLI responses
@@ -2668,7 +2456,7 @@ Error: ${error.message}`
   /**
    * Fetch user's model preferences from API keys
    * Returns a map of CLI provider -> default_model
-   * Also fetches and caches perspectivesPerMessage setting and allProviders list
+   * Also fetches and caches perspectives_per_message setting and allProviders list
    */
   async fetchUserModelPreferences() {
     // Check cache first

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.9.14",
+  "version": "1.9.16",
   "engines": {
     "node": ">=20.x <=22.x"
   },