@ejazullah/browser-mcp 0.0.62 → 0.0.64

package/README.md

@@ -319,6 +319,14 @@ Enhanced Playwright MCP server supports following arguments. They can be provide
                                specified, a temporary directory will be created.
   --viewport-size <size>       specify browser viewport size in pixels, for
                                example "1280, 720"
+  --mcp-logs                   Enable verbose MCP/session transport logs in CLI
+                               output
+  --no-mcp-logs                Disable verbose MCP/session transport logs in
+                               CLI output
+  --mcp-heartbeat              Enable MCP streamable transport heartbeat (may
+                               close sessions on slow/long operations)
+  --no-mcp-heartbeat           Disable MCP streamable transport heartbeat
+                               (recommended for n8n item-by-item runs)
 ```
 
 <!--- End of options generated section -->
@@ -471,6 +479,34 @@ And then in MCP client config, set the `url` to the HTTP endpoint:
 
 If a client reconnects with a stale `mcp-session-id`, the server now recovers automatically for `POST` requests by creating a new session. If your client reports `Session not found`, reconnect and retry the request.
 
+### Streamable HTTP session behavior (n8n / CDP)
+
+When using Streamable HTTP (`/mcp`) with tools like n8n (especially item-by-item execution), requests may arrive without consistent `mcp-session-id` propagation.
+
+The server handles stale `mcp-session-id` for `POST` by creating a new session. If your client reuses an old session id, reconnect and initialize again before retrying tool calls.
+
+For n8n-style long-running operations, use:
+
+```bash
+npx @ejazullah/browser-mcp --port 8931 --mcp-logs --no-mcp-heartbeat
+```
+
+Use `--mcp-heartbeat` only when you explicitly want heartbeat-driven liveness checks.
+
+### CLI diagnostics
+
+- Enable verbose MCP logs in terminal:
+
+```bash
+npx @ejazullah/browser-mcp --port 8931 --mcp-logs
+```
+
+- Disable MCP logs explicitly:
+
+```bash
+npx @ejazullah/browser-mcp --port 8931 --no-mcp-logs
+```
+
 <details>
 <summary><b>Docker</b></summary>
 

package/lib/mcp/transport.js

@@ -128,37 +128,7 @@ async function handleSSE(serverBackendFactory, req, res, url, sessions) {
     res.statusCode = 405;
     res.end('Method not allowed');
 }
-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, runHeartbeat) {
-    const cdpSessionKey = resolveClientCdpSessionKey(req);
+async function handleStreamable(serverBackendFactory, req, res, sessions, runHeartbeat) {
     const sessionId = req.headers['mcp-session-id'];
     if (sessionId) {
         const transport = sessions.get(sessionId);
@@ -168,60 +138,18 @@ async function handleStreamable(serverBackendFactory, req, res, sessions, sessio
                 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 {
-            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);
+            return await transport.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, runHeartbeat);
                 sessions.set(sessionId, transport);
             }
@@ -230,7 +158,6 @@ async function handleStreamable(serverBackendFactory, req, res, sessions, sessio
             if (!transport.sessionId)
                 return;
             sessions.delete(transport.sessionId);
-            sessionCdpKeys.delete(transport.sessionId);
             testDebug(`delete http session: ${transport.sessionId}`);
         };
         await transport.handleRequest(req, res);
@@ -242,7 +169,6 @@ async function handleStreamable(serverBackendFactory, req, res, sessions, sessio
 function startHttpTransport(httpServer, serverBackendFactory, auth, runHeartbeat) {
     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
@@ -267,7 +193,7 @@ function startHttpTransport(httpServer, serverBackendFactory, auth, runHeartbeat
             if (url.pathname.startsWith('/sse'))
                 await handleSSE(serverBackendFactory, req, res, url, sseSessions);
             else
-                await handleStreamable(serverBackendFactory, req, res, streamableSessions, streamableSessionCdpKeys, runHeartbeat);
+                await handleStreamable(serverBackendFactory, req, res, streamableSessions, runHeartbeat);
         });
     });
     const url = httpAddressToString(httpServer.address());

package/lib/program.js

@@ -137,5 +137,25 @@ function setupExitWatchdog() {
     process.stdin.on('close', handleExit);
     process.on('SIGINT', handleExit);
     process.on('SIGTERM', handleExit);
+    const isSharedWorkerError = (err) => {
+        const msg = err?.message || String(err || '');
+        return msg.includes('shared_worker targets are not supported yet') || err?.targetInfo?.type === 'shared_worker' || msg.includes('type: "shared_worker"');
+    };
+    process.on('uncaughtException', (err) => {
+        if (isSharedWorkerError(err)) {
+            console.warn('[mcp] Ignoring Playwright shared_worker assertion error to prevent crash.');
+            return;
+        }
+        console.error('Uncaught Exception:', err);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (err) => {
+        if (isSharedWorkerError(err)) {
+            console.warn('[mcp] Ignoring Playwright shared_worker assertion error to prevent crash.');
+            return;
+        }
+        console.error('Unhandled Rejection:', err);
+        process.exit(1);
+    });
 }
 void program.parseAsync(process.argv);

package/package.json

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