polydev-ai 1.9.25 → 1.9.27

package/lib/cliManager.js

@@ -208,7 +208,7 @@ class CLIManager {
           provider.command, 
           provider.subcommands.version,
           'args',
-          5000
+          400000
         );
         version = versionResult.stdout?.trim();
       } catch (versionError) {
@@ -244,7 +244,7 @@ class CLIManager {
             provider.command,
             provider.subcommands.auth_status,
             'args',
-            5000 // Reduced timeout to 5 seconds
+            400000 // Reduced timeout to 5 seconds
           );
           
           // If command succeeds, check output for authentication indicators
@@ -458,16 +458,16 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
   }
 
   async sendCliPrompt(providerId, prompt, mode = 'args', timeoutMs = null, model = null) {
-    // Set default timeout for CLI responses (240 seconds / 4 minutes)
+    // Set default timeout for CLI responses (400 seconds)
     // CLI-within-CLI scenarios (Claude Code calling Claude Code) need generous timeouts
     if (timeoutMs === null) {
-      timeoutMs = 240000; // 240 seconds (4 minutes) default for CLI responses
+      timeoutMs = 400000; // 400 seconds default for CLI responses
     }
 
     // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
     // Allow up to 600 seconds (10 minutes) for very complex operations
     if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 600000) {
-      timeoutMs = 240000 // Default to 240 seconds (4 minutes) for CLI responses
+      timeoutMs = 400000 // Default to 400 seconds for CLI responses
     }
     
     const startTime = Date.now();
@@ -806,11 +806,11 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
     }
   }
 
-  async executeCliCommand(command, args, mode = 'args', timeoutMs = 240000, stdinInput) {
+  async executeCliCommand(command, args, mode = 'args', timeoutMs = 400000, stdinInput) {
     // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
-    // 240 seconds (4 minutes) default for CLI responses
+    // 400 seconds default for CLI responses
     if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 600000) {
-      timeoutMs = 240000 // Default to 240 seconds (4 minutes)
+      timeoutMs = 400000 // Default to 400 seconds
     }
     
     return new Promise((resolve, reject) => {

package/mcp/stdio-wrapper.js

@@ -35,7 +35,7 @@ if (typeof globalThis.fetch === 'undefined') {
       });
 
       req.on('error', reject);
-      req.setTimeout(240000, () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.setTimeout(400000, () => { req.destroy(); reject(new Error('Request timed out')); });
       if (options.body) req.write(options.body);
       req.end();
     });
@@ -308,7 +308,7 @@ class StdioMCPWrapper {
     this.clientInfo = null;
 
     // Adaptive timeout tracking: stores recent response times per CLI
-    // Used to set smarter timeouts instead of fixed 240s
+    // Used to set smarter timeouts instead of fixed 400s
     this.cliResponseTimes = {}; // { cliId: [latency_ms, ...] }
     this.CLI_RESPONSE_HISTORY_SIZE = 5; // Keep last 5 response times
     this.loadCliResponseTimes(); // Load from disk
@@ -644,7 +644,7 @@ To authenticate, use one of these methods:
       // if this process dies, the new one can resume polling with same session)
       this.startLoginPolling(sessionId);
       
-      // Wait for authentication to complete (blocks up to 120s)
+      // Wait for authentication to complete (blocks up to 400s)
       console.error('[Polydev] Waiting for browser authentication to complete...');
       const authenticated = await this.waitForAuthCompletion();
       
@@ -721,10 +721,10 @@ Still waiting for login. Use /polydev:auth to check status after signing in.`
   /**
    * Wait for authentication to complete by polling this.isAuthenticated
    * Used to block tool calls until login is detected by startLoginPolling
-   * @param {number} timeoutMs - Max time to wait (default 120s)
+   * @param {number} timeoutMs - Max time to wait (default 400s)
    * @returns {boolean} true if authenticated, false if timed out
    */
-  async waitForAuthCompletion(timeoutMs = 120000) {
+  async waitForAuthCompletion(timeoutMs = 400000) {
     const pollInterval = 3000; // Check every 3 seconds
     const maxPolls = Math.floor(timeoutMs / pollInterval);
     
@@ -813,7 +813,7 @@ Dashboard: https://polydev.ai/dashboard`
 
   /**
    * Trigger re-authentication by opening browser and starting polling
-   * Waits for auth to complete inline (up to 120s) then returns full status
+   * Waits for auth to complete inline (up to 400s) then returns full status
    * Used when token is detected as invalid/expired
    * @param {*} id - JSON-RPC request id
    * @param {string} reason - Human-readable reason for re-auth
@@ -879,7 +879,7 @@ To authenticate, pass your token directly:
       this.savePendingSession(sessionId);
       this.startLoginPolling(sessionId);
 
-      // Wait for authentication to complete (blocks up to 120s)
+      // Wait for authentication to complete (blocks up to 400s)
       console.error('[Polydev] Waiting for browser authentication to complete...');
       const authenticated = await this.waitForAuthCompletion();
       
@@ -1566,76 +1566,64 @@ To re-login: /polydev:login`
 </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}`
-          }
-        };
+  /**
+   * Send an MCP progress notification to the client
+   * This is a JSON-RPC notification (no id) that compatible clients use to:
+   * 1. Display progress UI (status bar, spinners)
+   * 2. Reset their tool call timeout (if resetTimeoutOnProgress is enabled)
+   * @param {string|number} progressToken - Token from request's _meta.progressToken
+   * @param {number} progress - Current progress value (must increase monotonically)
+   * @param {number} total - Total expected progress value
+   * @param {string} message - Human-readable status message
+   */
+  sendProgressNotification(progressToken, progress, total, message) {
+    if (!progressToken) return; // Client didn't request progress
+    
+    const notification = {
+      jsonrpc: '2.0',
+      method: 'notifications/progress',
+      params: {
+        progressToken,
+        progress,
+        total,
+        message
       }
-
-      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}`
-        }
-      };
+    };
+    
+    try {
+      process.stdout.write(JSON.stringify(notification) + '\n');
+      console.error(`[Polydev] Progress: ${progress}/${total} - ${message}`);
+    } catch (err) {
+      console.error(`[Polydev] Failed to send progress notification:`, err.message);
     }
   }
 
   /**
-   * Check if a tool is a CLI tool that should be handled locally
+   * Start a periodic progress heartbeat to prevent client-side timeouts.
+   * Sends a progress notification every intervalMs to signal the server is still working.
+   * Compatible MCP clients will reset their timeout clock on each notification.
+   * @param {string|number} progressToken - Token from request's _meta.progressToken
+   * @param {number} intervalMs - Heartbeat interval in milliseconds (default: 10s)
+   * @returns {{ stop: Function, tick: Function }} Controller to stop heartbeat and manually tick progress
    */
-  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);
+  startProgressHeartbeat(progressToken, intervalMs = 10000) {
+    if (!progressToken) return { stop: () => {}, tick: () => {} };
+    
+    let currentProgress = 0;
+    const total = 100; // Use percentage-style progress
+    
+    const interval = setInterval(() => {
+      currentProgress = Math.min(currentProgress + 5, 95); // Never reach 100 until done
+      this.sendProgressNotification(progressToken, currentProgress, total, 'Processing perspectives...');
+    }, intervalMs);
+    
+    return {
+      stop: () => clearInterval(interval),
+      tick: (progress, message) => {
+        currentProgress = progress;
+        this.sendProgressNotification(progressToken, progress, total, message);
+      }
+    };
   }
 
   /**
@@ -1644,12 +1632,30 @@ To re-login: /polydev:login`
   async handleGetPerspectivesWithCLIs(params, id) {
     console.error(`[Stdio Wrapper] Handling get_perspectives with local CLIs + remote`);
     
+    // Extract progress token from request metadata (MCP spec)
+    // Clients that want progress updates include this in _meta.progressToken
+    const progressToken = params?._meta?.progressToken;
+    if (progressToken) {
+      console.error(`[Stdio Wrapper] Client requested progress updates (token: ${progressToken})`);
+    }
+    
+    // Start periodic heartbeat to prevent client-side timeouts
+    // Sends progress notification every 10s to keep the connection alive
+    const heartbeat = this.startProgressHeartbeat(progressToken);
+    
     try {
+      // Send initial progress
+      heartbeat.tick(5, 'Initializing perspectives engine...');
+      
       // 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);
+      const result = await this.localSendCliPrompt(params.arguments, progressToken);
+
+      // Stop heartbeat before sending final response
+      heartbeat.stop();
+      heartbeat.tick(100, 'Complete');
 
       // Check if result indicates auth failure (from forwardToRemoteServer 401 handling)
       if (result?.result?.content?.[0]?.text?.includes('RE-AUTHENTICATION REQUIRED')) {
@@ -1678,6 +1684,7 @@ To re-login: /polydev:login`
       };
 
     } catch (error) {
+      heartbeat.stop(); // Always clean up heartbeat
       console.error(`[Stdio Wrapper] get_perspectives error:`, error);
       
       // Check if error is auth-related
@@ -1704,9 +1711,13 @@ To re-login: /polydev:login`
   async handleLocalCliTool(request) {
     const { method, params, id } = request;
     const { name: toolName, arguments: args } = params;
+    const progressToken = params?._meta?.progressToken;
 
     console.error(`[Stdio Wrapper] Handling local CLI tool: ${toolName}`);
 
+    // Start heartbeat for long-running CLI operations
+    const heartbeat = this.startProgressHeartbeat(progressToken);
+
     try {
       let result;
 
@@ -1723,13 +1734,14 @@ To re-login: /polydev:login`
         
         case 'send_cli_prompt':
         case 'polydev.send_cli_prompt':
-          result = await this.localSendCliPrompt(args);
+          result = await this.localSendCliPrompt(args, progressToken);
           break;
         
         default:
           throw new Error(`Unknown CLI tool: ${toolName}`);
       }
 
+      heartbeat.stop();
       return {
         jsonrpc: '2.0',
         id,
@@ -1745,6 +1757,7 @@ To re-login: /polydev:login`
 
     } catch (error) {
       console.error(`[Stdio Wrapper] CLI tool error:`, error);
+      heartbeat.stop();
       return {
         jsonrpc: '2.0',
         id,
@@ -1885,23 +1898,23 @@ To re-login: /polydev:login`
    * Respects user's perspectives_per_message setting for total perspectives
    * Uses allProviders from dashboard - tries CLI first, falls back to API
    */
-  async localSendCliPrompt(args) {
+  async localSendCliPrompt(args, progressToken) {
     console.error(`[Stdio Wrapper] Local CLI prompt sending with perspectives`);
     
     try {
-      let { provider_id, prompt, mode = 'args', timeout_ms = 240000 } = args;
+      let { provider_id, prompt, mode = 'args', timeout_ms = 400000 } = args;
       
       // Ensure timeout_ms is valid (not undefined, null, Infinity, or negative)
-      // Default to 4 minutes (240 seconds) for complex CLI responses
+      // Default to 400 seconds for complex CLI responses
       if (!timeout_ms || timeout_ms === Infinity || timeout_ms < 1 || timeout_ms > 600000) {
-        timeout_ms = 240000; // Default to 4 minutes for CLI responses
+        timeout_ms = 400000; // Default to 400 seconds for CLI responses
       }
       
       if (!prompt) {
         throw new Error('prompt is required');
       }
 
-      // Use configured timeout but cap at 10 minutes max for safety
+      // Use configured timeout but cap at 400s max for safety
       const gracefulTimeout = Math.min(timeout_ms, 600000);
 
       // Fetch user's model preferences (cached, non-blocking on failure)
@@ -1912,6 +1925,8 @@ To re-login: /polydev:login`
       } catch (prefError) {
         console.error('[Stdio Wrapper] Model preferences fetch failed (will use CLI defaults):', prefError.message);
       }
+      
+      this.sendProgressNotification(progressToken, 15, 100, 'Loaded model preferences');
 
       // Get the user's perspectives_per_message setting (default 2)
       const maxPerspectives = this.perspectivesPerMessage || 2;
@@ -1920,14 +1935,11 @@ To re-login: /polydev:login`
       let localResults = [];
 
       if (provider_id) {
-        // Specific provider requested - use only that one
+        // Single provider requested - use only that one
         console.error(`[Stdio Wrapper] Using specific provider: ${provider_id}`);
         const model = modelPreferences[provider_id] || null;
-        if (model) {
-          console.error(`[Stdio Wrapper] Using user's preferred model for ${provider_id}: ${model}`);
-        } else {
-          console.error(`[Stdio Wrapper] No model preference for ${provider_id}, using CLI default`);
-        }
+        console.error(`[Stdio Wrapper] Using user's preferred model for ${provider_id}: ${model}`);
+        this.sendProgressNotification(progressToken, 20, 100, `Querying ${provider_id}...`);
         const result = await this.cliManager.sendCliPrompt(provider_id, prompt, mode, gracefulTimeout, model);
         localResults = [{ provider_id, ...result }];
       } else {
@@ -1939,6 +1951,7 @@ To re-login: /polydev:login`
         // Get available CLIs for checking
         const { available: availableClis } = await this.getAllAvailableProviders();
         console.error(`[Stdio Wrapper] Available CLIs: ${availableClis.join(', ') || 'none'}`);
+        this.sendProgressNotification(progressToken, 25, 100, `Found ${availableClis.length} CLIs: ${availableClis.join(', ') || 'none'}`);
         
         // Get all providers from dashboard (user's configured providers + CLI-only)
         const allProviders = this.allProviders || [];
@@ -1983,7 +1996,7 @@ To re-login: /polydev:login`
         for (const cliId of cliPriorityOrder) {
           if (!availableClis.includes(cliId)) continue;
           if (cliId === excludedCli) {
-            console.error(`[Stdio Wrapper] [CLI-FIRST] Skipping ${cliId} (same as current IDE — would cause recursive call)`);
+            console.error(`[Stdio Wrapper] [CLI-FIRST] Skipping ${excludedCli} (same as current IDE — would cause recursive call)`);
             continue;
           }
           
@@ -2041,6 +2054,7 @@ To re-login: /polydev:login`
         // Run ALL CLI prompts concurrently with fast-collect pattern
         // Resolves once we have maxPerspectives successes OR all complete
         if (cliProviderEntries.length > 0) {
+          this.sendProgressNotification(progressToken, 30, 100, `Querying ${cliProviderEntries.length} CLIs in parallel...`);
           const cliPromises = cliProviderEntries.map(async (providerEntry) => {
             try {
               // ONLY use the model from providerEntry (which is filtered to user's own API keys, not credits)
@@ -2050,7 +2064,7 @@ To re-login: /polydev:login`
               if (model) {
                 console.error(`[Stdio Wrapper] Using model for ${providerEntry.cliId}: ${model}`);
               }
-              // Use adaptive timeout based on historical response times (instead of fixed 240s)
+              // Use adaptive timeout based on historical response times (instead of fixed 400s)
               const cliTimeout = this.getAdaptiveTimeout(providerEntry.cliId, gracefulTimeout);
               let result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, cliTimeout, model);
 
@@ -2094,6 +2108,7 @@ To re-login: /polydev:login`
           // 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`);
+          this.sendProgressNotification(progressToken, 55, 100, `Got ${localResults.filter(r => r.success).length} CLI responses`);
         }
         
         // Store API-only providers info for remote API call
@@ -2116,6 +2131,7 @@ To re-login: /polydev:login`
       // Get remote perspectives for API-only providers and failed CLIs
       let perspectivesResult;
       if (remainingPerspectives > 0) {
+        this.sendProgressNotification(progressToken, 65, 100, `Fetching ${remainingPerspectives} more perspectives from API...`);
         console.error(`[Stdio Wrapper] Calling remote API for ${remainingPerspectives} more perspectives (have ${successfulLocalCount}/${maxPerspectives})`);
         
         // Pass API-only provider info to help remote API choose correct models
@@ -2155,6 +2171,7 @@ To re-login: /polydev:login`
       }
 
       // Combine all results
+      this.sendProgressNotification(progressToken, 90, 100, 'Combining all perspectives...');
       return this.combineAllCliAndPerspectives(localResults, perspectivesResult, args);
 
     } catch (error) {
@@ -2194,7 +2211,7 @@ To re-login: /polydev:login`
           if (result.success) successCount++;
           completedCount++;
           
-          // Resolve early if we have enough successes OR all promises done
+          // Resolve early if we have enough successes OR all complete
           if (successCount >= needed || completedCount >= promises.length) {
             resolved = true;
             resolve([...results]); // Copy to prevent mutation from late arrivals
@@ -2462,7 +2479,7 @@ To re-login: /polydev:login`
             user_token: this.userToken,
             // Exclude providers that succeeded locally
             exclude_providers: excludeProviders,
-            // NEW: Specific providers to request (from API-only list)
+            // NEW: Specific providers to request (from API-only providers)
             request_providers: requestProviders.length > 0 ? requestProviders : undefined,
             // Pass CLI responses for dashboard logging
             cli_responses: cliResponses,
@@ -2713,16 +2730,16 @@ To re-login: /polydev:login`
 
   /**
    * 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)
+   * Returns timeout in ms (2.5x the average, with min 30s and max 400s)
    */
-  getAdaptiveTimeout(cliId, defaultTimeout = 240000) {
+  getAdaptiveTimeout(cliId, defaultTimeout = 400000) {
     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)));
+    // 2.5x average, clamped between 30s and 400s
+    const adaptive = Math.min(400000, 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;
   }
@@ -2849,11 +2866,11 @@ To re-login: /polydev:login`
     try {
       const homeDir = require('os').homedir();
       const polydevevDir = path.join(homeDir, '.polydev');
-      const usageFile = path.join(polydevevDir, 'cli-usage.json');
+      const usageFile = path.join(polydeveevDir, 'cli-usage.json');
 
       // Ensure directory exists
-      if (!fs.existsSync(polydevevDir)) {
-        fs.mkdirSync(polydevevDir, { recursive: true });
+      if (!fs.existsSync(polydeveevDir)) {
+        fs.mkdirSync(polydeveevDir, { recursive: true });
       }
 
       // Add new usage record
@@ -2963,7 +2980,7 @@ To re-login: /polydev:login`
         this.userModelPreferences = result.modelPreferences;
         this.modelPreferencesCacheTime = Date.now();
         
-        // Also cache perspectives_per_message setting (default 2)
+        // Also cache perspectivesPerMessage setting (default 2)
         this.perspectivesPerMessage = result.perspectivesPerMessage || 2;
         
         // Cache provider order from user's dashboard (respects display_order)
@@ -3141,6 +3158,7 @@ To re-login: /polydev:login`
         return this.localForceCliDetection({});
       }).then(() => {
         this._cliDetectionComplete = true;
+        // Display CLI status after detection
         return this.displayCliStatus();
       }).catch((error) => {
         console.error('[Polydev] Auto-login flow error:', error.message);

package/package.json

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