vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,627 @@
+// @vibecodingmachine/core - macOS IDE Manager
+// macOS-specific IDE operations using AppleScript
+
+const { execSync } = require('child_process');
+const { writeFileSync, unlinkSync } = require('fs');
+const { join } = require('path');
+const { tmpdir } = require('os');
+
+/**
+ * macOS IDE Manager for AppleScript-based interactions
+ * Handles all macOS-specific IDE operations
+ */
+class MacOSIDEManager {
+  constructor(appleScriptUtils) {
+    this.logger = console;
+    this.appleScriptUtils = appleScriptUtils;
+  }
+
+  /**
+   * Open IDE on macOS using AppleScript
+   * @param {string} ide - The IDE name
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  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 'github-copilot':
+        return await this.openVSCodeWithExtension('github-copilot', repoPath);
+      case 'amazon-q':
+        return await this.openVSCodeWithExtension('amazon-q', repoPath);
+      case 'replit':
+        return await this.openReplit(repoPath);
+      case 'kiro':
+        return await this.openKiro(repoPath);
+      case 'claude':
+      case 'claude-code':
+        return await this.openClaude(repoPath);
+      case 'gemini':
+        return await this.openGemini(repoPath);
+      default:
+        return {
+          success: false,
+          error: `Unknown IDE: ${ide}. Supported: cursor, windsurf, antigravity, vscode, github-copilot, amazon-q, replit, kiro, claude, claude-code, gemini`
+        };
+    }
+  }
+
+  /**
+   * 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) {
+    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
+      // [Continued in next part due to size...]
+      return await this._findAndFocusClaudeTerminal(repoPath);
+    } catch (error) {
+      this.logger.log('Error opening Claude:', error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'applescript'
+      };
+    }
+  }
+
+  /**
+   * Find and focus existing Claude terminal window
+   * @param {string} repoPath - Repository path for context
+   * @returns {Promise<Object>} Result object
+   */
+  async _findAndFocusClaudeTerminal(repoPath) {
+    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
+              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}`);
+        }
+      }
+
+      // No existing Claude found, open a new terminal with Claude
+      return await this._openNewClaudeTerminal(repoPath);
+    } catch (focusError) {
+      this.logger.log('⚠️ [Claude] Error finding Claude window, will create new one:', focusError.message);
+      return await this._openNewClaudeTerminal(repoPath);
+    }
+  }
+
+  /**
+   * Open new Claude terminal
+   * @param {string} repoPath - Repository path for context
+   * @returns {Promise<Object>} Result object
+   */
+  async _openNewClaudeTerminal(repoPath) {
+    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}`);
+      }
+    }
+  }
+
+  /**
+   * Open VS Code with optional repository path
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openVSCode(repoPath = null) {
+    try {
+      this.logger.log('Opening VS Code with remote debugging enabled...');
+
+      // First, check if VS Code is already running
+      try {
+        const isRunning = execSync('pgrep -x "Code"', { encoding: 'utf8', stdio: 'pipe' }).trim();
+        if (isRunning) {
+          this.logger.log('VS Code is already running - closing it to enable remote debugging...');
+          execSync('pkill -x "Code"', { stdio: 'pipe' });
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+      } catch (err) {
+        // VS Code not running, that's fine
+      }
+
+      // Launch VS Code with remote debugging enabled for quota detection
+      let command = 'open -a "Visual Studio Code" --args --remote-debugging-port=9222';
+      if (repoPath) {
+        command = `open -a "Visual Studio Code" "${repoPath}" --args --remote-debugging-port=9222`;
+        this.logger.log(`Opening VS Code with repository: ${repoPath}`);
+      }
+
+      execSync(command, { stdio: 'pipe' });
+
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Verify remote debugging port is accessible
+      try {
+        const CDP = require('chrome-remote-interface');
+        await CDP.List({ port: 9222 });
+        this.logger.log('✅ VS Code remote debugging port 9222 is accessible');
+      } catch (cdpError) {
+        this.logger.log(`⚠️ Warning: VS Code remote debugging port not accessible: ${cdpError.message}`);
+        this.logger.log('   Waiting additional 2 seconds for VS Code to fully start...');
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      }
+
+      this.logger.log('VS Code opened successfully with remote debugging');
+      return { success: true, message: `VS Code opened with repository: ${repoPath}`, method: 'applescript' };
+    } catch (error) {
+      this.logger.log('Error opening VS Code:', error.message);
+      return { success: false, error: error.message, method: 'applescript' };
+    }
+  }
+
+  /**
+   * Open VS Code with a specific extension installed
+   * @param {string} extension - Extension key (e.g., 'github-copilot', 'amazon-q')
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openVSCodeWithExtension(extension, repoPath = null) {
+    try {
+      this.logger.log(`Opening VS Code with ${extension} extension...`);
+
+      // Extension IDs mapping
+      const extensionIds = {
+        'github-copilot': 'GitHub.copilot',
+        'amazon-q': 'amazonwebservices.amazon-q-vscode',
+        'continue': 'Continue.continue'
+      };
+
+      const extensionId = extensionIds[extension];
+      if (!extensionId) {
+        return { success: false, error: `Unknown extension: ${extension}`, method: 'applescript' };
+      }
+
+      // First, check if the extension is installed
+      try {
+        const checkCmd = `code --list-extensions | grep -i "${extensionId}"`;
+        execSync(checkCmd, { stdio: 'pipe' });
+        this.logger.log(`Extension ${extension} is already installed`);
+      } catch (checkError) {
+        // Extension not found, try to install it
+        this.logger.log(`Extension ${extension} not found, installing...`);
+        try {
+          execSync(`code --install-extension ${extensionId} --force`, { stdio: 'pipe', timeout: 60000 });
+          this.logger.log(`Extension ${extension} installed successfully`);
+        } catch (installError) {
+          this.logger.log(`Failed to install extension ${extension}:`, installError.message);
+          return { success: false, error: `Failed to install extension: ${installError.message}`, method: 'applescript' };
+        }
+      }
+
+      // First, check if VS Code is already running
+      try {
+        const isRunning = execSync('pgrep -x "Code"', { encoding: 'utf8', stdio: 'pipe' }).trim();
+        if (isRunning) {
+          this.logger.log('VS Code is already running - closing it to enable remote debugging...');
+          execSync('pkill -x "Code"', { stdio: 'pipe' });
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+      } catch (err) {
+        // VS Code not running, that's fine
+      }
+
+      // Open VS Code with the repository and remote debugging enabled
+      let command = 'open -a "Visual Studio Code" --args --remote-debugging-port=9222';
+      if (repoPath) {
+        command = `open -a "Visual Studio Code" "${repoPath}" --args --remote-debugging-port=9222`;
+        this.logger.log(`Opening VS Code with repository: ${repoPath}`);
+      }
+
+      execSync(command, { stdio: 'pipe' });
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Verify remote debugging port is accessible
+      try {
+        const CDP = require('chrome-remote-interface');
+        await CDP.List({ port: 9222 });
+        this.logger.log('✅ VS Code remote debugging port 9222 is accessible');
+      } catch (cdpError) {
+        this.logger.log(`⚠️ Warning: VS Code remote debugging port not accessible: ${cdpError.message}`);
+        this.logger.log('   Waiting additional 2 seconds for VS Code to fully start...');
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      }
+
+      this.logger.log(`VS Code opened successfully with ${extension} extension and remote debugging`);
+      return { success: true, message: `VS Code opened with ${extension} extension`, method: 'applescript' };
+    } catch (error) {
+      this.logger.log(`Error opening VS Code with ${extension}:`, error.message);
+      return { success: false, error: error.message, method: 'applescript' };
+    }
+  }
+
+  /**
+   * Open Replit Agent with optional repository path
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openReplit(repoPath = null) {
+    try {
+      this.logger.log('Opening Replit...');
+      this.logger.log(`Platform detected: ${process.platform}`);
+
+      // Replit typically uses web browser, so we'll open the Replit website
+      // If Replit has a desktop app or CLI, this can be updated
+      const replitUrl = repoPath
+        ? `https://replit.com/@replit/agent?path=${encodeURIComponent(repoPath)}`
+        : 'https://replit.com/@replit/agent';
+
+      const command = `open "${replitUrl}"`;
+      this.logger.log(`Using macOS command: ${command}`);
+
+      execSync(command, { stdio: 'pipe' });
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      this.logger.log('Replit opened successfully');
+      return { success: true, message: 'Replit opened in browser', method: 'applescript' };
+    } catch (error) {
+      this.logger.log('Error opening Replit:', error.message);
+      return { success: false, error: error.message, method: 'applescript' };
+    }
+  }
+
+  /**
+   * Open Windsurf IDE with optional repository path
+   * @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
+        '/usr/local/bin/windsurf', // Linux
+        '/opt/windsurf/windsurf' // Linux alternative
+      ];
+
+      let windsurfPath = possiblePaths.find(path => {
+        try {
+          const fs = require('fs');
+          fs.accessSync(path);
+          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'
+      };
+    }
+  }
+
+  /**
+   * Open Google Antigravity with optional repository path
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  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'
+      };
+    }
+  }
+
+  /**
+   * Open AWS Kiro IDE with optional repository path
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openKiro(repoPath = null) {
+    try {
+      this.logger.log('Opening AWS Kiro...');
+
+      let command = 'open -a "AWS Kiro"';
+      if (repoPath) {
+        command += ` "${repoPath}"`;
+      }
+
+      try {
+        this.logger.log(`Executing command: ${command}`);
+        execSync(command, { stdio: 'pipe' });
+      } catch (e) {
+        // Fallback to just "Kiro"
+        this.logger.log('Failed to open "AWS Kiro", trying "Kiro"...');
+        command = 'open -a "Kiro"';
+        if (repoPath) {
+          command += ` "${repoPath}"`;
+        }
+        execSync(command, { stdio: 'pipe' });
+      }
+
+      // Wait a moment for Kiro to start
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      this.logger.log('AWS Kiro opened successfully');
+      return {
+        success: true,
+        message: repoPath ? `AWS Kiro opened with repository: ${repoPath}` : 'AWS Kiro opened successfully',
+        method: 'applescript'
+      };
+    } catch (error) {
+      this.logger.log('Error opening AWS Kiro:', error.message);
+      return {
+        success: false,
+        error: error.message,
+        method: 'applescript'
+      };
+    }
+  }
+
+  // Continue with sendText, closePreviousChatThread, and other methods...
+  // These will be split into additional files to stay under 555 lines
+}
+
+module.exports = MacOSIDEManager;