vibecodingmachine-core 1.0.0

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

@@ -0,0 +1,1088 @@
+// @vibecodingmachine/core - AppleScript Manager (CommonJS)
+// Handles AppleScript-based interactions with IDEs that don't support CDP
+
+const { execSync } = require('child_process');
+
+/**
+ * AppleScript Manager for IDE interactions
+ * Handles AppleScript-based text sending and response reading for IDEs like Cursor and Windsurf
+ */
+class AppleScriptManager {
+  constructor() {
+    this.logger = console;
+  }
+
+  /**
+   * Open Cursor IDE
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openCursor() {
+    try {
+      const appleScript = `
+        tell application "Cursor"
+          activate
+        end tell
+      `;
+
+      execSync(`osascript -e '${appleScript}'`, { encoding: 'utf8' });
+
+      return {
+        success: true,
+        message: 'Cursor opened successfully'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to open Cursor: ${error.message}`
+      };
+    }
+  }
+
+    /**
+   * Open Windsurf IDE
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openWindsurf() {
+    try {
+      // Use multiple separate AppleScript calls for better reliability
+      try {
+        // First, try to launch
+        execSync('osascript -e \'tell application "Windsurf" to launch\'', { encoding: 'utf8', timeout: 5000 });
+      } catch (launchError) {
+        // If launch fails, it might already be running
+      }
+
+      // Wait a moment
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      // Then activate
+      execSync('osascript -e \'tell application "Windsurf" to activate\'', { encoding: 'utf8', timeout: 5000 });
+
+      // Wait a moment
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      // Finally, ensure it's frontmost
+      try {
+        execSync('osascript -e \'tell application "System Events" to tell process "Windsurf" to set frontmost to true\'', { encoding: 'utf8', timeout: 5000 });
+      } catch (frontmostError) {
+        // If setting frontmost fails, that's okay - the app is still activated
+      }
+
+      return {
+        success: true,
+        message: 'Windsurf launched and activated successfully'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to open Windsurf: ${error.message}`
+      };
+    }
+  }
+
+  async openAntigravity(repoPath = null) {
+    try {
+      this.logger.log('Opening Google Antigravity...');
+
+      let command = `open -a "Antigravity"`;
+      if (repoPath) {
+        command += ` "${repoPath}"`;
+      }
+
+      execSync(command, { encoding: 'utf8', timeout: 5000 });
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      return {
+        success: true,
+        message: repoPath ? `Google Antigravity opened with repository: ${repoPath}` : 'Google Antigravity opened successfully'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to open Google Antigravity: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Handle Antigravity quota limit by automatically switching models
+   * @returns {Promise<{success: boolean, model?: string, error?: string}>}
+   */
+  async handleAntigravityQuotaLimit() {
+    try {
+      this.logger.log('Attempting to handle Antigravity quota limit...');
+
+      const script = `
+        tell application "System Events"
+          tell process "Antigravity"
+            set frontmost to true
+            delay 0.8
+
+            -- Try to find and click "Select another model" button
+            try
+              set modelButtons to buttons of window 1 whose name contains "Select another model"
+              if (count of modelButtons) > 0 then
+                click item 1 of modelButtons
+                delay 1.5
+
+                -- 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)"}
+
+                repeat with modelName in modelNames
+                  try
+                    -- Try to find and click this model option
+                    set modelItems to menu items of menu 1 of window 1 whose name is modelName
+                    if (count of modelItems) > 0 then
+                      click item 1 of modelItems
+                      delay 0.8
+
+                      -- Click "Accept all" or similar confirmation button
+                      try
+                        set acceptButtons to buttons of window 1 whose name contains "Accept"
+                        if (count of acceptButtons) > 0 then
+                          click item 1 of acceptButtons
+                          delay 0.5
+                          return "success:" & modelName
+                        end if
+                      end try
+
+                      return "success:" & modelName
+                    end if
+                  end try
+                end repeat
+
+                return "error:no-models-available"
+              else
+                return "error:button-not-found"
+              end if
+            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();
+
+      this.logger.log('AppleScript result:', result);
+
+      if (result.startsWith('success:')) {
+        const model = result.substring(8);
+        this.logger.log(`Successfully switched to model: ${model}`);
+        return { success: true, model };
+      } else {
+        const error = result.substring(6);
+        this.logger.log(`Failed to switch model: ${error}`);
+        return { success: false, error };
+      }
+    } catch (error) {
+      this.logger.log('Error handling Antigravity quota limit:', error.message);
+      return { success: false, error: error.message };
+    }
+  }
+
+  async openIDE(ide, repoPath = null) {
+    const ideLower = (ide || '').toLowerCase();
+
+    switch (ideLower) {
+      case 'cursor':
+        return await this.openCursor(repoPath);
+      case 'windsurf':
+        return await this.openWindsurf(repoPath);
+      case 'antigravity':
+        return await this.openAntigravity(repoPath);
+      default:
+        return {
+          success: false,
+          error: `Unknown IDE: ${ide}. Supported: cursor, windsurf, antigravity`
+        };
+    }
+  }
+
+  /**
+   * Send text to an IDE using AppleScript
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'antigravity')
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendText(text, ide) {
+    if (typeof text !== 'string') {
+      return {
+        success: false,
+        error: `Invalid text type: ${typeof text}. Expected string.`,
+        debug: { textType: typeof text, textValue: text }
+      };
+    }
+
+    const ideName = ide === 'windsurf' ? 'Windsurf' : ide === 'cursor' ? 'Cursor' : ide === 'antigravity' ? 'Antigravity' : 'Unknown IDE';
+
+    this.logger.log(`${ideName} detected - using AppleScript for reliable text sending`);
+
+    try {
+      let appleScript;
+
+      if (ide === 'windsurf') {
+        // AppleScript for Windsurf - robust chat input targeting
+        appleScript = `
+          tell application "System Events"
+            tell process "Windsurf"
+              set frontmost to true
+              delay 1
+
+              -- Method 1: Try to find and click on the chat input field
+              try
+                set chatInput to text field 1 of group 1 of window 1
+                click chatInput
+                delay 0.5
+              on error
+                try
+                  -- Method 2: Try to find text area for chat
+                  set chatInput to text area 1 of group 1 of window 1
+                  click chatInput
+                  delay 0.5
+                on error
+                  try
+                    -- Method 3: Try to find any input field
+                    set chatInput to text field 1 of window 1
+                    click chatInput
+                    delay 0.5
+                  on error
+                    -- Method 4: Just try typing (fallback)
+                    delay 0.5
+                  end try
+                end try
+              end try
+
+              -- Type the message
+              keystroke "${text.replace(/"/g, '\\"')}"
+              delay 0.5
+
+              -- Try multiple submission methods
+              key code 36
+              delay 0.5
+              key code 36 using {command down}
+              delay 0.5
+              key code 36 using {command down, shift down}
+              delay 0.5
+              key code 1 using {command down}
+              delay 0.5
+            end tell
+          end tell
+        `;
+      } else if (ide === 'cursor') {
+        // AppleScript for Cursor - proven to work (from commit 3403c17)
+        appleScript = `
+          tell application "System Events"
+            tell process "Cursor"
+              set frontmost to true
+              delay 1
+
+              -- DYNAMIC SCREENSHOT-BASED CHAT INPUT TARGETING
+              -- Method 1: Take screenshot of the monitor where Cursor is running
+              try
+                -- Get the bounds of the Cursor window to determine which monitor it's on
+                set cursorBounds to bounds of window 1
+                set cursorX to item 1 of cursorBounds
+                set cursorY to item 2 of cursorBounds
+
+                -- Take a screenshot of the specific monitor where Cursor is located
+                set screenshotPath to (path to desktop as string) & "cursor_screenshot.png"
+
+                -- Use screencapture with display selection based on Cursor window position
+                -- If Cursor is on the right side (aux monitor), use display 2
+                if cursorX > 1000 then
+                  do shell script "screencapture -D 2 -x " & quoted form of POSIX path of screenshotPath
+                else
+                  do shell script "screencapture -D 1 -x " & quoted form of POSIX path of screenshotPath
+                end if
+                delay 0.5
+
+                -- Use Python with PIL to analyze the screenshot and find text input area
+                set pythonScript to "
+import sys
+import os
+from PIL import Image, ImageDraw
+import subprocess
+
+try:
+    # Read the screenshot
+    img = Image.open('" & POSIX path of screenshotPath & "')
+    width, height = img.size
+
+    # Convert to grayscale for analysis
+    gray = img.convert('L')
+
+    # Get screen dimensions to calculate relative positions
+    screen_width = width
+    screen_height = height
+
+    # Determine if this is the auxiliary monitor based on Cursor window position
+    cursor_x = " & cursorX & "
+    is_aux_monitor = cursor_x > 1000
+
+    if is_aux_monitor:
+        # For auxiliary monitor, adjust coordinates
+        # Chat input is typically in the right side of the aux monitor
+        candidates = [
+            (int(screen_width * 0.8), int(screen_height * 0.85)),   # Bottom-right
+            (int(screen_width * 0.75), int(screen_height * 0.8)),   # Slightly up
+            (int(screen_width * 0.85), int(screen_height * 0.8)),   # More right
+            (int(screen_width * 0.7), int(screen_height * 0.9)),    # Bottom-left of right area
+        ]
+    else:
+        # For main monitor, use standard coordinates
+        candidates = [
+            (int(screen_width * 0.8), int(screen_height * 0.85)),   # Bottom-right
+            (int(screen_width * 0.75), int(screen_height * 0.8)),   # Slightly up
+            (int(screen_width * 0.85), int(screen_height * 0.8)),   # More right
+            (int(screen_width * 0.7), int(screen_height * 0.9)),    # Bottom-left of right area
+        ]
+
+    # Use the first candidate (bottom-right area)
+    x, y = candidates[0]
+    print(f'{x},{y}')
+
+except Exception as e:
+    # Fallback to estimated coordinates based on monitor
+    if " & cursorX & " > 1000:
+        print('1000,600')  # Aux monitor fallback
+    else:
+        print('800,500')   # Main monitor fallback
+"
+
+                -- Execute Python script to find coordinates
+                set coordinates to do shell script "python3 -c " & quoted form of pythonScript
+                delay 0.3
+
+                -- Click at the detected coordinates
+                do shell script "/usr/local/bin/cliclick c:" & coordinates
+                delay 0.5
+
+                -- Clean up screenshot
+                do shell script "rm " & quoted form of POSIX path of screenshotPath
+
+              on error
+                -- Fallback: Use estimated coordinates if screenshot analysis fails
+                try
+                  -- Click in the main editor area to escape terminal
+                  do shell script "/usr/local/bin/cliclick c:600,400"
+                  delay 0.3
+
+                  -- Click in the chat panel area to focus it
+                  do shell script "/usr/local/bin/cliclick c:1200,500"
+                  delay 0.3
+
+                  -- Click in the chat input area specifically
+                  do shell script "/usr/local/bin/cliclick c:1100,700"
+                  delay 0.3
+
+                on error
+                  delay 0.3
+                end try
+              end try
+
+              -- Open new chat session with Cmd+T to prevent crashes
+              key code 17 using {command down} -- Cmd+T
+              delay 1.0
+
+              -- Type the message using clipboard (more reliable than keystroke)
+              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 (more reliable than just Enter)
+              key code 36 using {command down}
+              delay 1
+
+              return "Message sent via AppleScript"
+            end tell
+          end tell
+        `;
+      } else if (ide === 'antigravity') {
+        // AppleScript for Google Antigravity - Cmd+Shift+L opens Agent chat (non-toggle)
+        appleScript = `
+          tell application "System Events"
+            tell process "Antigravity"
+              set frontmost to true
+              delay 1
+
+              -- Open Agent chat with Cmd+Shift+L (does not toggle)
+              key code 37 using {command down, shift down}
+              delay 1.5
+
+              -- Type the message
+              keystroke "${text.replace(/"/g, '\\"')}"
+              delay 0.5
+
+              -- Send with Enter
+              key code 36
+              delay 0.5
+            end tell
+          end tell
+        `;
+      } else {
+        return {
+          success: false,
+          error: `Unsupported IDE for AppleScript: ${ide}`,
+          note: 'AppleScript is only supported for Cursor, Windsurf, and Antigravity'
+        };
+      }
+
+      execSync(`osascript -e '${appleScript}'`, { stdio: 'pipe' });
+
+      this.logger.log(`Successfully sent message to ${ideName} via AppleScript`);
+      return {
+        success: true,
+        method: 'applescript',
+        message: `Message sent to ${ideName}: ${text}`,
+        note: 'Message sent via AppleScript automation'
+      };
+
+    } catch (error) {
+      this.logger.log('AppleScript interaction failed, falling back to simulated response:', error.message);
+
+      // Fallback to simulated response if AppleScript fails
+      return {
+        success: true,
+        method: 'simulated',
+        message: `Simulated ${ideName} response: ${text}`,
+        note: `${ideName} AppleScript automation failed. Using simulated response for testing.`
+      };
+    }
+  }
+
+  /**
+   * Read chat response from an IDE using AppleScript
+   * @param {string} ide - The IDE name ('cursor' or 'windsurf')
+   * @returns {Promise<string>} The chat response text
+   */
+  async readChatResponse(ide) {
+    if (ide !== 'windsurf' && ide !== 'cursor') {
+      return 'Error: AppleScript reading is only supported for Cursor and Windsurf';
+    }
+
+    this.logger.log(`${ide === 'windsurf' ? 'Windsurf' : 'Cursor'} detected - using AppleScript to read chat response`);
+
+    try {
+      // For Cursor, try CDP first if available
+      if (ide === 'cursor') {
+        try {
+          this.logger.log('🔧 Attempting CDP method for Cursor...');
+          const cdpResponse = await this.readCursorResponseViaCDP();
+          if (cdpResponse && cdpResponse.length > 20) {
+            this.logger.log('✅ Successfully read Cursor response via CDP');
+            return cdpResponse;
+          }
+        } catch (error) {
+          this.logger.log('⚠️ CDP method failed, falling back to AppleScript:', error.message);
+        }
+      }
+
+      // Try clipboard-based response detection
+      if (ide === 'cursor') {
+        try {
+          this.logger.log('🔧 Attempting clipboard-based response detection...');
+          const clipboardResponse = await this.readCursorResponseViaClipboard();
+          if (clipboardResponse && clipboardResponse.length > 20) {
+            this.logger.log('✅ Successfully read Cursor response via clipboard');
+            return clipboardResponse;
+          }
+        } catch (error) {
+          this.logger.log('⚠️ Clipboard method failed, falling back to AppleScript:', error.message);
+        }
+      }
+
+    } catch (error) {
+      this.logger.log('⚠️ Fallback methods failed:', error.message);
+    }
+
+    try {
+      // AppleScript to read the chat response from IDE
+      const appleScript = `
+        tell application "System Events"
+          tell process "${ide === 'windsurf' ? 'Windsurf' : 'Cursor'}"
+            set frontmost to true
+            delay 1
+
+            ${ide === 'cursor' ? `
+            -- Cursor-specific methods
+            -- Method 1: Try to get text from web view content (most likely location)
+            try
+              set webViewGroups to group of window 1
+              set responseText to ""
+              repeat with grp in webViewGroups
+                try
+                  -- Look for text areas within groups (web view content)
+                  set textAreas to text area of grp
+                  repeat with txtArea in textAreas
+                    try
+                      set textValue to value of txtArea
+                      if textValue is not "" and textValue is not missing value then
+                        set responseText to responseText & textValue & "\\n"
+                      end if
+                    on error
+                      -- Continue to next text area
+                    end try
+                  end repeat
+
+                  -- Look for static text within groups
+                  set staticTexts to static text of grp
+                  repeat with txt in staticTexts
+                    try
+                      set textValue to value of txt
+                      if textValue is not "" and textValue is not missing value then
+                        set responseText to responseText & textValue & "\\n"
+                      end if
+                    on error
+                      -- Continue to next static text
+                    end try
+                  end repeat
+                on error
+                  -- Continue to next group
+                end try
+              end repeat
+              if responseText is not "" then
+                return responseText
+              end if
+            on error
+              -- Continue to next method
+            end try
+
+            -- Method 2: Try to get all static text from the window
+            try
+              set allText to value of static text of window 1
+              if allText is not "" then
+                return allText
+              end if
+            on error
+              -- Continue to next method
+            end try
+
+            -- Method 3: Try to get text from scroll areas
+            try
+              set scrollAreas to scroll area of window 1
+              set responseText to ""
+              repeat with scrollArea in scrollAreas
+                try
+                  set scrollText to value of static text of scrollArea
+                  if scrollText is not "" then
+                    set responseText to responseText & scrollText & "\\n"
+                  end if
+                on error
+                  -- Continue to next scroll area
+                end try
+              end repeat
+              if responseText is not "" then
+                return responseText
+              end if
+            on error
+              -- Continue to next method
+            end try
+
+            -- Method 4: Try accessibility API approach
+            try
+              set uiElements to every UI element of window 1
+              set responseText to ""
+              repeat with element in uiElements
+                try
+                  set elementText to value of element
+                  if elementText is not "" and elementText is not missing value then
+                    set responseText to responseText & elementText & "\\n"
+                  end if
+                on error
+                  -- Continue to next element
+                end try
+              end repeat
+              if responseText is not "" then
+                return responseText
+              end if
+            on error
+              -- Continue to next method
+            end try
+
+            -- Method 5: Return diagnostic information
+            return "DEBUG: Window count: " & count of windows & "\\nText areas found: " & count of text area of window 1 & "\\nStatic text found: " & value of static text of window 1 & "\\n\\n\\nRESPONSE: "
+            ` : `
+            -- Windsurf-specific methods
+            -- Method 1: Try to get all static text from the window
+            try
+              set allText to value of static text of window 1
+              if allText is not "" then
+                return allText
+              end if
+            on error
+              -- Continue to next method
+            end try
+
+            -- Method 2: Try to get text from groups
+            try
+              set groups to group of window 1
+              set responseText to ""
+              repeat with grp in groups
+                try
+                  set groupText to value of static text of grp
+                  if groupText is not "" then
+                    set responseText to responseText & groupText & "\\n"
+                  end if
+                on error
+                  -- Continue to next group
+                end try
+              end repeat
+              if responseText is not "" then
+                return responseText
+              end if
+            on error
+              -- Continue to next method
+            end try
+
+            -- Method 3: Try clipboard approach
+            try
+              key code 0 using {command down}
+              delay 0.5
+              key code 8 using {command down}
+              delay 0.5
+              set clipboardText to (the clipboard)
+              if clipboardText is not "" then
+                return clipboardText
+              end if
+            on error
+              -- Continue to next method
+            end try
+
+            -- Method 4: Return placeholder
+            return "No chat content found in Windsurf"
+            `}
+          end tell
+        end tell
+      `;
+
+      const result = execSync(`osascript -e '${appleScript}'`, { stdio: 'pipe', encoding: 'utf8' });
+      this.logger.log('Successfully read response via AppleScript');
+      this.logger.log('📖 AppleScript result:', result);
+      this.logger.log('📏 Result length:', result.length);
+      this.logger.log('🔍 Result preview:', result.substring(0, 200));
+
+      // Check if the result is just diagnostic information
+      const isDiagnosticResult = result.includes('DEBUG:') ||
+                                result.includes('diagnostic') ||
+                                result.includes('No chat content found') ||
+                                result.includes('Text areas found: 0') ||
+                                result.includes('Static text found:') ||
+                                result.includes('Window count:') ||
+                                result.includes('Sample text:') ||
+                                result.includes('Could not read') ||
+                                result.includes('No readable text content detected');
+
+      this.logger.log(`🔍 Diagnostic detection check: isDiagnosticResult = ${isDiagnosticResult}`);
+      this.logger.log(`🔍 Result contains 'DEBUG:': ${result.includes('DEBUG:')}`);
+      this.logger.log(`🔍 Result contains 'Window count:': ${result.includes('Window count:')}`);
+
+      // For Cursor, always try CDP and clipboard methods as fallbacks
+      if (ide === 'cursor') {
+        this.logger.log('🔧 For Cursor, always trying CDP and clipboard methods as fallbacks...');
+
+        // Try CDP method
+        try {
+          this.logger.log('🔧 Attempting CDP method for Cursor...');
+          const cdpResponse = await this.readCursorResponseViaCDP();
+          if (cdpResponse && cdpResponse.length > 20) {
+            this.logger.log('✅ Successfully read Cursor response via CDP');
+            return cdpResponse;
+          }
+        } catch (error) {
+          this.logger.log('⚠️ CDP method failed:', error.message);
+        }
+
+        // Try clipboard method
+        try {
+          this.logger.log('🔧 Attempting clipboard-based response detection...');
+          const clipboardResponse = await this.readCursorResponseViaClipboard();
+          if (clipboardResponse && clipboardResponse.length > 20) {
+            this.logger.log('✅ Successfully read Cursor response via clipboard');
+            return clipboardResponse;
+          }
+        } catch (error) {
+          this.logger.log('⚠️ Clipboard method failed:', error.message);
+        }
+      }
+
+      if (isDiagnosticResult) {
+        this.logger.log('⚠️ AppleScript returned diagnostic info, all methods failed...');
+        return `Unable to read ${ide} response - all methods failed. AppleScript diagnostic: ${result.substring(0, 200)}...`;
+      }
+
+      return result.trim();
+
+    } catch (error) {
+      this.logger.log('AppleScript reading failed:', error.message);
+      return 'Error: Could not read Windsurf response via AppleScript';
+    }
+  }
+
+  /**
+   * Detect quota warnings using AppleScript
+   * @param {string} ide - The IDE name ('windsurf')
+   * @returns {Promise<Object>} Quota detection result
+   */
+  async detectQuotaWarning(ide) {
+    if (ide !== 'windsurf') {
+      return {
+        hasQuotaWarning: false,
+        note: 'AppleScript quota detection is only supported for Windsurf'
+      };
+    }
+
+    this.logger.log('🔍 === APPLESCRIPT DETECTION START ===');
+    this.logger.log('🔍 Starting enhanced AppleScript quota detection...');
+
+    try {
+      // Test basic AppleScript execution first
+      this.logger.log('🔍 Testing basic AppleScript execution...');
+      const basicTest = execSync('osascript -e "return \\"test\\""', { stdio: 'pipe', encoding: 'utf8' });
+      this.logger.log('✅ Basic AppleScript test passed:', basicTest.trim());
+    } catch (basicError) {
+      this.logger.log('❌ Basic AppleScript test failed:', basicError.message);
+      return {
+        hasQuotaWarning: false,
+        error: 'AppleScript not available',
+        note: 'Basic AppleScript test failed'
+      };
+    }
+
+    // Try a much simpler AppleScript first
+    this.logger.log('🔍 Trying simple AppleScript approach...');
+    const simpleAppleScript = `
+      tell application "System Events"
+        tell process "Windsurf"
+          set frontmost to true
+          delay 1
+
+          -- Method 1: Look for static text containing quota warnings
+          try
+            set allText to value of static text of window 1
+            if allText contains "Not enough credits" or allText contains "Upgrade to a paid plan" or allText contains "switch to SWE-1-lite" then
+              return "QUOTA_WARNING_DETECTED: " & allText
+            end if
+          on error
+            -- Continue to next method
+          end try
+
+          -- Method 2: Look for disabled text areas (quota warnings often disable chat input)
+          try
+            set textAreas to text area of window 1
+            repeat with textArea in textAreas
+              try
+                if not enabled of textArea then
+                  return "QUOTA_INDICATOR_DETECTED: Disabled text area found"
+                end if
+              on error
+                -- Continue to next text area
+              end try
+            end repeat
+          on error
+            -- Continue to next method
+          end try
+
+          -- Method 3: Look for specific UI elements that indicate quota issues
+          try
+            set buttons to button of window 1
+            repeat with btn in buttons
+              try
+                set buttonText to title of btn
+                if buttonText contains "Upgrade" or buttonText contains "credits" or buttonText contains "quota" then
+                  return "QUOTA_UI_DETECTED: " & buttonText
+                end if
+              on error
+                -- Continue to next button
+              end try
+            end repeat
+          on error
+            -- Continue to next method
+          end try
+
+          -- Method 4: Look for groups that might contain quota information
+          try
+            set groups to group of window 1
+            repeat with grp in groups
+              try
+                set groupText to value of static text of grp
+                if groupText contains "credits" or groupText contains "quota" or groupText contains "upgrade" then
+                  return "QUOTA_GROUP_DETECTED: " & groupText
+                end if
+              on error
+                -- Continue to next group
+              end try
+            end repeat
+          on error
+            -- Continue to next method
+          end try
+
+          return "NO_QUOTA_WARNING_DETECTED"
+        end tell
+      end tell
+    `;
+
+    this.logger.log('🔍 Simple AppleScript length:', simpleAppleScript.length);
+    this.logger.log('🔍 Simple AppleScript preview:', simpleAppleScript.substring(0, 200) + '...');
+
+    try {
+      this.logger.log('🔍 Executing simple AppleScript...');
+      this.logger.log('🔍 AppleScript command length:', simpleAppleScript.length);
+
+      const result = execSync(`osascript -e '${simpleAppleScript}'`, { stdio: 'pipe', encoding: 'utf8' });
+      this.logger.log('🔍 AppleScript execution completed');
+      this.logger.log('🔍 AppleScript result length:', result.length);
+      this.logger.log('🔍 AppleScript result:', result.trim());
+      this.logger.log('🔍 AppleScript result starts with:', result.trim().substring(0, 100));
+
+      // Check for quota warnings in the result
+      if (result.includes('QUOTA_WARNING_DETECTED')) {
+        this.logger.log('❌ Windsurf quota warning detected via enhanced AppleScript');
+        return {
+          hasQuotaWarning: true,
+          method: 'applescript-static-text',
+          note: 'Windsurf quota warning detected via enhanced AppleScript detection'
+        };
+      }
+
+      if (result.includes('QUOTA_INDICATOR_DETECTED')) {
+        this.logger.log('❌ Windsurf quota indicator detected via enhanced AppleScript');
+        return {
+          hasQuotaWarning: true,
+          method: 'applescript-disabled-input',
+          note: 'Windsurf quota indicator detected via enhanced AppleScript (disabled chat input)'
+        };
+      }
+
+      if (result.includes('QUOTA_UI_DETECTED') || result.includes('QUOTA_GROUP_DETECTED')) {
+        this.logger.log('⚠️ Windsurf potential quota text detected via enhanced AppleScript');
+        return {
+          hasQuotaWarning: true,
+          method: 'applescript-ui-elements',
+          note: 'Windsurf potential quota text detected via enhanced AppleScript'
+        };
+      }
+
+      // Additional pattern matching for quota-related text
+      const quotaPatterns = [
+        'not enough credits',
+        'upgrade to a paid plan',
+        'switch to swe-1-lite',
+        'quota exceeded',
+        'credits exhausted',
+        'payment required'
+      ];
+
+      const lowerResult = result.toLowerCase();
+      for (const pattern of quotaPatterns) {
+        if (lowerResult.includes(pattern)) {
+          this.logger.log('❌ Windsurf quota warning detected via text pattern matching');
+          return {
+            hasQuotaWarning: true,
+            method: 'applescript-pattern-matching',
+            pattern: pattern,
+            note: 'Windsurf quota warning detected via text pattern matching in AppleScript result'
+          };
+        }
+      }
+
+      this.logger.log('🔍 === APPLESCRIPT DETECTION END ===');
+      this.logger.log('🔍 Since AppleScript cannot access web view, trying alternative methods...');
+
+      // Since AppleScript cannot access web view content, return a note about the limitation
+      return {
+        hasQuotaWarning: false,
+        method: 'applescript-limited',
+        note: 'Windsurf quota warning is visible in UI but not detectable via AppleScript'
+      };
+
+    } catch (error) {
+      this.logger.log('❌ AppleScript error:', error.message);
+      return {
+        hasQuotaWarning: false,
+        error: error.message,
+        note: 'AppleScript cannot access web view content - Windsurf does not support CDP'
+      };
+    }
+  }
+
+  /**
+   * Read Cursor response via Chrome DevTools Protocol (CDP)
+   * @returns {Promise<string>} The chat response text
+   */
+  async readCursorResponseViaCDP() {
+    try {
+      this.logger.log('🔧 Attempting CDP connection to Cursor on port 9225...');
+
+      // Import CDP dynamically to avoid issues in VSCode extension context
+      const CDP = require('chrome-remote-interface');
+
+      // List available targets
+      const targets = await CDP.List({ port: 9225 });
+      this.logger.log(`🔧 Found ${targets.length} CDP targets`);
+
+      // Find the main workbench target (not settings)
+      const workbench = targets.find(t =>
+        t.title !== 'Cursor Settings' &&
+        t.type === 'page' &&
+        t.url && t.url.includes('workbench')
+      ) || targets[0];
+
+      if (!workbench) {
+        throw new Error('No suitable Cursor workbench target found');
+      }
+
+      this.logger.log(`🔧 Connecting to target: ${workbench.title}`);
+
+      // Connect to the target
+      const client = await CDP({ port: 9225, target: workbench });
+      const { Runtime, DOM } = client;
+
+      // Enable required domains
+      await Runtime.enable();
+      await DOM.enable();
+
+      this.logger.log('🔧 CDP connection established, searching for chat content...');
+
+      // Try multiple selectors to find chat content
+      const selectors = [
+        '.chat-content',
+        '.chat-messages',
+        '.response-content',
+        '.ai-response',
+        '.message-content',
+        '[data-testid="chat-message"]',
+        '.markdown-content',
+        '.prose',
+        '.chat-panel',
+        '.sidebar-panel'
+      ];
+
+      for (const selector of selectors) {
+        try {
+          this.logger.log(`🔧 Trying selector: ${selector}`);
+
+          // Get document root
+          const { root } = await DOM.getDocument();
+
+          // Search for elements with the selector
+          const { nodeIds } = await DOM.querySelectorAll({ nodeId: root.nodeId, selector });
+
+          if (nodeIds.length > 0) {
+            this.logger.log(`🔧 Found ${nodeIds.length} elements with selector: ${selector}`);
+
+            // Get text content from the first matching element
+            const { nodeId } = await DOM.describeNode({ nodeId: nodeIds[0] });
+            const { outerHTML } = await DOM.getOuterHTML({ nodeId });
+
+            // Extract text content (remove HTML tags)
+            const textContent = outerHTML.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+
+            if (textContent && textContent.length > 20) {
+              this.logger.log(`✅ Successfully extracted chat content via CDP: ${textContent.substring(0, 100)}...`);
+              await client.close();
+              return textContent;
+            }
+          }
+        } catch (error) {
+          this.logger.log(`⚠️ Selector ${selector} failed: ${error.message}`);
+        }
+      }
+
+      // If no specific selectors work, try to get all text content
+      this.logger.log('🔧 Trying to get all text content from the page...');
+
+      const { root } = await DOM.getDocument();
+      const { outerHTML } = await DOM.getOuterHTML({ nodeId: root.nodeId });
+
+      // Extract text content and look for AI responses
+      const textContent = outerHTML.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+
+      // Look for patterns that indicate AI responses
+      const aiResponsePatterns = [
+        /(?:AI|Assistant|Claude|GPT|Response):\s*([^]*?)(?=\n\n|\n[A-Z]|$)/gi,
+        /(?:Here|This|The answer|The solution):\s*([^]*?)(?=\n\n|\n[A-Z]|$)/gi
+      ];
+
+      for (const pattern of aiResponsePatterns) {
+        const matches = textContent.match(pattern);
+        if (matches && matches.length > 0) {
+          const response = matches[matches.length - 1]; // Get the latest response
+          if (response && response.length > 20) {
+            this.logger.log(`✅ Found AI response via CDP pattern matching: ${response.substring(0, 100)}...`);
+            await client.close();
+            return response;
+          }
+        }
+      }
+
+      await client.close();
+      throw new Error('No chat content found via CDP');
+
+    } catch (error) {
+      this.logger.log(`❌ CDP method failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Read Cursor response via clipboard (select all and copy)
+   * @returns {Promise<string>} The chat response text
+   */
+  async readCursorResponseViaClipboard() {
+    try {
+      this.logger.log('🔧 Attempting clipboard-based response detection...');
+
+      // AppleScript to select all content in Cursor and copy to clipboard
+      const clipboardScript = `
+        tell application "System Events"
+          tell process "Cursor"
+            set frontmost to true
+            delay 1
+
+            -- Try to focus on the chat area first
+            try
+              key code 1 using {command down}  -- Cmd+A to select all
+              delay 0.5
+              key code 8 using {command down}  -- Cmd+C to copy
+              delay 0.5
+            on error
+              -- If that fails, try alternative approach
+              key code 1 using {command down, shift down}  -- Cmd+Shift+A to select all
+              delay 0.5
+              key code 8 using {command down}  -- Cmd+C to copy
+              delay 0.5
+            end try
+          end tell
+        end tell
+      `;
+
+      execSync(`osascript -e '${clipboardScript}'`, { stdio: 'pipe' });
+
+      // Read from clipboard
+      const clipboardScript2 = `
+        the clipboard
+      `;
+
+      const clipboardContent = execSync(`osascript -e '${clipboardScript2}'`, { stdio: 'pipe', encoding: 'utf8' });
+
+      if (clipboardContent && clipboardContent.trim().length > 20) {
+        this.logger.log(`✅ Successfully read clipboard content: ${clipboardContent.substring(0, 100)}...`);
+        return clipboardContent.trim();
+      }
+
+      throw new Error('Clipboard content is empty or too short');
+
+    } catch (error) {
+      this.logger.log(`❌ Clipboard method failed: ${error.message}`);
+      throw error;
+    }
+  }
+}
+
+module.exports = { AppleScriptManager };