@dynamicu/chromedebug-mcp 2.6.7 → 2.7.0

package/src/legacy/index-old.js

@@ -1,977 +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 express from 'express';
-import { ChromeController } from './chrome-controller.js';
-import { createRoutes } from './routes.js';
-import { findAvailablePort } from './utils.js';
-import { promises as fs } from 'fs';
-import path from 'path';
-
-const chromeController = new ChromeController();
-const app = express();
-let serverPort = null; // Store the actual server port
-
-app.use((req, res, next) => {
-  res.header('Access-Control-Allow-Origin', '*');
-  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-  res.header('Access-Control-Allow-Headers', 'Content-Type');
-  if (req.method === 'OPTIONS') {
-    res.sendStatus(200);
-  } else {
-    next();
-  }
-});
-
-app.use(express.json({ limit: '10mb' }));
-
-const server = new Server(
-  {
-    name: 'chrome-pilot',
-    version: '1.0.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
-
-const tools = [
-    {
-      name: 'launch_chrome',
-      description: 'Launch a Chrome browser instance',
-      inputSchema: {
-        type: 'object',
-        properties: {},
-      },
-    },
-    {
-      name: 'connect_to_existing_chrome',
-      description: 'Connect to an existing Chrome instance with debugging enabled. Chrome must be running with --remote-debugging-port flag (e.g., --remote-debugging-port=9222)',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          port: {
-            type: 'number',
-            description: 'Debugging port Chrome is running on (default: 9222)',
-            default: 9222,
-          },
-        },
-      },
-    },
-    {
-      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 (320x568px viewport, JPEG quality 30, max 25KB)',
-      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, set false to disable)',
-          },
-          quality: {
-            type: 'number',
-            description: 'JPEG quality (1-100, default: 10)',
-            minimum: 1,
-            maximum: 100,
-          },
-          path: {
-            type: 'string',
-            description: 'Save screenshot to file path',
-          },
-        },
-      },
-    },
-    {
-      name: 'get_selected_element',
-      description: 'Get information about the currently selected element from the 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 (e.g., "background-color: blue !important; padding: 20px !important")',
-          },
-        },
-        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_recording',
-      description: 'Get information about a screen recording (frame capture only). This tool identifies the recording type and guides you to the appropriate tools',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          recordingId: {
-            type: 'string',
-            description: 'The recording ID returned when recording was saved',
-          },
-        },
-        required: ['recordingId'],
-      },
-    },
-    {
-      name: 'get_server_info',
-      description: 'Get information about the current Chrome Debug server including port and storage location',
-      inputSchema: {
-        type: 'object',
-        properties: {},
-      },
-    },
-    {
-      name: 'discover_server_port',
-      description: 'Discover the port of a running Chrome Debug server by checking common ports',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          startPort: {
-            type: 'number',
-            description: 'Starting port to check (default: 3000)',
-            default: 3000,
-          },
-          maxPort: {
-            type: 'number',
-            description: 'Maximum port to check (default: 3020)',
-            default: 3020,
-          },
-        },
-      },
-    },
-    {
-      name: 'get_recording_info',
-      description: 'Get information about a chunked recording session including total chunks and metadata',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          sessionId: {
-            type: 'string',
-            description: 'The session ID returned when recording was saved',
-          },
-        },
-        required: ['sessionId'],
-      },
-    },
-    {
-      name: 'get_recording_chunk',
-      description: 'Get a specific chunk from a recording session with synchronized console logs',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          sessionId: {
-            type: 'string',
-            description: 'The session ID returned when recording was saved',
-          },
-          chunkIndex: {
-            type: 'number',
-            description: 'The chunk index to retrieve (0-based)',
-          },
-        },
-        required: ['sessionId', 'chunkIndex'],
-      },
-    },
-    {
-      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_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 (0-based)',
-          },
-        },
-        required: ['sessionId', 'frameIndex'],
-      },
-    },
-    {
-      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 show (default: 10)',
-            default: 10,
-          },
-          showLogs: {
-            type: 'boolean',
-            description: 'Whether to include console logs in the output (default: true)',
-            default: true,
-          },
-        },
-        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 '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 isConnected = await chromeController.isConnected();
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({ connected: isConnected }, 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);
-        
-        // Format response based on whether screenshot was saved or returned
-        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}\n\nTo get the full screenshot, please provide a 'path' parameter to save it to a file.`,
-              },
-            ],
-          };
-        } else if (result.error) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error taking screenshot: ${result.message}`,
-              },
-            ],
-            isError: true,
-          };
-        } else if (result.lowRes) {
-          // For low-res screenshots, return the full base64 data for AI parsing
-          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 {
-          // For normal screenshots, show preview only
-          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_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_recording': {
-        if (!args.recordingId) {
-          throw new Error('Recording ID is required');
-        }
-        const result = await chromeController.getRecording(args.recordingId);
-        if (result.error) {
-          throw new Error(result.message);
-        }
-        
-        // Handle frame capture sessions
-        if (result.type === 'frame_capture') {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Recording ${args.recordingId} is a FRAME CAPTURE session.\n\n` +
-                      `${result.message}\n\n` +
-                      `Session Info:\n` +
-                      `- Total Frames: ${result.recording.totalFrames}\n` +
-                      `- Session ID: ${args.recordingId}\n\n` +
-                      `To access this recording, use:\n` +
-                      `1. get_frame_session_info with sessionId: "${args.recordingId}"\n` +
-                      `2. get_frame with sessionId: "${args.recordingId}" and frameIndex: 0, 1, 2, etc.`
-              }
-            ],
-          };
-        }
-        
-        // Handle chunked recordings (legacy - no longer supported)
-        if (result.type === 'chunked_recording') {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Recording ${args.recordingId} is a CHUNKED recording (legacy).\n\n` +
-                      `${result.message}\n\n` +
-                      `Session Info:\n` +
-                      `- Total Chunks: ${result.recording.totalChunks}\n` +
-                      `- Session ID: ${args.recordingId}\n\n` +
-                      `To access this recording, use:\n` +
-                      `1. get_recording_info with sessionId: "${args.recordingId}"\n` +
-                      `2. get_recording_chunk with sessionId: "${args.recordingId}" and chunkIndex: 0, 1, 2, etc.`
-              }
-            ],
-          };
-        }
-        
-        // Handle old single-file recordings
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Recording ${args.recordingId}:\n` +
-                    `Duration: ${result.recording.duration}ms\n` +
-                    `Logs: ${result.recording.logs.length} entries\n` +
-                    `Data: ${result.recording.filename || 'legacy recording'}`
-            },
-            {
-              type: 'text',
-              text: '--- Console Logs ---\n' + result.recording.logs.map(log => 
-                `[${log.relativeTime}ms] [${log.level}] ${log.message}`
-              ).join('\n')
-            }
-          ],
-        };
-      }
-
-
-      case 'get_server_info': {
-        const port = serverPort || process.env.PORT || 3000;
-        const storageLocation = path.join(process.cwd(), 'src', '.recordings-storage.json');
-        
-        // Check if storage file exists
-        let storageInfo = 'Not created yet';
-        try {
-          const stats = await fs.stat(storageLocation);
-          const sizeKB = Math.round(stats.size / 1024);
-          storageInfo = `${sizeKB}KB`;
-        } catch (e) {
-          // File doesn't exist yet
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Chrome Debug Server Information:\n\n` +
-                    `Server Port: ${port}\n` +
-                    `Storage Location: ${storageLocation}\n` +
-                    `Storage Size: ${storageInfo}\n` +
-                    `Working Directory: ${process.cwd()}\n\n` +
-                    `To retrieve recordings from a different server, use:\n` +
-                    `get_recording_from_server with port parameter`
-            }
-          ],
-        };
-      }
-
-      case 'discover_server_port': {
-        const startPort = args.startPort || 3000;
-        const maxPort = args.maxPort || 3020;
-        
-        const foundServers = [];
-        
-        for (let port = startPort; port <= maxPort; port++) {
-          try {
-            const response = await fetch(`http://localhost:${port}/chrome-pilot/port`);
-            if (response.ok) {
-              const data = await response.json();
-              foundServers.push({
-                port: port,
-                reported_port: data.port,
-                timestamp: data.timestamp,
-                message: data.message
-              });
-            }
-          } catch (e) {
-            // Port not available or no server running
-          }
-        }
-        
-        if (foundServers.length === 0) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `No Chrome Debug servers found on ports ${startPort}-${maxPort}.\n\n` +
-                      `To start a server, run: npm start`
-              }
-            ],
-          };
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Found ${foundServers.length} Chrome Debug server(s):\n\n` +
-                    foundServers.map(server => 
-                      `Port ${server.port}: ${server.message} (${server.timestamp})`
-                    ).join('\n') + '\n\n' +
-                    `Use these ports to connect to the servers.`
-            }
-          ],
-        };
-      }
-
-      case 'get_recording_info': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        const result = await chromeController.getRecordingInfo(args.sessionId);
-        if (result.error) {
-          throw new Error(result.message);
-        }
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Recording Session ${args.sessionId}:\n` +
-                    `Total Chunks: ${result.info.totalChunks}\n` +
-                    `Created: ${result.info.createdAt}\n` +
-                    `Last Updated: ${result.info.lastUpdated}\n` +
-                    `Available Chunks: ${result.info.chunkIndexes.join(', ')}`
-            }
-          ],
-        };
-      }
-
-      case 'get_recording_chunk': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        if (args.chunkIndex === undefined) {
-          throw new Error('Chunk index is required');
-        }
-        const result = await chromeController.getRecordingChunk(args.sessionId, args.chunkIndex);
-        if (result.error) {
-          throw new Error(result.message);
-        }
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Recording Chunk ${args.chunkIndex} from Session ${args.sessionId}:\n` +
-                    `Time Range: ${result.chunk.startTimeMs}ms - ${result.chunk.endTimeMs}ms\n` +
-                    `Duration: ${result.chunk.endTimeMs - result.chunk.startTimeMs}ms\n` +
-                    `Console Logs: ${result.chunk.logs.length} entries\n` +
-                    `Data: ${result.chunk.filename || 'chunk_' + args.chunkIndex}`
-            },
-            {
-              type: 'text',
-              text: '--- Console Logs for this chunk ---\n' + result.chunk.logs.map(log => 
-                `[${log.chunkRelativeTime || log.relativeTime}ms] [${log.level}] ${log.message}`
-              ).join('\n')
-            }
-          ],
-        };
-      }
-
-      case 'get_frame_session_info': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        const info = await chromeController.getFrameSessionInfo(args.sessionId);
-        if (!info) {
-          throw new Error('Frame session not found');
-        }
-        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.map(t => t + 'ms').join(', ')}`
-            }
-          ],
-        };
-      }
-      
-      case 'get_frame': {
-        if (!args.sessionId) {
-          throw new Error('Session ID is required');
-        }
-        if (args.frameIndex === undefined) {
-          throw new Error('Frame index is required');
-        }
-        const frame = await chromeController.getFrame(args.sessionId, args.frameIndex);
-        if (!frame) {
-          throw new Error('Frame not found');
-        }
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Frame ${args.frameIndex} from Session ${args.sessionId}:\n` +
-                    `Timestamp: ${frame.timestamp}ms\n` +
-                    `Console Logs: ${frame.logs.length} entries`
-            },
-            {
-              type: 'resource',
-              resource: {
-                uri: frame.imageData,
-                mimeType: 'image/jpeg',
-                text: `Frame ${args.frameIndex} at ${frame.timestamp}ms`
-              }
-            },
-            {
-              type: 'text',
-              text: 'Console Logs:\n' + frame.logs.map(log => 
-                `[${log.level.toUpperCase()}] ${log.message}`
-              ).join('\n')
-            }
-          ],
-        };
-      }
-
-      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 sessionInfo = await chromeController.getFrameSessionInfo(args.sessionId);
-        if (!sessionInfo) {
-          throw new Error('Frame session not found');
-        }
-        
-        const session = await chromeController.getFrameSession(args.sessionId);
-        if (!session) {
-          throw new Error('Frame session data not found');
-        }
-        
-        // Limit the number of frames to display
-        const framesToShow = session.frames.slice(0, maxFrames);
-        
-        let output = `Frame Recording: ${args.sessionId}\n`;
-        output += `Created: ${new Date(sessionInfo.timestamp).toLocaleString()}\n`;
-        output += `Total Frames: ${sessionInfo.totalFrames}\n`;
-        output += `Showing: ${framesToShow.length} of ${sessionInfo.totalFrames} frames\n\n`;
-        
-        framesToShow.forEach((frame, index) => {
-          output += `Frame ${index}:\n`;
-          output += `  Timestamp: ${frame.timestamp}ms\n`;
-          output += `  Image Size: ${frame.imageData ? Math.round(frame.imageData.length / 1024) + 'KB' : 'N/A'}\n`;
-          
-          if (showLogs && frame.logs && frame.logs.length > 0) {
-            output += `  Console Logs (${frame.logs.length}):\n`;
-            frame.logs.forEach(log => {
-              output += `    [${log.level.toUpperCase()}] ${log.message}\n`;
-            });
-          } else {
-            output += `  Console Logs: ${frame.logs ? frame.logs.length : 0}\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
-            }
-          ],
-        };
-      }
-
-      default:
-        throw new Error(`Unknown tool: ${name}`);
-    }
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error: ${error.message}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-});
-
-async function main() {
-  app.use(createRoutes(chromeController));
-  
-  app.use((err, req, res, next) => {
-    console.error('Express error:', err);
-    res.status(500).json({ error: err.message });
-  });
-
-  const startPort = process.env.PORT ? parseInt(process.env.PORT) : 3000;
-  const port = await findAvailablePort(startPort);
-  serverPort = port; // Store for get_server_info
-  
-  // Set SERVER_PORT environment variable for the port discovery endpoint
-  process.env.SERVER_PORT = port.toString();
-  
-  app.listen(port, () => {
-    console.error(`Chrome Debug REST API listening on port ${port}`);
-    if (port !== startPort) {
-      console.error(`Note: Port ${startPort} was busy, using port ${port} instead`);
-    }
-  });
-
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('Chrome Debug MCP server running');
-}
-
-process.on('SIGINT', async () => {
-  await chromeController.close();
-  process.exit(0);
-});
-
-process.on('SIGTERM', async () => {
-  await chromeController.close();
-  process.exit(0);
-});
-
-main().catch((error) => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});