vibecodingmachine-core 1.0.0

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

@@ -0,0 +1,321 @@
+import CDP from 'chrome-remote-interface';
+
+// Timeout utility function
+function timeout(ms, promise) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms)
+    )
+  ]);
+}
+
+export class CDPManager {
+  constructor() {
+    this.ports = {
+      vscode: 9222,
+      cursor: 9225,
+      windsurf: 9224
+    };
+  }
+
+  /**
+   * Connect to an IDE via CDP
+   * @param {string} ide - The IDE name (vscode, cursor, windsurf)
+   * @param {number} port - The CDP port (optional, will use default if not provided)
+   * @returns {Promise<Object>} CDP client and domains
+   */
+  async connectToIDE(ide, port = null) {
+    const targetPort = port || this.ports[ide];
+
+    if (!targetPort) {
+      throw new Error(`No CDP port configured for IDE: ${ide}`);
+    }
+
+    try {
+      console.log(`🔍 Connecting to ${ide} on port ${targetPort}...`);
+
+      const targets = await timeout(5000, CDP.List({ port: targetPort }));
+
+      if (!targets || targets.length === 0) {
+        throw new Error(`Could not find ${ide}. Make sure ${ide} is running with --remote-debugging-port=${targetPort}`);
+      }
+
+      // Find the appropriate target
+      let target;
+      if (ide === 'vscode') {
+        target = targets.find(t => t.url && t.url.includes('workbench')) || targets[0];
+      } else {
+        target = targets[0];
+      }
+
+      if (!target) {
+        throw new Error(`No suitable target found for ${ide}`);
+      }
+
+      console.log(`Found ${targets.length} targets, using: ${target.title}`);
+
+      const client = await CDP({ port: targetPort, target });
+      const { Runtime, Input, Page, DOM } = client;
+
+      await Runtime.enable();
+      await DOM.enable();
+
+      if (Page && Page.bringToFront) {
+        try {
+          await Page.bringToFront();
+        } catch (error) {
+          console.log('Could not bring page to front:', error.message);
+        }
+      }
+
+      return {
+        client,
+        Runtime,
+        Input,
+        Page,
+        DOM,
+        target
+      };
+    } catch (error) {
+      console.error(`CDP connection error for ${ide}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Send text to an IDE via CDP
+   * @param {string} text - The text to send
+   * @param {string} ide - The IDE name
+   * @returns {Promise<Object>} Result of the operation
+   */
+  async sendText(text, ide) {
+    if (typeof text !== 'string') {
+      return {
+        success: false,
+        error: `Invalid text type: ${typeof text}. Expected string.`
+      };
+    }
+
+    const ideName = ide === 'windsurf' ? 'Windsurf' : ide === 'cursor' ? 'Cursor' : 'VS Code';
+
+    console.log(`🔍 sendText: Starting debug session`);
+    console.log(`📋 IDE: ${ideName} (${ide})`);
+    console.log(`💬 Text: "${text.substring(0, 100)}${text.length > 100 ? '...' : ''}"`);
+
+    try {
+      const { client, Runtime, Input } = await this.connectToIDE(ide);
+
+      // VS Code specific handling
+      if (ide === 'vscode') {
+        return await this.sendTextToVSCode(text, Runtime, Input);
+      }
+
+      // For other IDEs, use basic CDP approach
+      return await this.sendTextBasic(text, Runtime, Input);
+
+    } catch (error) {
+      console.error(`${ideName} CDP error:`, error);
+      return {
+        success: false,
+        error: `${ideName} CDP error: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Send text to VS Code using the working approach
+   * @param {string} text - The text to send
+   * @param {Object} Runtime - CDP Runtime domain
+   * @param {Object} Input - CDP Input domain
+   * @returns {Promise<Object>} Result of the operation
+   */
+  async sendTextToVSCode(text, Runtime, Input) {
+    try {
+      try {
+        const isDarwin = process.platform === 'darwin';
+        const modifiers = (isDarwin ? 4 /* Meta */ | 2 /* Ctrl */ : 2 /* Ctrl */);
+        await Input.dispatchKeyEvent({ type: 'keyDown', key: 'I', text: 'I', modifiers });
+        await Input.dispatchKeyEvent({ type: 'keyUp', key: 'I', text: 'I', modifiers });
+      } catch (error) {
+        console.log('Could not activate chat view:', error.message);
+      }
+
+      const textToSend = String(text).slice(0, 4000);
+
+      // Use clipboard approach to avoid focus issues
+      console.log('Copying text to clipboard:', textToSend);
+
+      // Note: In VSCode extension context, we'll need to handle clipboard differently
+      // For now, we'll use character-by-character typing
+
+      // Type the text character by character
+      console.log('Starting character-by-character typing...');
+      for (let i = 0; i < textToSend.length; i++) {
+        const char = textToSend[i];
+        await Input.dispatchKeyEvent({ type: 'keyDown', key: char, text: char });
+        await Input.dispatchKeyEvent({ type: 'keyUp', key: char, text: char });
+        await new Promise(resolve => setTimeout(resolve, 20)); // Small delay between characters
+      }
+      console.log('Finished character-by-character typing');
+
+      // Submit the message
+      await this.submitMessage(Input, Runtime);
+
+      return {
+        success: true,
+        method: 'cdp-character-typing',
+        message: `Message sent to VS Code: ${text}`,
+        note: 'Message sent via CDP with character-by-character typing'
+      };
+
+    } catch (error) {
+      console.error('VS Code CDP error:', error);
+      return { success: false, error: `VS Code CDP error: ${error.message}` };
+    }
+  }
+
+  /**
+   * Send text using basic CDP approach
+   * @param {string} text - The text to send
+   * @param {Object} Runtime - CDP Runtime domain
+   * @param {Object} Input - CDP Input domain
+   * @returns {Promise<Object>} Result of the operation
+   */
+  async sendTextBasic(text, Runtime, Input) {
+    try {
+      const textToSend = String(text).slice(0, 4000);
+
+      // Type the text character by character
+      console.log('Starting character-by-character typing...');
+      for (let i = 0; i < textToSend.length; i++) {
+        const char = textToSend[i];
+        await Input.dispatchKeyEvent({ type: 'keyDown', key: char, text: char });
+        await Input.dispatchKeyEvent({ type: 'keyUp', key: char, text: char });
+        await new Promise(resolve => setTimeout(resolve, 20));
+      }
+      console.log('Finished character-by-character typing');
+
+      // Submit the message
+      await this.submitMessage(Input, Runtime);
+
+      return {
+        success: true,
+        method: 'cdp-basic',
+        message: `Message sent: ${text}`,
+        note: 'Message sent via basic CDP approach'
+      };
+
+    } catch (error) {
+      console.error('Basic CDP error:', error);
+      return { success: false, error: `Basic CDP error: ${error.message}` };
+    }
+  }
+
+  /**
+   * Submit a message using multiple methods
+   * @param {Object} Input - CDP Input domain
+   * @param {Object} Runtime - CDP Runtime domain
+   * @returns {Promise<void>}
+   */
+  async submitMessage(Input, Runtime) {
+    // Wait a moment then try multiple ways to submit the message
+    setTimeout(async () => {
+      try {
+        console.log('Attempting to submit message...');
+
+        // Method 1: Press Enter
+        console.log('Method 1: Pressing Enter...');
+        await Input.dispatchKeyEvent({ type: 'keyDown', key: 'Enter' });
+        await Input.dispatchKeyEvent({ type: 'keyUp', key: 'Enter' });
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Method 2: Try clicking the send button
+        console.log('Method 2: Looking for send button...');
+        const clickSendButton = `(() => {
+          const sendButton = document.querySelector('[aria-label*="Send"]') ||
+                            document.querySelector('[title*="Send"]') ||
+                            document.querySelector('button[aria-label*="submit"]') ||
+                            document.querySelector('button[title*="submit"]') ||
+                            document.querySelector('[aria-label*="Send message"]') ||
+                            document.querySelector('[title*="Send message"]') ||
+                            document.querySelector('button[aria-label*="Send message"]') ||
+                            document.querySelector('button[title*="Send message"]') ||
+                            document.querySelector('button[aria-label*="Submit"]') ||
+                            document.querySelector('button[title*="Submit"]') ||
+                            document.querySelector('button[aria-label*="Send request"]') ||
+                            document.querySelector('button[title*="Send request"]') ||
+                            document.querySelector('button svg[data-icon*="send"]')?.closest('button') ||
+                            document.querySelector('button svg[data-icon*="play"]')?.closest('button') ||
+                            document.querySelector('button svg[data-icon*="arrow"]')?.closest('button') ||
+                            document.querySelector('button.send-button') ||
+                            document.querySelector('button.submit-button') ||
+                            document.querySelector('button[class*="send"]') ||
+                            document.querySelector('button[class*="submit"]');
+
+          if (sendButton) {
+            console.log('Found send button:', sendButton.getAttribute('aria-label') || sendButton.getAttribute('title') || sendButton.className);
+            sendButton.click();
+            return true;
+          } else {
+            console.log('No send button found');
+            return false;
+          }
+        })()`;
+
+        const { result: clickRes } = await Runtime.evaluate({ expression: clickSendButton, returnByValue: true });
+        const clickResult = clickRes && (clickRes.value ?? clickRes.unserializableValue) ? (clickRes.value ?? clickRes.unserializableValue) : false;
+        console.log('Send button click result:', clickResult);
+
+        // Method 3: Try Cmd+Enter as alternative
+        if (!clickResult) {
+          console.log('Method 3: Trying Cmd+Enter...');
+          const isDarwin = process.platform === 'darwin';
+          const enterMods = isDarwin ? 4 /* Meta */ : 2 /* Ctrl */;
+          await Input.dispatchKeyEvent({ type: 'keyDown', key: 'Enter', text: 'Enter', modifiers: enterMods });
+          await Input.dispatchKeyEvent({ type: 'keyUp', key: 'Enter', text: 'Enter', modifiers: enterMods });
+        }
+
+        console.log('All submission methods attempted');
+      } catch (error) {
+        console.log('Submission failed:', error.message);
+      }
+    }, 300);
+  }
+
+  /**
+   * Read chat text from an IDE
+   * @param {string} ide - The IDE name
+   * @returns {Promise<string>} The chat text
+   */
+  async readChatText(ide) {
+    try {
+      const { Runtime } = await this.connectToIDE(ide);
+
+      const expression = `(() => {
+        try {
+          // Look for chat messages in various possible locations
+          const chatMessages = document.querySelectorAll('[class*="message"], [class*="chat"], [class*="conversation"]');
+          const messages = [];
+
+          chatMessages.forEach(msg => {
+            const text = msg.textContent || msg.innerText;
+            if (text && text.trim()) {
+              messages.push(text.trim());
+            }
+          });
+
+          return messages.join('\\n\\n');
+        } catch (error) {
+          return 'Error reading chat: ' + error.message;
+        }
+      })()`;
+
+      const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+      return result.value || '[]';
+    } catch (error) {
+      console.error(`Error reading chat from ${ide}:`, error);
+      return `Error: ${error.message}`;
+    }
+  }
+}

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

@@ -0,0 +1,301 @@
+// Claude Code CLI Manager - handles Claude Code CLI execution
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Helper function for timestamps
+function getTimestamp() {
+  const now = new Date();
+  return now.toLocaleTimeString('en-US', {
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false
+  });
+}
+
+class ClaudeCodeCLIManager {
+  constructor() {
+    this.logger = console;
+    this.runningProcesses = [];
+  }
+
+  /**
+   * Check if Claude Code CLI is installed
+   */
+  isInstalled() {
+    try {
+      execSync('which claude', { stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get Claude Code CLI version
+   */
+  getVersion() {
+    try {
+      const version = execSync('claude --version', { encoding: 'utf8', stdio: 'pipe' });
+      return version.trim();
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Install Claude Code CLI
+   * @returns {Promise<{success: boolean, error?: string, suggestions?: string[]}>}
+   */
+  async install() {
+    try {
+      console.log('\n📦 Installing Claude Code CLI...\n');
+
+      // Check if npm is available
+      try {
+        execSync('which npm', { stdio: 'pipe' });
+      } catch {
+        return {
+          success: false,
+          error: 'npm is not installed',
+          suggestions: [
+            'Install Node.js and npm first:',
+            '  macOS: brew install node',
+            '  Linux: sudo apt-get install nodejs npm',
+            '  Windows: Download from https://nodejs.org/'
+          ]
+        };
+      }
+
+      // Install Claude Code globally
+      console.log('Running: npm install -g @anthropic-ai/claude-code');
+      execSync('npm install -g @anthropic-ai/claude-code', {
+        stdio: 'inherit',
+        encoding: 'utf8'
+      });
+
+      // Verify installation
+      if (this.isInstalled()) {
+        const version = this.getVersion();
+        console.log(`\n✓ Claude Code CLI installed successfully: ${version}\n`);
+        return { success: true };
+      } else {
+        return {
+          success: false,
+          error: 'Installation completed but claude command not found',
+          suggestions: [
+            'Try running: npm install -g @anthropic-ai/claude-code',
+            'Make sure your npm global bin directory is in PATH'
+          ]
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        suggestions: [
+          'Try installing manually: npm install -g @anthropic-ai/claude-code',
+          'Check if you have permission to install global npm packages',
+          'You may need to use: sudo npm install -g @anthropic-ai/claude-code'
+        ]
+      };
+    }
+  }
+
+  /**
+   * Kill all running Claude Code processes
+   */
+  killAllProcesses() {
+    for (const proc of this.runningProcesses) {
+      try {
+        if (!proc.killed) {
+          proc.kill('SIGTERM');
+          setTimeout(() => {
+            if (!proc.killed) {
+              proc.kill('SIGKILL');
+            }
+          }, 1000);
+        }
+      } catch (err) {
+        // Ignore errors
+      }
+    }
+    this.runningProcesses = [];
+  }
+
+  /**
+   * Send a prompt to Claude Code and wait for completion
+   * @param {string} text - The message/prompt to send
+   * @param {string} cwd - Path to the repository (working directory)
+   * @param {Object} options - Additional options
+   * @param {Function} options.onOutput - Optional callback for output
+   * @param {Function} options.onError - Optional callback for errors
+   * @param {number} options.timeoutMs - Timeout in milliseconds (default 300000 = 5 minutes)
+   * @returns {Promise<{success: boolean, output: string, error?: string}>}
+   */
+  async sendText(text, cwd = process.cwd(), options = {}) {
+    if (!this.isInstalled()) {
+      return {
+        success: false,
+        error: 'Claude Code CLI is not installed. Run install() first.',
+        needsInstall: true
+      };
+    }
+
+    try {
+      const { onOutput, onError, timeoutMs = 300000 } = options;
+
+      return new Promise((resolve) => {
+        const startTime = Date.now();
+        let stdout = '';
+        let stderr = '';
+        let completed = false;
+        let timeoutKilled = false;
+        let lastOutputTime = Date.now();
+
+        // Spawn Claude Code in the repository directory
+        const proc = spawn('claude', ['code'], {
+          cwd: cwd,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: { ...process.env }
+        });
+
+        this.runningProcesses.push(proc);
+
+        // Status update interval - show progress every 10 seconds if no output
+        const statusInterval = setInterval(() => {
+          const timeSinceOutput = (Date.now() - lastOutputTime) / 1000;
+          if (timeSinceOutput > 10) {
+            const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
+            const chalk = require('chalk');
+            const timestamp = getTimestamp();
+            console.log(chalk.yellow(`[${timestamp}] [CLAUDE] Still waiting... (${elapsed}s elapsed, ${timeSinceOutput.toFixed(0)}s since last output)`));
+          }
+        }, 10000);
+
+        // Hard timeout - kill process if it runs too long
+        const hardTimeout = setTimeout(() => {
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
+          const chalk = require('chalk');
+          const timestamp = getTimestamp();
+          console.log(chalk.red(`\n[${timestamp}] ⏰ TIMEOUT: Claude Code process exceeded ${timeoutMs/1000}s limit (ran for ${elapsed}s)`));
+          console.log(chalk.red(`[${timestamp}] Killing Claude Code process to prevent hanging...`));
+          timeoutKilled = true;
+          completed = true;
+          clearInterval(statusInterval);
+          proc.kill('SIGTERM');
+          setTimeout(() => proc.kill('SIGKILL'), 2000); // Force kill after 2s
+        }, timeoutMs);
+
+        // Handle stdout
+        proc.stdout.on('data', (chunk) => {
+          const chunkText = chunk.toString();
+          stdout += chunkText;
+          lastOutputTime = Date.now();
+
+          // Filter and show useful output
+          const lines = chunkText.split('\n');
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+
+            // Call output callback if provided
+            if (onOutput) {
+              onOutput(line + '\n');
+            } else {
+              // Fallback: write directly to stdout
+              try {
+                const chalk = require('chalk');
+                process.stdout.write(chalk.gray(line + '\n'));
+              } catch {
+                process.stdout.write(line + '\n');
+              }
+            }
+          }
+        });
+
+        // Handle stderr
+        proc.stderr.on('data', (chunk) => {
+          const chunkText = chunk.toString();
+          stderr += chunkText;
+
+          // Only show actual errors
+          if (chunkText.includes('Error:') || chunkText.includes('Failed:') || chunkText.includes('error')) {
+            if (onError) {
+              onError(chunkText.trim());
+            } else {
+              this.logger.error('[Claude Code Error]', chunkText.trim());
+            }
+          }
+        });
+
+        // Send the message and close stdin
+        proc.stdin.write(text + '\n');
+        proc.stdin.end();
+
+        // Handle process exit
+        proc.on('close', (code) => {
+          // Remove process from tracking array
+          const index = this.runningProcesses.indexOf(proc);
+          if (index > -1) {
+            this.runningProcesses.splice(index, 1);
+          }
+
+          clearInterval(statusInterval);
+          clearTimeout(hardTimeout);
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+          const chalk = require('chalk');
+          const timestamp = getTimestamp();
+
+          if (timeoutKilled) {
+            console.log(chalk.red(`[${timestamp}] [CLAUDE] Process killed due to timeout after ${elapsed}s`));
+            resolve({
+              success: false,
+              output: stdout,
+              error: 'Timeout: Process exceeded maximum execution time',
+              exitCode: -1,
+              timeout: true
+            });
+          } else if (code === 0) {
+            console.log(chalk.gray(`[${timestamp}] [CLAUDE] Process completed after ${elapsed}s with code: ${code}`));
+            resolve({
+              success: true,
+              output: stdout,
+              stderr: stderr,
+              exitCode: code
+            });
+          } else {
+            console.log(chalk.gray(`[${timestamp}] [CLAUDE] Process closed after ${elapsed}s with code: ${code}`));
+            resolve({
+              success: false,
+              output: stdout,
+              error: stderr || `Process exited with code ${code}`,
+              exitCode: code
+            });
+          }
+        });
+
+        proc.on('error', (error) => {
+          clearInterval(statusInterval);
+          clearTimeout(hardTimeout);
+          completed = true;
+          const timestamp = getTimestamp();
+          console.log(`\n[${timestamp}] ✗ Claude Code error: ${error.message}`);
+          resolve({
+            success: false,
+            error: error.message,
+            exitCode: -1
+          });
+        });
+      });
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+}
+
+module.exports = ClaudeCodeCLIManager;