@tontoko/fast-playwright-mcp 0.0.4

package/lib/browser-server-backend.js

@@ -0,0 +1,139 @@
+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/browser-server-backend.ts
+import { fileURLToPath } from "node:url";
+import debug from "debug";
+import { z } from "zod";
+import { Context } from "./context.js";
+import { logUnhandledError } from "./log.js";
+import { packageJSON } from "./package.js";
+import { Response } from "./response.js";
+import { SessionLog } from "./session-log.js";
+import { defineTool } from "./tools/tool.js";
+import { filteredTools } from "./tools.js";
+var backendDebug = debug("pw:mcp:backend");
+
+class BrowserServerBackend {
+  name = "Playwright";
+  version = packageJSON.version;
+  _tools;
+  _context;
+  _sessionLog;
+  _config;
+  _browserContextFactory;
+  constructor(config, factories) {
+    this._config = config;
+    this._browserContextFactory = factories[0];
+    this._tools = filteredTools(config);
+    if (factories.length > 1) {
+      this._tools.push(this._defineContextSwitchTool(factories));
+    }
+  }
+  async initialize(server) {
+    const capabilities = server.getClientCapabilities();
+    let rootPath;
+    if (capabilities.roots && (server.getClientVersion()?.name === "Visual Studio Code" || server.getClientVersion()?.name === "Visual Studio Code - Insiders")) {
+      const { roots } = await server.listRoots();
+      const firstRootUri = roots[0]?.uri;
+      const url = firstRootUri ? new URL(firstRootUri) : undefined;
+      rootPath = url ? fileURLToPath(url) : undefined;
+    }
+    this._sessionLog = this._config.saveSession ? await SessionLog.create(this._config, rootPath) : undefined;
+    this._context = new Context({
+      tools: this._tools,
+      config: this._config,
+      browserContextFactory: this._browserContextFactory,
+      sessionLog: this._sessionLog,
+      clientInfo: { ...server.getClientVersion(), rootPath }
+    });
+  }
+  tools() {
+    return this._tools.map((tool) => tool.schema);
+  }
+  async callTool(schema, rawArguments) {
+    if (!this._context) {
+      throw new Error("Context not initialized. Call initialize() first.");
+    }
+    const context = this._context;
+    const parsedArguments = schema.inputSchema.parse(rawArguments || {});
+    const response = new Response(context, schema.name, parsedArguments, parsedArguments.expectation);
+    const matchedTool = this._tools.find((t) => t.schema.name === schema.name);
+    if (!matchedTool) {
+      throw new Error(`Tool not found: ${schema.name}`);
+    }
+    context.setRunningTool(true);
+    try {
+      await matchedTool.handle(context, parsedArguments, response);
+      await response.finish();
+      this._sessionLog?.logResponse(response);
+    } catch (error) {
+      backendDebug(`Error executing tool ${schema.name}:`, error);
+      response.addError(String(error));
+    } finally {
+      context.setRunningTool(false);
+    }
+    return response.serialize();
+  }
+  serverClosed() {
+    this._context?.dispose().catch(logUnhandledError);
+  }
+  _defineContextSwitchTool(factories) {
+    const self = this;
+    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:",
+          ...factories.map((factory) => `- "${factory.name}": ${factory.description}`)
+        ].join(`
+`),
+        inputSchema: z.object({
+          method: z.enum(factories.map((f) => f.name)).default(factories[0].name).describe("The method to use to connect to the browser")
+        }),
+        type: "readOnly"
+      },
+      async handle(_context, params, response) {
+        const selectedFactory = factories.find((f) => f.name === params.method);
+        if (!selectedFactory) {
+          response.addError(`Unknown connection method: ${params.method}`);
+          return;
+        }
+        await self._setContextFactory(selectedFactory);
+        response.addResult("Successfully changed connection method.");
+      }
+    });
+  }
+  async _setContextFactory(newFactory) {
+    if (this._context) {
+      const options = {
+        ...this._context.options,
+        browserContextFactory: newFactory
+      };
+      await this._context.dispose();
+      this._context = new Context(options);
+    }
+    this._browserContextFactory = newFactory;
+  }
+}
+export {
+  BrowserServerBackend
+};

package/lib/config/constants.js

@@ -0,0 +1,80 @@
+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/config/constants.ts
+var TIMEOUTS = {
+  DEFAULT_PAGE_TIMEOUT: 5000,
+  LOAD_STATE_TIMEOUT: 5000,
+  NETWORK_IDLE_TIMEOUT: 2000,
+  STABILITY_TIMEOUT: 3000,
+  RETRY_DELAY: 500,
+  ELEMENT_DISCOVERY_TIMEOUT: 500,
+  PAGE_ANALYSIS_TIMEOUT: 1000,
+  PARALLEL_ANALYSIS_TIMEOUT: 2000,
+  WAIT_FOR_COMPLETION: 1000,
+  STABILITY_WAIT: 1500,
+  PING_TIMEOUT: 5000,
+  HEARTBEAT_INTERVAL: 3000,
+  SESSION_LOG_FLUSH: 1000,
+  FRAME_ACCESS_TIMEOUT: 1000,
+  INITIALIZATION_TIMEOUT: 5000,
+  MAX_WAIT_TIME: 30000,
+  SHORT_DELAY: 500,
+  MEDIUM_DELAY: 1000,
+  LONG_DELAY: 3000
+};
+var THRESHOLDS = {
+  HIGH_PERFORMANCE_IMPACT: 1000,
+  EXECUTION_TIME_WARNING: 2000,
+  EXECUTION_TIME_SLOW: 5000,
+  LARGE_SUBTREE_ELEMENTS: 1000,
+  SMALL_SUBTREE_ELEMENTS: 500,
+  ELEMENTS_WARNING: 1500,
+  ELEMENTS_DANGER: 3000,
+  VISIBLE_ELEMENTS_LIMIT: 1000,
+  DESCENDANT_COUNT_WARNING: 500,
+  HIGH_Z_INDEX: 1000,
+  EXCESSIVE_Z_INDEX: 1000,
+  LARGE_IMAGE_SIZE: 1000,
+  MEDIUM_IMAGE_SIZE: 500,
+  PERFORMANCE_TRACKER_HISTORY_SIZE: 1000,
+  COMPLEXITY_HIGH: 2000,
+  COMPLEXITY_MEDIUM: 1000
+};
+var DURATIONS = {
+  FIVE_MINUTES: 5 * 60 * 1000,
+  TEN_MINUTES: 10 * 60 * 1000,
+  ONE_HOUR: 60 * 60 * 1000,
+  ONE_DAY: 24 * 60 * 60 * 1000,
+  ONE_YEAR: 365 * 24 * 60 * 60 * 1000
+};
+var STRING_LIMITS = {
+  CDP_MESSAGE_PREVIEW: 500,
+  DEFAULT_TRUNCATION: 1000
+};
+var NETWORK = {
+  WS_NORMAL_CLOSURE: 1000
+};
+export {
+  TIMEOUTS,
+  THRESHOLDS,
+  STRING_LIMITS,
+  NETWORK,
+  DURATIONS
+};

package/lib/config.js

@@ -0,0 +1,405 @@
+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/config.ts
+import { promises as fsPromises } from "node:fs";
+import { platform, tmpdir } from "node:os";
+import { join as pathJoin } from "node:path";
+import { devices } from "playwright";
+import { sanitizeForFilePath } from "./utils.js";
+var defaultConfig = {
+  browser: {
+    browserName: "chromium",
+    launchOptions: {
+      channel: "chrome",
+      headless: platform() === "linux" && !process.env.DISPLAY,
+      chromiumSandbox: true
+    },
+    contextOptions: {
+      viewport: null
+    }
+  },
+  network: {
+    allowedOrigins: undefined,
+    blockedOrigins: undefined
+  },
+  server: {},
+  saveTrace: false
+};
+function resolveConfig(config) {
+  return mergeConfig(defaultConfig, config);
+}
+async function resolveCLIConfig(cliOptions) {
+  const configInFile = await loadConfig(cliOptions.config);
+  const envOverrides = configFromEnv();
+  const cliOverrides = configFromCLIOptions(cliOptions);
+  let result = defaultConfig;
+  result = mergeConfig(result, configInFile);
+  result = mergeConfig(result, envOverrides);
+  result = mergeConfig(result, cliOverrides);
+  return result;
+}
+function parseBrowserType(browser) {
+  if (isChromiumVariant(browser)) {
+    return { browserName: "chromium", channel: browser };
+  }
+  if (browser === "firefox") {
+    return { browserName: "firefox", channel: undefined };
+  }
+  if (browser === "webkit") {
+    return { browserName: "webkit", channel: undefined };
+  }
+  return { browserName: undefined, channel: undefined };
+}
+function isChromiumVariant(browser) {
+  const chromiumVariants = [
+    "chrome",
+    "chrome-beta",
+    "chrome-canary",
+    "chrome-dev",
+    "chromium",
+    "msedge",
+    "msedge-beta",
+    "msedge-canary",
+    "msedge-dev"
+  ];
+  return chromiumVariants.includes(browser);
+}
+function createLaunchOptions(cliOptions, channel) {
+  const launchOptions = {
+    channel,
+    executablePath: cliOptions.executablePath,
+    headless: cliOptions.headless
+  };
+  applySandboxSettings(launchOptions, cliOptions);
+  applyProxySettings(launchOptions, cliOptions);
+  return launchOptions;
+}
+function applySandboxSettings(launchOptions, cliOptions) {
+  if (cliOptions.sandbox === false) {
+    launchOptions.chromiumSandbox = false;
+  }
+}
+function applyProxySettings(launchOptions, cliOptions) {
+  if (!cliOptions.proxyServer) {
+    return;
+  }
+  launchOptions.proxy = {
+    server: cliOptions.proxyServer,
+    ...cliOptions.proxyBypass && { bypass: cliOptions.proxyBypass }
+  };
+}
+function createContextOptions(cliOptions) {
+  const contextOptions = cliOptions.device ? devices[cliOptions.device] || {} : {};
+  applyStorageOptions(contextOptions, cliOptions);
+  applyViewportOptions(contextOptions, cliOptions);
+  applySecurityOptions(contextOptions, cliOptions);
+  return contextOptions;
+}
+function applyStorageOptions(contextOptions, cliOptions) {
+  if (cliOptions.storageState) {
+    contextOptions.storageState = cliOptions.storageState;
+  }
+}
+function applyViewportOptions(contextOptions, cliOptions) {
+  if (cliOptions.userAgent) {
+    contextOptions.userAgent = cliOptions.userAgent;
+  }
+  if (cliOptions.viewportSize) {
+    contextOptions.viewport = parseViewportSize(cliOptions.viewportSize);
+  }
+}
+function applySecurityOptions(contextOptions, cliOptions) {
+  if (cliOptions.ignoreHttpsErrors) {
+    contextOptions.ignoreHTTPSErrors = true;
+  }
+  if (cliOptions.blockServiceWorkers) {
+    contextOptions.serviceWorkers = "block";
+  }
+}
+function parseViewportSize(viewportSize) {
+  try {
+    const [width, height] = viewportSize.split(",").map((n) => +n);
+    if (Number.isNaN(width) || Number.isNaN(height)) {
+      throw new Error("bad values");
+    }
+    return { width, height };
+  } catch {
+    throw new Error('Invalid viewport size format: use "width,height", for example --viewport-size="800,600"');
+  }
+}
+function validateDeviceAndCDPOptions(cliOptions) {
+  if (cliOptions.device && cliOptions.cdpEndpoint) {
+    throw new Error("Device emulation is not supported with cdpEndpoint.");
+  }
+}
+function configFromCLIOptions(cliOptions) {
+  const browserInfo = getBrowserInfo(cliOptions);
+  validateDeviceAndCDPOptions(cliOptions);
+  return buildFinalConfig(cliOptions, browserInfo);
+}
+function buildFinalConfig(cliOptions, browserInfo) {
+  return assembleConfigFromParts(cliOptions, browserInfo);
+}
+function assembleConfigFromParts(cliOptions, browserInfo) {
+  const configParts = createAllConfigParts(cliOptions, browserInfo);
+  return mergeAllConfigParts(configParts);
+}
+function createAllConfigParts(cliOptions, browserInfo) {
+  return {
+    browserConfig: createBrowserConfig(cliOptions, browserInfo.browserName, browserInfo.channel),
+    serverConfig: createServerConfig(cliOptions),
+    networkConfig: createNetworkConfig(cliOptions),
+    miscConfig: createMiscellaneousConfig(cliOptions)
+  };
+}
+function mergeAllConfigParts(configParts) {
+  return {
+    ...configParts.browserConfig,
+    ...configParts.serverConfig,
+    ...configParts.networkConfig,
+    ...configParts.miscConfig
+  };
+}
+function getBrowserInfo(cliOptions) {
+  return cliOptions.browser ? parseBrowserType(cliOptions.browser) : { browserName: undefined, channel: undefined };
+}
+function createMiscellaneousConfig(cliOptions) {
+  return {
+    capabilities: cliOptions.caps,
+    saveSession: cliOptions.saveSession,
+    saveTrace: cliOptions.saveTrace,
+    outputDir: cliOptions.outputDir,
+    imageResponses: cliOptions.imageResponses
+  };
+}
+function createBrowserConfig(cliOptions, browserName, channel) {
+  const browser = {
+    isolated: cliOptions.isolated,
+    userDataDir: cliOptions.userDataDir,
+    launchOptions: createLaunchOptions(cliOptions, channel),
+    contextOptions: createContextOptions(cliOptions),
+    cdpEndpoint: cliOptions.cdpEndpoint
+  };
+  if (browserName !== undefined) {
+    browser.browserName = browserName;
+  }
+  return { browser };
+}
+function createServerConfig(cliOptions) {
+  return {
+    server: {
+      port: cliOptions.port,
+      host: cliOptions.host
+    }
+  };
+}
+function createNetworkConfig(cliOptions) {
+  return {
+    network: {
+      allowedOrigins: cliOptions.allowedOrigins,
+      blockedOrigins: cliOptions.blockedOrigins
+    }
+  };
+}
+function configFromEnv() {
+  const options = buildEnvOptions();
+  return configFromCLIOptions(options);
+}
+function buildEnvOptions() {
+  const options = {};
+  populateAllOptions(options);
+  return options;
+}
+function populateAllOptions(options) {
+  populateNetworkOptions(options);
+  populateBrowserOptions(options);
+  populateDeviceOptions(options);
+  populateProxyOptions(options);
+  populateOutputOptions(options);
+  populateMiscellaneousOptions(options);
+}
+function populateNetworkOptions(options) {
+  options.allowedOrigins = semicolonSeparatedList(process.env.PLAYWRIGHT_MCP_ALLOWED_ORIGINS);
+  options.blockedOrigins = semicolonSeparatedList(process.env.PLAYWRIGHT_MCP_BLOCKED_ORIGINS);
+  options.ignoreHttpsErrors = envToBoolean(process.env.PLAYWRIGHT_MCP_IGNORE_HTTPS_ERRORS);
+  options.host = envToString(process.env.PLAYWRIGHT_MCP_HOST);
+  options.port = envToNumber(process.env.PLAYWRIGHT_MCP_PORT);
+}
+function populateBrowserOptions(options) {
+  options.browser = envToString(process.env.PLAYWRIGHT_MCP_BROWSER);
+  options.executablePath = envToString(process.env.PLAYWRIGHT_MCP_EXECUTABLE_PATH);
+  options.headless = envToBoolean(process.env.PLAYWRIGHT_MCP_HEADLESS);
+  options.sandbox = envToBoolean(process.env.PLAYWRIGHT_MCP_SANDBOX);
+  options.isolated = envToBoolean(process.env.PLAYWRIGHT_MCP_ISOLATED);
+  options.blockServiceWorkers = envToBoolean(process.env.PLAYWRIGHT_MCP_BLOCK_SERVICE_WORKERS);
+}
+function populateDeviceOptions(options) {
+  options.device = envToString(process.env.PLAYWRIGHT_MCP_DEVICE);
+  options.viewportSize = envToString(process.env.PLAYWRIGHT_MCP_VIEWPORT_SIZE);
+  options.userAgent = envToString(process.env.PLAYWRIGHT_MCP_USER_AGENT);
+  options.userDataDir = envToString(process.env.PLAYWRIGHT_MCP_USER_DATA_DIR);
+  options.storageState = envToString(process.env.PLAYWRIGHT_MCP_STORAGE_STATE);
+}
+function populateProxyOptions(options) {
+  options.proxyServer = envToString(process.env.PLAYWRIGHT_MCP_PROXY_SERVER);
+  options.proxyBypass = envToString(process.env.PLAYWRIGHT_MCP_PROXY_BYPASS);
+}
+function populateOutputOptions(options) {
+  options.outputDir = envToString(process.env.PLAYWRIGHT_MCP_OUTPUT_DIR);
+  options.saveTrace = envToBoolean(process.env.PLAYWRIGHT_MCP_SAVE_TRACE);
+  if (process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES === "omit") {
+    options.imageResponses = "omit";
+  }
+}
+function populateMiscellaneousOptions(options) {
+  options.caps = commaSeparatedList(process.env.PLAYWRIGHT_MCP_CAPS);
+  options.cdpEndpoint = envToString(process.env.PLAYWRIGHT_MCP_CDP_ENDPOINT);
+  options.config = envToString(process.env.PLAYWRIGHT_MCP_CONFIG);
+}
+async function loadConfig(configFile) {
+  if (!configFile) {
+    return {};
+  }
+  try {
+    const configContent = await fsPromises.readFile(configFile, "utf8");
+    validateConfigContent(configContent);
+    const config = JSON.parse(configContent);
+    sanitizeConfigIfNeeded(config);
+    return config;
+  } catch (error) {
+    throw new Error(`Failed to load config file: ${configFile}, ${error}`);
+  }
+}
+function validateConfigContent(configContent) {
+  if (configContent.length > 1024 * 1024) {
+    throw new Error("Configuration file too large");
+  }
+  if (configContent.includes("__proto__") || configContent.includes("constructor")) {
+    throw new Error("Configuration file contains potentially dangerous content");
+  }
+}
+function sanitizeConfigIfNeeded(config) {
+  if (config && typeof config === "object") {
+    sanitizeConfigObject(config);
+  }
+}
+function sanitizeConfigObject(obj) {
+  if (!obj || typeof obj !== "object") {
+    return;
+  }
+  const dangerousProps = ["__proto__", "constructor", "prototype"];
+  for (const prop of dangerousProps) {
+    if (prop in obj) {
+      delete obj[prop];
+    }
+  }
+  for (const value of Object.values(obj)) {
+    if (typeof value === "object" && value !== null) {
+      sanitizeConfigObject(value);
+    }
+  }
+}
+async function outputFile(config, rootPath, name) {
+  const outputDir = config.outputDir ?? (rootPath ? pathJoin(rootPath, ".playwright-mcp") : undefined) ?? pathJoin(tmpdir(), "playwright-mcp-output", sanitizeForFilePath(new Date().toISOString()));
+  await fsPromises.mkdir(outputDir, { recursive: true });
+  const fileName = sanitizeForFilePath(name);
+  return pathJoin(outputDir, fileName);
+}
+function pickDefined(obj) {
+  return Object.fromEntries(Object.entries(obj ?? {}).filter(([_, v]) => v !== undefined));
+}
+function mergeConfig(base, overrides) {
+  const browser = createMergedBrowserConfig(base, overrides);
+  return {
+    ...pickDefined(base),
+    ...pickDefined(overrides),
+    browser,
+    network: {
+      ...pickDefined(base.network),
+      ...pickDefined(overrides.network)
+    },
+    server: {
+      ...pickDefined(base.server),
+      ...pickDefined(overrides.server)
+    }
+  };
+}
+function createMergedBrowserConfig(base, overrides) {
+  const browser = {
+    ...pickDefined(base.browser),
+    ...pickDefined(overrides.browser),
+    browserName: overrides.browser?.browserName ?? base.browser?.browserName ?? "chromium",
+    isolated: overrides.browser?.isolated ?? base.browser?.isolated ?? false,
+    launchOptions: {
+      ...pickDefined(base.browser?.launchOptions),
+      ...pickDefined(overrides.browser?.launchOptions),
+      ...{ assistantMode: true }
+    },
+    contextOptions: {
+      ...pickDefined(base.browser?.contextOptions),
+      ...pickDefined(overrides.browser?.contextOptions)
+    }
+  };
+  handleNonChromiumChannel(browser);
+  return browser;
+}
+function handleNonChromiumChannel(browser) {
+  if (browser.browserName !== "chromium" && browser.launchOptions) {
+    browser.launchOptions.channel = undefined;
+  }
+}
+function semicolonSeparatedList(value) {
+  if (!value) {
+    return;
+  }
+  return value.split(";").map((v) => v.trim());
+}
+function commaSeparatedList(value) {
+  if (!value) {
+    return;
+  }
+  return value.split(",").map((v) => v.trim());
+}
+function envToNumber(value) {
+  if (!value) {
+    return;
+  }
+  return +value;
+}
+function envToBoolean(value) {
+  if (value === "true" || value === "1") {
+    return true;
+  }
+  if (value === "false" || value === "0") {
+    return false;
+  }
+}
+function envToString(value) {
+  return value ? value.trim() : undefined;
+}
+export {
+  semicolonSeparatedList,
+  resolveConfig,
+  resolveCLIConfig,
+  outputFile,
+  isChromiumVariant,
+  configFromCLIOptions,
+  commaSeparatedList
+};