@probebrowser/mcp-server 1.2.0

package/Dockerfile

@@ -0,0 +1,59 @@
+FROM node:20-slim
+
+WORKDIR /app
+
+# Install build dependencies if needed (e.g. for native modules)
+# RUN apt-get update && apt-get install -y python3 make g++
+
+# Copy workspace configuration
+COPY package.json .
+
+# Copy package manifests to install dependencies first (caching)
+COPY packages/sdk/package.json packages/sdk/
+COPY packages/mcp-server/package.json packages/mcp-server/
+
+# Install SDK dependencies
+WORKDIR /app/packages/sdk
+RUN npm install
+
+# Install MCP Server dependencies
+WORKDIR /app/packages/mcp-server
+RUN npm install
+
+# Copy source code
+COPY packages/sdk /app/packages/sdk
+COPY packages/mcp-server /app/packages/mcp-server
+
+# Build SDK
+WORKDIR /app/packages/sdk
+RUN npm run build
+
+# Build MCP Server
+WORKDIR /app/packages/mcp-server
+# Ensure local SDK is used
+RUN npm install ../sdk
+RUN npm run build
+
+# Cleanup dev dependencies (optional optimization)
+# RUN npm prune --production
+
+# Runtime Configuration
+ENV NODE_ENV=production
+ENV TRANSPORT=sse
+ENV PORT=3000
+# IMPORTANT: Trace needs a browser. 
+# In Docker, you typically connect to a remote browser (browserless.io) 
+# or install Chromium. For this base image, we assume remote connect 
+# or headless with Puppeteer installing Chrome (which needs libs).
+# Installing Chrome dependencies:
+RUN apt-get update && apt-get install -y wget gnupg \
+    && wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - \
+    && sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list' \
+    && apt-get update \
+    && apt-get install -y google-chrome-stable fonts-ipafont-gothic fonts-wqy-zenhei fonts-thai-tlwg fonts-kacst fonts-freefont-ttf libxss1 \
+      --no-install-recommends \
+    && rm -rf /var/lib/apt/lists/*
+
+EXPOSE 3000
+
+CMD ["node", "dist/index.js"]

package/dist/index.js

@@ -0,0 +1,29 @@
+import express from 'express';
+import cors from 'cors';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { TraceMcpServer } from './server.js';
+async function main() {
+    const transportType = process.env.TRANSPORT || 'stdio';
+    if (transportType === 'sse') {
+        const app = express();
+        app.use(cors());
+        // Create MCP Server
+        const traceServer = new TraceMcpServer();
+        const transport = new SSEServerTransport('/messages', app); // Type cast might be needed if SDK types mismatch express
+        await traceServer.connect(transport);
+        const port = process.env.PORT || 3000;
+        app.listen(port, () => {
+            console.error(`Trace MCP Server (SSE) running on port ${port}`);
+            console.error(`Endpoint: http://localhost:${port}/sse`);
+        });
+    }
+    else {
+        // Stdio Mode
+        const traceServer = new TraceMcpServer();
+        await traceServer.start();
+    }
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/resources.js

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,282 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { Trace, ALL_TOOLS } from '@probebrowser/sdk';
+import { TOOLS } from './tools.js';
+// Schema conversion helper
+function zodToJsonSchema(schema) {
+    return {
+        type: 'object',
+        properties: {}, // Simplified
+    };
+}
+export class TraceMcpServer {
+    server;
+    trace;
+    constructor() {
+        this.server = new Server({
+            name: 'trace-mcp-server',
+            version: '1.2.0',
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+                prompts: {},
+            },
+        });
+        // Initialize Trace SDK with Env Config
+        const headless = process.env.TRACE_HEADLESS !== 'false'; // Default to true
+        const verbose = process.env.TRACE_VERBOSE === 'true';
+        this.trace = new Trace({
+            headless,
+            verbose,
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // ============================================
+        // 1. TOOLS
+        // ============================================
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            const definedTools = Object.entries(TOOLS).map(([name, def]) => ({
+                name,
+                description: def.description,
+                inputSchema: zodToJsonSchema(def.schema),
+            }));
+            const definedNames = new Set(Object.keys(TOOLS));
+            const distinctAllTools = new Set(ALL_TOOLS);
+            // Add dynamic tools
+            for (const tool of distinctAllTools) {
+                const mcpName = `trace_${tool}`;
+                if (!definedNames.has(mcpName)) {
+                    definedTools.push({
+                        name: mcpName,
+                        description: `Execute ${tool} (Dynamic Tool)`,
+                        inputSchema: { type: 'object', properties: {} },
+                    });
+                }
+            }
+            return { tools: definedTools };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const toolName = request.params.name;
+            let toolDef = TOOLS[toolName];
+            let method = toolDef?.method;
+            // Dynamic Tool Logic
+            if (!toolDef && toolName.startsWith('trace_')) {
+                const rawName = toolName.replace('trace_', '');
+                if (ALL_TOOLS.includes(rawName)) {
+                    method = rawName;
+                    toolDef = { method: rawName };
+                }
+            }
+            if (!method)
+                throw new Error(`Unknown tool: ${toolName}`);
+            const isConnected = !!this.trace.getCurrentUrl();
+            try {
+                let result;
+                // 1. Handle Connect Tool
+                if (toolDef.method === 'connect') {
+                    const url = String(request.params.arguments?.url);
+                    // Re-init trace if headless mode changes? For now just connect.
+                    await this.trace.connect(url);
+                    return { content: [{ type: 'text', text: `Connected to ${url}` }] };
+                }
+                if (!isConnected) {
+                    return { content: [{ type: 'text', text: 'Error: No active page. Call trace_connect first.' }], isError: true };
+                }
+                // 2. Handle Azure AI Agent (Unified Deep Debug)
+                if (toolDef.method === 'deep_debug' || toolDef.method === 'trace_p') {
+                    // Check for API Key
+                    if (!process.env.TRACE_API_KEY) {
+                        return { content: [{ type: 'text', text: 'Error: TRACE_API_KEY is required for AI features.' }], isError: true };
+                    }
+                    const prompt = String(request.params.arguments?.prompt || request.params.arguments?.q || 'Analyze page');
+                    // Delegate to SDK's queryDeep which calls Azure /v1/agent-step
+                    const analysis = await this.trace.queryDeep(prompt);
+                    // Return the conclusion and steps
+                    return {
+                        content: [
+                            { type: 'text', text: `### Conclusion\n${analysis.conclusion}\n\n### Steps Taken\n${analysis.steps.map(s => `- ${s.tool}: ${s.success ? 'Success' : 'Failed'}`).join('\n')}` }
+                        ]
+                    };
+                }
+                // 3. Handle Standard SDK Tools
+                result = await this.trace.executeTool(toolDef.method, request.params.arguments);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: 'text', text: `Error: ${error.message}` }],
+                    isError: true,
+                };
+            }
+        });
+        // ============================================
+        // 2. RESOURCES
+        // ============================================
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+            return {
+                resources: [
+                    {
+                        uri: 'trace://console/errors',
+                        name: 'Console Errors',
+                        mimeType: 'application/json',
+                        description: 'List of all console errors and exceptions',
+                    },
+                    {
+                        uri: 'trace://console/logs',
+                        name: 'All Console Logs',
+                        mimeType: 'application/json',
+                        description: 'Full console history (info, warn, error)',
+                    },
+                    {
+                        uri: 'trace://network/failed',
+                        name: 'Failed Network Requests',
+                        mimeType: 'application/json',
+                        description: 'List of failed network requests (4xx, 5xx)',
+                    },
+                    {
+                        uri: 'trace://network/all',
+                        name: 'All Network Traffic',
+                        mimeType: 'application/json',
+                        description: 'Recent network requests summary',
+                    },
+                    {
+                        uri: 'trace://dom/tree',
+                        name: 'DOM Tree',
+                        mimeType: 'application/json',
+                        description: 'Simplified DOM structure',
+                    },
+                    {
+                        uri: 'trace://screenshot',
+                        name: 'Page Screenshot',
+                        mimeType: 'image/png',
+                        description: 'Current page screenshot',
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+            const uri = request.params.uri;
+            if (!this.trace.getCurrentUrl()) {
+                throw new Error('Not connected. Call trace_connect first.');
+            }
+            // --- Console ---
+            if (uri === 'trace://console/errors') {
+                const logs = await this.trace.executeTool('get_console_errors', {});
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(logs, null, 2) }] };
+            }
+            if (uri === 'trace://console/logs') {
+                // We don't have get_console_logs explicitly in ALL_TOOLS list in previous step,
+                // but we can use get_console_summary or implement a getter.
+                // For now, let's return the summary as it contains counts.
+                // Ideally SDK should expose 'get_all_logs'.
+                // Fallback: use get_console_errors
+                const logs = await this.trace.executeTool('get_console_summary', {});
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(logs, null, 2) }] };
+            }
+            // --- Network ---
+            if (uri === 'trace://network/failed') {
+                const reqs = await this.trace.executeTool('get_network_failed', {});
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(reqs, null, 2) }] };
+            }
+            if (uri === 'trace://network/all') {
+                const reqs = await this.trace.executeTool('get_network_summary', {});
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(reqs, null, 2) }] };
+            }
+            // --- DOM ---
+            if (uri === 'trace://dom/tree') {
+                const tree = await this.trace.executeTool('get_dom_tree', { depth: 2 });
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(tree, null, 2) }] };
+            }
+            // --- Screenshot ---
+            if (uri === 'trace://screenshot') {
+                // Try to capture snapshot via capture_execution_state which might have screenshot
+                // Or just return a placeholder if SDK doesn't support raw image output via tool interface easily
+                // For now, returning text explainer
+                return { contents: [{ uri, mimeType: 'text/plain', text: "Screenshot resource requires Trace SDK v1.4+" }] };
+            }
+            throw new Error(`Resource not found: ${uri}`);
+        });
+        // ============================================
+        // 3. PROMPTS
+        // ============================================
+        this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
+            return {
+                prompts: [
+                    {
+                        name: 'debug_error',
+                        description: 'Analyze the most recent error and suggest a fix',
+                        arguments: [],
+                    },
+                    {
+                        name: 'audit_performance',
+                        description: 'Check metrics and run a quick profile',
+                        arguments: [],
+                    },
+                    {
+                        name: 'verify_security',
+                        description: 'Check security headers and SSL status',
+                        arguments: [],
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+            const promptName = request.params.name;
+            if (promptName === 'debug_error') {
+                return {
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: 'Please check the console for errors, analyze the most critical one, and suggest a code fix.',
+                            },
+                        },
+                    ],
+                };
+            }
+            if (promptName === 'audit_performance') {
+                return {
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: 'Please capture performance metrics, take a heap snapshot, and tell me if there are any obvious bottlenecks.',
+                            },
+                        },
+                    ],
+                };
+            }
+            if (promptName === 'verify_security') {
+                return {
+                    messages: [
+                        {
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: 'Please check the security info, verify HTTPS, and look for mixed content warnings.',
+                            },
+                        },
+                    ],
+                };
+            }
+            throw new Error('Prompt not found');
+        });
+    }
+    async connect(transport) {
+        await this.server.connect(transport);
+        console.error('Trace MCP Server connected');
+    }
+    async start() {
+        // Default to Stdio for backward compatibility
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Trace MCP Server running on stdio');
+    }
+}