@tontoko/fast-playwright-mcp 0.0.4

package/lib/manual-promise.js

@@ -0,0 +1,125 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/manual-promise.ts
+class ManualPromise extends Promise {
+  _resolve;
+  _reject;
+  _isDone;
+  constructor() {
+    let resolve;
+    let reject;
+    super((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this._isDone = false;
+    this._resolve = resolve;
+    this._reject = reject;
+  }
+  isDone() {
+    return this._isDone;
+  }
+  resolve(t) {
+    this._isDone = true;
+    this._resolve(t);
+  }
+  reject(e) {
+    this._isDone = true;
+    this._reject(e);
+  }
+  static get [Symbol.species]() {
+    return Promise;
+  }
+  get [Symbol.toStringTag]() {
+    return "ManualPromise";
+  }
+}
+
+class LongStandingScope {
+  _terminateError;
+  _closeError;
+  _terminatePromises = new Map;
+  _isClosed = false;
+  reject(error) {
+    this._isClosed = true;
+    this._terminateError = error;
+    for (const p of this._terminatePromises.keys()) {
+      p.resolve(error);
+    }
+  }
+  close(error) {
+    this._isClosed = true;
+    this._closeError = error;
+    for (const [p, frames] of this._terminatePromises) {
+      p.resolve(cloneError(error, frames));
+    }
+  }
+  isClosed() {
+    return this._isClosed;
+  }
+  static raceMultiple(scopes, promise) {
+    return Promise.race(scopes.map((s) => s.race(promise)));
+  }
+  race(promise) {
+    return this._race(Array.isArray(promise) ? promise : [promise], false);
+  }
+  safeRace(promise, defaultValue) {
+    return this._race([promise], true, defaultValue);
+  }
+  async _race(promises, safe, defaultValue) {
+    const terminatePromise = new ManualPromise;
+    const frames = captureRawStack();
+    if (this._terminateError) {
+      terminatePromise.resolve(this._terminateError);
+    }
+    if (this._closeError) {
+      terminatePromise.resolve(cloneError(this._closeError, frames));
+    }
+    this._terminatePromises.set(terminatePromise, frames);
+    try {
+      return await Promise.race([
+        terminatePromise.then((e) => safe ? defaultValue : Promise.reject(e)),
+        ...promises
+      ]);
+    } finally {
+      this._terminatePromises.delete(terminatePromise);
+    }
+  }
+}
+function cloneError(error, frames) {
+  const clone = new Error(error.message);
+  clone.name = error.name;
+  clone.stack = [`${error.name}:${error.message}`, ...frames].join(`
+`);
+  return clone;
+}
+function captureRawStack() {
+  const stackTraceLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 50;
+  const error = new Error("Stack trace capture");
+  const stack = error.stack ?? "";
+  Error.stackTraceLimit = stackTraceLimit;
+  return stack.split(`
+`);
+}
+export {
+  ManualPromise,
+  LongStandingScope
+};

package/lib/mcp/in-process-transport.js

@@ -0,0 +1,91 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/mcp/in-process-transport.ts
+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;
+  }
+  send(message, _options) {
+    if (!this._connected) {
+      throw new Error("Transport not connected");
+    }
+    this._serverTransport._receiveFromClient(message);
+    return Promise.resolve();
+  }
+  close() {
+    if (this._connected) {
+      this._connected = false;
+      this.onclose?.();
+      this._serverTransport.onclose?.();
+    }
+    return Promise.resolve();
+  }
+  onclose;
+  onerror;
+  onmessage;
+  sessionId;
+  setProtocolVersion;
+  _receiveFromServer(message, extra) {
+    this.onmessage?.(message, extra);
+  }
+}
+
+class InProcessServerTransport {
+  _clientTransport;
+  constructor(clientTransport) {
+    this._clientTransport = clientTransport;
+  }
+  start() {
+    if (!this._clientTransport) {
+      throw new Error("InProcessServerTransport: Client transport not available");
+    }
+    return Promise.resolve();
+  }
+  send(message, _options) {
+    this._clientTransport._receiveFromServer(message);
+    return Promise.resolve();
+  }
+  close() {
+    this.onclose?.();
+    return Promise.resolve();
+  }
+  onclose;
+  onerror;
+  onmessage;
+  sessionId;
+  setProtocolVersion;
+  _receiveFromClient(message, extra) {
+    this.onmessage?.(message, extra);
+  }
+}
+export {
+  InProcessTransport
+};

package/lib/mcp/proxy-backend.js

@@ -0,0 +1,127 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/mcp/proxy-backend.ts
+import { z } from "zod";
+import { logUnhandledError } from "../log.js";
+import { packageJSON } from "../package.js";
+import { defineTool } from "../tools/tool.js";
+
+class ProxyBackend {
+  name = "Playwright MCP Client Switcher";
+  version = packageJSON.version;
+  _clientFactories;
+  _currentClient;
+  _contextSwitchTool;
+  _tools = [];
+  _server;
+  constructor(clientFactories) {
+    this._clientFactories = clientFactories;
+    this._contextSwitchTool = this._defineContextSwitchTool();
+  }
+  async initialize(server) {
+    this._server = server;
+    await this._setCurrentClient(this._clientFactories[0]);
+  }
+  tools() {
+    if (this._clientFactories.length === 1) {
+      return this._tools;
+    }
+    return [...this._tools, this._contextSwitchTool.schema];
+  }
+  async callTool(schema, rawArguments) {
+    if (schema.name === this._contextSwitchTool.schema.name) {
+      return this._callContextSwitchTool(rawArguments);
+    }
+    const result = await this._currentClient?.callTool({
+      name: schema.name,
+      arguments: rawArguments
+    });
+    return result;
+  }
+  serverClosed() {
+    this._currentClient?.close().catch(logUnhandledError);
+  }
+  async _callContextSwitchTool(params) {
+    try {
+      const contextParams = params;
+      const factory = this._clientFactories.find((f) => f.name === contextParams.name);
+      if (!factory) {
+        throw new Error(`Unknown connection method: ${contextParams.name}`);
+      }
+      await this._setCurrentClient(factory);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `### Result
+Successfully changed connection method.
+`
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `### Result
+Error: ${error}
+` }],
+        isError: true
+      };
+    }
+  }
+  _defineContextSwitchTool() {
+    return defineTool({
+      capability: "core",
+      schema: {
+        name: "browser_connect",
+        title: "Connect to a browser context",
+        description: [
+          "Connect to a browser using one of the available methods:",
+          ...this._clientFactories.map((factory) => `- "${factory.name}": ${factory.description}`)
+        ].join(`
+`),
+        inputSchema: z.object({
+          name: z.enum(this._clientFactories.map((factory) => factory.name)).describe("The method to use to connect to the browser")
+        }),
+        type: "readOnly"
+      },
+      handle() {
+        throw new Error("Unreachable");
+      }
+    });
+  }
+  async _setCurrentClient(factory) {
+    await this._currentClient?.close();
+    if (!this._server) {
+      throw new Error("Server not initialized");
+    }
+    this._currentClient = await factory.create(this._server);
+    const tools = await this._currentClient.listTools();
+    this._tools = tools.tools.map((tool) => ({
+      name: tool.name,
+      title: tool.title ?? "",
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema ? z.any() : z.object({}),
+      type: tool.annotations?.readOnlyHint ? "readOnly" : "destructive"
+    }));
+  }
+}
+export {
+  ProxyBackend
+};

package/lib/mcp/server.js

@@ -0,0 +1,123 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import debug from "debug";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { logUnhandledError } from "../log.js";
+import { ManualPromise } from "../manual-promise.js";
+import { logRequest } from "../utils/request-logger.js";
+var serverDebug = debug("pw:mcp:server");
+async function connect(serverBackendFactory, transport, runHeartbeat) {
+  const backend = serverBackendFactory();
+  const server = createServer(backend, runHeartbeat);
+  await server.connect(transport);
+}
+function createServer(backend, runHeartbeat) {
+  const initializedPromise = new ManualPromise;
+  const server = new Server({ name: backend.name, version: backend.version }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+  server.setRequestHandler(ListToolsRequestSchema, () => {
+    const tools = backend.tools();
+    return {
+      tools: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema instanceof z.ZodType ? zodToJsonSchema(tool.inputSchema) : 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
+${messages.join(`
+`)}` }],
+      isError: true
+    });
+    const tools = backend.tools();
+    const tool = tools.find((t) => t.name === request.params.name);
+    if (!tool) {
+      return errorResult(`Error: Tool "${request.params.name}" not found`);
+    }
+    try {
+      logRequest(request.params.name, request.params.arguments ?? {});
+      return await backend.callTool(tool, 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;
+}
+var startHeartbeat = (server) => {
+  const beat = async () => {
+    try {
+      await Promise.race([
+        server.ping(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("ping timeout")), 5000))
+      ]);
+      setTimeout(beat, 3000);
+    } catch (error) {
+      serverDebug("Heartbeat ping failed:", error);
+      try {
+        await server.close();
+      } catch (closeError) {
+        serverDebug("Failed to close server after heartbeat failure:", closeError);
+      }
+    }
+  };
+  beat().catch((error) => {
+    serverDebug("Heartbeat initialization failed:", error);
+  });
+};
+function addServerListener(server, event, listener) {
+  const oldListener = server[`on${event}`];
+  server[`on${event}`] = () => {
+    oldListener?.();
+    listener();
+  };
+}
+export {
+  createServer,
+  connect
+};

package/lib/mcp/transport.js

@@ -0,0 +1,159 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/mcp/transport.ts
+import crypto from "node:crypto";
+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 debug from "debug";
+import { httpAddressToString, startHttpServer } from "../http-server.js";
+import { connect } from "./server.js";
+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 connect(serverBackendFactory, new StdioServerTransport, false);
+}
+var testDebug = debug("pw:mcp:test");
+var transportDebug = debug("pw:mcp:transport");
+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);
+  }
+  if (req.method === "GET") {
+    const transport = new SSEServerTransport("/sse", res);
+    sessions.set(transport.sessionId, transport);
+    testDebug(`create SSE session: ${transport.sessionId}`);
+    try {
+      await connect(serverBackendFactory, transport, false);
+    } catch (error) {
+      testDebug(`SSE session connection failed: ${transport.sessionId}`, error);
+      sessions.delete(transport.sessionId);
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.end("Connection failed");
+      }
+      return;
+    }
+    res.on("close", () => {
+      testDebug(`delete SSE session: ${transport.sessionId}`);
+      sessions.delete(transport.sessionId);
+    });
+    res.on("error", (error) => {
+      testDebug(`SSE session error: ${transport.sessionId}`, error);
+      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 (_httpSessionId) => {
+        testDebug(`create http session: ${transport.sessionId}`);
+        try {
+          await connect(serverBackendFactory, transport, true);
+          if (transport.sessionId) {
+            sessions.set(transport.sessionId, transport);
+          }
+        } catch (error) {
+          testDebug(`HTTP session initialization failed: ${transport.sessionId}`, error);
+        }
+      }
+    });
+    transport.onclose = () => {
+      if (!transport.sessionId) {
+        return;
+      }
+      sessions.delete(transport.sessionId);
+      testDebug(`delete http session: ${transport.sessionId}`);
+    };
+    try {
+      await transport.handleRequest(req, res);
+    } catch (error) {
+      testDebug("HTTP transport request handling failed", error);
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.end("Request handling failed");
+      }
+    }
+    return;
+  }
+  res.statusCode = 400;
+  res.end("Invalid request");
+}
+function startHttpTransport(httpServer, serverBackendFactory) {
+  const sseSessions = new Map;
+  const streamableSessions = new Map;
+  httpServer.on("request", async (req, res) => {
+    const url2 = new URL(`http://localhost${req.url}`);
+    if (url2.pathname.startsWith("/sse")) {
+      await handleSSE(serverBackendFactory, req, res, url2, sseSessions);
+    } else {
+      await handleStreamable(serverBackendFactory, req, res, streamableSessions);
+    }
+  });
+  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(`
+`);
+  transportDebug("Server listening:", message);
+}
+export {
+  start
+};

package/lib/package.js

@@ -0,0 +1,28 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/package.ts
+import fs from "node:fs";
+import path from "node:path";
+import url from "node:url";
+var __filename2 = url.fileURLToPath(import.meta.url);
+var packageJSON = JSON.parse(fs.readFileSync(path.join(path.dirname(__filename2), "..", "package.json"), "utf8"));
+export {
+  packageJSON
+};