@ejazullah/browser-mcp 0.0.59 → 0.0.61

package/lib/mcp/transport.js

@@ -128,7 +128,37 @@ async function handleSSE(serverBackendFactory, req, res, url, sessions) {
     res.statusCode = 405;
     res.end('Method not allowed');
 }
-async function handleStreamable(serverBackendFactory, req, res, sessions) {
+function cdpSessionKeyFromUrl(value) {
+    try {
+        const parsed = new URL(value);
+        const match = parsed.pathname.match(/\/devtools\/([^/]+)/i);
+        return match?.[1];
+    }
+    catch {
+        const match = value.match(/\/devtools\/([^/]+)/i);
+        return match?.[1];
+    }
+}
+function resolveClientCdpSessionKey(req) {
+    const explicitSessionId = req.headers['x-cdp-session-id'];
+    if (explicitSessionId)
+        return explicitSessionId;
+    const cdpUrl = req.headers['x-cdp-url']
+        ?? req.headers['x-cdp-endpoint']
+        ?? req.headers['x-browser-url'];
+    if (!cdpUrl)
+        return undefined;
+    return cdpSessionKeyFromUrl(cdpUrl);
+}
+function findSessionIdByCdpKey(sessionCdpKeys, sessions, cdpSessionKey) {
+    for (const [knownSessionId, knownCdpSessionKey] of sessionCdpKeys.entries()) {
+        if (knownCdpSessionKey === cdpSessionKey && sessions.has(knownSessionId))
+            return knownSessionId;
+    }
+    return undefined;
+}
+async function handleStreamable(serverBackendFactory, req, res, sessions, sessionCdpKeys) {
+    const cdpSessionKey = resolveClientCdpSessionKey(req);
     const sessionId = req.headers['mcp-session-id'];
     if (sessionId) {
         const transport = sessions.get(sessionId);
@@ -138,18 +168,60 @@ async function handleStreamable(serverBackendFactory, req, res, sessions) {
                 res.end('Session not found');
                 return;
             }
+            if (cdpSessionKey) {
+                const matchedSessionId = findSessionIdByCdpKey(sessionCdpKeys, sessions, cdpSessionKey);
+                if (matchedSessionId) {
+                    const matchedTransport = sessions.get(matchedSessionId);
+                    testDebug(`stale mcp-session-id ${sessionId}, reusing cdp-matched session: ${matchedSessionId} (${cdpSessionKey})`);
+                    return await matchedTransport.handleRequest(req, res);
+                }
+            }
+            if (sessions.size === 1) {
+                const [singleSessionId, singleTransport] = sessions.entries().next().value;
+                testDebug(`stale mcp-session-id ${sessionId}, reusing single active session: ${singleSessionId}`);
+                return await singleTransport.handleRequest(req, res);
+            }
             delete req.headers['mcp-session-id'];
             testDebug(`stale http session id: ${sessionId}, creating a new session`);
         }
         else {
-            return await transport.handleRequest(req, res);
+            if (cdpSessionKey) {
+                const knownCdpSessionKey = sessionCdpKeys.get(sessionId);
+                if (knownCdpSessionKey && knownCdpSessionKey !== cdpSessionKey) {
+                    delete req.headers['mcp-session-id'];
+                    testDebug(`browser changed for mcp session ${sessionId} (${knownCdpSessionKey} -> ${cdpSessionKey}), creating a new session`);
+                }
+                else {
+                    if (!knownCdpSessionKey)
+                        sessionCdpKeys.set(sessionId, cdpSessionKey);
+                    return await transport.handleRequest(req, res);
+                }
+            }
+            else {
+                return await transport.handleRequest(req, res);
+            }
+        }
+    }
+    if (!sessionId && cdpSessionKey && req.method === 'POST') {
+        const matchedSessionId = findSessionIdByCdpKey(sessionCdpKeys, sessions, cdpSessionKey);
+        if (matchedSessionId) {
+            const matchedTransport = sessions.get(matchedSessionId);
+            testDebug(`missing mcp-session-id, reusing cdp-matched session: ${matchedSessionId} (${cdpSessionKey})`);
+            return await matchedTransport.handleRequest(req, res);
         }
     }
+    if (!sessionId && req.method === 'POST' && sessions.size === 1) {
+        const [singleSessionId, singleTransport] = sessions.entries().next().value;
+        testDebug(`missing mcp-session-id, reusing single active session: ${singleSessionId}`);
+        return await singleTransport.handleRequest(req, res);
+    }
     if (req.method === 'POST') {
         const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => crypto.randomUUID(),
             onsessioninitialized: async (sessionId) => {
                 testDebug(`create http session: ${transport.sessionId}`);
+                if (cdpSessionKey)
+                    sessionCdpKeys.set(sessionId, cdpSessionKey);
                 await mcpServer.connect(serverBackendFactory, transport, true);
                 sessions.set(sessionId, transport);
             }
@@ -158,6 +230,7 @@ async function handleStreamable(serverBackendFactory, req, res, sessions) {
             if (!transport.sessionId)
                 return;
             sessions.delete(transport.sessionId);
+            sessionCdpKeys.delete(transport.sessionId);
             testDebug(`delete http session: ${transport.sessionId}`);
         };
         await transport.handleRequest(req, res);
@@ -169,6 +242,7 @@ async function handleStreamable(serverBackendFactory, req, res, sessions) {
 function startHttpTransport(httpServer, serverBackendFactory, auth) {
     const sseSessions = new Map();
     const streamableSessions = new Map();
+    const streamableSessionCdpKeys = new Map();
     // Configure CORS with permissive settings for MCP tools
     const corsHandler = cors({
         origin: true, // Allow all origins
@@ -193,7 +267,7 @@ function startHttpTransport(httpServer, serverBackendFactory, auth) {
             if (url.pathname.startsWith('/sse'))
                 await handleSSE(serverBackendFactory, req, res, url, sseSessions);
             else
-                await handleStreamable(serverBackendFactory, req, res, streamableSessions);
+                await handleStreamable(serverBackendFactory, req, res, streamableSessions, streamableSessionCdpKeys);
         });
     });
     const url = httpAddressToString(httpServer.address());

package/lib/program.js

@@ -16,6 +16,7 @@
 import { program, Option } from 'commander';
 // @ts-ignore
 import { startTraceViewerServer } from 'playwright-core/lib/server';
+import debug from 'debug';
 import * as mcpTransport from './mcp/transport.js';
 import { commaSeparatedList, resolveCLIConfig, semicolonSeparatedList } from './config.js';
 import { buildAuthConfig } from './auth.js';
@@ -25,6 +26,28 @@ import { BrowserServerBackend } from './browserServerBackend.js';
 import { Context } from './context.js';
 import { contextFactory } from './browserContextFactory.js';
 import { runLoopTools } from './loopTools/main.js';
+const mcpDebugNamespace = 'pw:mcp:*';
+function setMcpDebugLogging(enabled) {
+    if (enabled === undefined)
+        return;
+    const current = process.env.DEBUG ?? '';
+    const namespaces = current.split(',').map(token => token.trim()).filter(Boolean);
+    if (enabled) {
+        if (!namespaces.includes(mcpDebugNamespace)) {
+            namespaces.push(mcpDebugNamespace);
+            process.env.DEBUG = namespaces.join(',');
+            debug.enable(process.env.DEBUG);
+        }
+        // eslint-disable-next-line no-console
+        console.error(`[mcp] verbose logs enabled (${mcpDebugNamespace})`);
+        return;
+    }
+    const filtered = namespaces.filter(ns => ns !== mcpDebugNamespace && !ns.startsWith('pw:mcp:'));
+    process.env.DEBUG = filtered.join(',');
+    debug.enable(process.env.DEBUG);
+    // eslint-disable-next-line no-console
+    console.error('[mcp] verbose logs disabled');
+}
 program
     .version('Version ' + packageJSON.version)
     .name(packageJSON.name)
@@ -53,6 +76,8 @@ program
     .option('--user-agent <ua string>', 'specify user agent string')
     .option('--user-data-dir <path>', 'path to the user data directory. If not specified, a temporary directory will be created.')
     .option('--viewport-size <size>', 'specify browser viewport size in pixels, for example "1280, 720"')
+    .option('--mcp-logs', 'Enable verbose MCP/session transport logs in CLI output')
+    .option('--no-mcp-logs', 'Disable verbose MCP/session transport logs in CLI output')
     .option('--mongodb-url <url>', 'MongoDB connection URL. Example: mongodb://localhost:27017')
     .option('--mongodb-db <name>', 'MongoDB database name. Default: playwright_mcp')
     .option('--mongodb-collection <name>', 'MongoDB collection name. Default: element_interactions')
@@ -67,6 +92,7 @@ program
     .addOption(new Option('--vision', 'Legacy option, use --caps=vision instead').hideHelp())
     .action(async (options) => {
     setupExitWatchdog();
+    setMcpDebugLogging(options.mcpLogs);
     if (options.vision) {
         // eslint-disable-next-line no-console
         console.error('The --vision option is deprecated, use --caps=vision instead');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ejazullah/browser-mcp",
-  "version": "0.0.59",
+  "version": "0.0.61",
   "description": "@ejazullah/browser-mcp - Enhanced Playwright Tools for MCP with CDP Support",
   "type": "module",
   "repository": {