vibecodingmachine-core 1.0.0

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

@@ -0,0 +1,2803 @@
+// @vibecodingmachine/core - AppleScript Manager
+// Handles AppleScript-based interactions with IDEs that don't support CDP
+// Now supports both macOS (AppleScript) and Windows (PowerShell automation)
+
+const { execSync } = require('child_process');
+const { writeFileSync, unlinkSync } = require('fs');
+const { join } = require('path');
+const { tmpdir } = require('os');
+
+// Import Windows automation manager for Windows platform
+let WindowsAutomationManager;
+if (process.platform === 'win32') {
+  WindowsAutomationManager = require('./windows-automation-manager');
+}
+
+const AppleScriptUtils = require('./applescript-utils');
+
+/**
+ * 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;
+    this.platform = process.platform;
+    this.appleScriptUtils = new AppleScriptUtils();
+
+    if (this.platform === 'win32' && WindowsAutomationManager) {
+      this.windowsManager = new WindowsAutomationManager();
+    }
+  }
+
+  /**
+   * Deterministically send text to Terminal window 1 tab 1 and verify via history snippet
+   * @param {string} text
+   * @returns {Promise<Object>} Result with success and note
+   */
+  async sendDeterministicToTerminalWindow1(text) {
+    // CRITICAL: Validate text parameter
+    if (!text || typeof text !== 'string') {
+      this.logger.error(`❌ [Deterministic] Invalid text parameter: type=${typeof text}, value=${text}`);
+      return {
+        success: false,
+        error: `Invalid text parameter: received ${typeof text} instead of string`,
+        debug: { textType: typeof text, textValue: text }
+      };
+    }
+
+    try {
+      // First, read recent history to detect interactive prompts (like theme selection)
+      const readHistoryScript = `
+        tell application "Terminal"
+          try
+            set fullHistory to history of tab 1 of window 1 as text
+            if (length of fullHistory) > 600 then
+              set histSnippet to (text -600 thru -1 of fullHistory)
+            else
+              set histSnippet to fullHistory
+            end if
+            return histSnippet
+          on error
+            return "HIST_READ_ERROR"
+          end try
+        end tell
+      `;
+
+      const tmpRead = join(tmpdir(), `claude_read_${Date.now()}.scpt`);
+      writeFileSync(tmpRead, readHistoryScript, 'utf8');
+      let historyOut = '';
+      try {
+        historyOut = execSync(`osascript "${tmpRead}"`, { encoding: 'utf8', timeout: 10000, stdio: 'pipe' }).trim();
+      } catch (rerr) {
+        this.logger.log('⚠️ Deterministic: failed to read history before send:', rerr.message || rerr);
+        historyOut = '';
+      } finally { try { unlinkSync(tmpRead); } catch (e) {} }
+
+      this.logger.log('🔎 Deterministic: recent history snippet length:', historyOut.length);
+
+      // Detect interactive prompt patterns that commonly appear on first run (e.g., theme selection)
+      const interactivePatterns = [
+        'Choose the text style',
+        'Change this later, run /theme',
+        '1. Dark mode',
+        '2. Light mode',
+        'Choose the text style that looks best',
+        'To change this later, run /theme'
+      ];
+
+      const hasInteractivePrompt = interactivePatterns.some(p => historyOut.includes(p));
+      this.logger.log('🔎 Deterministic: interactive prompt detected=', hasInteractivePrompt);
+
+      const directSendScript = `
+        tell application "Terminal"
+          activate
+          try
+            set selected tab of window 1 to tab 1 of window 1
+            delay 0.5
+          end try
+        end tell
+
+        tell application "System Events"
+          tell process "Terminal"
+            set frontmost to true
+            delay 0.5
+            ${hasInteractivePrompt ? `keystroke return\n            delay 0.8` : ''}
+            keystroke "${text.replace(/"/g, '\\"')}"
+            delay 1.0
+            keystroke return
+            delay 0.3
+          end tell
+        end tell
+
+        tell application "Terminal"
+          try
+            set fullHistory to history of tab 1 of window 1 as text
+            if (length of fullHistory) > 300 then
+              set histSnippet to (text -300 thru -1 of fullHistory)
+            else
+              set histSnippet to fullHistory
+            end if
+            return "SENT_TO:W1_T1|HIST:" & histSnippet
+          on error
+            return "SENT_TO:W1_T1|HIST:ERROR"
+          end try
+        end tell
+      `;
+
+      const tempFile = join(tmpdir(), `claude_direct_${Date.now()}.scpt`);
+      writeFileSync(tempFile, directSendScript, 'utf8');
+      const out = execSync(`osascript "${tempFile}"`, { encoding: 'utf8', timeout: 30000, stdio: 'pipe' }).trim();
+      try { unlinkSync(tempFile); } catch (e) {}
+
+      this.logger.log('🔁 Deterministic direct send output:', out);
+      const verified = out.indexOf('|HIST:') !== -1 && out.split('|HIST:')[1].includes(text);
+      return { success: verified, note: out };
+    } catch (err) {
+      this.logger.log('❌ Deterministic direct send failed:', err.message || err);
+      return { success: false, error: err.message || String(err) };
+    }
+  }
+
+  /**
+   * Open Cursor IDE with optional repository path and remote debugging enabled
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openCursor(repoPath = null) {
+    // Handle Windows platform
+    if (this.platform === 'win32' && this.windowsManager) {
+      return await this.windowsManager.openCursor(repoPath);
+    }
+
+    // Handle macOS platform (existing AppleScript logic)
+    try {
+      this.logger.log('Opening Cursor with remote debugging enabled...');
+
+      // Launch Cursor with remote debugging enabled
+      let command = 'open -a "Cursor" --args --remote-debugging-port=9225';
+      if (repoPath) {
+        command = `open -a "Cursor" "${repoPath}" --args --remote-debugging-port=9225`;
+      }
+
+      execSync(command, { stdio: 'pipe' });
+
+      // Wait for Cursor to start and bind the debugging port
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      this.logger.log('Cursor opened successfully with remote debugging on port 9225');
+      return {
+        success: true,
+        message: repoPath ? `Cursor opened with repository: ${repoPath} and remote debugging` : 'Cursor opened successfully with remote debugging',
+        method: 'applescript',
+        debugPort: 9225
+      };
+    } catch (error) {
+      this.logger.log('Error opening Cursor:', error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'applescript'
+      };
+    }
+  }
+
+  /**
+   * Open Gemini (in VS Code)
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openGemini(repoPath = null) {
+    this.logger.log('Opening Gemini, which runs in VS Code...');
+    return await this.openVSCode(repoPath);
+  }
+
+  /**
+   * Open Claude in a new terminal or bring existing instance to foreground
+   * @param {string} repoPath - Optional repository path to open (will cd to this directory before starting Claude)
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openClaude(repoPath = null) {
+    try {
+      this.logger.log('Opening Claude in terminal or bringing to foreground...');
+
+      // First, check if any Claude process is running using a simple shell command
+      try {
+        const claudeProcessCheck = execSync('ps aux | grep -i "claude" | grep -v grep | grep -v "Claude.app" | wc -l', { encoding: 'utf8' }).trim();
+        const claudeCount = parseInt(claudeProcessCheck);
+        this.logger.log(`🔍 [Claude] Found ${claudeCount} Claude processes running`);
+
+        if (claudeCount === 0) {
+          this.logger.log('No Claude process found, will create new terminal');
+          throw new Error('No Claude process running');
+        }
+      } catch (processCheckError) {
+        this.logger.log('No Claude process detected, will create new terminal');
+        // Jump to creating new terminal
+        const escapedPath = repoPath ? repoPath.replace(/'/g, "'\\''") : '';
+        const cdCommand = repoPath ? `cd '${escapedPath}' && ` : '';
+        const openClaudeScript = `
+          tell application "Terminal"
+            activate
+            set newWindow to do script "echo 'Starting Claude Code...' && ${cdCommand}claude --dangerously-skip-permissions"
+            delay 3
+          end tell
+        `;
+
+        const tempFile = join(tmpdir(), `claude_open_${Date.now()}.scpt`);
+        try {
+          writeFileSync(tempFile, openClaudeScript, 'utf8');
+          execSync(`osascript "${tempFile}"`, { stdio: 'pipe' });
+
+          this.logger.log('Claude opened in new terminal successfully');
+          return {
+            success: true,
+            message: repoPath ? `Claude opened in terminal with context: ${repoPath}` : 'Claude opened in new terminal',
+            method: 'applescript',
+            action: 'open'
+          };
+        } finally {
+          try {
+            unlinkSync(tempFile);
+          } catch (cleanupError) {
+            this.logger.log(`⚠️ Failed to cleanup temp file: ${cleanupError.message}`);
+          }
+        }
+      }
+
+      // If we get here, Claude process exists - find the specific Claude terminal window
+      try {
+        this.logger.log('🔍 [Claude] Claude process detected, searching for Claude terminal window...');
+        const escapedRepoPath = repoPath ? repoPath.replace(/'/g, "'\\''") : '';
+        const repoPathCheck = repoPath ? `and historyText contains "${escapedRepoPath}"` : '';
+        const findClaudeWindowScript = `
+          tell application "Terminal"
+            activate
+            delay 0.5
+
+            set claudeWindow to null
+            set windowCount to count of windows
+
+            -- Search through all terminal windows to find the one running Claude IN THE CORRECT DIRECTORY
+            repeat with i from 1 to windowCount
+              try
+                set currentWindow to window i
+                set currentTab to selected tab of currentWindow
+                set historyText to history of currentTab as text
+
+                -- Check for Claude AND optionally the correct repo path to avoid wrong terminal
+                -- CRITICAL FIX: Must check BOTH Claude process AND repo path to avoid wrong terminal
+                if (historyText contains "Claude Code" or historyText contains "claude --dangerously-skip-permissions") ${repoPathCheck} then
+                  set claudeWindow to currentWindow
+                  exit repeat
+                end if
+              on error
+                -- Continue to next window
+              end try
+            end repeat
+
+            if claudeWindow is not null then
+              -- Found Claude window - bring it to front
+              set index of claudeWindow to 1
+              delay 0.5
+              return "claude-window-found"
+            else
+              return "claude-window-not-found"
+            end if
+          end tell
+        `;
+
+        const tempFile = join(tmpdir(), `claude_find_${Date.now()}.scpt`);
+        try {
+          writeFileSync(tempFile, findClaudeWindowScript, 'utf8');
+          const result = execSync(`osascript "${tempFile}"`, { stdio: 'pipe', encoding: 'utf8' }).trim();
+
+          if (result === 'claude-window-found') {
+            this.logger.log('✅ [Claude] Found and focused Claude terminal window');
+            return {
+              success: true,
+              message: 'Claude terminal window found and focused',
+              method: 'applescript',
+              action: 'focus'
+            };
+          } else {
+            this.logger.log('⚠️ [Claude] Claude window not found despite process running, will create new one');
+          }
+        } finally {
+          try {
+            unlinkSync(tempFile);
+          } catch (cleanupError) {
+            this.logger.log(`⚠️ Failed to cleanup temp file: ${cleanupError.message}`);
+          }
+        }
+      } catch (focusError) {
+        this.logger.log('⚠️ [Claude] Error finding Claude window, will create new one:', focusError.message);
+      }
+
+      // No existing Claude found, open a new terminal with Claude
+      // Escape the path properly for AppleScript
+      const escapedPath = repoPath ? repoPath.replace(/'/g, "'\\''") : '';
+      const cdCommand = repoPath ? `cd '${escapedPath}' && ` : '';
+      const openClaudeScript = `
+        tell application "Terminal"
+          activate
+          set newWindow to do script "echo 'Starting Claude Code...' && ${cdCommand}claude --dangerously-skip-permissions"
+          delay 3
+        end tell
+      `;
+
+      // Use file-based execution to avoid quote escaping issues
+      const tempFile = join(tmpdir(), `claude_open_${Date.now()}.scpt`);
+      try {
+        writeFileSync(tempFile, openClaudeScript, 'utf8');
+        execSync(`osascript "${tempFile}"`, { stdio: 'pipe' });
+
+        this.logger.log('Claude opened in new terminal successfully');
+        return {
+          success: true,
+          message: repoPath ? `Claude opened in terminal with context: ${repoPath}` : 'Claude opened in new terminal',
+          method: 'applescript',
+          action: 'open'
+        };
+      } finally {
+        try {
+          unlinkSync(tempFile);
+        } catch (cleanupError) {
+          this.logger.log(`⚠️ Failed to cleanup temp file: ${cleanupError.message}`);
+        }
+      }
+    } catch (error) {
+      this.logger.log('Error opening Claude:', error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'applescript'
+      };
+    }
+  }
+
+  /**
+   * 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) {
+    // Handle Windows platform
+    if (this.platform === 'win32' && this.windowsManager) {
+      // Assuming a similar method exists in the windows manager
+      return await this.windowsManager.openVSCode(repoPath);
+    }
+
+    // Handle macOS platform
+    try {
+      this.logger.log('Opening VS Code...');
+
+      let command = 'open -a "Visual Studio Code"';
+      if (repoPath) {
+        command += ` "${repoPath}"`;
+        this.logger.log(`Opening VS Code with repository: ${repoPath}`);
+      }
+
+      execSync(command, { stdio: 'pipe' });
+
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      this.logger.log('VS Code opened successfully');
+      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 Windsurf IDE with optional repository path
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openWindsurf(repoPath = null) {
+    try {
+      this.logger.log('Opening Windsurf...');
+
+      // Try to find Windsurf installation
+      const possiblePaths = [
+        '/Users/jesseolsen/.codeium/windsurf/bin/windsurf', // macOS - Codeium installation
+        '/Applications/Windsurf.app/Contents/MacOS/Windsurf', // macOS - App Store
+        'C:\\Users\\%USERNAME%\\AppData\\Local\\Programs\\Windsurf\\Windsurf.exe', // Windows
+        '/usr/local/bin/windsurf', // Linux
+        '/opt/windsurf/windsurf' // Linux alternative
+      ];
+
+      let windsurfPath = possiblePaths.find(path => {
+        try {
+          const fs = require('fs');
+          fs.accessSync(path.replace('%USERNAME%', process.env.USERNAME || process.env.USER));
+          return true;
+        } catch {
+          return false;
+        }
+      });
+
+      if (!windsurfPath) {
+        // Try using the 'windsurf' command directly
+        windsurfPath = 'windsurf';
+      }
+
+      let command;
+      if (windsurfPath.includes('Windsurf.app')) {
+        // macOS app bundle
+        command = `open -a "Windsurf"`;
+        if (repoPath) {
+          command += ` "${repoPath}"`;
+        }
+      } else {
+        // Direct executable - use --reuse-window flag to avoid hanging when Windsurf is already running
+        command = `"${windsurfPath}" --reuse-window`;
+        if (repoPath) {
+          command += ` "${repoPath}"`;
+        }
+      }
+
+              this.logger.log(`Executing command: ${command}`);
+
+        // For Windsurf, we don't wait for the command to complete since it runs in background
+        if (windsurfPath.includes('windsurf')) {
+          // Use spawn to run in background
+          const { spawn } = require('child_process');
+          const windsurfProcess = spawn(windsurfPath, ['--reuse-window', repoPath], {
+            stdio: 'pipe',
+            detached: true
+          });
+
+          // Don't wait for completion, just give it a moment to start
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        } else {
+          execSync(command, { stdio: 'pipe' });
+          // Wait a moment for Windsurf to start
+          await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+
+      this.logger.log('Windsurf opened successfully');
+      return {
+        success: true,
+        message: repoPath ? `Windsurf opened with repository: ${repoPath}` : 'Windsurf opened successfully',
+        method: 'applescript'
+      };
+    } catch (error) {
+      this.logger.log('Error opening Windsurf:', error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'applescript'
+      };
+    }
+  }
+
+  async openAntigravity(repoPath = null) {
+    try {
+      this.logger.log('Opening Google Antigravity...');
+
+      // Google Antigravity app path
+      const antigravityPath = '/Applications/Antigravity.app';
+
+      // Check if Antigravity is installed
+      try {
+        const fs = require('fs');
+        fs.accessSync(antigravityPath);
+      } catch {
+        throw new Error('Google Antigravity is not installed at /Applications/Antigravity.app');
+      }
+
+      let command = `open -a "Antigravity"`;
+      if (repoPath) {
+        command += ` "${repoPath}"`;
+      }
+
+      this.logger.log(`Executing command: ${command}`);
+      execSync(command, { stdio: 'pipe' });
+
+      // Wait a moment for Antigravity to start
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      this.logger.log('Google Antigravity opened successfully');
+      return {
+        success: true,
+        message: repoPath ? `Google Antigravity opened with repository: ${repoPath}` : 'Google Antigravity opened successfully',
+        method: 'applescript'
+      };
+    } catch (error) {
+      this.logger.log('Error opening Google Antigravity:', 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}>}
+   */
+  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 };
+    }
+  }
+
+  /**
+   * Generic IDE opener - routes to specific IDE methods
+   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'antigravity', 'vscode', etc.')
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object
+   */
+  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);
+      case 'vscode':
+        return await this.openVSCode(repoPath);
+      case 'claude':
+        return await this.openClaude(repoPath);
+      case 'gemini':
+        return await this.openGemini(repoPath);
+      default:
+        return {
+          success: false,
+          error: `Unknown IDE: ${ide}. Supported: cursor, windsurf, antigravity, vscode, claude, gemini`
+        };
+    }
+  }
+
+  /**
+   * Ensure we're not in an editor context before sending text
+   * @param {string} ide - The IDE name
+   * @returns {Promise<boolean>} True if safe to send text, false if in editor
+   */
+  async ensureNotInEditor(ide) {
+    if (ide !== 'cursor') {
+      return true; // Only check for Cursor
+    }
+
+    try {
+      const safetyScript = `
+        tell application "System Events"
+          tell process "Cursor"
+            set frontmost to true
+            delay 0.5
+
+            -- Check if we're currently in a text editor
+            try
+              -- Try to get the focused element
+              set focusedElement to value of attribute "AXFocused" of window 1
+              if focusedElement is not missing value then
+                -- We're in an editor, need to escape
+                key code 53 -- Escape key to exit editor mode
+                delay 0.5
+                return "escaped_from_editor"
+              else
+                return "not_in_editor"
+              end if
+            on error
+              -- If we can't determine focus, assume we're safe
+              return "focus_check_failed_assuming_safe"
+            end try
+          end tell
+        end tell
+      `;
+
+      const tempFile = join(tmpdir(), `safety_check_${Date.now()}.scpt`);
+      try {
+        writeFileSync(tempFile, safetyScript, 'utf8');
+        const result = execSync(`osascript "${tempFile}"`, { stdio: 'pipe', encoding: 'utf8' });
+        this.logger.log(`🔒 [${ide}] Safety check result: ${result.trim()}`);
+        return true; // Always return true to proceed, but log the result
+      } finally {
+        try {
+          unlinkSync(tempFile);
+        } catch (cleanupError) {
+          this.logger.log(`⚠️ Failed to cleanup safety check temp file: ${cleanupError.message}`);
+        }
+      }
+    } catch (error) {
+      this.logger.log(`⚠️ Safety check failed: ${error.message}`);
+      return true; // Proceed anyway if safety check fails
+    }
+  }
+
+  /**
+   * Send text to VS Code using AppleScript
+   * @param {string} text - The text to send
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendTextToVSCode(text) {
+    const ideName = 'VS Code';
+    this.logger.log(`🚀 [${ideName}] Using dedicated sendTextToVSCode method with new chat session.`);
+
+    try {
+      // Get current extension from manager instance
+      const extension = this.currentExtension || 'gemini-code'; // Default to gemini-code
+      let commandText = 'Gemini Code Assist: Focus on Chat View'; // default for gemini
+
+      if (extension === 'amazon-q') {
+        commandText = 'Amazon Q: Open Chat';
+      } else if (extension === 'github-copilot') {
+        commandText = 'GitHub Copilot Chat: Open Chat';
+      } else if (extension === 'gemini-code') {
+        commandText = 'Gemini Code Assist: Focus on Chat View';
+      } else if (extension === 'windsurf') {
+        commandText = 'Windsurf: Open Chat';
+      }
+
+      const appleScript = `
+        tell application "System Events"
+          tell process "Visual Studio Code"
+            -- Check if the process is running before attempting to interact
+            try
+              set frontmost to true
+              delay 1.5
+          -- Step 1: Start new chat session first (only for Gemini)
+          ${extension === 'gemini-code' ? `
+          key code 35 using {command down, shift down}
+          delay 1.0
+          keystroke "Gemini Code Assistant New Chat"
+          delay 1.5
+          key code 36
+          delay 2.0
+          ` : ''}
+
+          -- Step 2: Open Command Palette to focus on chat view
+          key code 35 using {command down, shift down}
+          delay 1.0
+
+          -- Type to open the selected extension chat (increased delay for command processing)
+          keystroke "${commandText.replace(/"/g, '\\"')}"
+          delay 1.5
+
+          -- Press Enter (increased delay for chat window to fully open)
+          key code 36
+          delay 2.5
+
+
+          -- Type the message (increased delay for input field to be ready)
+          keystroke "${text.replace(/"/g, '\\"')}"
+          delay 1.0
+
+          -- Send with Cmd+Enter or Enter
+          key code 36 using {command down}
+          delay 0.5
+          key code 36
+          delay 1.5
+            on error
+              -- Process not running or not accessible
+              error "Process 'Visual Studio Code' is not running or not accessible. VibeCodingMachine does not open IDEs - please open VS Code manually first."
+            end try
+          end tell
+        end tell
+      `;
+
+      const tempFile = join(tmpdir(), `vscode_script_${Date.now()}.scpt`);
+      writeFileSync(tempFile, appleScript, 'utf8');
+      execSync(`osascript "${tempFile}"`, { stdio: 'pipe' });
+      unlinkSync(tempFile);
+
+      return { success: true, method: 'applescript', message: `Message sent to ${ideName}: ${text}` };
+    } catch (error) {
+      return { success: false, error: error.message, method: 'applescript' };
+    }
+  }
+
+  /**
+   * Send text to an IDE using AppleScript
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name ('cursor', 'windsurf', 'claude')
+   * @param {string} repoPath - The repository path (optional, used for Claude)
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendText(text, ide, repoPath = null) {
+    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' : ide === 'claude' ? 'Claude' : ide === 'vscode' ? 'VS Code' : 'Unknown IDE';
+
+    this.logger.log(`🚀 [${ideName}] Starting text send on ${this.platform} platform`);
+    this.logger.log(`🚀 [${ideName}] Text to send: "${text}"`);
+
+    // Special handling for Windsurf extension within VS Code
+    if (ide === 'windsurf' && this.isRunningInVSCodeExtension()) {
+      return await this.sendTextToWindsurfExtension(text);
+    }
+
+    // Handle Windows platform
+    if (this.platform === 'win32') {
+      return await this.sendTextWindows(text, ide);
+    }
+    this.logger.log(`🚀 [${ideName}] Using precise element targeting - AVOIDING TERMINAL`);
+
+    // Safety check: Ensure we're not in an editor before sending text
+    await this.ensureNotInEditor(ide);
+
+    // Enhanced diagnostic for Cursor to understand UI structure and prevent file typing
+    if (ide === 'cursor') {
+      try {
+        const diagnosticScript = `
+          tell application "System Events"
+            tell process "Cursor"
+              set frontmost to true
+              delay 1
+
+              -- Check if we're currently in an editor text area
+              set inEditor to false
+              try
+                set activeElement to value of attribute "AXFocused" of window 1
+                if activeElement is not missing value then
+                  set inEditor to true
+                end if
+              on error
+                -- Continue
+              end try
+
+              -- Log all text fields and their descriptions
+              set allTextFields to text field of window 1
+              set fieldCount to count of allTextFields
+              log "Found " & fieldCount & " text fields in Cursor"
+
+              repeat with i from 1 to fieldCount
+                try
+                  set currentField to item i of allTextFields
+                  set fieldDesc to description of currentField
+                  log "Field " & i & ": " & fieldDesc
+                on error
+                  log "Field " & i & ": No description available"
+                end try
+              end repeat
+
+              -- Log all groups and their structure
+              set allGroups to group of window 1
+              set groupCount to count of allGroups
+              log "Found " & groupCount & " groups in Cursor"
+
+              -- Log current focus state
+              log "Currently in editor: " & inEditor
+            end tell
+          end tell
+        `;
+
+        this.logger.log(`🔍 [${ideName}] Running enhanced diagnostic script to understand Cursor UI structure...`);
+
+        // Use file-based AppleScript execution to avoid shell escaping issues
+        const tempFile = join(tmpdir(), `cursor_diagnostic_${Date.now()}.scpt`);
+        try {
+          writeFileSync(tempFile, diagnosticScript, 'utf8');
+          const diagnosticResult = execSync(`osascript "${tempFile}"`, { stdio: 'pipe', encoding: 'utf8' });
+          this.logger.log(`✅ [${ideName}] Diagnostic completed: ${diagnosticResult.trim()}`);
+        } finally {
+          // Clean up temporary file
+          try {
+            unlinkSync(tempFile);
+          } catch (cleanupError) {
+            this.logger.log(`⚠️ [${ideName}] Failed to cleanup diagnostic temp file: ${cleanupError.message}`);
+          }
+        }
+      } catch (diagnosticError) {
+        this.logger.log(`⚠️ [${ideName}] Diagnostic failed: ${diagnosticError.message}`);
+      }
+    }
+
+    try {
+      let appleScript;
+
+      if (ide === 'windsurf') {
+        // AppleScript for Windsurf - send text to existing process only
+        this.logger.log('🔄 [Windsurf] Sending text to existing Windsurf process...');
+        appleScript = `
+          tell application "System Events"
+            tell process "Windsurf"
+              -- Check if the process is running before attempting to interact
+              try
+                set frontmost to true
+                delay 1
+
+                -- Step 1: Open Command Palette to start a new chat
+                key code 35 using {command down, shift down}
+                delay 0.8
+
+                -- Step 2: Type "New Chat" to start a fresh conversation
+                keystroke "New Chat"
+                delay 0.8
+
+                -- Step 3: Press Enter to execute the command
+                key code 36
+                delay 2.0
+
+                -- Step 4: Now 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
+              on error
+                -- Process not running or not accessible
+                error "Process 'Windsurf' is not running or not accessible. VibeCodingMachine does not open IDEs - please open Windsurf manually first."
+              end try
+            end tell
+          end tell
+        `;
+      } else if (ide === 'claude') {
+        // Use a different approach for Claude - find existing Claude terminal and send text
+        const targetRepoPath = repoPath || '/Users/jesse/code/mediawink/allnightai';
+        this.logger.log(`🔍 [Claude] Using repo path for terminal detection: "${targetRepoPath}" (passed: "${repoPath}")`);
+
+        // Check if Claude process is running
+        let claudeProcessCount = 0;
+        try {
+          const processCheck = execSync('ps aux | grep -i "claude" | grep -v grep | grep -v "Claude.app" | wc -l', { encoding: 'utf8' }).trim();
+          claudeProcessCount = parseInt(processCheck);
+          this.logger.log(`🔍 [Claude] Found ${claudeProcessCount} Claude processes`);
+        } catch (error) {
+          this.logger.log(`⚠️ [Claude] Process check failed: ${error.message}`);
+        }
+
+        if (claudeProcessCount === 0) {
+          // No Claude process running - try to open it
+          this.logger.log('⚠️ [Claude] No Claude process found, attempting to open Claude...');
+          const openResult = await this.openClaude(repoPath);
+
+          if (!openResult.success) {
+            return {
+              success: false,
+              method: 'applescript',
+              error: `No Claude process found and failed to open Claude: ${openResult.error}`,
+              note: 'Attempted to open Claude but it failed'
+            };
+          }
+
+          // Wait for Claude to fully start
+          this.logger.log('✅ [Claude] Claude opened successfully, waiting for it to be ready...');
+          await new Promise(resolve => setTimeout(resolve, 5000));
+
+          // Re-check if Claude process is now running
+          try {
+            const recheckProcess = execSync('ps aux | grep -i "claude" | grep -v grep | grep -v "Claude.app" | wc -l', { encoding: 'utf8' }).trim();
+            const recheckCount = parseInt(recheckProcess);
+            if (recheckCount === 0) {
+              return {
+                success: false,
+                method: 'applescript',
+                error: 'Claude was opened but process not detected after waiting',
+                note: 'Claude may need more time to start'
+              };
+            }
+            this.logger.log(`✅ [Claude] Confirmed ${recheckCount} Claude processes running after opening`);
+          } catch (recheckError) {
+            this.logger.log(`⚠️ [Claude] Could not verify Claude process after opening: ${recheckError.message}`);
+          }
+        }
+
+        // Claude process exists - find and send text to the specific Claude terminal window
+        this.logger.log('🔄 [Claude] Finding specific Claude terminal window...');
+
+        // CRITICAL: Validate text parameter before using in template string
+        if (!text || typeof text !== 'string') {
+          this.logger.error(`❌ [Claude] Invalid text parameter: type=${typeof text}, value=${text}`);
+          return {
+            success: false,
+            method: 'applescript',
+            error: `Invalid text parameter for Claude: received ${typeof text} instead of string`,
+            debug: { textType: typeof text, textValue: text }
+          };
+        }
+
+        const escapedRepoPath = targetRepoPath.replace(/'/g, "'\\''");
+        const findAndSendScript = `
+          tell application "Terminal"
+            activate
+
+            set claudeWindow to null
+            set claudeTab to null
+            set windowCount to count of windows
+
+            -- Search through all terminal windows to find the one running Claude IN THE CORRECT DIRECTORY
+            repeat with i from 1 to windowCount
+              try
+                set currentWindow to window i
+                set currentTab to selected tab of currentWindow
+                set historyText to history of currentTab as text
+
+                -- Check for Claude AND the correct repo path to avoid sending to wrong terminal
+                -- CRITICAL FIX: Must check BOTH Claude process AND repo path to avoid wrong terminal
+                -- Also check that Claude is CURRENTLY RUNNING (not just in history)
+                set hasClaudeCode to historyText contains "Claude Code" or historyText contains "claude --dangerously-skip-permissions"
+                set hasRepoPath to historyText contains "${escapedRepoPath}"
+                -- Check for Claude interactive prompts or working state
+                set hasClaudePrompt to historyText contains "claude>" or historyText contains "What can I help you build" or historyText contains "bypass permissions"
+
+                if hasClaudeCode and hasRepoPath and hasClaudePrompt then
+                  set claudeWindow to currentWindow
+                  set claudeTab to currentTab
+                  exit repeat
+                end if
+              on error
+                -- Continue to next window
+              end try
+            end repeat
+
+            if claudeWindow is not null then
+              -- Found existing Claude terminal, bring it to front
+              set index of claudeWindow to 1
+              delay 1.0
+            else
+              error "No Claude terminal found in directory: ${escapedRepoPath}"
+            end if
+          end tell
+
+          -- CRITICAL: Must use System Events, NOT 'do script'
+          -- REASON: 'do script' only submits when STARTING a command, not when process is already running
+          -- This was the root cause of "Start Auto" not submitting text to Claude (Oct 17, 2025)
+          -- DO NOT CHANGE THIS TO 'do script' - it will break text submission!
+          tell application "System Events"
+            tell process "Terminal"
+              set frontmost to true
+              delay 0.5
+
+              -- Type the text
+              keystroke "${text.replace(/"/g, '\\"')}"
+              delay 1.0
+
+              -- Submit with return (REQUIRED - 'do script' won't do this when Claude is running)
+              keystroke return
+              delay 0.3
+            end tell
+          end tell
+        `;
+
+        // Execute the AppleScript using file-based approach
+        try {
+          const tempFile = join(tmpdir(), `claude_script_${Date.now()}.scpt`);
+          writeFileSync(tempFile, findAndSendScript, 'utf8');
+
+            let result;
+            try {
+              result = execSync(`osascript "${tempFile}"`, {
+                encoding: 'utf8',
+                timeout: 30000, // 30 seconds to allow for window searching and delays
+                stdio: 'pipe'
+              }).toString().trim();
+            } finally {
+              // Clean up temp file
+              try { unlinkSync(tempFile); } catch (cleanupError) { this.logger.log(`⚠️ [Claude] Failed to cleanup temp file: ${cleanupError.message}`); }
+            }
+
+            this.logger.log(`✅ [Claude] AppleScript execution output:`, result);
+
+            // Verify that the sent text appears in the returned history snippet
+            try {
+              const sentVerified = result && result.indexOf('|HIST:') !== -1 && result.split('|HIST:')[1].includes(`${text}`);
+              if (sentVerified) {
+                this.logger.log('✅ [Claude] Verified sent text present in terminal history snippet');
+                return {
+                  success: true,
+                  method: 'applescript',
+                  message: `Text sent and verified in Claude terminal: ${text}`,
+                  note: result
+                };
+              }
+              this.logger.log('⚠️ [Claude] Sent text NOT found in terminal history snippet; will attempt deterministic retry');
+            } catch (verifyErr) {
+              this.logger.log('⚠️ [Claude] Verification parse error:', verifyErr.message || verifyErr);
+            }
+
+            // If verification failed, attempt a deterministic direct send to window 1 tab 1
+            try {
+              const det = await this.sendDeterministicToTerminalWindow1(text);
+              if (det && det.success) {
+                this.logger.log('✅ [Claude] Deterministic retry verified and succeeded');
+                return { success: true, method: 'applescript', message: `Text sent to newly opened Claude terminal: ${text}`, note: det.note };
+              }
+              this.logger.log('⚠️ [Claude] Deterministic retry did not verify:', det && det.note ? det.note : det && det.error ? det.error : det);
+            } catch (detErr) {
+              this.logger.log('❌ [Claude] Deterministic retry failed:', detErr.message || detErr);
+            }
+
+            // CRITICAL FIX: If we reach here, text was sent but not verified
+            // Return success anyway since the AppleScript execution succeeded
+            this.logger.log('⚠️ [Claude] Text sent but verification inconclusive, returning success');
+            return {
+              success: true,
+              method: 'applescript',
+              message: `Text sent to Claude terminal (verification inconclusive): ${text}`,
+              note: 'Text sent successfully but verification did not confirm'
+            };
+        } catch (error) {
+          this.logger.log('❌ [Claude] AppleScript failed:', error.message);
+          return {
+            success: false,
+            method: 'applescript',
+            error: `Failed to send text to Claude: ${error.message}`,
+            note: 'Claude AppleScript automation failed'
+          };
+        }
+      } else if (ide === 'cursor') {
+        // Cursor already has new chat logic in generateAIPanelFocusScript (Cmd+T)
+        appleScript = this.appleScriptUtils.generateAIPanelFocusScript(text, 'Cursor');
+      } else if (ide === 'vscode') {
+        // Delegate to the dedicated VS Code method
+        return await this.sendTextToVSCode(text);
+      } else if (ide === 'antigravity') {
+        // AppleScript for Google Antigravity - Cmd+Shift+L opens Agent chat (non-toggle)
+        this.logger.log('🔄 [Antigravity] Sending text to Antigravity Agent chat...');
+        appleScript = `
+          tell application "System Events"
+            tell process "Antigravity"
+              -- Check if the process is running before attempting to interact
+              try
+                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
+
+                return "Message sent to Antigravity Agent"
+              on error
+                -- Process not running or not accessible
+                error "Process 'Antigravity' is not running or not accessible. VibeCodingMachine does not open IDEs - please open Antigravity manually first."
+              end try
+            end tell
+          end tell
+        `;
+      } else {
+        return {
+          success: false,
+          error: `Unsupported IDE for AppleScript: ${ide}`,
+          note: 'AppleScript is only supported for Cursor, Windsurf, Antigravity, and VS Code'
+        };
+      }
+
+      this.logger.log(`🚀 [${ideName}] Executing AppleScript with PRECISE CHAT TARGETING...`);
+
+      // Guard against undefined appleScript (can happen with Claude path)
+      if (!appleScript) {
+        this.logger.error(`❌ [${ideName}] AppleScript variable is undefined - invalid code path`);
+        return {
+          success: false,
+          method: 'applescript',
+          error: 'AppleScript not generated - this should not happen for non-Claude IDEs',
+          note: 'Check IDE-specific code path logic'
+        };
+      }
+
+      // FIXED: Use file-based AppleScript execution to avoid shell escaping issues
+      const tempFile = join(tmpdir(), `applescript_${Date.now()}.scpt`);
+      try {
+        writeFileSync(tempFile, appleScript, 'utf8');
+        execSync(`osascript "${tempFile}"`, { stdio: 'pipe' });
+        this.logger.log(`✅ [${ideName}] AppleScript executed successfully - PRECISE TARGETING`);
+        this.logger.log(`✅ [${ideName}] Message sent successfully via precise element targeting`);
+        return {
+          success: true,
+          method: 'applescript',
+          message: `Message sent to ${ideName}: ${text}`,
+          note: 'Message sent via AppleScript automation'
+        };
+      } finally {
+        // Clean up temporary file
+        try {
+          unlinkSync(tempFile);
+        } catch (cleanupError) {
+          this.logger.log(`⚠️ [${ideName}] Failed to cleanup temp file: ${cleanupError.message}`);
+        }
+      }
+
+    } catch (error) {
+      this.logger.log('AppleScript interaction failed:', error.message);
+
+      // For Claude, don't fall back to simulated response - return actual failure
+      if (ide === 'claude') {
+        return {
+          success: false,
+          method: 'applescript',
+          error: `Failed to send text to Claude: ${error.message}`,
+          note: 'Claude AppleScript automation failed. Check if Claude is running and accessible.'
+        };
+      }
+
+      // For other IDEs, fall back to simulated response
+      return {
+        success: true,
+        method: 'simulated',
+        message: `Simulated ${ideName} response: ${text}`,
+        note: `${ideName} AppleScript automation failed. Using simulated response for testing.`
+      };
+    }
+  }
+
+  /**
+   * Check Claude terminal output for session limit errors
+   * Reads the terminal history and detects if Claude has hit its usage limit
+   * @returns {Promise<Object>} Result object with sessionLimitReached flag and details
+   */
+  async checkClaudeSessionLimit() {
+    try {
+      this.logger.log('🔍 Checking Claude terminal for session limit errors...');
+
+      const checkScript = `
+        tell application "Terminal"
+          set claudeWindow to null
+          set claudeTab to null
+          set windowCount to count of windows
+
+          -- Search through all terminal windows to find the one running Claude
+          repeat with i from 1 to windowCount
+            try
+              set currentWindow to window i
+              set currentTab to selected tab of currentWindow
+              set historyText to history of currentTab as text
+
+              -- Check if this is the Claude terminal
+              if historyText contains "Claude Code" or historyText contains "claude --dangerously-skip-permissions" then
+                set claudeWindow to currentWindow
+                set claudeTab to currentTab
+                exit repeat
+              end if
+            on error
+              -- Continue to next window
+            end try
+          end repeat
+
+          if claudeWindow is not null then
+            -- Get the last ~500 characters of history to check for recent errors
+            set fullHistory to history of claudeTab as text
+            set historyLength to length of fullHistory
+            set recentHistory to ""
+
+            if historyLength > 500 then
+              set recentHistory to text -500 thru -1 of fullHistory
+            else
+              set recentHistory to fullHistory
+            end if
+
+            return recentHistory
+          else
+            error "No Claude terminal found"
+          end if
+        end tell
+      `;
+
+      const tempFile = join(tmpdir(), `check_claude_limit_${Date.now()}.scpt`);
+      writeFileSync(tempFile, checkScript, 'utf8');
+
+      const recentOutput = execSync(`osascript "${tempFile}"`, {
+        encoding: 'utf8',
+        timeout: 10000,
+        stdio: 'pipe'
+      }).trim();
+
+      // Clean up temp file
+      try {
+        unlinkSync(tempFile);
+      } catch (cleanupError) {
+        this.logger.log(`⚠️ Failed to cleanup temp file: ${cleanupError.message}`);
+      }
+
+      // Check for session limit patterns
+      const sessionLimitPatterns = [
+        'Session limit reached',
+        'session limit reached',
+        'usage limit',
+        '/upgrade to increase your usage limit',
+        'resets at',
+        /resets \d{1,2}(am|pm)/i  // Matches "resets 7pm", "resets 10am", etc.
+      ];
+
+      const sessionLimitReached = sessionLimitPatterns.some(pattern => {
+        if (pattern instanceof RegExp) {
+          return pattern.test(recentOutput);
+        }
+        return recentOutput.toLowerCase().includes(pattern.toLowerCase());
+      });
+
+      if (sessionLimitReached) {
+        this.logger.log('🚨 SESSION LIMIT DETECTED in Claude terminal output');
+        this.logger.log('📋 Recent output:', recentOutput.substring(Math.max(0, recentOutput.length - 200)));
+
+        // Extract reset time if present (e.g., "resets 10am", "resets 7pm")
+        const resetTimeMatch = recentOutput.match(/resets\s+(\d{1,2})(am|pm)/i);
+        let resetTime = null;
+        if (resetTimeMatch) {
+          resetTime = `${resetTimeMatch[1]}${resetTimeMatch[2].toLowerCase()}`;
+          this.logger.log(`🕐 Reset time detected: ${resetTime}`);
+        }
+
+        return {
+          sessionLimitReached: true,
+          message: 'Claude session limit has been reached',
+          resetTime: resetTime,  // Add reset time to response
+          recentOutput: recentOutput,
+          note: resetTime
+            ? `Claude usage limit exceeded - resets at ${resetTime}. Please wait or upgrade.`
+            : 'Claude usage limit exceeded - please wait for reset or upgrade'
+        };
+      } else {
+        this.logger.log('✅ No session limit detected');
+        return {
+          sessionLimitReached: false,
+          message: 'No session limit detected',
+          recentOutput: recentOutput
+        };
+      }
+
+    } catch (error) {
+      this.logger.log('❌ Error checking Claude session limit:', error.message);
+      return {
+        sessionLimitReached: false,
+        error: error.message,
+        message: 'Failed to check session limit'
+      };
+    }
+  }
+
+  /**
+   * Send text to IDE on Windows platform using PowerShell automation
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendTextWindows(text, ide) {
+    if (!this.windowsManager) {
+      return {
+        success: false,
+        error: 'Windows automation manager not available',
+        method: 'windows-automation'
+      };
+    }
+
+    try {
+      this.logger.log(`🔧 Windows: Sending text to ${ide}...`);
+
+      switch (ide.toLowerCase()) {
+        case 'cursor':
+          // Try the native Windows API approach first, then fallback to basic PowerShell
+          let result = await this.windowsManager.sendTextToCursorNative(text);
+          if (!result.success) {
+            this.logger.log('🔧 Windows: Native approach failed, trying basic PowerShell...');
+            result = await this.windowsManager.sendTextToCursor(text);
+          }
+          return result;
+
+        case 'vscode':
+        case 'windsurf':
+          // For now, use the same approach as Cursor for other IDEs
+          return await this.windowsManager.sendTextToCursor(text);
+
+        default:
+          return {
+            success: false,
+            error: `Windows automation not implemented for IDE: ${ide}`,
+            method: 'windows-automation'
+          };
+      }
+    } catch (error) {
+      this.logger.error(`❌ Windows: Error sending text to ${ide}:`, error.message);
+      return {
+        success: false,
+        error: `Windows automation error: ${error.message}`,
+        method: 'windows-automation'
+      };
+    }
+  }
+
+  /**
+   * Read chat response from 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' && ide !== 'vscode') {
+      return 'Error: AppleScript reading is only supported for Cursor, Windsurf, and VS Code';
+    }
+
+    const ideName = ide === 'windsurf' ? 'Windsurf' : ide === 'cursor' ? 'Cursor' : ide === 'vscode' ? 'VS Code' : 'Unknown';
+    this.logger.log(`${ideName} 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);
+        }
+      }
+
+      let appleScript;
+
+      if (ide === 'cursor') {
+        // Enhanced AppleScript to read the chat response from Cursor
+        appleScript = `
+          tell application "System Events"
+            tell process "Cursor"
+              set frontmost to true
+              delay 1
+
+              -- 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 text from all text areas in the window
+              try
+                set allTextAreas to text area of window 1
+                set responseText to ""
+                repeat with txtArea in allTextAreas
+                  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
+                if responseText is not "" then
+                  return responseText
+                end if
+              on error
+                -- Continue to next method
+              end try
+
+              -- Method 3: Try to get text from all static text elements
+              try
+                set allTexts to static text of window 1
+                set responseText to ""
+                repeat with txt in allTexts
+                  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 text element
+                  end try
+                end repeat
+                if responseText is not "" then
+                  return responseText
+                end if
+              on error
+                -- Continue to next method
+              end try
+
+              -- Method 4: Try clipboard approach (select all and copy)
+              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 5: Try to find scroll areas and get their content
+              try
+                set scrollAreas to scroll area of window 1
+                set responseText to ""
+                repeat with scrollArea in scrollAreas
+                  try
+                    set scrollTexts to static text of scrollArea
+                    repeat with txt in scrollTexts
+                      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 text
+                      end try
+                    end repeat
+                  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 6: Try to access web view content through accessibility
+              try
+                set webViews to group of window 1
+                set responseText to ""
+                repeat with webView in webViews
+                  try
+                    -- Try to get all accessible elements within the web view
+                    set accessibleElements to every UI element of webView
+                    repeat with element in accessibleElements
+                      try
+                        set elementValue to value of element
+                        if elementValue is not "" and elementValue is not missing value then
+                          set responseText to responseText & elementValue & "\\n"
+                        end if
+                      on error
+                        -- Continue to next element
+                      end try
+                    end repeat
+                  on error
+                    -- Continue to next web view
+                  end try
+                end repeat
+                if responseText is not "" then
+                  return responseText
+                end if
+              on error
+                -- Continue to next method
+              end try
+
+              -- Method 7: Try to use JavaScript injection (if possible)
+              try
+                -- This is a fallback method that might work in some cases
+                set responseText to ""
+                set allElements to every UI element of window 1
+                repeat with element in allElements
+                  try
+                    set elementValue to value of element
+                    if elementValue is not "" and elementValue is not missing value then
+                      set responseText to responseText & elementValue & "\\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 8: Return diagnostic information
+              return "No chat content found in Cursor - diagnostic info: Window exists but no readable text content detected. This may be because Cursor's chat interface is in a web view that AppleScript cannot access directly."
+            end tell
+          end tell
+        `;
+      } else if (ide === 'windsurf') {
+        // AppleScript to read the chat response from Windsurf
+        appleScript = `
+        tell application "System Events"
+          tell process "Windsurf"
+            set frontmost to true
+            delay 1
+
+            -- 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
+      `;
+      } else if (ide === 'vscode') {
+        // AppleScript to read the chat response from VS Code
+        appleScript = `
+        tell application "System Events"
+          tell process "Visual Studio Code"
+            set frontmost to true
+            delay 1
+
+            -- Method 1: Try to get all static text from the window (GitHub Copilot Chat)
+            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 (chat panels)
+            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 to get text from text areas (chat input/output areas)
+            try
+              set textAreas to text area of window 1
+              set responseText to ""
+              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
+              if responseText is not "" then
+                return responseText
+              end if
+            on error
+              -- Continue to next method
+            end try
+
+            -- Method 4: Try clipboard approach (select all chat content and copy)
+            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 5: Try to access scroll areas (chat history)
+            try
+              set scrollAreas to scroll area of window 1
+              set responseText to ""
+              repeat with scrollArea in scrollAreas
+                try
+                  set scrollTexts to static text of scrollArea
+                  repeat with txt in scrollTexts
+                    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 text
+                    end try
+                  end repeat
+                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 6: Return placeholder
+            return "No chat content found in VS Code - ensure GitHub Copilot Chat or Continue extension is active"
+          end tell
+        end tell
+      `;
+      } else {
+        return `Error: AppleScript reading is not supported for IDE: ${ide}`;
+      }
+
+      const result = execSync(`osascript -e '${appleScript}'`, { stdio: 'pipe', encoding: 'utf8' });
+      this.logger.log(`Successfully read ${ide} 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 Cursor response - all methods failed. AppleScript diagnostic: ${result.substring(0, 200)}...`;
+      }
+
+      // If we got a very short result, try a diagnostic approach
+      if (result.trim().length <= 5) {
+        this.logger.log('AppleScript returned very short result, trying diagnostic approach...');
+
+        const processName = ide === 'windsurf' ? 'Windsurf' : ide === 'antigravity' ? 'Antigravity' : 'Cursor';
+        const diagnosticScript = `
+          tell application "System Events"
+            tell process "${processName}"
+              set frontmost to true
+              delay 1
+
+              -- Get window info
+              set windowInfo to "Window: " & name of window 1 & "\\n"
+
+              -- Try to get element counts
+              try
+                set staticTexts to static text of window 1
+                set groups to group of window 1
+                set textAreas to text area of window 1
+                set scrollAreas to scroll area of window 1
+                set uiElements to every UI element of window 1
+
+                set elementInfo to "\\nStatic Texts: " & count of staticTexts & "\\n"
+                set elementInfo to elementInfo & "Groups: " & count of groups & "\\n"
+                set elementInfo to elementInfo & "Text Areas: " & count of textAreas & "\\n"
+                set elementInfo to elementInfo & "Scroll Areas: " & count of scrollAreas & "\\n"
+                set elementInfo to elementInfo & "UI Elements: " & count of uiElements & "\\n"
+
+                -- Try to get sample text from each type
+                if count of staticTexts > 0 then
+                  try
+                    set sampleText to value of item 1 of staticTexts
+                    set elementInfo to elementInfo & "\\nSample static text: " & sampleText & "\\n"
+                  on error
+                    set elementInfo to elementInfo & "\\nCould not read sample static text\\n"
+                  end try
+                end if
+
+                if count of textAreas > 0 then
+                  try
+                    set sampleText to value of item 1 of textAreas
+                    set elementInfo to elementInfo & "\\nSample text area: " & sampleText & "\\n"
+                  on error
+                    set elementInfo to elementInfo & "\\nCould not read sample text area\\n"
+                  end try
+                end if
+
+                return windowInfo & elementInfo
+              on error
+                return windowInfo & "\\nCould not get element info"
+              end try
+            end tell
+          end tell
+        `;
+
+        const diagnosticResult = execSync(`osascript -e '${diagnosticScript}'`, { stdio: 'pipe', encoding: 'utf8' });
+        this.logger.log('Diagnostic AppleScript result:', diagnosticResult);
+
+        if (diagnosticResult.length > 20) {
+          return diagnosticResult.trim();
+        }
+      }
+
+      return result.trim();
+
+    } catch (error) {
+      this.logger.log('AppleScript reading failed:', error.message);
+      return 'Error: Could not read 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 without selecting all content
+            try
+              -- Just try to copy without selecting all (safer approach)
+              key code 8 using {command down}  -- Cmd+C to copy
+              delay 0.5
+            on error
+              -- If that fails, return empty response
+              return ""
+            end try
+          end tell
+        end tell
+      `;
+
+      // Use file-based execution for clipboard script too
+      const tempFile = join(tmpdir(), `clipboard_${Date.now()}.scpt`);
+      try {
+        writeFileSync(tempFile, clipboardScript, 'utf8');
+        execSync(`osascript "${tempFile}"`, { stdio: 'pipe' });
+      } finally {
+        try {
+          unlinkSync(tempFile);
+        } catch (cleanupError) {
+          this.logger.log(`⚠️ Failed to cleanup clipboard temp file: ${cleanupError.message}`);
+        }
+      }
+
+      // Read from clipboard
+      const clipboardScript2 = `
+        the clipboard
+      `;
+
+      const tempFile2 = join(tmpdir(), `clipboard_read_${Date.now()}.scpt`);
+      try {
+        writeFileSync(tempFile2, clipboardScript2, 'utf8');
+        const clipboardContent = execSync(`osascript "${tempFile2}"`, { 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');
+      } finally {
+        try {
+          unlinkSync(tempFile2);
+        } catch (cleanupError) {
+          this.logger.log(`⚠️ Failed to cleanup clipboard read temp file: ${cleanupError.message}`);
+        }
+      }
+
+    } catch (error) {
+      this.logger.log(`❌ Clipboard method failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Close Claude CLI terminal windows
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async closeClaudeCLI() {
+    try {
+      this.logger.log('🔄 [Claude] Closing Claude CLI terminal windows...');
+
+      const script = `
+tell application "Terminal"
+  activate
+  delay 1
+
+  -- Find all terminal windows with Claude CLI running
+  set claudeWindows to {}
+  repeat with w in windows
+    try
+      set windowName to name of w
+      if windowName contains "claude" or windowName contains "Claude" then
+        set end of claudeWindows to w
+      end if
+    end try
+  end repeat
+
+  -- Close Claude terminal windows
+  if (count of claudeWindows) > 0 then
+    repeat with w in claudeWindows
+      try
+        close w
+        delay 0.5
+      end try
+    end repeat
+    return "Closed " & (count of claudeWindows) & " Claude terminal windows"
+  else
+    return "No Claude terminal windows found to close"
+  end if
+end tell
+      `;
+
+      // Create a temporary AppleScript file
+      const tempScriptPath = join(tmpdir(), `close_claude_${Date.now()}.scpt`);
+      writeFileSync(tempScriptPath, script);
+
+      // Execute the AppleScript file
+      this.logger.log('🔧 Executing AppleScript to close Claude CLI terminal windows...');
+      const result = execSync(`osascript "${tempScriptPath}"`, {
+        encoding: 'utf8',
+        timeout: 10000
+      });
+
+      // Clean up the temporary file
+      try {
+        unlinkSync(tempScriptPath);
+      } catch (cleanupError) {
+        this.logger.log(`⚠️ Failed to cleanup temp file: ${cleanupError.message}`);
+      }
+
+      this.logger.log(`✅ Claude CLI close result: ${result.trim()}`);
+      return {
+        success: true,
+        message: result.trim(),
+        method: 'applescript',
+        action: 'close'
+      };
+    } catch (error) {
+      this.logger.log(`⚠️ Error closing Claude CLI: ${error.message}`);
+      return {
+        success: false,
+        error: error.message,
+        method: 'applescript'
+      };
+    }
+  }
+
+  /**
+   * Close previous chat thread in an IDE to prevent conflicts
+   * @param {string} ide - The IDE name ('cursor', 'vscode', 'windsurf', 'claude')
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async closePreviousChatThread(ide) {
+    if (!ide || typeof ide !== 'string') {
+      return {
+        success: false,
+        error: 'Invalid IDE parameter',
+        method: 'applescript'
+      };
+    }
+
+    const ideName = ide.toLowerCase();
+
+    // Handle Claude CLI separately since it's a terminal application
+    if (ideName === 'claude') {
+      return await this.closeClaudeCLI();
+    }
+
+    if (!['cursor', 'vscode', 'windsurf'].includes(ideName)) {
+      return {
+        success: false,
+        error: 'Unsupported IDE for thread closure',
+        method: 'applescript'
+      };
+    }
+
+    try {
+      this.logger.log(`🔄 [${ideName}] Closing previous chat thread...`);
+
+      let script = '';
+      switch (ideName) {
+        case 'cursor':
+          script = `
+tell application "Cursor"
+  activate
+  delay 1
+end tell
+
+tell application "System Events"
+  tell process "Cursor"
+    set frontmost to true
+    delay 1
+
+    -- Close previous chat thread by starting a new conversation
+    try
+      -- Open Command Palette (Cmd+Shift+P)
+      key code 35 using {command down, shift down} -- Cmd+Shift+P
+      delay 0.5
+
+      -- Type "New Chat" or "Start New Conversation"
+      keystroke "New Chat"
+      delay 0.5
+
+      -- Press Enter to start new conversation
+      key code 36 -- Enter
+      delay 1
+
+      return "Previous chat thread closed in Cursor"
+    on error
+      -- Fallback: just return success without clearing anything
+      return "Previous chat thread closed in Cursor (fallback)"
+    end try
+  end tell
+end tell
+          `;
+          break;
+
+        case 'vscode':
+          script = `
+tell application "Visual Studio Code"
+  activate
+  delay 1.5
+end tell
+
+tell application "System Events"
+  tell process "Visual Studio Code"
+    set frontmost to true
+    delay 1.5
+
+    -- Close previous chat thread in VS Code
+    try
+      -- Open Command Palette (Cmd+Shift+P)
+      key code 35 using {command down, shift down} -- Cmd+Shift+P
+      delay 1.0
+
+      -- Type "New Chat" or "Start New Conversation"
+      keystroke "New Chat"
+      delay 1.0
+
+      -- Press Enter to start new conversation
+      key code 36 -- Enter
+      delay 1.5
+
+      return "Previous chat thread closed in VS Code"
+    on error
+      -- Fallback: just return success without clearing anything
+      return "Previous chat thread closed in VS Code (fallback)"
+    end try
+  end tell
+end tell
+          `;
+          break;
+
+        case 'windsurf':
+          script = `
+tell application "Windsurf"
+  activate
+  delay 1
+end tell
+
+tell application "System Events"
+  tell process "Windsurf"
+    set frontmost to true
+    delay 1
+
+    -- Close previous chat thread in Windsurf
+    try
+      -- Open Command Palette (Cmd+Shift+P)
+      key code 35 using {command down, shift down} -- Cmd+Shift+P
+      delay 0.5
+
+      -- Type "New Chat" or "Start New Conversation"
+      keystroke "New Chat"
+      delay 0.5
+
+      -- Press Enter to start new conversation
+      key code 36 -- Enter
+      delay 1
+
+      return "Previous chat thread closed in Windsurf"
+    on error
+      -- Fallback: just return success without clearing anything
+      return "Previous chat thread closed in Windsurf (fallback)"
+    end try
+  end tell
+end tell
+          `;
+          break;
+      }
+
+      // Create a temporary AppleScript file
+      const tempScriptPath = join(tmpdir(), `close_thread_${Date.now()}.scpt`);
+      writeFileSync(tempScriptPath, script);
+
+      // Execute the AppleScript file
+      this.logger.log(`🔧 Executing AppleScript to close previous thread in ${ideName}...`);
+      const result = execSync(`osascript "${tempScriptPath}"`, {
+        encoding: 'utf8',
+        timeout: 10000
+      });
+
+      // Clean up the temporary file
+      try {
+        unlinkSync(tempScriptPath);
+      } catch (cleanupError) {
+        this.logger.log(`⚠️ Failed to cleanup temp file: ${cleanupError.message}`);
+      }
+
+      this.logger.log(`✅ Previous chat thread closed in ${ideName}: ${result.trim()}`);
+      return {
+        success: true,
+        message: result.trim(),
+        method: 'applescript'
+      };
+
+    } catch (error) {
+      this.logger.log(`❌ Failed to close previous chat thread in ${ideName}: ${error.message}`);
+      return {
+        success: false,
+        error: error.message,
+        method: 'applescript'
+      };
+    }
+  }
+
+  /**
+   * Send text to an IDE with automatic thread closure
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name ('cursor', 'vscode', 'windsurf')
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async sendTextWithThreadClosure(text, ide) {
+    if (!text || typeof text !== 'string' || !text.trim()) {
+      return {
+        success: false,
+        error: 'Invalid text parameter',
+        method: 'applescript'
+      };
+    }
+
+    if (!ide || typeof ide !== 'string') {
+      return {
+        success: false,
+        error: 'Invalid IDE parameter',
+        method: 'applescript'
+      };
+    }
+
+    try {
+      this.logger.log(`🔄 [${ide}] Sending text with thread closure...`);
+
+      // First, try to close the previous chat thread
+      const closeResult = await this.closePreviousChatThread(ide);
+
+      // Wait a moment for the thread closure to complete
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      // Then send the new message
+      const sendResult = await this.sendText(text, ide);
+
+      // Combine the results
+      if (sendResult.success) {
+        return {
+          success: true,
+          message: sendResult.message,
+          method: sendResult.method,
+          threadClosure: closeResult.success ? 'Previous thread closed' : 'Thread closure failed',
+          warning: !closeResult.success ? `Failed to close previous thread: ${closeResult.error}` : undefined
+        };
+      } else {
+        return {
+          success: false,
+          error: sendResult.error,
+          method: sendResult.method,
+          threadClosure: closeResult.success ? 'Previous thread closed' : 'Thread closure failed'
+        };
+      }
+
+    } catch (error) {
+      this.logger.log(`❌ Failed to send text with thread closure to ${ide}: ${error.message}`);
+      return {
+        success: false,
+        error: error.message,
+        method: 'applescript'
+      };
+    }
+  }
+
+  /**
+   * Programmatically sets the state of the Gemini "Code Assistance" feature in VS Code's settings.json.
+   * This is more reliable than UI automation.
+   * @param {boolean} enable - True to enable, false to disable.
+   * @returns {Promise<Object>} Result object with success status and details.
+   * @private
+   */
+  async _setGeminiAgentState(enable) {
+    const ideName = 'VS Code';
+    const action = enable ? 'Enabling' : 'Disabling';
+    this.logger.log(`🚀 [${ideName}] ${action} Gemini Code Assistance by editing settings.json...`);
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const os = require('os');
+
+      // Determine the path to settings.json based on the OS
+      const homeDir = os.homedir();
+      let settingsPath;
+      if (this.platform === 'darwin') {
+        settingsPath = path.join(homeDir, 'Library', 'Application Support', 'Code', 'User', 'settings.json');
+      } else if (this.platform === 'win32') {
+        settingsPath = path.join(homeDir, 'AppData', 'Roaming', 'Code', 'User', 'settings.json');
+      } else { // Linux
+        settingsPath = path.join(homeDir, '.config', 'Code', 'User', 'settings.json');
+      }
+
+      this.logger.log(`📝 Located settings.json at: ${settingsPath}`);
+
+      if (!fs.existsSync(settingsPath)) {
+        throw new Error(`VS Code settings.json not found at ${settingsPath}`);
+      }
+
+      // Read and parse the settings file, handling comments
+      const settingsContent = fs.readFileSync(settingsPath, 'utf8');
+      // A simple regex to strip comments before parsing
+      const jsonContent = settingsContent.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m);
+      const settings = JSON.parse(jsonContent);
+
+      // Update the setting
+      const settingKey = 'gemini.codeAssistance';
+      settings[settingKey] = enable;
+
+      // Write the updated settings back to the file
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+
+      this.logger.log(`✅ [${ideName}] Successfully set "${settingKey}": ${enable} in settings.json.`);
+      return {
+        success: true,
+        method: 'settings.json',
+        message: `Gemini Code Assistance ${action.toLowerCase()}d successfully.`
+      };
+    } catch (error) {
+      this.logger.error(`❌ [${ideName}] Error toggling Gemini Agent via settings.json:`, error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'settings.json'
+      };
+    }
+  }
+
+
+  /**
+   * Check if we're running within a VS Code extension context
+   * @returns {boolean} True if running in VS Code extension
+   */
+  isRunningInVSCodeExtension() {
+    try {
+      // Check for VS Code extension environment variables
+      return !!(process.env.VSCODE_PID ||
+                process.env.VSCODE_INJECTION ||
+                process.env.VSCODE_IPC_HOOK_CLI ||
+                (typeof require !== 'undefined' && require.main && require.main.filename.includes('vscode')));
+    } catch (error) {
+      this.logger.log('⚠️ Could not determine VS Code extension context:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Send text to Windsurf extension within VS Code
+   * @param {string} text - The text to send
+   * @returns {Promise<Object>} Result object with success status
+   */
+  async sendTextToWindsurfExtension(text) {
+    try {
+      this.logger.log('🚀 Sending message to Windsurf extension via VS Code commands...');
+
+      // Since we're in the core package, we can't directly use vscode.commands
+      // Instead, we'll use AppleScript to interact with VS Code
+      const appleScript = `
+        tell application "System Events"
+          tell process "Visual Studio Code"
+            set frontmost to true
+            delay 1
+
+            -- Step 1: Open Command Palette (Cmd+Shift+P)
+            key code 35 using {command down, shift down}
+            delay 0.5
+
+            -- Step 2: Type "Windsurf: Open Chat"
+            keystroke "Windsurf: Open Chat"
+            delay 0.5
+
+            -- Step 3: Press Enter to execute the command
+            key code 36
+            delay 1.5
+
+            -- Step 4: Try to start a new chat session
+            try
+              -- Open Command Palette again
+              key code 35 using {command down, shift down}
+              delay 0.5
+
+              -- Type the new chat command
+              keystroke "extension.windSurf.newChat"
+              delay 0.5
+
+              -- Press Enter
+              key code 36
+              delay 1
+            on error
+              -- Continue if new chat command fails
+            end try
+
+            -- Step 5: Send the message
+            keystroke "${text.replace(/"/g, '\\"')}"
+            delay 0.5
+
+            -- Step 6: Submit the message (Enter)
+            key code 36
+            delay 0.5
+
+            return "Message sent to Windsurf extension"
+          end tell
+        end tell
+      `;
+
+      // Use file-based execution for AppleScript
+      const tempFile = join(tmpdir(), `windsurf_extension_${Date.now()}.scpt`);
+      try {
+        writeFileSync(tempFile, appleScript, 'utf8');
+        execSync(`osascript "${tempFile}"`, { stdio: 'pipe' });
+        this.logger.log('✅ Message sent to Windsurf extension successfully');
+        return {
+          success: true,
+          method: 'applescript-vscode-commands',
+          message: `Message sent to Windsurf extension: ${text}`,
+          note: 'Message sent via AppleScript automation to VS Code Windsurf extension'
+        };
+      } finally {
+        try {
+          unlinkSync(tempFile);
+        } catch (cleanupError) {
+          this.logger.log(`⚠️ Failed to cleanup temp file: ${cleanupError.message}`);
+        }
+      }
+
+    } catch (error) {
+      this.logger.log('❌ Failed to send message to Windsurf extension:', error);
+      return {
+        success: false,
+        error: `Failed to send message to Windsurf extension: ${error.message}`,
+        method: 'applescript-vscode-commands'
+      };
+    }
+  }
+}
+
+module.exports = AppleScriptManager;