vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1956

package/src/utils/provider-checker/cursor-approval-clicker.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * Periodically clicks the Run/Allow button in Cursor's agentic composer.
+ * Cursor shows a confirmation dialog for terminal commands; this auto-approves it.
+ *
+ * Returns a cleanup function that stops the interval.
+ */
+function startCursorApprovalClicker(resolvedRef) {
+  let cursorApprovalAttempt = 0;
+  let cursorApprovalInterval;
+
+  const clickCursorRun = () => {
+    if (resolvedRef.resolved) { clearInterval(cursorApprovalInterval); return; }
+    cursorApprovalAttempt++;
+    console.log(`[AGENT CHECK] Cursor: clicking Run button (attempt ${cursorApprovalAttempt})`);
+    const approveScript = `
+      tell application "Cursor" to activate
+      delay 0.4
+      tell application "System Events"
+        tell process "Cursor"
+          set btnNames to {"Yes, allow", "Yes", "Run", "Allow", "Accept", "Continue"}
+          -- Check all windows (dialog may be window 2+)
+          set windowCount to count of windows
+          repeat with w from 1 to windowCount
+            -- Check buttons directly in window
+            try
+              set winBtns to buttons of window w
+              repeat with btn in winBtns
+                try
+                  set btnName to name of btn
+                  repeat with bName in btnNames
+                    if btnName contains bName then
+                      click btn
+                      return "clicked " & btnName & " in window " & w
+                    end if
+                  end repeat
+                end try
+              end repeat
+            end try
+            -- Check groups in window
+            try
+              set allGroups to groups of window w
+              repeat with grp in allGroups
+                try
+                  set grpBtns to buttons of grp
+                  repeat with btn in grpBtns
+                    try
+                      set btnName to name of btn
+                      repeat with bName in btnNames
+                        if btnName contains bName then
+                          click btn
+                          return "clicked " & btnName & " in group"
+                        end if
+                      end repeat
+                    end try
+                  end repeat
+                end try
+              end repeat
+            end try
+            -- Check sheets (modal dialogs)
+            try
+              set sheetList to sheets of window w
+              repeat with s in sheetList
+                try
+                  set sheetBtns to buttons of s
+                  repeat with btn in sheetBtns
+                    try
+                      set btnName to name of btn
+                      repeat with bName in btnNames
+                        if btnName contains bName then
+                          click btn
+                          return "clicked " & btnName & " in sheet"
+                        end if
+                      end repeat
+                    end try
+                  end repeat
+                end try
+              end repeat
+            end try
+          end repeat
+          -- Fallback: try pressing Enter (default button in dialog)
+          key code 36
+          return "pressed Enter as fallback"
+        end tell
+      end tell
+    `;
+    const tmpFile = os.tmpdir() + '/cursor_approve.scpt';
+    fs.writeFileSync(tmpFile, approveScript);
+    const approveChild = spawn('osascript', [tmpFile], { detached: true, stdio: 'ignore' });
+    approveChild.unref();
+  };
+
+  setTimeout(() => {
+    if (!resolvedRef.resolved) {
+      clickCursorRun();
+      cursorApprovalInterval = setInterval(clickCursorRun, 10000);
+    }
+  }, 20000);
+
+  return () => clearInterval(cursorApprovalInterval);
+}
+
+module.exports = { startCursorApprovalClicker };

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

@@ -1,6 +1,6 @@
 /**
  * Format Utilities Module
- * 
+ *
  * Contains formatting utilities for dates and other data.
  */
 
@@ -12,18 +12,18 @@ function formatCheckedAt(checkedAt) {
   if (!checkedAt) return '';
   const d = new Date(checkedAt);
   if (isNaN(d.getTime())) return checkedAt;
-  
+
   const months = [
     'January', 'February', 'March', 'April', 'May', 'June',
     'July', 'August', 'September', 'October', 'November', 'December'
   ];
-  
+
   const hours = d.getHours();
   const ampm = hours >= 12 ? 'pm' : 'am';
   const hour12 = hours % 12 || 12;
   const minutes = d.getMinutes().toString().padStart(2, '0');
   const timePart = `${hour12}:${minutes} ${ampm}`;
-  
+
   return `${months[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()} at ${timePart}`;
 }
 

package/src/utils/provider-checker/ide-installer-helper.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const { isIDERunning, openIDEApp } = require('./ide-manager');
+
+/**
+ * Ensure the IDE is launched/installed before running a connectivity check.
+ * Returns { ideLaunchNote, error } — if error is set, the caller should return it immediately.
+ */
+async function ensureIDEReady(providerId, def, repoPath, info, onProgress) {
+  let ideLaunchNote = '';
+
+  if (process.platform === 'darwin' && info.app) {
+    const launchSuccess = await openIDEApp(info.app, repoPath);
+    if (launchSuccess) {
+      ideLaunchNote = ` (VCM launched ${info.app})`;
+    } else {
+      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 {
+          ideLaunchNote,
+          error: `${info.app} is not installed. Please download from ${IDEInstaller.IDE_CONFIG[ideKey]?.downloadBrowserUrl || 'its official website'}`
+        };
+      }
+    }
+  } else if (process.platform === 'win32') {
+    const result = await _ensureIDEReadyWindows(providerId, def, repoPath, info, onProgress);
+    ideLaunchNote = result.ideLaunchNote;
+    if (result.error) return result;
+  }
+
+  return { ideLaunchNote, error: null };
+}
+
+async function _ensureIDEReadyWindows(providerId, def, repoPath, info, onProgress) {
+  const { IDEInstaller } = require('../../../../electron-app/src/main/ide-installer');
+  const installer = new IDEInstaller();
+  const ideKey = def.ide || providerId;
+  const ideConfig = IDEInstaller.IDE_CONFIG[ideKey];
+  let ideLaunchNote = '';
+
+  let checkResult = await installer.checkIDEInstallation(ideKey);
+
+  if (!checkResult.installed) {
+    const downloadUrl = ideConfig?.downloadUrl?.[process.platform];
+    if (downloadUrl) {
+      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) {
+          return {
+            ideLaunchNote,
+            error: `Failed to install ${info.app || ideKey}: ${installResult?.error || 'Installation failed'}. Please install manually and try again.`
+          };
+        }
+        console.log(`[AGENT CHECK] ${info.app || ideKey} installed successfully`);
+        ideLaunchNote = ` (VCM installed ${info.app || ideKey})`;
+        await new Promise(r => setTimeout(r, 3000));
+        checkResult = await installer.checkIDEInstallation(ideKey);
+      } catch (installError) {
+        return {
+          ideLaunchNote,
+          error: `Installation failed for ${info.app || ideKey}: ${installError.message}. Please install manually and try again.`
+        };
+      }
+    } else {
+      const browserUrl = ideConfig?.downloadBrowserUrl || `${ideKey}'s official website`;
+      return { ideLaunchNote, error: `${info.app || ideKey} is not installed. Please download from: ${browserUrl}` };
+    }
+  }
+
+  if (checkResult.installed) {
+    if (!isIDERunning(info.process, info.appPath)) {
+      console.log(`🪟 [AGENT CHECK] ${info.app} not running, attempting to launch...`);
+      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`);
+      await new Promise(r => setTimeout(r, 2000));
+    }
+  }
+
+  return { ideLaunchNote, error: null };
+}
+
+module.exports = { ensureIDEReady };

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

@@ -2,12 +2,12 @@
 
 const { execSync } = require('child_process');
 
-// Map provider id → { process: process name for tasklist/pgrep, app: app name for opening }
+// Map provider id → { process: process name for tasklist/pgrep, app: app name for opening, appPath: macOS .app path for ps-based detection }
 const IDE_INFO = {
-  windsurf:       { process: 'Windsurf',            app: 'Windsurf' },
+  devin:          { process: 'Devin',               app: 'Devin' },
   cursor:         { process: 'Cursor',              app: 'Cursor' },
   antigravity:    { process: 'Antigravity',         app: 'Antigravity' },
-  kiro:           { process: 'Kiro',                app: 'Kiro' },
+  kiro:           { process: 'Kiro',                app: 'Kiro',                 appPath: '/Applications/Kiro.app' },
   'github-copilot': { process: 'Code',              app: 'Visual Studio Code' },
   'amazon-q':     { process: 'Code',                app: 'Visual Studio Code' },
   cline:          { process: 'Code',                app: 'Visual Studio Code' },
@@ -17,11 +17,22 @@ const IDE_INFO = {
 
 /**
  * Returns true if the IDE process is currently running.
+ * @param {string} processName - process name for pgrep/tasklist
+ * @param {string|null} appPath - optional macOS .app path for ps-based detection (e.g. Kiro which runs as Electron)
  */
-function isIDERunning(processName) {
-  if (!processName) return false;
+function isIDERunning(processName, appPath = null) {
+  if (!processName && !appPath) return false;
 
   if (process.platform === 'darwin') {
+    // If an appPath is provided, detect via ps (handles apps that run as generic process names like Electron)
+    if (appPath) {
+      try {
+        const result = execSync(`ps aux | grep -v grep | grep "${appPath}" | head -1`, { encoding: 'utf8' });
+        return result.trim().length > 0;
+      } catch {
+        return false;
+      }
+    }
     // macOS: use pgrep
     try {
       execSync(`pgrep -x "${processName}"`, { stdio: 'ignore' });
@@ -71,9 +82,9 @@ async function openIDEApp(appName, repoPath) {
 
       // Map app name to the appropriate method
       let result;
-      if (appName === 'Windsurf') {
-        console.log('🪟 [IDE MANAGER] Calling openWindsurf()...');
-        result = await manager.openWindsurf(repoPath);
+      if (appName === 'Devin') {
+        console.log('🪟 [IDE MANAGER] Calling openDevin()...');
+        result = await manager.openDevin(repoPath);
       } else if (appName === 'Cursor') {
         console.log('🪟 [IDE MANAGER] Calling openCursorNative()...');
         result = await manager.openCursorNative(repoPath);

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

@@ -0,0 +1,120 @@
+'use strict';
+
+const fs = require('fs');
+
+const QUOTA_KEYWORDS = [
+  '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',
+  'high demand', 'permission denied: we\'re currently facing'
+];
+
+/**
+ * Check for IDE quota/rate-limit signals and call done() with an enriched result.
+ * Checks process output first, then falls back to platform-specific UI scraping.
+ */
+async function checkIDEQuotaLimitAndDone(providerId, errorResult, output, done) {
+  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 {
+    const lowerOutput = output.toLowerCase();
+    const lowerErrorMsg = errorResult.message.toLowerCase();
+    debugLog('Checking process output length: ' + output.length);
+    debugLog('Process output sample: ' + output.substring(0, 300));
+
+    const hasQuotaKeyword = QUOTA_KEYWORDS.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;
+      _setProviderRateLimitFlag(providerId, errorResult);
+      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}`);
+
+    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();
+    }
+
+    if (quotaManager) {
+      try {
+        let quotaCheck = null;
+
+        switch (providerId) {
+          case 'antigravity':
+            quotaCheck = await quotaManager.checkAntigravityQuotaLimit();
+            break;
+          case 'devin':
+            quotaCheck = await quotaManager.checkDevinRateLimit?.();
+            break;
+          case 'cursor':
+            quotaCheck = await quotaManager.checkCursorQuotaLimit();
+            break;
+          case 'github-copilot':
+            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;
+          }
+          _setProviderRateLimitFlag(providerId, errorResult);
+          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);
+  }
+}
+
+function _setProviderRateLimitFlag(providerId, errorResult) {
+  switch (providerId) {
+    case 'antigravity': errorResult.antigravityRateLimited = true; break;
+    case 'devin': errorResult.devinRateLimited = true; break;
+    case 'cursor': errorResult.cursorRateLimited = true; break;
+    case 'github-copilot': errorResult.githubCopilotRateLimited = true; break;
+  }
+}
+
+module.exports = { checkIDEQuotaLimitAndDone };

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

@@ -1,6 +1,6 @@
 /**
  * IDE Utilities Module
- * 
+ *
  * Contains IDE process detection and launching utilities.
  */
 
@@ -8,7 +8,7 @@ const { execSync } = require('child_process');
 
 // Map provider id → { process: process name for tasklist/pgrep, app: app name for opening }
 const IDE_INFO = {
-  windsurf:       { process: 'Windsurf',            app: 'Windsurf' },
+  devin:          { process: 'Devin',               app: 'Devin' },
   cursor:         { process: 'Cursor',              app: 'Cursor' },
   antigravity:    { process: 'Antigravity',         app: 'Antigravity' },
   'vscode':       { process: 'Code',                app: 'Visual Studio Code' },

package/src/utils/provider-checker/node-detector.js

@@ -13,7 +13,7 @@ function getNodeExecutable() {
   if (process.env.NODE_BINARY_PATH) {
     return process.env.NODE_BINARY_PATH;
   }
-  
+
   // Try to find node in PATH
   try {
     const nodeCmd = process.platform === 'win32' ? 'where node' : 'which node';
@@ -22,7 +22,7 @@ function getNodeExecutable() {
       return nodePath;
     }
   } catch (_) {}
-  
+
   // Fallback: try common node installation paths
   const commonPaths = process.platform === 'win32'
     ? [
@@ -36,13 +36,13 @@ function getNodeExecutable() {
         '/usr/local/bin/node',
         '/opt/homebrew/bin/node'
       ];
-  
+
   for (const nodePath of commonPaths) {
     if (nodePath && fs.existsSync(nodePath)) {
       return nodePath;
     }
   }
-  
+
   // Last resort: use process.execPath (might be electron but worth trying)
   console.warn('[AGENT CHECK] Could not find node executable, falling back to process.execPath');
   return process.execPath;

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

@@ -1,6 +1,6 @@
 /**
  * Node Utilities Module
- * 
+ *
  * Contains Node.js executable detection and related utilities.
  */
 
@@ -17,7 +17,7 @@ function getNodeExecutable() {
   if (process.env.NODE_BINARY_PATH) {
     return process.env.NODE_BINARY_PATH;
   }
-  
+
   // Try to find node in PATH
   try {
     const nodeCmd = process.platform === 'win32' ? 'where node' : 'which node';
@@ -26,7 +26,7 @@ function getNodeExecutable() {
       return nodePath;
     }
   } catch (_) {}
-  
+
   // Fallback: try common node installation paths
   const commonPaths = process.platform === 'win32'
     ? [
@@ -40,13 +40,13 @@ function getNodeExecutable() {
         '/usr/local/bin/node',
         '/opt/homebrew/bin/node'
       ];
-  
+
   for (const nodePath of commonPaths) {
     if (nodePath && fs.existsSync(nodePath)) {
       return nodePath;
     }
   }
-  
+
   // Last resort: use process.execPath (might be electron but worth trying)
   console.warn('[AGENT CHECK] Could not find node executable, falling back to process.execPath');
   return process.execPath;