@dynamicu/chromedebug-mcp 2.2.0

package/src/legacy/routes.js

@@ -0,0 +1,260 @@
+import express from 'express';
+
+export function createRoutes(chromeController) {
+  const router = express.Router();
+
+  const asyncHandler = (fn) => (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+
+  router.post('/chrome-pilot/launch', asyncHandler(async (req, res) => {
+    const result = await chromeController.launch();
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/navigate', asyncHandler(async (req, res) => {
+    const { url } = req.body;
+    if (!url) {
+      return res.status(400).json({ error: 'URL is required' });
+    }
+    const result = await chromeController.navigateTo(url);
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/pause', asyncHandler(async (req, res) => {
+    const result = await chromeController.pause();
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/resume', asyncHandler(async (req, res) => {
+    const result = await chromeController.resume();
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/step-over', asyncHandler(async (req, res) => {
+    const result = await chromeController.stepOver();
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/evaluate', asyncHandler(async (req, res) => {
+    const { expression } = req.body;
+    if (!expression) {
+      return res.status(400).json({ error: 'Expression is required' });
+    }
+    const result = await chromeController.evaluate(expression);
+    res.json(result);
+  }));
+
+  router.get('/chrome-pilot/scopes', asyncHandler(async (req, res) => {
+    const result = await chromeController.getScopes();
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/set-breakpoint', asyncHandler(async (req, res) => {
+    const { url, lineNumber } = req.body;
+    if (!url || lineNumber === undefined) {
+      return res.status(400).json({ error: 'URL and lineNumber are required' });
+    }
+    const result = await chromeController.setBreakpoint(url, lineNumber);
+    res.json(result);
+  }));
+
+  router.get('/chrome-pilot/logs', asyncHandler(async (req, res) => {
+    const result = chromeController.getLogs();
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/screenshot', asyncHandler(async (req, res) => {
+    const { type, fullPage, path } = req.body || {};
+    const options = {};
+    if (type) options.type = type;
+    if (fullPage !== undefined) options.fullPage = fullPage;
+    if (path) options.path = path;
+    
+    const result = await chromeController.takeScreenshot(options);
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/dom-intent', asyncHandler(async (req, res) => {
+    const { selector, instruction, elementInfo } = req.body;
+    if (!selector) {
+      return res.status(400).json({ error: 'Selector is required' });
+    }
+    const result = await chromeController.selectElement(selector, instruction, elementInfo);
+    res.json(result);
+  }));
+
+  router.get('/chrome-pilot/status', asyncHandler(async (req, res) => {
+    const isConnected = await chromeController.isConnected();
+    res.json({ connected: isConnected, status: 'ok' });
+  }));
+
+  // Port discovery endpoint for Claude to find the server
+  router.get('/chrome-pilot/port', (req, res) => {
+    const serverPort = process.env.SERVER_PORT || process.env.PORT || 3000;
+    res.json({ 
+      port: serverPort,
+      message: 'Chrome Debug server port',
+      timestamp: new Date().toISOString()
+    });
+  });
+  
+  router.get('/chrome-pilot/recording/:id', asyncHandler(async (req, res) => {
+    // Get recording for Claude to analyze
+    const result = await chromeController.getRecording(req.params.id);
+    if (result.error) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  }));
+  
+  router.delete('/chrome-pilot/recording/:id', asyncHandler(async (req, res) => {
+    // Delete recording
+    const result = await chromeController.deleteRecording(req.params.id);
+    if (result.error) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  }));
+  
+  // New frame capture endpoints
+  router.post('/chrome-pilot/frame-batch', (req, res, next) => {
+    // Use multer middleware for this specific route
+    chromeController.upload(req, res, async (err) => {
+      if (err) {
+        console.error('Multer error:', err);
+        return res.status(400).json({ error: true, message: err.message });
+      }
+      
+      try {
+        // Extract data from req.body (populated by multer)
+        const { sessionId, frames } = req.body;
+        
+        console.log('Route received sessionId:', sessionId);
+        console.log('Route received frames (type):', typeof frames);
+        
+        if (!sessionId || !frames) {
+          return res.status(400).json({ error: 'Missing sessionId or frames in request body' });
+        }
+        
+        // Parse the stringified frames and call the controller method correctly
+        const parsedFrames = JSON.parse(frames);
+        console.log('Parsed frames count:', parsedFrames.length);
+        
+        const result = await chromeController.storeFrameBatch(sessionId, parsedFrames);
+        res.json(result);
+        
+      } catch (error) {
+        console.error('Error processing frame batch:', error);
+        res.status(500).json({ error: 'Failed to store frame batch', details: error.message });
+      }
+    });
+  });
+
+  router.get('/chrome-pilot/check-session/:sessionId', asyncHandler(async (req, res) => {
+    const { sessionId } = req.params;
+    const result = await chromeController.checkFrameSession(sessionId);
+    if (result.found) {
+      return res.status(200).json({ status: 'found', sessionId, ...result });
+    } else {
+      return res.status(404).json({ status: 'not_found', sessionId });
+    }
+  }));
+
+  router.post('/chrome-pilot/associate-logs', asyncHandler(async (req, res) => {
+    const { sessionId, logs } = req.body;
+    if (!sessionId || !logs) {
+      return res.status(400).json({ error: 'sessionId and logs are required' });
+    }
+    const result = await chromeController.associateLogsWithFrames(sessionId, logs);
+    res.json(result);
+  }));
+
+  router.post('/chrome-pilot/save-edited-session', asyncHandler(async (req, res) => {
+    const { sessionId, sessionData } = req.body;
+    if (!sessionId || !sessionData) {
+      return res.status(400).json({ error: 'sessionId and sessionData are required' });
+    }
+    const result = await chromeController.saveEditedSession(sessionId, sessionData);
+    res.json(result);
+  }));
+
+  router.get('/chrome-pilot/session/:sessionId', asyncHandler(async (req, res) => {
+    const { sessionId } = req.params;
+    const result = await chromeController.getFrameSession(sessionId);
+    if (result) {
+      res.json(result);
+    } else {
+      res.status(404).json({ error: 'Session not found' });
+    }
+  }));
+
+  // Import session from Chrome extension storage format
+  router.post('/chrome-pilot/import-session', asyncHandler(async (req, res) => {
+    const { sessionId, sessionData } = req.body;
+    if (!sessionId || !sessionData) {
+      return res.status(400).json({ error: 'sessionId and sessionData are required' });
+    }
+    const result = await chromeController.importSessionFromChrome(sessionId, sessionData);
+    res.json(result);
+  }));
+
+  // Workflow recording endpoints
+  router.post('/chrome-pilot/workflow-recording', asyncHandler(async (req, res) => {
+    const { sessionId, url, title, includeLogs, actions, logs } = req.body;
+    if (!sessionId || !actions) {
+      return res.status(400).json({ error: 'sessionId and actions are required' });
+    }
+    const result = await chromeController.storeWorkflowRecording(sessionId, url, title, includeLogs, actions, logs);
+    res.json(result);
+  }));
+
+  router.get('/chrome-pilot/workflow-recording/:sessionId', asyncHandler(async (req, res) => {
+    const { sessionId } = req.params;
+    const result = await chromeController.getWorkflowRecording(sessionId);
+    if (result.error) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  }));
+
+  router.get('/chrome-pilot/workflow-recordings', asyncHandler(async (req, res) => {
+    const result = await chromeController.listWorkflowRecordings();
+    res.json(result);
+  }));
+
+  // Restore point endpoints
+  router.post('/chrome-pilot/restore-point', asyncHandler(async (req, res) => {
+    const result = await chromeController.saveRestorePoint(req.body);
+    res.json(result);
+  }));
+
+  router.get('/chrome-pilot/restore-point/:id', asyncHandler(async (req, res) => {
+    const result = await chromeController.getRestorePoint(req.params.id);
+    if (result.error) {
+      res.status(404).json(result);
+    } else {
+      res.json(result);
+    }
+  }));
+
+  router.get('/chrome-pilot/restore-points/:workflowId', asyncHandler(async (req, res) => {
+    const result = await chromeController.listRestorePoints(req.params.workflowId);
+    res.json(result);
+  }));
+
+  router.delete('/chrome-pilot/restore-point/:id', asyncHandler(async (req, res) => {
+    const result = await chromeController.deleteRestorePoint(req.params.id);
+    res.json(result);
+  }));
+
+  router.use((error, req, res, next) => {
+    console.error('Error:', error);
+    res.status(500).json({
+      error: true,
+      message: error.message || 'Internal server error'
+    });
+  });
+
+  return router;
+}

package/src/legacy/shared-storage.js

@@ -0,0 +1,101 @@
+// New shared storage implementation using SQLite database
+import { database } from './database.js';
+
+class SharedRecordingStorage {
+  constructor() {
+    this.initialized = false;
+    this.initPromise = this.init();
+  }
+
+  async init() {
+    database.init();
+    this.initialized = true;
+  }
+
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initPromise;
+    }
+  }
+
+  // Legacy method - no longer needed with SQLite
+  async loadFromDisk() {
+    // SQLite handles persistence automatically
+  }
+
+  // Legacy method - no longer needed with SQLite
+  async saveToDisk() {
+    // SQLite handles persistence automatically
+  }
+
+  async get(id) {
+    await this.ensureInitialized();
+    return database.getRecording(id);
+  }
+
+  async delete(id) {
+    await this.ensureInitialized();
+    return database.deleteRecording(id);
+  }
+
+  async list() {
+    await this.ensureInitialized();
+    return database.listRecordings();
+  }
+
+  // Store frame batch for frame capture sessions
+  async storeFrameBatch(sessionId, frames) {
+    await this.ensureInitialized();
+    return database.storeFrameBatch(sessionId, frames);
+  }
+  
+  // Get frame session info
+  async getFrameSessionInfo(sessionId) {
+    await this.ensureInitialized();
+    return database.getFrameSessionInfo(sessionId);
+  }
+  
+  // Get specific frame from session
+  async getFrame(sessionId, frameIndex) {
+    await this.ensureInitialized();
+    return database.getFrame(sessionId, frameIndex);
+  }
+  
+  // Get entire frame session
+  async getFrameSession(sessionId) {
+    await this.ensureInitialized();
+    return database.getFrameSession(sessionId);
+  }
+  
+  // Update frame session - for SQLite this is handled by associateLogsWithFrames
+  async updateFrameSession(sessionId, updatedSession) {
+    await this.ensureInitialized();
+    
+    // With SQLite, we don't update the entire session at once
+    // Instead, we use the database's structured approach
+    // This method is kept for backward compatibility
+    
+    if (updatedSession.frames) {
+      // Store the frames
+      const result = database.storeFrameBatch(sessionId, updatedSession.frames);
+      return result;
+    }
+    
+    throw new Error('Frame session update not supported in SQLite mode');
+  }
+
+  // Associate logs with frames
+  async associateLogsWithFrames(sessionId, logs) {
+    await this.ensureInitialized();
+    return database.associateLogsWithFrames(sessionId, logs);
+  }
+
+  // Get database statistics
+  async getStats() {
+    await this.ensureInitialized();
+    return database.getStats();
+  }
+}
+
+// Export singleton instance
+export const sharedStorage = new SharedRecordingStorage();

package/src/logger.js

@@ -0,0 +1,10 @@
+// Simple conditional logger for Chrome Debug
+const isDev = process.env.NODE_ENV === 'development';
+
+module.exports = {
+  log: (...args) => { if (isDev) console.log(...args); },
+  error: (...args) => console.error(...args),
+  warn: (...args) => { if (isDev) console.warn(...args); },
+  info: (...args) => { if (isDev) console.info(...args); },
+  debug: (...args) => { if (isDev) console.debug(...args); }
+};

package/src/mcp/handlers/chrome-tool-handler.js

@@ -0,0 +1,306 @@
+/**
+ * Chrome Tool Handler - Handles Chrome browser control tools
+ * Extracted from original index.js with preserved functionality
+ */
+
+export class ChromeToolHandler {
+  constructor(chromeController) {
+    this.chromeController = chromeController;
+  }
+
+  /**
+   * Handles Chrome-related tool calls with session-aware error recovery
+   * @param {string} name - Tool name
+   * @param {Object} args - Tool arguments
+   * @returns {Object} Tool execution result
+   */
+  async handle(name, args) {
+    // Critical operations that need session isolation error recovery
+    const criticalOps = ['launch_chrome', 'connect_to_existing_chrome', 'force_reset'];
+    
+    if (criticalOps.includes(name)) {
+      return await this.handleWithSessionRecovery(name, args);
+    }
+    
+    switch (name) {
+      case 'launch_chrome':
+        return await this.chromeController.launch();
+      
+      case 'connect_to_existing_chrome':
+        const port = args.port || 9222;
+        return await this.chromeController.connectToExisting(port);
+
+      case 'navigate_to':
+        return await this.chromeController.navigateTo(args.url);
+
+      case 'pause_execution':
+        return await this.chromeController.pause();
+
+      case 'resume_execution':
+        return await this.chromeController.resume();
+
+      case 'step_over':
+        return await this.chromeController.stepOver();
+
+      case 'evaluate_expression':
+        return await this.chromeController.evaluate(args.expression);
+
+      case 'get_scopes':
+        return await this.chromeController.getScopes();
+
+      case 'set_breakpoint':
+        return await this.chromeController.setBreakpoint(args.url, args.lineNumber);
+
+      case 'get_logs':
+        return this.chromeController.getLogs();
+
+      case 'check_connection':
+        return await this.handleCheckConnection();
+
+      case 'force_reset':
+        return await this.chromeController.forceReset();
+
+      case 'take_screenshot':
+        return await this.handleTakeScreenshot(args);
+
+      case 'get_page_content':
+        return await this.handleGetPageContent(args);
+
+      default:
+        throw new Error(`Unknown Chrome tool: ${name}`);
+    }
+  }
+
+  /**
+   * Handle check connection tool
+   * @returns {Object} Connection status
+   */
+  async handleCheckConnection() {
+    const status = await this.chromeController.getConnectionStatus();
+    return { 
+      connected: status.connected,
+      debugPort: status.debugPort,
+      wsEndpoint: status.browserWSEndpoint
+    };
+  }
+
+  /**
+   * Handle take screenshot tool with custom formatting
+   * @param {Object} args - Screenshot arguments
+   * @returns {Object} Screenshot result
+   */
+  async handleTakeScreenshot(args) {
+    const result = await this.chromeController.takeScreenshot(args);
+    
+    if (result.saved) {
+      return {
+        message: `Screenshot saved successfully!`,
+        path: result.path,
+        type: result.type,
+        fullPage: result.fullPage
+      };
+    } else if (result.truncated) {
+      return {
+        message: `Screenshot preview (truncated)`,
+        size: result.size,
+        type: result.type,
+        fullPage: result.fullPage,
+        note: result.message
+      };
+    } else if (result.error) {
+      throw new Error(`Error taking screenshot: ${result.message}`);
+    } else if (result.lowRes) {
+      return {
+        message: `Low-resolution screenshot captured for AI parsing`,
+        size: result.size,
+        type: result.type,
+        fullPage: result.fullPage,
+        quality: result.quality || 'N/A',
+        data: `data:image/${result.type};base64,${result.screenshot}`
+      };
+    } else {
+      return {
+        message: `Screenshot captured!`,
+        size: result.size,
+        type: result.type,
+        fullPage: result.fullPage,
+        preview: result.screenshot.substring(0, 100) + '...',
+        note: 'Full screenshot is too large to display. Use lowRes: true for AI-parseable screenshots or path to save to file.'
+      };
+    }
+  }
+
+  /**
+   * Handle get page content tool with formatted output
+   * @param {Object} args - Page content arguments
+   * @returns {Object} Page content result
+   */
+  async handleGetPageContent(args) {
+    const result = await this.chromeController.getPageContent(args);
+    
+    if (result.error) {
+      throw new Error(`Error getting page content: ${result.message}`);
+    }
+    
+    const formattedResult = {
+      url: result.url,
+      title: result.title,
+      meta: result.meta,
+      statistics: {
+        forms: result.statistics.forms,
+        images: result.statistics.images,
+        links: result.statistics.links,
+        scripts: result.statistics.scripts
+      }
+    };
+
+    if (result.text !== undefined) {
+      formattedResult.text = result.text;
+      formattedResult.textLength = result.textLength;
+      if (result.textLength > 1000) {
+        formattedResult.textPreview = result.text.substring(0, 1000) + '...';
+        formattedResult.note = `Showing first 1000 of ${result.textLength} characters`;
+      }
+    }
+    
+    if (result.structure !== undefined) {
+      formattedResult.structure = result.structure;
+      // Format structure for better readability
+      formattedResult.structureFormatted = this.formatDOMStructure(result.structure);
+    }
+    
+    if (result.html !== undefined) {
+      formattedResult.htmlLength = result.html.length;
+      if (result.html.length > 2000) {
+        formattedResult.htmlPreview = result.html.substring(0, 2000) + '...';
+        formattedResult.htmlNote = `Showing first 2000 of ${result.html.length} characters`;
+      } else {
+        formattedResult.html = result.html;
+      }
+    }
+
+    return formattedResult;
+  }
+
+  /**
+   * Format DOM structure for readable output
+   * @param {Object} node - DOM node structure
+   * @param {string} indent - Indentation level
+   * @returns {string} Formatted structure string
+   */
+  formatDOMStructure(node, indent = '') {
+    if (!node) return '';
+    
+    let output = `${indent}<${node.tag}`;
+    
+    if (node.id) output += ` id="${node.id}"`;
+    if (node.class) output += ` class="${node.class}"`;
+    if (node.href) output += ` href="${node.href}"`;
+    if (node.src) output += ` src="${node.src}"`;
+    if (node.type) output += ` type="${node.type}"`;
+    
+    output += '>';
+    
+    if (node.text && node.text.trim()) {
+      output += ` ${node.text.trim()}`;
+    }
+    
+    output += '\n';
+    
+    if (node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        output += this.formatDOMStructure(child, indent + '  ');
+      }
+    }
+    
+    return output;
+  }
+
+  /**
+   * Handles critical operations with session-aware error recovery
+   * Provides retry logic for SingletonLock and other session conflicts
+   * @param {string} name - Tool name
+   * @param {Object} args - Tool arguments
+   * @returns {Object} Tool execution result
+   */
+  async handleWithSessionRecovery(name, args) {
+    const maxRetries = 3;
+    let lastError = null;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        console.log(`[ChromeToolHandler] Attempt ${attempt}/${maxRetries} for ${name} (Session: ${this.chromeController.sessionId})`);
+        
+        // Execute the operation based on name
+        switch (name) {
+          case 'launch_chrome':
+            return await this.chromeController.launch();
+          
+          case 'connect_to_existing_chrome':
+            const port = args.port || 9222;
+            return await this.chromeController.connectToExisting(port);
+          
+          case 'force_reset':
+            return await this.chromeController.forceReset();
+          
+          default:
+            throw new Error(`Unknown critical operation: ${name}`);
+        }
+      } catch (error) {
+        lastError = error;
+        console.error(`[ChromeToolHandler] Attempt ${attempt} failed for ${name}:`, error.message);
+        
+        // Check for known session conflict errors
+        const isSessionConflict = this.isSessionConflictError(error);
+        
+        if (isSessionConflict && attempt < maxRetries) {
+          console.log(`[ChromeToolHandler] Detected session conflict, attempting recovery...`);
+          
+          try {
+            // Force cleanup current session and create new one
+            await this.chromeController.forceReset();
+            
+            // Wait a bit before retrying to let system stabilize
+            await new Promise(resolve => setTimeout(resolve, 1000 + (attempt * 500)));
+            
+            console.log(`[ChromeToolHandler] Session recovery completed, retrying...`);
+          } catch (recoveryError) {
+            console.error(`[ChromeToolHandler] Session recovery failed:`, recoveryError.message);
+          }
+        } else if (attempt === maxRetries) {
+          // Last attempt failed
+          console.error(`[ChromeToolHandler] All ${maxRetries} attempts failed for ${name}`);
+          break;
+        }
+      }
+    }
+
+    // Return detailed error information
+    throw new Error(`${name} failed after ${maxRetries} attempts. Last error: ${lastError.message}. Session ID: ${this.chromeController.sessionId}`);
+  }
+
+  /**
+   * Checks if an error indicates a session conflict (SingletonLock, port conflicts, etc.)
+   * @param {Error} error - The error to check
+   * @returns {boolean} True if this is a session conflict error
+   */
+  isSessionConflictError(error) {
+    const message = error.message.toLowerCase();
+    
+    // Known session conflict patterns
+    const conflictPatterns = [
+      'singletonlock',
+      'singleton lock',
+      'address already in use',
+      'eaddrinuse',
+      'port already in use',
+      'chrome already running',
+      'debug port',
+      'user data directory',
+      'profile in use',
+      'cannot start chrome'
+    ];
+
+    return conflictPatterns.some(pattern => message.includes(pattern));
+  }
+}