@szymonrybczak/playwright-mcp 0.0.2 → 0.0.4

package/lib/esm/node_modules/ms/index.js

@@ -0,0 +1,172 @@
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function (val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+export { requireMs as __require };

package/lib/esm/package.js

@@ -0,0 +1,5 @@
+import json from './cloudflare/package.json.js';
+
+const packageJSON = json;
+
+export { packageJSON };

package/lib/esm/src/browserContextFactory.js

@@ -0,0 +1,216 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import os from 'node:os';
+import debug from '../_virtual/browser.js';
+import * as playwright from '@szymonrybczak/patchright';
+import { userDataDir } from './fileUtils.js';
+
+const testDebug = debug("pw:mcp:test");
+function contextFactory(browserConfig) {
+  if (browserConfig.remoteEndpoint)
+    return new RemoteContextFactory(browserConfig);
+  if (browserConfig.cdpEndpoint)
+    return new CdpContextFactory(browserConfig);
+  if (browserConfig.isolated)
+    return new IsolatedContextFactory(browserConfig);
+  if (browserConfig.browserAgent)
+    return new BrowserServerContextFactory(browserConfig);
+  return new PersistentContextFactory(browserConfig);
+}
+class BaseContextFactory {
+  browserConfig;
+  _browserPromise;
+  name;
+  constructor(name, browserConfig) {
+    this.name = name;
+    this.browserConfig = browserConfig;
+  }
+  async _obtainBrowser() {
+    if (this._browserPromise)
+      return this._browserPromise;
+    testDebug(`obtain browser (${this.name})`);
+    this._browserPromise = this._doObtainBrowser();
+    void this._browserPromise.then((browser) => {
+      browser.on("disconnected", () => {
+        this._browserPromise = void 0;
+      });
+    }).catch(() => {
+      this._browserPromise = void 0;
+    });
+    return this._browserPromise;
+  }
+  async _doObtainBrowser() {
+    throw new Error("Not implemented");
+  }
+  async createContext() {
+    testDebug(`create browser context (${this.name})`);
+    const browser = await this._obtainBrowser();
+    const browserContext = await this._doCreateContext(browser);
+    return { browserContext, close: () => this._closeBrowserContext(browserContext, browser) };
+  }
+  async _doCreateContext(browser) {
+    throw new Error("Not implemented");
+  }
+  async _closeBrowserContext(browserContext, browser) {
+    testDebug(`close browser context (${this.name})`);
+    if (browser.contexts().length === 1)
+      this._browserPromise = void 0;
+    await browserContext.close().catch(() => {
+    });
+    if (browser.contexts().length === 0) {
+      testDebug(`close browser (${this.name})`);
+      await browser.close().catch(() => {
+      });
+    }
+  }
+}
+class IsolatedContextFactory extends BaseContextFactory {
+  constructor(browserConfig) {
+    super("isolated", browserConfig);
+  }
+  async _doObtainBrowser() {
+    await injectCdpPort(this.browserConfig);
+    const browserType = playwright[this.browserConfig.browserName];
+    return browserType.launch({
+      ...this.browserConfig.launchOptions,
+      handleSIGINT: false,
+      handleSIGTERM: false
+    }).catch((error) => {
+      if (error.message.includes("Executable doesn't exist"))
+        throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+      throw error;
+    });
+  }
+  async _doCreateContext(browser) {
+    return browser.newContext(this.browserConfig.contextOptions);
+  }
+}
+class CdpContextFactory extends BaseContextFactory {
+  constructor(browserConfig) {
+    super("cdp", browserConfig);
+  }
+  async _doObtainBrowser() {
+    return playwright.chromium.connectOverCDP(this.browserConfig.cdpEndpoint);
+  }
+  async _doCreateContext(browser) {
+    return this.browserConfig.isolated ? await browser.newContext() : browser.contexts()[0];
+  }
+}
+class RemoteContextFactory extends BaseContextFactory {
+  constructor(browserConfig) {
+    super("remote", browserConfig);
+  }
+  async _doObtainBrowser() {
+    const url = new URL(this.browserConfig.remoteEndpoint);
+    url.searchParams.set("browser", this.browserConfig.browserName);
+    if (this.browserConfig.launchOptions)
+      url.searchParams.set("launch-options", JSON.stringify(this.browserConfig.launchOptions));
+    return playwright[this.browserConfig.browserName].connect(String(url));
+  }
+  async _doCreateContext(browser) {
+    return browser.newContext();
+  }
+}
+class PersistentContextFactory {
+  browserConfig;
+  _userDataDirs = /* @__PURE__ */ new Set();
+  constructor(browserConfig) {
+    this.browserConfig = browserConfig;
+  }
+  async createContext() {
+    await injectCdpPort(this.browserConfig);
+    testDebug("create browser context (persistent)");
+    const userDataDir2 = this.browserConfig.userDataDir ?? await this._createUserDataDir();
+    this._userDataDirs.add(userDataDir2);
+    testDebug("lock user data dir", userDataDir2);
+    const browserType = playwright[this.browserConfig.browserName];
+    for (let i = 0; i < 5; i++) {
+      try {
+        const browserContext = await browserType.launchPersistentContext(userDataDir2, {
+          ...this.browserConfig.launchOptions,
+          ...this.browserConfig.contextOptions,
+          handleSIGINT: false,
+          handleSIGTERM: false
+        });
+        const close = () => this._closeBrowserContext(browserContext, userDataDir2);
+        return { browserContext, close };
+      } catch (error) {
+        if (error.message.includes("Executable doesn't exist"))
+          throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+        if (error.message.includes("ProcessSingleton") || error.message.includes("Invalid URL")) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error(`Browser is already in use for ${userDataDir2}, use --isolated to run multiple instances of the same browser`);
+  }
+  async _closeBrowserContext(browserContext, userDataDir2) {
+    testDebug("close browser context (persistent)");
+    testDebug("release user data dir", userDataDir2);
+    await browserContext.close().catch(() => {
+    });
+    this._userDataDirs.delete(userDataDir2);
+    testDebug("close browser context complete (persistent)");
+  }
+  async _createUserDataDir() {
+    let cacheDirectory;
+    if (process.platform === "linux")
+      cacheDirectory = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+    else if (process.platform === "darwin")
+      cacheDirectory = path.join(os.homedir(), "Library", "Caches");
+    else if (process.platform === "win32")
+      cacheDirectory = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    else
+      throw new Error("Unsupported platform: " + process.platform);
+    const result = path.join(cacheDirectory, "ms-playwright", `mcp-${this.browserConfig.launchOptions?.channel ?? this.browserConfig?.browserName}-profile`);
+    await fs.promises.mkdir(result, { recursive: true });
+    return result;
+  }
+}
+class BrowserServerContextFactory extends BaseContextFactory {
+  constructor(browserConfig) {
+    super("persistent", browserConfig);
+  }
+  async _doObtainBrowser() {
+    const response = await fetch(new URL(`/json/launch`, this.browserConfig.browserAgent), {
+      method: "POST",
+      body: JSON.stringify({
+        browserType: this.browserConfig.browserName,
+        userDataDir: this.browserConfig.userDataDir ?? await this._createUserDataDir(),
+        launchOptions: this.browserConfig.launchOptions,
+        contextOptions: this.browserConfig.contextOptions
+      })
+    });
+    const info = await response.json();
+    if (info.error)
+      throw new Error(info.error);
+    return await playwright.chromium.connectOverCDP(`http://localhost:${info.cdpPort}/`);
+  }
+  async _doCreateContext(browser) {
+    return this.browserConfig.isolated ? await browser.newContext() : browser.contexts()[0];
+  }
+  async _createUserDataDir() {
+    const dir = await userDataDir(this.browserConfig);
+    await fs.promises.mkdir(dir, { recursive: true });
+    return dir;
+  }
+}
+async function injectCdpPort(browserConfig) {
+  if (browserConfig.browserName === "chromium")
+    browserConfig.launchOptions.cdpPort = await findFreePort();
+}
+async function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+
+export { BrowserServerContextFactory, contextFactory };

package/lib/esm/src/config.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import '@szymonrybczak/patchright';
+import { sanitizeForFilePath } from './tools/utils.js';
+
+const defaultConfig = {
+  browser: {
+    browserName: "chromium",
+    launchOptions: {
+      channel: "chrome",
+      headless: os.platform() === "linux" && !process.env.DISPLAY,
+      chromiumSandbox: true
+    },
+    contextOptions: {
+      viewport: null
+    }
+  },
+  network: {
+    allowedOrigins: void 0,
+    blockedOrigins: void 0
+  },
+  server: {},
+  outputDir: path.join(os.tmpdir(), "playwright-mcp-output", sanitizeForFilePath((/* @__PURE__ */ new Date()).toISOString()))
+};
+async function resolveConfig(config) {
+  return mergeConfig(defaultConfig, config);
+}
+async function outputFile(config, name) {
+  await fs.promises.mkdir(config.outputDir, { recursive: true });
+  const fileName = sanitizeForFilePath(name);
+  return path.join(config.outputDir, fileName);
+}
+function pickDefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj ?? {}).filter(([_, v]) => v !== void 0)
+  );
+}
+function mergeConfig(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)
+    }
+  };
+  if (browser.browserName !== "chromium" && browser.launchOptions)
+    delete browser.launchOptions.channel;
+  return {
+    ...pickDefined(base),
+    ...pickDefined(overrides),
+    browser,
+    network: {
+      ...pickDefined(base.network),
+      ...pickDefined(overrides.network)
+    },
+    server: {
+      ...pickDefined(base.server),
+      ...pickDefined(overrides.server)
+    }
+  };
+}
+
+export { outputFile, resolveConfig };

package/lib/esm/src/connection.js

@@ -0,0 +1,69 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { Context } from './context.js';
+import { visionTools, snapshotTools } from './tools.js';
+import { packageJSON } from '../package.js';
+
+function createConnection(config, browserContextFactory) {
+  const allTools = config.vision ? visionTools : snapshotTools;
+  const tools = allTools.filter((tool) => !config.capabilities || tool.capability === "core" || config.capabilities.includes(tool.capability));
+  const context = new Context(tools, config, browserContextFactory);
+  const server = new Server({ name: "Playwright", version: packageJSON.version }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: tools.map((tool) => ({
+        name: tool.schema.name,
+        description: tool.schema.description,
+        inputSchema: zodToJsonSchema(tool.schema.inputSchema),
+        annotations: {
+          title: tool.schema.title,
+          readOnlyHint: tool.schema.type === "readOnly",
+          destructiveHint: tool.schema.type === "destructive",
+          openWorldHint: true
+        }
+      }))
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const errorResult = (...messages) => ({
+      content: [{ type: "text", text: messages.join("\n") }],
+      isError: true
+    });
+    const tool = tools.find((tool2) => tool2.schema.name === request.params.name);
+    if (!tool)
+      return errorResult(`Tool "${request.params.name}" not found`);
+    const modalStates = context.modalStates().map((state) => state.type);
+    if (tool.clearsModalState && !modalStates.includes(tool.clearsModalState))
+      return errorResult(`The tool "${request.params.name}" can only be used when there is related modal state present.`, ...context.modalStatesMarkdown());
+    if (!tool.clearsModalState && modalStates.length)
+      return errorResult(`Tool "${request.params.name}" does not handle the modal state.`, ...context.modalStatesMarkdown());
+    try {
+      return await context.run(tool, request.params.arguments);
+    } catch (error) {
+      return errorResult(String(error));
+    }
+  });
+  return new Connection(server, context);
+}
+class Connection {
+  server;
+  context;
+  constructor(server, context) {
+    this.server = server;
+    this.context = context;
+    this.server.oninitialized = () => {
+      this.context.clientVersion = this.server.getClientVersion();
+    };
+  }
+  async close() {
+    await this.server.close();
+    await this.context.close();
+  }
+}
+
+export { Connection, createConnection };