vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1956

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

@@ -6,13 +6,17 @@ const path = require('path');
 const chokidar = require('chokidar');
 
 const { NODE_EXECUTABLE } = require('./node-detector');
-const { IDE_INFO, isIDERunning, openIDEApp } = require('./ide-manager');
+const { IDE_INFO, isIDERunning } = require('./ide-manager');
 const { getResultFilePath, getAgentsFilePath, updateAgentStatus, getAgentStatus } = require('./agents-manager');
+const { startVSCodeApprovalClicker } = require('./vscode-approval-clicker');
+const { startCursorApprovalClicker } = require('./cursor-approval-clicker');
+const { checkIDEQuotaLimitAndDone } = require('./ide-quota-checker');
+const { ensureIDEReady } = require('./ide-installer-helper');
 
 // Timeout for direct LLM round-trips via auto:direct (ms)
 const DIRECT_TIMEOUT_MS = 60000;
-// Timeout for IDE automation round-trips via auto:start (ms)
-const IDE_TIMEOUT_MS = 90000;
+// Timeout for IDE automation round-trips — AI needs time to receive, process, and edit agents.json
+const IDE_TIMEOUT_MS = 360000;
 
 const CLI_ENTRY_POINT = path.resolve(path.join(__dirname, '../../../bin/vibecodingmachine.js'));
 
@@ -30,113 +34,21 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
 
   // Ensure temp dir exists
   fs.mkdirSync(path.dirname(resultFile), { recursive: true });
-  // Remove stale result file so we detect a fresh write
+  // Remove stale result files so we detect a fresh write
   try { fs.unlinkSync(resultFile); } catch { }
+  const _homeResultFile = path.join(require('os').homedir(), '.vibecodingmachine', 'temp', 'TEMP_agent_check.txt');
+  try { fs.mkdirSync(path.dirname(_homeResultFile), { recursive: true }); } catch { }
+  try { fs.unlinkSync(_homeResultFile); } catch { }
 
   // For IDE providers: verify the IDE is running/installed, install if needed
   let ideLaunchNote = '';
   if (def.type === 'ide') {
     const info = IDE_INFO[providerId] || IDE_INFO[def.ide] || null;
-    if (info && info.process) {
-      if (!isIDERunning(info.process)) {
-        // macOS: launch the app if not running
-        if (process.platform === 'darwin' && info.app) {
-          const launchSuccess = await openIDEApp(info.app, repoPath);
-          if (launchSuccess) {
-            ideLaunchNote = ` (VCM launched ${info.app})`;
-          } else {
-            // Failed to launch on macOS - check if installed
-            const { IDEInstaller } = require('../../../../electron-app/src/main/ide-installer');
-            const installer = new IDEInstaller();
-            const ideKey = def.ide || providerId;
-            const checkResult = await installer.checkIDEInstallation(ideKey);
-            if (!checkResult.installed) {
-              return {
-                status: 'error',
-                message: `${info.app} is not installed. Please download from ${IDEInstaller.IDE_CONFIG[ideKey]?.downloadBrowserUrl || 'its official website'}`,
-                checkedAt
-              };
-            }
-          }
-        }
-        // Windows: check if installed, install if possible, launch if installed
-        else if (process.platform === 'win32') {
-          const { IDEInstaller } = require('../../../../electron-app/src/main/ide-installer');
-          const installer = new IDEInstaller();
-          const ideKey = def.ide || providerId;
-          const ideConfig = IDEInstaller.IDE_CONFIG[ideKey];
-
-          // Check if IDE is installed
-          let checkResult = await installer.checkIDEInstallation(ideKey);
-
-          if (!checkResult.installed) {
-            // IDE is not installed - try to install if we have a download URL
-            const downloadUrl = ideConfig?.downloadUrl?.[process.platform];
-
-            if (downloadUrl) {
-              // Has a direct download URL - auto-install
-              console.log(`[AGENT CHECK] ${info.app || ideKey} not installed, installing...`);
-              if (onProgress) onProgress(providerId, 'installing');
-
-              try {
-                const installResult = await installer.installIDE(ideKey, (progress) => {
-                  console.log(`[AGENT CHECK] Installation progress for ${ideKey}: ${progress.progress}% - ${progress.message}`);
-                });
-
-                if (!installResult || !installResult.success) {
-                  console.error(`[AGENT CHECK] Installation failed for ${info.app || ideKey}`);
-                  return {
-                    status: 'error',
-                    message: `Failed to install ${info.app || ideKey}: ${installResult?.error || 'Installation failed'}. Please install manually and try again.`,
-                    checkedAt
-                  };
-                }
-
-                console.log(`[AGENT CHECK] ${info.app || ideKey} installed successfully`);
-                ideLaunchNote = ` (VCM installed ${info.app || ideKey})`;
-                // Re-check that installation succeeded
-                await new Promise(r => setTimeout(r, 3000));
-                checkResult = await installer.checkIDEInstallation(ideKey);
-              } catch (installError) {
-                console.error(`[AGENT CHECK] Installation error for ${info.app || ideKey}:`, installError.message);
-                return {
-                  status: 'error',
-                  message: `Installation failed for ${info.app || ideKey}: ${installError.message}. Please install manually and try again.`,
-                  checkedAt
-                };
-              }
-            } else {
-              // No direct download URL - provide browser download link
-              const browserUrl = ideConfig?.downloadBrowserUrl || `${ideKey}'s official website`;
-              return {
-                status: 'error',
-                message: `${info.app || ideKey} is not installed. Please download from: ${browserUrl}`,
-                checkedAt
-              };
-            }
-          }
-
-          // 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));
-            }
-          }
-        }
+    if (info && (info.process || info.appPath) && !isIDERunning(info.process, info.appPath)) {
+      const ideResult = await ensureIDEReady(providerId, def, repoPath, info, onProgress);
+      ideLaunchNote = ideResult.ideLaunchNote;
+      if (ideResult.error) {
+        return { status: 'error', message: ideResult.error, checkedAt };
       }
     }
   }
@@ -148,9 +60,13 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
     let watcher;
     let requirementsWatcher;
 
+    // Shared resolved-state object so clicker modules can check it
+    const resolvedRef = { resolved: false };
+
     async function done(result) {
       if (resolved) return;
       resolved = true;
+      resolvedRef.resolved = true;
       try { if (watcher) watcher.close(); } catch { }
       try { if (requirementsWatcher) requirementsWatcher.close(); } catch { }
       clearTimeout(timeout);
@@ -160,15 +76,14 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       // Update agent status based on result
       try {
         if (result.status === 'success') {
-          // Status already set to 'operational' by the IDE agent
           console.log(`[AGENT CHECK] ${providerId} check passed - status is 'operational'`);
         } else if (result.rateLimited) {
-          updateAgentStatus(providerId, 'rate_limited', {
+          await updateAgentStatus(providerId, 'rate_limited', {
             rateLimitResume: result.rateLimitResume
           });
           console.log(`[AGENT CHECK] Set ${providerId} status to 'rate_limited'`);
         } else {
-          updateAgentStatus(providerId, 'error', {
+          await updateAgentStatus(providerId, 'error', {
             error: result.message
           });
           console.log(`[AGENT CHECK] Set ${providerId} status to 'error'`);
@@ -177,7 +92,6 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
         console.warn(`[AGENT CHECK] Could not update agent status: ${err.message}`);
       }
 
-      // Notify UI that check is done
       if (onProgress) {
         const statusMessage = result.status === 'success'
           ? 'Check completed successfully'
@@ -188,68 +102,90 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       resolve(result);
     }
 
+    // Also watch home-dir fallback path (some IDEs resolve relative paths to ~ not repoPath)
+    const homeResultFile = path.join(require('os').homedir(), '.vibecodingmachine', 'temp', 'TEMP_agent_check.txt');
+
     function checkResult() {
-      if (!resolved && fs.existsSync(resultFile)) {
-        try {
-          const content = fs.readFileSync(resultFile, 'utf8');
-          if (content.includes('VCM_CHECK_OK')) {
-            if (onProgress) onProgress(providerId, 'response_detected', null, 'Response detected.');
-            done({ status: 'success', message: 'End-to-end check passed', checkedAt });
-          }
-        } catch { }
+      for (const f of [resultFile, homeResultFile]) {
+        if (!resolved && fs.existsSync(f)) {
+          try {
+            const content = fs.readFileSync(f, 'utf8');
+            if (content.includes('VCM_CHECK_OK')) {
+              console.log(`[AGENT CHECK] ${providerId}: VCM_CHECK_OK found in ${f}`);
+              if (onProgress) onProgress(providerId, 'response_detected', null, 'Response detected.');
+              done({ status: 'success', message: 'End-to-end check passed', checkedAt });
+              return;
+            }
+          } catch { }
+        }
       }
     }
 
-    // Watch for result file creation
-    watcher = chokidar.watch(resultFile, { persistent: true, ignoreInitial: false, disableGlobbing: true });
+    // Watch for result file creation (both repo-path and home-dir fallback)
+    watcher = chokidar.watch([resultFile, homeResultFile], { persistent: true, ignoreInitial: false, disableGlobbing: true });
     watcher.on('add', checkResult);
     watcher.on('change', checkResult);
 
-    // Watch agents.json for status changes to 'operational'
-    // Use debouncing to prevent multiple rapid status checks
+    // Watch agents.json for status changes to 'operational' written AFTER this test started.
+    // Guard against stale 'operational' status from a previous test run for this or another agent.
     let debounceTimer = null;
     const agentsFilePath = getAgentsFilePath();
     requirementsWatcher = chokidar.watch(agentsFilePath, { persistent: true, ignoreInitial: true });
     requirementsWatcher.on('change', () => {
-      // Clear existing debounce timer
       if (debounceTimer) clearTimeout(debounceTimer);
-
-      // Set new timer (50ms debounce - fast response while avoiding duplicate reads)
       debounceTimer = setTimeout(() => {
-      try {
-        const agentStatus = getAgentStatus(providerId);
-        console.log(`[AGENT CHECK] Current status for ${providerId}: ${agentStatus.status}`);
-
-        // Check if agent status is 'operational'
-        if (agentStatus.status === 'operational') {
-          console.log(`[AGENT CHECK] Detected 'operational' status in agents.json for ${providerId}`);
-          if (onProgress) onProgress(providerId, 'response_detected', null, 'Status updated to operational.');
-          done({ status: 'success', message: 'Agent updated status to operational', checkedAt });
+        try {
+          const agentStatus = getAgentStatus(providerId);
+          console.log(`[AGENT CHECK] Current status for ${providerId}: ${agentStatus.status}`);
+          const writtenAfterTestStart = agentStatus.lastChecked && new Date(agentStatus.lastChecked) > new Date(checkedAt);
+          if (agentStatus.status === 'operational' && writtenAfterTestStart) {
+            console.log(`[AGENT CHECK] Detected fresh 'operational' status for ${providerId} (written at ${agentStatus.lastChecked})`);
+            if (onProgress) onProgress(providerId, 'response_detected', null, 'Status updated to operational.');
+            done({ status: 'success', message: 'Agent updated status to operational', checkedAt });
+          } else if (agentStatus.status === 'operational' && !writtenAfterTestStart) {
+            console.log(`[AGENT CHECK] Ignoring stale 'operational' for ${providerId} — was set before this test started`);
+          }
+        } catch (err) {
+          console.warn(`[AGENT CHECK] Error reading agents.json: ${err.message}`);
         }
-      } catch (err) {
-        console.warn(`[AGENT CHECK] Error reading agents.json: ${err.message}`);
-      }
-      }, 50); // End of debounce setTimeout - reduced from 300ms to 50ms for faster response
+      }, 50);
     });
 
     const timeout = setTimeout(() => {
-      // Diagnose: is the IDE process still running?
       let diagnosis = '';
       if (def.type === 'ide') {
         const info = IDE_INFO[providerId] || IDE_INFO[def.ide] || null;
-        if (info && info.process) {
-          diagnosis = isIDERunning(info.process)
+        if (info && (info.process || info.appPath)) {
+          diagnosis = isIDERunning(info.process, info.appPath)
             ? ` — ${info.app || info.process} is running but did not respond`
             : ` — ${info.app || info.process} is not running`;
         }
       }
       console.warn(`[AGENT CHECK] Timeout for ${providerId} after ${timeoutMs / 1000}s${diagnosis}`);
 
-      const timeoutResult = { status: 'error', message: `Timeout${ideLaunchNote}${diagnosis}`, checkedAt };
+      const ideNotRunning = def.type === 'ide' && diagnosis.includes('is not running');
+      const failureReason = ideNotRunning
+        ? `${def.name || providerId} is not running`
+        : `${def.name || providerId} did not complete the test file write within ${timeoutMs / 1000}s${diagnosis}`;
+      const userAction = ideNotRunning
+        ? `Open ${def.name || providerId} and try again`
+        : `Check that ${def.name || providerId} is logged in, has no quota errors, and can run shell commands`;
+      const timeoutResult = { status: 'error', message: `Timeout${ideLaunchNote}${diagnosis}`, checkedAt, failureReason, userAction };
 
-      // For IDE timeout, also check for quota limit (in output + UI)
       if (def.type === 'ide') {
-        checkIDEQuotaLimitAndDone(providerId, timeoutResult).catch(err => {
+        try {
+          const { getAgentStatus } = require('./agents-manager');
+          const currentStatus = getAgentStatus(providerId);
+          if (currentStatus && currentStatus.status === 'operational' &&
+              currentStatus.lastChecked && new Date(currentStatus.lastChecked) > new Date(checkedAt)) {
+            console.log(`[AGENT CHECK] ${providerId} succeeded after timeout — status is operational`);
+            done({ status: 'success', message: 'Agent updated status to operational (post-timeout)', checkedAt });
+            return;
+          }
+        } catch (e) {
+          // ignore
+        }
+        checkIDEQuotaLimitAndDone(providerId, timeoutResult, output, done).catch(err => {
           console.error('[AGENT CHECK] Error in quota check:', err);
           done(timeoutResult);
         });
@@ -263,38 +199,70 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       if (signal && signal.cancelled) {
         done({ status: 'error', message: 'Check cancelled by user', checkedAt });
       }
-    }, 1000); // Check every second
+    }, 1000);
 
-    // Send initial checking status
     if (onProgress) {
       onProgress(providerId, 'awaiting', null, 'Awaiting response...');
     }
 
-    // For IDE providers: send connectivity test directly using Windows automation
-    // Don't spawn auto:start since it expects requirements files (which we removed)
+    // For IDE providers: send connectivity test directly using platform-specific automation
     if (def.type === 'ide') {
       try {
         const { generateConnectivityTestMessage } = require('./agents-manager');
-        const { WindowsAutomationManager } = require('vibecodingmachine-core');
 
-        console.log(`[AGENT CHECK] Sending connectivity test directly to ${providerId}`);
+        let automation;
+        if (process.platform === 'darwin') {
+          const { AppleScriptManager } = require('vibecodingmachine-core');
+          automation = new AppleScriptManager();
+        } else if (process.platform === 'win32') {
+          const { WindowsAutomationManager } = require('vibecodingmachine-core');
+          automation = new WindowsAutomationManager();
+        } else {
+          return {
+            status: 'error',
+            message: `Platform ${process.platform} not supported for IDE automation`,
+            checkedAt
+          };
+        }
 
-        // Get the test message
-        const testMessage = generateConnectivityTestMessage(def.name || providerId, providerId);
+        console.log(`[AGENT CHECK] Sending connectivity test directly to ${providerId}`);
+        console.log(`[AGENT CHECK] Setting ${providerId} status to 'checking' in agents.json`);
+        try {
+          await updateAgentStatus(providerId, 'checking');
+          console.log(`[AGENT CHECK] Set ${providerId} status to 'checking'`);
+        } catch (err) {
+          console.warn(`[AGENT CHECK] Could not set agent status: ${err.message}`);
+        }
 
-        // Send directly to IDE using Windows automation
-        const automation = new WindowsAutomationManager();
+        const testMessage = generateConnectivityTestMessage(def.name || providerId, providerId, repoPath);
+        console.log(`[AGENT CHECK] ${providerId}: test message = "${testMessage}"`);
 
-        // Call the appropriate method based on provider
         let sendResult;
         try {
           switch(providerId.toLowerCase()) {
-            case 'windsurf':
-              sendResult = await automation.sendTextToWindsurf(testMessage);
-              break;
+            case 'devin':
+              // Devin is web-based — not automatable via desktop automation
+              done({ status: 'error', message: 'Devin is web-based and cannot be tested via desktop automation', checkedAt });
+              return;
             case 'cursor':
               sendResult = await automation.sendTextToCursor(testMessage);
               break;
+            case 'antigravity':
+              sendResult = await automation.sendTextToAntigravity(testMessage);
+              break;
+            case 'kiro':
+              sendResult = await automation.sendTextToKiro(testMessage);
+              break;
+            case 'vscode':
+            case 'github-copilot':
+            case 'vscode-copilot-cli':
+            case 'amazon-q':
+              sendResult = await automation.sendTextToVSCode(testMessage);
+              break;
+            case 'replit':
+              // Replit is browser-based — not automatable via desktop AppleScript
+              done({ status: 'error', message: 'Replit is browser-based and cannot be tested via desktop automation', checkedAt });
+              return;
             default:
               sendResult = { success: false, error: `No automation method for ${providerId}` };
           }
@@ -314,7 +282,63 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
         console.log(`[AGENT CHECK] Successfully sent connectivity test to ${providerId}`);
         console.log(`[AGENT CHECK] Waiting for IDE to update agents.json status to 'operational'...`);
 
-        // Don't spawn child process - just wait for file watcher to detect status change
+        // Antigravity shows "Allow running this command?" approval dialog — auto-approve with "1" + Enter
+        if (process.platform === 'darwin' && providerId === 'antigravity') {
+          const { spawn: spawnApproval } = require('child_process');
+          const tryApproveAntigravity = (attempt) => {
+            if (resolved) return;
+            console.log(`[AGENT CHECK] Antigravity: pressing "1" to approve command (attempt ${attempt})`);
+            const approveScript = `
+              tell application "Antigravity" to activate
+              delay 0.5
+              tell application "System Events"
+                tell process "Antigravity"
+                  keystroke "1"
+                  delay 0.3
+                  key code 36
+                end tell
+              end tell
+            `;
+            const tmpFile = require('os').tmpdir() + '/antigravity_approve.scpt';
+            require('fs').writeFileSync(tmpFile, approveScript);
+            const approveChild = spawnApproval('osascript', [tmpFile], { detached: true, stdio: 'ignore' });
+            approveChild.unref();
+          };
+          for (let i = 0; i < 20; i++) {
+            setTimeout(() => tryApproveAntigravity(i + 1), 20000 + i * 15000);
+          }
+        }
+
+        // VS Code-based IDEs show "Allow"/"Run" buttons in WebViews — use CGEvent clicker
+        if (process.platform === 'darwin' && (providerId === 'github-copilot' || providerId === 'amazon-q' || providerId === 'kiro')) {
+          startVSCodeApprovalClicker(providerId, resolvedRef, testMessage);
+        }
+
+        // Cursor shows a "Run" button for terminal commands in agentic mode
+        if (process.platform === 'darwin' && providerId === 'cursor') {
+          startCursorApprovalClicker(resolvedRef);
+        }
+
+        // Early quota check for cursor
+        if (process.platform === 'darwin' && providerId === 'cursor') {
+          const earlyCheckDelay = 30000;
+          setTimeout(async () => {
+            if (resolved) return;
+            try {
+              let quotaCheck = null;
+              if (providerId === 'cursor') {
+                quotaCheck = await automation.checkCursorQuotaLimit();
+              }
+              if (quotaCheck && (quotaCheck.isRateLimited || quotaCheck.hasQuotaWarning)) {
+                console.log(`[AGENT CHECK] ${providerId} rate limit detected early`);
+                done({ status: 'error', message: `Rate limited: ${quotaCheck.matchedText || quotaCheck.message || 'quota exceeded'}`, checkedAt, rateLimited: true });
+              }
+            } catch (e) {
+              console.log(`[AGENT CHECK] Early rate limit check error for ${providerId}: ${e.message}`);
+            }
+          }, earlyCheckDelay);
+        }
+
         return;
 
       } catch (err) {
@@ -324,17 +348,15 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       }
     }
 
-    // For direct LLM providers: still use auto:direct
+    // For direct LLM providers: use auto:direct
     let args;
     if (def.type !== 'ide') {
       args = [CLI_ENTRY_POINT, 'auto:direct', '--provider', providerId, '--max-chats', '1'];
     } else {
-      // IDE handling moved above - this shouldn't be reached
       done({ status: 'error', message: 'IDE handling logic error', checkedAt });
       return;
     }
 
-    // Verify CLI entry point exists and is readable
     if (!fs.existsSync(CLI_ENTRY_POINT)) {
       console.error(`[AGENT CHECK] CLI entry point not found: ${CLI_ENTRY_POINT}`);
       done({ status: 'error', message: `CLI entry point not found: ${CLI_ENTRY_POINT}`, checkedAt });
@@ -349,7 +371,6 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       return;
     }
 
-    // Verify repo path exists and is accessible
     if (!fs.existsSync(repoPath)) {
       console.error(`[AGENT CHECK] Repository path not found: ${repoPath}`);
       done({ status: 'error', message: `Repository path not found: ${repoPath}`, checkedAt });
@@ -364,29 +385,24 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       return;
     }
 
-    // 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}`);
 
-    // Set agent status to 'checking' in agents.json before sending test
     console.log(`[AGENT CHECK] Setting ${providerId} status to 'checking' in agents.json`);
     try {
-      updateAgentStatus(providerId, 'checking');
+      await updateAgentStatus(providerId, 'checking');
       console.log(`[AGENT CHECK] Set ${providerId} status to 'checking'`);
     } catch (err) {
       console.warn(`[AGENT CHECK] Could not set agent status: ${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'),
         path.join(__dirname, '../../../node_modules'),
@@ -394,13 +410,6 @@ 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,
@@ -435,13 +444,11 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       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));
+      if (providerId === 'devin' && code === 8) {
+        console.log(`[AGENT CHECK] Devin specific debugging - code 8 often indicates authentication or startup issues`);
+        console.log(`[AGENT CHECK] Devin 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 DONE in console output for ${providerId}`);
         console.log(`[AGENT CHECK] ✅ Test PASSED: Agent reached DONE status - communication verified`);
@@ -450,9 +457,24 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
         return;
       }
 
-      // Check one more time after process exits
+      if (code === 0 && def.type === 'direct' && (output.includes('No requirements') || output.includes('No more TODO'))) {
+        console.log(`[AGENT CHECK] ${providerId} CLI exited cleanly — marking operational`);
+        if (onProgress) onProgress(providerId, 'response_detected', null, 'CLI verified operational.');
+        done({ status: 'success', message: `${providerId} CLI is operational`, checkedAt });
+        return;
+      }
+
       checkResult();
       if (!resolved) {
+        // Detect rate-limit / credit-balance conditions — treat as rateLimited, not a config error
+        const isRateLimited = /credit balance is too low/i.test(output) ||
+          (/rate.?limit/i.test(output) && /no providers available/i.test(output));
+        if (isRateLimited) {
+          console.log(`[AGENT CHECK] ${providerId} detected as rate-limited via output scan`);
+          done({ status: 'error', rateLimited: true, message: 'Rate limited (credit balance low or quota exceeded)', checkedAt });
+          return;
+        }
+
         const tail = output.slice(-300).trim().replace(/\n/g, ' ');
         let codeInfo = '';
         if (code === 4294967295 || code === -1) {
@@ -468,9 +490,8 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
 
         const errorResult = { status: 'error', message: `Automation exited (code ${code})${codeInfo}${tail ? ': ' + tail : ''}`, checkedAt };
 
-        // For IDE providers, check for quota limit (UI + process output)
         if (def.type === 'ide') {
-          checkIDEQuotaLimitAndDone(providerId, errorResult).catch(err => {
+          checkIDEQuotaLimitAndDone(providerId, errorResult, output, done).catch(err => {
             console.error('[AGENT CHECK] Error in quota check:', err);
             done(errorResult);
           });
@@ -479,138 +500,6 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
         }
       }
     });
-
-    // Helper function to check IDE quota limits and call done with enriched result
-    async function checkIDEQuotaLimitAndDone(providerId, errorResult) {
-      const debugLog = (msg) => {
-        const timestamp = new Date().toISOString();
-        const logLine = `[${timestamp}] ${msg}\n`;
-        try {
-          fs.appendFileSync(`/tmp/vibe-${providerId}-quota-debug.log`, logLine);
-        } catch (_) { }
-        console.log(`[AGENT CHECK] ${msg}`);
-      };
-
-      debugLog(`Starting checkIDEQuotaLimitAndDone for ${providerId}`);
-      debugLog('errorResult.message: ' + JSON.stringify(errorResult.message).substring(0, 200));
-
-      try {
-        debugLog(`Checking for ${providerId} quota limit...`);
-
-        // Check process output first for quota error keywords
-        const lowerOutput = output.toLowerCase();
-        const lowerErrorMsg = errorResult.message.toLowerCase();
-        debugLog('Checking process output length: ' + output.length);
-        debugLog('Process output sample: ' + output.substring(0, 300));
-
-        // Check both output and error message for quota keywords
-        const quotaKeywords = ['quota', 'rate limit', 'resource_exhausted', 'usage limit', 'model quota', 'limit exceeded', 'spending cap', 'usage cap', 'you\'ve reached your monthly chat messages quota', 'upgrade to copilot pro', 'wait for your allowance to renew'];
-        const hasQuotaKeyword = quotaKeywords.some(kw => lowerOutput.includes(kw) || lowerErrorMsg.includes(kw));
-
-        if (hasQuotaKeyword) {
-          debugLog(`🚨 Quota keywords found in process output or message for ${providerId}`);
-          errorResult.rateLimited = true;
-          errorResult.rateLimitMessage = output || errorResult.message;
-          // Set provider-specific rate limit flags for compatibility
-          switch (providerId) {
-            case 'antigravity':
-              errorResult.antigravityRateLimited = true;
-              break;
-            case 'windsurf':
-              errorResult.windsurfRateLimited = true;
-              break;
-            case 'cursor':
-              errorResult.cursorRateLimited = true;
-              break;
-            case 'github-copilot':
-              errorResult.githubCopilotRateLimited = true;
-              break;
-          }
-          debugLog('Set rateLimited to true, calling done()');
-          done(errorResult);
-          return;
-        }
-
-        debugLog(`No quota keywords in process output or message, checking platform-specific UI fallback for ${providerId}`);
-
-        // 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 {
-            let quotaCheck = null;
-
-            // Use specific quota detection methods for each IDE
-            switch (providerId) {
-              case 'antigravity':
-                quotaCheck = await quotaManager.checkAntigravityQuotaLimit();
-                break;
-              case 'windsurf':
-                quotaCheck = await quotaManager.checkWindsurfQuotaLimit();
-                break;
-              case 'cursor':
-                quotaCheck = await quotaManager.checkCursorQuotaLimit();
-                break;
-              case 'github-copilot':
-                // GitHub Copilot uses the same detection as Cursor (both are VS Code extensions)
-                quotaCheck = await quotaManager.checkCursorQuotaLimit();
-                break;
-              default:
-                debugLog(`No specific quota detection method available for ${providerId}`);
-                break;
-            }
-
-            debugLog(`${providerId} quota check result: ` + JSON.stringify(quotaCheck));
-
-            if (quotaCheck && (quotaCheck.isRateLimited || quotaCheck.hasQuotaWarning)) {
-              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) {
-                errorResult.rateLimitResume = quotaCheck.resumeAt;
-              }
-              // Set provider-specific rate limit flags for compatibility
-              switch (providerId) {
-                case 'antigravity':
-                  errorResult.antigravityRateLimited = true;
-                  break;
-                case 'windsurf':
-                  errorResult.windsurfRateLimited = true;
-                  break;
-                case 'cursor':
-                  errorResult.cursorRateLimited = true;
-                  break;
-                case 'github-copilot':
-                  errorResult.githubCopilotRateLimited = true;
-                  break;
-              }
-              debugLog('Enriched error result with quota limit');
-            } else {
-              debugLog(`No rate limit detected for ${providerId}`);
-            }
-          } catch (appleScriptError) {
-            debugLog(`AppleScript quota detection failed for ${providerId}: ${appleScriptError.message}`);
-          }
-        } else {
-          debugLog(`Skipping AppleScript quota detection for ${providerId} on non-macOS platform`);
-        }
-      } catch (err) {
-        debugLog(`Error checking ${providerId} quota: ${err.message}`);
-      } finally {
-        debugLog('Calling done() with final errorResult');
-        debugLog('Final errorResult.rateLimited: ' + errorResult.rateLimited);
-        debugLog('Final errorResult.rateLimitMessage: ' + (errorResult.rateLimitMessage ? errorResult.rateLimitMessage.substring(0, 100) : 'none'));
-        done(errorResult);
-      }
-    }
   });
 }