vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/llm/direct-llm-manager.cjs

@@ -632,6 +632,504 @@ class DirectLLMManager {
     });
   }
 
+  /**
+   * Call the VS Code Copilot CLI with a prompt
+   */
+  async callVSCodeCopilotCLI(model, prompt, options = {}) {
+    const { onChunk, onComplete, onError } = options;
+    const { spawn } = require('child_process');
+    const os = require('os');
+
+    // Safe logging function to prevent EPIPE errors
+    const safeLog = (message) => {
+      try {
+        console.log(message);
+      } catch (err) {
+        // Ignore EPIPE errors that occur when stdout is closed
+        if (err.code === 'EPIPE') {
+          // Silently ignore - this happens during process shutdown
+        } else {
+          // Re-throw other errors
+          throw err;
+        }
+      }
+    };
+
+    safeLog(`[VS CODE COPILOT CLI] Starting call with model: ${model}`);
+    safeLog(`[VS CODE COPILOT CLI] Prompt: ${prompt.substring(0, 100)}...`);
+
+    // Set up environment with authentication if available
+    const env = { ...process.env };
+    if (!env.HOME) env.HOME = os.homedir();
+    
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      let errorOutput = '';
+
+      // Non-interactive prompt invocation
+      // `copilot` uses `-p/--prompt` for non-interactive mode.
+      const args = ['-p', String(prompt), '-s', '--no-ask-user'];
+      const copilot = spawn('copilot', args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        cwd: process.cwd(),
+        env
+      });
+
+      safeLog(`[VS CODE COPILOT CLI] Spawned process with PID: ${copilot.pid}`);
+
+      copilot.stdout.on('data', (data) => {
+        const text = data.toString();
+        fullResponse += text;
+        safeLog(`[VS CODE COPILOT CLI] STDOUT: ${text.substring(0, 200)}...`);
+        if (onChunk) onChunk(text);
+      });
+
+      copilot.stderr.on('data', (data) => {
+        const text = data.toString();
+        errorOutput += text;
+        safeLog(`[VS CODE COPILOT CLI] STDERR: ${text.substring(0, 200)}...`);
+      });
+
+      copilot.on('close', (code) => {
+        safeLog(`[VS CODE COPILOT CLI] Process closed with code: ${code}`);
+        safeLog(`[VS CODE COPILOT CLI] Full response length: ${fullResponse.length}`);
+        safeLog(`[VS CODE COPILOT CLI] Error output length: ${errorOutput.length}`);
+        safeLog(`[VS CODE COPILOT CLI] Error output: ${errorOutput}`);
+        
+        if (code === 0) {
+          if (onComplete) onComplete(fullResponse);
+          resolve({ success: true, response: fullResponse });
+        } else {
+          // Check if this is an authentication error and provide a helpful message
+          const isAuthError = this.checkForAuthenticationError(errorOutput);
+          let error = `VS Code Copilot CLI exited with code ${code}: ${errorOutput}`;
+          
+          if (isAuthError) {
+            error = `VS Code Copilot CLI requires authentication. Run 'copilot login' to authenticate with GitHub, or set COPILOT_GITHUB_TOKEN environment variable.`;
+            safeLog(`[VS CODE COPILOT CLI] Authentication error detected: ${error}`);
+
+            // If we had previously marked this provider as rate limited, clear that stale state.
+            // Auth/setup failures should never surface as rate limit in the GUI.
+            try {
+              if (this.providerManager && typeof this.providerManager.clearProviderRateLimits === 'function') {
+                this.providerManager.clearProviderRateLimits('vscode-copilot-cli');
+              }
+            } catch (_) { }
+          }
+          
+          safeLog(`[VS CODE COPILOT CLI] Error: ${error}`);
+          if (onError) onError(error);
+          
+          // Check if this is actually a rate limit error before calling detectAndSaveRateLimit
+          const isRateLimitError = this.checkForRateLimitError(errorOutput);
+          safeLog(`[VS CODE COPILOT CLI] Is rate limit error: ${isRateLimitError}`);
+          
+          if (isRateLimitError) {
+            this.detectAndSaveRateLimit('vscode-copilot-cli', 'copilot-cli', errorOutput);
+          }
+          
+          resolve({ success: false, error });
+        }
+      });
+
+      copilot.on('error', (err) => {
+        const error = `Failed to start VS Code Copilot CLI: ${err.message}`;
+        safeLog(`[VS CODE COPILOT CLI] Spawn error: ${error}`);
+        if (onError) onError(error);
+        resolve({ success: false, error });
+      });
+    });
+  }
+
+  /**
+   * Check if error output indicates an authentication error
+   */
+  checkForAuthenticationError(errorOutput) {
+    const authIndicators = [
+      'No authentication information found',
+      'authentication information found',
+      'not authenticated',
+      'COPILOT_GITHUB_TOKEN',
+      'GH_TOKEN',
+      'GITHUB_TOKEN',
+      '/login',
+      'gh auth login',
+      'OAuth Token',
+      'Personal Access Token'
+    ];
+
+    const isAuthError = authIndicators.some(indicator => 
+      errorOutput.includes(indicator)
+    );
+
+    console.log(`[AUTH CHECK] Error output: "${errorOutput}"`);
+    console.log(`[AUTH CHECK] Is authentication error: ${isAuthError}`);
+
+    return isAuthError;
+  }
+
+  /**
+   * Check if error output indicates a genuine rate limit error
+   */
+  checkForRateLimitError(errorOutput) {
+    // VS Code Copilot CLI specific rate limit indicators
+    const rateLimitIndicators = [
+      'rate limit',
+      'Rate limit',
+      'too many requests',
+      'Too many requests',
+      '429',
+      'quota exceeded',
+      'Quota exceeded',
+      'usage limit',
+      'Usage limit',
+      'limit reached',
+      'Limit reached',
+      'weekly limit',
+      'Weekly limit',
+      'daily limit',
+      'Daily limit'
+    ];
+
+    // Exclude common authentication and setup errors that are NOT rate limits
+    const nonRateLimitIndicators = [
+      'authentication information found',
+      'Authentication information found',
+      'No authentication',
+      'not authenticated',
+      'COPILOT_GITHUB_TOKEN',
+      'GH_TOKEN',
+      'GITHUB_TOKEN',
+      '/login',
+      'gh auth login',
+      'OAuth Token',
+      'Personal Access Token',
+      'GitHub CLI'
+    ];
+
+    // First check if it contains non-rate-limit indicators
+    const isNonRateLimit = nonRateLimitIndicators.some(indicator => 
+      errorOutput.includes(indicator)
+    );
+
+    if (isNonRateLimit) {
+      console.log(`[RATE LIMIT CHECK] Contains non-rate-limit indicators, not a rate limit`);
+      return false;
+    }
+
+    // Only consider it a rate limit if it contains specific rate limit indicators
+    const isRateLimit = rateLimitIndicators.some(indicator => 
+      errorOutput.includes(indicator)
+    );
+
+    console.log(`[RATE LIMIT CHECK] Error output: "${errorOutput}"`);
+    console.log(`[RATE LIMIT CHECK] Is rate limit: ${isRateLimit}`);
+
+    return isRateLimit;
+  }
+
+  /**
+   * Check if VS Code Copilot CLI is available AND authenticated
+   * @returns {Promise<{available: boolean, needsAuth: boolean, authMethod?: string}>}
+   */
+  async isVSCodeCopilotCLIAvailable() {
+    const { spawn } = require('child_process');
+    const os = require('os');
+
+    // Safe logging function to prevent EPIPE errors
+    const safeLog = (message) => {
+      try {
+        console.log(message);
+      } catch (err) {
+        // Ignore EPIPE errors that occur when stdout is closed
+        if (err.code === 'EPIPE') {
+          // Silently ignore - this happens during process shutdown
+        } else {
+          // Re-throw other errors
+          throw err;
+        }
+      }
+    };
+
+    safeLog(`[VS CODE COPILOT CLI] Checking availability and authentication...`);
+
+    return new Promise((resolve) => {
+      // First check if the CLI is installed
+      const baseEnv = { ...process.env };
+      if (!baseEnv.HOME) baseEnv.HOME = os.homedir();
+
+      const versionProc = spawn('copilot', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'], env: baseEnv });
+      
+      let versionStdout = '';
+      let versionStderr = '';
+      let versionTimeout;
+      
+      versionProc.stdout.on('data', (data) => {
+        versionStdout += data.toString();
+        safeLog(`[VS CODE COPILOT CLI] Version check STDOUT: ${data.toString().trim()}`);
+      });
+      
+      versionProc.stderr.on('data', (data) => {
+        versionStderr += data.toString();
+        safeLog(`[VS CODE COPILOT CLI] Version check STDERR: ${data.toString().trim()}`);
+      });
+
+      versionProc.on('close', (versionCode) => {
+        clearTimeout(versionTimeout);
+        safeLog(`[VS CODE COPILOT CLI] Version check exited with code: ${versionCode}`);
+        
+        if (versionCode !== 0) {
+          safeLog(`[VS CODE COPILOT CLI] Not installed or not in PATH`);
+          resolve({ available: false, needsAuth: false });
+          return;
+        }
+
+        // CLI is installed, now check if it's authenticated using a short non-interactive prompt.
+        // Note: This CLI does not support `copilot whoami`, and GitHub CLI (`gh`) may not be installed.
+        // We keep this probe short and interpret device-flow output as needsAuth.
+        safeLog(`[VS CODE COPILOT CLI] CLI is installed, checking authentication (non-interactive probe)...`);
+
+        const probeArgs = ['-p', 'Reply with OK', '-s', '--no-ask-user'];
+        const probeProc = spawn('copilot', probeArgs, { stdio: ['ignore', 'pipe', 'pipe'], env: baseEnv });
+
+        let probeStdout = '';
+        let probeStderr = '';
+        let probeFinished = false;
+        const finishProbe = (code) => {
+          if (probeFinished) return;
+          probeFinished = true;
+          const out = (probeStdout || '').trim();
+          const err = (probeStderr || '').trim();
+          safeLog(`[VS CODE COPILOT CLI] Probe exited with code: ${code}`);
+          if (out) safeLog(`[VS CODE COPILOT CLI] Probe STDOUT: ${out.substring(0, 200)}`);
+          if (err) safeLog(`[VS CODE COPILOT CLI] Probe STDERR: ${err.substring(0, 200)}`);
+
+          // For copilot CLI, we consider it working if we get "OK" output even with exit code 1
+          // The --no-ask-user flag seems to cause exit code 1 but still provides the response
+          const isWorking = (code === 0 && out) || (code === 1 && out.trim() === 'OK');
+          
+          if (isWorking) {
+            resolve({ available: true, needsAuth: false, authMethod: 'existing' });
+            return;
+          }
+
+          const combined = `${out}\n${err}`;
+          
+          // Check for rate limit first
+          const isRateLimited = 
+            combined.includes('402 You have no quota') ||
+            combined.includes('quota') ||
+            combined.includes('rate limit') ||
+            combined.includes('Rate limit');
+            
+          if (isRateLimited) {
+            safeLog(`[VS CODE COPILOT CLI] Detected rate limit error`);
+            resolve({ available: true, needsAuth: false, authMethod: 'existing', rateLimited: true });
+            return;
+          }
+          
+          const needsAuth =
+            combined.includes('copilot login') ||
+            combined.includes('Authenticate with Copilot') ||
+            combined.includes('github.com/login/device') ||
+            combined.includes('To authenticate') ||
+            combined.includes('Waiting for authorization');
+
+          resolve({ available: true, needsAuth: Boolean(needsAuth), authMethod: needsAuth ? 'manual' : 'unknown' });
+        };
+
+        probeProc.stdout.on('data', (data) => { probeStdout += data.toString(); });
+        probeProc.stderr.on('data', (data) => { probeStderr += data.toString(); });
+        probeProc.on('close', (code) => finishProbe(code));
+        probeProc.on('error', () => finishProbe(1));
+        setTimeout(() => {
+          try { probeProc.kill(); } catch (_) { }
+          finishProbe(1);
+        }, 8000);
+      });
+      
+      versionProc.on('error', (err) => {
+        clearTimeout(versionTimeout);
+        safeLog(`[VS CODE COPILOT CLI] Version check error: ${err.message}`);
+        resolve({ available: false, needsAuth: false });
+      });
+      
+      versionTimeout = setTimeout(() => { 
+        safeLog(`[VS CODE COPILOT CLI] Version check timeout, killing process`);
+        versionProc.kill(); 
+        resolve({ available: false, needsAuth: false }); 
+      }, 5000);
+    });
+  }
+
+  /**
+   * Attempt to authenticate VS Code Copilot CLI automatically
+   * @returns {Promise<{success: boolean, method: string, reason?: string}>}
+   */
+  async attemptAutoAuthentication() {
+    const { spawn } = require('child_process');
+    
+    // Safe logging function to prevent EPIPE errors
+    const safeLog = (message) => {
+      try {
+        console.log(message);
+      } catch (err) {
+        // Ignore EPIPE errors that occur when stdout is closed
+        if (err.code === 'EPIPE') {
+          // Silently ignore - this happens during process shutdown
+        } else {
+          // Re-throw other errors
+          throw err;
+        }
+      }
+    };
+    
+    safeLog(`[VS CODE COPILOT CLI] Attempting auto-authentication...`);
+    
+    // Method 1: Check if GitHub CLI is authenticated and get token
+    try {
+      safeLog(`[VS CODE COPILOT CLI] Method 1: Checking GitHub CLI authentication...`);
+      const ghAuth = spawn('gh', ['auth', 'status'], { stdio: ['ignore', 'pipe', 'pipe'] });
+      
+      let ghStdout = '';
+      let ghStderr = '';
+      
+      ghAuth.stdout.on('data', (data) => {
+        ghStdout += data.toString();
+      });
+      
+      ghAuth.stderr.on('data', (data) => {
+        ghStderr += data.toString();
+      });
+      
+      const ghResult = await new Promise((resolve) => {
+        ghAuth.on('close', (code) => {
+          resolve({ code, stdout: ghStdout, stderr: ghStderr });
+        });
+        
+        ghAuth.on('error', () => {
+          resolve({ code: -1, stdout: '', stderr: 'gh command not found' });
+        });
+        
+        setTimeout(() => { ghAuth.kill(); resolve({ code: -1, stdout: '', stderr: 'timeout' }); }, 5000);
+      });
+      
+      if (ghResult.code === 0 && ghResult.stdout.includes('Logged in to')) {
+        safeLog(`[VS CODE COPILOT CLI] GitHub CLI is authenticated, getting token...`);
+        
+        // Get token from GitHub CLI
+        const ghToken = spawn('gh', ['auth', 'token'], { stdio: ['ignore', 'pipe', 'pipe'] });
+        
+        let tokenStdout = '';
+        let tokenStderr = '';
+        
+        ghToken.stdout.on('data', (data) => {
+          tokenStdout += data.toString();
+        });
+        
+        ghToken.stderr.on('data', (data) => {
+          tokenStderr += data.toString();
+        });
+        
+        const tokenResult = await new Promise((resolve) => {
+          ghToken.on('close', (code) => {
+            resolve({ code, stdout: tokenStdout, stderr: tokenStderr });
+          });
+          
+          ghToken.on('error', () => {
+            resolve({ code: 1, stdout: '', stderr: 'Failed to spawn gh auth token' });
+          });
+          
+          setTimeout(() => {
+            try { ghToken.kill(); } catch (_) { }
+            resolve({ code: 1, stdout: '', stderr: 'Timeout getting token' });
+          }, 5000);
+        });
+        
+        if (tokenResult.code === 0 && tokenResult.stdout) {
+          safeLog(`[VS CODE COPILOT CLI] Got token from GitHub CLI, testing with Copilot CLI...`);
+          
+          // Test the token with Copilot CLI
+          const testResult = await this.testTokenWithCopilot(tokenResult.stdout);
+          if (testResult.success) {
+            return { success: true, method: 'github-cli' };
+          } else {
+            safeLog(`[VS CODE COPILOT CLI] GitHub CLI token failed with Copilot: ${testResult.reason}`);
+          }
+        }
+      }
+    } catch (error) {
+      safeLog(`[VS CODE COPILOT CLI] GitHub CLI method failed: ${error.message}`);
+    }
+    
+    // Method 2: Check environment variables
+    safeLog(`[VS CODE COPILOT CLI] Method 2: Checking environment variables...`);
+    const envVars = ['COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN'];
+    
+    for (const envVar of envVars) {
+      const token = process.env[envVar];
+      if (token) {
+        safeLog(`[VS CODE COPILOT CLI] Found ${envVar}, testing with Copilot CLI...`);
+        
+        const testResult = await this.testTokenWithCopilot(token);
+        if (testResult.success) {
+          return { success: true, method: `env-${envVar}` };
+        } else {
+          safeLog(`[VS CODE COPILOT CLI] ${envVar} token failed with Copilot: ${testResult.reason}`);
+        }
+      }
+    }
+    
+    safeLog(`[VS CODE COPILOT CLI] All auto-authentication methods failed`);
+    return { success: false, method: 'none', reason: 'No valid authentication found' };
+  }
+
+  /**
+   * Test if a token works with VS Code Copilot CLI
+   * @param {string} token - GitHub token to test
+   * @returns {Promise<{success: boolean, reason?: string}>}
+   */
+  async testTokenWithCopilot(token) {
+    const { spawn } = require('child_process');
+    
+    return new Promise((resolve) => {
+      const env = { ...process.env, COPILOT_GITHUB_TOKEN: token };
+      
+      const testProc = spawn('copilot', ['-p', 'test', '-s'], { 
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env,
+        timeout: 5000
+      });
+      
+      let stderr = '';
+      
+      testProc.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      testProc.on('close', (code) => {
+        const needsAuth = stderr.includes('No authentication information found') ||
+                         stderr.includes('authentication information found') ||
+                         stderr.includes('not authenticated');
+        
+        if (needsAuth) {
+          resolve({ success: false, reason: 'Token not valid for Copilot CLI' });
+        } else {
+          resolve({ success: true });
+        }
+      });
+      
+      testProc.on('error', (err) => {
+        resolve({ success: false, reason: err.message });
+      });
+      
+      setTimeout(() => { 
+        testProc.kill(); 
+        resolve({ success: false, reason: 'timeout' }); 
+      }, 5000);
+    });
+  }
+
   /**
    * Call any LLM provider
    * @param {Object} config - Provider configuration
@@ -686,6 +1184,9 @@ class DirectLLMManager {
         case 'opencode':
           result = await this.callOpenCode(currentModel, prompt, options);
           break;
+        case 'vscode-copilot-cli':
+          result = await this.callVSCodeCopilotCLI(currentModel, prompt, options);
+          break;
         default:
           return { success: false, error: `Unknown provider: ${provider}` };
       }