vibecodingmachine-cli 2026.2.26-1752 → 2026.3.9-1621

package/src/utils/provider-checker/opencode-checker.js

@@ -0,0 +1,588 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * OpenCode Agent Checker - Handles OpenCode CLI specific checks and configuration
+ * 
+ * This module provides specialized checking for OpenCode CLI agent:
+ * 1. First attempts a simple ping test (1+1 or "ping")
+ * 2. If configuration errors occur, attempts to pre-configure with working model
+ * 3. If still stuck, attempts to automate initial configuration prompts
+ */
+
+class OpenCodeChecker {
+  constructor() {
+    this.configPath = path.join(os.homedir(), '.config', 'opencode');
+    this.globalConfigFile = path.join(this.configPath, 'opencode.json');
+  }
+
+  /**
+   * Check if OpenCode CLI is available in PATH
+   * @returns {boolean}
+   */
+  isAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('which opencode', { stdio: 'ignore', timeout: 5000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Attempt a simple ping test to check if OpenCode is responsive
+   * @returns {Promise<{responsive: boolean, error?: string, needsConfig?: boolean}>}
+   */
+  async pingTest(configOverride = null) {
+    console.log('[OPENCODE CHECK] Starting ping test...');
+    
+    return new Promise((resolve) => {
+      const env = { ...process.env };
+      if (configOverride) {
+        env.OPENCODE_CONFIG_CONTENT = configOverride;
+        console.log('[OPENCODE CHECK] Using config override:', configOverride);
+      }
+      
+      const proc = spawn('opencode', ['-p', '1+1', '-q'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 30000,
+        env
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        console.log('[OPENCODE CHECK] STDOUT:', chunk.trim());
+      });
+
+      proc.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        console.log('[OPENCODE CHECK] STDERR:', chunk.trim());
+      });
+
+      proc.on('close', (code) => {
+        const output = stdout + stderr;
+        console.log(`[OPENCODE CHECK] Process exited with code: ${code}`);
+        console.log(`[OPENCODE CHECK] Full output: ${output.substring(0, 500)}`);
+        
+        // Check for successful response
+        if (code === 0 && (output.includes('2') || output.includes('2\n'))) {
+          console.log('[OPENCODE CHECK] ✓ Ping test successful');
+          resolve({ responsive: true });
+          return;
+        }
+
+        // Check for configuration errors
+        const needsConfig = 
+          output.includes('model') && output.includes('decommissioned') ||
+          output.includes('API key') ||
+          output.includes('configuration') ||
+          output.includes('configure') ||
+          output.includes('failed to process events') ||
+          output.includes('LSP Configuration') ||  // Add LSP configuration detection
+          output.includes('Unknown request URL') ||  // Add API endpoint detection
+          output.includes('unknown_url');  // Add API endpoint detection
+
+        if (needsConfig) {
+          console.log('[OPENCODE CHECK] ⚠ Configuration needed detected');
+          
+          // Provide specific error details
+          let errorDetails = 'OpenCode needs configuration';
+          if (output.includes('Unknown request URL') || output.includes('unknown_url')) {
+            errorDetails = 'OpenCode has incorrect API endpoint configuration';
+          } else if (output.includes('max_tokens')) {
+            errorDetails = 'OpenCode has max_tokens configuration issue';
+          }
+          
+          resolve({ 
+            responsive: false, 
+            error: errorDetails,
+            needsConfig: true,
+            details: output.substring(0, 200)
+          });
+        } else {
+          console.log('[OPENCODE CHECK] ✗ Ping test failed for unknown reason');
+          resolve({ 
+            responsive: false, 
+            error: `OpenCode ping failed (exit code: ${code})`,
+            details: output.substring(0, 200)
+          });
+        }
+      });
+
+      proc.on('error', (error) => {
+        console.log(`[OPENCODE CHECK] ✗ Process error: ${error.message}`);
+        resolve({ 
+          responsive: false, 
+          error: `Failed to run OpenCode: ${error.message}` 
+        });
+      });
+    });
+  }
+
+  /**
+   * Create a basic configuration with a working model
+   * @returns {Promise<{success: boolean, error?: string}>}
+   */
+  async createBasicConfig() {
+    console.log('[OPENCODE CHECK] Attempting to create basic configuration...');
+    
+    try {
+      // Ensure config directory exists
+      fs.mkdirSync(this.configPath, { recursive: true });
+      console.log(`[OPENCODE CHECK] Config directory ensured: ${this.configPath}`);
+
+      // Try to detect available API keys from environment
+      const availableProviders = this.detectAvailableProviders();
+      console.log(`[OPENCODE CHECK] Available providers detected: ${availableProviders.join(', ')}`);
+      
+      // Create config with the first available provider and a working model
+      const model = this.selectWorkingModel(availableProviders);
+      console.log(`[OPENCODE CHECK] Selected model: ${model}`);
+      
+      const config = {
+        "$schema": "https://opencode.ai/config.json",
+        "model": model,
+        "autoupdate": false,
+        "server": {
+          "port": 4096
+        }
+      };
+
+      // Write the configuration
+      const configJson = JSON.stringify(config, null, 2);
+      fs.writeFileSync(this.globalConfigFile, configJson);
+      console.log(`[OPENCODE CHECK] Configuration written to: ${this.globalConfigFile}`);
+      console.log(`[OPENCODE CHECK] Config content: ${configJson}`);
+      
+      return { success: true };
+    } catch (error) {
+      console.log(`[OPENCODE CHECK] ✗ Failed to create config: ${error.message}`);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Detect available API providers from environment variables
+   * @returns {string[]}
+   */
+  detectAvailableProviders() {
+    const providers = [];
+    
+    if (process.env.OPENAI_API_KEY) providers.push('openai');
+    if (process.env.ANTHROPIC_API_KEY) providers.push('anthropic');
+    if (process.env.GEMINI_API_KEY) providers.push('google');
+    if (process.env.GROQ_API_KEY) providers.push('groq');
+    
+    return providers;
+  }
+
+  /**
+   * Select a working model based on available providers
+   * @param {string[]} providers 
+   * @returns {string}
+   */
+  selectWorkingModel(providers) {
+    const modelMap = {
+      'openai': 'gpt-4o-mini',
+      'anthropic': 'claude-3-haiku-20240307',
+      'google': 'gemini-flash-1.5',
+      'groq': 'Llama3_3_70BVersatile'  // Use the model shown in OpenCode's UI
+    };
+
+    // Try providers in order of preference
+    for (const provider of ['anthropic', 'openai', 'google', 'groq']) {
+      if (providers.includes(provider)) {
+        return modelMap[provider];
+      }
+    }
+
+    // Fallback to a common model (may fail but worth trying)
+    return 'Llama3_3_70BVersatile';
+  }
+
+  /**
+   * Attempt to automatically configure OpenCode using keyboard shortcuts
+   * @returns {Promise<{success: boolean, message: string}>}
+   */
+  async attemptKeyboardConfiguration() {
+    console.log('[OPENCODE CHECK] Attempting keyboard-based configuration...');
+    
+    return new Promise((resolve) => {
+      // Try to use expect or node-pty to send keyboard shortcuts
+      let pty;
+      try {
+        pty = require('node-pty');
+      } catch (error) {
+        console.log('[OPENCODE CHECK] node-pty not available for keyboard automation');
+        resolve({ success: false, message: 'node-pty not available for keyboard automation' });
+        return;
+      }
+
+      const proc = pty.spawn('opencode', [], {
+        name: 'xterm-color',
+        cols: 120,
+        rows: 30,
+        cwd: process.cwd(),
+        env: process.env
+      });
+
+      let output = '';
+      let configured = false;
+
+      proc.on('data', (data) => {
+        output += data;
+        console.log('[OPENCODE CHECK] KEYBOARD STDOUT:', data.trim());
+        
+        // Wait for OpenCode to fully load
+        if (output.includes('OpenCode') && output.includes('press enter to send')) {
+          console.log('[OPENCODE CHECK] OpenCode ready, attempting model selection...');
+          
+          // Send ctrl+o to open model selection
+          proc.write('\x0f'); // ctrl+o
+          
+          setTimeout(() => {
+            // Try to select a working model by typing and entering
+            proc.write('Llama3_3_70BVersatile\r');
+            
+            setTimeout(() => {
+              // Try to send a test message
+              proc.write('1+1\r');
+              
+              setTimeout(() => {
+                if (output.includes('2') || output.includes('2\n')) {
+                  configured = true;
+                  console.log('[OPENCODE CHECK] ✓ Keyboard configuration successful');
+                }
+                
+                proc.write('\x03'); // ctrl+c to quit
+                setTimeout(() => proc.destroy(), 1000);
+              }, 3000);
+            }, 2000);
+          }, 1000);
+        }
+      });
+
+      proc.on('exit', () => {
+        resolve({ 
+          success: configured, 
+          message: configured ? 'Keyboard configuration successful' : 'Keyboard configuration failed - manual intervention required'
+        });
+      });
+
+      // Timeout after 15 seconds
+      setTimeout(() => {
+        if (!proc.destroyed) {
+          proc.destroy();
+          resolve({ 
+            success: false, 
+            message: 'Keyboard configuration timed out' 
+          });
+        }
+      }, 15000);
+    });
+  }
+
+  /**
+   * Attempt to automatically respond to LSP Configuration prompt
+   * @returns {Promise<{success: boolean, message: string}>}
+   */
+  async attemptLSPConfiguration() {
+    console.log('[OPENCODE CHECK] Attempting to bypass LSP Configuration...');
+    
+    return new Promise((resolve) => {
+      // Try to send a message to skip LSP configuration
+      const proc = spawn('opencode', ['-p', 'skip', '-q'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 15000
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        console.log('[OPENCODE CHECK] LSP-CONFIG STDOUT:', chunk.trim());
+      });
+
+      proc.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        console.log('[OPENCODE CHECK] LSP-CONFIG STDERR:', chunk.trim());
+      });
+
+      proc.on('close', (code) => {
+        const output = stdout + stderr;
+        console.log(`[OPENCODE CHECK] LSP config process exited with code: ${code}`);
+        
+        // If we get a successful response or it moves past the LSP config
+        if (code === 0 && !output.includes('LSP Configuration')) {
+          console.log('[OPENCODE CHECK] ✓ LSP Configuration bypassed');
+          resolve({ success: true, message: 'LSP Configuration bypassed successfully' });
+        } else {
+          console.log('[OPENCODE CHECK] ✗ LSP Configuration still blocking');
+          resolve({ success: false, message: 'LSP Configuration still requires manual intervention' });
+        }
+      });
+
+      proc.on('error', (error) => {
+        console.log(`[OPENCODE CHECK] LSP config error: ${error.message}`);
+        resolve({ success: false, message: `LSP config error: ${error.message}` });
+      });
+    });
+  }
+
+  /**
+   * Test if OpenCode interactive mode works (to detect configuration mismatch)
+   * @returns {Promise<{interactiveWorks: boolean, error?: string}>}
+   */
+  async testInteractiveMode() {
+    console.log('[OPENCODE CHECK] Testing interactive mode vs non-interactive mode...');
+    
+    return new Promise((resolve) => {
+      const proc = spawn('opencode', ['-d'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 5000
+      });
+
+      let stdout = '';
+      let stderr = '';
+      let interactiveReady = false;
+
+      proc.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        console.log('[OPENCODE CHECK] INTERACTIVE STDOUT:', chunk.trim());
+        
+        // Check if interactive mode loads successfully and has the correct model
+        if (stdout.includes('OpenCode') && (stdout.includes('press enter to send') || stdout.includes('ctrl+? help'))) {
+          interactiveReady = true;
+          console.log('[OPENCODE CHECK] ✓ Interactive mode ready');
+          if (stdout.includes('Llama3_3_70BVersatile')) {
+            console.log('[OPENCODE CHECK] ✓ Correct model detected in interactive mode');
+          }
+          proc.kill('SIGTERM');
+        }
+      });
+
+      proc.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        console.log('[OPENCODE CHECK] INTERACTIVE STDERR:', chunk.trim());
+      });
+
+      const timeout = setTimeout(() => {
+        proc.kill('SIGTERM');
+      }, 4000);
+
+      proc.on('close', (code) => {
+        clearTimeout(timeout);
+        
+        if (interactiveReady) {
+          resolve({ interactiveWorks: true });
+        } else {
+          resolve({ 
+            interactiveWorks: false, 
+            error: 'Interactive mode failed to load properly' 
+          });
+        }
+      });
+
+      proc.on('error', (error) => {
+        clearTimeout(timeout);
+        resolve({ 
+          interactiveWorks: false, 
+          error: `Failed to start interactive mode: ${error.message}` 
+        });
+      });
+    });
+  }
+
+  /**
+   * Attempt to run OpenCode in interactive mode and detect configuration prompts
+   * @returns {Promise<{success: boolean, configured: boolean, error?: string}>}
+   */
+  async attemptAutoConfiguration() {
+    console.log('[OPENCODE CHECK] Attempting to detect auto-configuration prompts...');
+    
+    return new Promise((resolve) => {
+      const proc = spawn('opencode', ['-d'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000
+      });
+
+      let stdout = '';
+      let stderr = '';
+      let detectedPrompt = false;
+
+      proc.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        console.log('[OPENCODE CHECK] AUTO-CONFIG STDOUT:', chunk.trim());
+        
+        // Detect common configuration prompts
+        if (stdout.includes('Select a model') || 
+            stdout.includes('Choose a provider') ||
+            stdout.includes('API key') ||
+            stdout.includes('Configure') ||
+            stdout.includes('LSP Configuration')) {
+          detectedPrompt = true;
+          console.log('[OPENCODE CHECK] ⚠ Configuration prompt detected');
+        }
+      });
+
+      proc.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        console.log('[OPENCODE CHECK] AUTO-CONFIG STDERR:', chunk.trim());
+      });
+
+      // Kill the process after timeout or when prompt is detected
+      const timeout = setTimeout(() => {
+        console.log('[OPENCODE CHECK] Timeout reached, killing process...');
+        proc.kill('SIGTERM');
+      }, 8000);
+
+      proc.on('close', (code) => {
+        clearTimeout(timeout);
+        
+        if (detectedPrompt) {
+          resolve({ 
+            success: false, 
+            configured: false,
+            error: 'OpenCode is waiting for initial configuration. Please run `opencode` interactively to complete setup.',
+            needsManualConfig: true
+          });
+        } else if (stdout.includes('Error') || stderr.includes('Error')) {
+          resolve({ 
+            success: false, 
+            configured: false,
+            error: 'OpenCode configuration error detected'
+          });
+        } else {
+          resolve({ 
+            success: true, 
+            configured: true
+          });
+        }
+      });
+
+      proc.on('error', (error) => {
+        clearTimeout(timeout);
+        resolve({ 
+          success: false, 
+          configured: false,
+          error: `Failed to start OpenCode: ${error.message}` 
+        });
+      });
+    });
+  }
+
+  /**
+   * Run the complete OpenCode check flow
+   * @returns {Promise<{status: string, message: string, checkedAt: string}>}
+   */
+  async check() {
+    const checkedAt = new Date().toISOString();
+
+    // 1. Check if OpenCode is available
+    if (!this.isAvailable()) {
+      return {
+        status: 'error',
+        message: 'OpenCode CLI not installed. Install from https://opencode.ai',
+        checkedAt
+      };
+    }
+
+    // 2. Try ping test first
+    const pingResult = await this.pingTest();
+    if (pingResult.responsive) {
+      return {
+        status: 'success',
+        message: 'OpenCode is responsive and configured',
+        checkedAt
+      };
+    }
+
+    // 3. If ping failed due to configuration, try to create basic config
+    if (pingResult.needsConfig) {
+      console.log('🔧 OpenCode needs configuration, attempting to setup...');
+      
+      const configResult = await this.createBasicConfig();
+      if (configResult.success) {
+        // Create config override string
+        const availableProviders = this.detectAvailableProviders();
+        const model = this.selectWorkingModel(availableProviders);
+        const configOverride = JSON.stringify({
+          "$schema": "https://opencode.ai/config.json",
+          "model": model,
+          "autoupdate": false,
+          "server": { "port": 4096 }
+        });
+        
+        console.log('[OPENCODE CHECK] Trying with config override...');
+        const retryPing = await this.pingTest(configOverride);
+        if (retryPing.responsive) {
+          return {
+            status: 'success',
+            message: 'OpenCode configured and responsive (with config override)',
+            checkedAt
+          };
+        } else if (retryPing.needsConfig) {
+          // Still needs config - provide specific guidance based on what we know
+          console.log('🔧 Non-interactive mode has max_tokens issues, but interactive mode may work...');
+          
+          return {
+            status: 'error',
+            message: 'OpenCode has max_tokens configuration issues with the selected Groq model. Both interactive and non-interactive modes are affected. Please try: 1) Select a different model with Ctrl+o, 2) Check your GROQ_API_KEY quota, 3) Update OpenCode, or 4) Use a different provider.',
+            checkedAt
+          };
+        } else {
+          // Configuration created but still not working
+          return {
+            status: 'error',
+            message: `OpenCode configured but still not responding: ${retryPing.error}`,
+            checkedAt
+          };
+        }
+      } else {
+        return {
+          status: 'error',
+          message: `Failed to configure OpenCode: ${configResult.error}`,
+          checkedAt
+        };
+      }
+    }
+
+    // 4. If we get here, try to detect if it's stuck in initial setup
+    const autoConfigResult = await this.attemptAutoConfiguration();
+    if (autoConfigResult.needsManualConfig) {
+      return {
+        status: 'error',
+        message: 'OpenCode requires manual configuration. Interactive mode works but non-interactive mode has max_tokens issues. Please run "opencode" interactively to complete setup, then try the agent check again.',
+        checkedAt
+      };
+    }
+
+    // 5. Generic failure
+    return {
+      status: 'error',
+      message: pingResult.error || 'OpenCode check failed',
+      checkedAt
+    };
+  }
+}
+
+module.exports = {
+  OpenCodeChecker
+};

package/src/utils/provider-checker/provider-validator.js

@@ -77,9 +77,67 @@ async function checkProvider(providerId, config = {}, repoPath, onProgress = nul
 
   const resultFile = getResultFilePath(repoPath);
 
+  // Special handling: VS Code Copilot CLI is often installed but not authenticated.
+  // Detect that case explicitly so the UI can prompt for configuration instead of showing rate limit.
+  if (providerId === 'vscode-copilot-cli') {
+    try {
+      if (onProgress) onProgress(providerId, 'configuring', null, 'Checking configuration...');
+      const DirectLLMManager = require('vibecodingmachine-core/src/llm/direct-llm-manager.cjs');
+      const mgr = new DirectLLMManager();
+      const availability = await mgr.isVSCodeCopilotCLIAvailable();
+
+      if (!availability || !availability.available) {
+        return {
+          status: 'error',
+          message: `${def.name} is not installed or not in PATH. Install GitHub Copilot CLI and try again.`,
+          checkedAt: new Date().toISOString(),
+          requirementLeftPending: false,
+          needsConfiguration: true
+        };
+      }
+
+      if (availability.needsAuth) {
+        return {
+          status: 'error',
+          message: `${def.name} is installed but not authenticated. Run 'copilot login' (or authenticate GitHub CLI and restart) then try again.`,
+          checkedAt: new Date().toISOString(),
+          requirementLeftPending: false,
+          needsConfiguration: true
+        };
+      }
+
+      // Check if rate limited
+      if (availability.rateLimited) {
+        return {
+          status: 'error',
+          message: `${def.name} is rate limited. Quota reset should happen soon.`,
+          checkedAt: new Date().toISOString(),
+          requirementLeftPending: false,
+          rateLimited: true
+        };
+      }
+
+      // Copilot CLI is available and authenticated - return success immediately
+      return {
+        status: 'success',
+        message: `${def.name} is working correctly (tested with copilot -p "Reply with OK" -s --no-ask-user)`,
+        checkedAt: new Date().toISOString(),
+        requirementLeftPending: false
+      };
+    } catch (err) {
+      return {
+        status: 'error',
+        message: `${def.name} configuration check failed: ${err.message}`,
+        checkedAt: new Date().toISOString(),
+        requirementLeftPending: false,
+        needsConfiguration: true
+      };
+    }
+  }
+
   // Ensure the config has repoPath set for the child process
   try {
-    const { getRepoPath, setRepoPath } = require('./config');
+    const { getRepoPath, setRepoPath } = require('../config');
     const currentRepoPath = await getRepoPath();
     if (currentRepoPath !== repoPath) {
       console.log(`[AGENT CHECK] Setting main config repoPath to: ${repoPath}`);
@@ -96,11 +154,38 @@ async function checkProvider(providerId, config = {}, repoPath, onProgress = nul
   // For direct CLI providers: auto-install if missing
   const cliInfo = CLI_AUTO_INSTALL[providerId];
   if (cliInfo && !isCLIAvailable(cliInfo.cmd, providerId)) {
-    if (onProgress) onProgress(providerId, 'installing');
+    if (onProgress) {
+      onProgress(providerId, 'installing');
+    }
+
     const { installed, note } = await installCLI(providerId);
     if (!installed) {
       return { status: 'error', message: `${def.name} not installed and auto-install failed: ${note}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
     }
+    
+    if (onProgress) {
+      onProgress(providerId, 'installing', null, 'Installation complete, configuring...');
+    }
+  }
+
+  // Special handling for OpenCode - use specialized checker
+  if (providerId === 'opencode') {
+    const { OpenCodeChecker } = require('./opencode-checker');
+    const checker = new OpenCodeChecker();
+    const result = await checker.check();
+    
+    if (result.status === 'success') {
+      // OpenCode is responsive, create the result file to indicate success
+      try {
+        fs.writeFileSync(resultFile, 'VCM_CHECK_OK', 'utf8');
+      } catch (err) {
+        console.warn(`[AGENT CHECK] Could not write result file: ${err.message}`);
+      }
+      return { ...result, requirementLeftPending: false };
+    } else {
+      // OpenCode failed - leave requirement pending for other agents
+      return { ...result, requirementLeftPending: true };
+    }
   }
 
   // Add test requirement (idempotent — safe to call even if already present from a prior failed agent)
@@ -137,7 +222,7 @@ async function checkAllProviders(providerIds, config = {}, repoPath, onProgress
     if (signal && signal.cancelled) break;
     if (onProgress) onProgress(id, 'checking');
     results[id] = await checkProvider(id, config, repoPath, onProgress, signal);
-    if (onProgress) onProgress(id, 'done', results[id]);
+    if (onProgress) onProgress(id, 'done', results[id].status === 'error' ? results[id].message : null);
   }
 
   // Final cleanup — remove requirement if still pending (all agents failed or skipped)