mcp-web-inspector 0.1.0

package/dist/evals/evals.d.ts

@@ -0,0 +1,5 @@
+import { EvalConfig } from 'mcp-evals';
+import { EvalFunction } from "mcp-evals";
+declare const config: EvalConfig;
+export default config;
+export declare const evals: EvalFunction[];

package/dist/evals/evals.js

@@ -0,0 +1,41 @@
+//evals.ts
+import { openai } from "@ai-sdk/openai";
+import { grade } from "mcp-evals";
+const startCodegenSessionEval = {
+    name: 'startCodegenSession Evaluation',
+    description: 'Evaluates the start codegen session tool',
+    run: async () => {
+        const result = await grade(openai("gpt-4"), "Please start a new code generation session with an output path of /my/test/path, a testNamePrefix of MyPrefix, and comments enabled. Confirm the session was created successfully.");
+        return JSON.parse(result);
+    }
+};
+const end_codegen_sessionEval = {
+    name: 'end_codegen_session Evaluation',
+    description: 'Evaluates the end_codegen_session tool functionality',
+    run: async () => {
+        const result = await grade(openai("gpt-4"), "Please end the code generation session with ID session123 and generate the Playwright test code");
+        return JSON.parse(result);
+    }
+};
+const get_codegen_sessionEval = {
+    name: 'get_codegen_session Tool Evaluation',
+    description: 'Evaluates the retrieval of code generation session details',
+    run: async () => {
+        const result = await grade(openai("gpt-4"), "Please retrieve the code generation session details using session ID abc123.");
+        return JSON.parse(result);
+    }
+};
+const clearCodegenSessionEval = {
+    name: 'clear_codegen_session Evaluation',
+    description: 'Evaluates the functionality of clearing a code generation session',
+    run: async () => {
+        const result = await grade(openai("gpt-4"), "Please clear the code generation session with the ID testSession_123 to verify removal.");
+        return JSON.parse(result);
+    }
+};
+const config = {
+    model: openai("gpt-4"),
+    evals: [startCodegenSessionEval, end_codegen_sessionEval, get_codegen_sessionEval, clearCodegenSessionEval]
+};
+export default config;
+export const evals = [startCodegenSessionEval, end_codegen_sessionEval, get_codegen_sessionEval, clearCodegenSessionEval];

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createToolDefinitions } from "./tools.js";
+import { setupRequestHandlers } from "./requestHandler.js";
+import { parseArgs } from "node:util";
+import { setSessionConfig } from "./toolHandler.js";
+// Parse command line arguments
+const { values } = parseArgs({
+    options: {
+        'no-save-session': {
+            type: 'boolean',
+            default: false,
+        },
+        'user-data-dir': {
+            type: 'string',
+            default: './.mcp-web-inspector',
+        },
+    },
+    strict: false,
+});
+// Configure session settings (session saving is enabled by default)
+const baseDir = String(values['user-data-dir'] || './.mcp-web-inspector');
+const sessionConfig = {
+    saveSession: !Boolean(values['no-save-session']),
+    userDataDir: `${baseDir}/user-data`,
+    screenshotsDir: `${baseDir}/screenshots`,
+};
+setSessionConfig(sessionConfig);
+async function runServer() {
+    const server = new Server({
+        name: "mcp-web-inspector",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+    });
+    // Create tool definitions with session config
+    const TOOLS = createToolDefinitions(sessionConfig);
+    // Setup request handlers
+    setupRequestHandlers(server, TOOLS);
+    // Graceful shutdown logic
+    function shutdown() {
+        console.log('Shutdown signal received');
+        process.exit(0);
+    }
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    process.on('exit', shutdown);
+    process.on('uncaughtException', (err) => {
+        console.error('Uncaught Exception:', err);
+    });
+    // Create transport and connect
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+runServer().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/requestHandler.d.ts

@@ -0,0 +1,3 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare function setupRequestHandlers(server: Server, tools: Tool[]): void;

package/dist/requestHandler.js

@@ -0,0 +1,53 @@
+import { ListResourcesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { handleToolCall, getConsoleLogs, getScreenshots } from "./toolHandler.js";
+export function setupRequestHandlers(server, tools) {
+    // List resources handler
+    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+        resources: [
+            {
+                uri: "console://logs",
+                mimeType: "text/plain",
+                name: "Browser console logs",
+            },
+            ...Array.from(getScreenshots().keys()).map(name => ({
+                uri: `screenshot://${name}`,
+                mimeType: "image/png",
+                name: `Screenshot: ${name}`,
+            })),
+        ],
+    }));
+    // Read resource handler
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const uri = request.params.uri.toString();
+        if (uri === "console://logs") {
+            const logs = getConsoleLogs().join("\n");
+            return {
+                contents: [{
+                        uri,
+                        mimeType: "text/plain",
+                        text: logs,
+                    }],
+            };
+        }
+        if (uri.startsWith("screenshot://")) {
+            const name = uri.split("://")[1];
+            const screenshot = getScreenshots().get(name);
+            if (screenshot) {
+                return {
+                    contents: [{
+                            uri,
+                            mimeType: "image/png",
+                            blob: screenshot,
+                        }],
+                };
+            }
+        }
+        throw new Error(`Resource not found: ${uri}`);
+    });
+    // List tools handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: tools,
+    }));
+    // Call tool handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => handleToolCall(request.params.name, request.params.arguments ?? {}, server));
+}

package/dist/toolHandler.d.ts

@@ -0,0 +1,91 @@
+import type { Page } from 'playwright';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export interface NetworkRequest {
+    index: number;
+    method: string;
+    url: string;
+    resourceType: string;
+    timestamp: number;
+    status?: number;
+    statusText?: string;
+    timing?: number;
+    requestData: {
+        headers: Record<string, string>;
+        postData: string | null;
+    };
+    responseData?: {
+        headers: Record<string, string>;
+        body: string | null;
+    };
+}
+interface SessionConfig {
+    saveSession: boolean;
+    userDataDir: string;
+    screenshotsDir: string;
+}
+/**
+ * Sets the session configuration
+ */
+export declare function setSessionConfig(config: Partial<SessionConfig>): void;
+/**
+ * Gets the screenshots directory
+ */
+export declare function getScreenshotsDir(): string;
+/**
+ * Resets browser and page variables
+ * Used when browser is closed
+ */
+export declare function resetBrowserState(): void;
+/**
+ * Gets the network log
+ */
+export declare function getNetworkLog(): NetworkRequest[];
+/**
+ * Clears the network log
+ */
+export declare function clearNetworkLog(): void;
+/**
+ * Sets the provided page to the global page variable
+ * @param newPage The Page object to set as the global page
+ */
+export declare function setGlobalPage(newPage: Page): void;
+interface BrowserSettings {
+    viewport?: {
+        width?: number;
+        height?: number;
+    };
+    userAgent?: string;
+    headless?: boolean;
+    browserType?: 'chromium' | 'firefox' | 'webkit';
+    device?: string;
+}
+declare function registerConsoleMessage(page: any): Promise<void>;
+/**
+ * Ensures a browser is launched and returns the page
+ */
+export declare function ensureBrowser(browserSettings?: BrowserSettings): Promise<Page>;
+/**
+ * Main handler for tool calls
+ */
+export declare function handleToolCall(name: string, args: any, server: any): Promise<CallToolResult>;
+/**
+ * Get console logs
+ */
+export declare function getConsoleLogs(): string[];
+/**
+ * Get screenshots
+ */
+export declare function getScreenshots(): Map<string, string>;
+/**
+ * Update last interaction timestamp
+ */
+export declare function updateLastInteractionTimestamp(): void;
+/**
+ * Update last navigation timestamp
+ */
+export declare function updateLastNavigationTimestamp(): void;
+/**
+ * Clear console logs
+ */
+export declare function clearConsoleLogs(): void;
+export { registerConsoleMessage };