polydev-ai 1.9.17 → 1.9.19

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

@@ -304,6 +304,12 @@ class StdioMCPWrapper {
     // 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
@@ -839,14 +845,16 @@ Still waiting for login. Use /polydev:auth to check status after signing in.`
         }
       };
     } catch (error) {
-      const cause = error.cause ? ` (${error.cause.code || error.cause.message || error.cause})` : '';
+      const errCode = error.cause?.code || error.code || '';
+      const cause = errCode ? ` (${errCode})` : (error.cause?.message ? ` (${error.cause.message})` : '');
+      console.error(`[Polydev] Re-auth failed: ${error.message}${cause}`);
       return {
         jsonrpc: '2.0',
         id,
         result: {
           content: [{
             type: 'text',
-            text: `${reason}\n\nCould not reach server: ${error.message}${cause}\nPlease run: npx polydev-ai`
+            text: `${reason}\n\nCould not reach Polydev server: ${error.message}${cause}\n\nTroubleshooting:\n  1. Check your internet connection\n  2. Try: /polydev:login\n  3. Or run in terminal: npx polydev-ai`
           }],
           isError: true
         }
@@ -934,25 +942,9 @@ Still waiting for login. Use /polydev:auth to check status after signing in.`
     }
     
     if (!this.isAuthenticated || !this.userToken) {
-      return {
-        jsonrpc: '2.0',
-        id,
-        result: {
-          content: [{
-            type: 'text',
-            text: `POLYDEV STATUS
-==============
-
-Authentication: Not connected
-
-To login:
-  1. Use the "login" tool (opens browser)
-  2. Or run: npx polydev-ai
-
-Token will be saved automatically after login.`
-          }]
-        }
-      };
+      // No token found anywhere — auto-trigger login instead of showing static message
+      console.error('[Polydev] No token found, auto-triggering login flow...');
+      return await this.triggerReAuth(id, 'Not authenticated. Opening browser for login...');
     }
 
     try {
@@ -1047,6 +1039,16 @@ Configure: https://polydev.ai/dashboard/models`
         return await this.triggerReAuth(id, 'Token invalid or expired.');
       }
     } catch (error) {
+      // Categorize the error for clearer user messaging
+      const errCode = error.cause?.code || error.code || '';
+      const isNetwork = ['ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'ECONNRESET', 'UND_ERR_CONNECT_TIMEOUT', 'FETCH_ERROR'].includes(errCode)
+        || error.message?.includes('fetch') || error.message?.includes('network');
+      const errorDetail = isNetwork
+        ? `Network error: ${error.message}${errCode ? ` (${errCode})` : ''}\nCheck your internet connection and try again.`
+        : `Error: ${error.message}${errCode ? ` (${errCode})` : ''}`;
+
+      console.error(`[Polydev] Auth status check failed: ${error.message} (code: ${errCode})`);
+
       return {
         jsonrpc: '2.0',
         id,
@@ -1056,9 +1058,12 @@ Configure: https://polydev.ai/dashboard/models`
             text: `POLYDEV STATUS
 ==============
 
-Could not verify status (offline?)
+Could not verify authentication status.
+
+${errorDetail}
 
-Error: ${error.message}`
+To retry: /polydev:auth
+To re-login: /polydev:login`
           }],
           isError: true
         }
@@ -1506,14 +1511,20 @@ Error: ${error.message}`
       // 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')) {
+      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,
@@ -1819,7 +1830,7 @@ Error: ${error.message}`
         // 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`);
+          console.error(`[Stdio Wrapper] [CLI-FIRST] Skipping ${excludedCli} (same as current IDE — would cause recursive call)`);
         }
 
         // Build merged provider list: CLIs first, then API-only
@@ -1889,35 +1900,45 @@ 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 with fast-collect pattern
-        // Resolves once we have maxPerspectives successes (don't wait for slow CLIs)
+        // Resolves once we have maxPerspectives successes OR all complete
         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);
@@ -1931,7 +1952,7 @@ Error: ${error.message}`
             }
           });
           
-          // Fast-collect: resolve once we have maxPerspectives successes OR all complete
+          // 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`);
         }
@@ -2213,17 +2234,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
@@ -2528,6 +2538,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
    */
@@ -2603,7 +2663,7 @@ Error: ${error.message}`
         const staleProviders = [];
         for (const [providerId, status] of Object.entries(currentStatus)) {
           if (this.isStale(status)) {
-            const minutesOld = Math.floor((new Date().getTime() - new Date(status.last_checked).getTime()) / (1000 * 60));
+            const minutesOld = Math.floor((now.getTime() - lastChecked.getTime()) / (1000 * 60));
             const timeout = this.getSmartTimeout(status);
             staleProviders.push({ providerId, minutesOld, timeout });
           }
@@ -2680,8 +2740,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)
@@ -2879,8 +2942,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;
@@ -3072,16 +3152,18 @@ Dashboard: https://polydev.ai/dashboard`
         console.error(`Credits: ${credits} | Tier: ${tier}`);
         console.error('─'.repeat(50) + '\n');
       } else {
-        this.isAuthenticated = false;
+        // Don't clear isAuthenticated here — handleGetAuthStatus has its own
+        // verification and triggerReAuth logic. Clearing here causes a race condition
+        // where startup verification can invalidate auth before the user checks status.
         console.error('─'.repeat(50));
-        console.error('Polydev - Token Invalid');
+        console.error('Polydev - Token may be invalid');
         console.error('─'.repeat(50));
-        console.error('Your token may have expired.');
+        console.error('Server returned non-OK. Will re-verify on next auth check.');
         console.error('Use the "login" tool or run: npx polydev-ai login');
         console.error('─'.repeat(50) + '\n');
       }
     } catch (error) {
-      console.error('[Polydev] Could not verify auth (offline?)');
+      console.error('[Polydev] Could not verify auth (offline?):', error.message || 'unknown');
     }
   }
 

package/package.json

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