vibecodingmachine-core 2026.1.3-2209 → 2026.1.22-1441

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

@@ -13,6 +13,589 @@ class AppleScriptManager {
     this.logger = console;
   }
 
+  /**
+   * Best-effort: switch Antigravity's active model to the requested label.
+   * @param {string} modelName
+   * @returns {Promise<{success: boolean, model?: string, error?: string}>}
+   */
+  async switchAntigravityModel(modelName) {
+    try {
+      if (!modelName || typeof modelName !== 'string') {
+        return { success: false, error: 'Invalid model name' };
+      }
+
+      const script = `
+        tell application "System Events"
+          tell process "Antigravity"
+            set frontmost to true
+            delay 0.8
+
+            try
+              set buttonTexts to {"Select another model", "Switch model", "Change model", "Select model", "Try another model", "Choose model"}
+              set foundButton to missing value
+
+              repeat with buttonText in buttonTexts
+                try
+                  set matchingButtons to buttons of window 1 whose name contains buttonText
+                  if (count of matchingButtons) > 0 then
+                    set foundButton to item 1 of matchingButtons
+                    exit repeat
+                  end if
+                end try
+              end repeat
+
+              if foundButton is missing value then
+                repeat with buttonText in buttonTexts
+                  try
+                    set allGroups to groups of window 1
+                    repeat with grp in allGroups
+                      try
+                        set matchingButtons to buttons of grp whose name contains buttonText
+                        if (count of matchingButtons) > 0 then
+                          set foundButton to item 1 of matchingButtons
+                          exit repeat
+                        end if
+                      end try
+                    end repeat
+                    if foundButton is not missing value then exit repeat
+                  end try
+                end repeat
+              end if
+
+              if foundButton is missing value then
+                return "error:button-not-found"
+              end if
+
+              click foundButton
+              delay 1.2
+
+              set modelItems to {}
+              try
+                set modelItems to menu items of menu 1 of window 1 whose name contains "${modelName.replace(/"/g, '\\"')}"
+              end try
+
+              if (count of modelItems) = 0 then
+                try
+                  set modelItems to buttons of window 1 whose name contains "${modelName.replace(/"/g, '\\"')}"
+                end try
+              end if
+
+              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.replace(/"/g, '\\"')}")
+                      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
+                return "error:model-not-found"
+              end if
+
+              click item 1 of modelItems
+              delay 0.6
+              return "success:${modelName.replace(/"/g, '\\"')}"
+            on error errMsg
+              return "error:" & errMsg
+            end try
+          end tell
+        end tell
+      `;
+
+      const result = execSync(`osascript -e '${script.replace(/'/g, "'\\''")}'`, {
+        encoding: 'utf8',
+        timeout: 15000
+      }).trim();
+
+      if (result.startsWith('success:')) {
+        return { success: true, model: result.substring(8) };
+      }
+      return { success: false, error: result };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * 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}`
+      };
+    }
+  }
+
+  /**
+   * Check AWS Kiro UI for quota limit messages
+   * This is best-effort: Kiro may render quota messages in different UI elements or web-based UI
+   * @returns {Promise<{isRateLimited: boolean, message?: string, resumeAt?: string, note?: string}>}
+   */
+  async checkKiroQuotaLimit() {
+    try {
+      // First try AppleScript UI detection
+      const script = `
+        tell application "System Events"
+          set processName to "AWS Kiro"
+          try
+            if not (exists process "AWS Kiro") then
+              set processName to "Kiro"
+            end if
+          on error
+            set processName to "Kiro"
+          end try
+          
+          if not (exists process processName) then
+            return "NOT_RUNNING"
+          end if
+          
+          tell process processName
+            set frontmost to true
+            delay 0.4
+
+            set allText to ""
+            
+            -- Get window title (might contain quota info)
+            try
+              set windowTitle to title of window 1
+              set allText to allText & "WINDOW_TITLE: " & windowTitle & "\\n"
+            end try
+            
+            -- Get window description
+            try
+              set windowDesc to description of window 1
+              set allText to allText & "WINDOW_DESC: " & windowDesc & "\\n"
+            end try
+            
+            -- Get window help text
+            try
+              set windowHelp to help of window 1
+              set allText to allText & "WINDOW_HELP: " & windowHelp & "\\n"
+            end try
+            
+            -- Try to get text from main window
+            try
+              set windowText to (value of static text of window 1 as string)
+              set allText to allText & "WINDOW_STATIC: " & windowText & "\\n"
+            end try
+
+            -- Try to get text from groups in main window
+            try
+              set groupsList to groups of window 1
+              repeat with g in groupsList
+                try
+                  set groupText to (value of static text of g as string)
+                  set allText to allText & "GROUP: " & groupText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from buttons in main window
+            try
+              set buttonsList to buttons of window 1
+              repeat with b in buttonsList
+                try
+                  set buttonText to (name of b as string)
+                  set allText to allText & "BUTTON: " & buttonText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from text fields in main window
+            try
+              set textFieldsList to text fields of window 1
+              repeat with tf in textFieldsList
+                try
+                  set fieldText to (value of tf as string)
+                  set allText to allText & "TEXT_FIELD: " & fieldText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from text views in main window
+            try
+              set textViewsList to text views of window 1
+              repeat with tv in textViewsList
+                try
+                  set viewText to (value of tv as string)
+                  set allText to allText & "TEXT_VIEW: " & viewText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from sheets (dialogs/alerts)
+            try
+              set sheetsList to sheets of window 1
+              repeat with s in sheetsList
+                try
+                  set sheetText to (value of static text of s as string)
+                  set allText to allText & "SHEET: " & sheetText & "\\n"
+                end try
+              end repeat
+            end try
+
+            -- Try to get text from all UI elements (catch-all)
+            try
+              set uiElementsList to every UI element of window 1
+              repeat with element in uiElementsList
+                try
+                  set elementText to value of element as string
+                  if elementText is not missing value and elementText is not "" then
+                    set allText to allText & "UI_ELEMENT: " & elementText & "\\n"
+                  end if
+                end try
+              end repeat
+            end try
+
+            -- Try to get accessibility attributes
+            try
+              set windowRole to role of window 1
+              set allText to allText & "WINDOW_ROLE: " & windowRole & "\\n"
+            end try
+            
+            try
+              set windowSubrole to subrole of window 1
+              set allText to allText & "WINDOW_SUBROLE: " & windowSubrole & "\\n"
+            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' ? 'AWS Kiro not running' : 'No readable UI text'
+        };
+      }
+
+      const text = raw.replace(/\s+/g, ' ').trim();
+      const lower = text.toLowerCase();
+
+      // Check for Kiro-specific quota limit patterns (expanded for better detection)
+      const hasKiroQuota = lower.includes('quota limit exceeded') ||
+        lower.includes('usage limit reached') ||
+        lower.includes('rate limit exceeded') ||
+        lower.includes('api limit exceeded') ||
+        lower.includes('request limit exceeded') ||
+        lower.includes('too many requests') ||
+        lower.includes('quota exceeded') ||
+        lower.includes('limit exceeded') ||
+        lower.includes('usage exceeded') ||
+        lower.includes('rate limited') ||
+        lower.includes('api limited') ||
+        lower.includes('request limited') ||
+        lower.includes('quota reached') ||
+        lower.includes('limit reached') ||
+        lower.includes('usage reached') ||
+        lower.includes('cap reached') ||
+        lower.includes('cap exceeded') ||
+        lower.includes('spending cap') ||
+        lower.includes('usage cap') ||
+        lower.includes('daily limit') ||
+        lower.includes('monthly limit') ||
+        lower.includes('hourly limit') ||
+        lower.includes('request limit') ||
+        lower.includes('token limit') ||
+        lower.includes('credit limit') ||
+        lower.includes('billing limit') ||
+        lower.includes('subscription limit') ||
+        lower.includes('plan limit') ||
+        lower.includes('tier limit') ||
+        lower.includes('upgrade required') ||
+        lower.includes('upgrade needed') ||
+        lower.includes('upgrade to pro') ||
+        lower.includes('upgrade to premium') ||
+        lower.includes('upgrade plan') ||
+        lower.includes('increase limit') ||
+        lower.includes('exhausted') ||
+        lower.includes('no more requests') ||
+        lower.includes('no more credits') ||
+        lower.includes('insufficient credits') ||
+        lower.includes('insufficient quota') ||
+        lower.includes('maximum reached') ||
+        lower.includes('max requests') ||
+        lower.includes('max usage') ||
+        lower.includes('over limit') ||
+        lower.includes('over quota') ||
+        lower.includes('over usage') ||
+        lower.includes('out of credits') ||
+        lower.includes('out of credit') ||
+        lower.includes('credits exhausted') ||
+        lower.includes('credits depleted') ||
+        lower.includes('credits used up') ||
+        lower.includes('credit exhausted') ||
+        lower.includes('credit depleted') ||
+        lower.includes('credit used up') ||
+        lower.includes('credit balance is too low') ||
+        lower.includes('not enough credits') ||
+        lower.includes('credits: 0') ||
+        lower.includes('credit balance: 0') ||
+        lower.includes('no credits available') ||
+        lower.includes('purchase more credits') ||
+        lower.includes('credits: 0 remaining') ||
+        lower.includes('credit balance: 0') ||
+        (lower.includes('credits') && (lower.includes('out of') || lower.includes('exhausted') || lower.includes('depleted') || lower.includes('used up'))) ||
+        (lower.includes('credit') && (lower.includes('out of') || lower.includes('exhausted') || lower.includes('depleted') || lower.includes('used up') || lower.includes('balance is too low') || lower.includes('balance: 0'))) ||
+        (lower.includes('quota') && (lower.includes('exceeded') || lower.includes('reached') || lower.includes('exhaust'))) ||
+        (lower.includes('limit') && (lower.includes('exceeded') || lower.includes('reached') || lower.includes('exhaust'))) ||
+        (lower.includes('cap') && (lower.includes('exceeded') || lower.includes('reached') || lower.includes('exhaust')));
+
+      if (hasKiroQuota) {
+        // Try to extract reset time from various formats (expanded for better detection)
+        const resumeAtMatch = text.match(/(?:resume|reset|available|renew|refresh|restart|continue|try again)\s+(?:at|in|on)\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;
+
+        // Also try other time formats
+        if (!resumeAt) {
+          const timeMatch = text.match(/(?:try again|resume|reset|available|renew|refresh|restart|continue)\s+(?:in|after)\s+(\d+)\s*(?:minutes?|hours?|days?|seconds?)/i);
+          if (timeMatch) {
+            // For "in X minutes/hours/days" format, we'll return the raw text
+            return {
+              isRateLimited: true,
+              message: text,
+              resumeTime: timeMatch[1] + ' ' + timeMatch[2]
+            };
+          }
+        }
+
+        // Try specific time patterns like "resets at 12pm" or "resets at 3:30 PM"
+        if (!resumeAt) {
+          const timeOnlyMatch = text.match(/(?:resets|reset|resume|available)\s+(?:at|@)\s+(\d{1,2}:\d{2}(?::\d{2})?)\s*(am|pm)?/i);
+          if (timeOnlyMatch) {
+            const time = timeOnlyMatch[1] + (timeOnlyMatch[2] ? ' ' + timeOnlyMatch[2].toUpperCase() : '');
+            return {
+              isRateLimited: true,
+              message: text,
+              resumeTime: time
+            };
+          }
+        }
+
+        // Try date patterns like "resets on January 15" or "resets on 1/15"
+        if (!resumeAt) {
+          const dateMatch = text.match(/(?:resets|reset|resume|available)\s+(?:on|at)\s+(\d{1,2}\/\d{1,2})(?:\/\d{4})?/i);
+          if (dateMatch) {
+            return {
+              isRateLimited: true,
+              message: text,
+              resumeTime: dateMatch[1]
+            };
+          }
+        }
+
+        return {
+          isRateLimited: true,
+          message: text,
+          resumeAt
+        };
+      }
+
+      // If AppleScript didn't find quota messages, try fallback methods
+      return await this.checkKiroQuotaLimitFallback();
+
+    } catch (error) {
+      return {
+        isRateLimited: false,
+        note: `Failed to check AWS Kiro quota: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Fallback method to check Kiro quota using alternative approaches
+   * @returns {Promise<{isRateLimited: boolean, message?: string, note?: string}>}
+   */
+  async checkKiroQuotaLimitFallback() {
+    try {
+      // Method 1: Check if Kiro process is running and consuming high CPU (might indicate quota error)
+      const processCheck = execSync('ps aux | grep -i kiro | grep -v grep', {
+        encoding: 'utf8',
+        timeout: 3000
+      }).trim();
+
+      if (!processCheck) {
+        return {
+          isRateLimited: false,
+          note: 'AWS Kiro process not found'
+        };
+      }
+
+      // Method 2: Check for system notifications (macOS notifications about quota)
+      try {
+        const notifications = execSync('log show --predicate \'subsystem == "com.apple.notificationcenter"\' --info --last 5m | grep -i "kiro\\|quota\\|limit"', {
+          encoding: 'utf8',
+          timeout: 5000
+        }).trim();
+
+        if (notifications) {
+          const lower = notifications.toLowerCase();
+          if (lower.includes('quota') || lower.includes('limit') || lower.includes('exceeded')) {
+            return {
+              isRateLimited: true,
+              message: 'Quota limit detected in system notifications',
+              note: 'Detected via system notifications'
+            };
+          }
+        }
+      } catch (notifError) {
+        // Notifications check failed, continue
+      }
+
+      // Method 3: Check console logs for Kiro-related quota messages
+      try {
+        const consoleLogs = execSync('log show --predicate \'process == "Kiro" OR process == "AWS Kiro"\' --info --last 10m | grep -i "quota\\|limit\\|exceeded\\|error"', {
+          encoding: 'utf8',
+          timeout: 5000
+        }).trim();
+
+        if (consoleLogs) {
+          const lower = consoleLogs.toLowerCase();
+          if (lower.includes('quota') || lower.includes('limit') || lower.includes('exceeded')) {
+            return {
+              isRateLimited: true,
+              message: 'Quota limit detected in console logs',
+              note: 'Detected via console logs'
+            };
+          }
+        }
+      } catch (logError) {
+        // Console log check failed, continue
+      }
+
+      // Method 4: Check if Kiro window title contains quota information
+      try {
+        const windowTitle = execSync(`osascript -e '
+          tell application "System Events"
+            set processName to "AWS Kiro"
+            try
+              if not (exists process "AWS Kiro") then
+                set processName to "Kiro"
+              end if
+            on error
+              set processName to "Kiro"
+            end try
+            
+            if exists process processName then
+              return title of window 1 of process processName
+            end if
+          end tell
+        '`, {
+          encoding: 'utf8',
+          timeout: 3000
+        }).trim();
+
+        if (windowTitle) {
+          const lower = windowTitle.toLowerCase();
+          if (lower.includes('quota') || lower.includes('limit') || lower.includes('exceeded')) {
+            return {
+              isRateLimited: true,
+              message: `Quota limit detected in window title: ${windowTitle}`,
+              note: 'Detected via window title'
+            };
+          }
+        }
+      } catch (titleError) {
+        // Window title check failed, continue
+      }
+
+      return {
+        isRateLimited: false,
+        note: 'No quota limit detected via fallback methods'
+      };
+
+    } catch (error) {
+      return {
+        isRateLimited: false,
+        note: `Fallback quota check failed: ${error.message}`
+      };
+    }
+  }
+
   /**
    * Open Cursor IDE
    * @returns {Promise<Object>} Result object with success status and details
@@ -169,6 +752,170 @@ class AppleScriptManager {
     }
   }
 
+  /**
+   * Open VS Code with optional repository path
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openVSCode(repoPath = null) {
+    try {
+      this.logger.log('Opening VS Code with remote debugging enabled...');
+
+      // 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 = `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 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);
+      return { success: false, error: error.message, method: 'applescript' };
+    }
+  }
+
+  /**
+   * 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...');
+
+      // Replit typically uses web browser, so we'll open the Replit website
+      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}"`;
+      } else if (this.platform === 'win32') {
+        command = `start "" "${replitUrl}"`;
+      } else {
+        command = `xdg-open "${replitUrl}"`;
+      }
+
+      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' };
+    }
+  }
+
   /**
    * Handle Antigravity quota limit by automatically switching models
    * @returns {Promise<{success: boolean, model?: string, error?: string}>}
@@ -224,7 +971,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
@@ -233,7 +980,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
@@ -243,6 +990,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
@@ -310,12 +1073,27 @@ class AppleScriptManager {
         return await this.openWindsurf(repoPath);
       case 'antigravity':
         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':
+      case 'claude-code':
+        return await this.openClaude(repoPath);
+      case 'gemini':
+        return await this.openGemini(repoPath);
       default:
         return {
           success: false,
-          error: `Unknown IDE: ${ide}. Supported: cursor, windsurf, antigravity, kiro`
+          error: `Unknown IDE: ${ide}. Supported: cursor, windsurf, antigravity, vscode, github-copilot, amazon-q, replit, kiro, claude, claude-code, gemini`
         };
     }
   }
@@ -416,6 +1194,32 @@ class AppleScriptManager {
             end tell
           end tell
         `;
+      } else if (ide === 'vscode' || ide === 'github-copilot' || ide === 'amazon-q') {
+        // AppleScript for VS Code (including GitHub Copilot and Amazon Q extensions)
+        appleScript = `
+          tell application "System Events"
+            tell process "Code"
+              set frontmost to true
+              delay 1.0
+
+              -- Focus GitHub Copilot chat with Cmd+Shift+I or open chat panel
+              key code 34 using {command down, shift down}
+              delay 1.0
+
+              -- Type the message using clipboard (more reliable)
+              set the clipboard to "${text.replace(/"/g, '\\"')}"
+              delay 0.5
+              key code 9 using {command down} -- Cmd+V to paste
+              delay 0.5
+
+              -- Press Cmd+Enter to send
+              key code 36 using {command down}
+              delay 1.0
+
+              return "Message sent to VS Code"
+            end tell
+          end tell
+        `;
       } else if (ide === 'antigravity') {
         // AppleScript for Google Antigravity - Cmd+Shift+L opens Agent chat (non-toggle)
         appleScript = `
@@ -504,7 +1308,7 @@ class AppleScriptManager {
         return {
           success: false,
           error: `Unsupported IDE for AppleScript: ${ide}`,
-          note: 'AppleScript is only supported for Cursor, Windsurf, Antigravity, VS Code, AWS Kiro, and Claude'
+          note: 'AppleScript is only supported for Cursor, Windsurf, Antigravity, VS Code, GitHub Copilot, Amazon Q, AWS Kiro, and Claude'
         };
       }
 
@@ -1158,6 +1962,260 @@ class AppleScriptManager {
       throw error;
     }
   }
+
+  /**
+   * 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 = execSync(`osascript -e '${script}'`, { stdio: 'pipe', encoding: 'utf8' });
+      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 = execSync(`osascript -e '${script}'`, { stdio: 'pipe', encoding: 'utf8' });
+      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 = execSync(`osascript -e '${script}'`, { stdio: 'pipe', encoding: 'utf8' });
+      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 = execSync(`osascript -e '${script}'`, { stdio: 'pipe', encoding: 'utf8' });
+      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 };