@probebrowser/mcp-server 1.2.0

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@probebrowser/mcp-server",
+  "version": "1.2.0",
+  "description": "Trace MCP Server - Bridge between AI Agents and Trace",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "trace-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "@probebrowser/sdk": "^1.3.0",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.0",
+    "typescript": "^5.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "trace",
+    "debugging",
+    "ai",
+    "browser",
+    "devtools"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AhmadBilalAmjad/dev-intelli.git"
+  },
+  "author": "Probe",
+  "license": "Apache-2.0"
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+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 as any); // 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/src/server.ts

@@ -0,0 +1,330 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    ListResourcesRequestSchema,
+    ReadResourceRequestSchema,
+    ListPromptsRequestSchema,
+    GetPromptRequestSchema,
+    Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+import { Trace, ALL_TOOLS } from '@probebrowser/sdk';
+import { TOOLS } from './tools.js';
+import { z } from 'zod';
+
+// Schema conversion helper
+function zodToJsonSchema(schema: z.ZodType<any>): any {
+    return {
+        type: 'object',
+        properties: {}, // Simplified
+    };
+}
+
+export class TraceMcpServer {
+    private server: Server;
+    private trace: 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();
+    }
+
+    private setupHandlers() {
+        // ============================================
+        // 1. TOOLS
+        // ============================================
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            const definedTools: Tool[] = 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 as any)[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 as any);
+
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            } catch (error: any) {
+                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: any) {
+        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');
+    }
+}