vibecodingmachine-core 2026.1.3-2209 → 2026.1.23-1010

package/src/ide-integration/applescript-manager.js

@@ -370,19 +370,43 @@ class AppleScriptManager {
 
     // Handle macOS platform
     try {
-      this.logger.log('Opening VS Code...');
+      this.logger.log('Opening VS Code with remote debugging enabled...');
 
-      let command = 'open -a "Visual Studio Code"';
+      // First, check if VS Code is already running
+      try {
+        const isRunning = execSync('pgrep -x "Code"', { encoding: 'utf8', stdio: 'pipe' }).trim();
+        if (isRunning) {
+          this.logger.log('VS Code is already running - closing it to enable remote debugging...');
+          execSync('pkill -x "Code"', { stdio: 'pipe' });
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+      } catch (err) {
+        // VS Code not running, that's fine
+      }
+
+      // Launch VS Code with remote debugging enabled for quota detection
+      let command = 'open -a "Visual Studio Code" --args --remote-debugging-port=9222';
       if (repoPath) {
-        command += ` "${repoPath}"`;
+        command = `open -a "Visual Studio Code" "${repoPath}" --args --remote-debugging-port=9222`;
         this.logger.log(`Opening VS Code with repository: ${repoPath}`);
       }
 
       execSync(command, { stdio: 'pipe' });
 
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Verify remote debugging port is accessible
+      try {
+        const CDP = require('chrome-remote-interface');
+        await CDP.List({ port: 9222 });
+        this.logger.log('✅ VS Code remote debugging port 9222 is accessible');
+      } catch (cdpError) {
+        this.logger.log(`⚠️ Warning: VS Code remote debugging port not accessible: ${cdpError.message}`);
+        this.logger.log('   Waiting additional 2 seconds for VS Code to fully start...');
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      }
 
-      this.logger.log('VS Code opened successfully');
+      this.logger.log('VS Code opened successfully with remote debugging');
       return { success: true, message: `VS Code opened with repository: ${repoPath}`, method: 'applescript' };
     } catch (error) {
       this.logger.log('Error opening VS Code:', error.message);
@@ -390,6 +414,125 @@ class AppleScriptManager {
     }
   }
 
+  /**
+   * Open VS Code with a specific extension installed
+   * @param {string} extension - Extension key (e.g., 'github-copilot', 'amazon-q')
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openVSCodeWithExtension(extension, repoPath = null) {
+    try {
+      this.logger.log(`Opening VS Code with ${extension} extension...`);
+
+      // Extension IDs mapping
+      const extensionIds = {
+        'github-copilot': 'GitHub.copilot',
+        'amazon-q': 'amazonwebservices.amazon-q-vscode',
+        'continue': 'Continue.continue'
+      };
+
+      const extensionId = extensionIds[extension];
+      if (!extensionId) {
+        return { success: false, error: `Unknown extension: ${extension}`, method: 'applescript' };
+      }
+
+      // First, check if the extension is installed
+      try {
+        const checkCmd = `code --list-extensions | grep -i "${extensionId}"`;
+        execSync(checkCmd, { stdio: 'pipe' });
+        this.logger.log(`Extension ${extension} is already installed`);
+      } catch (checkError) {
+        // Extension not found, try to install it
+        this.logger.log(`Extension ${extension} not found, installing...`);
+        try {
+          execSync(`code --install-extension ${extensionId} --force`, { stdio: 'pipe', timeout: 60000 });
+          this.logger.log(`Extension ${extension} installed successfully`);
+        } catch (installError) {
+          this.logger.log(`Failed to install extension ${extension}:`, installError.message);
+          return { success: false, error: `Failed to install extension: ${installError.message}`, method: 'applescript' };
+        }
+      }
+
+      // First, check if VS Code is already running
+      try {
+        const isRunning = execSync('pgrep -x "Code"', { encoding: 'utf8', stdio: 'pipe' }).trim();
+        if (isRunning) {
+          this.logger.log('VS Code is already running - closing it to enable remote debugging...');
+          execSync('pkill -x "Code"', { stdio: 'pipe' });
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+      } catch (err) {
+        // VS Code not running, that's fine
+      }
+
+      // Open VS Code with the repository and remote debugging enabled
+      let command = 'open -a "Visual Studio Code" --args --remote-debugging-port=9222';
+      if (repoPath) {
+        command = `open -a "Visual Studio Code" "${repoPath}" --args --remote-debugging-port=9222`;
+        this.logger.log(`Opening VS Code with repository: ${repoPath}`);
+      }
+
+      execSync(command, { stdio: 'pipe' });
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Verify remote debugging port is accessible
+      try {
+        const CDP = require('chrome-remote-interface');
+        await CDP.List({ port: 9222 });
+        this.logger.log('✅ VS Code remote debugging port 9222 is accessible');
+      } catch (cdpError) {
+        this.logger.log(`⚠️ Warning: VS Code remote debugging port not accessible: ${cdpError.message}`);
+        this.logger.log('   Waiting additional 2 seconds for VS Code to fully start...');
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      }
+
+      this.logger.log(`VS Code opened successfully with ${extension} extension and remote debugging`);
+      return { success: true, message: `VS Code opened with ${extension} extension`, method: 'applescript' };
+    } catch (error) {
+      this.logger.log(`Error opening VS Code with ${extension}:`, error.message);
+      return { success: false, error: error.message, method: 'applescript' };
+    }
+  }
+
+  /**
+   * Open Replit Agent with optional repository path
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openReplit(repoPath = null) {
+    try {
+      this.logger.log('Opening Replit...');
+      this.logger.log(`Platform detected: ${this.platform}`);
+
+      // Replit typically uses web browser, so we'll open the Replit website
+      // If Replit has a desktop app or CLI, this can be updated
+      const replitUrl = repoPath
+        ? `https://replit.com/@replit/agent?path=${encodeURIComponent(repoPath)}`
+        : 'https://replit.com/@replit/agent';
+
+      let command;
+      if (this.platform === 'darwin') {
+        command = `open "${replitUrl}"`;
+        this.logger.log(`Using macOS command: ${command}`);
+      } else if (this.platform === 'win32') {
+        command = `start "" "${replitUrl}"`;
+        this.logger.log(`Using Windows command: ${command}`);
+      } else {
+        command = `xdg-open "${replitUrl}"`;
+        this.logger.log(`Using Linux command: ${command}`);
+      }
+
+      execSync(command, { stdio: 'pipe' });
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      this.logger.log('Replit opened successfully');
+      return { success: true, message: 'Replit opened in browser', method: 'applescript' };
+    } catch (error) {
+      this.logger.log('Error opening Replit:', error.message);
+      return { success: false, error: error.message, method: 'applescript' };
+    }
+  }
+
 
   /**
    * Open Windsurf IDE with optional repository path
@@ -562,6 +705,85 @@ class AppleScriptManager {
     }
   }
 
+  /**
+   * Check Antigravity UI for Gemini quota limit popup text.
+   * This is best-effort: Antigravity may render the popup in a WebView that AppleScript can't read.
+   * @returns {Promise<{isRateLimited: boolean, message?: string, resumeAt?: string, note?: string}>}
+   */
+  async checkAntigravityQuotaLimit() {
+    try {
+      const script = `
+        tell application "System Events"
+          if not (exists process "Antigravity") then
+            return "NOT_RUNNING"
+          end if
+          tell process "Antigravity"
+            set frontmost to true
+            delay 0.4
+
+            set allText to ""
+            try
+              set allText to allText & (value of static text of window 1 as string) & "\\n"
+            end try
+
+            try
+              set groupsList to groups of window 1
+              repeat with g in groupsList
+                try
+                  set allText to allText & (value of static text of g as string) & "\\n"
+                end try
+              end repeat
+            end try
+
+            return allText
+          end tell
+        end tell
+      `;
+
+      const raw = execSync(`osascript -e '${script.replace(/'/g, "'\\\\''")}'`, {
+        encoding: 'utf8',
+        timeout: 8000
+      }).trim();
+
+      if (!raw || raw === 'NOT_RUNNING') {
+        return {
+          isRateLimited: false,
+          note: raw === 'NOT_RUNNING' ? 'Antigravity not running' : 'No readable UI text'
+        };
+      }
+
+      const text = raw.replace(/\\s+/g, ' ').trim();
+      const lower = text.toLowerCase();
+
+      const hasGeminiQuota = lower.includes('model quota limit exceeded') ||
+        (lower.includes('quota limit') && lower.includes('you can resume')) ||
+        lower.includes('you have reached the quota limit') ||
+        lower.includes('spending cap reached') ||
+        lower.includes('usage cap reached') ||
+        lower.includes('rate limit reached');
+
+      if (!hasGeminiQuota) {
+        return { isRateLimited: false };
+      }
+
+      const resumeAtMatch = text.match(/resume\s+(?:using\s+this\s+model\s+)?at\s+(\d{1,2}\/\d{1,2}\/\d{4})\s*,?\s*(\d{1,2}:\d{2}(?::\d{2})?)\s*(AM|PM)/i);
+      const resumeAt = resumeAtMatch
+        ? `${resumeAtMatch[1]}, ${resumeAtMatch[2]} ${resumeAtMatch[3].toUpperCase()}`
+        : undefined;
+
+      return {
+        isRateLimited: true,
+        message: text,
+        resumeAt
+      };
+    } catch (error) {
+      return {
+        isRateLimited: false,
+        note: `Failed to check Antigravity quota: ${error.message}`
+      };
+    }
+  }
+
   /**
    * Handle Antigravity quota limit by automatically switching models
    * @returns {Promise<{success: boolean, model?: string, error?: string}>}
@@ -617,7 +839,7 @@ class AppleScriptManager {
 
                 -- Look for model dropdown/menu items
                 -- Try alternative models in order of preference
-                set modelNames to {"Gemini 3 Pro (Low)", "Claude Sonnet 4.5", "Claude Sonnet 4.5 (Thinking)", "GPT-OSS 120B (Medium)"}
+                set modelNames to {"Gemini 3 Flash", "Gemini 3 Pro (High)", "Gemini 3 Pro (Low)", "Claude Sonnet 4.5", "Claude Sonnet 4.5 (Thinking)", "Claude Opus 4.5 (Thinking)", "GPT-OSS 120B (Medium)"}
 
                 repeat with modelName in modelNames
                   try
@@ -626,7 +848,7 @@ class AppleScriptManager {
 
                     -- Try menu items
                     try
-                      set modelItems to menu items of menu 1 of window 1 whose name is modelName
+                      set modelItems to menu items of menu 1 of window 1 whose name contains modelName
                     end try
 
                     -- Try buttons if no menu items found
@@ -636,6 +858,22 @@ class AppleScriptManager {
                       end try
                     end if
 
+                    -- Search in groups
+                    if (count of modelItems) = 0 then
+                      try
+                        set allGroups to groups of window 1
+                        repeat with grp in allGroups
+                          try
+                            set matchingItems to (every UI element of grp whose name contains modelName)
+                            if (count of matchingItems) > 0 then
+                              set modelItems to matchingItems
+                              exit repeat
+                            end if
+                          end try
+                        end repeat
+                      end try
+                    end if
+
                     if (count of modelItems) > 0 then
                       click item 1 of modelItems
                       delay 0.8
@@ -711,6 +949,14 @@ class AppleScriptManager {
         return await this.openAntigravity(repoPath);
       case 'vscode':
         return await this.openVSCode(repoPath);
+      case 'github-copilot':
+        // Open VS Code with GitHub Copilot extension
+        return await this.openVSCodeWithExtension('github-copilot', repoPath);
+      case 'amazon-q':
+        // Open VS Code with Amazon Q extension
+        return await this.openVSCodeWithExtension('amazon-q', repoPath);
+      case 'replit':
+        return await this.openReplit(repoPath);
       case 'kiro':
         return await this.openKiro(repoPath);
       case 'claude':
@@ -721,7 +967,7 @@ class AppleScriptManager {
       default:
         return {
           success: false,
-          error: `Unknown IDE: ${ide}. Supported: cursor, windsurf, antigravity, vscode, claude, claude-code, gemini`
+          error: `Unknown IDE: ${ide}. Supported: cursor, windsurf, antigravity, vscode, github-copilot, amazon-q, replit, kiro, claude, claude-code, gemini`
         };
     }
   }
@@ -833,7 +1079,23 @@ class AppleScriptManager {
 
           -- Press Enter (increased delay for chat window to fully open)
           key code 36
-          delay 2.5
+          delay 3.0
+
+          -- Additional step for Amazon Q: ensure it's properly focused
+          ${extension === 'amazon-q' ? `
+          -- Wait for Amazon Q to fully load and then ensure focus
+          delay 1.0
+          -- Try to set focus to the Amazon Q chat input
+          try
+            -- Look for the Amazon Q chat input field and focus it
+            keystroke tab
+            delay 0.5
+            keystroke tab
+            delay 0.5
+          on error
+            -- If tab navigation fails, continue
+          end try
+          ` : ''}
 
 
           -- Type the message (increased delay for input field to be ready)
@@ -1231,8 +1493,9 @@ class AppleScriptManager {
       } else if (ide === 'cursor') {
         // Cursor already has new chat logic in generateAIPanelFocusScript (Cmd+T)
         appleScript = this.appleScriptUtils.generateAIPanelFocusScript(text, 'Cursor');
-      } else if (ide === 'vscode') {
+      } else if (ide === 'vscode' || ide === 'github-copilot' || ide === 'amazon-q') {
         // Delegate to the dedicated VS Code method
+        // github-copilot and amazon-q are VS Code extensions
         return await this.sendTextToVSCode(text);
       } else if (ide === 'antigravity') {
         // AppleScript for Google Antigravity - Cmd+Shift+L opens Agent chat (non-toggle)
@@ -1311,7 +1574,7 @@ class AppleScriptManager {
         return {
           success: false,
           error: `Unsupported IDE for AppleScript: ${ide}`,
-          note: 'AppleScript is only supported for Cursor, Windsurf, Antigravity, VS Code, and AWS Kiro'
+          note: 'AppleScript is only supported for Cursor, Windsurf, Antigravity, VS Code, GitHub Copilot, Amazon Q, AWS Kiro, and Claude'
         };
       }
 
@@ -1353,6 +1616,28 @@ class AppleScriptManager {
     } catch (error) {
       this.logger.log('AppleScript interaction failed:', error.message);
 
+      // Check for Accessibility permission error
+      if (error.message.includes('not allowed to send keystrokes') ||
+        error.message.includes('assistive devices') ||
+        (error.message.includes('System Events') && error.message.includes('not allowed'))) {
+
+        this.logger.log('⚠️ Accessibility permissions missing. Opening System Settings...');
+        try {
+          // Open System Settings -> Privacy & Security -> Accessibility
+          execSync('open "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility"');
+        } catch (settingsErr) {
+          this.logger.log('Failed to open System Settings:', settingsErr.message);
+        }
+
+        return {
+          success: false,
+          error: 'Missing Accessibility Permissions',
+          message: 'Please grant Accessibility permissions to Terminal/Node in System Settings',
+          permissionError: true,
+          note: 'macOS blocked keystroke automation. Opened settings for user.'
+        };
+      }
+
       // For Claude, don't fall back to simulated response - return actual failure
       if (ide === 'claude' || ide === 'claude-code') {
         return {
@@ -1363,6 +1648,16 @@ class AppleScriptManager {
         };
       }
 
+      // For Antigravity, also return failure to trigger user notification in auto.js
+      if (ide === 'antigravity' || ide === 'kiro') {
+        return {
+          success: false,
+          method: 'applescript',
+          error: `Failed to send text to ${ideName}: ${error.message}`,
+          note: `${ideName} automation failed.`
+        };
+      }
+
       // For other IDEs, fall back to simulated response
       return {
         success: true,
@@ -2937,6 +3232,260 @@ end tell
       };
     }
   }
+
+  /**
+   * Check if an IDE is running and accessible
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async getIDEStatus(ide) {
+    if (!ide || typeof ide !== 'string') {
+      return {
+        success: false,
+        error: 'Invalid IDE name provided',
+        running: false
+      };
+    }
+
+    try {
+      this.logger.log(`🔍 Checking status of ${ide}...`);
+      
+      switch (ide.toLowerCase()) {
+        case 'cursor':
+          return await this._checkCursorStatus();
+        case 'vscode':
+          return await this._checkVSCodeStatus();
+        case 'windsurf':
+          return await this._checkWindsurfStatus();
+        case 'antigravity':
+          return await this._checkAntigravityStatus();
+        case 'cline':
+          return await this._checkClineStatus();
+        default:
+          return {
+            success: false,
+            error: `Unsupported IDE: ${ide}`,
+            running: false
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to check IDE status: ${error.message}`,
+        running: false
+      };
+    }
+  }
+
+  /**
+   * Check Cursor status
+   * @private
+   */
+  async _checkCursorStatus() {
+    try {
+      const script = `
+        tell application "System Events"
+          set isRunning to (exists process "Cursor")
+          if isRunning then
+            try
+              tell application "Cursor" to activate
+              delay 0.5
+              return "running"
+            on error
+              return "error"
+            end try
+          else
+            return "not_running"
+          end if
+        end tell
+      `;
+      
+      const result = this.appleScriptUtils.executeAppleScript(script);
+      const running = result.includes('running');
+      
+      return {
+        success: true,
+        running,
+        status: running ? 'running' : 'not_running',
+        message: running ? 'Cursor is running and accessible' : 'Cursor is not running'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to check Cursor status: ${error.message}`,
+        running: false
+      };
+    }
+  }
+
+  /**
+   * Check VS Code status
+   * @private
+   */
+  async _checkVSCodeStatus() {
+    try {
+      const script = `
+        tell application "System Events"
+          set isRunning to (exists process "Code")
+          if isRunning then
+            try
+              tell application "Visual Studio Code" to activate
+              delay 0.5
+              return "running"
+            on error
+              return "error"
+            end try
+          else
+            return "not_running"
+          end if
+        end tell
+      `;
+      
+      const result = this.appleScriptUtils.executeAppleScript(script);
+      const running = result.includes('running');
+      
+      return {
+        success: true,
+        running,
+        status: running ? 'running' : 'not_running',
+        message: running ? 'VS Code is running and accessible' : 'VS Code is not running'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to check VS Code status: ${error.message}`,
+        running: false
+      };
+    }
+  }
+
+  /**
+   * Check Windsurf status
+   * @private
+   */
+  async _checkWindsurfStatus() {
+    try {
+      const script = `
+        tell application "System Events"
+          set isRunning to (exists process "Windsurf")
+          if isRunning then
+            try
+              tell application "Windsurf" to activate
+              delay 0.5
+              return "running"
+            on error
+              return "error"
+            end try
+          else
+            return "not_running"
+          end if
+        end tell
+      `;
+      
+      const result = this.appleScriptUtils.executeAppleScript(script);
+      const running = result.includes('running');
+      
+      return {
+        success: true,
+        running,
+        status: running ? 'running' : 'not_running',
+        message: running ? 'Windsurf is running and accessible' : 'Windsurf is not running'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to check Windsurf status: ${error.message}`,
+        running: false
+      };
+    }
+  }
+
+  /**
+   * Check Antigravity status
+   * @private
+   */
+  async _checkAntigravityStatus() {
+    try {
+      // Antigravity runs in browser, check if Chrome/Edge is running with Antigravity tab
+      const script = `
+        tell application "System Events"
+          set isChromeRunning to (exists process "Google Chrome")
+          set isEdgeRunning to (exists process "Microsoft Edge")
+          
+          if isChromeRunning then
+            try
+              tell application "Google Chrome" to activate
+              delay 0.5
+              return "running"
+            on error
+              return "error"
+            end try
+          else if isEdgeRunning then
+            try
+              tell application "Microsoft Edge" to activate
+              delay 0.5
+              return "running"
+            on error
+              return "error"
+            end try
+          else
+            return "not_running"
+          end if
+        end tell
+      `;
+      
+      const result = this.appleScriptUtils.executeAppleScript(script);
+      const running = result.includes('running');
+      
+      return {
+        success: true,
+        running,
+        status: running ? 'running' : 'not_running',
+        message: running ? 'Browser is running (Antigravity accessible)' : 'Browser is not running'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to check Antigravity status: ${error.message}`,
+        running: false
+      };
+    }
+  }
+
+  /**
+   * Check Cline status
+   * @private
+   */
+  async _checkClineStatus() {
+    try {
+      // Cline runs in VS Code as an extension
+      const vscodeStatus = await this._checkVSCodeStatus();
+      
+      if (!vscodeStatus.running) {
+        return {
+          success: true,
+          running: false,
+          status: 'not_running',
+          message: 'Cline requires VS Code to be running'
+        };
+      }
+
+      // For now, assume Cline is available if VS Code is running
+      // In a more sophisticated implementation, we could check if the extension is installed
+      return {
+        success: true,
+        running: true,
+        status: 'running',
+        message: 'Cline is available (VS Code running)'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to check Cline status: ${error.message}`,
+        running: false
+      };
+    }
+  }
 }
 
 module.exports = AppleScriptManager;