vibecodingmachine-cli 2026.3.9-850 → 2026.3.10-1547

package/src/utils/prompt-helper.js

@@ -1,64 +1,64 @@
-const inquirer = require('inquirer');
-const chalk = require('chalk');
-
-/**
- * Enhanced inquirer.prompt that shows a helpful hint for questions with defaults
- * @param {Array} questions - Array of inquirer question objects
- * @param {Object} options - Options object
- * @param {boolean} options.showDefaultHint - Whether to show the default hint (default: true)
- * @returns {Promise} - Promise resolving to answers
- */
-async function promptWithDefaults(questions, options = {}) {
-  const { showDefaultHint = true } = options;
-  
-  // Check if any questions have defaults and if we should show the hint
-  const hasDefaults = questions.some(q => q.default !== undefined);
-  
-  if (showDefaultHint && hasDefaults) {
-    // Show the hint in gray before the first question with a default
-    console.log(chalk.gray('(Capital letters are defaults--press return to select the defaults)'));
-  }
-  
-  return await inquirer.prompt(questions);
-}
-
-/**
- * Track whether we've shown the default hint in this session
- * This ensures we only show it once per CLI session
- */
-let hasShownDefaultHint = false;
-
-/**
- * Enhanced inquirer.prompt that shows the default hint only once per session
- * @param {Array} questions - Array of inquirer question objects
- * @param {Object} options - Options object
- * @param {boolean} options.forceShowHint - Force showing the hint even if already shown
- * @returns {Promise} - Promise resolving to answers
- */
-async function promptWithDefaultsOnce(questions, options = {}) {
-  const { forceShowHint = false } = options;
-  
-  // Check if any questions have defaults
-  const hasDefaults = questions.some(q => q.default !== undefined);
-  
-  if (hasDefaults && (!hasShownDefaultHint || forceShowHint)) {
-    // Show the hint in gray before the first question with a default
-    console.log(chalk.gray('(Capital letters are defaults--press return to select the defaults)'));
-    hasShownDefaultHint = true;
-  }
-  
-  return await inquirer.prompt(questions);
-}
-
-/**
- * Reset the hint tracking (useful for testing or new sessions)
- */
-function resetDefaultHint() {
-  hasShownDefaultHint = false;
-}
-
-module.exports = {
-  promptWithDefaults,
-  promptWithDefaultsOnce,
-  resetDefaultHint
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+/**
+ * Enhanced inquirer.prompt that shows a helpful hint for questions with defaults
+ * @param {Array} questions - Array of inquirer question objects
+ * @param {Object} options - Options object
+ * @param {boolean} options.showDefaultHint - Whether to show the default hint (default: true)
+ * @returns {Promise} - Promise resolving to answers
+ */
+async function promptWithDefaults(questions, options = {}) {
+  const { showDefaultHint = true } = options;
+  
+  // Check if any questions have defaults and if we should show the hint
+  const hasDefaults = questions.some(q => q.default !== undefined);
+  
+  if (showDefaultHint && hasDefaults) {
+    // Show the hint in gray before the first question with a default
+    console.log(chalk.gray('(Capital letters are defaults--press return to select the defaults)'));
+  }
+  
+  return await inquirer.prompt(questions);
+}
+
+/**
+ * Track whether we've shown the default hint in this session
+ * This ensures we only show it once per CLI session
+ */
+let hasShownDefaultHint = false;
+
+/**
+ * Enhanced inquirer.prompt that shows the default hint only once per session
+ * @param {Array} questions - Array of inquirer question objects
+ * @param {Object} options - Options object
+ * @param {boolean} options.forceShowHint - Force showing the hint even if already shown
+ * @returns {Promise} - Promise resolving to answers
+ */
+async function promptWithDefaultsOnce(questions, options = {}) {
+  const { forceShowHint = false } = options;
+  
+  // Check if any questions have defaults
+  const hasDefaults = questions.some(q => q.default !== undefined);
+  
+  if (hasDefaults && (!hasShownDefaultHint || forceShowHint)) {
+    // Show the hint in gray before the first question with a default
+    console.log(chalk.gray('(Capital letters are defaults--press return to select the defaults)'));
+    hasShownDefaultHint = true;
+  }
+  
+  return await inquirer.prompt(questions);
+}
+
+/**
+ * Reset the hint tracking (useful for testing or new sessions)
+ */
+function resetDefaultHint() {
+  hasShownDefaultHint = false;
+}
+
+module.exports = {
+  promptWithDefaults,
+  promptWithDefaultsOnce,
+  resetDefaultHint
 };

package/src/utils/provider-checker/agent-runner.js

@@ -7,7 +7,7 @@ const chokidar = require('chokidar');
 
 const { NODE_EXECUTABLE } = require('./node-detector');
 const { IDE_INFO, isIDERunning, openIDEApp } = require('./ide-manager');
-const { getResultFilePath } = require('./requirements-manager');
+const { getResultFilePath, addTestRequirement, removeTestRequirement } = require('./requirements-manager');
 
 // Timeout for direct LLM round-trips via auto:direct (ms)
 const DIRECT_TIMEOUT_MS = 60000;
@@ -15,6 +15,7 @@ const DIRECT_TIMEOUT_MS = 60000;
 const IDE_TIMEOUT_MS = 90000;
 
 const CLI_ENTRY_POINT = path.resolve(path.join(__dirname, '../../../bin/vibecodingmachine.js'));
+const TEST_REQ_TITLE = 'VCM agent connectivity check';
 
 /**
  * Run an agent for 1 iteration and watch for the result file to be written.
@@ -33,6 +34,11 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
   // Remove stale result file so we detect a fresh write
   try { fs.unlinkSync(resultFile); } catch { }
 
+  // Calculate requirements path early so it's available in the Promise scope
+  const os = require('os');
+  const hostname = os.hostname();
+  const requirementsPath = path.join(repoPath, `REQUIREMENTS-${hostname}.md`);
+
   // For IDE providers: verify the IDE is running/installed, install if needed
   let ideLaunchNote = '';
   if (def.type === 'ide') {
@@ -116,24 +122,24 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
             }
           }
 
-          // IDE is now installed (either was already or we just installed it) - launch it
-          if (checkResult.installed && checkResult.path) {
-            try {
-              const exePath = checkResult.path;
-              const repoArg = repoPath ? ` "${repoPath}"` : '';
-              const { execSync } = require('child_process');
-              execSync(`start "" "${exePath}"${repoArg}`, {
-                stdio: 'ignore',
-                windowsHide: true,
-                timeout: 10000,
-                shell: true
-              });
-              ideLaunchNote = ideLaunchNote || ` (VCM launched ${info.app})`;
-              // Give IDE time to start
-              await new Promise(r => setTimeout(r, 5000));
-            } catch (launchError) {
-              // Launch failed but IDE is installed - continue anyway
-              console.warn(`[AGENT CHECK] Could not launch ${info.app}, continuing...`);
+          // IDE is now installed (either was already or we just installed it) - launch it if not already running
+          if (checkResult.installed) {
+            // Check if IDE is already running before attempting to launch
+            const isRunning = isIDERunning(info.process);
+            if (!isRunning) {
+              console.log(`🪟 [AGENT CHECK] ${info.app} not running, attempting to launch...`);
+              // Use openIDEApp which will use WindowsAutomationManager
+              const launchSuccess = await openIDEApp(info.app, repoPath);
+              if (launchSuccess) {
+                ideLaunchNote = ideLaunchNote || ` (VCM launched ${info.app})`;
+                console.log(`🪟 [AGENT CHECK] Successfully launched ${info.app}`);
+              } else {
+                console.warn(`🪟 [AGENT CHECK] Could not launch ${info.app}, continuing anyway...`);
+              }
+            } else {
+              console.log(`[AGENT CHECK] ${info.app} is already running, skipping launch`);
+              // Give running IDE a moment to be ready
+              await new Promise(r => setTimeout(r, 2000));
             }
           }
         }
@@ -145,14 +151,26 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
     let resolved = false;
     let child = null;
     let output = '';
+    let watcher;
+    let requirementsWatcher;
 
     async function done(result) {
       if (resolved) return;
       resolved = true;
-      try { watcher.close(); } catch { }
+      try { if (watcher) watcher.close(); } catch { }
+      try { if (requirementsWatcher) requirementsWatcher.close(); } catch { }
       clearTimeout(timeout);
       clearInterval(cancelCheckInterval);
       try { if (child) child.kill(); } catch { }
+
+      // Remove test requirement after check completes (pass or fail)
+      try {
+        removeTestRequirement(requirementsPath);
+        console.log(`[AGENT CHECK] Removed test requirement from ${requirementsPath}`);
+      } catch (err) {
+        console.warn(`[AGENT CHECK] Could not remove test requirement: ${err.message}`);
+      }
+
       resolve(result);
     }
 
@@ -168,10 +186,27 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       }
     }
 
-    const watcher = chokidar.watch(resultFile, { persistent: true, ignoreInitial: false, disableGlobbing: true });
+    // Watch for result file creation
+    watcher = chokidar.watch(resultFile, { persistent: true, ignoreInitial: false, disableGlobbing: true });
     watcher.on('add', checkResult);
     watcher.on('change', checkResult);
 
+    // Also watch requirements file for status changes to [DONE]
+    requirementsWatcher = chokidar.watch(requirementsPath, { persistent: true, ignoreInitial: true });
+    requirementsWatcher.on('change', () => {
+      try {
+        const content = fs.readFileSync(requirementsPath, 'utf8');
+        // Check if test requirement status is [DONE]
+        if (content.includes(TEST_REQ_TITLE) && content.match(/VCM agent connectivity check[\s\S]*?Status:.*?\[DONE\]/)) {
+          console.log(`[AGENT CHECK] Detected [DONE] status in requirements file for ${providerId}`);
+          if (onProgress) onProgress(providerId, 'response_detected', null, 'Status updated to DONE.');
+          done({ status: 'success', message: 'Agent updated status to DONE', checkedAt });
+        }
+      } catch (err) {
+        console.warn(`[AGENT CHECK] Error reading requirements file: ${err.message}`);
+      }
+    });
+
     const timeout = setTimeout(() => {
       // Diagnose: is the IDE process still running?
       let diagnosis = '';
@@ -212,7 +247,7 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
 
     let args;
     if (def.type === 'ide') {
-      args = [CLI_ENTRY_POINT, 'auto:start', '--ide', def.ide || providerId, '--max-chats', '1'];
+      args = [CLI_ENTRY_POINT, 'auto:start', '--ide', def.ide || providerId, '--max-chats', '5'];
       if (def.defaultModel) args.push('--ide-model', String(def.defaultModel));
       if (def.extension) args.push('--extension', String(def.extension));
     } else {
@@ -257,9 +292,23 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
     console.log(`[AGENT CHECK] CWD: ${repoPath}`);
     console.log(`[AGENT CHECK] Result file: ${resultFile}`);
 
+    // Add test requirement to REQUIREMENTS-<hostname>.md
+    // This tells the IDE agent to respond, and will be deleted after check completes
+    // (requirementsPath already calculated at function start)
+    console.log(`[AGENT CHECK] Using requirements file: ${requirementsPath}`);
+    try {
+      addTestRequirement(requirementsPath, resultFile);
+      console.log(`[AGENT CHECK] Added test requirement to ${requirementsPath}`);
+    } catch (err) {
+      console.warn(`[AGENT CHECK] Could not add test requirement: ${err.message}`);
+    }
+
     // Prepare environment - inherit all process.env and add NODE_PATH if needed
     const spawnEnv = {
       ...process.env,
+      // Set IDE check mode flag so auto-execution knows to use --ide option instead of configured providers
+      VCM_IDE_CHECK_MODE: 'true',
+      VCM_SKIP_AUTH: 'true',
       // Ensure NODE_PATH includes the monorepo node_modules if it exists
       NODE_PATH: [
         path.join(__dirname, '../../node_modules'),
@@ -268,6 +317,13 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       ].filter(Boolean).join(path.delimiter)
     };
 
+    // Log the command being executed
+    console.log(`[AGENT CHECK] Starting check for ${providerId}`);
+    console.log(`[AGENT CHECK] Node Executable: ${NODE_EXECUTABLE}`);
+    console.log(`[AGENT CHECK] Args: ${args.join(' ')}`);
+    console.log(`[AGENT CHECK] CWD: ${repoPath}`);
+    console.log(`[AGENT CHECK] Result file: ${resultFile}`);
+
     child = spawn(NODE_EXECUTABLE, args, {
       cwd: repoPath,
       env: spawnEnv,
@@ -301,6 +357,21 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       if (resolved) return;
       console.log(`[AGENT CHECK] ${providerId} process exited with code ${code}`);
       console.log(`[AGENT CHECK] ${providerId} process output: ${output.slice(-500)}`);
+
+      // Additional debugging for Windsurf authentication issues
+      if (providerId === 'windsurf' && code === 8) {
+        console.log(`[AGENT CHECK] Windsurf specific debugging - code 8 often indicates authentication or startup issues`);
+        console.log(`[AGENT CHECK] Windsurf output analysis:`, output.split('\n').slice(-10));
+      }
+
+      // Check for DONE status in output (indicates successful completion)
+      if (code === 0 && output.includes('Status: ✅ DONE') && output.includes('Requirement complete')) {
+        console.log(`[AGENT CHECK] Detected successful completion in output for ${providerId}`);
+        if (onProgress) onProgress(providerId, 'response_detected', null, 'Auto mode completed successfully.');
+        done({ status: 'success', message: 'Agent completed requirement successfully', checkedAt });
+        return;
+      }
+
       // Check one more time after process exits
       checkResult();
       if (!resolved) {
@@ -382,29 +453,37 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
           return;
         }
 
-        debugLog(`No quota keywords in process output or message, checking AppleScript UI as fallback for ${providerId}`);
+        debugLog(`No quota keywords in process output or message, checking platform-specific UI fallback for ${providerId}`);
 
-        // Then check AppleScript UI scraping as fallback for IDEs that support it
+        // Get quota manager based on platform
+        let quotaManager = null;
         if (process.platform === 'darwin') {
+          const { AppleScriptManager } = require('vibecodingmachine-core');
+          quotaManager = new AppleScriptManager();
+        } else if (process.platform === 'win32') {
+          const { WindowsAutomationManager } = require('vibecodingmachine-core');
+          quotaManager = new WindowsAutomationManager();
+        }
+
+        // Check platform-specific UI scraping as fallback for IDEs that support it
+        if (quotaManager) {
           try {
-            const { AppleScriptManager } = require('vibecodingmachine-core');
-            const appleScriptManager = new AppleScriptManager();
             let quotaCheck = null;
 
             // Use specific quota detection methods for each IDE
             switch (providerId) {
               case 'antigravity':
-                quotaCheck = await appleScriptManager.checkAntigravityQuotaLimit();
+                quotaCheck = await quotaManager.checkAntigravityQuotaLimit();
                 break;
               case 'windsurf':
-                quotaCheck = await appleScriptManager.checkWindsurfQuotaLimit();
+                quotaCheck = await quotaManager.checkWindsurfQuotaLimit();
                 break;
               case 'cursor':
-                quotaCheck = await appleScriptManager.checkCursorQuotaLimit();
+                quotaCheck = await quotaManager.checkCursorQuotaLimit();
                 break;
               case 'github-copilot':
                 // GitHub Copilot uses the same detection as Cursor (both are VS Code extensions)
-                quotaCheck = await appleScriptManager.checkCursorQuotaLimit();
+                quotaCheck = await quotaManager.checkCursorQuotaLimit();
                 break;
               default:
                 debugLog(`No specific quota detection method available for ${providerId}`);
@@ -414,7 +493,7 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
             debugLog(`${providerId} quota check result: ` + JSON.stringify(quotaCheck));
 
             if (quotaCheck && (quotaCheck.isRateLimited || quotaCheck.hasQuotaWarning)) {
-              debugLog(`🚨 ${providerId} quota limit detected via AppleScript`);
+              debugLog(`🚨 ${providerId} quota limit detected via platform UI check`);
               errorResult.rateLimited = true;
               errorResult.rateLimitMessage = quotaCheck.message || quotaCheck.matchedText || `${providerId} quota limit detected`;
               if (quotaCheck.resumeAt) {

package/src/utils/provider-checker/ide-manager.js

@@ -49,18 +49,47 @@ function isIDERunning(processName) {
 }
 
 /**
- * Open the IDE using `open -a <app> <repoPath>` (macOS).
+ * Open the IDE using `open -a <app> <repoPath>` (macOS) or Windows automation manager.
  * Returns true when the launch command was sent.
  */
 async function openIDEApp(appName, repoPath) {
-  if (!appName || process.platform !== 'darwin') return false;
+  if (!appName) return false;
+
   try {
-    const safeRepo = repoPath ? ` "${repoPath.replace(/"/g, '\\"')}"` : '';
-    execSync(`open -a "${appName}"${safeRepo}`, { stdio: 'ignore' });
-    // Give it a few seconds to start before the automation begins
-    await new Promise(r => setTimeout(r, 5000));
-    return true;
-  } catch {
+    if (process.platform === 'darwin') {
+      // macOS: use `open -a`
+      const safeRepo = repoPath ? ` "${repoPath.replace(/"/g, '\\"')}"` : '';
+      execSync(`open -a "${appName}"${safeRepo}`, { stdio: 'ignore' });
+      // Give it a few seconds to start before the automation begins
+      await new Promise(r => setTimeout(r, 5000));
+      return true;
+    } else if (process.platform === 'win32') {
+      // Windows: use WindowsAutomationManager
+      console.log(`🪟 [IDE MANAGER] Opening ${appName} on Windows...`);
+      const { WindowsAutomationManager } = require('vibecodingmachine-core');
+      const manager = new WindowsAutomationManager();
+
+      // Map app name to the appropriate method
+      let result;
+      if (appName === 'Windsurf') {
+        console.log('🪟 [IDE MANAGER] Calling openWindsurf()...');
+        result = await manager.openWindsurf(repoPath);
+      } else if (appName === 'Cursor') {
+        console.log('🪟 [IDE MANAGER] Calling openCursorNative()...');
+        result = await manager.openCursorNative(repoPath);
+      } else {
+        console.log(`🪟 [IDE MANAGER] No Windows opener for ${appName}`);
+        return false;
+      }
+
+      console.log('🪟 [IDE MANAGER] Result:', result);
+      return result && result.success;
+    }
+
+    // Other platforms: not supported
+    return false;
+  } catch (error) {
+    console.error(`❌ [IDE MANAGER] Error opening ${appName}:`, error.message);
     return false;
   }
 }

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

@@ -188,11 +188,61 @@ async function checkProvider(providerId, config = {}, repoPath, onProgress = nul
     }
   }
 
+  // Special handling for IDE providers - only check configuration for those that need it
+  if (def.type === 'ide') {
+    // Check if this IDE provider requires special configuration
+    try {
+      const { getProviderDefinition } = require('../provider-registry');
+      const providerDef = getProviderDefinition(providerId);
+      
+      // Only check configuration if the provider has configKeys defined
+      if (providerDef && providerDef.configKeys) {
+        const { getAutoConfig } = require('../config');
+        const autoConfig = getAutoConfig();
+        
+        // Check if all required config keys are available
+        const hasRequiredConfig = Object.entries(providerDef.configKeys).every(([configKey]) => {
+          return autoConfig && autoConfig[configKey];
+        });
+        
+        if (!hasRequiredConfig) {
+          let configMessage = `${def.name} is installed but CLI is not configured for automation. `;
+          
+          // Generate specific config instructions based on configKeys
+          const configInstructions = Object.keys(providerDef.configKeys).map(key => {
+            const envVar = key.toUpperCase();
+            return `Set ${envVar} or run "vcm auto:config".`;
+          }).join(' ');
+          
+          configMessage += configInstructions;
+          
+          return {
+            status: 'error',
+            message: configMessage,
+            checkedAt: new Date().toISOString(),
+            requirementLeftPending: false,
+            needsConfiguration: true
+          };
+        }
+      }
+      
+      // If no configKeys are defined (like Windsurf), assume no special configuration needed
+      console.log(`[AGENT CHECK] ${def.name} requires no special configuration`);
+      
+    } catch (configError) {
+      console.warn(`[AGENT CHECK] Could not check provider configuration: ${configError.message}`);
+      // Continue with automation check even if configuration check fails
+    }
+  }
+
   // Add test requirement (idempotent — safe to call even if already present from a prior failed agent)
   try { addTestRequirement(reqPath, resultFile); } catch (err) {
     return { status: 'error', message: `Could not write to REQUIREMENTS.md: ${err.message}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
   }
 
+  // IDE providers generally don't need CLI system configuration to work
+  // They can communicate directly with the IDE without requiring VCM CLI setup
+
   const { DIRECT_TIMEOUT_MS, IDE_TIMEOUT_MS } = require('./agent-runner');
   const timeoutMs = def.type === 'ide' ? IDE_TIMEOUT_MS : DIRECT_TIMEOUT_MS;
   const result = await runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, signal, onProgress);

package/src/utils/provider-checker/requirements-manager.js

@@ -5,6 +5,7 @@ const path = require('path');
 
 const TEST_REQ_TITLE = 'VCM agent connectivity check';
 const PENDING_HEADER = '## ⏳ Requirements not yet completed';
+const IN_PROGRESS_HEADER = '## 🔨 Current In Progress Requirement';
 const VERIFIED_HEADER = '## ✅ Verified by AI';
 
 /**
@@ -15,7 +16,8 @@ function getResultFilePath(repoPath) {
 }
 
 /**
- * Add the test requirement at the TOP of the pending section.
+ * Add the test requirement as the FIRST item in the pending section.
+ * The first item in the "Requirements not yet completed" section is the current in-progress item.
  * Idempotent — if it's already there, do nothing.
  */
 function addTestRequirement(reqPath, resultFile) {
@@ -25,11 +27,24 @@ function addTestRequirement(reqPath, resultFile) {
   // Already present?
   if (content.includes(TEST_REQ_TITLE)) return;
 
-  const testBlock = `### 1. ${TEST_REQ_TITLE}
-🚦 Current Status: PREPARE
-Create a new file at the following absolute path: ${resultFile}
-The file must contain exactly this text on the first line: VCM_CHECK_OK
-Do not modify any other files. This is an automated connectivity test.
+  const testBlock = `- ${TEST_REQ_TITLE}
+🚦 Current Status: [PREPARE]
+
+**AUTOMATED CONNECTIVITY TEST - Please read and acknowledge:**
+
+This is a simple test to verify VCM can communicate with your IDE.
+
+**To complete this test, update the status above to [DONE]:**
+- Change \`🚦 Current Status: [PREPARE]\` to \`🚦 Current Status: [DONE]\`
+
+That's it! VCM will detect the status change and mark the connectivity test as successful.
+
+**Alternative (if you want to create a file):**
+1. Create file: \`${resultFile}\`
+2. Write: \`VCM_CHECK_OK\`
+3. Save
+
+Either method works - status update is simplest.
 
 `;