@dynamicu/chromedebug-mcp 2.6.6 → 2.7.0

package/src/legacy/index-express.js

@@ -1,625 +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 express from 'express';
-import { findAvailablePort } from './utils.js';
-
-// Create a single Chrome controller instance for this MCP server
-const chromeController = new ChromeController();
-
-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_selected_element',
-    description: 'Get information about the currently selected element',
-    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: 'select_element',
-    description: 'Select an element on the page for manipulation',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        selector: {
-          type: 'string',
-          description: 'CSS selector for the element',
-        },
-        instruction: {
-          type: 'string',
-          description: 'Optional instruction for what to do with the element',
-        },
-      },
-      required: ['selector'],
-    },
-  },
-];
-
-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 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);
-        
-        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_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 'select_element': {
-        const result = await chromeController.selectElement(args.selector, args.instruction);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
-
-      default:
-        throw new Error(`Unknown tool: ${name}`);
-    }
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error: ${error.message}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-});
-
-// Minimal Express server for Chrome extension support
-const app = express();
-
-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' }));
-
-// Essential endpoints for Chrome extension
-app.post('/chrome-pilot/dom-intent', async (req, res) => {
-  try {
-    const { selector, instruction, elementInfo } = req.body;
-    if (!selector) {
-      return res.status(400).json({ error: 'Selector is required' });
-    }
-    const result = await chromeController.selectElement(selector, instruction, elementInfo);
-    res.json(result);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
-});
-
-// Navigation endpoint for extension
-app.post('/chrome-pilot/navigate', async (req, res) => {
-  try {
-    const { url } = req.body;
-    if (!url) {
-      return res.status(400).json({ error: 'URL is required' });
-    }
-    const result = await chromeController.navigateTo(url);
-    res.json(result);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
-});
-
-app.get('/chrome-pilot/status', async (req, res) => {
-  try {
-    const status = await chromeController.getConnectionStatus();
-    res.json({ 
-      connected: status.connected, 
-      status: 'ok',
-      debugPort: status.debugPort,
-      browserWSEndpoint: status.browserWSEndpoint
-    });
-  } catch (error) {
-    res.json({ connected: false, status: 'error', error: error.message });
-  }
-});
-
-app.get('/chrome-pilot/port', (req, res) => {
-  res.json({ 
-    port: process.env.SERVER_PORT || 3000,
-    message: 'Chrome Debug server port',
-    timestamp: new Date().toISOString()
-  });
-});
-
-async function main() {
-  // Start minimal Express server for Chrome extension
-  const startPort = process.env.PORT ? parseInt(process.env.PORT) : 3000;
-  const port = await findAvailablePort(startPort);
-  process.env.SERVER_PORT = port.toString();
-  
-  app.listen(port, () => {
-    console.error(`Chrome Debug extension API on port ${port}`);
-  });
-
-  // Start MCP server
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('Chrome Debug MCP server running');
-}
-
-// Clean shutdown
-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);
-});