@dynamicu/chromedebug-mcp 2.6.7 → 2.7.1

package/src/index-monolithic-backup.js

@@ -1,2230 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { 
-  ListToolsRequestSchema,
-  CallToolRequestSchema
-} from '@modelcontextprotocol/sdk/types.js';
-import { ChromeController } from './chrome-controller.js';
-import { discoverServer } from './port-discovery.js';
-import { startHttpServer, startWebSocketServer } from './http-server.js';
-
-// Create a single Chrome controller instance for this MCP server
-const chromeController = new ChromeController();
-
-// Track the HTTP server port for the Chrome extension
-let httpServerPort = null;
-
-const server = new Server(
-  {
-    name: 'chrome-pilot',
-    version: '1.0.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
-
-const tools = [
-  {
-    name: 'launch_chrome',
-    description: 'Launch a Chrome browser instance for this MCP server',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'connect_to_existing_chrome',
-    description: 'Connect to an existing Chrome instance with debugging enabled',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        port: {
-          type: 'number',
-          description: 'Debugging port Chrome is running on (default: 9222)',
-          default: 9222,
-        },
-      },
-    },
-  },
-  {
-    name: 'navigate_to',
-    description: 'Navigate to a URL',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        url: {
-          type: 'string',
-          description: 'URL to navigate to',
-        },
-      },
-      required: ['url'],
-    },
-  },
-  {
-    name: 'pause_execution',
-    description: 'Pause Chrome execution',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'resume_execution',
-    description: 'Resume Chrome execution',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'step_over',
-    description: 'Step over in Chrome debugger',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'evaluate_expression',
-    description: 'Evaluate a JavaScript expression in Chrome',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        expression: {
-          type: 'string',
-          description: 'JavaScript expression to evaluate',
-        },
-      },
-      required: ['expression'],
-    },
-  },
-  {
-    name: 'get_scopes',
-    description: 'Get scope variables from the top call frame',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'set_breakpoint',
-    description: 'Set a breakpoint at a specific URL and line',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        url: {
-          type: 'string',
-          description: 'URL of the script',
-        },
-        lineNumber: {
-          type: 'number',
-          description: 'Line number for the breakpoint',
-        },
-      },
-      required: ['url', 'lineNumber'],
-    },
-  },
-  {
-    name: 'get_logs',
-    description: 'Get recent console logs',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'check_connection',
-    description: 'Check if Chrome is connected',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'force_reset',
-    description: 'Force reset Chrome by killing all processes and clearing state',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'take_screenshot',
-    description: 'Take a screenshot optimized for AI processing',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        type: {
-          type: 'string',
-          description: 'Image type (default: jpeg)',
-          enum: ['png', 'jpeg'],
-        },
-        fullPage: {
-          type: 'boolean',
-          description: 'Capture full page (default: true, but limited to 600px height for AI)',
-        },
-        lowRes: {
-          type: 'boolean',
-          description: 'Low-resolution mode for AI (default: true)',
-        },
-        quality: {
-          type: 'number',
-          description: 'JPEG quality (1-100, default: 30)',
-          minimum: 1,
-          maximum: 100,
-        },
-        path: {
-          type: 'string',
-          description: 'Save screenshot to file path',
-        },
-      },
-    },
-  },
-  {
-    name: 'get_page_content',
-    description: 'Get the content of the current page including text, HTML, and DOM structure. Useful for checking if specific content exists without taking a screenshot.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        includeText: {
-          type: 'boolean',
-          description: 'Include extracted text content (default: true)',
-        },
-        includeHtml: {
-          type: 'boolean',
-          description: 'Include full HTML source (default: false, can be large)',
-        },
-        includeStructure: {
-          type: 'boolean',
-          description: 'Include DOM structure with important elements and attributes (default: true)',
-        },
-      },
-    },
-  },
-  {
-    name: 'get_selected_element',
-    description: 'Get information about the currently selected element from Chrome extension',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'apply_css_to_selected',
-    description: 'Apply CSS styles to the currently selected element',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        css: {
-          type: 'string',
-          description: 'CSS rules to apply',
-        },
-      },
-      required: ['css'],
-    },
-  },
-  {
-    name: 'execute_js_on_selected',
-    description: 'Execute JavaScript code on the currently selected element',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        code: {
-          type: 'string',
-          description: 'JavaScript code to execute. The element is available as the "element" variable.',
-        },
-      },
-      required: ['code'],
-    },
-  },
-  {
-    name: 'clear_selected_element',
-    description: 'Clear the currently selected element',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'get_websocket_info',
-    description: 'Get WebSocket server information for Chrome extension',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'get_workflow_recording',
-    description: 'Get a complete workflow recording including actions and optional logs',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The workflow session ID',
-        },
-      },
-      required: ['sessionId'],
-    },
-  },
-  {
-    name: 'list_workflow_recordings',
-    description: 'List all workflow recordings stored in the database',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'save_restore_point',
-    description: 'Save a restore point for the current browser state including DOM, form values, storage, and cookies',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'The workflow ID this restore point belongs to',
-        },
-        actionIndex: {
-          type: 'number',
-          description: 'The action index in the workflow where this restore point was created',
-        },
-        description: {
-          type: 'string',
-          description: 'Optional description of this restore point',
-        },
-      },
-      required: ['workflowId'],
-    },
-  },
-  {
-    name: 'restore_from_point',
-    description: 'Restore the browser to a previously saved restore point',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        restorePointId: {
-          type: 'string',
-          description: 'The ID of the restore point to restore from',
-        },
-      },
-      required: ['restorePointId'],
-    },
-  },
-  {
-    name: 'list_restore_points',
-    description: 'List all restore points for a workflow',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        workflowId: {
-          type: 'string',
-          description: 'The workflow ID to get restore points for',
-        },
-      },
-      required: ['workflowId'],
-    },
-  },
-  {
-    name: 'chrome_pilot_show_frames',
-    description: 'Display frame recording information in a compact format optimized for MCP tools. Shows frame metadata, console logs, and timestamps without including large image data.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The frame session ID to display',
-        },
-        maxFrames: {
-          type: 'number',
-          description: 'Maximum number of frames to display (default: 10)',
-          default: 10,
-        },
-        showLogs: {
-          type: 'boolean',
-          description: 'Whether to show console logs for each frame (default: true)',
-          default: true,
-        },
-        showInteractions: {
-          type: 'boolean',
-          description: 'Whether to show user interactions for each frame (default: true)',
-          default: true,
-        },
-        logLevel: {
-          type: 'string',
-          description: 'Filter logs by level: error, warn, info, debug, log, or all (default: all)',
-          enum: ['error', 'warn', 'info', 'debug', 'log', 'all'],
-          default: 'all',
-        },
-        maxLogsPerFrame: {
-          type: 'number',
-          description: 'Maximum number of logs to show per frame (default: 10). Use 0 for no limit.',
-          default: 10,
-        },
-      },
-      required: ['sessionId'],
-    },
-  },
-  {
-    name: 'get_frame_session_info',
-    description: 'Get information about a frame capture session including total frames and timestamps',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The frame session ID returned when recording was saved',
-        },
-      },
-      required: ['sessionId'],
-    },
-  },
-  {
-    name: 'get_screen_interactions',
-    description: 'Get all user interactions (clicks, inputs, keypresses, scrolls) recorded during a screen recording session',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The screen recording session ID',
-        },
-      },
-      required: ['sessionId'],
-    },
-  },
-  {
-    name: 'get_frame',
-    description: 'Get a specific frame from a frame capture session',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The frame session ID',
-        },
-        frameIndex: {
-          type: 'number',
-          description: 'The frame index to retrieve (0-based)',
-        },
-        logLevel: {
-          type: 'string',
-          description: 'Filter logs by level: error, warn, info, debug, log, or all (default: all)',
-          enum: ['error', 'warn', 'info', 'debug', 'log', 'all'],
-          default: 'all',
-        },
-        maxLogs: {
-          type: 'number',
-          description: 'Maximum number of logs to show (default: 20). Use 0 for no limit.',
-          default: 20,
-        },
-        searchLogs: {
-          type: 'string',
-          description: 'Search for specific text in log messages (case insensitive)',
-        },
-      },
-      required: ['sessionId', 'frameIndex'],
-    },
-  },
-  {
-    name: 'search_frame_logs',
-    description: 'Search for specific logs across all frames in a recording session',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The frame session ID to search',
-        },
-        searchText: {
-          type: 'string',
-          description: 'Text to search for in log messages (case insensitive)',
-        },
-        logLevel: {
-          type: 'string',
-          description: 'Filter by log level: error, warn, info, debug, log, or all (default: all)',
-          enum: ['error', 'warn', 'info', 'debug', 'log', 'all'],
-          default: 'all',
-        },
-        maxResults: {
-          type: 'number',
-          description: 'Maximum number of matching logs to return (default: 50)',
-          default: 50,
-        },
-      },
-      required: ['sessionId', 'searchText'],
-    },
-  },
-  {
-    name: 'get_frame_logs_paginated',
-    description: 'Get logs for a specific frame with pagination to handle large log volumes',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The frame session ID',
-        },
-        frameIndex: {
-          type: 'number',
-          description: 'The frame index to retrieve logs from (0-based)',
-        },
-        logLevel: {
-          type: 'string',
-          description: 'Filter by log level: error, warn, info, debug, log, or all (default: all)',
-          enum: ['error', 'warn', 'info', 'debug', 'log', 'all'],
-          default: 'all',
-        },
-        offset: {
-          type: 'number',
-          description: 'Number of logs to skip (for pagination, default: 0)',
-          default: 0,
-        },
-        limit: {
-          type: 'number',
-          description: 'Maximum number of logs to return (default: 100)',
-          default: 100,
-        },
-        searchText: {
-          type: 'string',
-          description: 'Search for specific text in log messages (case insensitive)',
-        },
-      },
-      required: ['sessionId', 'frameIndex'],
-    },
-  },
-  {
-    name: 'play_workflow_recording',
-    description: 'Play a workflow recording by executing all recorded actions',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The workflow session ID to play',
-        },
-        speed: {
-          type: 'number',
-          description: 'Playback speed multiplier (1 = normal, 2 = 2x faster, 0.5 = half speed)',
-          default: 1,
-        },
-      },
-      required: ['sessionId'],
-    },
-  },
-  {
-    name: 'play_workflow_by_name',
-    description: 'Play a workflow recording by its name',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: {
-          type: 'string',
-          description: 'The name of the workflow recording to play',
-        },
-        speed: {
-          type: 'number',
-          description: 'Playback speed multiplier (1 = normal, 2 = 2x faster, 0.5 = half speed)',
-          default: 1,
-        },
-      },
-      required: ['name'],
-    },
-  },
-  {
-    name: 'get_screen_interactions',
-    description: 'Get all user interactions from a screen recording session or for a specific frame',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        sessionId: {
-          type: 'string',
-          description: 'The screen recording session ID',
-        },
-        frameIndex: {
-          type: 'number',
-          description: 'Optional: specific frame index to get interactions for',
-        },
-        type: {
-          type: 'string',
-          description: 'Optional: filter by interaction type (click, input, keypress, scroll)',
-          enum: ['click', 'input', 'keypress', 'scroll'],
-        },
-      },
-      required: ['sessionId'],
-    },
-  },
-];
-
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return { tools };
-});
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-
-  try {
-    switch (name) {
-      case 'launch_chrome': {
-        const result = await chromeController.launch();
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-      
-      case 'connect_to_existing_chrome': {
-        const port = args.port || 9222;
-        const result = await chromeController.connectToExisting(port);
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'navigate_to': {
-        const result = await chromeController.navigateTo(args.url);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'pause_execution': {
-        const result = await chromeController.pause();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'resume_execution': {
-        const result = await chromeController.resume();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'step_over': {
-        const result = await chromeController.stepOver();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'evaluate_expression': {
-        const result = await chromeController.evaluate(args.expression);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'get_scopes': {
-        const result = await chromeController.getScopes();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'set_breakpoint': {
-        const result = await chromeController.setBreakpoint(args.url, args.lineNumber);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'get_logs': {
-        const result = chromeController.getLogs();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'check_connection': {
-        const status = await chromeController.getConnectionStatus();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({ 
-                connected: status.connected,
-                debugPort: status.debugPort,
-                wsEndpoint: status.browserWSEndpoint
-              }, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'force_reset': {
-        const result = await chromeController.forceReset();
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'take_screenshot': {
-        const result = await chromeController.takeScreenshot(args);
-        
-        if (result.saved) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Screenshot saved successfully!\n\nPath: ${result.path}\nType: ${result.type}\nFull page: ${result.fullPage}`,
-              },
-            ],
-          };
-        } else if (result.truncated) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Screenshot preview (truncated):\n\nSize: ${result.size}\nType: ${result.type}\nFull page: ${result.fullPage}\n\n${result.message}`,
-              },
-            ],
-          };
-        } else if (result.error) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error taking screenshot: ${result.message}`,
-              },
-            ],
-            isError: true,
-          };
-        } else if (result.lowRes) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Low-resolution screenshot captured for AI parsing\n\nSize: ${result.size}\nType: ${result.type}\nFull page: ${result.fullPage}\nQuality: ${result.quality || 'N/A'}\n\ndata:image/${result.type};base64,${result.screenshot}`,
-              },
-            ],
-          };
-        } else {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Screenshot captured!\n\nSize: ${result.size}\nType: ${result.type}\nFull page: ${result.fullPage}\n\nBase64 data: ${result.screenshot.substring(0, 100)}...\n\nNote: Full screenshot is too large to display. Use 'lowRes: true' for AI-parseable screenshots or 'path' to save to file.`,
-              },
-            ],
-          };
-        }
-      }
-
-      case 'get_page_content': {
-        const result = await chromeController.getPageContent(args);
-        
-        if (result.error) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error getting page content: ${result.message}`,
-              },
-            ],
-            isError: true,
-          };
-        }
-        
-        let output = `Page Content Analysis:\n\n`;
-        output += `URL: ${result.url}\n`;
-        output += `Title: ${result.title}\n`;
-        
-        if (Object.keys(result.meta).length > 0) {
-          output += `\nMeta Tags:\n`;
-          for (const [key, value] of Object.entries(result.meta)) {
-            output += `  ${key}: ${value}\n`;
-          }
-        }
-        
-        output += `\nPage Statistics:\n`;
-        output += `  Forms: ${result.statistics.forms}\n`;
-        output += `  Images: ${result.statistics.images}\n`;
-        output += `  Links: ${result.statistics.links}\n`;
-        output += `  Scripts: ${result.statistics.scripts}\n`;
-        
-        if (result.text !== undefined) {
-          output += `\nText Content (${result.textLength} characters):\n`;
-          if (result.textLength > 1000) {
-            output += result.text.substring(0, 1000) + '...\n';
-            output += `(Showing first 1000 of ${result.textLength} characters)\n`;
-          } else {
-            output += result.text + '\n';
-          }
-        }
-        
-        if (result.structure !== undefined) {
-          output += `\nDOM Structure:\n`;
-          const formatStructure = (node, indent = '') => {
-            let str = `${indent}<${node.tag}`;
-            
-            if (Object.keys(node.attributes).length > 0) {
-              for (const [attr, value] of Object.entries(node.attributes)) {
-                str += ` ${attr}="${value}"`;
-              }
-            }
-            str += '>';
-            
-            if (node.text) {
-              str += ` ${node.text}`;
-            }
-            
-            output += str + '\n';
-            
-            if (node.children) {
-              for (const child of node.children) {
-                formatStructure(child, indent + '  ');
-              }
-            }
-          };
-          
-          formatStructure(result.structure);
-        }
-        
-        if (result.html !== undefined) {
-          output += `\nHTML Content (${result.htmlLength} characters):\n`;
-          if (result.htmlLength > 500) {
-            output += result.html.substring(0, 500) + '...\n';
-            output += `(Showing first 500 of ${result.htmlLength} characters)\n`;
-          } else {
-            output += result.html + '\n';
-          }
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-
-      case 'get_selected_element': {
-        // Check the controller's selected element
-        const result = await chromeController.getSelectedElement();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'apply_css_to_selected': {
-        const result = await chromeController.applyToSelectedElement(args.css);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'execute_js_on_selected': {
-        const result = await chromeController.executeOnSelectedElement(args.code);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'clear_selected_element': {
-        const result = await chromeController.clearSelectedElement();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      case 'get_websocket_info': {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `WebSocket Server Information:\n\n` +
-                    `Note: WebSocket server is running on a separate HTTP server process.\n` +
-                    `Default URL: ws://localhost:3001\n\n` +
-                    `Chrome extension should connect to this WebSocket.`,
-            },
-          ],
-        };
-      }
-      
-      case 'get_workflow_recording': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        
-        const recording = await chromeController.getWorkflowRecording(args.sessionId);
-        
-        if (recording.error) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error: ${recording.error}`,
-              },
-            ],
-            isError: true,
-          };
-        }
-        
-        let output = `Workflow Recording: ${recording.sessionId}\n\n`;
-        output += `URL: ${recording.url}\n`;
-        output += `Title: ${recording.title}\n`;
-        output += `Timestamp: ${new Date(recording.timestamp).toISOString()}\n`;
-        output += `Total Actions: ${recording.totalActions}\n\n`;
-        
-        if (recording.actions && recording.actions.length > 0) {
-          output += `Actions:\n`;
-          recording.actions.forEach((action, index) => {
-            output += `  ${index + 1}. ${action.type} - ${action.selector}\n`;
-            if (action.value) output += `     Value: ${action.value}\n`;
-            if (action.text) output += `     Text: ${action.text}\n`;
-          });
-        }
-        
-        if (recording.logs && recording.logs.length > 0) {
-          output += `\nConsole Logs (${recording.logs.length}):\n`;
-          recording.logs.forEach((log, index) => {
-            output += `  ${index + 1}. [${log.level}] ${log.message}\n`;
-          });
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-      
-      case 'list_workflow_recordings': {
-        const result = await chromeController.listWorkflowRecordings();
-        const recordings = result.recordings || [];
-        
-        if (recordings.length === 0) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: 'No workflow recordings found.',
-              },
-            ],
-          };
-        }
-        
-        let output = `Workflow Recordings (${recordings.length}):\n\n`;
-        recordings.forEach((recording, index) => {
-          const name = recording.name || recording.session_id;
-          output += `${index + 1}. ${name}\n`;
-          output += `   Session ID: ${recording.session_id}\n`;
-          output += `   URL: ${recording.url}\n`;
-          output += `   Title: ${recording.title}\n`;
-          output += `   Actions: ${recording.total_actions}\n`;
-          output += `   Date: ${new Date(recording.timestamp).toISOString()}\n`;
-          if (recording.screenshot_settings) {
-            output += `   Screenshots: Enabled\n`;
-          }
-          output += `\n`;
-        });
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-      
-      case 'save_restore_point': {
-        if (!args.workflowId) {
-          throw new Error('Workflow ID is required');
-        }
-        
-        // Capture current browser state
-        const page = await chromeController.getPage();
-        if (!page) {
-          throw new Error('No page available. Please launch Chrome and navigate to a URL first.');
-        }
-        
-        // Execute content script to capture state
-        const captureResult = await page.evaluate(async () => {
-          // This runs in the browser context
-          const captureState = () => {
-            const state = {
-              url: window.location.href,
-              title: document.title,
-              domSnapshot: {
-                html: document.documentElement.outerHTML,
-                formData: {},
-                checkboxStates: {},
-                radioStates: {},
-                selectValues: {},
-                textareaValues: {},
-              },
-              scrollX: window.scrollX,
-              scrollY: window.scrollY,
-              localStorage: {},
-              sessionStorage: {},
-            };
-            
-            // Capture form values
-            document.querySelectorAll('input').forEach(input => {
-              const id = input.id || input.name || Math.random().toString(36);
-              if (input.type === 'checkbox') {
-                state.domSnapshot.checkboxStates[id] = input.checked;
-              } else if (input.type === 'radio') {
-                state.domSnapshot.radioStates[id] = {
-                  checked: input.checked,
-                  value: input.value,
-                };
-              } else if (input.type !== 'file' && input.type !== 'password') {
-                state.domSnapshot.formData[id] = input.value;
-              }
-            });
-            
-            // Capture select values
-            document.querySelectorAll('select').forEach(select => {
-              const id = select.id || select.name || Math.random().toString(36);
-              state.domSnapshot.selectValues[id] = select.value;
-            });
-            
-            // Capture textarea values
-            document.querySelectorAll('textarea').forEach(textarea => {
-              const id = textarea.id || textarea.name || Math.random().toString(36);
-              state.domSnapshot.textareaValues[id] = textarea.value;
-            });
-            
-            // Capture storage
-            try {
-              for (let i = 0; i < localStorage.length; i++) {
-                const key = localStorage.key(i);
-                state.localStorage[key] = localStorage.getItem(key);
-              }
-            } catch (e) {}
-            
-            try {
-              for (let i = 0; i < sessionStorage.length; i++) {
-                const key = sessionStorage.key(i);
-                state.sessionStorage[key] = sessionStorage.getItem(key);
-              }
-            } catch (e) {}
-            
-            return state;
-          };
-          
-          return captureState();
-        });
-        
-        // Get cookies
-        const cookies = await page.cookies();
-        captureResult.cookies = cookies;
-        
-        // Save restore point
-        const restoreData = {
-          workflowId: args.workflowId,
-          actionIndex: args.actionIndex || 0,
-          ...captureResult,
-          description: args.description,
-          timestamp: Date.now(),
-        };
-        
-        const result = await chromeController.saveRestorePoint(restoreData);
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Restore point saved successfully!\nID: ${result.restorePointId}\nWorkflow: ${args.workflowId}\nDescription: ${args.description || 'N/A'}`,
-            },
-          ],
-        };
-      }
-      
-      case 'restore_from_point': {
-        if (!args.restorePointId) {
-          throw new Error('Restore point ID is required');
-        }
-        
-        // Get restore point data
-        const restoreData = await chromeController.getRestorePoint(args.restorePointId);
-        if (restoreData.error) {
-          throw new Error(restoreData.error);
-        }
-        
-        const page = await chromeController.getPage();
-        if (!page) {
-          throw new Error('No page available. Please launch Chrome first.');
-        }
-        
-        // Navigate if needed
-        const currentUrl = await page.url();
-        if (currentUrl !== restoreData.url) {
-          await page.goto(restoreData.url, { waitUntil: 'networkidle0' });
-        }
-        
-        // Restore state
-        await page.evaluate((data) => {
-          // Restore storage
-          try {
-            localStorage.clear();
-            Object.entries(data.localStorage).forEach(([key, value]) => {
-              localStorage.setItem(key, value);
-            });
-          } catch (e) {}
-          
-          try {
-            sessionStorage.clear();
-            Object.entries(data.sessionStorage).forEach(([key, value]) => {
-              sessionStorage.setItem(key, value);
-            });
-          } catch (e) {}
-          
-          // Restore form values
-          const snapshot = data.domSnapshot;
-          Object.entries(snapshot.formData).forEach(([id, value]) => {
-            const element = document.getElementById(id) || document.querySelector(`[name="${id}"]`);
-            if (element) element.value = value;
-          });
-          
-          Object.entries(snapshot.checkboxStates).forEach(([id, checked]) => {
-            const element = document.getElementById(id) || document.querySelector(`[name="${id}"]`);
-            if (element) element.checked = checked;
-          });
-          
-          Object.entries(snapshot.radioStates).forEach(([id, state]) => {
-            const element = document.getElementById(id) || document.querySelector(`[name="${id}"]`);
-            if (element && state.checked) element.checked = true;
-          });
-          
-          Object.entries(snapshot.selectValues).forEach(([id, value]) => {
-            const element = document.getElementById(id) || document.querySelector(`[name="${id}"]`);
-            if (element) element.value = value;
-          });
-          
-          Object.entries(snapshot.textareaValues).forEach(([id, value]) => {
-            const element = document.getElementById(id) || document.querySelector(`[name="${id}"]`);
-            if (element) element.value = value;
-          });
-          
-          // Restore scroll
-          window.scrollTo(data.scrollX, data.scrollY);
-        }, restoreData);
-        
-        // Restore cookies
-        if (restoreData.cookies && restoreData.cookies.length > 0) {
-          for (const cookie of restoreData.cookies) {
-            await page.setCookie(cookie);
-          }
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Successfully restored from restore point!\nURL: ${restoreData.url}\nTitle: ${restoreData.title}\nTimestamp: ${new Date(restoreData.timestamp).toISOString()}`,
-            },
-          ],
-        };
-      }
-      
-      case 'list_restore_points': {
-        if (!args.workflowId) {
-          throw new Error('Workflow ID is required');
-        }
-        
-        const restorePoints = await chromeController.listRestorePoints(args.workflowId);
-        
-        if (restorePoints.length === 0) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `No restore points found for workflow: ${args.workflowId}`,
-              },
-            ],
-          };
-        }
-        
-        let output = `Restore Points for workflow ${args.workflowId} (${restorePoints.length}):\n\n`;
-        restorePoints.forEach((rp, index) => {
-          output += `${index + 1}. ${rp.id}\n`;
-          output += `   Action Index: ${rp.actionIndex}\n`;
-          output += `   URL: ${rp.url}\n`;
-          output += `   Title: ${rp.title || 'N/A'}\n`;
-          output += `   Date: ${new Date(rp.timestamp).toISOString()}\n\n`;
-        });
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-
-      case 'chrome_pilot_show_frames': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        
-        const maxFrames = args.maxFrames || 10;
-        const showLogs = args.showLogs !== false;
-        const showInteractions = args.showInteractions !== false;
-        const logLevel = args.logLevel || 'all';
-        const maxLogsPerFrame = args.maxLogsPerFrame || 10;
-        
-        const sessionInfo = await chromeController.getFrameSessionInfo(args.sessionId);
-        if (!sessionInfo) {
-          // Get list of available sessions for better error message
-          const availableSessions = await chromeController.listFrameSessions();
-          const recentSessions = availableSessions.slice(0, 5);
-          
-          let errorMsg = `Frame session not found: ${args.sessionId}\n\n`;
-          if (recentSessions.length > 0) {
-            errorMsg += 'Available frame sessions:\n';
-            recentSessions.forEach(s => {
-              errorMsg += `  - ${s.sessionId} (${s.totalFrames} frames, ${new Date(s.timestamp).toLocaleString()})\n`;
-            });
-            errorMsg += '\nTip: Use list_workflow_recordings to see all available recordings.';
-          } else {
-            errorMsg += 'No frame sessions found in the database.\n';
-            errorMsg += 'Frame recordings may have been created in a different Chrome Debug instance.';
-          }
-          
-          throw new Error(errorMsg);
-        }
-        
-        // Get only frame metadata without image data to avoid token limits
-        const { database } = await import('./database.js');
-        const recording = database.getRecording(args.sessionId);
-        if (!recording) {
-          throw new Error('Frame session data not found');
-        }
-        
-        // Get frames without image data
-        const framesMetadataStmt = database.db.prepare(`
-          SELECT frame_index, timestamp, absolute_timestamp
-          FROM frames 
-          WHERE recording_id = ? 
-          ORDER BY frame_index ASC
-          LIMIT ?
-        `);
-        const framesToShow = framesMetadataStmt.all(recording.id, maxFrames);
-        
-        let output = `Frame Recording: ${args.sessionId}\n`;
-        output += `Type: ${recording.type}\n`;
-        output += `Created: ${new Date(sessionInfo.timestamp).toLocaleString()}\n`;
-        output += `Total Frames: ${sessionInfo.totalFrames}\n`;
-        
-        // Handle case where recording exists but has no frames
-        if (sessionInfo.totalFrames === 0) {
-          output += `Status: Recording exists but contains no frames\n`;
-          
-          // Check for screen interactions
-          const interactions = await chromeController.getScreenInteractions(args.sessionId);
-          if (interactions && interactions.length > 0) {
-            output += `\nScreen Interactions Found: ${interactions.length}\n`;
-            output += `Note: This recording has captured user interactions but no frame data.\n`;
-            output += `Use get_screen_interactions to view the captured interactions.\n`;
-          } else {
-            output += `\nNo frame data or interactions found.\n`;
-            output += `This may indicate the recording was started but stopped immediately.\n`;
-          }
-          
-          return {
-            content: [{ type: 'text', text: output }]
-          };
-        }
-        
-        output += `Showing: ${framesToShow.length} of ${sessionInfo.totalFrames} frames\n`;
-        if (logLevel !== 'all') {
-          output += `Log Filter: ${logLevel.toUpperCase()} level only\n`;
-        }
-        output += '\n';
-        
-        // Get all interactions for this recording if requested
-        let allInteractions = [];
-        if (showInteractions) {
-          allInteractions = await chromeController.getScreenInteractions(args.sessionId);
-        }
-        
-        framesToShow.forEach((frame, index) => {
-          output += `Frame ${frame.frame_index}:\n`;
-          output += `  Timestamp: ${frame.timestamp}ms\n`;
-          
-          // Get logs for this specific frame if requested
-          let logs = [];
-          if (showLogs) {
-            const frameRowStmt = database.db.prepare(`
-              SELECT id FROM frames 
-              WHERE recording_id = ? AND frame_index = ?
-            `);
-            const frameRow = frameRowStmt.get(recording.id, frame.frame_index);
-            
-            if (frameRow) {
-              let logsQuery = `
-                SELECT level, message, relative_time 
-                FROM console_logs 
-                WHERE frame_id = ?`;
-              let queryParams = [frameRow.id];
-              
-              if (logLevel !== 'all') {
-                logsQuery += ` AND level = ?`;
-                queryParams.push(logLevel);
-              }
-              
-              logsQuery += ` ORDER BY relative_time ASC`;
-              
-              if (maxLogsPerFrame > 0) {
-                logsQuery += ` LIMIT ?`;
-                queryParams.push(maxLogsPerFrame);
-              }
-              
-              const logsStmt = database.db.prepare(logsQuery);
-              logs = logsStmt.all(...queryParams);
-            }
-          }
-          
-          if (showLogs && logs.length > 0) {
-            output += `  Console Logs (${logs.length}${maxLogsPerFrame > 0 && logs.length === maxLogsPerFrame ? '+' : ''}):\n`;
-            logs.forEach(log => {
-              output += `    [${log.level.toUpperCase()}] ${log.message}\n`;
-            });
-            if (maxLogsPerFrame > 0 && logs.length === maxLogsPerFrame) {
-              output += `    ... (truncated, use get_frame or search_frame_logs for more)\n`;
-            }
-          } else {
-            // Count all logs for this frame to show total
-            const frameRowStmt = database.db.prepare(`
-              SELECT id FROM frames 
-              WHERE recording_id = ? AND frame_index = ?
-            `);
-            const frameRow = frameRowStmt.get(recording.id, frame.frame_index);
-            let totalLogCount = 0;
-            
-            if (frameRow) {
-              let countQuery = `SELECT COUNT(*) as count FROM console_logs WHERE frame_id = ?`;
-              let countParams = [frameRow.id];
-              
-              if (logLevel !== 'all') {
-                countQuery += ` AND level = ?`;
-                countParams.push(logLevel);
-              }
-              
-              const countStmt = database.db.prepare(countQuery);
-              totalLogCount = countStmt.get(...countParams).count;
-            }
-            
-            output += `  Console Logs: ${totalLogCount}\n`;
-          }
-          
-          // Show interactions for this frame
-          if (showInteractions && allInteractions.length > 0) {
-            const frameInteractions = allInteractions.filter(i => i.frame_index === frame.frame_index);
-            if (frameInteractions.length > 0) {
-              output += `  User Interactions (${frameInteractions.length}):\n`;
-              frameInteractions.forEach(interaction => {
-                switch (interaction.type) {
-                  case 'click':
-                    output += `    [CLICK] ${interaction.selector || `at (${interaction.x}, ${interaction.y})`}`;
-                    if (interaction.text) output += ` - "${interaction.text}"`;
-                    output += '\n';
-                    break;
-                  case 'input':
-                    output += `    [INPUT] ${interaction.selector} = "${interaction.value}"`;
-                    if (interaction.placeholder) output += ` (placeholder: ${interaction.placeholder})`;
-                    output += '\n';
-                    break;
-                  case 'keypress':
-                    output += `    [KEY] ${interaction.key}\n`;
-                    break;
-                  case 'scroll':
-                    output += `    [SCROLL] to (${interaction.scrollX}, ${interaction.scrollY})\n`;
-                    break;
-                  default:
-                    output += `    [${interaction.type.toUpperCase()}]\n`;
-                }
-              });
-            }
-          }
-          
-          output += '\n';
-        });
-        
-        if (sessionInfo.totalFrames > maxFrames) {
-          output += `... and ${sessionInfo.totalFrames - maxFrames} more frames\n`;
-          output += `Use get_frame with frameIndex to view specific frames\n`;
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-      
-      case 'get_frame_session_info': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        
-        const info = await chromeController.getFrameSessionInfo(args.sessionId);
-        if (!info) {
-          // Get list of available sessions for better error message
-          const availableSessions = await chromeController.listFrameSessions();
-          const recentSessions = availableSessions.slice(0, 5);
-          
-          let errorMsg = `Frame session not found: ${args.sessionId}\n\n`;
-          if (recentSessions.length > 0) {
-            errorMsg += 'Available frame sessions:\n';
-            recentSessions.forEach(s => {
-              errorMsg += `  - ${s.sessionId} (${s.totalFrames} frames, ${new Date(s.timestamp).toLocaleString()})\n`;
-            });
-            errorMsg += '\nTip: Frame recordings are stored in the local database and may not persist across different Chrome Debug instances.';
-          } else {
-            errorMsg += 'No frame sessions found in the database.\n';
-            errorMsg += 'Frame recordings may have been created in a different Chrome Debug instance or the database may have been reset.';
-          }
-          
-          throw new Error(errorMsg);
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Frame Session ${args.sessionId}:\n` +
-                    `Total Frames: ${info.totalFrames}\n` +
-                    `Created: ${new Date(info.timestamp).toISOString()}\n` +
-                    `Frame Timestamps: ${info.frameTimestamps ? info.frameTimestamps.slice(0, 5).join(', ') + (info.frameTimestamps.length > 5 ? '...' : '') : 'N/A'}`,
-            },
-          ],
-        };
-      }
-      
-      case 'get_frame': {
-        if (!args.sessionId || args.frameIndex === undefined) {
-          throw new Error('Session ID and frame index are required');
-        }
-        
-        const logLevel = args.logLevel || 'all';
-        const maxLogs = args.maxLogs || 20;
-        const searchLogs = args.searchLogs;
-        
-        const frame = await chromeController.getFrame(args.sessionId, args.frameIndex);
-        if (!frame) {
-          throw new Error('Frame not found');
-        }
-        
-        // Apply filtering to logs
-        let filteredLogs = frame.logs || [];
-        
-        // Filter by log level
-        if (logLevel !== 'all') {
-          filteredLogs = filteredLogs.filter(log => log.level === logLevel);
-        }
-        
-        // Filter by search text
-        if (searchLogs) {
-          const searchText = searchLogs.toLowerCase();
-          filteredLogs = filteredLogs.filter(log => 
-            log.message.toLowerCase().includes(searchText)
-          );
-        }
-        
-        // Limit the number of logs
-        const totalMatchingLogs = filteredLogs.length;
-        if (maxLogs > 0 && filteredLogs.length > maxLogs) {
-          filteredLogs = filteredLogs.slice(0, maxLogs);
-        }
-        
-        let output = `Frame ${args.frameIndex} from Session ${args.sessionId}:\n`;
-        output += `Timestamp: ${frame.timestamp}ms\n`;
-        output += `Image Size: ${frame.imageData ? Math.round(frame.imageData.length / 1024) + 'KB' : 'N/A'}\n`;
-        output += `Total Console Logs: ${frame.logs ? frame.logs.length : 0}\n`;
-        
-        if (logLevel !== 'all' || searchLogs) {
-          output += `Filtered Logs: ${totalMatchingLogs}`;
-          if (searchLogs) {
-            output += ` (containing "${searchLogs}")`;
-          }
-          if (logLevel !== 'all') {
-            output += ` (${logLevel.toUpperCase()} level)`;
-          }
-          output += '\n';
-        }
-        
-        if (filteredLogs.length > 0) {
-          // If there are a lot of logs, recommend paginated approach
-          if (totalMatchingLogs > 500) {
-            output += `\n⚠️  WARNING: This frame has ${totalMatchingLogs} matching logs!\n`;
-            output += `Showing only first ${filteredLogs.length} logs to prevent output overflow.\n`;
-            output += `For better navigation, use: get_frame_logs_paginated\n\n`;
-          } else {
-            output += `\nShowing: ${filteredLogs.length}${filteredLogs.length < totalMatchingLogs ? ` of ${totalMatchingLogs}` : ''} logs\n\n`;
-          }
-          
-          output += 'Logs:\n';
-          filteredLogs.forEach(log => {
-            output += `  [${log.level.toUpperCase()}] ${log.message}\n`;
-          });
-          
-          if (filteredLogs.length < totalMatchingLogs) {
-            if (totalMatchingLogs > 100) {
-              output += `\n... ${totalMatchingLogs - filteredLogs.length} more logs\n`;
-              output += `💡 TIP: Use get_frame_logs_paginated for better navigation with large log volumes\n`;
-            } else {
-              output += `\n... ${totalMatchingLogs - filteredLogs.length} more logs (use maxLogs=0 to see all, or search_frame_logs for cross-frame search)\n`;
-            }
-          }
-        }
-        
-        // Show interactions for this frame
-        if (frame.interactions && frame.interactions.length > 0) {
-          output += `\n\nUser Interactions (${frame.interactions.length}):\n`;
-          frame.interactions.forEach(interaction => {
-            switch (interaction.type) {
-              case 'click':
-                output += `  [CLICK] ${interaction.selector || `at (${interaction.x}, ${interaction.y})`}`;
-                if (interaction.text) output += ` - "${interaction.text}"`;
-                output += '\n';
-                break;
-              case 'input':
-                output += `  [INPUT] ${interaction.selector} = "${interaction.value}"`;
-                if (interaction.placeholder) output += ` (placeholder: ${interaction.placeholder})`;
-                output += '\n';
-                break;
-              case 'keypress':
-                output += `  [KEY] ${interaction.key}\n`;
-                break;
-              case 'scroll':
-                output += `  [SCROLL] to (${interaction.scrollX}, ${interaction.scrollY})\n`;
-                break;
-              default:
-                output += `  [${interaction.type.toUpperCase()}]\n`;
-            }
-          });
-        }
-        
-        if (frame.imageData) {
-          output += '\n[Frame image data available]';
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-      
-      case 'search_frame_logs': {
-        if (!args.sessionId || !args.searchText) {
-          throw new Error('Session ID and search text are required');
-        }
-        
-        const searchText = args.searchText.toLowerCase();
-        const logLevel = args.logLevel || 'all';
-        const maxResults = args.maxResults || 50;
-        
-        const { database } = await import('./database.js');
-        const recording = database.getRecording(args.sessionId);
-        if (!recording) {
-          throw new Error('Frame session not found');
-        }
-        
-        // Search across all frames in the session
-        let searchQuery = `
-          SELECT f.frame_index, cl.level, cl.message, cl.relative_time, f.timestamp
-          FROM console_logs cl
-          JOIN frames f ON cl.frame_id = f.id
-          WHERE f.recording_id = ? AND LOWER(cl.message) LIKE ?`;
-        
-        let queryParams = [recording.id, `%${searchText}%`];
-        
-        if (logLevel !== 'all') {
-          searchQuery += ` AND cl.level = ?`;
-          queryParams.push(logLevel);
-        }
-        
-        searchQuery += ` ORDER BY f.frame_index ASC, cl.relative_time ASC`;
-        
-        if (maxResults > 0) {
-          searchQuery += ` LIMIT ?`;
-          queryParams.push(maxResults);
-        }
-        
-        const searchStmt = database.db.prepare(searchQuery);
-        const results = searchStmt.all(...queryParams);
-        
-        let output = `Search Results for "${args.searchText}" in Session ${args.sessionId}:\n`;
-        output += `Found: ${results.length}${maxResults > 0 && results.length === maxResults ? '+' : ''} matching logs\n`;
-        if (logLevel !== 'all') {
-          output += `Filter: ${logLevel.toUpperCase()} level only\n`;
-        }
-        output += '\n';
-        
-        if (results.length > 0) {
-          let currentFrame = -1;
-          results.forEach(result => {
-            if (result.frame_index !== currentFrame) {
-              if (currentFrame !== -1) output += '\n';
-              output += `Frame ${result.frame_index} (${result.timestamp}ms):\n`;
-              currentFrame = result.frame_index;
-            }
-            output += `  [${result.level.toUpperCase()}] ${result.message}\n`;
-          });
-          
-          if (maxResults > 0 && results.length === maxResults) {
-            output += `\n... (truncated to ${maxResults} results, use maxResults=0 for all)\n`;
-          }
-          
-          output += `\nTip: Use get_frame with frameIndex to see full context for specific frames.\n`;
-        } else {
-          output += 'No matching logs found.\n';
-          output += `Try different search terms or check available log levels with chrome_pilot_show_frames.\n`;
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-      
-      case 'get_frame_logs_paginated': {
-        if (!args.sessionId || args.frameIndex === undefined) {
-          throw new Error('Session ID and frame index are required');
-        }
-        
-        const logLevel = args.logLevel || 'all';
-        const offset = args.offset || 0;
-        const limit = args.limit || 100;
-        const searchText = args.searchText;
-        
-        const { database } = await import('./database.js');
-        const recording = database.getRecording(args.sessionId);
-        if (!recording) {
-          throw new Error('Frame session not found');
-        }
-        
-        // Get the frame ID
-        const frameRowStmt = database.db.prepare(`
-          SELECT id FROM frames 
-          WHERE recording_id = ? AND frame_index = ?
-        `);
-        const frameRow = frameRowStmt.get(recording.id, args.frameIndex);
-        
-        if (!frameRow) {
-          throw new Error('Frame not found');
-        }
-        
-        // Build the query with filtering and pagination
-        let logsQuery = `
-          SELECT level, message, relative_time 
-          FROM console_logs 
-          WHERE frame_id = ?`;
-        let queryParams = [frameRow.id];
-        
-        // Add level filter
-        if (logLevel !== 'all') {
-          logsQuery += ` AND level = ?`;
-          queryParams.push(logLevel);
-        }
-        
-        // Add search filter
-        if (searchText) {
-          logsQuery += ` AND LOWER(message) LIKE ?`;
-          queryParams.push(`%${searchText.toLowerCase()}%`);
-        }
-        
-        // Get total count before pagination
-        const countQuery = logsQuery.replace('SELECT level, message, relative_time', 'SELECT COUNT(*)');
-        const totalCount = database.db.prepare(countQuery).get(...queryParams)['COUNT(*)'];
-        
-        // Add pagination
-        logsQuery += ` ORDER BY relative_time ASC LIMIT ? OFFSET ?`;
-        queryParams.push(limit, offset);
-        
-        const logsStmt = database.db.prepare(logsQuery);
-        const logs = logsStmt.all(...queryParams);
-        
-        let output = `Frame ${args.frameIndex} Logs (Paginated):\n`;
-        output += `Total Matching Logs: ${totalCount}\n`;
-        output += `Showing: ${Math.min(logs.length, limit)} logs (offset: ${offset})\n`;
-        
-        if (logLevel !== 'all') {
-          output += `Filter: ${logLevel.toUpperCase()} level only\n`;
-        }
-        if (searchText) {
-          output += `Search: "${searchText}"\n`;
-        }
-        
-        output += `\n`;
-        
-        if (logs.length > 0) {
-          logs.forEach((log, index) => {
-            const logNumber = offset + index + 1;
-            output += `${logNumber}. [${log.level.toUpperCase()}] ${log.message}\n`;
-          });
-          
-          // Show pagination info
-          const hasMore = (offset + logs.length) < totalCount;
-          if (hasMore) {
-            const nextOffset = offset + limit;
-            output += `\n... ${totalCount - offset - logs.length} more logs available\n`;
-            output += `Use get_frame_logs_paginated with offset=${nextOffset} to see more\n`;
-          }
-        } else {
-          output += 'No logs found matching the criteria.\n';
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-
-      case 'play_workflow_recording': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        
-        const speed = args.speed || 1;
-        
-        // Get the workflow recording
-        const recording = await chromeController.getWorkflowRecording(args.sessionId);
-        if (recording.error) {
-          throw new Error(recording.error);
-        }
-        
-        // Check if Chrome is connected
-        const status = await chromeController.getConnectionStatus();
-        if (!status.connected) {
-          throw new Error('Chrome is not connected. Please launch Chrome or connect to an existing instance first.');
-        }
-        
-        // Play the workflow
-        const result = await chromeController.playWorkflow(recording, recording.actions, speed);
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Workflow playback ${result.success ? 'completed successfully' : 'failed'}.\n` +
-                    `Executed ${result.executedActions}/${result.totalActions} actions.\n` +
-                    (result.error ? `Error: ${result.error}\n` : '') +
-                    `Duration: ${result.duration}ms`,
-            },
-          ],
-        };
-      }
-
-      case 'play_workflow_by_name': {
-        if (!args.name) {
-          throw new Error('Workflow name is required');
-        }
-        
-        const speed = args.speed || 1;
-        
-        // Find workflow by name
-        const allRecordings = await chromeController.listWorkflowRecordings();
-        const matchingRecording = allRecordings.recordings.find(r => 
-          r.name && r.name.toLowerCase() === args.name.toLowerCase()
-        );
-        
-        if (!matchingRecording) {
-          // Show available workflow names
-          const availableNames = allRecordings.recordings
-            .filter(r => r.name)
-            .map(r => `- ${r.name}`)
-            .join('\n');
-          
-          throw new Error(`No workflow found with name: ${args.name}\n\nAvailable workflows:\n${availableNames || 'No named workflows found'}`);
-        }
-        
-        // Get the full workflow recording
-        const recording = await chromeController.getWorkflowRecording(matchingRecording.session_id);
-        if (recording.error) {
-          throw new Error(recording.error);
-        }
-        
-        // Check if Chrome is connected
-        const status = await chromeController.getConnectionStatus();
-        if (!status.connected) {
-          throw new Error('Chrome is not connected. Please launch Chrome or connect to an existing instance first.');
-        }
-        
-        // Play the workflow
-        const result = await chromeController.playWorkflow(recording, recording.actions, speed);
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Playing workflow "${args.name}"...\n\n` +
-                    `Workflow playback ${result.success ? 'completed successfully' : 'failed'}.\n` +
-                    `Executed ${result.executedActions}/${result.totalActions} actions.\n` +
-                    (result.error ? `Error: ${result.error}\n` : '') +
-                    `Duration: ${result.duration}ms`,
-            },
-          ],
-        };
-      }
-
-      case 'get_screen_interactions': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        
-        let interactions;
-        
-        if (args.frameIndex !== undefined) {
-          // Get interactions for specific frame
-          interactions = await chromeController.getFrameInteractions(args.sessionId, args.frameIndex);
-        } else {
-          // Get all interactions for the recording
-          interactions = await chromeController.getScreenInteractions(args.sessionId);
-        }
-        
-        // Filter by type if requested
-        if (args.type) {
-          interactions = interactions.filter(i => i.type === args.type);
-        }
-        
-        if (interactions.length === 0) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `No interactions found for session ${args.sessionId}${args.frameIndex !== undefined ? ` frame ${args.frameIndex}` : ''}${args.type ? ` of type '${args.type}'` : ''}.`,
-              },
-            ],
-          };
-        }
-        
-        let output = `Screen Interactions for session ${args.sessionId}`;
-        if (args.frameIndex !== undefined) {
-          output += ` (frame ${args.frameIndex})`;
-        }
-        if (args.type) {
-          output += ` - Type: ${args.type}`;
-        }
-        output += `\nTotal: ${interactions.length} interactions\n\n`;
-        
-        interactions.forEach((interaction, index) => {
-          output += `${index + 1}. `;
-          switch (interaction.type) {
-            case 'click':
-              output += `[CLICK] ${interaction.selector || `at (${interaction.x}, ${interaction.y})`}`;
-              if (interaction.text) output += ` - "${interaction.text}"`;
-              if (interaction.frame_index !== null) output += ` (frame ${interaction.frame_index})`;
-              output += '\n';
-              if (interaction.xpath) output += `   XPath: ${interaction.xpath}\n`;
-              break;
-            case 'input':
-              output += `[INPUT] ${interaction.selector} = "${interaction.value}"`;
-              if (interaction.placeholder) output += ` (placeholder: ${interaction.placeholder})`;
-              if (interaction.frame_index !== null) output += ` (frame ${interaction.frame_index})`;
-              output += '\n';
-              break;
-            case 'keypress':
-              output += `[KEY] ${interaction.key}`;
-              if (interaction.frame_index !== null) output += ` (frame ${interaction.frame_index})`;
-              output += '\n';
-              break;
-            case 'scroll':
-              output += `[SCROLL] to (${interaction.scrollX || interaction.x}, ${interaction.scrollY || interaction.y})`;
-              if (interaction.frame_index !== null) output += ` (frame ${interaction.frame_index})`;
-              output += '\n';
-              break;
-            default:
-              output += `[${interaction.type.toUpperCase()}]`;
-              if (interaction.frame_index !== null) output += ` (frame ${interaction.frame_index})`;
-              output += '\n';
-          }
-          output += `   Time: ${new Date(interaction.timestamp).toISOString()}\n\n`;
-        });
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: output,
-            },
-          ],
-        };
-      }
-
-      default:
-        throw new Error(`Unknown tool: ${name}`);
-    }
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error: ${error.message}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-});
-
-async function checkForExistingSingleServer() {
-  try {
-    const { database } = await import('./database.js');
-    const pid = await database.getSingleServerInstance();
-    
-    return { exists: !!pid, pid };
-  } catch (error) {
-    console.error('Error checking for single-server:', error.message);
-    return { exists: false, pid: null };
-  }
-}
-
-/**
- * Safely validates a process ID to prevent injection attacks
- * @param {*} pid - The process ID to validate
- * @returns {number|null} - Validated PID or null if invalid
- */
-function validateProcessId(pid) {
-  // Security: Check for suspicious characters before parsing
-  const pidStr = String(pid).trim();
-  if (!/^\d+$/.test(pidStr)) {
-    // Contains non-digit characters - potential injection attempt
-    return null;
-  }
-  
-  const numericPid = parseInt(pidStr, 10);
-  if (isNaN(numericPid) || numericPid <= 0 || numericPid > 4194304) { // Max PID on Linux/macOS
-    return null;
-  }
-  return numericPid;
-}
-
-/**
- * Safely kills a process using Node.js native APIs to prevent command injection
- * @param {number} pid - Validated process ID
- * @param {string} signal - Signal to send ('SIGTERM' or 'SIGKILL')
- * @returns {Promise<boolean>} - True if successful, false otherwise
- */
-async function safeKillProcess(pid, signal = 'SIGTERM') {
-  const validatedPid = validateProcessId(pid);
-  if (!validatedPid) {
-    console.error(`Invalid process ID: ${pid}`);
-    return false;
-  }
-  
-  try {
-    // Security: Use Node.js native process.kill() instead of shell commands
-    process.kill(validatedPid, signal);
-    return true;
-  } catch (error) {
-    if (error.code === 'ESRCH') {
-      // Process doesn't exist
-      return true;
-    } else if (error.code === 'EPERM') {
-      console.error(`Permission denied killing process ${validatedPid}`);
-      return false;
-    } else {
-      console.error(`Error killing process ${validatedPid}: ${error.message}`);
-      return false;
-    }
-  }
-}
-
-/**
- * Find Chrome Debug processes using Node.js process list instead of shell commands
- * This prevents command injection while maintaining functionality
- */
-async function findChromePilotProcesses() {
-  const currentPid = process.pid;
-  const pidsToKill = [];
-  const processDescriptions = [];
-  
-  try {
-    // Security: Use Node.js process list instead of shell commands
-    // This approach uses the 'ps-list' module or similar safe approach
-    // For now, we'll use a safer implementation with spawn instead of exec
-    const { spawn } = await import('child_process');
-    
-    return new Promise((resolve) => {
-      const ps = spawn('ps', ['aux'], { stdio: ['ignore', 'pipe', 'ignore'] });
-      let stdout = '';
-      
-      ps.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-      
-      ps.on('close', (code) => {
-        if (code !== 0) {
-          console.error('Failed to get process list');
-          resolve({ pidsToKill: [], processDescriptions: [] });
-          return;
-        }
-        
-        const lines = stdout.trim().split('\n');
-        
-        for (const line of lines) {
-          // Security: Validate each line and extract PID safely
-          const parts = line.trim().split(/\s+/);
-          if (parts.length < 2) continue;
-          
-          const pid = validateProcessId(parts[1]);
-          if (!pid || pid === currentPid) continue;
-          
-          // Check if it's a Chrome Debug related process
-          let processType = '';
-          if (line.includes('src/index.js')) {
-            processType = 'MCP server';
-            pidsToKill.push(pid);
-          } else if (line.includes('standalone-server.js')) {
-            processType = 'HTTP server';
-            pidsToKill.push(pid);
-          } else if (line.includes('chrome-pilot')) {
-            processType = 'Chrome Debug process';
-            pidsToKill.push(pid);
-          }
-          
-          if (processType) {
-            processDescriptions.push(`${pid} (${processType})`);
-          }
-        }
-        
-        resolve({ pidsToKill, processDescriptions });
-      });
-      
-      ps.on('error', (error) => {
-        console.error('Error running ps command:', error.message);
-        resolve({ pidsToKill: [], processDescriptions: [] });
-      });
-    });
-  } catch (error) {
-    console.error('Error finding processes:', error.message);
-    return { pidsToKill: [], processDescriptions: [] };
-  }
-}
-
-async function killOtherChromePilotInstances() {
-  try {
-    console.error('Searching for other Chrome Debug instances...');
-    
-    const { pidsToKill, processDescriptions } = await findChromePilotProcesses();
-    
-    if (pidsToKill.length > 0) {
-      console.error(`Found ${pidsToKill.length} other Chrome Debug instance(s) running:`);
-      processDescriptions.forEach(desc => console.error(`  - Process ${desc}`));
-      console.error('Terminating processes...');
-      
-      for (const pid of pidsToKill) {
-        // Security: Use safe process killing with validated PIDs
-        const termSuccess = await safeKillProcess(pid, 'SIGTERM');
-        if (termSuccess) {
-          console.error(`Sent TERM signal to process ${pid}`);
-        } else {
-          // Try force kill if graceful termination fails
-          const killSuccess = await safeKillProcess(pid, 'SIGKILL');
-          if (killSuccess) {
-            console.error(`Force killed process ${pid}`);
-          } else {
-            console.error(`Failed to kill process ${pid}`);
-          }
-        }
-      }
-      
-      // Wait a moment for processes to terminate
-      await new Promise(resolve => setTimeout(resolve, 1500));
-      console.error('Process cleanup completed');
-    } else {
-      console.error('No other Chrome Debug instances found');
-    }
-  } catch (error) {
-    console.error('Error during process cleanup:', error.message);
-    // Don't fail startup if cleanup fails
-  }
-}
-
-async function main() {
-  const isSingleServerMode = process.argv.includes('--single-server');
-  
-  if (isSingleServerMode) {
-    console.error('Starting in single-server mode - killing other Chrome Debug instances...');
-    await killOtherChromePilotInstances();
-    
-    // Register this server instance in the database
-    const { database } = await import('./database.js');
-    await database.registerServerInstance(process.pid, 'single-server');
-    
-    console.error(`Single-server mode active (PID: ${process.pid})`);
-  } else {
-    // Check if there's already a single-server running
-    const singleServerCheck = await checkForExistingSingleServer();
-    
-    if (singleServerCheck.exists) {
-      console.error('⚠️  Detected existing single-server instance.');
-      console.error(`   Single-server PID: ${singleServerCheck.pid}`);
-      console.error('   This Claude session will try to connect to the existing Chrome instance.');
-      console.error('   If connection fails, this session will start its own Chrome instance.');
-    }
-  }
-  
-  // Try to discover HTTP server
-  httpServerPort = await discoverServer();
-  if (httpServerPort) {
-    console.error(`Found existing Chrome Debug HTTP server on port ${httpServerPort}`);
-  } else {
-    // Start embedded HTTP server
-    console.error('Starting embedded HTTP server...');
-    try {
-      httpServerPort = await startHttpServer();
-      console.error(`Started HTTP server on port ${httpServerPort}`);
-      
-      // Also start WebSocket server for element selection
-      const wsPort = await startWebSocketServer();
-      console.error(`Started WebSocket server on port ${wsPort}`);
-    } catch (error) {
-      console.error('WARNING: Failed to start embedded HTTP server:', error.message);
-      console.error('Chrome extension features will not be available');
-    }
-  }
-  
-  // Start MCP server
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('Chrome Debug MCP server running');
-}
-
-// Function to clean up single-server registration and port file
-async function cleanupSingleServerFlag() {
-  try {
-    const { database } = await import('./database.js');
-    await database.unregisterServerInstance(process.pid);
-  } catch (error) {
-    // Ignore cleanup errors
-  }
-  
-  // Clean up port file if we started the HTTP server
-  if (httpServerPort) {
-    try {
-      const { removePortFile } = await import('./port-discovery.js');
-      removePortFile();
-    } catch (error) {
-      // Ignore cleanup errors
-    }
-  }
-}
-
-// Clean shutdown
-process.on('SIGINT', async () => {
-  await cleanupSingleServerFlag();
-  await chromeController.close();
-  process.exit(0);
-});
-
-process.on('SIGTERM', async () => {
-  await cleanupSingleServerFlag();
-  await chromeController.close();
-  process.exit(0);
-});
-
-main().catch((error) => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});