@pedropaulovc/playwright 1.59.0-next → 1.59.0-next.1

package/lib/mcp/terminal/program.js

@@ -0,0 +1,310 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var program_exports = {};
+__export(program_exports, {
+  program: () => program
+});
+module.exports = __toCommonJS(program_exports);
+var import_child_process = require("child_process");
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_socketConnection = require("./socketConnection");
+const debugCli = (0, import_utilsBundle.debug)("pw:cli");
+class Session {
+  constructor(name, connection) {
+    this._nextMessageId = 1;
+    this._callbacks = /* @__PURE__ */ new Map();
+    this.name = name;
+    this._connection = connection;
+    this._connection.onmessage = (message) => this._onMessage(message);
+    this._connection.onclose = () => this.close();
+  }
+  async run(args) {
+    return await this._send("run", { args });
+  }
+  async stop() {
+    await this._send("stop");
+    this.close();
+  }
+  async _send(method, params = {}) {
+    const messageId = this._nextMessageId++;
+    const message = {
+      id: messageId,
+      method,
+      params
+    };
+    await this._connection.send(message);
+    return new Promise((resolve, reject) => {
+      this._callbacks.set(messageId, { resolve, reject });
+    });
+  }
+  close() {
+    for (const callback of this._callbacks.values())
+      callback.reject(new Error("Session closed"));
+    this._callbacks.clear();
+    this._connection.close();
+  }
+  _onMessage(object) {
+    if (object.id && this._callbacks.has(object.id)) {
+      const callback = this._callbacks.get(object.id);
+      this._callbacks.delete(object.id);
+      if (object.error)
+        callback.reject(new Error(object.error));
+      else
+        callback.resolve(object.result);
+    } else if (object.id) {
+      throw new Error(`Unexpected message id: ${object.id}`);
+    } else {
+      throw new Error(`Unexpected message without id: ${JSON.stringify(object)}`);
+    }
+  }
+}
+class SessionManager {
+  async list() {
+    const dir = daemonSocketDir;
+    try {
+      const files = await import_fs.default.promises.readdir(dir);
+      const sessions = [];
+      for (const file of files) {
+        if (file.endsWith("-user-data")) {
+          const sessionName = file.slice(0, -"-user-data".length);
+          const live = await this._canConnect(sessionName);
+          sessions.push({ name: sessionName, live });
+        }
+      }
+      return sessions;
+    } catch {
+      return [];
+    }
+  }
+  async run(args) {
+    const sessionName = this._resolveSessionName(args.session);
+    const session = await this._connect(sessionName);
+    const result = await session.run(args);
+    console.log(result);
+    session.close();
+  }
+  async stop(sessionName) {
+    sessionName = this._resolveSessionName(sessionName);
+    if (!await this._canConnect(sessionName)) {
+      console.log(`Session '${sessionName}' is not running.`);
+      return;
+    }
+    const session = await this._connect(sessionName);
+    await session.stop();
+    console.log(`Session '${sessionName}' stopped.`);
+  }
+  async delete(sessionName) {
+    sessionName = this._resolveSessionName(sessionName);
+    if (await this._canConnect(sessionName)) {
+      const session = await this._connect(sessionName);
+      await session.stop();
+    }
+    const userDataDir = import_path.default.resolve(daemonSocketDir, `${sessionName}-user-data`);
+    try {
+      await import_fs.default.promises.rm(userDataDir, { recursive: true });
+      console.log(`Deleted user data for session '${sessionName}'.`);
+    } catch (e) {
+      if (e.code === "ENOENT")
+        console.log(`No user data found for session '${sessionName}'.`);
+      else
+        throw e;
+    }
+    if (import_os.default.platform() !== "win32") {
+      const socketPath = this._daemonSocketPath(sessionName);
+      await import_fs.default.promises.unlink(socketPath).catch(() => {
+      });
+    }
+  }
+  async _connect(sessionName) {
+    const socketPath = process.env.PLAYWRIGHT_DAEMON_SOCKET_PATH || this._daemonSocketPath(sessionName);
+    debugCli(`Connecting to daemon at ${socketPath}`);
+    const socketExists = await import_fs.default.promises.stat(socketPath).then((stat) => stat?.isSocket() ?? false).catch(() => false);
+    if (socketExists) {
+      debugCli(`Socket file exists, attempting to connect...`);
+      try {
+        return await this._connectToSocket(sessionName, socketPath);
+      } catch (e) {
+        if (import_os.default.platform() !== "win32")
+          await import_fs.default.promises.unlink(socketPath).catch(() => {
+          });
+      }
+    }
+    if (process.env.PLAYWRIGHT_DAEMON_SOCKET_PATH)
+      throw new Error(`Socket path ${socketPath} does not exist`);
+    const userDataDir = import_path.default.resolve(daemonSocketDir, `${sessionName}-user-data`);
+    const child = spawnDaemon(socketPath, userDataDir, {
+      detached: true,
+      stdio: "ignore",
+      cwd: process.cwd()
+      // Will be used as root.
+    });
+    child.unref();
+    const maxRetries = 50;
+    const retryDelay = 100;
+    for (let i = 0; i < maxRetries; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      try {
+        return await this._connectToSocket(sessionName, socketPath);
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
+        debugCli(`Retrying to connect to daemon at ${socketPath} (${i + 1}/${maxRetries})`);
+      }
+    }
+    throw new Error(`Failed to connect to daemon at ${socketPath} after ${maxRetries * retryDelay}ms`);
+  }
+  async _connectToSocket(sessionName, socketPath) {
+    const socket = await new Promise((resolve, reject) => {
+      const socket2 = import_net.default.createConnection(socketPath, () => {
+        debugCli(`Connected to daemon at ${socketPath}`);
+        resolve(socket2);
+      });
+      socket2.on("error", reject);
+    });
+    return new Session(sessionName, new import_socketConnection.SocketConnection(socket));
+  }
+  async _canConnect(sessionName) {
+    const socketPath = this._daemonSocketPath(sessionName);
+    return new Promise((resolve) => {
+      const socket = import_net.default.createConnection(socketPath, () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on("error", () => {
+        resolve(false);
+      });
+    });
+  }
+  _resolveSessionName(sessionName) {
+    if (sessionName)
+      return sessionName;
+    if (process.env.PLAYWRIGHT_CLI_SESSION)
+      return process.env.PLAYWRIGHT_CLI_SESSION;
+    return "default";
+  }
+  _daemonSocketPath(sessionName) {
+    const socketName = `${sessionName}.sock`;
+    if (import_os.default.platform() === "win32")
+      return `\\\\.\\pipe\\${socketDirHash}-${socketName}`;
+    return import_path.default.join(daemonSocketDir, socketName);
+  }
+}
+async function handleSessionCommand(sessionManager, args) {
+  const subcommand = args._[0].split("-").slice(1).join("-");
+  if (subcommand === "list") {
+    const sessions = await sessionManager.list();
+    console.log("Sessions:");
+    for (const session of sessions) {
+      const liveMarker = session.live ? " (live)" : "";
+      console.log(`  ${session.name}${liveMarker}`);
+    }
+    if (sessions.length === 0)
+      console.log("  (no sessions)");
+    return;
+  }
+  if (subcommand === "stop") {
+    await sessionManager.stop(args._[1]);
+    return;
+  }
+  if (subcommand === "stop-all") {
+    const sessions = await sessionManager.list();
+    for (const session of sessions)
+      await sessionManager.stop(session.name);
+    return;
+  }
+  if (subcommand === "delete") {
+    await sessionManager.delete(args._[1]);
+    return;
+  }
+  console.error(`Unknown session subcommand: ${subcommand}`);
+  process.exit(1);
+}
+const socketDirHash = (() => {
+  const hash = import_crypto.default.createHash("sha1");
+  hash.update(require.resolve("../../../package.json"));
+  return hash.digest("hex");
+})();
+const daemonSocketDir = (() => {
+  let localCacheDir;
+  if (process.platform === "linux")
+    localCacheDir = process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache");
+  if (process.platform === "darwin")
+    localCacheDir = import_path.default.join(import_os.default.homedir(), "Library", "Caches");
+  if (process.platform === "win32")
+    localCacheDir = process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local");
+  if (!localCacheDir)
+    throw new Error("Unsupported platform: " + process.platform);
+  return import_path.default.join(localCacheDir, "ms-playwright", "daemon", "daemon", socketDirHash);
+})();
+function spawnDaemon(socketPath, userDataDir, options) {
+  const cliPath = import_path.default.join(__dirname, "../../../cli.js");
+  debugCli(`Will launch daemon process: ${cliPath}`);
+  return (0, import_child_process.spawn)(process.execPath, [cliPath, "run-mcp-server", `--daemon=${socketPath}`, `--user-data-dir=${userDataDir}`], options);
+}
+async function program(options) {
+  const argv = process.argv.slice(2);
+  const args = require("minimist")(argv);
+  const help = require("./help.json");
+  const commandName = args._[0];
+  if (args.version || args.v) {
+    console.log(options.version);
+    process.exit(0);
+  }
+  const command = help.commands[commandName];
+  if (args.help || args.h) {
+    if (command) {
+      console.log(command);
+    } else {
+      console.log("playwright-cli - run playwright mcp commands from terminal\n");
+      console.log(help.global);
+    }
+    process.exit(0);
+  }
+  if (!command) {
+    console.error(`Unknown command: ${commandName}
+`);
+    console.log(help.global);
+    process.exit(1);
+  }
+  const sessionManager = new SessionManager();
+  if (commandName.startsWith("session")) {
+    await handleSessionCommand(sessionManager, args);
+    return;
+  }
+  await sessionManager.run(args);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  program
+});

package/lib/program.js

@@ -388,6 +388,7 @@ const testOptions = [
   ["--repeat-each <N>", { description: `Run each test N times (default: 1)` }],
   ["--reporter <reporter>", { description: `Reporter to use, comma-separated, can be ${import_config.builtInReporters.map((name) => `"${name}"`).join(", ")} (default: "${import_config.defaultReporter}")` }],
   ["--retries <retries>", { description: `Maximum retry count for flaky tests, zero for no retries (default: no retries)` }],
+  ["--run-agents <mode>", { description: `Run agents to generate the code for page.perform`, choices: ["missing", "all", "none"], preset: "none" }],
   ["--shard <shard>", { description: `Shard tests and execute only the selected shard, specify in the form "current/all", 1-based, for example "3/5"` }],
   ["--test-list <file>", { description: `Path to a file containing a list of tests to run. See https://playwright.dev/docs/test-cli for more details.` }],
   ["--test-list-invert <file>", { description: `Path to a file containing a list of tests to skip. See https://playwright.dev/docs/test-cli for more details.` }],

package/lib/reporters/base.js

@@ -368,10 +368,14 @@ function formatFailure(screen, config, test, index, options) {
         resultLines.push(screen.colors.dim(`    ${relativePath}`));
         if (attachment.name === "trace") {
           const packageManagerCommand = (0, import_utils.getPackageManagerExecCommand)();
-          resultLines.push(screen.colors.dim(`    Usage:`));
+          resultLines.push(screen.colors.dim(`    Usage (GUI):`));
           resultLines.push("");
           resultLines.push(screen.colors.dim(`        ${packageManagerCommand} playwright show-trace ${quotePathIfNeeded(relativePath)}`));
           resultLines.push("");
+          resultLines.push(screen.colors.dim(`    Usage (markdown, LLM friendly):`));
+          resultLines.push("");
+          resultLines.push(screen.colors.dim(`        ${packageManagerCommand} playwright export-trace ${quotePathIfNeeded(relativePath)}`));
+          resultLines.push("");
         }
       } else {
         if (attachment.contentType.startsWith("text/") && attachment.body) {

package/lib/transform/transform.js

@@ -187,8 +187,8 @@ function setTransformData(pluginName, value) {
 }
 function transformHook(originalCode, filename, moduleUrl) {
   let inputSourceMap;
-  if (filename.endsWith(".md") && false) {
-    const transformed = transformMDToTS(originalCode, filename);
+  if (filename.endsWith(".md")) {
+    const transformed = (0, import_md.transformMDToTS)(originalCode, filename);
     originalCode = transformed.code;
     inputSourceMap = transformed.map;
   }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@pedropaulovc/playwright",
-  "version": "1.59.0-next",
+  "version": "1.59.0-next.1",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/microsoft/playwright.git"
+    "url": "git+https://github.com/pedropaulovc/playwright.git"
   },
   "homepage": "https://playwright.dev",
   "engines": {
@@ -26,6 +26,7 @@
     "./lib/mcp/program": "./lib/mcp/program.js",
     "./lib/mcp/sdk/bundle": "./lib/mcp/sdk/bundle.js",
     "./lib/mcp/sdk/exports": "./lib/mcp/sdk/exports.js",
+    "./lib/mcp/terminal/program": "./lib/mcp/terminal/program.js",
     "./lib/program": "./lib/program.js",
     "./lib/reporters/base": "./lib/reporters/base.js",
     "./lib/reporters/list": "./lib/reporters/list.js",
@@ -64,7 +65,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.59.0-next"
+    "@pedropaulovc/playwright-core": "1.59.0-next.1"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"

package/types/test.d.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import type { APIRequestContext, Browser, BrowserContext, BrowserContextOptions, Page, LaunchOptions, ViewportSize, Geolocation, HTTPCredentials, Locator, APIResponse, PageScreenshotOptions } from 'playwright-core';
+import type { APIRequestContext, Browser, BrowserContext, BrowserContextOptions, Page, PageAgent, LaunchOptions, ViewportSize, Geolocation, HTTPCredentials, Locator, APIResponse, PageScreenshotOptions } from 'playwright-core';
 export * from 'playwright-core';
 
 export type BlobReporterOptions = { outputDir?: string, fileName?: string };
@@ -1611,6 +1611,14 @@ interface TestConfig<TestArgs = {}, WorkerArgs = {}> {
    */
   retries?: number;
 
+  /**
+   * Whether to run LLM agent for [PageAgent](https://playwright.dev/docs/api/class-pageagent):
+   * - "all" disregards existing cache and performs all actions via LLM
+   * - "missing" only performs actions that don't have generated cache actions
+   * - "none" does not talk to LLM at all, relies on the cached actions (default)
+   */
+  runAgents?: "all"|"missing"|"none";
+
   /**
    * Shard tests and execute only the selected shard. Specify in the one-based form like `{ total: 5, current: 2 }`.
    *
@@ -2067,6 +2075,14 @@ export interface FullConfig<TestArgs = {}, WorkerArgs = {}> {
    */
   rootDir: string;
 
+  /**
+   * Whether to run LLM agent for [PageAgent](https://playwright.dev/docs/api/class-pageagent):
+   * - "all" disregards existing cache and performs all actions via LLM
+   * - "missing" only performs actions that don't have generated cache actions
+   * - "none" does not talk to LLM at all, relies on the cached actions (default)
+   */
+  runAgents: "all"|"missing"|"none";
+
   /**
    * See [testConfig.shard](https://playwright.dev/docs/api/class-testconfig#test-config-shard).
    */
@@ -6934,6 +6950,24 @@ export interface PlaywrightWorkerOptions {
 export type ScreenshotMode = 'off' | 'on' | 'only-on-failure' | 'on-first-failure';
 export type TraceMode = 'off' | 'on' | 'retain-on-failure' | 'on-first-retry' | 'on-all-retries' | 'retain-on-first-failure';
 export type VideoMode = 'off' | 'on' | 'retain-on-failure' | 'on-first-retry';
+export type AgentOptions = {
+  provider?: {
+    api: 'openai' | 'openai-compatible' | 'anthropic' | 'google';
+    apiEndpoint?: string;
+    apiKey: string;
+    apiTimeout?: number;
+    model: string;
+  },
+  limits?: {
+    maxTokens?: number;
+    maxActions?: number;
+    maxActionRetries?: number;
+  };
+  cachePathTemplate?: string;
+  runAgents?: 'all' | 'missing' | 'none';
+  secrets?: { [key: string]: string };
+  systemPrompt?: string;
+};
 
 /**
  * Playwright Test provides many options to configure test environment,
@@ -6974,6 +7008,7 @@ export type VideoMode = 'off' | 'on' | 'retain-on-failure' | 'on-first-retry';
  *
  */
 export interface PlaywrightTestOptions {
+  agentOptions: AgentOptions | undefined;
   /**
    * Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
    *
@@ -7683,6 +7718,7 @@ export interface PlaywrightTestArgs {
    *
    */
   request: APIRequestContext;
+  agent: PageAgent;
 }
 
 type ExcludeProps<A, B> = {

package/lib/mcp/browser/actions.d.js

@@ -1,16 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var actions_d_exports = {};
-module.exports = __toCommonJS(actions_d_exports);

package/lib/mcp/browser/tools/navigateAndWait.js

@@ -1,66 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var navigateAndWait_exports = {};
-__export(navigateAndWait_exports, {
-  default: () => navigateAndWait_default
-});
-module.exports = __toCommonJS(navigateAndWait_exports);
-var import_mcpBundle = require("playwright-core/lib/mcpBundle");
-var import_tool = require("./tool");
-const navigateThenWaitFor = (0, import_tool.defineTool)({
-  capability: "core",
-  schema: {
-    name: "browser_navigate_then_wait_for",
-    title: "Navigate to URL and wait",
-    description: "Navigate to a URL and then wait for text to appear or disappear or a specified time to pass",
-    inputSchema: import_mcpBundle.z.object({
-      url: import_mcpBundle.z.string().describe("The URL to navigate to"),
-      time: import_mcpBundle.z.number().optional().describe("The time to wait in seconds after navigation"),
-      text: import_mcpBundle.z.string().optional().describe("The text to wait for after navigation"),
-      textGone: import_mcpBundle.z.string().optional().describe("The text to wait for to disappear after navigation")
-    }),
-    type: "action"
-  },
-  handle: async (context, params, response) => {
-    if (!params.text && !params.textGone && !params.time)
-      throw new Error("Either time, text or textGone must be provided");
-    const tab = await context.ensureTab();
-    await tab.navigate(params.url);
-    response.addCode(`await page.goto('${params.url}');`);
-    if (params.time) {
-      response.addCode(`await new Promise(f => setTimeout(f, ${params.time} * 1000));`);
-      await new Promise((f) => setTimeout(f, Math.min(3e4, params.time * 1e3)));
-    }
-    const locator = params.text ? tab.page.getByText(params.text).first() : void 0;
-    const goneLocator = params.textGone ? tab.page.getByText(params.textGone).first() : void 0;
-    if (goneLocator) {
-      response.addCode(`await page.getByText(${JSON.stringify(params.textGone)}).first().waitFor({ state: 'hidden' });`);
-      await goneLocator.waitFor({ state: "hidden" });
-    }
-    if (locator) {
-      response.addCode(`await page.getByText(${JSON.stringify(params.text)}).first().waitFor({ state: 'visible' });`);
-      await locator.waitFor({ state: "visible" });
-    }
-    response.addResult(`Navigated to ${params.url} and waited for ${params.text || params.textGone || params.time}`);
-    response.setIncludeSnapshot();
-  }
-});
-var navigateAndWait_default = [
-  navigateThenWaitFor
-];

package/lib/mcp/browser/tools/snapshotViewport.js

@@ -1,63 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var snapshotViewport_exports = {};
-__export(snapshotViewport_exports, {
-  default: () => snapshotViewport_default
-});
-module.exports = __toCommonJS(snapshotViewport_exports);
-var import_fs = __toESM(require("fs"));
-var import_mcpBundle = require("playwright-core/lib/mcpBundle");
-var import_tool = require("./tool");
-const snapshotViewport = (0, import_tool.defineTool)({
-  capability: "core",
-  schema: {
-    name: "browser_snapshot_viewport",
-    title: "Viewport snapshot",
-    description: "Capture accessibility snapshot of only what is visible in the current viewport",
-    inputSchema: import_mcpBundle.z.object({
-      filename: import_mcpBundle.z.string().optional().describe("Save snapshot to markdown file instead of returning it in the response.")
-    }),
-    type: "readOnly"
-  },
-  handle: async (context, params, response) => {
-    const tab = await context.ensureTab();
-    const snapshotResult = await tab.page._snapshotForAI({ track: "response", viewportOnly: true });
-    const viewportSnapshot = snapshotResult.full;
-    if (params.filename) {
-      const fileName = await response.addFile(params.filename, { origin: "llm", reason: "Saved viewport snapshot" });
-      await import_fs.default.promises.writeFile(fileName, viewportSnapshot);
-      response.setIncludeMetaOnly();
-    } else {
-      response.addResult(viewportSnapshot);
-    }
-  }
-});
-var snapshotViewport_default = [
-  snapshotViewport
-];