@dynamicu/chromedebug-mcp 2.2.0

package/src/services/chrome-service.js

@@ -0,0 +1,375 @@
+/**
+ * Chrome Service Wrapper - Service layer for Chrome controller integration
+ * Provides a clean interface between MCP tools and Chrome controller
+ */
+
+import { ProcessManager } from './process-manager.js';
+import { discoverServer } from '../port-discovery.js';
+import { startHttpServer } from '../http-server.js';
+
+/**
+ * Chrome Service class that wraps ChromeController with additional services
+ * Manages HTTP server integration and process lifecycle
+ */
+export class ChromeService {
+  constructor(chromeController) {
+    this.chromeController = chromeController;
+    this.processManager = new ProcessManager();
+    this.httpServerPort = null;
+    this.httpServer = null;
+    
+    // Add Chrome controller cleanup to process manager
+    this.processManager.addShutdownHandler(async () => {
+      await this.cleanup();
+    });
+  }
+
+  /**
+   * Initializes the Chrome service with HTTP server if needed
+   * @param {Object} options - Initialization options
+   * @returns {Promise<Object>} Initialization result
+   */
+  async initialize(options = {}) {
+    const { startHttp = true, singleServer = false, sessionManager = null } = options;
+
+    const result = {
+      chromeService: 'initialized',
+      httpServer: null,
+      processManager: this.processManager.getStatistics()
+    };
+
+    if (startHttp && !singleServer) {
+      try {
+        // Use port from session manager if available, otherwise use discovery
+        let targetPort = null;
+
+        if (sessionManager) {
+          const sessionInfo = sessionManager.getSessionInfo();
+          if (sessionInfo && sessionInfo.port) {
+            targetPort = sessionInfo.port;
+            console.error(`Using session manager allocated port: ${targetPort}`);
+          }
+        }
+
+        if (!targetPort) {
+          // Fallback to discovery
+          const serverInfo = await discoverServer();
+          console.error('Falling back to port discovery');
+        }
+
+        const { httpServer, serverPort } = await startHttpServer(this.chromeController, targetPort);
+
+        this.httpServer = httpServer;
+        this.httpServerPort = serverPort;
+
+        result.httpServer = {
+          port: serverPort,
+          status: 'running'
+        };
+
+        console.error(`HTTP server started on port ${serverPort}`);
+      } catch (error) {
+        console.error('Failed to start HTTP server:', error);
+        result.httpServer = {
+          error: error.message,
+          status: 'failed'
+        };
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Gets the Chrome controller instance
+   * @returns {Object} Chrome controller
+   */
+  getController() {
+    return this.chromeController;
+  }
+
+  /**
+   * Gets the process manager instance
+   * @returns {ProcessManager} Process manager
+   */
+  getProcessManager() {
+    return this.processManager;
+  }
+
+  /**
+   * Gets HTTP server information
+   * @returns {Object} HTTP server info
+   */
+  getHttpServerInfo() {
+    return {
+      port: this.httpServerPort,
+      running: !!this.httpServer,
+      server: this.httpServer
+    };
+  }
+
+  /**
+   * Safely launches Chrome with process management
+   * @param {Object} options - Launch options
+   * @returns {Promise<Object>} Launch result
+   */
+  async launchChrome(options = {}) {
+    try {
+      const result = await this.chromeController.launch(options);
+      
+      // Register Chrome process for management if available
+      if (result.chromeProcess && result.chromeProcess.pid) {
+        this.processManager.registerProcess(result.chromeProcess.pid);
+      }
+      
+      return result;
+    } catch (error) {
+      console.error('Error launching Chrome:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Connects to existing Chrome with process management
+   * @param {number} port - Chrome debugging port
+   * @returns {Promise<Object>} Connection result
+   */
+  async connectToExistingChrome(port = 9222) {
+    try {
+      const result = await this.chromeController.connectToExisting(port);
+      
+      // Note: We don't register external Chrome processes for management
+      // since we didn't create them and shouldn't kill them
+      
+      return result;
+    } catch (error) {
+      console.error('Error connecting to Chrome:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Alias for connectToExistingChrome for MCP ChromeToolHandler compatibility
+   * @param {number} port - Chrome debugging port
+   * @returns {Promise<Object>} Connection result
+   */
+  async connectToExisting(port = 9222) {
+    // Alias for ChromeToolHandler compatibility
+    return this.connectToExistingChrome(port);
+  }
+
+  /**
+   * Force reset Chrome with comprehensive cleanup
+   * @returns {Promise<Object>} Reset result
+   */
+  async forceReset() {
+    try {
+      // First, let the chrome controller handle its cleanup
+      const chromeResult = await this.chromeController.forceReset();
+      
+      // Then use process manager to clean up any remaining processes
+      const processResult = await this.processManager.cleanupChromePilotProcesses();
+      
+      return {
+        chromeController: chromeResult,
+        processCleanup: processResult,
+        httpServer: this.httpServerPort ? {
+          port: this.httpServerPort,
+          running: !!this.httpServer
+        } : null
+      };
+    } catch (error) {
+      console.error('Error during force reset:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Gets comprehensive connection status
+   * @returns {Promise<Object>} Status information
+   */
+  async getStatus() {
+    const chromeStatus = await this.chromeController.getConnectionStatus();
+    const processStats = this.processManager.getStatistics();
+    const httpInfo = this.getHttpServerInfo();
+    
+    return {
+      chrome: chromeStatus,
+      httpServer: httpInfo,
+      processManager: processStats,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Cleans up all managed resources
+   * @returns {Promise<void>}
+   */
+  async cleanup() {
+    try {
+      // Stop HTTP server if running
+      if (this.httpServer) {
+        this.httpServer.close();
+        this.httpServer = null;
+        this.httpServerPort = null;
+      }
+      
+      // Clean up Chrome controller
+      if (this.chromeController && typeof this.chromeController.cleanup === 'function') {
+        await this.chromeController.cleanup();
+      }
+      
+      console.error('Chrome service cleanup completed');
+    } catch (error) {
+      console.error('Error during Chrome service cleanup:', error);
+    }
+  }
+
+  // MCP Tool Interface Compatibility Methods
+  // These proxy methods provide the expected interface for MCP tools
+  
+  /**
+   * Launch Chrome - proxy to launchChrome for MCP compatibility
+   * @param {Object} options - Launch options
+   * @returns {Promise<Object>} Launch result
+   */
+  async launch(options = {}) {
+    return this.launchChrome(options);
+  }
+
+  /**
+   * Get connection status - proxy to chromeController for MCP compatibility
+   * @returns {Promise<Object>} Connection status
+   */
+  async getConnectionStatus() {
+    return await this.chromeController.getConnectionStatus();
+  }
+
+  /**
+   * Delegates method calls to the Chrome controller
+   * This allows the service to act as a proxy while adding process management
+   */
+  
+  // Navigation methods
+  async navigateTo(url) {
+    return await this.chromeController.navigateTo(url);
+  }
+
+  // Debug methods
+  async pause() {
+    return await this.chromeController.pause();
+  }
+
+  async resume() {
+    return await this.chromeController.resume();
+  }
+
+  async stepOver() {
+    return await this.chromeController.stepOver();
+  }
+
+  async evaluate(expression) {
+    return await this.chromeController.evaluate(expression);
+  }
+
+  async getScopes() {
+    return await this.chromeController.getScopes();
+  }
+
+  async setBreakpoint(url, lineNumber) {
+    return await this.chromeController.setBreakpoint(url, lineNumber);
+  }
+
+  // Content methods
+  async takeScreenshot(options) {
+    return await this.chromeController.takeScreenshot(options);
+  }
+
+  async getPageContent(options) {
+    return await this.chromeController.getPageContent(options);
+  }
+
+  // Element methods
+  async getSelectedElement() {
+    return await this.chromeController.getSelectedElement();
+  }
+
+  async applyToSelectedElement(css) {
+    return await this.chromeController.applyToSelectedElement(css);
+  }
+
+  async executeOnSelectedElement(code) {
+    return await this.chromeController.executeOnSelectedElement(code);
+  }
+
+  async clearSelectedElement() {
+    return await this.chromeController.clearSelectedElement();
+  }
+
+  // Workflow methods
+  async getWorkflowRecording(sessionId) {
+    return await this.chromeController.getWorkflowRecording(sessionId);
+  }
+
+  async listWorkflowRecordings() {
+    return await this.chromeController.listWorkflowRecordings();
+  }
+
+  async saveRestorePoint(data) {
+    return await this.chromeController.saveRestorePoint(data);
+  }
+
+  async getRestorePoint(id) {
+    return await this.chromeController.getRestorePoint(id);
+  }
+
+  async listRestorePoints(workflowId) {
+    return await this.chromeController.listRestorePoints(workflowId);
+  }
+
+  async playWorkflowRecording(sessionId, speed) {
+    return await this.chromeController.playWorkflowRecording(sessionId, speed);
+  }
+
+  async playWorkflowByName(name, speed) {
+    return await this.chromeController.playWorkflowByName(name, speed);
+  }
+
+  // Frame methods
+  async getFrameSessionInfo(sessionId) {
+    return await this.chromeController.getFrameSessionInfo(sessionId);
+  }
+
+  async listFrameSessions() {
+    return await this.chromeController.listFrameSessions();
+  }
+
+  async getFrame(sessionId, frameIndex) {
+    return await this.chromeController.getFrame(sessionId, frameIndex);
+  }
+
+  async searchFrameLogs(sessionId, searchText, logLevel, maxResults) {
+    return await this.chromeController.searchFrameLogs(sessionId, searchText, logLevel, maxResults);
+  }
+
+  async getFrameLogsPaginated(sessionId, frameIndex, offset, limit, logLevel, searchText) {
+    return await this.chromeController.getFrameLogsPaginated(sessionId, frameIndex, offset, limit, logLevel, searchText);
+  }
+
+  async getScreenInteractions(sessionId) {
+    return await this.chromeController.getScreenInteractions(sessionId);
+  }
+
+  async getFrameInteractions(sessionId, frameIndex) {
+    return await this.chromeController.getFrameInteractions(sessionId, frameIndex);
+  }
+
+  // Utility methods
+  getLogs() {
+    return this.chromeController.getLogs();
+  }
+
+  async getPage() {
+    return await this.chromeController.getPage();
+  }
+}