polydev-ai 1.9.16 → 1.9.18

package/lib/cliManager.js

@@ -180,6 +180,16 @@ class CLIManager {
     return result;
   }
 
+  /**
+   * Pre-seed the status cache from external data (e.g., disk cache)
+   * This allows instant CLI availability without waiting for detection
+   */
+  setCachedStatus(statusMap) {
+    for (const [providerId, status] of Object.entries(statusMap)) {
+      this.statusCache.set(providerId, status);
+    }
+  }
+
   async detectCliProvider(provider) {
     try {
       const cliPath = await this.findCliPath(provider.command);

package/mcp/stdio-wrapper.js

@@ -299,11 +299,17 @@ 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;
-    
+
+    // Adaptive timeout tracking: stores recent response times per CLI
+    // Used to set smarter timeouts instead of fixed 240s
+    this.cliResponseTimes = {}; // { cliId: [latency_ms, ...] }
+    this.CLI_RESPONSE_HISTORY_SIZE = 5; // Keep last 5 response times
+    this.loadCliResponseTimes(); // Load from disk
+
     // 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
@@ -1000,10 +1006,11 @@ Token will be saved automatically after login.`
           perspectivesSection += ` (${perspectiveCount} active)`;
           
           // Show providers in order with their selected models
-          for (const p of modelPrefs.allProviders) {
+          for (let i = 0; i < modelPrefs.allProviders.length; i++) {
+            const p = modelPrefs.allProviders[i];
             const providerName = p.provider.charAt(0).toUpperCase() + p.provider.slice(1);
             const source = p.cliId ? 'CLI' : (p.tier ? `Credits/${p.tier}` : 'API');
-            perspectivesSection += `\n  ${providerName.padEnd(12)} ${p.model} [${source}]`;
+            perspectivesSection += `\n  ${i + 1}. ${providerName.padEnd(12)} ${p.model} [${source}]`;
           }
         } else {
           perspectivesSection += '\n  (none configured - using defaults)';
@@ -1421,6 +1428,279 @@ 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
+   */
+  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`);
+    
+    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)
+      if (result?.result?.content?.[0]?.text?.includes('RE-AUTHENTICATION REQUIRED')) {
+        // Auth failure already handled with re-auth response - pass through
+        return result;
+      }
+
+      // localSendCliPrompt returns either:
+      // - A string (from combineAllCliAndPerspectives) on success
+      // - An object { success, error, timestamp } on exception
+      const resultText = typeof result === 'string'
+        ? result
+        : (result.content || this.formatCliResponse(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`);
+    
+    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`);
+    
+    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
+      };
+    }
+  }
+
   /**
    * 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).
@@ -1428,9 +1708,9 @@ Error: ${error.message}`
    */
   getExcludedCliForCurrentIDE() {
     if (!this.clientInfo?.name) return null;
-    
+
     const clientName = this.clientInfo.name.toLowerCase();
-    
+
     // Map known IDE client names to their corresponding CLI IDs
     // These are the clientInfo.name values sent during MCP initialize handshake
     const ideToCliMap = {
@@ -1439,8 +1719,7 @@ Error: ${error.message}`
       '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
+      // Cursor uses Claude under the hood but is a separate IDE — don't exclude
       // Gemini CLI / Google IDX
       'gemini-cli': 'gemini_cli',
       'gemini_cli': 'gemini_cli',
@@ -1449,17 +1728,17 @@ Error: ${error.message}`
       'codex_cli': 'codex_cli',
       'codex': 'codex_cli',
     };
-    
+
     // 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;
   }
 
@@ -1548,17 +1827,17 @@ 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 (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)
@@ -1584,7 +1863,7 @@ Error: ${error.message}`
           
           finalProviders.push({
             provider: providerName,
-            model: configuredProvider?.model || null, // null = use CLI default model
+            model: configuredProvider?.model || null, // null = use CLI's default model
             cliId: cliId,
             source: 'cli',
             tier: null // CLIs don't use credits tiers
@@ -1626,31 +1905,41 @@ Error: ${error.message}`
         if (cliProviderEntries.length > 0) {
           const cliPromises = cliProviderEntries.map(async (providerEntry) => {
             try {
-              const model = providerEntry.model || modelPreferences[providerEntry.cliId] || null;
+              // ONLY use the model from providerEntry (which is filtered to user's own API keys, not credits)
+              // Do NOT fall back to modelPreferences[cliId] — it may contain credits-tier model names
+              // (e.g., 'gemini-3-flash') that cause ModelNotFoundError on the actual CLI
+              const model = providerEntry.model || null;
               if (model) {
                 console.error(`[Stdio Wrapper] Using model for ${providerEntry.cliId}: ${model}`);
               }
-              let result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, gracefulTimeout, model);
-              
+              // Use adaptive timeout based on historical response times (instead of fixed 240s)
+              const cliTimeout = this.getAdaptiveTimeout(providerEntry.cliId, gracefulTimeout);
+              let result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, cliTimeout, model);
+
               // If CLI failed with a model and the error suggests model issue, retry with CLI default
               if (!result.success && model) {
                 const errorLower = (result.error || '').toLowerCase();
-                const isModelError = errorLower.includes('not found') || 
-                  errorLower.includes('not supported') || 
+                const isModelError = errorLower.includes('not found') ||
+                  errorLower.includes('not supported') ||
                   errorLower.includes('invalid model') ||
                   errorLower.includes('entity was not found') ||
                   errorLower.includes('does not exist') ||
                   errorLower.includes('unknown model');
                 if (isModelError) {
                   console.error(`[Stdio Wrapper] Model '${model}' failed for ${providerEntry.cliId}, retrying with CLI default...`);
-                  result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, gracefulTimeout, null);
+                  result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, cliTimeout, null);
                 }
               }
-              
-              return { 
-                provider_id: providerEntry.cliId, 
+
+              // Record response time for adaptive timeout calculation
+              if (result.success && result.latency_ms) {
+                this.recordCliResponseTime(providerEntry.cliId, result.latency_ms);
+              }
+
+              return {
+                provider_id: providerEntry.cliId,
                 original_provider: providerEntry.provider,
-                ...result 
+                ...result
               };
             } catch (error) {
               console.error(`[Stdio Wrapper] CLI ${providerEntry.cliId} failed:`, error.message);
@@ -1664,7 +1953,7 @@ Error: ${error.message}`
             }
           });
           
-          // Fast-collect: resolve early once we have maxPerspectives successes OR all complete
+          // Fast-collect: resolve 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`);
         }
@@ -1946,17 +2235,6 @@ Error: ${error.message}`
     return this.getModelPreferenceForCli(providerId);
   }
 
-  /**
-   * Get default model name for a CLI tool (used when model not specified in result)
-   * These are just display labels - actual model selection is done by:
-   * 1. User's configured default_model in dashboard API keys
-   * 2. CLI tool's own default if no preference set
-   */
-  getDefaultModelForCli(providerId) {
-    // Prefer user's model preference if available
-    return this.getModelPreferenceForCli(providerId);
-  }
-
   /**
    * Call remote perspectives for CLI prompts
    * Only calls remote APIs for providers NOT covered by successful local CLIs
@@ -2261,6 +2539,56 @@ Error: ${error.message}`
     }
   }
 
+  /**
+   * Load CLI response times from disk for adaptive timeouts
+   */
+  loadCliResponseTimes() {
+    try {
+      const timesFile = path.join(os.homedir(), '.polydev', 'cli-response-times.json');
+      if (fs.existsSync(timesFile)) {
+        this.cliResponseTimes = JSON.parse(fs.readFileSync(timesFile, 'utf8'));
+        console.error(`[Stdio Wrapper] Loaded CLI response times from disk`);
+      }
+    } catch (e) {
+      // Non-critical
+    }
+  }
+
+  /**
+   * Record a CLI response time for adaptive timeout calculation
+   */
+  recordCliResponseTime(cliId, latencyMs) {
+    if (!this.cliResponseTimes[cliId]) {
+      this.cliResponseTimes[cliId] = [];
+    }
+    this.cliResponseTimes[cliId].push(latencyMs);
+    // Keep only the last N entries
+    if (this.cliResponseTimes[cliId].length > this.CLI_RESPONSE_HISTORY_SIZE) {
+      this.cliResponseTimes[cliId] = this.cliResponseTimes[cliId].slice(-this.CLI_RESPONSE_HISTORY_SIZE);
+    }
+    // Save to disk (fire-and-forget)
+    try {
+      const timesFile = path.join(os.homedir(), '.polydev', 'cli-response-times.json');
+      fs.writeFileSync(timesFile, JSON.stringify(this.cliResponseTimes));
+    } catch (e) { /* non-critical */ }
+  }
+
+  /**
+   * Get adaptive timeout for a CLI based on historical response times
+   * Returns timeout in ms (2.5x the average, with min 30s and max 240s)
+   */
+  getAdaptiveTimeout(cliId, defaultTimeout = 240000) {
+    const times = this.cliResponseTimes[cliId];
+    if (!times || times.length === 0) {
+      return defaultTimeout; // No history, use default
+    }
+    const avg = times.reduce((a, b) => a + b, 0) / times.length;
+    // 2.5x average, clamped between 30s and 240s
+    const adaptive = Math.min(240000, Math.max(30000, Math.round(avg * 2.5)));
+    console.error(`[Stdio Wrapper] Adaptive timeout for ${cliId}: ${adaptive}ms (avg: ${Math.round(avg)}ms from ${times.length} samples)`);
+    return adaptive;
+  }
+
   /**
    * Load CLI status from local file cache
    */
@@ -2413,8 +2741,11 @@ Error: ${error.message}`
    * Format CLI response for MCP output
    */
   formatCliResponse(result) {
+    // Handle string results (from combineAllCliAndPerspectives)
+    if (typeof result === 'string') return result;
+
     if (!result.success) {
-      return `❌ **CLI Error**\n\n${result.error}\n\n*Timestamp: ${result.timestamp}*`;
+      return `❌ **CLI Error**\n\n${result.error || 'Unknown error'}\n\n*Timestamp: ${result.timestamp || new Date().toISOString()}*`;
     }
 
     // Handle combined CLI + perspectives response (single or multiple CLIs)
@@ -2456,7 +2787,7 @@ Error: ${error.message}`
   /**
    * Fetch user's model preferences from API keys
    * Returns a map of CLI provider -> default_model
-   * Also fetches and caches perspectives_per_message setting and allProviders list
+   * Also fetches and caches perspectivesPerMessage setting and allProviders list
    */
   async fetchUserModelPreferences() {
     // Check cache first
@@ -2612,8 +2943,25 @@ Error: ${error.message}`
     // Only run CLI detection here if we already have a token
     // (If no token, CLI detection runs after login completes in runStartupFlow)
     if (this.userToken) {
+      // Pre-seed CLI status from disk cache for instant availability
+      // This eliminates the 3-7s startup penalty from shelling out to CLI --version
+      try {
+        const cachedStatus = await this.loadLocalCliStatus();
+        if (cachedStatus && Object.keys(cachedStatus).length > 0) {
+          console.error(`[Polydev] Pre-seeded CLI status from disk cache (${Object.keys(cachedStatus).length} providers)`);
+          this.cliManager.setCachedStatus(cachedStatus);
+          this._cliDetectionComplete = true; // Mark as complete so requests don't wait
+          if (this._cliDetectionResolver) {
+            this._cliDetectionResolver(); // Unblock any waiting requests
+          }
+        }
+      } catch (e) {
+        console.error('[Polydev] Disk cache pre-seed failed (will detect fresh):', e.message);
+      }
+
+      // Run full CLI detection in background to refresh the cache
       console.error('[Polydev] Detecting local CLI tools...');
-      
+
       this.localForceCliDetection({})
         .then(async () => {
           this._cliDetectionComplete = true;

package/package.json

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