@szymonrybczak/playwright-mcp 0.0.2 → 0.0.4

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

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+/**
+ * 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;
+}
+
+exports.__require = requireMs;

package/lib/cjs/package.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const _package = require('./cloudflare/package.json.js');
+
+const packageJSON = _package.default;
+
+exports.packageJSON = packageJSON;

package/lib/cjs/src/browserContextFactory.js

@@ -0,0 +1,240 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const fs = require('node:fs');
+const net = require('node:net');
+const path = require('node:path');
+const os = require('node:os');
+const browser = require('../_virtual/browser.js');
+const playwright = require('@szymonrybczak/patchright');
+const fileUtils = require('./fileUtils.js');
+
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+  if (e) {
+    for (const k in e) {
+      if (k !== 'default') {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+const playwright__namespace = /*#__PURE__*/_interopNamespaceDefault(playwright);
+
+const testDebug = browser.default("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__namespace[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__namespace.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__namespace[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__namespace[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__namespace.chromium.connectOverCDP(`http://localhost:${info.cdpPort}/`);
+  }
+  async _doCreateContext(browser) {
+    return this.browserConfig.isolated ? await browser.newContext() : browser.contexts()[0];
+  }
+  async _createUserDataDir() {
+    const dir = await fileUtils.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);
+  });
+}
+
+exports.BrowserServerContextFactory = BrowserServerContextFactory;
+exports.contextFactory = contextFactory;

package/lib/cjs/src/config.js

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+require('@szymonrybczak/patchright');
+const utils = require('./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", utils.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 = utils.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)
+    }
+  };
+}
+
+exports.outputFile = outputFile;
+exports.resolveConfig = resolveConfig;

package/lib/cjs/src/connection.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const index_js = require('@modelcontextprotocol/sdk/server/index.js');
+const types_js = require('@modelcontextprotocol/sdk/types.js');
+const zodToJsonSchema = require('zod-to-json-schema');
+const context = require('./context.js');
+const tools = require('./tools.js');
+const _package = require('../package.js');
+
+function createConnection(config, browserContextFactory) {
+  const allTools = config.vision ? tools.visionTools : tools.snapshotTools;
+  const tools$1 = allTools.filter((tool) => !config.capabilities || tool.capability === "core" || config.capabilities.includes(tool.capability));
+  const context$1 = new context.Context(tools$1, config, browserContextFactory);
+  const server = new index_js.Server({ name: "Playwright", version: _package.packageJSON.version }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+  server.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
+    return {
+      tools: tools$1.map((tool) => ({
+        name: tool.schema.name,
+        description: tool.schema.description,
+        inputSchema: zodToJsonSchema.zodToJsonSchema(tool.schema.inputSchema),
+        annotations: {
+          title: tool.schema.title,
+          readOnlyHint: tool.schema.type === "readOnly",
+          destructiveHint: tool.schema.type === "destructive",
+          openWorldHint: true
+        }
+      }))
+    };
+  });
+  server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
+    const errorResult = (...messages) => ({
+      content: [{ type: "text", text: messages.join("\n") }],
+      isError: true
+    });
+    const tool = tools$1.find((tool2) => tool2.schema.name === request.params.name);
+    if (!tool)
+      return errorResult(`Tool "${request.params.name}" not found`);
+    const modalStates = context$1.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$1.modalStatesMarkdown());
+    if (!tool.clearsModalState && modalStates.length)
+      return errorResult(`Tool "${request.params.name}" does not handle the modal state.`, ...context$1.modalStatesMarkdown());
+    try {
+      return await context$1.run(tool, request.params.arguments);
+    } catch (error) {
+      return errorResult(String(error));
+    }
+  });
+  return new Connection(server, context$1);
+}
+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();
+  }
+}
+
+exports.Connection = Connection;
+exports.createConnection = createConnection;