@ejazullah/browser-mcp 0.0.56

package/lib/mcp/inProcessTransport.js

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export class InProcessTransport {
+    _server;
+    _serverTransport;
+    _connected = false;
+    constructor(server) {
+        this._server = server;
+        this._serverTransport = new InProcessServerTransport(this);
+    }
+    async start() {
+        if (this._connected)
+            throw new Error('InprocessTransport already started!');
+        await this._server.connect(this._serverTransport);
+        this._connected = true;
+    }
+    async send(message, options) {
+        if (!this._connected)
+            throw new Error('Transport not connected');
+        this._serverTransport._receiveFromClient(message);
+    }
+    async close() {
+        if (this._connected) {
+            this._connected = false;
+            this.onclose?.();
+            this._serverTransport.onclose?.();
+        }
+    }
+    onclose;
+    onerror;
+    onmessage;
+    sessionId;
+    setProtocolVersion;
+    _receiveFromServer(message, extra) {
+        this.onmessage?.(message, extra);
+    }
+}
+class InProcessServerTransport {
+    _clientTransport;
+    constructor(clientTransport) {
+        this._clientTransport = clientTransport;
+    }
+    async start() {
+    }
+    async send(message, options) {
+        this._clientTransport._receiveFromServer(message);
+    }
+    async close() {
+        this.onclose?.();
+    }
+    onclose;
+    onerror;
+    onmessage;
+    sessionId;
+    setProtocolVersion;
+    _receiveFromClient(message) {
+        this.onmessage?.(message);
+    }
+}

package/lib/mcp/server.js

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { ManualPromise } from '../manualPromise.js';
+import { logUnhandledError } from '../log.js';
+export async function connect(serverBackendFactory, transport, runHeartbeat) {
+    const backend = serverBackendFactory();
+    const server = createServer(backend, runHeartbeat);
+    await server.connect(transport);
+}
+export function createServer(backend, runHeartbeat) {
+    const initializedPromise = new ManualPromise();
+    const server = new Server({ name: backend.name, version: backend.version }, {
+        capabilities: {
+            tools: {},
+        }
+    });
+    const tools = backend.tools();
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: tools.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: zodToJsonSchema(tool.inputSchema),
+                annotations: {
+                    title: tool.title,
+                    readOnlyHint: tool.type === 'readOnly',
+                    destructiveHint: tool.type === 'destructive',
+                    openWorldHint: true,
+                },
+            })) };
+    });
+    let heartbeatRunning = false;
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        await initializedPromise;
+        if (runHeartbeat && !heartbeatRunning) {
+            heartbeatRunning = true;
+            startHeartbeat(server);
+        }
+        const errorResult = (...messages) => ({
+            content: [{ type: 'text', text: '### Result\n' + messages.join('\n') }],
+            isError: true,
+        });
+        const tool = tools.find(tool => tool.name === request.params.name);
+        if (!tool)
+            return errorResult(`Error: Tool "${request.params.name}" not found`);
+        try {
+            return await backend.callTool(tool, tool.inputSchema.parse(request.params.arguments || {}));
+        }
+        catch (error) {
+            return errorResult(String(error));
+        }
+    });
+    addServerListener(server, 'initialized', () => {
+        backend.initialize?.(server).then(() => initializedPromise.resolve()).catch(logUnhandledError);
+    });
+    addServerListener(server, 'close', () => backend.serverClosed?.());
+    return server;
+}
+const startHeartbeat = (server) => {
+    const beat = () => {
+        Promise.race([
+            server.ping(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('ping timeout')), 5000)),
+        ]).then(() => {
+            setTimeout(beat, 3000);
+        }).catch(() => {
+            void server.close();
+        });
+    };
+    beat();
+};
+function addServerListener(server, event, listener) {
+    const oldListener = server[`on${event}`];
+    server[`on${event}`] = () => {
+        oldListener?.();
+        listener();
+    };
+}

package/lib/mcp/transport.js

@@ -0,0 +1,217 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import crypto from 'crypto';
+import debug from 'debug';
+import cors from 'cors';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { httpAddressToString, startHttpServer } from '../httpServer.js';
+import * as mcpServer from './server.js';
+import { AuthManager, defaultAuthConfig } from '../auth.js';
+export async function start(serverBackendFactory, options, authConfig) {
+    if (options.port !== undefined) {
+        const httpServer = await startHttpServer(options);
+        const auth = new AuthManager(authConfig ?? defaultAuthConfig());
+        startHttpTransport(httpServer, serverBackendFactory, auth);
+    }
+    else {
+        await startStdioTransport(serverBackendFactory);
+    }
+}
+async function startStdioTransport(serverBackendFactory) {
+    await mcpServer.connect(serverBackendFactory, new StdioServerTransport(), false);
+}
+const testDebug = debug('pw:mcp:test');
+// Get the current file's directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Embedded OpenAPI specification as fallback
+const embeddedOpenApiSpec = `{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "MCP Playwright Browser Automation API",
+    "description": "Enhanced Playwright Tools for Model Context Protocol (MCP) with CDP Support. Provides browser automation capabilities including navigation, interaction, extraction, and testing.",
+    "version": "0.0.36",
+    "contact": {
+      "name": "Ejaz Ullah",
+      "email": "ejazullah@example.com",
+      "url": "https://github.com/ejazullah/mcp-playwright"
+    },
+    "license": {
+      "name": "Apache-2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    }
+  },
+  "servers": [
+    {
+      "url": "https://mcp.doingerp.com",
+      "description": "Production MCP Playwright Server"
+    },
+    {
+      "url": "http://localhost:8931",
+      "description": "Local Development Server"
+    }
+  ],
+  "info": {
+    "description": "This API provides browser automation tools through MCP (Model Context Protocol). All endpoints accept POST requests with JSON payloads and return structured responses."
+  }
+}`;
+async function handleOpenAPI(req, res) {
+    if (req.method !== 'GET') {
+        res.statusCode = 405;
+        res.end('Method not allowed');
+        return;
+    }
+    try {
+        // Try to read the OpenAPI spec from file first
+        const openApiPath = join(__dirname, '../../openapi.json');
+        let openApiSpec;
+        try {
+            openApiSpec = readFileSync(openApiPath, 'utf8');
+        }
+        catch {
+            // Fallback to embedded spec if file not found
+            openApiSpec = embeddedOpenApiSpec;
+        }
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.statusCode = 200;
+        res.end(openApiSpec);
+    }
+    catch (error) {
+        res.statusCode = 500;
+        res.end('OpenAPI specification not found');
+    }
+}
+async function handleSSE(serverBackendFactory, req, res, url, sessions) {
+    if (req.method === 'POST') {
+        const sessionId = url.searchParams.get('sessionId');
+        if (!sessionId) {
+            res.statusCode = 400;
+            return res.end('Missing sessionId');
+        }
+        const transport = sessions.get(sessionId);
+        if (!transport) {
+            res.statusCode = 404;
+            return res.end('Session not found');
+        }
+        return await transport.handlePostMessage(req, res);
+    }
+    else if (req.method === 'GET') {
+        const transport = new SSEServerTransport('/sse', res);
+        sessions.set(transport.sessionId, transport);
+        testDebug(`create SSE session: ${transport.sessionId}`);
+        await mcpServer.connect(serverBackendFactory, transport, false);
+        res.on('close', () => {
+            testDebug(`delete SSE session: ${transport.sessionId}`);
+            sessions.delete(transport.sessionId);
+        });
+        return;
+    }
+    res.statusCode = 405;
+    res.end('Method not allowed');
+}
+async function handleStreamable(serverBackendFactory, req, res, sessions) {
+    const sessionId = req.headers['mcp-session-id'];
+    if (sessionId) {
+        const transport = sessions.get(sessionId);
+        if (!transport) {
+            res.statusCode = 404;
+            res.end('Session not found');
+            return;
+        }
+        return await transport.handleRequest(req, res);
+    }
+    if (req.method === 'POST') {
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => crypto.randomUUID(),
+            onsessioninitialized: async (sessionId) => {
+                testDebug(`create http session: ${transport.sessionId}`);
+                await mcpServer.connect(serverBackendFactory, transport, true);
+                sessions.set(sessionId, transport);
+            }
+        });
+        transport.onclose = () => {
+            if (!transport.sessionId)
+                return;
+            sessions.delete(transport.sessionId);
+            testDebug(`delete http session: ${transport.sessionId}`);
+        };
+        await transport.handleRequest(req, res);
+        return;
+    }
+    res.statusCode = 400;
+    res.end('Invalid request');
+}
+function startHttpTransport(httpServer, serverBackendFactory, auth) {
+    const sseSessions = new Map();
+    const streamableSessions = new Map();
+    // Configure CORS with permissive settings for MCP tools
+    const corsHandler = cors({
+        origin: true, // Allow all origins
+        methods: ['GET', 'POST', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Authorization', 'mcp-session-id', 'X-API-Key'],
+        credentials: true,
+        preflightContinue: false,
+        optionsSuccessStatus: 204
+    });
+    httpServer.on('request', async (req, res) => {
+        // Handle CORS first
+        corsHandler(req, res, async () => {
+            const url = new URL(`http://localhost${req.url}`);
+            // Handle OpenAPI specification endpoint (public)
+            if (url.pathname === '/openapi.json') {
+                await handleOpenAPI(req, res);
+                return;
+            }
+            // Authenticate all other requests when auth is enabled
+            if (await auth.authenticateRequest(req, res))
+                return;
+            if (url.pathname.startsWith('/sse'))
+                await handleSSE(serverBackendFactory, req, res, url, sseSessions);
+            else
+                await handleStreamable(serverBackendFactory, req, res, streamableSessions);
+        });
+    });
+    const url = httpAddressToString(httpServer.address());
+    const authStatus = auth.enabled ? ' (auth enabled)' : '';
+    const message = [
+        `Listening on ${url}${authStatus}`,
+        'Put this in your client config:',
+        JSON.stringify({
+            'mcpServers': {
+                'playwright': {
+                    'url': `${url}/mcp`
+                }
+            }
+        }, undefined, 2),
+        'For legacy SSE transport support, you can use the /sse endpoint instead.',
+        ...(auth.enabled ? [
+            '',
+            'Auth endpoints:',
+            `  POST ${url}/oauth/token          - Get access token`,
+            `  GET  ${url}/oauth/authorize       - Authorization code flow`,
+            `  GET  ${url}/oauth/token-info      - Introspect token`,
+            `  GET  ${url}/.well-known/oauth-authorization-server - OAuth metadata`,
+        ] : []),
+    ].join('\n');
+    // eslint-disable-next-line no-console
+    console.error(message);
+}

package/lib/mongoDBLogger.js

@@ -0,0 +1,252 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { MongoClient } from 'mongodb';
+import { logUnhandledError } from './log.js';
+export class MongoDBLogger {
+    _client = null;
+    _db = null;
+    _collection = null;
+    _mongoUrl;
+    _dbName;
+    _collectionName;
+    _sessionId;
+    _connected = false;
+    _pendingWrites = [];
+    _flushTimeout;
+    constructor(config = {}) {
+        this._mongoUrl = config.mongoUrl || process.env.MONGODB_URL || 'mongodb://localhost:27017';
+        this._dbName = config.dbName || process.env.MONGODB_DB_NAME || 'playwright_mcp';
+        this._collectionName = config.collectionName || process.env.MONGODB_COLLECTION || 'element_interactions';
+        this._sessionId = config.sessionId || `session_${Date.now()}`;
+    }
+    /**
+     * Connect to MongoDB
+     */
+    async connect() {
+        if (this._connected)
+            return true;
+        try {
+            this._client = new MongoClient(this._mongoUrl);
+            await this._client.connect();
+            this._db = this._client.db(this._dbName);
+            this._collection = this._db.collection(this._collectionName);
+            // Create indexes for better query performance
+            await this._collection.createIndex({ sessionId: 1, timestamp: 1 });
+            await this._collection.createIndex({ toolName: 1 });
+            await this._collection.createIndex({ elementRef: 1 });
+            await this._collection.createIndex({ url: 1 });
+            this._connected = true;
+            // eslint-disable-next-line no-console
+            console.error(`✓ MongoDB connected: ${this._dbName}.${this._collectionName}`);
+            return true;
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error(`✗ MongoDB connection failed: ${error}`);
+            logUnhandledError(error);
+            return false;
+        }
+    }
+    /**
+     * Disconnect from MongoDB
+     */
+    async disconnect() {
+        await this.flushSync();
+        if (this._client) {
+            await this._client.close();
+            this._client = null;
+            this._db = null;
+            this._collection = null;
+            this._connected = false;
+        }
+    }
+    /**
+     * Check if connected to MongoDB
+     */
+    isConnected() {
+        return this._connected;
+    }
+    /**
+     * Get the session ID
+     */
+    getSessionId() {
+        return this._sessionId;
+    }
+    /**
+     * Log an element interaction to MongoDB
+     */
+    async logInteraction(interaction) {
+        const fullInteraction = {
+            ...interaction,
+            sessionId: this._sessionId,
+        };
+        if (!this._connected) {
+            // Queue for later if not connected
+            this._pendingWrites.push(fullInteraction);
+            return;
+        }
+        this._pendingWrites.push(fullInteraction);
+        // Debounce writes
+        if (this._flushTimeout)
+            clearTimeout(this._flushTimeout);
+        this._flushTimeout = setTimeout(() => this._flush(), 500);
+    }
+    async _flush() {
+        if (this._pendingWrites.length === 0 || !this._collection)
+            return;
+        const interactions = [...this._pendingWrites];
+        this._pendingWrites = [];
+        try {
+            if (interactions.length === 1) {
+                await this._collection.insertOne(interactions[0]);
+            }
+            else {
+                await this._collection.insertMany(interactions);
+            }
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('Failed to write to MongoDB:', error);
+            logUnhandledError(error);
+            // Re-queue failed writes
+            this._pendingWrites.unshift(...interactions);
+        }
+    }
+    /**
+     * Flush all pending writes immediately
+     */
+    async flushSync() {
+        if (this._flushTimeout) {
+            clearTimeout(this._flushTimeout);
+            this._flushTimeout = undefined;
+        }
+        await this._flush();
+    }
+    /**
+     * Query interactions by tool name
+     */
+    async queryByToolName(toolName, sessionId) {
+        if (!this._collection)
+            return [];
+        await this.flushSync();
+        const query = { toolName };
+        if (sessionId)
+            query.sessionId = sessionId;
+        else
+            query.sessionId = this._sessionId;
+        return await this._collection.find(query).sort({ timestamp: 1 }).toArray();
+    }
+    /**
+     * Query interactions by element ref
+     */
+    async queryByElementRef(ref, sessionId) {
+        if (!this._collection)
+            return [];
+        await this.flushSync();
+        const query = { elementRef: ref };
+        if (sessionId)
+            query.sessionId = sessionId;
+        else
+            query.sessionId = this._sessionId;
+        return await this._collection.find(query).sort({ timestamp: 1 }).toArray();
+    }
+    /**
+     * Query interactions by URL
+     */
+    async queryByUrl(url, sessionId) {
+        if (!this._collection)
+            return [];
+        await this.flushSync();
+        const query = { url: { $regex: url, $options: 'i' } };
+        if (sessionId)
+            query.sessionId = sessionId;
+        else
+            query.sessionId = this._sessionId;
+        return await this._collection.find(query).sort({ timestamp: 1 }).toArray();
+    }
+    /**
+     * Get all interactions for current session
+     */
+    async getAllInteractions(sessionId) {
+        if (!this._collection)
+            return [];
+        await this.flushSync();
+        const query = { sessionId: sessionId || this._sessionId };
+        return await this._collection.find(query).sort({ timestamp: 1 }).toArray();
+    }
+    /**
+     * Get all sessions
+     */
+    async getAllSessions() {
+        if (!this._collection)
+            return [];
+        const sessions = await this._collection.distinct('sessionId');
+        return sessions;
+    }
+    /**
+     * Get interaction statistics
+     */
+    async getStatistics(sessionId) {
+        if (!this._collection)
+            return { totalInteractions: 0, toolCounts: {}, elementCounts: {}, urlCounts: {} };
+        await this.flushSync();
+        const query = { sessionId: sessionId || this._sessionId };
+        const interactions = await this._collection.find(query).toArray();
+        const toolCounts = {};
+        const elementCounts = {};
+        const urlCounts = {};
+        interactions.forEach(interaction => {
+            toolCounts[interaction.toolName] = (toolCounts[interaction.toolName] || 0) + 1;
+            elementCounts[interaction.elementRef] = (elementCounts[interaction.elementRef] || 0) + 1;
+            urlCounts[interaction.url] = (urlCounts[interaction.url] || 0) + 1;
+        });
+        return {
+            totalInteractions: interactions.length,
+            toolCounts,
+            elementCounts,
+            urlCounts,
+        };
+    }
+    /**
+     * Delete all interactions for a session
+     */
+    async deleteSession(sessionId) {
+        if (!this._collection)
+            return 0;
+        await this.flushSync();
+        const result = await this._collection.deleteMany({
+            sessionId: sessionId || this._sessionId
+        });
+        return result.deletedCount;
+    }
+    /**
+     * Clear all data from the collection (use with caution!)
+     */
+    async clearAll() {
+        if (!this._collection)
+            return;
+        await this.flushSync();
+        await this._collection.deleteMany({});
+    }
+}
+/**
+ * Create a MongoDB logger instance
+ */
+export async function createMongoDBLogger(config = {}) {
+    const logger = new MongoDBLogger(config);
+    await logger.connect();
+    return logger;
+}

package/lib/package.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import fs from 'fs';
+import path from 'path';
+import url from 'url';
+const __filename = url.fileURLToPath(import.meta.url);
+export const packageJSON = JSON.parse(fs.readFileSync(path.join(path.dirname(__filename), '..', 'package.json'), 'utf8'));