vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,250 @@
+/**
+ * Agent Checker Module
+ * 
+ * Contains main agent checking functionality.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { NODE_EXECUTABLE } = require('./node-utils');
+const { isCLIAvailable, installCLI, CLI_AUTO_INSTALL } = require('./cli-utils');
+const { IDE_INFO, isIDERunning, openIDEApp } = require('./ide-utils');
+const {
+  getResultFilePath,
+  addTestRequirement,
+  removeTestRequirement
+} = require('./test-requirements');
+const { spawnAndWait } = require('./process-utils');
+const { checkAntigravityQuota } = require('./quota-checker');
+
+const CLI_ENTRY_POINT = path.resolve(path.join(__dirname, '../../../bin/vibecodingmachine.js'));
+
+// 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;
+
+/**
+ * For IDE providers: ensure the IDE is open first, launching it if needed.
+ * Returns { status, message, checkedAt, rateLimited?, rateLimitMessage?, rateLimitResume? }.
+ */
+async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, signal = null, onProgress = null) {
+  const checkedAt = new Date().toISOString();
+
+  // Ensure temp dir exists
+  const tempDir = path.dirname(resultFile);
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+  }
+
+  // Clean up any previous result
+  if (fs.existsSync(resultFile)) {
+    fs.unlinkSync(resultFile);
+  }
+
+  // For IDE providers, ensure IDE is running
+  if (def.type === 'ide' && IDE_INFO[providerId]) {
+    const ideInfo = IDE_INFO[providerId];
+    const isRunning = isIDERunning(ideInfo.process);
+
+    if (!isRunning) {
+      if (onProgress) onProgress({ type: 'ide_launch', message: `Launching ${ideInfo.app}...` });
+
+      const launched = await openIDEApp(ideInfo.app, repoPath);
+      if (!launched) {
+        return {
+          status: 'error',
+          message: `Failed to launch ${ideInfo.app}`,
+          checkedAt
+        };
+      }
+
+      // Wait a bit for IDE to fully start
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+  }
+
+  // Check for rate limits on specific providers
+  if (providerId === 'antigravity') {
+    const quotaCheck = await checkAntigravityQuota();
+    if (quotaCheck.isRateLimited) {
+      return {
+        status: 'rate_limited',
+        message: quotaCheck.message,
+        checkedAt,
+        rateLimited: true,
+        rateLimitMessage: quotaCheck.message,
+        rateLimitResume: quotaCheck.resumeAt
+      };
+    }
+  }
+
+  // Prepare command arguments
+  let args = [];
+  let cmd;
+
+  if (def.type === 'cli') {
+    // CLI provider
+    const cliInfo = CLI_AUTO_INSTALL[providerId];
+    if (!cliInfo) {
+      return {
+        status: 'error',
+        message: `Unknown CLI provider: ${providerId}`,
+        checkedAt
+      };
+    }
+
+    // Ensure CLI is available
+    if (!isCLIAvailable(cliInfo.cmd, providerId)) {
+      if (onProgress) onProgress({ type: 'cli_install', message: `Installing ${providerId}...` });
+
+      const installResult = await installCLI(providerId);
+      if (!installResult.installed) {
+        return {
+          status: 'error',
+          message: `Failed to install ${providerId}: ${installResult.note}`,
+          checkedAt
+        };
+      }
+    }
+
+    cmd = cliInfo.cmd;
+    args = ['agent', 'test', '--repo', repoPath, '--result', resultFile];
+  } else if (def.type === 'ide') {
+    // IDE provider - use our CLI to communicate with IDE
+    cmd = NODE_EXECUTABLE;
+    args = [CLI_ENTRY_POINT, 'agent', 'test', '--repo', repoPath, '--result', resultFile, '--ide', providerId];
+  } else {
+    return {
+      status: 'error',
+      message: `Unknown provider type: ${def.type}`,
+      checkedAt
+    };
+  }
+
+  // Run the agent test
+  if (onProgress) onProgress({ type: 'test_start', message: 'Running agent connectivity test...' });
+
+  const result = await spawnAndWait(cmd, args, {
+    signal,
+    timeout: timeoutMs,
+    cwd: repoPath
+  });
+
+  // Check if result file was created
+  let testResult = null;
+  if (fs.existsSync(resultFile)) {
+    try {
+      testResult = fs.readFileSync(resultFile, 'utf8');
+    } catch (_) { }
+  }
+
+  if (result.code !== 0 || !testResult) {
+    return {
+      status: 'error',
+      message: `Agent test failed (exit code: ${result.code})`,
+      checkedAt,
+      output: result.output
+    };
+  }
+
+  // Parse the test result
+  try {
+    const parsed = JSON.parse(testResult);
+    return {
+      status: 'success',
+      message: 'Agent test completed successfully',
+      checkedAt,
+      result: parsed
+    };
+  } catch (_) {
+    return {
+      status: 'success',
+      message: 'Agent test completed (raw output)',
+      checkedAt,
+      result: testResult
+    };
+  }
+}
+
+/**
+ * Check a single provider.
+ * Returns { status, message, checkedAt, requirementLeftPending }.
+ */
+async function checkProvider(providerId, config = {}, repoPath, onProgress = null, signal = null) {
+  const { getProviderDefinition } = require('../provider-registry');
+  console.log(`[AGENT CHECK] Checking provider: ${providerId} in repo: ${repoPath}`);
+
+  const def = getProviderDefinition(providerId);
+  if (!def) {
+    return {
+      status: 'error',
+      message: `Unknown provider: ${providerId}`,
+      checkedAt: new Date().toISOString(),
+      requirementLeftPending: false
+    };
+  }
+
+  const reqPath = path.join(repoPath, 'REQUIREMENTS.md');
+  const resultFile = getResultFilePath(repoPath);
+
+  // Add test requirement
+  addTestRequirement(reqPath, resultFile);
+
+  try {
+    // Choose timeout based on provider type
+    const timeoutMs = def.type === 'cli' ? DIRECT_TIMEOUT_MS : IDE_TIMEOUT_MS;
+
+    const result = await runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, signal, onProgress);
+
+    // Remove test requirement (clean up)
+    removeTestRequirement(reqPath);
+
+    // Clean up result file
+    if (fs.existsSync(resultFile)) {
+      fs.unlinkSync(resultFile);
+    }
+
+    return {
+      ...result,
+      requirementLeftPending: false
+    };
+  } catch (error) {
+    // Ensure cleanup on error
+    removeTestRequirement(reqPath);
+    if (fs.existsSync(resultFile)) {
+      fs.unlinkSync(resultFile);
+    }
+
+    return {
+      status: 'error',
+      message: `Check failed: ${error.message}`,
+      checkedAt: new Date().toISOString(),
+      requirementLeftPending: false
+    };
+  }
+}
+
+/**
+ * Check multiple providers in sequence.
+ * Returns { [providerId]: checkResult }.
+ */
+async function checkAllProviders(providerIds, config = {}, repoPath, onProgress = null, signal = null) {
+  const results = {};
+
+  for (const id of providerIds) {
+    if (signal && signal.aborted) break;
+
+    results[id] = await checkProvider(id, config, repoPath, onProgress, signal);
+  }
+
+  return results;
+}
+
+module.exports = {
+  runAgentCheck,
+  checkProvider,
+  checkAllProviders,
+  DIRECT_TIMEOUT_MS,
+  IDE_TIMEOUT_MS
+};

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

@@ -0,0 +1,450 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const chokidar = require('chokidar');
+
+const { NODE_EXECUTABLE } = require('./node-detector');
+const { IDE_INFO, isIDERunning, openIDEApp } = require('./ide-manager');
+const { getResultFilePath } = require('./requirements-manager');
+
+// 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;
+
+const CLI_ENTRY_POINT = path.resolve(path.join(__dirname, '../../../bin/vibecodingmachine.js'));
+
+/**
+ * Run an agent for 1 iteration and watch for the result file to be written.
+ * For IDE providers: ensure the IDE is open first, launching it if needed.
+ * Returns { status, message, checkedAt, rateLimited?, rateLimitMessage?, rateLimitResume? }.
+ */
+async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, signal = null, onProgress = null) {
+  const checkedAt = new Date().toISOString();
+
+  // Ensure temp dir exists
+  fs.mkdirSync(path.dirname(resultFile), { recursive: true });
+  // Remove stale result file so we detect a fresh write
+  try { fs.unlinkSync(resultFile); } 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 (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...`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return new Promise((resolve) => {
+    let resolved = false;
+    let child = null;
+    let output = '';
+
+    async function done(result) {
+      if (resolved) return;
+      resolved = true;
+      try { watcher.close(); } catch { }
+      clearTimeout(timeout);
+      clearInterval(cancelCheckInterval);
+      try { if (child) child.kill(); } catch { }
+      resolve(result);
+    }
+
+    function checkResult() {
+      if (!resolved && fs.existsSync(resultFile)) {
+        try {
+          const content = fs.readFileSync(resultFile, 'utf8');
+          if (content.includes('VCM_CHECK_OK')) {
+            done({ status: 'success', message: 'End-to-end check passed', checkedAt });
+          }
+        } catch { }
+      }
+    }
+
+    const watcher = chokidar.watch(resultFile, { persistent: true, ignoreInitial: false, disableGlobbing: true });
+    watcher.on('add', checkResult);
+    watcher.on('change', checkResult);
+
+    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)
+            ? ` — ${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: `No response within ${timeoutMs / 1000}s${ideLaunchNote}${diagnosis}`, checkedAt };
+
+      // For IDE timeout, also check for quota limit (in output + UI)
+      if (def.type === 'ide') {
+        checkIDEQuotaLimitAndDone(providerId, timeoutResult).catch(err => {
+          console.error('[AGENT CHECK] Error in quota check:', err);
+          done(timeoutResult);
+        });
+      } else {
+        done(timeoutResult);
+      }
+    }, timeoutMs);
+
+    // Periodically check for cancellation signal
+    const cancelCheckInterval = setInterval(() => {
+      if (signal && signal.cancelled) {
+        done({ status: 'error', message: 'Check cancelled by user', checkedAt });
+      }
+    }, 1000); // Check every second
+
+    let args;
+    if (def.type === 'ide') {
+      args = [CLI_ENTRY_POINT, 'auto:start', '--ide', def.ide || providerId, '--max-chats', '1'];
+      if (def.defaultModel) args.push('--ide-model', String(def.defaultModel));
+      if (def.extension) args.push('--extension', String(def.extension));
+    } else {
+      // Direct LLM: use auto:direct --provider to force this specific provider
+      args = [CLI_ENTRY_POINT, 'auto:direct', '--provider', providerId, '--max-chats', '1'];
+    }
+
+    // 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 });
+      return;
+    }
+
+    try {
+      fs.accessSync(CLI_ENTRY_POINT, fs.constants.R_OK);
+    } catch (err) {
+      console.error(`[AGENT CHECK] CLI entry point not readable: ${CLI_ENTRY_POINT} - ${err.message}`);
+      done({ status: 'error', message: `CLI entry point not readable: ${err.message}`, checkedAt });
+      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 });
+      return;
+    }
+
+    try {
+      fs.accessSync(repoPath, fs.constants.R_OK | fs.constants.W_OK);
+    } catch (err) {
+      console.error(`[AGENT CHECK] Repository path not accessible: ${repoPath} - ${err.message}`);
+      done({ status: 'error', message: `Repository path not accessible: ${err.message}`, checkedAt });
+      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}`);
+
+    // Prepare environment - inherit all process.env and add NODE_PATH if needed
+    const spawnEnv = {
+      ...process.env,
+      // Ensure NODE_PATH includes the monorepo node_modules if it exists
+      NODE_PATH: [
+        path.join(__dirname, '../../node_modules'),
+        path.join(__dirname, '../../../node_modules'),
+        process.env.NODE_PATH || ''
+      ].filter(Boolean).join(path.delimiter)
+    };
+
+    child = spawn(NODE_EXECUTABLE, args, {
+      cwd: repoPath,
+      env: spawnEnv,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: false
+    });
+
+    console.log(`[AGENT CHECK] Child process spawned for ${providerId}, PID: ${child.pid}`);
+
+    child.stdout.on('data', d => {
+      const data = d.toString();
+      output += data;
+      console.log(`[AGENT CHECK ${providerId}] STDOUT: ${data.slice(0, 200)}`);
+    });
+    child.stderr.on('data', d => {
+      const data = d.toString();
+      output += data;
+      console.log(`[AGENT CHECK ${providerId}] STDERR: ${data.slice(0, 200)}`);
+    });
+
+    child.on('error', (err) => {
+      console.error(`[AGENT CHECK] Failed to start ${providerId}: ${err.message}`);
+      done({ status: 'error', message: `Failed to start automation: ${err.message}`, checkedAt });
+    });
+
+    child.on('exit', (code) => {
+      if (resolved) return;
+      console.log(`[AGENT CHECK] ${providerId} process exited with code ${code}`);
+      console.log(`[AGENT CHECK] ${providerId} process output: ${output.slice(-500)}`);
+      // Check one more time after process exits
+      checkResult();
+      if (!resolved) {
+        const tail = output.slice(-300).trim().replace(/\n/g, ' ');
+        let codeInfo = '';
+        if (code === 4294967295 || code === -1) {
+          codeInfo = ` (process may not have started or crashed immediately)`;
+          if (def.type === 'ide') {
+            const ideInfo = IDE_INFO[providerId] || IDE_INFO[def.ide];
+            if (ideInfo && ideInfo.app) {
+              codeInfo += ` — Make sure ${ideInfo.app} is installed and running`;
+            }
+          }
+        }
+        console.error(`[AGENT CHECK] ${providerId} error: Automation exited (code ${code})${codeInfo}${tail ? ': ' + tail : ''}`);
+
+        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 => {
+            console.error('[AGENT CHECK] Error in quota check:', err);
+            done(errorResult);
+          });
+        } else {
+          done(errorResult);
+        }
+      }
+    });
+
+    // 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 AppleScript UI as fallback for ${providerId}`);
+
+        // Then check AppleScript UI scraping as fallback for IDEs that support it
+        if (process.platform === 'darwin') {
+          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();
+                break;
+              case 'windsurf':
+                quotaCheck = await appleScriptManager.checkWindsurfQuotaLimit();
+                break;
+              case 'cursor':
+                quotaCheck = await appleScriptManager.checkCursorQuotaLimit();
+                break;
+              case 'github-copilot':
+                // GitHub Copilot uses the same detection as Cursor (both are VS Code extensions)
+                quotaCheck = await appleScriptManager.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 AppleScript`);
+              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);
+      }
+    }
+  });
+}
+
+module.exports = {
+  runAgentCheck,
+  DIRECT_TIMEOUT_MS,
+  IDE_TIMEOUT_MS
+};