polydev-ai 1.9.13 → 1.9.15

package/mcp/stdio-wrapper.js

@@ -585,7 +585,16 @@ To re-login: npx polydev-ai`
       // if this process dies, the new one can resume polling with same session)
       this.startLoginPolling(sessionId);
       
-      // Return immediately with accurate status
+      // Wait for authentication to complete (blocks up to 120s)
+      console.error('[Polydev] Waiting for browser authentication to complete...');
+      const authenticated = await this.waitForAuthCompletion();
+      
+      if (authenticated) {
+        console.error('[Polydev] Login successful, returning status...');
+        return await this.fetchAuthStatusResponse(id);
+      }
+      
+      // Timeout - return fallback message
       return {
         jsonrpc: '2.0',
         id,
@@ -595,20 +604,12 @@ To re-login: npx polydev-ai`
             text: `AUTHENTICATION STARTED
 ======================
 
-A browser window is opening for you to sign in.
+A browser window was opened for you to sign in.
 
-If it doesn't open, visit:
+If it didn't open, visit:
   ${authUrl}
 
-Once you sign in, your token will be saved automatically to:
-  ~/.polydev.env
-  ~/.zshrc
-
-After login completes, you can:
-  /polydev:ask   Query multiple AI models
-  /polydev:auth  Check status & credits
-
-Dashboard: https://polydev.ai/dashboard`
+Still waiting for login. Use /polydev:auth to check status after signing in.`
           }]
         }
       };
@@ -658,8 +659,102 @@ Dashboard: https://polydev.ai/dashboard`
     }
   }
 
+  /**
+   * 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)
+   * @returns {boolean} true if authenticated, false if timed out
+   */
+  async waitForAuthCompletion(timeoutMs = 120000) {
+    const pollInterval = 3000; // Check every 3 seconds
+    const maxPolls = Math.floor(timeoutMs / pollInterval);
+    
+    for (let i = 0; i < maxPolls; i++) {
+      await new Promise(r => setTimeout(r, pollInterval));
+      if (this.isAuthenticated && this.userToken) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Fetch account status and return formatted response
+   * Standalone helper that doesn't trigger re-auth (avoids circular calls)
+   * @param {*} id - JSON-RPC request id
+   * @returns {object} JSON-RPC response with account status
+   */
+  async fetchAuthStatusResponse(id) {
+    try {
+      const accountResponse = await fetch('https://www.polydev.ai/api/auth/status', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.userToken}`,
+          'User-Agent': 'polydev-stdio-wrapper/1.0.0'
+        }
+      });
+      
+      if (accountResponse.ok) {
+        const data = await accountResponse.json();
+        const credits = data.credits_remaining?.toLocaleString() || 0;
+        const messages = data.messages_remaining?.toLocaleString() || 0;
+        const tier = data.subscription_tier || 'Free';
+        const email = data.email || 'Connected';
+        
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{
+              type: 'text',
+              text: `LOGIN SUCCESSFUL
+================
+
+Authentication: Connected
+Account:        ${email}
+Credits:        ${credits}
+Messages:       ${messages}
+Tier:           ${tier}
+
+You can now use:
+  /polydev:ask   Query multiple AI models
+  /polydev:auth  Check full status & credits
+
+Dashboard: https://polydev.ai/dashboard`
+            }]
+          }
+        };
+      }
+    } catch (e) {
+      console.error('[Polydev] Post-login status fetch failed:', e.message);
+    }
+    
+    // Fallback if status fetch fails
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        content: [{
+          type: 'text',
+          text: `LOGIN SUCCESSFUL
+================
+
+Your token has been saved and is active.
+
+You can now use:
+  /polydev:ask   Query multiple AI models
+  /polydev:auth  Check full status & credits
+
+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
    * Used when token is detected as invalid/expired
    * @param {*} id - JSON-RPC request id
    * @param {string} reason - Human-readable reason for re-auth
@@ -703,23 +798,33 @@ Dashboard: https://polydev.ai/dashboard`
       this.savePendingSession(sessionId);
       this.startLoginPolling(sessionId);
 
+      // Wait for authentication to complete (blocks up to 120s)
+      console.error('[Polydev] Waiting for browser authentication to complete...');
+      const authenticated = await this.waitForAuthCompletion();
+      
+      if (authenticated) {
+        console.error('[Polydev] Re-authentication successful, returning status...');
+        return await this.fetchAuthStatusResponse(id);
+      }
+
+      // Timeout - return fallback message
       return {
         jsonrpc: '2.0',
         id,
         result: {
           content: [{
             type: 'text',
-            text: `RE-AUTHENTICATION REQUIRED
-==========================
+            text: `RE-AUTHENTICATION STARTED
+=========================
 
 ${reason}
 
-A browser window is opening to re-authenticate.
+A browser window was opened for re-authentication.
 
-If it doesn't open, visit:
+If it didn't open, visit:
   ${authUrl}
 
-Once you sign in, your token will be updated automatically.`
+Still waiting for login. Use /polydev:auth to check status after signing in.`
           }]
         }
       };
@@ -1664,9 +1769,10 @@ Error: ${error.message}`
         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)
         for (const cliId of cliPriorityOrder) {
-          if (finalProviders.length >= maxPerspectives) break;
           if (!availableClis.includes(cliId)) continue;
           
           const providerName = cliToProviderMap[cliId];
@@ -1712,7 +1818,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');
@@ -1720,7 +1826,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 {
@@ -1761,7 +1868,10 @@ Error: ${error.message}`
               };
             }
           });
-          localResults = await Promise.all(cliPromises);
+          
+          // 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`);
         }
         
         // Store API-only providers info for remote API call
@@ -1836,6 +1946,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
@@ -2173,54 +2319,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

package/package.json

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