@dynamicu/chromedebug-mcp 2.2.0

package/src/chrome-controller.js

@@ -0,0 +1,2658 @@
+import puppeteer from 'puppeteer';
+import { findAvailablePort } from './utils.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { SessionManager } from './services/session-manager.js';
+import { BrowserDaemon } from './services/browser-daemon.js';
+import { FailoverManager } from './services/failover-manager.js';
+import { getExtensionPath } from './utils/extension-path.js';
+
+export class ChromeController {
+  constructor() {
+    this.browser = null;
+    this.page = null;
+    this.client = null;
+    this.paused = false;
+    this.logs = [];
+    this.debugPort = null;
+    this.defaultTimeout = 10000;
+    this.selectedElement = null;
+    this.processId = null; // Track our Chrome process
+    this.userDataDir = null; // Track user data directory for cleanup
+
+    // Tab Registry - ROBUST TAB TRACKING
+    this.tabRegistry = new Map(); // targetId -> { page, title, url, sessionId, createdAt }
+    this.activeTargetId = null;   // Currently active tab Target ID
+    this.targetEventListenersSetup = false; // Track if event listeners are initialized
+
+    // Session management - NEW for Phase 1
+    this.sessionManager = new SessionManager();
+    this.sessionId = this.sessionManager.sessionId;
+
+    // Shared browser management - Phase 2 Enhanced Security
+    this.sharedBrowserConnection = null;
+    this.sharedSessionData = null;
+    this.failoverManager = new FailoverManager();
+    this.usingSharedBrowser = false;
+    this.claudeInstanceId = `claude-${this.sessionId}`;
+
+    // Auto-start daemon tracking - Phase 2 Enhanced Security
+    this.sharedDaemon = null; // Auto-started daemon instance
+    this.isDaemonOwner = false; // Whether this controller started the daemon
+
+    // Class-level lock to prevent race conditions
+    if (!ChromeController.daemonStartPromise) {
+      ChromeController.daemonStartPromise = null;
+    }
+
+    // Initialize database
+    this.initDatabase();
+  }
+  
+  async initDatabase() {
+    const { database } = await import('./database.js');
+    this.database = database;
+    this.database.init();
+  }
+
+  withTimeout(promise, timeoutMs = this.defaultTimeout, operation = 'operation') {
+    return Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      })
+    ]);
+  }
+
+  /**
+   * Tab Registry Management Methods - ROBUST TAB TRACKING
+   */
+
+  /**
+   * Registers a new tab in the registry with Target ID-based tracking
+   */
+  async registerTab(page, targetId = null) {
+    if (!page) return null;
+
+    try {
+      // Get target ID if not provided
+      if (!targetId) {
+        const target = page.target();
+        targetId = target._targetId || target.targetInfo().targetId;
+      }
+
+      // Get page info
+      const url = page.url();
+      const title = await page.title().catch(() => 'Untitled');
+
+      const tabData = {
+        page,
+        title,
+        url,
+        sessionId: this.sessionId,
+        createdAt: new Date().toISOString(),
+        targetId
+      };
+
+      this.tabRegistry.set(targetId, tabData);
+
+      // Set as active tab if it's the first one or no active tab exists
+      if (!this.activeTargetId || this.tabRegistry.size === 1) {
+        this.setActiveTab(targetId);
+      }
+
+      console.log(`[TabRegistry] Registered tab ${targetId} for session ${this.sessionId}`);
+      return tabData;
+    } catch (error) {
+      console.error(`[TabRegistry] Failed to register tab:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Sets the active tab and updates this.page for backward compatibility
+   */
+  setActiveTab(targetId) {
+    const tabData = this.tabRegistry.get(targetId);
+    if (tabData) {
+      this.activeTargetId = targetId;
+      this.page = tabData.page; // Maintain backward compatibility
+      console.log(`[TabRegistry] Active tab set to ${targetId}`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Gets tab data by target ID
+   */
+  getTab(targetId) {
+    return this.tabRegistry.get(targetId);
+  }
+
+  /**
+   * Gets the currently active tab data
+   */
+  getActiveTab() {
+    if (this.activeTargetId) {
+      return this.tabRegistry.get(this.activeTargetId);
+    }
+    return null;
+  }
+
+  /**
+   * Lists all tabs in the registry for this session
+   */
+  listTabs() {
+    return Array.from(this.tabRegistry.values()).filter(tab => tab.sessionId === this.sessionId);
+  }
+
+  /**
+   * Removes a tab from the registry
+   */
+  unregisterTab(targetId) {
+    const wasActive = this.activeTargetId === targetId;
+    const removed = this.tabRegistry.delete(targetId);
+
+    if (removed) {
+      console.log(`[TabRegistry] Unregistered tab ${targetId}`);
+
+      // If this was the active tab, select a new active tab
+      if (wasActive) {
+        const availableTabs = Array.from(this.tabRegistry.keys());
+        if (availableTabs.length > 0) {
+          this.setActiveTab(availableTabs[0]);
+        } else {
+          this.activeTargetId = null;
+          this.page = null;
+        }
+      }
+    }
+
+    return removed;
+  }
+
+  /**
+   * Clears all tabs from the registry
+   */
+  clearTabRegistry() {
+    this.tabRegistry.clear();
+    this.activeTargetId = null;
+    this.page = null;
+    console.log(`[TabRegistry] Cleared all tabs for session ${this.sessionId}`);
+  }
+
+  /**
+   * Sets up Target API event listeners for robust tab tracking
+   */
+  async setupTargetEventListeners() {
+    if (!this.browser || this.targetEventListenersSetup) {
+      return;
+    }
+
+    try {
+      // Create a browser-level CDP session for Target events
+      const browserTarget = this.browser.target();
+      const browserClient = await browserTarget.createCDPSession();
+
+      // Enable Target domain to receive events
+      await browserClient.send('Target.setDiscoverTargets', { discover: true });
+
+      // Listen for tab creation
+      browserClient.on('Target.targetCreated', async (params) => {
+        const { targetInfo } = params;
+
+        // Only handle page targets (tabs)
+        if (targetInfo.type === 'page') {
+          try {
+            console.log(`[TargetEvents] New tab created: ${targetInfo.targetId}`);
+
+            // Wait a bit for the page to be ready
+            setTimeout(async () => {
+              try {
+                const pages = await this.browser.pages();
+                const newPage = pages.find(p => {
+                  const target = p.target();
+                  const id = target._targetId || target.targetInfo().targetId;
+                  return id === targetInfo.targetId;
+                });
+
+                if (newPage) {
+                  await this.registerTab(newPage, targetInfo.targetId);
+                }
+              } catch (error) {
+                console.error(`[TargetEvents] Error registering new tab:`, error);
+              }
+            }, 100);
+          } catch (error) {
+            console.error(`[TargetEvents] Error handling target creation:`, error);
+          }
+        }
+      });
+
+      // Listen for tab destruction
+      browserClient.on('Target.targetDestroyed', (params) => {
+        const { targetId } = params;
+        console.log(`[TargetEvents] Tab destroyed: ${targetId}`);
+        this.unregisterTab(targetId);
+      });
+
+      // Listen for tab info changes (URL, title changes)
+      browserClient.on('Target.targetInfoChanged', (params) => {
+        const { targetInfo } = params;
+
+        if (targetInfo.type === 'page') {
+          const tabData = this.tabRegistry.get(targetInfo.targetId);
+          if (tabData) {
+            tabData.url = targetInfo.url;
+            tabData.title = targetInfo.title || 'Untitled';
+            console.log(`[TargetEvents] Tab info updated: ${targetInfo.targetId} - ${targetInfo.title}`);
+          }
+        }
+      });
+
+      this.targetEventListenersSetup = true;
+      console.log(`[TabRegistry] Target event listeners setup complete for session ${this.sessionId}`);
+    } catch (error) {
+      console.error(`[TabRegistry] Failed to setup target event listeners:`, error);
+    }
+  }
+
+  /**
+   * Initializes tab registry with existing tabs
+   */
+  async initializeTabRegistry() {
+    if (!this.browser) {
+      console.warn(`[TabRegistry] Cannot initialize - no browser connection`);
+      return;
+    }
+
+    try {
+      const pages = await this.browser.pages();
+      console.log(`[TabRegistry] Initializing with ${pages.length} existing tabs`);
+
+      for (const page of pages) {
+        await this.registerTab(page);
+      }
+
+      // Set up event listeners after registry initialization
+      await this.setupTargetEventListeners();
+
+      console.log(`[TabRegistry] Initialization complete - ${this.tabRegistry.size} tabs registered`);
+    } catch (error) {
+      console.error(`[TabRegistry] Failed to initialize tab registry:`, error);
+    }
+  }
+
+  /**
+   * Ensures the current page reference is valid and updates from registry if needed
+   */
+  async ensureValidPageReference() {
+    // If this.page exists and is still valid, use it
+    if (this.page && !this.page.isClosed()) {
+      return this.page;
+    }
+
+    // Try to get the active tab from registry
+    const activeTab = this.getActiveTab();
+    if (activeTab && activeTab.page && !activeTab.page.isClosed()) {
+      this.page = activeTab.page;
+      return this.page;
+    }
+
+    // Get the first available tab from our session
+    const sessionTabs = this.listTabs();
+    for (const tab of sessionTabs) {
+      if (tab.page && !tab.page.isClosed()) {
+        this.setActiveTab(tab.targetId);
+        return this.page;
+      }
+    }
+
+    // If no valid tabs in our session, get any available page
+    if (this.browser) {
+      try {
+        const pages = await this.browser.pages();
+        for (const page of pages) {
+          if (!page.isClosed()) {
+            await this.registerTab(page);
+            return this.page;
+          }
+        }
+      } catch (error) {
+        console.error(`[TabRegistry] Error finding valid page:`, error);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Session Isolation Methods - ENHANCED SECURITY
+   */
+
+  /**
+   * Gets all tabs from the registry (including other sessions)
+   */
+  getAllTabs() {
+    return Array.from(this.tabRegistry.values());
+  }
+
+  /**
+   * Gets tabs count by session ID
+   */
+  getTabCountBySession() {
+    const sessionCounts = {};
+    for (const tab of this.tabRegistry.values()) {
+      sessionCounts[tab.sessionId] = (sessionCounts[tab.sessionId] || 0) + 1;
+    }
+    return sessionCounts;
+  }
+
+  /**
+   * Finds tabs created by other Claude instances (different sessionIds)
+   */
+  getOtherInstanceTabs() {
+    return Array.from(this.tabRegistry.values()).filter(tab => tab.sessionId !== this.sessionId);
+  }
+
+  /**
+   * Safely switches to a tab from another session (if allowed)
+   */
+  async switchToTab(targetId, options = {}) {
+    const tabData = this.tabRegistry.get(targetId);
+    if (!tabData) {
+      throw new Error(`Tab not found: ${targetId}`);
+    }
+
+    // Check if this is a cross-session switch
+    if (tabData.sessionId !== this.sessionId) {
+      if (!options.allowCrossSession) {
+        throw new Error(`Cross-session tab access denied. Tab belongs to session ${tabData.sessionId}, current session is ${this.sessionId}`);
+      }
+      console.warn(`[TabRegistry] Cross-session tab switch: ${tabData.sessionId} → ${this.sessionId}`);
+    }
+
+    // Verify the page is still valid
+    if (tabData.page.isClosed()) {
+      this.unregisterTab(targetId);
+      throw new Error(`Target tab is closed: ${targetId}`);
+    }
+
+    // Switch to the tab
+    const success = this.setActiveTab(targetId);
+    if (success) {
+      console.log(`[TabRegistry] Switched to tab ${targetId} (Session: ${tabData.sessionId})`);
+      return {
+        success: true,
+        targetId,
+        sessionId: tabData.sessionId,
+        url: tabData.url,
+        title: tabData.title
+      };
+    }
+
+    throw new Error(`Failed to switch to tab: ${targetId}`);
+  }
+
+  /**
+   * Creates a new tab and registers it for this session
+   */
+  async createNewTab(url = null) {
+    if (!this.browser) {
+      throw new Error('Browser not connected');
+    }
+
+    try {
+      const newPage = await this.browser.newPage();
+
+      if (url) {
+        await newPage.goto(url, { waitUntil: 'domcontentloaded' });
+      }
+
+      const tabData = await this.registerTab(newPage);
+
+      if (tabData) {
+        console.log(`[TabRegistry] Created new tab ${tabData.targetId} for session ${this.sessionId}`);
+        return {
+          success: true,
+          targetId: tabData.targetId,
+          url: tabData.url,
+          title: tabData.title
+        };
+      }
+
+      throw new Error('Failed to register new tab');
+    } catch (error) {
+      console.error(`[TabRegistry] Error creating new tab:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Safely kills our own Chrome process using Node.js native process.kill()
+   * This prevents command injection by validating PID and using native APIs
+   */
+  async killOwnChromeProcess() {
+    try {
+      if (this.processId) {
+        // Security: Validate that processId is a valid number and contains no suspicious characters
+        const pidStr = String(this.processId).trim();
+        if (!/^\d+$/.test(pidStr)) {
+          console.error('Invalid or suspicious process ID for Chrome process:', this.processId);
+          this.processId = null;
+          return;
+        }
+        
+        const pid = parseInt(pidStr, 10);
+        if (isNaN(pid) || pid <= 0 || pid > 4194304) {
+          console.error('Invalid process ID for Chrome process:', this.processId);
+          this.processId = null;
+          return;
+        }
+        
+        // Security: Use Node.js native process.kill() instead of shell commands
+        // This prevents command injection attacks
+        try {
+          // First try graceful termination
+          process.kill(pid, 'SIGTERM');
+          
+          // Wait a bit for graceful shutdown
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          
+          // Check if process still exists, if so force kill
+          try {
+            process.kill(pid, 0); // Signal 0 checks if process exists
+            // Process still exists, force kill
+            process.kill(pid, 'SIGKILL');
+          } catch (e) {
+            // Process doesn't exist anymore (ESRCH), good
+            if (e.code !== 'ESRCH') {
+              throw e;
+            }
+          }
+        } catch (error) {
+          if (error.code === 'ESRCH') {
+            // Process already dead, ignore
+          } else if (error.code === 'EPERM') {
+            console.error('Permission denied killing Chrome process:', pid);
+          } else {
+            throw error;
+          }
+        }
+        
+        this.processId = null;
+      }
+    } catch (error) {
+      console.error('Error killing Chrome process:', error.message);
+    }
+  }
+
+  /**
+   * Safely validates and cleans up a directory path
+   * Prevents directory traversal attacks and validates paths
+   */
+  async safeCleanupDirectory(dirPath) {
+    if (!dirPath || typeof dirPath !== 'string') {
+      throw new Error('Invalid directory path provided');
+    }
+    
+    // Security: Validate that the directory path is within expected locations
+    const tmpDir = os.tmpdir();
+    const resolvedPath = path.resolve(dirPath);
+    const resolvedTmpDir = path.resolve(tmpDir);
+    
+    // Ensure the path is within the temp directory and contains chromedebug prefix
+    if (!resolvedPath.startsWith(resolvedTmpDir) || !path.basename(resolvedPath).startsWith('chromedebug-')) {
+      throw new Error(`Security: Refusing to clean up directory outside temp or without chromedebug prefix: ${dirPath}`);
+    }
+    
+    try {
+      // Use Node.js fs.rm() instead of shell commands to prevent injection
+      await fs.rm(resolvedPath, { recursive: true, force: true });
+      console.error(`Cleaned up directory: ${resolvedPath}`);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // Directory doesn't exist, ignore
+        return;
+      }
+      throw error;
+    }
+  }
+
+  async cleanupStaleProfiles() {
+    try {
+      const tmpDir = os.tmpdir();
+      const entries = await fs.readdir(tmpDir);
+      
+      const chromePilotDirs = entries.filter(entry => entry.startsWith('chromedebug-'));
+      
+      for (const dir of chromePilotDirs) {
+        try {
+          // Parse PID from directory name
+          const parts = dir.split('-');
+          if (parts.length >= 3) {
+            const pid = parseInt(parts[2], 10);
+            
+            if (!isNaN(pid)) {
+              // Check if process is still alive
+              try {
+                process.kill(pid, 0);
+                // Process exists, skip this directory
+                console.error(`Skipping active ChromeDebug MCP directory: ${dir} (PID ${pid} is still running)`);
+              } catch (e) {
+                if (e.code === 'ESRCH') {
+                  // Process doesn't exist, safe to clean up
+                  const dirPath = path.join(tmpDir, dir);
+                  console.error(`Cleaning up stale ChromeDebug MCP directory: ${dir} (PID ${pid} no longer exists)`);
+                  await fs.rm(dirPath, { recursive: true, force: true });
+                }
+              }
+            }
+          }
+        } catch (error) {
+          console.error(`Error processing directory ${dir}:`, error.message);
+        }
+      }
+    } catch (error) {
+      console.error('Error during stale profile cleanup:', error.message);
+    }
+  }
+
+  async launch() {
+    // Clean up any stale profiles from previous runs using SessionManager
+    await this.sessionManager.cleanupStaleSessions();
+
+    let sessionData = null;
+
+    try {
+      // Close any existing browser
+      if (this.browser) {
+        await this.close();
+      }
+
+      // Initialize failover manager
+      await this.failoverManager.initialize();
+
+      // Phase 2: Try connecting to shared browser daemon first
+      try {
+        const sharedResult = await this.connectToSharedBrowser();
+        if (sharedResult.success) {
+          return sharedResult;
+        }
+      } catch (error) {
+        console.warn('[ChromeController] Shared browser unavailable, falling back to individual browser:', error.message);
+      }
+
+      // Fallback to individual browser launch
+      return await this.launchIndividualBrowser();
+    } catch (error) {
+      // Clean up session if launch failed
+      if (sessionData) {
+        try {
+          await this.sessionManager.forceCleanupSession(sessionData.sessionId);
+          console.error(`Cleaned up session after launch failure: ${sessionData.sessionId}`);
+        } catch (cleanupError) {
+          console.error(`Failed to clean up session: ${sessionData.sessionId}`, cleanupError.message);
+        }
+      }
+
+      // Reset state
+      this.browser = null;
+      this.page = null;
+      this.client = null;
+      this.processId = null;
+      this.userDataDir = null;
+
+      throw new Error(`Failed to launch Chrome: ${error.message}`);
+    }
+  }
+
+  /**
+   * Attempts to connect to a shared browser daemon
+   * @returns {Promise<Object>} Connection result
+   */
+  async connectToSharedBrowser() {
+    console.log('[ChromeController] Attempting to connect to shared browser daemon...');
+
+    // Check if we should use fallback based on failover manager
+    const shouldUseFallback = await this.failoverManager.shouldUseFallback('connect');
+    if (shouldUseFallback) {
+      // Instead of immediately failing, try to auto-start a daemon if none exists
+      console.log('[ChromeController] Failover manager recommends fallback, but checking for auto-start opportunity...');
+    }
+
+    // Try to find a running daemon by checking common ports
+    const daemonPorts = [9222, 9223, 9224, 9225];
+    let daemon = null;
+    let daemonPort = null;
+
+    for (const port of daemonPorts) {
+      try {
+        // Simple check if something is listening on the port using Node.js http
+        const http = await import('http');
+        const checkPort = () => new Promise((resolve, reject) => {
+          const req = http.request({
+            hostname: 'localhost',
+            port: port,
+            path: '/json/version',
+            method: 'GET',
+            timeout: 2000
+          }, (res) => {
+            if (res.statusCode === 200) {
+              resolve(true);
+            } else {
+              resolve(false);
+            }
+          });
+
+          req.on('error', () => resolve(false));
+          req.on('timeout', () => resolve(false));
+          req.end();
+        });
+
+        const isListening = await checkPort();
+        if (isListening) {
+          daemonPort = port;
+          console.log(`[ChromeController] Found potential daemon on port ${port}`);
+          break;
+        }
+      } catch (error) {
+        // Port not available, continue
+      }
+    }
+
+    if (!daemonPort) {
+      try {
+        console.log('[ChromeController] No existing daemon found, starting new daemon...');
+        daemonPort = await this.autoStartDaemon();
+      } catch (error) {
+        console.warn('[ChromeController] Daemon auto-start failed, falling back to individual browser:', error.message);
+        // Now honor the failover manager's recommendation if auto-start also failed
+        if (shouldUseFallback) {
+          throw new Error('Failover manager recommends using individual browser after auto-start failed');
+        }
+        return null; // This will trigger individual browser fallback
+      }
+    }
+
+    // Connect to the daemon's browser
+    this.browser = await puppeteer.connect({
+      browserURL: `http://localhost:${daemonPort}`,
+      defaultViewport: null
+    });
+
+    this.debugPort = daemonPort;
+    this.usingSharedBrowser = true;
+
+    // Initialize tab registry with existing tabs + robust tab tracking
+    await this.initializeTabRegistry();
+
+    // Create a new page for this session (isolated context)
+    this.page = await this.browser.newPage();
+
+    // Register the new page in our tab registry
+    await this.registerTab(this.page);
+
+    // Set up CDP session
+    this.client = await this.page.createCDPSession();
+
+    await Promise.all([
+      this.client.send('Debugger.enable'),
+      this.client.send('Runtime.enable'),
+      this.client.send('Console.enable')
+    ]);
+
+    // Set up event listeners
+    this.setupCDPEventListeners();
+
+    // Notify failover manager of successful connection
+    await this.failoverManager.recordSuccessfulCheck(Date.now());
+
+    console.log(`[ChromeController] Successfully connected to shared browser daemon on port ${daemonPort}`);
+
+    return {
+      success: true,
+      message: `Connected to shared browser daemon on port ${daemonPort} (Session: ${this.sessionId})`,
+      browserWSEndpoint: this.browser.wsEndpoint(),
+      debugPort: this.debugPort,
+      sessionId: this.sessionId,
+      connectionType: 'shared-daemon',
+      usingSharedBrowser: true
+    };
+  }
+
+  /**
+   * Launches an individual browser instance (fallback method)
+   * @returns {Promise<Object>} Launch result
+   */
+  async launchIndividualBrowser() {
+    console.log('[ChromeController] Launching individual browser instance...');
+
+    let sessionData = null;
+
+    try {
+      // Create session with UUID-based isolation - CORE SESSION ISOLATION FIX
+      sessionData = await this.sessionManager.createSession();
+
+      // Use session-managed debug port and profile path
+      this.debugPort = sessionData.debugPort;
+      this.userDataDir = sessionData.profilePath;
+      this.sessionId = sessionData.sessionId;
+      
+      console.error(`Launching Chrome with debugging port ${this.debugPort}`);
+      console.error(`User data directory: ${this.userDataDir}`);
+      
+      // Detect Chrome executable path
+      let executablePath;
+      const platform = process.platform;
+      
+      if (platform === 'darwin') {
+        executablePath = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+      } else if (platform === 'win32') {
+        executablePath = 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe';
+        const fs = await import('fs');
+        if (!fs.existsSync(executablePath)) {
+          executablePath = 'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe';
+        }
+      } else {
+        executablePath = '/usr/bin/google-chrome';
+      }
+      
+      console.error(`Using Chrome executable: ${executablePath}`);
+      
+      // Get Chrome extension path with fallback logic
+      const extensionPath = getExtensionPath();
+
+      // Build launch args
+      const launchArgs = [
+        `--remote-debugging-port=${this.debugPort}`,
+        '--no-first-run',
+        '--no-default-browser-check',
+        `--user-data-dir=${this.userDataDir}`
+      ];
+
+      // Add extension flags if extension found
+      if (extensionPath) {
+        launchArgs.push(
+          '--enable-extensions',
+          '--extensions-on-chrome-urls',
+          `--disable-extensions-except=${extensionPath}`,
+          `--load-extension=${extensionPath}`
+        );
+      } else {
+        console.warn('[ChromeController] ChromeDebug extension not found. Visual selection features will be unavailable.');
+      }
+
+      // First, try to launch Chrome with a simpler configuration
+      try {
+        this.browser = await puppeteer.launch({
+          headless: false,
+          executablePath: executablePath,
+          args: launchArgs,
+          defaultViewport: null,
+          ignoreDefaultArgs: ['--disable-extensions', '--disable-default-apps', '--disable-component-extensions-with-background-pages'],
+          timeout: 60000
+        });
+      } catch (launchError) {
+        console.error('Simple launch failed, trying with additional flags...');
+
+        // Build fallback args with more flags
+        const fallbackArgs = [
+          `--remote-debugging-port=${this.debugPort}`,
+          '--no-first-run',
+          '--no-default-browser-check',
+          '--disable-features=VizDisplayCompositor',
+          `--user-data-dir=${this.userDataDir}`,
+          '--disable-setuid-sandbox',
+          '--no-sandbox',
+          '--disable-dev-shm-usage'
+        ];
+
+        // Add extension flags if extension found
+        if (extensionPath) {
+          fallbackArgs.push(
+            '--enable-extensions',
+            '--extensions-on-chrome-urls',
+            `--disable-extensions-except=${extensionPath}`,
+            `--load-extension=${extensionPath}`
+          );
+        }
+
+        // If simple launch fails, try with more flags
+        this.browser = await puppeteer.launch({
+          headless: false,
+          executablePath: executablePath,
+          args: fallbackArgs,
+          defaultViewport: null,
+          ignoreDefaultArgs: ['--disable-extensions', '--disable-default-apps', '--disable-component-extensions-with-background-pages'],
+          timeout: 60000,
+          dumpio: true
+        });
+      }
+      
+      // Store the process ID for cleanup - UPDATE SESSION MANAGER
+      const browserProcess = this.browser.process();
+      this.processId = browserProcess ? browserProcess.pid : null;
+      
+      // Update SessionManager with Chrome process ID
+      if (this.processId) {
+        this.sessionManager.setProcessId(this.processId);
+      }
+      
+      // Set up disconnect handler
+      this.browser.on('disconnected', () => {
+        console.error('Browser disconnected');
+        this.browser = null;
+        this.page = null;
+        this.client = null;
+        this.processId = null;
+        this.clearTabRegistry(); // Clear registry on disconnect
+      });
+
+      // Initialize tab registry with existing tabs + robust tab tracking
+      await this.initializeTabRegistry();
+
+      // Get or create a page
+      const pages = await this.withTimeout(
+        this.browser.pages(),
+        this.defaultTimeout,
+        'get browser pages'
+      );
+      this.page = pages[0] || await this.withTimeout(
+        this.browser.newPage(),
+        this.defaultTimeout,
+        'create new page'
+      );
+
+      // Register the current page in our tab registry if not already registered
+      if (this.page) {
+        const target = this.page.target();
+        const targetId = target._targetId || target.targetInfo().targetId;
+        if (!this.tabRegistry.has(targetId)) {
+          await this.registerTab(this.page, targetId);
+        }
+      }
+      
+      // Set up CDP session
+      this.client = await this.withTimeout(
+        this.page.createCDPSession(),
+        this.defaultTimeout,
+        'create CDP session'
+      );
+      
+      await this.withTimeout(
+        Promise.all([
+          this.client.send('Debugger.enable'),
+          this.client.send('Runtime.enable'),
+          this.client.send('Console.enable')
+        ]),
+        this.defaultTimeout,
+        'enable CDP domains'
+      );
+
+      // Set up event listeners
+      this.setupCDPEventListeners();
+      
+      // Get the WebSocket endpoint for future connections
+      const wsEndpoint = this.browser.wsEndpoint();
+      console.error(`Chrome WebSocket endpoint: ${wsEndpoint}`);
+      
+      return {
+        success: true,
+        message: `Chrome launched successfully on port ${this.debugPort} (Session: ${this.sessionId})`,
+        browserWSEndpoint: wsEndpoint,
+        debugPort: this.debugPort,
+        processId: this.processId || 'unknown',
+        sessionId: this.sessionId,
+        profilePath: this.userDataDir,
+        connectionType: 'individual-browser',
+        usingSharedBrowser: false
+      };
+    } catch (error) {
+      // Clean up session if launch failed
+      if (sessionData) {
+        try {
+          await this.sessionManager.forceCleanupSession(sessionData.sessionId);
+          console.error(`Cleaned up session after launch failure: ${sessionData.sessionId}`);
+        } catch (cleanupError) {
+          console.error(`Failed to clean up session: ${sessionData.sessionId}`, cleanupError.message);
+        }
+      }
+      
+      // Reset state
+      this.browser = null;
+      this.page = null;
+      this.client = null;
+      this.processId = null;
+      this.userDataDir = null;
+      
+      throw new Error(`Failed to launch Chrome: ${error.message}`);
+    }
+  }
+
+  /**
+   * Sets up Chrome DevTools Protocol event listeners
+   */
+  setupCDPEventListeners() {
+    if (!this.client) return;
+
+    this.client.on('Debugger.paused', () => {
+      this.paused = true;
+    });
+
+    this.client.on('Debugger.resumed', () => {
+      this.paused = false;
+    });
+
+    this.client.on('Console.messageAdded', (params) => {
+      this.logs.push({
+        level: params.message.level,
+        text: params.message.text,
+        timestamp: new Date().toISOString()
+      });
+      if (this.logs.length > 100) {
+        this.logs.shift();
+      }
+    });
+  }
+
+  /**
+   * Auto-starts a shared browser daemon with race condition protection
+   * @returns {Promise<number>} The port the daemon is running on
+   */
+  async autoStartDaemon() {
+    // Prevent concurrent daemon starts using class-level lock
+    if (ChromeController.daemonStartPromise) {
+      console.log('[ChromeController] Daemon start already in progress, waiting...');
+      return await ChromeController.daemonStartPromise;
+    }
+
+    ChromeController.daemonStartPromise = this._doStartDaemon();
+    try {
+      const port = await ChromeController.daemonStartPromise;
+      return port;
+    } finally {
+      ChromeController.daemonStartPromise = null;
+    }
+  }
+
+  /**
+   * Internal method to actually start the daemon
+   * @returns {Promise<number>} The port the daemon is running on
+   */
+  async _doStartDaemon() {
+    try {
+      const { BrowserDaemon } = await import('./services/browser-daemon.js');
+      this.sharedDaemon = new BrowserDaemon();
+
+      // Start daemon (it will find its own available port starting from 9222)
+      await this.sharedDaemon.start();
+      this.isDaemonOwner = true;
+
+      const daemonPort = this.sharedDaemon.config.daemonPort;
+      console.log(`[ChromeController] Started shared browser daemon on port ${daemonPort}`);
+
+      // Set up cleanup handlers for this specific daemon owner
+      this.setupDaemonCleanup();
+
+      return daemonPort;
+    } catch (error) {
+      console.error('[ChromeController] Failed to start daemon:', error.message);
+      this.sharedDaemon = null;
+      this.isDaemonOwner = false;
+      throw new Error(`Could not start shared browser daemon: ${error.message}`);
+    }
+  }
+
+  /**
+   * Sets up cleanup handlers for auto-started daemon
+   */
+  setupDaemonCleanup() {
+    if (!this.isDaemonOwner) return;
+
+    const cleanupHandler = async () => {
+      if (this.isDaemonOwner && this.sharedDaemon) {
+        console.log('[ChromeController] Cleaning up auto-started daemon...');
+        try {
+          await this.sharedDaemon.gracefulShutdown();
+        } catch (error) {
+          console.error('[ChromeController] Error stopping daemon:', error.message);
+        }
+        this.sharedDaemon = null;
+        this.isDaemonOwner = false;
+      }
+    };
+
+    // Register cleanup handlers
+    process.once('exit', cleanupHandler);
+    process.once('SIGINT', cleanupHandler);
+    process.once('SIGTERM', cleanupHandler);
+    process.once('uncaughtException', cleanupHandler);
+  }
+
+  async connectToExisting(port = 9222) {
+    try {
+      if (this.browser) {
+        await this.close();
+      }
+      
+      console.error(`Attempting to connect to Chrome on port ${port}...`);
+      
+      // Try connecting with a timeout
+      this.browser = await this.withTimeout(
+        puppeteer.connect({
+          browserURL: `http://localhost:${port}`,
+          defaultViewport: null
+        }),
+        30000,
+        `connect to Chrome on port ${port}`
+      );
+      
+      this.debugPort = port;
+      console.error(`Successfully connected to existing Chrome on port ${port}`);
+      
+      this.browser.on('disconnected', () => {
+        console.error('Browser disconnected');
+        this.browser = null;
+        this.page = null;
+        this.client = null;
+        this.clearTabRegistry(); // Clear registry on disconnect
+      });
+
+      // Initialize tab registry with existing tabs + robust tab tracking
+      await this.initializeTabRegistry();
+
+      const pages = await this.withTimeout(
+        this.browser.pages(),
+        this.defaultTimeout,
+        'get browser pages'
+      );
+      this.page = pages[0] || await this.withTimeout(
+        this.browser.newPage(),
+        this.defaultTimeout,
+        'create new page'
+      );
+
+      // Register the current page in our tab registry if not already registered
+      if (this.page) {
+        const target = this.page.target();
+        const targetId = target._targetId || target.targetInfo().targetId;
+        if (!this.tabRegistry.has(targetId)) {
+          await this.registerTab(this.page, targetId);
+        }
+      }
+      
+      this.client = await this.withTimeout(
+        this.page.createCDPSession(),
+        this.defaultTimeout,
+        'create CDP session'
+      );
+      
+      await this.withTimeout(
+        Promise.all([
+          this.client.send('Debugger.enable'),
+          this.client.send('Runtime.enable'),
+          this.client.send('Console.enable')
+        ]),
+        this.defaultTimeout,
+        'enable CDP domains'
+      );
+      
+      this.client.on('Debugger.paused', () => {
+        this.paused = true;
+      });
+      
+      this.client.on('Debugger.resumed', () => {
+        this.paused = false;
+      });
+      
+      this.client.on('Console.messageAdded', (params) => {
+        this.logs.push({
+          level: params.message.level,
+          text: params.message.text,
+          timestamp: new Date().toISOString()
+        });
+        if (this.logs.length > 100) {
+          this.logs.shift();
+        }
+      });
+      
+      return {
+        success: true,
+        message: `Connected to existing Chrome instance on port ${port}`,
+        browserWSEndpoint: this.browser.wsEndpoint(),
+        debugPort: this.debugPort
+      };
+    } catch (error) {
+      throw new Error(`Failed to connect to Chrome on port ${port}: ${error.message}`);
+    }
+  }
+
+  async isConnected() {
+    if (!this.browser) return false;
+    try {
+      await this.withTimeout(
+        this.browser.version(),
+        5000,
+        'browser version check'
+      );
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  
+  async getConnectionStatus() {
+    const connected = await this.isConnected();
+    return {
+      connected,
+      debugPort: this.debugPort,
+      browserWSEndpoint: this.browser?.wsEndpoint() || null
+    };
+  }
+
+  async ensureConnected() {
+    if (!await this.isConnected()) {
+      throw new Error('Chrome not connected. Please launch Chrome first using launch_chrome.');
+    }
+  }
+
+  async navigateTo(url) {
+    await this.ensureConnected();
+
+    // Use robust tab tracking to ensure we have a valid page
+    const currentPage = await this.ensureValidPageReference();
+    if (!currentPage) throw new Error('No valid page available');
+
+    try {
+      await this.withTimeout(
+        currentPage.goto(url, { waitUntil: 'domcontentloaded' }),
+        30000,
+        `navigate to ${url}`
+      );
+
+      // Update tab registry with new URL
+      if (this.activeTargetId) {
+        const tabData = this.tabRegistry.get(this.activeTargetId);
+        if (tabData) {
+          tabData.url = url;
+          tabData.title = await currentPage.title().catch(() => 'Loading...');
+        }
+      }
+
+      return { status: 'success', url };
+    } catch (error) {
+      throw new Error(`Failed to navigate to ${url}: ${error.message}`);
+    }
+  }
+
+  async pause() {
+    await this.ensureConnected();
+    if (!this.client) throw new Error('Chrome not connected');
+    await this.withTimeout(
+      this.client.send('Debugger.pause'),
+      this.defaultTimeout,
+      'pause execution'
+    );
+    return { status: 'paused' };
+  }
+
+  async resume() {
+    await this.ensureConnected();
+    if (!this.client) throw new Error('Chrome not connected');
+    await this.withTimeout(
+      this.client.send('Debugger.resume'),
+      this.defaultTimeout,
+      'resume execution'
+    );
+    return { status: 'resumed' };
+  }
+
+  async stepOver() {
+    await this.ensureConnected();
+    if (!this.client) throw new Error('Chrome not connected');
+    await this.withTimeout(
+      this.client.send('Debugger.stepOver'),
+      this.defaultTimeout,
+      'step over'
+    );
+    return { status: 'stepped' };
+  }
+
+  async evaluate(expression) {
+    await this.ensureConnected();
+    if (!this.client) throw new Error('Chrome not connected');
+    
+    try {
+      const result = await this.withTimeout(
+        this.client.send('Runtime.evaluate', {
+          expression: expression,
+          returnByValue: true,
+          generatePreview: true
+        }),
+        this.defaultTimeout,
+        'JavaScript evaluation'
+      );
+      
+      if (result.exceptionDetails) {
+        return {
+          error: true,
+          message: result.exceptionDetails.text || 'Evaluation error',
+          exception: result.exceptionDetails
+        };
+      }
+      
+      return {
+        result: result.result.value,
+        type: result.result.type,
+        className: result.result.className
+      };
+    } catch (error) {
+      return {
+        error: true,
+        message: error.message
+      };
+    }
+  }
+
+  async getScopes() {
+    await this.ensureConnected();
+    if (!this.client) throw new Error('Chrome not connected');
+    
+    try {
+      const { callFrames } = await this.client.send('Debugger.getStackTrace');
+      
+      if (!callFrames || callFrames.length === 0) {
+        return { scopes: [], message: 'No active call frames' };
+      }
+      
+      const topFrame = callFrames[0];
+      const scopes = [];
+      
+      for (const scope of topFrame.scopeChain) {
+        const scopeInfo = {
+          type: scope.type,
+          name: scope.name,
+          variables: {}
+        };
+        
+        if (scope.object && scope.object.objectId) {
+          const { result } = await this.client.send('Runtime.getProperties', {
+            objectId: scope.object.objectId,
+            ownProperties: true
+          });
+          
+          for (const prop of result) {
+            if (prop.value) {
+              scopeInfo.variables[prop.name] = {
+                value: prop.value.value,
+                type: prop.value.type
+              };
+            }
+          }
+        }
+        
+        scopes.push(scopeInfo);
+      }
+      
+      return { scopes };
+    } catch (error) {
+      return {
+        error: true,
+        message: error.message || 'Failed to get scopes'
+      };
+    }
+  }
+
+  async setBreakpoint(url, lineNumber) {
+    await this.ensureConnected();
+    if (!this.client) throw new Error('Chrome not connected');
+    
+    try {
+      const result = await this.withTimeout(
+        this.client.send('Debugger.setBreakpointByUrl', {
+          url: url,
+          lineNumber: lineNumber
+        }),
+        this.defaultTimeout,
+        'set breakpoint'
+      );
+      
+      return {
+        breakpointId: result.breakpointId,
+        locations: result.locations
+      };
+    } catch (error) {
+      return {
+        error: true,
+        message: error.message
+      };
+    }
+  }
+
+  getLogs() {
+    return { logs: this.logs };
+  }
+
+  async takeScreenshot(options = {}) {
+    await this.ensureConnected();
+
+    // Use robust tab tracking to ensure we have a valid page
+    const currentPage = await this.ensureValidPageReference();
+    if (!currentPage) throw new Error('Chrome not connected');
+
+    try {
+      const screenshotOptions = {
+        type: options.type || 'jpeg',
+        fullPage: options.fullPage !== false
+      };
+      
+      // Always use lowRes mode unless explicitly disabled
+      if (options.lowRes !== false) {
+        const viewport = currentPage.viewport();
+
+        if (screenshotOptions.type === 'jpeg' || screenshotOptions.type === 'jpg') {
+          screenshotOptions.quality = options.quality || 30;
+        }
+
+        let originalViewport = null;
+        const targetWidth = 320;
+        const targetHeight = 568;
+
+        if (viewport) {
+          originalViewport = viewport;
+          await currentPage.setViewport({
+            width: targetWidth,
+            height: targetHeight
+          });
+        }
+
+        if (screenshotOptions.fullPage) {
+          await currentPage.evaluate(() => {
+            const maxHeight = 600;
+            document.documentElement.style.maxHeight = `${maxHeight}px`;
+            document.documentElement.style.overflow = 'hidden';
+            document.body.style.maxHeight = `${maxHeight}px`;
+            document.body.style.overflow = 'hidden';
+          });
+
+          screenshotOptions.fullPage = false;
+          screenshotOptions.clip = {
+            x: 0,
+            y: 0,
+            width: targetWidth,
+            height: Math.min(targetHeight, 600)
+          };
+        }
+
+        screenshotOptions.encoding = 'base64';
+        const screenshot = await this.withTimeout(
+          currentPage.screenshot(screenshotOptions),
+          30000,
+          'take screenshot'
+        );
+
+        // Restore page state
+        if (options.fullPage !== false) {
+          await currentPage.evaluate(() => {
+            document.documentElement.style.maxHeight = '';
+            document.documentElement.style.overflow = '';
+            document.body.style.maxHeight = '';
+            document.body.style.overflow = '';
+          });
+        }
+
+        if (originalViewport) {
+          await currentPage.setViewport(originalViewport);
+        }
+        
+        const sizeInBytes = Math.ceil(screenshot.length * 3/4);
+        const sizeInKB = Math.round(sizeInBytes / 1024);
+        
+        if (sizeInKB > 50) {
+          return {
+            error: true,
+            message: `Screenshot too large for AI processing (${sizeInKB}KB). Maximum recommended size is 50KB.`,
+            size: `${sizeInKB}KB`
+          };
+        }
+        
+        return {
+          screenshot: screenshot,
+          size: `${sizeInKB}KB`,
+          type: screenshotOptions.type,
+          fullPage: screenshotOptions.fullPage,
+          lowRes: true,
+          quality: screenshotOptions.quality
+        };
+      }
+      
+      // File save or regular screenshot
+      if (options.path) {
+        screenshotOptions.path = options.path;
+        if (options.quality && (screenshotOptions.type === 'jpeg' || screenshotOptions.type === 'jpg')) {
+          screenshotOptions.quality = options.quality || 80;
+        }
+        
+        await this.withTimeout(
+          currentPage.screenshot(screenshotOptions),
+          30000,
+          'take screenshot'
+        );
+
+        return {
+          saved: true,
+          path: options.path,
+          type: screenshotOptions.type,
+          fullPage: screenshotOptions.fullPage
+        };
+      }
+
+      screenshotOptions.encoding = 'base64';
+      if (options.quality && (screenshotOptions.type === 'jpeg' || screenshotOptions.type === 'jpg')) {
+        screenshotOptions.quality = options.quality || 80;
+      }
+
+      const screenshot = await this.withTimeout(
+        currentPage.screenshot(screenshotOptions),
+        30000,
+        'take screenshot'
+      );
+      
+      const sizeInBytes = Math.ceil(screenshot.length * 3/4);
+      const sizeInKB = Math.round(sizeInBytes / 1024);
+      
+      if (sizeInKB > 100) {
+        return {
+          screenshot: screenshot.substring(0, 1000) + '... [truncated]',
+          size: `${sizeInKB}KB`,
+          type: screenshotOptions.type,
+          fullPage: screenshotOptions.fullPage,
+          truncated: true,
+          message: 'Screenshot too large. Use path parameter to save to file or lowRes: true for AI parsing.'
+        };
+      }
+      
+      return {
+        screenshot: screenshot,
+        size: `${sizeInKB}KB`,
+        type: screenshotOptions.type,
+        fullPage: screenshotOptions.fullPage
+      };
+    } catch (error) {
+      return {
+        error: true,
+        message: error.message
+      };
+    }
+  }
+
+  async getPageContent(options = {}) {
+    await this.ensureConnected();
+
+    // Use robust tab tracking to ensure we have a valid page
+    const currentPage = await this.ensureValidPageReference();
+    if (!currentPage) throw new Error('Chrome not connected');
+
+    try {
+      const includeText = options.includeText !== false;
+      const includeHtml = options.includeHtml === true;
+      const includeStructure = options.includeStructure !== false;
+
+      const result = await this.withTimeout(
+        currentPage.evaluate(() => {
+          const extractTextContent = (element) => {
+            // Skip script and style tags
+            if (element.tagName === 'SCRIPT' || element.tagName === 'STYLE') {
+              return '';
+            }
+            
+            let text = '';
+            for (const node of element.childNodes) {
+              if (node.nodeType === Node.TEXT_NODE) {
+                text += node.textContent.trim() + ' ';
+              } else if (node.nodeType === Node.ELEMENT_NODE) {
+                text += extractTextContent(node) + ' ';
+              }
+            }
+            return text.trim();
+          };
+          
+          const extractStructure = (element, depth = 0, maxDepth = 10) => {
+            if (depth > maxDepth) return null;
+            
+            // Skip script and style tags in structure
+            if (element.tagName === 'SCRIPT' || element.tagName === 'STYLE') {
+              return null;
+            }
+            
+            const structure = {
+              tag: element.tagName.toLowerCase(),
+              attributes: {}
+            };
+            
+            // Include important attributes
+            const importantAttrs = ['id', 'class', 'href', 'src', 'alt', 'title', 'type', 'name', 'value', 'placeholder'];
+            for (const attr of importantAttrs) {
+              if (element.getAttribute(attr)) {
+                structure.attributes[attr] = element.getAttribute(attr);
+              }
+            }
+            
+            // Get text content for leaf nodes or important elements
+            const importantTextElements = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'P', 'A', 'BUTTON', 'LABEL', 'SPAN', 'DIV', 'LI', 'TD', 'TH'];
+            if (importantTextElements.includes(element.tagName) || element.childElementCount === 0) {
+              const text = element.textContent.trim();
+              if (text && text.length > 0) {
+                structure.text = text.length > 200 ? text.substring(0, 200) + '...' : text;
+              }
+            }
+            
+            // Get children
+            if (element.childElementCount > 0) {
+              structure.children = [];
+              for (const child of element.children) {
+                const childStructure = extractStructure(child, depth + 1, maxDepth);
+                if (childStructure) {
+                  structure.children.push(childStructure);
+                }
+              }
+              if (structure.children.length === 0) {
+                delete structure.children;
+              }
+            }
+            
+            return structure;
+          };
+          
+          const pageInfo = {
+            url: window.location.href,
+            title: document.title,
+            meta: {}
+          };
+          
+          // Extract meta tags
+          const metaTags = document.querySelectorAll('meta');
+          metaTags.forEach(meta => {
+            const name = meta.getAttribute('name') || meta.getAttribute('property');
+            const content = meta.getAttribute('content');
+            if (name && content) {
+              pageInfo.meta[name] = content;
+            }
+          });
+          
+          // Extract text content
+          const textContent = extractTextContent(document.body);
+          
+          // Extract HTML
+          const htmlContent = document.documentElement.outerHTML;
+          
+          // Extract structure
+          const structure = extractStructure(document.body);
+          
+          return {
+            pageInfo,
+            textContent,
+            htmlContent,
+            structure,
+            // Additional useful info
+            forms: document.forms.length,
+            images: document.images.length,
+            links: document.links.length,
+            scripts: document.scripts.length
+          };
+        }),
+        30000,
+        'get page content'
+      );
+      
+      // Build response based on options
+      const response = {
+        url: result.pageInfo.url,
+        title: result.pageInfo.title,
+        meta: result.pageInfo.meta,
+        statistics: {
+          forms: result.forms,
+          images: result.images,
+          links: result.links,
+          scripts: result.scripts
+        }
+      };
+      
+      if (includeText) {
+        response.text = result.textContent;
+        response.textLength = result.textContent.length;
+      }
+      
+      if (includeHtml) {
+        response.html = result.htmlContent;
+        response.htmlLength = result.htmlContent.length;
+      }
+      
+      if (includeStructure) {
+        response.structure = result.structure;
+      }
+      
+      return response;
+    } catch (error) {
+      return {
+        error: true,
+        message: error.message
+      };
+    }
+  }
+
+  async forceReset() {
+    console.error('Force resetting Chrome...');
+
+    await this.killOwnChromeProcess();
+
+    // Clear tab registry before other cleanup
+    this.clearTabRegistry();
+
+    // Use SessionManager for force cleanup - PHASE 1 SESSION ISOLATION
+    if (this.sessionManager && this.sessionId) {
+      try {
+        await this.sessionManager.forceCleanupSession(this.sessionId);
+        console.log(`[ChromeController] Force cleanup completed for session ${this.sessionId}`);
+      } catch (error) {
+        console.error('[ChromeController] Error during force cleanup:', error.message);
+      }
+    }
+
+    this.browser = null;
+    this.page = null;
+    this.client = null;
+    this.paused = false;
+    this.logs = [];
+    this.selectedElement = null;
+    this.processId = null;
+    this.userDataDir = null;
+    this.sessionId = null;
+    this.targetEventListenersSetup = false; // Reset event listener state
+
+    return { status: 'reset complete' };
+  }
+
+  async close() {
+    // Clear tab registry first
+    this.clearTabRegistry();
+
+    if (this.browser) {
+      try {
+        await this.browser.close();
+      } catch (e) {
+        console.error('Error closing browser:', e.message);
+      } finally {
+        this.browser = null;
+        this.page = null;
+        this.client = null;
+        this.processId = null;
+      }
+    }
+
+    // Use SessionManager for cleanup - PHASE 1 SESSION ISOLATION
+    if (this.sessionManager) {
+      try {
+        await this.sessionManager.cleanup();
+        console.log(`[ChromeController] Session cleanup completed for ${this.sessionId}`);
+      } catch (error) {
+        console.error('[ChromeController] Error during session cleanup:', error.message);
+      }
+    }
+
+    // Reset session-related state
+    this.userDataDir = null;
+    this.sessionId = null;
+    this.targetEventListenersSetup = false; // Reset event listener state
+  }
+
+  /**
+   * Alias for close() method for backward compatibility with tests
+   */
+  async cleanup() {
+    // Clean up auto-started daemon first
+    if (this.isDaemonOwner && this.sharedDaemon) {
+      console.log('[ChromeController] Cleaning up auto-started daemon during cleanup...');
+      try {
+        await this.sharedDaemon.gracefulShutdown();
+      } catch (error) {
+        console.error('[ChromeController] Error stopping daemon during cleanup:', error.message);
+      }
+      this.sharedDaemon = null;
+      this.isDaemonOwner = false;
+    }
+
+    // Existing cleanup code...
+    return this.close();
+  }
+
+  // Element selection methods
+  async selectElement(selector, instruction) {
+    await this.ensureConnected();
+    if (!this.client) throw new Error('Chrome not connected');
+
+    // Use robust tab tracking to ensure we have a valid page
+    const currentPage = await this.ensureValidPageReference();
+    if (!currentPage) throw new Error('Chrome not connected');
+
+    try {
+      if (!selector || typeof selector !== 'string') {
+        throw new Error('Invalid selector provided');
+      }
+
+      const elementData = await currentPage.evaluate((sel) => {
+        try {
+          const element = document.querySelector(sel);
+          if (!element) {
+            return { error: `Element not found: ${sel}` };
+          }
+
+          // Highlight the selected element
+          element.style.outline = '3px solid #E91E63';
+          element.style.outlineOffset = '2px';
+
+          const computedStyles = window.getComputedStyle(element);
+          const relevantStyles = {};
+          
+          const styleProps = [
+            'width', 'height', 'padding', 'margin', 'backgroundColor', 
+            'color', 'fontSize', 'fontWeight', 'border', 'borderRadius',
+            'display', 'position', 'top', 'left', 'right', 'bottom',
+            'transform', 'opacity', 'boxShadow', 'textAlign'
+          ];
+          
+          styleProps.forEach(prop => {
+            relevantStyles[prop] = computedStyles[prop];
+          });
+
+          return {
+            outerHTML: element.outerHTML,
+            tagName: element.tagName.toLowerCase(),
+            id: element.id,
+            className: element.className,
+            computedStyles: relevantStyles,
+            boundingBox: element.getBoundingClientRect(),
+            textContent: element.textContent.substring(0, 100)
+          };
+        } catch (error) {
+          return { error: error.message };
+        }
+      }, selector);
+
+      if (elementData.error) {
+        throw new Error(elementData.error);
+      }
+
+      this.selectedElement = {
+        selector,
+        instruction: instruction || '',
+        elementData,
+        timestamp: new Date().toISOString()
+      };
+
+      this.logs.push({
+        timestamp: new Date().toISOString(),
+        type: 'element-selected',
+        message: `Selected: ${selector} - ${elementData.tagName}${elementData.id ? '#' + elementData.id : ''}`
+      });
+
+      return {
+        success: true,
+        message: 'Element selected and ready for MCP commands',
+        element: {
+          selector,
+          tagName: elementData.tagName,
+          id: elementData.id,
+          classes: elementData.className,
+          size: `${elementData.boundingBox.width}px × ${elementData.boundingBox.height}px`,
+          instruction: instruction || 'No instruction provided'
+        }
+      };
+    } catch (error) {
+      this.logs.push({
+        timestamp: new Date().toISOString(),
+        type: 'selection-error',
+        message: error.message
+      });
+
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async getSelectedElement() {
+    if (!this.selectedElement) {
+      return {
+        selected: false,
+        message: 'No element currently selected'
+      };
+    }
+
+    return {
+      selected: true,
+      ...this.selectedElement
+    };
+  }
+
+  async applyToSelectedElement(cssRules) {
+    if (!this.selectedElement) {
+      throw new Error('No element currently selected');
+    }
+
+    await this.ensureConnected();
+
+    // Use robust tab tracking to ensure we have a valid page
+    const currentPage = await this.ensureValidPageReference();
+    if (!currentPage) throw new Error('Chrome not connected');
+
+    const { selector } = this.selectedElement;
+
+    try {
+      const injectionResult = await currentPage.evaluate((sel, cssRules) => {
+        try {
+          let styleEl = document.getElementById('chromedebug-styles');
+          if (!styleEl) {
+            styleEl = document.createElement('style');
+            styleEl.id = 'chromedebug-styles';
+            document.head.appendChild(styleEl);
+          }
+          
+          styleEl.innerHTML += `\n/* ChromeDebug MCP - ${new Date().toISOString()} */\n${sel} { ${cssRules} }\n`;
+          
+          return { success: true, message: 'Styles applied successfully' };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      }, selector, cssRules);
+
+      if (!injectionResult.success) {
+        throw new Error(injectionResult.error);
+      }
+
+      this.logs.push({
+        timestamp: new Date().toISOString(),
+        type: 'css-applied',
+        message: `Applied to ${selector}: ${cssRules}`
+      });
+
+      return {
+        success: true,
+        applied: {
+          selector,
+          css: cssRules
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async executeOnSelectedElement(jsCode) {
+    if (!this.selectedElement) {
+      throw new Error('No element currently selected');
+    }
+
+    await this.ensureConnected();
+
+    // Use robust tab tracking to ensure we have a valid page
+    const currentPage = await this.ensureValidPageReference();
+    if (!currentPage) throw new Error('Chrome not connected');
+
+    const { selector } = this.selectedElement;
+    const fixedSelector = this.fixSelector(selector);
+
+    try {
+      const result = await currentPage.evaluate((sel, code) => {
+        try {
+          const element = document.querySelector(sel);
+          if (!element) {
+            throw new Error(`Element not found: ${sel}`);
+          }
+          
+          const fn = new Function('element', code);
+          return { 
+            success: true, 
+            result: fn(element) 
+          };
+        } catch (error) {
+          return { 
+            success: false, 
+            error: error.message 
+          };
+        }
+      }, fixedSelector, jsCode);
+
+      if (!result.success) {
+        throw new Error(result.error);
+      }
+
+      return {
+        success: true,
+        result: result.result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async clearSelectedElement() {
+    if (!this.selectedElement) {
+      return {
+        success: true,
+        message: 'No element was selected'
+      };
+    }
+
+    // Use robust tab tracking to clear element highlight
+    const currentPage = await this.ensureValidPageReference();
+    if (currentPage) {
+      await currentPage.evaluate((sel) => {
+        const element = document.querySelector(sel);
+        if (element) {
+          element.style.outline = '';
+          element.style.outlineOffset = '';
+        }
+      }, this.selectedElement.selector).catch(() => {});
+    }
+
+    this.selectedElement = null;
+
+    return {
+      success: true,
+      message: 'Selected element cleared'
+    };
+  }
+
+  // Workflow recording methods
+  async storeWorkflowRecording(sessionId, url, title, includeLogs, actions, logs, name = null, screenshotSettings = null, functionTraces = null) {
+    try {
+      const { database } = await import('./database.js');
+      
+      // Store the workflow recording
+      const workflowId = database.storeWorkflowRecording(sessionId, url, title, includeLogs, name, screenshotSettings);
+      
+      // Merge function traces into actions if provided
+      let allActions = [...actions];
+      if (functionTraces && functionTraces.length > 0) {
+        console.log(`[ChromeController] Merging ${functionTraces.length} function traces into actions`);
+        // Function traces are already in the correct format from the Chrome extension
+        allActions = [...actions, ...functionTraces];
+        // Sort all actions by timestamp to maintain chronological order
+        allActions.sort((a, b) => a.timestamp - b.timestamp);
+      }
+      
+      // Store actions with proper indexing
+      const indexedActions = allActions.map((action, index) => ({
+        ...action,
+        index: index
+      }));
+      
+      const actionsResult = database.storeWorkflowActions(workflowId, indexedActions);
+      
+      // Store logs if provided
+      if (includeLogs && logs && logs.length > 0) {
+        const logsResult = database.storeWorkflowLogs(workflowId, logs);
+        console.log(`Stored ${logsResult.storedCount} logs for workflow ${sessionId}`);
+      }
+      
+      console.log(`Stored workflow recording ${sessionId} with ${actionsResult.storedCount} actions (including ${functionTraces ? functionTraces.length : 0} function traces)`);
+      
+      return {
+        success: true,
+        sessionId: sessionId,
+        workflowId: workflowId,
+        actionsStored: actionsResult.storedCount,
+        logsStored: (includeLogs && logs) ? logs.length : 0,
+        functionTracesStored: functionTraces ? functionTraces.length : 0
+      };
+    } catch (error) {
+      console.error('Error storing workflow recording:', error);
+      throw error;
+    }
+  }
+
+  async getWorkflowRecording(sessionId) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getWorkflowRecording(sessionId);
+    } catch (error) {
+      console.error('Error retrieving workflow recording:', error);
+      throw error;
+    }
+  }
+
+  async listWorkflowRecordings() {
+    try {
+      const { database } = await import('./database.js');
+      const recordings = database.listWorkflowRecordings();
+      return { recordings };
+    } catch (error) {
+      console.error('Error listing workflow recordings:', error);
+      throw error;
+    }
+  }
+
+  async playWorkflowRecording(sessionId, speed = 1) {
+    try {
+      const { database } = await import('./database.js');
+      const recording = database.getWorkflowRecording(sessionId);
+      
+      if (!recording || recording.error) {
+        throw new Error(`Workflow recording not found: ${sessionId}`);
+      }
+
+      // For now, just return the recording data
+      // In the future, this could actually replay the actions
+      return {
+        success: true,
+        message: `Workflow recording ${sessionId} loaded successfully`,
+        recording: recording
+      };
+    } catch (error) {
+      console.error('Error playing workflow recording:', error);
+      throw error;
+    }
+  }
+
+  async playWorkflowByName(name, speed = 1) {
+    try {
+      const { database } = await import('./database.js');
+      const recordings = database.listWorkflowRecordings();
+      
+      // Find recording by name
+      const recording = recordings.find(r => r.name === name);
+      
+      if (!recording) {
+        throw new Error(`Workflow recording with name "${name}" not found`);
+      }
+
+      // Use the session ID to get the full recording
+      const fullRecording = database.getWorkflowRecording(recording.session_id);
+      
+      if (!fullRecording || fullRecording.error) {
+        throw new Error(`Could not load workflow recording: ${name}`);
+      }
+
+      // For now, just return the recording data
+      // In the future, this could actually replay the actions
+      return {
+        success: true,
+        message: `Workflow recording "${name}" loaded successfully`,
+        recording: fullRecording
+      };
+    } catch (error) {
+      console.error('Error playing workflow by name:', error);
+      throw error;
+    }
+  }
+
+  // Save restore point
+  async saveRestorePoint(restorePointData) {
+    try {
+      const { database } = await import('./database.js');
+      const result = database.storeRestorePoint(
+        restorePointData.workflowId,
+        restorePointData.actionIndex,
+        restorePointData
+      );
+      return result;
+    } catch (error) {
+      console.error('Error saving restore point:', error);
+      throw error;
+    }
+  }
+
+  // Get restore point
+  async getRestorePoint(restorePointId) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getRestorePoint(restorePointId);
+    } catch (error) {
+      console.error('Error getting restore point:', error);
+      throw error;
+    }
+  }
+
+  // List restore points for a workflow
+  async listRestorePoints(workflowId) {
+    try {
+      const { database } = await import('./database.js');
+      return database.listRestorePoints(workflowId);
+    } catch (error) {
+      console.error('Error listing restore points:', error);
+      throw error;
+    }
+  }
+
+  // Delete restore point
+  async deleteRestorePoint(restorePointId) {
+    try {
+      const { database } = await import('./database.js');
+      database.init();
+      const deleteStmt = database.db.prepare('DELETE FROM restore_points WHERE id = ?');
+      const result = deleteStmt.run(restorePointId);
+      return { success: result.changes > 0 };
+    } catch (error) {
+      console.error('Error deleting restore point:', error);
+      throw error;
+    }
+  }
+
+  // Frame recording methods
+  async getFrameSessionInfo(sessionId) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getFrameSessionInfo(sessionId);
+    } catch (error) {
+      console.error('Error getting frame session info:', error);
+      throw error;
+    }
+  }
+
+  async getFrame(sessionId, frameIndex) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getFrame(sessionId, frameIndex);
+    } catch (error) {
+      console.error('Error getting frame:', error);
+      throw error;
+    }
+  }
+
+  async getFrameScreenshot(sessionId, frameIndex, includeMetadata = false) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getFrameScreenshot(sessionId, frameIndex, includeMetadata);
+    } catch (error) {
+      console.error('Error getting frame screenshot:', error);
+      throw error;
+    }
+  }
+
+  async getScreenInteractions(sessionId) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getScreenInteractions(sessionId);
+    } catch (error) {
+      console.error('Error retrieving screen interactions:', error);
+      throw error;
+    }
+  }
+
+  async getFrameInteractions(sessionId, frameIndex) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getFrameInteractions(sessionId, frameIndex);
+    } catch (error) {
+      console.error('Error retrieving frame interactions:', error);
+      throw error;
+    }
+  }
+
+  async getFrameSession(sessionId) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getFrameSession(sessionId);
+    } catch (error) {
+      console.error('Error getting frame session:', error);
+      throw error;
+    }
+  }
+
+  async storeFrameBatch(sessionId, frames, sessionName = null) {
+    try {
+      const { database } = await import('./database.js');
+      const result = await database.storeFrameBatch(sessionId, frames, sessionName);
+
+      // After storing frames, attempt to associate any deferred logs
+      if (result && result.id) {
+        console.log(`[storeFrameBatch] Frames stored successfully, checking for deferred logs...`);
+        try {
+          const deferredResult = await database.associateDeferredLogs(sessionId);
+          if (deferredResult.success && deferredResult.logsAssociated > 0) {
+            console.log(`[storeFrameBatch] Associated ${deferredResult.logsAssociated} deferred logs with new frames`);
+          }
+        } catch (deferredError) {
+          console.error('[storeFrameBatch] Error associating deferred logs:', deferredError);
+          // Don't fail the frame storage if deferred log association fails
+        }
+      }
+
+      return result;
+    } catch (error) {
+      console.error('Error storing frame batch:', error);
+      throw error;
+    }
+  }
+
+  async associateLogsWithFrames(sessionId, logs) {
+    try {
+      const { database } = await import('./database.js');
+      return database.associateLogsWithFrames(sessionId, logs);
+    } catch (error) {
+      console.error('Error associating logs with frames:', error);
+      throw error;
+    }
+  }
+
+  async streamLogsToFrames(sessionId, logs) {
+    try {
+      const { database } = await import('./database.js');
+      return database.streamLogsToFrames(sessionId, logs);
+    } catch (error) {
+      console.error('Error streaming logs to frames:', error);
+      throw error;
+    }
+  }
+
+  /*
+   * SNAPSHOT FEATURE DISABLED (2025-10-01)
+   *
+   * Snapshot methods disabled - see SNAPSHOT_FEATURE_DISABLED.md
+   *
+   * WHY DISABLED:
+   * - Snapshots without console logs are just screenshots (users can do this natively)
+   * - Console log capture requires always-on monitoring (privacy concern)
+   * - Core value proposition (screenshot + searchable logs) cannot be achieved cleanly
+   *
+   * TO RE-ENABLE:
+   * 1. Implement privacy-conscious always-on log monitoring
+   * 2. Uncomment these methods
+   * 3. Re-enable database methods in database.js
+   * 4. Re-enable HTTP endpoint in http-server.js
+   * 5. Re-enable extension UI and handlers
+   */
+  /*
+  async storeSnapshot(sessionId, frameData, userNote = null) {
+    try {
+      const { database } = await import('./database.js');
+      return database.storeSnapshot(sessionId, frameData, userNote);
+    } catch (error) {
+      console.error('Error storing snapshot:', error);
+      throw error;
+    }
+  }
+
+  async getSnapshots(limit = 50) {
+    try {
+      const { database } = await import('./database.js');
+      return database.getSnapshots(limit);
+    } catch (error) {
+      console.error('Error getting snapshots:', error);
+      throw error;
+    }
+  }
+
+  async takeSnapshot(userNote = null) {
+    try {
+      // Ensure browser is connected
+      if (!this.page) {
+        throw new Error('No active page - please navigate to a URL first');
+      }
+
+      // Take screenshot
+      const screenshot = await this.takeScreenshot(true, true, 30);
+
+      // Get current logs
+      const logs = await this.getLogs();
+
+      // Generate unique session ID for the snapshot
+      const sessionId = `snapshot_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+      // Create frame data structure
+      const frameData = {
+        timestamp: Date.now(),
+        absoluteTimestamp: Date.now(),
+        imageData: screenshot.imageData,
+        logs: logs.logs || [],
+        frameIndex: 0,
+        index: 0
+      };
+
+      // Store snapshot
+      const result = await this.storeSnapshot(sessionId, frameData, userNote);
+
+      return {
+        success: true,
+        sessionId: result,
+        timestamp: frameData.timestamp,
+        userNote: userNote,
+        logCount: frameData.logs.length,
+        message: `Snapshot created successfully with ID: ${result}`
+      };
+    } catch (error) {
+      console.error('Error taking snapshot:', error);
+      throw error;
+    }
+  }
+  */
+
+  async listFrameSessions() {
+    try {
+      const { database } = await import('./database.js');
+      return database.listRecordings();
+    } catch (error) {
+      console.error('Error listing frame sessions:', error);
+      throw error;
+    }
+  }
+
+  async searchFrameLogs(sessionId, searchText, logLevel = 'all', maxResults = 50) {
+    try {
+      const { database } = await import('./database.js');
+      const recording = database.getRecording(sessionId);
+      if (!recording) {
+        throw new Error('Recording not found');
+      }
+
+      const searchLower = searchText.toLowerCase();
+
+      // Build query to search logs across all frames
+      let query = `
+        SELECT 
+          f.frame_index,
+          cl.level,
+          cl.message,
+          f.timestamp
+        FROM console_logs cl
+        JOIN frames f ON cl.frame_id = f.id
+        WHERE f.recording_id = ?
+          AND LOWER(cl.message) LIKE ?
+      `;
+      
+      const params = [recording.id, `%${searchLower}%`];
+
+      if (logLevel !== 'all') {
+        query += ' AND cl.level = ?';
+        params.push(logLevel);
+      }
+
+      query += ' ORDER BY f.frame_index ASC, cl.relative_time ASC LIMIT ?';
+      params.push(maxResults);
+
+      const stmt = database.db.prepare(query);
+      const logs = stmt.all(...params);
+
+      return logs.map(log => ({
+        frameIndex: log.frame_index,
+        level: log.level,
+        message: log.message,
+        timestamp: log.timestamp
+      }));
+    } catch (error) {
+      console.error('Error searching frame logs:', error);
+      throw error;
+    }
+  }
+
+  async getFrameLogsPaginated(sessionId, frameIndex, offset = 0, limit = 100, logLevel = 'all', searchText = null) {
+    try {
+      const { database } = await import('./database.js');
+      const recording = database.getRecording(sessionId);
+      if (!recording) {
+        throw new Error('Recording not found');
+      }
+
+      // Get frame ID
+      const frameStmt = database.db.prepare(`
+        SELECT id FROM frames 
+        WHERE recording_id = ? AND frame_index = ?
+      `);
+      const frame = frameStmt.get(recording.id, frameIndex);
+      
+      if (!frame) {
+        throw new Error('Frame not found');
+      }
+
+      // Build count query
+      let countQuery = 'SELECT COUNT(*) as total FROM console_logs WHERE frame_id = ?';
+      const countParams = [frame.id];
+
+      if (logLevel !== 'all') {
+        countQuery += ' AND level = ?';
+        countParams.push(logLevel);
+      }
+
+      if (searchText) {
+        countQuery += ' AND LOWER(message) LIKE ?';
+        countParams.push(`%${searchText.toLowerCase()}%`);
+      }
+
+      const countStmt = database.db.prepare(countQuery);
+      const { total } = countStmt.get(...countParams);
+
+      // Build logs query
+      let logsQuery = `
+        SELECT level, message, relative_time 
+        FROM console_logs 
+        WHERE frame_id = ?
+      `;
+      const logsParams = [frame.id];
+
+      if (logLevel !== 'all') {
+        logsQuery += ' AND level = ?';
+        logsParams.push(logLevel);
+      }
+
+      if (searchText) {
+        logsQuery += ' AND LOWER(message) LIKE ?';
+        logsParams.push(`%${searchText.toLowerCase()}%`);
+      }
+
+      logsQuery += ' ORDER BY relative_time ASC LIMIT ? OFFSET ?';
+      logsParams.push(limit, offset);
+
+      const logsStmt = database.db.prepare(logsQuery);
+      const logs = logsStmt.all(...logsParams);
+
+      return {
+        total,
+        logs
+      };
+    } catch (error) {
+      console.error('Error getting paginated frame logs:', error);
+      throw error;
+    }
+  }
+
+  async deleteRecording(recordingId) {
+    try {
+      const { database } = await import('./database.js');
+      const result = database.deleteRecording(recordingId);
+      if (result) {
+        return { success: true, message: 'Recording deleted successfully' };
+      } else {
+        return { success: false, error: 'Recording not found' };
+      }
+    } catch (error) {
+      console.error('Error deleting recording:', error);
+      throw error;
+    }
+  }
+
+  async deleteWorkflowRecording(recordingId) {
+    try {
+      const { database } = await import('./database.js');
+      const result = database.deleteWorkflowRecording(recordingId);
+      if (result) {
+        return { success: true, message: 'Workflow recording deleted successfully' };
+      } else {
+        return { success: false, error: 'Workflow recording not found' };
+      }
+    } catch (error) {
+      console.error('Error deleting workflow recording:', error);
+      throw error;
+    }
+  }
+
+  // Helper function to fix CSS selectors by removing pseudo-classes and Tailwind responsive/state prefixes
+  fixSelector(selector) {
+    if (!selector || typeof selector !== 'string') return selector;
+    
+    let fixedSelector = selector;
+    
+    // Remove standard pseudo-classes like :hover, :focus, :active that can't be used in querySelector
+    fixedSelector = fixedSelector.replace(/:(hover|focus|active|visited|focus-within|focus-visible|disabled)/g, '');
+    
+    // Remove Tailwind CSS responsive and state prefixes (e.g., hover:, sm:, md:, lg:, disabled:)
+    fixedSelector = fixedSelector.replace(/\.(hover|focus|active|disabled|sm|md|lg|xl|2xl)\\?:/g, '.');
+    
+    // Handle both escaped and unescaped Tailwind prefixes
+    fixedSelector = fixedSelector.replace(/\.(hover|focus|active|disabled|sm|md|lg|xl|2xl):/g, '.');
+    
+    // Remove any trailing dots
+    fixedSelector = fixedSelector.replace(/\.+$/, '');
+    
+    // Remove empty class selectors (consecutive dots)
+    fixedSelector = fixedSelector.replace(/\.\./g, '.');
+    
+    // Clean up any remaining malformed parts
+    fixedSelector = fixedSelector.replace(/\\:/g, ':'); // Unescape any remaining colons
+    
+    return fixedSelector;
+  }
+
+  async playWorkflow(workflow, actions, speed = 1) {
+    try {
+      // Use robust tab tracking to ensure we have a valid page
+      const currentPage = await this.ensureValidPageReference();
+      if (!currentPage) {
+        throw new Error('No page available. Please navigate to a URL first.');
+      }
+
+      const startTime = Date.now();
+      let executedActions = 0;
+      let lastError = null;
+
+      // Navigate to the initial URL if different from current
+      if (workflow.url) {
+        const currentUrl = currentPage.url();
+        if (currentUrl !== workflow.url) {
+          console.log(`Navigating to workflow URL: ${workflow.url}`);
+          await currentPage.goto(workflow.url, { waitUntil: 'networkidle2' });
+          await new Promise(resolve => setTimeout(resolve, 1000)); // Wait for page to settle
+        }
+      }
+
+      // Execute each action
+      for (const action of actions) {
+        try {
+          console.log(`Executing action ${executedActions + 1}/${actions.length}: ${action.type}`);
+          
+          // Calculate delay based on speed
+          const delay = action.timestamp && actions.indexOf(action) > 0 
+            ? (action.timestamp - actions[actions.indexOf(action) - 1].timestamp) / speed
+            : 500 / speed;
+          
+          // Wait between actions
+          if (delay > 0) {
+            await new Promise(resolve => setTimeout(resolve, Math.min(delay, 5000))); // Cap at 5 seconds
+          }
+
+          switch (action.type) {
+            case 'click':
+              if (action.selector) {
+                const fixedSelector = this.fixSelector(action.selector);
+                console.log(`Fixed selector: ${fixedSelector} (original: ${action.selector})`);
+                
+                try {
+                  await currentPage.waitForSelector(fixedSelector, { timeout: 5000 });
+                  await currentPage.click(fixedSelector);
+                } catch (selectorError) {
+                  console.error(`Failed with CSS selector, trying coordinates fallback`);
+                  if (action.x && action.y) {
+                    await currentPage.mouse.click(action.x, action.y);
+                  } else {
+                    throw selectorError;
+                  }
+                }
+              } else if (action.x && action.y) {
+                await currentPage.mouse.click(action.x, action.y);
+              }
+              break;
+
+            case 'input':
+              if (action.selector) {
+                const fixedSelector = this.fixSelector(action.selector);
+                console.log(`Fixed input selector: ${fixedSelector} (original: ${action.selector})`);
+                
+                await currentPage.waitForSelector(fixedSelector, { timeout: 5000 });
+                await currentPage.click(fixedSelector); // Focus the element
+
+                // Clear existing content
+                await currentPage.evaluate((selector) => {
+                  const element = document.querySelector(selector);
+                  if (element) {
+                    element.value = '';
+                  }
+                }, fixedSelector);
+
+                // Type new value
+                if (action.value) {
+                  await currentPage.type(fixedSelector, action.value);
+                }
+              }
+              break;
+
+            case 'keypress':
+              if (action.key) {
+                await currentPage.keyboard.press(action.key);
+              }
+              break;
+
+            case 'scroll':
+              if (action.deltaY !== undefined) {
+                await currentPage.evaluate((deltaY) => {
+                  window.scrollBy(0, deltaY);
+                }, action.deltaY);
+              }
+              break;
+
+            case 'navigation':
+              // Wait for navigation to complete
+              await currentPage.waitForNavigation({ waitUntil: 'networkidle2', timeout: 10000 }).catch(() => {
+                // Navigation might not happen, continue
+                console.log('Navigation timeout, continuing...');
+              });
+              break;
+
+            default:
+              console.warn(`Unknown action type: ${action.type}`);
+          }
+
+          executedActions++;
+        } catch (error) {
+          console.error(`Error executing action ${executedActions + 1}:`, error);
+          lastError = error.message;
+          // Continue with next action on error
+        }
+      }
+
+      const duration = Date.now() - startTime;
+
+      return {
+        success: executedActions === actions.length && !lastError,
+        executedActions,
+        totalActions: actions.length,
+        duration,
+        error: lastError
+      };
+    } catch (error) {
+      console.error('Error playing workflow:', error);
+      throw error;
+    }
+  }
+}