@wordbricks/playwright-mcp 0.1.20 → 0.1.22

package/lib/mcp/server.js

@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import debug from 'debug';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import ms from 'ms';
-import { ManualPromise } from '../utils/manualPromise.js';
-import { logUnhandledError } from '../utils/log.js';
-const serverDebug = debug('pw:mcp:server');
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import debug from "debug";
+import ms from "ms";
+import { logUnhandledError } from "../utils/log.js";
+import { ManualPromise } from "../utils/manualPromise.js";
+const serverDebug = debug("pw:mcp:server");
 export async function connect(serverBackendFactory, transport, runHeartbeat) {
     const backend = serverBackendFactory();
     const server = createServer(backend, runHeartbeat);
@@ -31,17 +31,17 @@ export function createServer(backend, runHeartbeat) {
     const server = new Server({ name: backend.name, version: backend.version }, {
         capabilities: {
             tools: {},
-        }
+        },
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
-        serverDebug('listTools');
+        serverDebug("listTools");
         await initializedPromise;
         const tools = await backend.listTools();
         return { tools };
     });
     let heartbeatRunning = false;
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        serverDebug('callTool', request);
+        serverDebug("callTool", request);
         await initializedPromise;
         if (runHeartbeat && !heartbeatRunning) {
             heartbeatRunning = true;
@@ -52,26 +52,31 @@ export function createServer(backend, runHeartbeat) {
         }
         catch (error) {
             return {
-                content: [{ type: 'text', text: '### Result\n' + String(error) }],
+                content: [{ type: "text", text: "### Result\n" + String(error) }],
                 isError: true,
             };
         }
     });
-    addServerListener(server, 'initialized', () => {
-        backend.initialize?.(server).then(() => initializedPromise.resolve()).catch(logUnhandledError);
+    addServerListener(server, "initialized", () => {
+        backend
+            .initialize?.(server)
+            .then(() => initializedPromise.resolve())
+            .catch(logUnhandledError);
     });
-    addServerListener(server, 'close', () => backend.serverClosed?.());
+    addServerListener(server, "close", () => backend.serverClosed?.());
     return server;
 }
 const startHeartbeat = (server) => {
     const beat = () => {
-        serverDebug('Health check...');
+        serverDebug("Health check...");
         Promise.race([
             server.ping(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('ping timeout')), ms('5s'))),
-        ]).then(() => {
-            setTimeout(beat, ms('3s'));
-        }).catch(() => {
+            new Promise((_, reject) => setTimeout(() => reject(new Error("ping timeout")), ms("5s"))),
+        ])
+            .then(() => {
+            setTimeout(beat, ms("3s"));
+        })
+            .catch(() => {
             void server.close();
         });
     };

package/lib/mcp/tool.js

@@ -13,18 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { z } from 'zod';
-const typesWithIntent = ['action', 'assertion', 'input'];
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+const typesWithIntent = ["action", "assertion", "input"];
 export function toMcpTool(tool, options) {
-    const inputSchema = options?.addIntent && typesWithIntent.includes(tool.type) ? tool.inputSchema.extend({
-        intent: z.string().describe('The intent of the call, for example the test step description plan idea')
-    }) : tool.inputSchema;
-    const readOnly = tool.type === 'readOnly' || tool.type === 'assertion';
+    const inputSchema = options?.addIntent && typesWithIntent.includes(tool.type)
+        ? tool.inputSchema.extend({
+            intent: z
+                .string()
+                .describe("The intent of the call, for example the test step description plan idea"),
+        })
+        : tool.inputSchema;
+    const readOnly = tool.type === "readOnly" || tool.type === "assertion";
     return {
         name: tool.name,
         description: tool.description,
-        inputSchema: zodToJsonSchema(inputSchema, { strictUnions: true }),
+        inputSchema: zodToJsonSchema(inputSchema, {
+            strictUnions: true,
+        }),
         annotations: {
             title: tool.title,
             readOnlyHint: readOnly,

package/lib/mcp/transport.js

@@ -13,19 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import crypto from 'crypto';
-import debug from 'debug';
-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 { SUPPORTED_PROTOCOL_VERSIONS, LATEST_PROTOCOL_VERSION, isInitializeRequest, isJSONRPCRequest } from '@modelcontextprotocol/sdk/types.js';
-import contentType from 'content-type';
-import getRawBody from 'raw-body';
-import { pipe } from '@fxts/core';
-import { httpAddressToString, startHttpServer } from '../utils/httpServer.js';
-import * as mcpServer from './server.js';
+import { pipe } from "@fxts/core";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest, isJSONRPCRequest, LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, } from "@modelcontextprotocol/sdk/types.js";
+import contentType from "content-type";
+import crypto from "crypto";
+import debug from "debug";
+import getRawBody from "raw-body";
+import { httpAddressToString, startHttpServer } from "../utils/httpServer.js";
+import * as mcpServer from "./server.js";
 // @see node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
-const MAXIMUM_MESSAGE_SIZE = '4mb';
+const MAXIMUM_MESSAGE_SIZE = "4mb";
 export async function start(serverBackendFactory, options) {
     if (options.port !== undefined) {
         const httpServer = await startHttpServer(options);
@@ -38,17 +38,17 @@ export async function start(serverBackendFactory, options) {
 async function startStdioTransport(serverBackendFactory) {
     await mcpServer.connect(serverBackendFactory, new StdioServerTransport(), false);
 }
-const testDebug = debug('pw:mcp:test');
+const testDebug = debug("pw:mcp:test");
 async function handleStreamableReinitiate(req, res, transport, serverBackendFactory, sessionId, serverInfos) {
-    const ct = req.headers['content-type'];
-    if (!ct || !ct.includes('application/json')) {
+    const ct = req.headers["content-type"];
+    if (!ct || !ct.includes("application/json")) {
         res.writeHead(415).end(JSON.stringify({
-            jsonrpc: '2.0',
+            jsonrpc: "2.0",
             error: {
                 code: -32000,
-                message: 'Unsupported Media Type: Content-Type must be application/json'
+                message: "Unsupported Media Type: Content-Type must be application/json",
             },
-            id: null
+            id: null,
         }));
         return;
     }
@@ -57,28 +57,35 @@ async function handleStreamableReinitiate(req, res, transport, serverBackendFact
     const body = await pipe(getRawBody(req, {
         limit: MAXIMUM_MESSAGE_SIZE,
         encoding,
-    }), raw => raw.toString(), JSON.parse);
-    const msg = Array.isArray(body) ? (body.length === 1 ? body[0] : undefined) : body;
+    }), (raw) => raw.toString(), JSON.parse);
+    const msg = Array.isArray(body)
+        ? body.length === 1
+            ? body[0]
+            : undefined
+        : body;
     if (body && isJSONRPCRequest(msg) && isInitializeRequest(msg)) {
         const requestedVersion = msg.params.protocolVersion;
-        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
+        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion)
+            ? requestedVersion
+            : LATEST_PROTOCOL_VERSION;
         const headers = {
-            'Content-Type': 'text/event-stream',
-            'Mcp-Session-Id': transport.sessionId
+            "Content-Type": "text/event-stream",
+            "Mcp-Session-Id": transport.sessionId,
         };
         res.writeHead(200, headers);
-        const info = serverInfos.get(sessionId) || (() => {
-            const backend = serverBackendFactory();
-            return { name: backend.name, version: backend.version };
-        })();
+        const info = serverInfos.get(sessionId) ||
+            (() => {
+                const backend = serverBackendFactory();
+                return { name: backend.name, version: backend.version };
+            })();
         const response = {
-            jsonrpc: '2.0',
+            jsonrpc: "2.0",
             id: msg.id,
             result: {
                 protocolVersion,
                 capabilities: { tools: {} },
                 serverInfo: info,
-            }
+            },
         };
         res.write(`event: message\n`);
         res.write(`data: ${JSON.stringify(response)}\n\n`);
@@ -88,48 +95,48 @@ async function handleStreamableReinitiate(req, res, transport, serverBackendFact
     return await transport.handleRequest(req, res, body);
 }
 async function handleSSE(serverBackendFactory, req, res, url, sessions) {
-    if (req.method === 'POST') {
-        const sessionId = url.searchParams.get('sessionId');
+    if (req.method === "POST") {
+        const sessionId = url.searchParams.get("sessionId");
         if (!sessionId) {
             res.statusCode = 400;
-            return res.end('Missing sessionId');
+            return res.end("Missing sessionId");
         }
         const transport = sessions.get(sessionId);
         if (!transport) {
             res.statusCode = 404;
-            return res.end('Session not found');
+            return res.end("Session not found");
         }
         return await transport.handlePostMessage(req, res);
     }
-    else if (req.method === 'GET') {
-        const transport = new SSEServerTransport('/sse', 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', () => {
+        res.on("close", () => {
             testDebug(`delete SSE session: ${transport.sessionId}`);
             sessions.delete(transport.sessionId);
         });
         return;
     }
     res.statusCode = 405;
-    res.end('Method not allowed');
+    res.end("Method not allowed");
 }
 // Streamable transport: 'initialize' handling per MCP Lifecycle (Initialization) https://modelcontextprotocol.io/specification/draft/basic/lifecycle#initialization
 async function handleStreamable(serverBackendFactory, req, res, sessions, serverInfos) {
-    const sessionId = req.headers['mcp-session-id'];
+    const sessionId = req.headers["mcp-session-id"];
     if (sessionId) {
         const transport = sessions.get(sessionId);
         if (!transport) {
             res.statusCode = 404;
-            res.end('Session not found');
+            res.end("Session not found");
             return;
         }
-        if (req.method === 'POST')
+        if (req.method === "POST")
             return await handleStreamableReinitiate(req, res, transport, serverBackendFactory, sessionId, serverInfos);
         return await transport.handleRequest(req, res);
     }
-    if (req.method === 'POST') {
+    if (req.method === "POST") {
         const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => crypto.randomUUID(),
             onsessioninitialized: async (sessionId) => {
@@ -137,7 +144,7 @@ async function handleStreamable(serverBackendFactory, req, res, sessions, server
                 const serverInfo = await mcpServer.connect(serverBackendFactory, transport, false);
                 sessions.set(sessionId, transport);
                 serverInfos.set(sessionId, serverInfo);
-            }
+            },
         });
         transport.onclose = () => {
             if (!transport.sessionId)
@@ -150,15 +157,15 @@ async function handleStreamable(serverBackendFactory, req, res, sessions, server
         return;
     }
     res.statusCode = 400;
-    res.end('Invalid request');
+    res.end("Invalid request");
 }
 function startHttpTransport(httpServer, serverBackendFactory) {
     const sseSessions = new Map();
     const streamableSessions = new Map();
     const streamableServerInfos = new Map();
-    httpServer.on('request', async (req, res) => {
+    httpServer.on("request", async (req, res) => {
         const url = new URL(`http://localhost${req.url}`);
-        if (url.pathname.startsWith('/sse'))
+        if (url.pathname.startsWith("/sse"))
             await handleSSE(serverBackendFactory, req, res, url, sseSessions);
         else
             await handleStreamable(serverBackendFactory, req, res, streamableSessions, streamableServerInfos);
@@ -166,16 +173,16 @@ function startHttpTransport(httpServer, serverBackendFactory) {
     const url = httpAddressToString(httpServer.address());
     const message = [
         `Listening on ${url}`,
-        'Put this in your client config:',
+        "Put this in your client config:",
         JSON.stringify({
-            'mcpServers': {
-                'playwright': {
-                    'url': `${url}/mcp`
-                }
-            }
+            mcpServers: {
+                playwright: {
+                    url: `${url}/mcp`,
+                },
+            },
         }, undefined, 2),
-        'For legacy SSE transport support, you can use the /sse endpoint instead.',
-    ].join('\n');
+        "For legacy SSE transport support, you can use the /sse endpoint instead.",
+    ].join("\n");
     // eslint-disable-next-line no-console
     console.error(message);
 }