@wordbricks/playwright-mcp 0.1.25 → 0.1.27

package/lib/mcp/transport.js

@@ -0,0 +1,188 @@
+/**
+ * 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 { 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";
+export async function start(serverBackendFactory, options) {
+    if (options.port !== undefined) {
+        const httpServer = await startHttpServer(options);
+        startHttpTransport(httpServer, serverBackendFactory);
+    }
+    else {
+        await startStdioTransport(serverBackendFactory);
+    }
+}
+async function startStdioTransport(serverBackendFactory) {
+    await mcpServer.connect(serverBackendFactory, new StdioServerTransport(), false);
+}
+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")) {
+        res.writeHead(415).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Unsupported Media Type: Content-Type must be application/json",
+            },
+            id: null,
+        }));
+        return;
+    }
+    const parsedCt = contentType.parse(ct);
+    const encoding = parsedCt.parameters.charset;
+    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;
+    if (body && isJSONRPCRequest(msg) && isInitializeRequest(msg)) {
+        const requestedVersion = msg.params.protocolVersion;
+        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion)
+            ? requestedVersion
+            : LATEST_PROTOCOL_VERSION;
+        const headers = {
+            "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 response = {
+            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`);
+        res.end();
+        return;
+    }
+    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 (!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");
+}
+// 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"];
+    if (sessionId) {
+        const transport = sessions.get(sessionId);
+        if (!transport) {
+            res.statusCode = 404;
+            res.end("Session not found");
+            return;
+        }
+        if (req.method === "POST")
+            return await handleStreamableReinitiate(req, res, transport, serverBackendFactory, sessionId, serverInfos);
+        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}`);
+                const serverInfo = await mcpServer.connect(serverBackendFactory, transport, false);
+                sessions.set(sessionId, transport);
+                serverInfos.set(sessionId, serverInfo);
+            },
+        });
+        transport.onclose = () => {
+            if (!transport.sessionId)
+                return;
+            sessions.delete(transport.sessionId);
+            serverInfos.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) {
+    const sseSessions = new Map();
+    const streamableSessions = new Map();
+    const streamableServerInfos = new Map();
+    httpServer.on("request", async (req, res) => {
+        const url = new URL(`http://localhost${req.url}`);
+        if (url.pathname.startsWith("/sse"))
+            await handleSSE(serverBackendFactory, req, res, url, sseSessions);
+        else
+            await handleStreamable(serverBackendFactory, req, res, streamableSessions, streamableServerInfos);
+    });
+    const url = httpAddressToString(httpServer.address());
+    const message = [
+        `Listening on ${url}`,
+        "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.",
+    ].join("\n");
+    // eslint-disable-next-line no-console
+    console.error(message);
+}