@tontoko/fast-playwright-mcp 0.0.4

package/lib/generate-keys.js

@@ -0,0 +1,75 @@
+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/generate-keys.ts
+import { generateKeyPairSync, randomBytes } from "node:crypto";
+function generateMockKeyPair() {
+  const { privateKey: privateKeyObj, publicKey } = generateKeyPairSync("rsa", {
+    modulusLength: 2048,
+    publicKeyEncoding: {
+      type: "spki",
+      format: "pem"
+    },
+    privateKeyEncoding: {
+      type: "pkcs8",
+      format: "pem"
+    }
+  });
+  const privateKey = privateKeyObj;
+  const serialNumber = randomBytes(16).toString("hex");
+  const currentDate = new Date;
+  const expiryDate = new Date(currentDate.getTime() + 365 * 24 * 60 * 60 * 1000);
+  const certificate = generateSelfSignedCert(publicKey, serialNumber, currentDate, expiryDate);
+  return {
+    privateKey,
+    certificate
+  };
+}
+function loadOrGenerateKeys() {
+  const envPrivateKey = process.env.TEST_PRIVATE_KEY;
+  const envCertificate = process.env.TEST_CERTIFICATE;
+  if (envPrivateKey && envCertificate) {
+    return {
+      privateKey: envPrivateKey,
+      certificate: envCertificate
+    };
+  }
+  return getBackupTestKeys();
+}
+function getBackupTestKeys() {
+  return generateMockKeyPair();
+}
+function generateSelfSignedCert(publicKey, serialNumber, notBefore, notAfter) {
+  const mockCert = `-----BEGIN CERTIFICATE-----
+${Buffer.from(`
+Mock Certificate for Testing
+Serial: ${serialNumber}
+Valid from: ${notBefore.toISOString()}
+Valid to: ${notAfter.toISOString()}
+${publicKey}
+`).toString("base64").match(/.{1,64}/g)?.join(`
+`) || ""}
+-----END CERTIFICATE-----`;
+  return mockCert;
+}
+export {
+  loadOrGenerateKeys,
+  getBackupTestKeys,
+  generateMockKeyPair
+};

package/lib/http-server.js

@@ -0,0 +1,50 @@
+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/http-server.ts
+import assert from "node:assert/strict";
+import http from "node:http";
+async function startHttpServer(config) {
+  const { host, port } = config;
+  const httpServer = http.createServer();
+  await new Promise((resolve, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(port, host, () => {
+      resolve();
+      httpServer.removeListener("error", reject);
+    });
+  });
+  return httpServer;
+}
+function httpAddressToString(address) {
+  assert(address, "Could not bind server socket");
+  if (typeof address === "string") {
+    return address;
+  }
+  const resolvedPort = address.port;
+  let resolvedHost = address.family === "IPv4" ? address.address : `[${address.address}]`;
+  if (resolvedHost === "0.0.0.0" || resolvedHost === "[::]") {
+    resolvedHost = "localhost";
+  }
+  return `http://${resolvedHost}:${resolvedPort}`;
+}
+export {
+  startHttpServer,
+  httpAddressToString
+};

package/lib/in-process-client.js

@@ -0,0 +1,64 @@
+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/in-process-client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { ListRootsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserServerBackend } from "./browser-server-backend.js";
+import { InProcessTransport } from "./mcp/in-process-transport.js";
+import { createServer } from "./mcp/server.js";
+import { packageJSON } from "./package.js";
+
+class InProcessClientFactory {
+  name;
+  description;
+  _contextFactory;
+  _config;
+  constructor(contextFactory, config) {
+    this.name = contextFactory.name;
+    this.description = contextFactory.description;
+    this._contextFactory = contextFactory;
+    this._config = config;
+  }
+  async create(server) {
+    const client = new Client(server.getClientVersion() ?? {
+      name: this.name,
+      version: packageJSON.version
+    });
+    const clientCapabilities = server.getClientCapabilities();
+    if (clientCapabilities) {
+      client.registerCapabilities(clientCapabilities);
+    }
+    if (clientCapabilities?.roots) {
+      client.setRequestHandler(ListRootsRequestSchema, async () => {
+        return await server.listRoots();
+      });
+    }
+    const backend = new BrowserServerBackend(this._config, [
+      this._contextFactory
+    ]);
+    const delegate = createServer(backend, false);
+    await client.connect(new InProcessTransport(delegate));
+    await client.ping();
+    return client;
+  }
+}
+export {
+  InProcessClientFactory
+};

package/lib/index.js

@@ -0,0 +1,48 @@
+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/index.ts
+import { contextFactory } from "./browser-context-factory.js";
+import { BrowserServerBackend } from "./browser-server-backend.js";
+import { resolveConfig } from "./config.js";
+import { createServer } from "./mcp/server.js";
+function createConnection(userConfig = {}, contextGetter) {
+  const config = resolveConfig(userConfig);
+  const factory = contextGetter ? new SimpleBrowserContextFactory(contextGetter) : contextFactory(config);
+  return createServer(new BrowserServerBackend(config, [factory]), false);
+}
+
+class SimpleBrowserContextFactory {
+  name = "custom";
+  description = "Connect to a browser using a custom context getter";
+  _contextGetter;
+  constructor(contextGetter) {
+    this._contextGetter = contextGetter;
+  }
+  async createContext() {
+    const browserContext = await this._contextGetter();
+    return {
+      browserContext,
+      close: () => browserContext.close()
+    };
+  }
+}
+export {
+  createConnection
+};

package/lib/javascript.js

@@ -0,0 +1,90 @@
+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/javascript.ts
+function escapeWithQuotes(text, char = "'") {
+  const stringified = JSON.stringify(text);
+  const escapedText = extractEscapedContent(stringified);
+  return wrapWithCharacter(escapedText, char);
+}
+function extractEscapedContent(stringified) {
+  return stringified.substring(1, stringified.length - 1).replace(/\\"/g, '"');
+}
+function wrapWithCharacter(text, char) {
+  const replacements = {
+    "'": "'",
+    '"': '"',
+    "`": "`"
+  };
+  const replacement = replacements[char];
+  if (!replacement) {
+    throw new Error("Invalid escape char");
+  }
+  let result = text;
+  if (char === "'") {
+    result = text.replaceAll("'", "'");
+  } else if (char === '"') {
+    result = text.replaceAll('"', '"');
+  } else if (char === "`") {
+    result = text.replaceAll("`", "`");
+  }
+  return char + result + char;
+}
+function quote(text) {
+  return escapeWithQuotes(text, "'");
+}
+function formatObject(value, indent = "  ") {
+  if (typeof value === "string") {
+    return quote(value);
+  }
+  if (Array.isArray(value)) {
+    return formatArray(value);
+  }
+  if (typeof value === "object" && value !== null) {
+    return formatObjectValue(value, indent);
+  }
+  return String(value);
+}
+function formatArray(arr) {
+  return `[${arr.map((o) => formatObject(o)).join(", ")}]`;
+}
+function formatObjectValue(obj, indent) {
+  const keys = getValidObjectKeys(obj);
+  if (keys.length === 0) {
+    return "{}";
+  }
+  return buildObjectString(obj, keys, indent);
+}
+function getValidObjectKeys(obj) {
+  return Object.keys(obj).filter((key) => obj[key] !== undefined).sort((a, b) => a.localeCompare(b, "en", { numeric: true }));
+}
+function buildObjectString(obj, keys, indent) {
+  const tokens = keys.map((key) => `${key}: ${formatObject(obj[key])}`);
+  const separator = `,
+${indent}`;
+  const tokensJoined = tokens.join(separator);
+  return `{
+${indent}${tokensJoined}
+}`;
+}
+export {
+  quote,
+  formatObject,
+  escapeWithQuotes
+};

package/lib/log.js

@@ -0,0 +1,33 @@
+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/log.ts
+import debug from "debug";
+var errorsDebug = debug("pw:mcp:errors");
+var requestsDebug = debug("pw:mcp:requests");
+function logUnhandledError(error) {
+  errorsDebug(error);
+}
+var testDebug = debug("pw:mcp:test");
+var requestDebug = requestsDebug;
+export {
+  testDebug,
+  requestDebug,
+  logUnhandledError
+};

package/lib/loop/loop-claude.js

@@ -0,0 +1,247 @@
+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/loop/loop-claude.ts
+var model = "claude-sonnet-4-20250514";
+
+class ClaudeDelegate {
+  _anthropic;
+  async anthropic() {
+    if (!this._anthropic) {
+      const anthropic = await import("@anthropic-ai/sdk");
+      this._anthropic = new anthropic.Anthropic;
+    }
+    return this._anthropic;
+  }
+  createConversation(task, tools, oneShot) {
+    const llmTools = tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema
+    }));
+    if (!oneShot) {
+      llmTools.push({
+        name: "done",
+        description: "Call this tool when the task is complete.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      });
+    }
+    return {
+      messages: [
+        {
+          role: "user",
+          content: task
+        }
+      ],
+      tools: llmTools
+    };
+  }
+  async makeApiCall(conversation) {
+    const formattedData = this.formatConversationData(conversation);
+    const response = await this.callClaudeApi(formattedData.claudeMessages, formattedData.claudeTools);
+    return this.processApiResponse(conversation, response);
+  }
+  processApiResponse(conversation, response) {
+    return this.processResponseAndUpdateConversation(conversation, response);
+  }
+  processResponseAndUpdateConversation(conversation, response) {
+    const llmToolCalls = this.extractToolCallsFromResponse(response);
+    this.addAssistantMessageToConversation(conversation, response, llmToolCalls);
+    return llmToolCalls;
+  }
+  formatConversationData(conversation) {
+    return {
+      claudeMessages: this.convertMessagesToClaudeFormat(conversation.messages),
+      claudeTools: this.convertToolsToClaudeFormat(conversation.tools)
+    };
+  }
+  convertMessagesToClaudeFormat(messages) {
+    return this.buildClaudeMessagesFromConversation(messages);
+  }
+  buildClaudeMessagesFromConversation(messages) {
+    const claudeMessages = [];
+    for (const message of messages) {
+      this.processMessageByType(claudeMessages, message);
+    }
+    return claudeMessages;
+  }
+  processMessageByType(claudeMessages, message) {
+    this.delegateMessageProcessing(claudeMessages, message);
+  }
+  delegateMessageProcessing(claudeMessages, message) {
+    switch (message.role) {
+      case "user":
+        this.addUserMessage(claudeMessages, message);
+        break;
+      case "assistant":
+        this.addAssistantMessage(claudeMessages, message);
+        break;
+      case "tool":
+        this.addToolResultMessage(claudeMessages, message);
+        break;
+      default:
+        break;
+    }
+  }
+  addUserMessage(claudeMessages, message) {
+    if (message.role === "user") {
+      claudeMessages.push({
+        role: "user",
+        content: message.content
+      });
+    }
+  }
+  addAssistantMessage(claudeMessages, message) {
+    if (message.role !== "assistant") {
+      return;
+    }
+    const content = this.buildAssistantContent(message);
+    claudeMessages.push({
+      role: "assistant",
+      content
+    });
+  }
+  buildAssistantContent(message) {
+    const content = [];
+    this.populateContentBlocks(content, message);
+    return content;
+  }
+  populateContentBlocks(content, message) {
+    this.addTextContentIfPresent(content, message.content);
+    this.addToolCallsIfPresent(content, message);
+  }
+  addTextContentIfPresent(content, textContent) {
+    if (!textContent) {
+      return;
+    }
+    content.push({
+      type: "text",
+      text: textContent,
+      citations: []
+    });
+  }
+  addToolCallsIfPresent(content, message) {
+    if (message.role !== "assistant" || !message.toolCalls) {
+      return;
+    }
+    this.addToolCallsToContent(content, message.toolCalls);
+  }
+  addToolCallsToContent(content, toolCalls) {
+    for (const toolCall of toolCalls) {
+      content.push({
+        type: "tool_use",
+        id: toolCall.id,
+        name: toolCall.name,
+        input: toolCall.arguments
+      });
+    }
+  }
+  addToolResultMessage(claudeMessages, message) {
+    if (message.role !== "tool") {
+      return;
+    }
+    const toolResult = this.createToolResultBlock(message);
+    this.appendToolResultToMessages(claudeMessages, toolResult);
+  }
+  createToolResultBlock(message) {
+    return {
+      type: "tool_result",
+      tool_use_id: message.toolCallId,
+      content: message.content,
+      is_error: message.isError
+    };
+  }
+  appendToolResultToMessages(claudeMessages, toolResult) {
+    const lastMessage = claudeMessages.at(-1);
+    this.handleToolResultAppending(claudeMessages, lastMessage, toolResult);
+  }
+  handleToolResultAppending(claudeMessages, lastMessage, toolResult) {
+    if (this.canAddToExistingToolResults(lastMessage)) {
+      this.addToExistingMessage(lastMessage, toolResult);
+    } else {
+      this.createNewToolResultMessage(claudeMessages, toolResult);
+    }
+  }
+  addToExistingMessage(lastMessage, toolResult) {
+    lastMessage.content.push(toolResult);
+  }
+  createNewToolResultMessage(claudeMessages, toolResult) {
+    claudeMessages.push({
+      role: "user",
+      content: [toolResult]
+    });
+  }
+  canAddToExistingToolResults(lastMessage) {
+    return !!(lastMessage && lastMessage.role === "user" && Array.isArray(lastMessage.content));
+  }
+  convertToolsToClaudeFormat(tools) {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputSchema
+    }));
+  }
+  async callClaudeApi(claudeMessages, claudeTools) {
+    const anthropic = await this.anthropic();
+    return await anthropic.messages.create({
+      model,
+      max_tokens: 1e4,
+      messages: claudeMessages,
+      tools: claudeTools
+    });
+  }
+  extractToolCallsFromResponse(response) {
+    const toolCalls = response.content.filter((block) => block.type === "tool_use");
+    return toolCalls.map((toolCall) => ({
+      name: toolCall.name,
+      arguments: toolCall.input,
+      id: toolCall.id
+    }));
+  }
+  addAssistantMessageToConversation(conversation, response, llmToolCalls) {
+    const textContent = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+    conversation.messages.push({
+      role: "assistant",
+      content: textContent,
+      toolCalls: llmToolCalls.length > 0 ? llmToolCalls : undefined
+    });
+  }
+  addToolResults(conversation, results) {
+    for (const result of results) {
+      conversation.messages.push({
+        role: "tool",
+        toolCallId: result.toolCallId,
+        content: result.content,
+        isError: result.isError
+      });
+    }
+  }
+  checkDoneToolCall(toolCall) {
+    if (toolCall.name === "done") {
+      return toolCall.arguments.result;
+    }
+    return null;
+  }
+}
+export {
+  ClaudeDelegate
+};