vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/ide-integration/claude-code-cli-manager.cjs

@@ -20,7 +20,9 @@ const RATE_LIMIT_PATTERNS = [
   /try again in \d+[mh]\d*[ms]?/i,
   /please try again in/i,
   /session limit reached/i,
-  /account limit reached/i
+  /account limit reached/i,
+  /spending cap reached/i,
+  /resets\s+[a-z]+\s+\d+\s+at\s+\d+[ap]m/i
 ];
 
 // Helper function for timestamps
@@ -183,27 +185,61 @@ class ClaudeCodeCLIManager {
 
     // Try to extract reset time if available
     let resetTime;
-    // Match patterns like "resets 6am (America/Buenos_Aires)" or "resets at 6am (America/Buenos_Aires)"
-    const resetMatch = error.match(/resets? (?:at )?(\d+)(?::(\d+))?\s*([ap]m)?\s*(\([^)]+\))?/i);
+    // Match patterns like "resets Mar 9 at 6pm" or "resets at 6pm"
+    const resetMatch = error.match(/resets?\s+(?:([a-z]+\s+\d+)\s+at\s+)?(\d+)(?::(\d+))?\s*([ap]m)?\s*(\([^)]*\))?/i);
     if (resetMatch) {
       try {
         const now = new Date();
-        let hours = parseInt(resetMatch[1]);
-        const minutes = resetMatch[2] ? parseInt(resetMatch[2]) : 0;
-        const period = resetMatch[3] ? resetMatch[3].toLowerCase() : null;
+        const monthDay = resetMatch[1]; // "Mar 9" or undefined
+        let hours = parseInt(resetMatch[2]);
+        const minutes = resetMatch[3] ? parseInt(resetMatch[3]) : 0;
+        const period = resetMatch[4] ? resetMatch[4].toLowerCase() : null;
         
         // Convert to 24-hour format if period is specified
         if (period === 'pm' && hours < 12) hours += 12;
         if (period === 'am' && hours === 12) hours = 0;
         
-        // Create reset time
-        resetTime = new Date(now);
-        resetTime.setHours(hours, minutes, 0, 0);
+        // Create reset date
+        const resetDate = new Date(now);
+        resetDate.setHours(hours, minutes, 0, 0);
         
-        // If reset time is in the past, assume it's for tomorrow
-        if (resetTime <= now) {
-          resetTime.setDate(resetTime.getDate() + 1);
+        // If month/day is specified, set it
+        if (monthDay) {
+          const monthDayMatch = monthDay.match(/([a-z]+)\s+(\d+)/i);
+          if (monthDayMatch) {
+            const monthStr = monthDayMatch[1];
+            const day = parseInt(monthDayMatch[2]);
+            const months = {
+              jan: 0, january: 0,
+              feb: 1, february: 1,
+              mar: 2, march: 2,
+              apr: 3, april: 3,
+              may: 4,
+              jun: 5, june: 5,
+              jul: 6, july: 6,
+              aug: 7, august: 7,
+              sep: 8, sept: 8, september: 8,
+              oct: 9, october: 9,
+              nov: 10, november: 10,
+              dec: 11, december: 11
+            };
+            const monthIndex = months[monthStr.toLowerCase().substring(0, 3)];
+            if (monthIndex !== undefined) {
+              resetDate.setMonth(monthIndex, day);
+              // If the date is in the past, assume it's next month
+              if (resetDate < now) {
+                resetDate.setMonth(resetDate.getMonth() + 1);
+              }
+            }
+          }
+        } else {
+          // If no month/day specified and time is in the past, assume tomorrow
+          if (resetDate <= now) {
+            resetDate.setDate(resetDate.getDate() + 1);
+          }
         }
+        
+        resetTime = resetDate;
       } catch (e) {
         console.error('Error parsing reset time:', e);
         resetTime = null;

package/src/ide-integration/ide-openers/claude-opener.js

@@ -0,0 +1,171 @@
+// @vibecodingmachine/core - Claude Code Opener
+// Handles Claude Code specific operations
+
+const { execSync } = require('child_process');
+const { writeFileSync, unlinkSync } = require('fs');
+const { join } = require('path');
+const { tmpdir } = require('os');
+
+/**
+ * Claude Code Opener
+ * Manages opening Claude Code in terminal
+ */
+class ClaudeOpener {
+  constructor(logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * Open Claude in a new terminal or bring existing instance to foreground
+   * @param {string} repoPath - Optional repository path to open
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async open(repoPath = null) {
+    try {
+      this.logger.log('Opening Claude in terminal or bringing to foreground...');
+
+      // First, check if any Claude process is running
+      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');
+        return await this._openNewTerminal(repoPath);
+      }
+
+      // If we get here, Claude process exists - find the specific Claude terminal window
+      return await this._findAndFocusTerminal(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 _findAndFocusTerminal(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
+      return await this._openNewTerminal(repoPath);
+    } catch (focusError) {
+      this.logger.log('⚠️ [Claude] Error finding Claude window, will create new one:', focusError.message);
+      return await this._openNewTerminal(repoPath);
+    }
+  }
+
+  /**
+   * Open new Claude terminal
+   * @param {string} repoPath - Repository path for context
+   * @returns {Promise<Object>} Result object
+   */
+  async _openNewTerminal(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}`);
+      }
+    }
+  }
+}
+
+module.exports = ClaudeOpener;

package/src/ide-integration/ide-openers/cursor-opener.js

@@ -0,0 +1,53 @@
+// @vibecodingmachine/core - Cursor IDE Opener
+// Handles Cursor IDE specific operations
+
+const { execSync } = require('child_process');
+
+/**
+ * Cursor IDE Opener
+ * Manages opening Cursor IDE with remote debugging
+ */
+class CursorOpener {
+  constructor(logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * 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 open(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'
+      };
+    }
+  }
+}
+
+module.exports = CursorOpener;

package/src/ide-integration/ide-openers/other-ides-opener.js

@@ -0,0 +1,230 @@
+// @vibecodingmachine/core - Other IDEs Opener
+// Handles Windsurf, Antigravity, Replit, Kiro, Gemini
+
+const { execSync, spawn } = require('child_process');
+
+/**
+ * Other IDEs Opener
+ * Manages opening various other supported IDEs
+ */
+class OtherIDEsOpener {
+  constructor(logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * Open Gemini (in VS Code)
+   * @param {string} repoPath - Optional repository path to open
+   * @param {Function} vsCodeOpener - VS Code opener function
+   * @returns {Promise<Object>} Result object with success status and details
+   */
+  async openGemini(repoPath, vsCodeOpener) {
+    this.logger.log('Opening Gemini, which runs in VS Code...');
+    return await vsCodeOpener(repoPath);
+  }
+
+  /**
+   * 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
+      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
+        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
+      if (windsurfPath.includes('windsurf')) {
+        // Use spawn to run in background
+        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'
+      };
+    }
+  }
+}
+
+module.exports = OtherIDEsOpener;

package/src/ide-integration/ide-openers/vscode-opener.js

@@ -0,0 +1,147 @@
+// @vibecodingmachine/core - VS Code Opener
+// Handles VS Code and VS Code extensions
+
+const { execSync } = require('child_process');
+
+/**
+ * VS Code Opener
+ * Manages opening VS Code with remote debugging and extensions
+ */
+class VSCodeOpener {
+  constructor(logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * 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 open(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 openWithExtension(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' };
+    }
+  }
+}
+
+module.exports = VSCodeOpener;