@pedropaulovc/playwright 1.59.0-alpha-1769214875000

package/lib/mcp/terminal/daemon.js

@@ -0,0 +1,131 @@
+"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 daemon_exports = {};
+__export(daemon_exports, {
+  startMcpDaemonServer: () => startMcpDaemonServer
+});
+module.exports = __toCommonJS(daemon_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_net = __toESM(require("net"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_url = __toESM(require("url"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_socketConnection = require("./socketConnection");
+var import_commands = require("./commands");
+var import_command = require("./command");
+const daemonDebug = (0, import_utilsBundle.debug)("pw:daemon");
+async function socketExists(socketPath) {
+  try {
+    const stat = await import_promises.default.stat(socketPath);
+    if (stat?.isSocket())
+      return true;
+  } catch (e) {
+  }
+  return false;
+}
+async function startMcpDaemonServer(socketPath, serverBackendFactory) {
+  if (import_os.default.platform() !== "win32" && await socketExists(socketPath)) {
+    daemonDebug(`Socket already exists, removing: ${socketPath}`);
+    try {
+      await import_promises.default.unlink(socketPath);
+    } catch (error) {
+      daemonDebug(`Failed to remove existing socket: ${error}`);
+      throw error;
+    }
+  }
+  const backend = serverBackendFactory.create();
+  const cwd = import_url.default.pathToFileURL(process.cwd()).href;
+  await backend.initialize?.({
+    name: "playwright-cli",
+    version: "1.0.0",
+    roots: [{
+      uri: cwd,
+      name: "cwd"
+    }],
+    timestamp: Date.now()
+  });
+  await import_promises.default.mkdir(import_path.default.dirname(socketPath), { recursive: true });
+  const server = import_net.default.createServer((socket) => {
+    daemonDebug("new client connection");
+    const connection = new import_socketConnection.SocketConnection(socket);
+    connection.onclose = () => {
+      daemonDebug("client disconnected");
+    };
+    connection.onmessage = async (message) => {
+      const { id, method, params } = message;
+      try {
+        daemonDebug("received command", method);
+        if (method === "stop") {
+          daemonDebug("stop command received, shutting down");
+          await connection.send({ id, result: "ok" });
+          server.close();
+          (0, import_utils.gracefullyProcessExitDoNotHang)(0);
+        } else if (method === "run") {
+          const { toolName, toolParams } = parseCliCommand(params.args);
+          const response = await backend.callTool(toolName, toolParams, () => {
+          });
+          await connection.send({ id, result: formatResult(response) });
+        } else {
+          throw new Error(`Unknown method: ${method}`);
+        }
+      } catch (e) {
+        daemonDebug("command failed", e);
+        await connection.send({ id, error: e.message });
+      }
+    };
+  });
+  return new Promise((resolve, reject) => {
+    server.on("error", (error) => {
+      daemonDebug(`server error: ${error.message}`);
+      reject(error);
+    });
+    server.listen(socketPath, () => {
+      daemonDebug(`daemon server listening on ${socketPath}`);
+      resolve(socketPath);
+    });
+  });
+}
+function formatResult(result) {
+  const isError = result.isError;
+  const text = result.content[0].type === "text" ? result.content[0].text : void 0;
+  const sections = result.content[0]._meta?.sections;
+  return { isError, text, sections };
+}
+function parseCliCommand(args) {
+  const command = import_commands.commands[args._[0]];
+  if (!command)
+    throw new Error("Command is required");
+  return (0, import_command.parseCommand)(command, args);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startMcpDaemonServer
+});

package/lib/mcp/terminal/help.json

@@ -0,0 +1,47 @@
+{
+  "global": "Usage: playwright-cli <command> [args] [options]\n\nCore:\n  open <url>                  open url\n  close                       close the page\n  type <text>                 type text into editable element\n  click <ref> [button]        perform click on a web page\n  dblclick <ref> [button]     perform double click on a web page\n  fill <ref> <text>           fill text into editable element\n  drag <startRef> <endRef>    perform drag and drop between two elements\n  hover <ref>                 hover over element on page\n  select <ref> <val>          select an option in a dropdown\n  upload <file>               upload one or multiple files\n  check <ref>                 check a checkbox or radio button\n  uncheck <ref>               uncheck a checkbox or radio button\n  snapshot                    capture page snapshot to obtain element ref\n  eval <func> [ref]           evaluate javascript expression on page or element\n  dialog-accept [prompt]      accept a dialog\n  dialog-dismiss              dismiss a dialog\n  resize <w> <h>              resize the browser window\n\nNavigation:\n  go-back                     go back to the previous page\n  go-forward                  go forward to the next page\n  reload                      reload the current page\n\nKeyboard:\n  press <key>                 press a key on the keyboard, `a`, `arrowleft`\n  keydown <key>               press a key down on the keyboard\n  keyup <key>                 press a key up on the keyboard\n\nMouse:\n  mousemove <x> <y>           move mouse to a given position\n  mousedown [button]          press mouse down\n  mouseup [button]            press mouse up\n  mousewheel <dx> <dy>        scroll mouse wheel\n\nSave as:\n  screenshot [ref]            screenshot of the current page or element\n  pdf                         save page as pdf\n\nTabs:\n  tab-list                    list all tabs\n  tab-new [url]               create a new tab\n  tab-close [index]           close a browser tab\n  tab-select <index>          select a browser tab\n\nDevTools:\n  console [min-level]         list console messages\n  network                     list all network requests since loading the page\n  run-code <code>             run playwright code snippet\n  tracing-start               start trace recording\n  tracing-stop                stop trace recording\n\nSessions:\n  session-list                list all sessions\n  session-stop [name]         stop session\n  session-stop-all            stop all sessions\n  session-delete [name]       delete session data",
+  "commands": {
+    "open": "playwright-cli open <url>\n\nOpen URL\n\nArguments:\n  <url>                       the url to navigate to\nOptions:\n  --headed                    run browser in headed mode",
+    "close": "playwright-cli close \n\nClose the page\n",
+    "type": "playwright-cli type <text>\n\nType text into editable element\n\nArguments:\n  <text>                      text to type into the element\nOptions:\n  --submit                    whether to submit entered text (press enter after)",
+    "click": "playwright-cli click <ref> [button]\n\nPerform click on a web page\n\nArguments:\n  <ref>                       exact target element reference from the page snapshot\n  [button]                    button to click, defaults to left\nOptions:\n  --modifiers                 modifier keys to press",
+    "dblclick": "playwright-cli dblclick <ref> [button]\n\nPerform double click on a web page\n\nArguments:\n  <ref>                       exact target element reference from the page snapshot\n  [button]                    button to click, defaults to left\nOptions:\n  --modifiers                 modifier keys to press",
+    "fill": "playwright-cli fill <ref> <text>\n\nFill text into editable element\n\nArguments:\n  <ref>                       exact target element reference from the page snapshot\n  <text>                      text to fill into the element\nOptions:\n  --submit                    whether to submit entered text (press enter after)",
+    "drag": "playwright-cli drag <startRef> <endRef>\n\nPerform drag and drop between two elements\n\nArguments:\n  <startRef>                  exact source element reference from the page snapshot\n  <endRef>                    exact target element reference from the page snapshot\nOptions:\n  --headed                    run browser in headed mode",
+    "hover": "playwright-cli hover <ref>\n\nHover over element on page\n\nArguments:\n  <ref>                       exact target element reference from the page snapshot",
+    "select": "playwright-cli select <ref> <val>\n\nSelect an option in a dropdown\n\nArguments:\n  <ref>                       exact target element reference from the page snapshot\n  <val>                       value to select in the dropdown",
+    "upload": "playwright-cli upload <file>\n\nUpload one or multiple files\n\nArguments:\n  <file>                      the absolute paths to the files to upload",
+    "check": "playwright-cli check <ref>\n\nCheck a checkbox or radio button\n\nArguments:\n  <ref>                       exact target element reference from the page snapshot",
+    "uncheck": "playwright-cli uncheck <ref>\n\nUncheck a checkbox or radio button\n\nArguments:\n  <ref>                       exact target element reference from the page snapshot",
+    "snapshot": "playwright-cli snapshot \n\nCapture page snapshot to obtain element ref\n\nOptions:\n  --filename                  save snapshot to markdown file instead of returning it in the response.",
+    "eval": "playwright-cli eval <func> [ref]\n\nEvaluate JavaScript expression on page or element\n\nArguments:\n  <func>                      () => { /* code */ } or (element) => { /* code */ } when element is provided\n  [ref]                       exact target element reference from the page snapshot",
+    "console": "playwright-cli console [min-level]\n\nList console messages\n\nArguments:\n  [min-level]                 level of the console messages to return. each level includes the messages of more severe levels. defaults to \"info\".\nOptions:\n  --clear                     whether to clear the console list",
+    "dialog-accept": "playwright-cli dialog-accept [prompt]\n\nAccept a dialog\n\nArguments:\n  [prompt]                    the text of the prompt in case of a prompt dialog.",
+    "dialog-dismiss": "playwright-cli dialog-dismiss \n\nDismiss a dialog\n",
+    "resize": "playwright-cli resize <w> <h>\n\nResize the browser window\n\nArguments:\n  <w>                         width of the browser window\n  <h>                         height of the browser window",
+    "go-back": "playwright-cli go-back \n\nGo back to the previous page\n",
+    "go-forward": "playwright-cli go-forward \n\nGo forward to the next page\n",
+    "reload": "playwright-cli reload \n\nReload the current page\n",
+    "press": "playwright-cli press <key>\n\nPress a key on the keyboard, `a`, `ArrowLeft`\n\nArguments:\n  <key>                       name of the key to press or a character to generate, such as `arrowleft` or `a`",
+    "keydown": "playwright-cli keydown <key>\n\nPress a key down on the keyboard\n\nArguments:\n  <key>                       name of the key to press or a character to generate, such as `arrowleft` or `a`",
+    "keyup": "playwright-cli keyup <key>\n\nPress a key up on the keyboard\n\nArguments:\n  <key>                       name of the key to press or a character to generate, such as `arrowleft` or `a`",
+    "mousemove": "playwright-cli mousemove <x> <y>\n\nMove mouse to a given position\n\nArguments:\n  <x>                         x coordinate\n  <y>                         y coordinate",
+    "mousedown": "playwright-cli mousedown [button]\n\nPress mouse down\n\nArguments:\n  [button]                    button to press, defaults to left",
+    "mouseup": "playwright-cli mouseup [button]\n\nPress mouse up\n\nArguments:\n  [button]                    button to press, defaults to left",
+    "mousewheel": "playwright-cli mousewheel <dx> <dy>\n\nScroll mouse wheel\n\nArguments:\n  <dx>                        y delta\n  <dy>                        x delta",
+    "screenshot": "playwright-cli screenshot [ref]\n\nscreenshot of the current page or element\n\nArguments:\n  [ref]                       exact target element reference from the page snapshot.\nOptions:\n  --filename                  file name to save the screenshot to. defaults to `page-{timestamp}.{png|jpeg}` if not specified.\n  --full-page                 when true, takes a screenshot of the full scrollable page, instead of the currently visible viewport.",
+    "pdf": "playwright-cli pdf \n\nSave page as PDF\n\nOptions:\n  --filename                  file name to save the pdf to. defaults to `page-{timestamp}.pdf` if not specified.",
+    "tab-list": "playwright-cli tab-list \n\nList all tabs\n",
+    "tab-new": "playwright-cli tab-new [url]\n\nCreate a new tab\n\nArguments:\n  [url]                       the url to navigate to in the new tab. if omitted, the new tab will be blank.",
+    "tab-close": "playwright-cli tab-close [index]\n\nClose a browser tab\n\nArguments:\n  [index]                     tab index. if omitted, current tab is closed.",
+    "tab-select": "playwright-cli tab-select <index>\n\nSelect a browser tab\n\nArguments:\n  <index>                     tab index",
+    "network": "playwright-cli network \n\nList all network requests since loading the page\n\nOptions:\n  --static                    whether to include successful static resources like images, fonts, scripts, etc. defaults to false.\n  --clear                     whether to clear the network list",
+    "run-code": "playwright-cli run-code <code>\n\nRun Playwright code snippet\n\nArguments:\n  <code>                      a javascript function containing playwright code to execute. it will be invoked with a single argument, page, which you can use for any page interaction.",
+    "tracing-start": "playwright-cli tracing-start \n\nStart trace recording\n",
+    "tracing-stop": "playwright-cli tracing-stop \n\nStop trace recording\n",
+    "session-list": "playwright-cli session-list \n\nList all sessions\n",
+    "session-stop": "playwright-cli session-stop [name]\n\nStop session\n\nArguments:\n  [name]                      name of the session to stop. if omitted, current session is stopped.",
+    "session-stop-all": "playwright-cli session-stop-all \n\nStop all sessions\n",
+    "session-delete": "playwright-cli session-delete [name]\n\nDelete session data\n\nArguments:\n  [name]                      name of the session to delete. if omitted, current session is deleted."
+  }
+}

package/lib/mcp/terminal/helpGenerator.js

@@ -0,0 +1,115 @@
+"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 __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 import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_commands = require("./commands");
+function commandArgs(command) {
+  const args = [];
+  const shape = command.args ? command.args.shape : {};
+  for (const [name, schema] of Object.entries(shape)) {
+    const zodSchema = schema;
+    const description = zodSchema.description ?? "";
+    args.push({ name, description, optional: zodSchema.safeParse(void 0).success });
+  }
+  return args;
+}
+function commandArgsText(args) {
+  return args.map((a) => a.optional ? `[${a.name}]` : `<${a.name}>`).join(" ");
+}
+function generateCommandHelp(command) {
+  const args = commandArgs(command);
+  const lines = [
+    `playwright-cli ${command.name} ${commandArgsText(args)}`,
+    "",
+    command.description,
+    ""
+  ];
+  if (args.length) {
+    lines.push("Arguments:");
+    lines.push(...args.map((a) => formatWithGap(`  ${a.optional ? `[${a.name}]` : `<${a.name}>`}`, a.description.toLowerCase())));
+  }
+  if (command.options) {
+    lines.push("Options:");
+    const optionsShape = command.options.shape;
+    for (const [name, schema] of Object.entries(optionsShape)) {
+      const zodSchema = schema;
+      const description = (zodSchema.description ?? "").toLowerCase();
+      lines.push(formatWithGap(`  --${name}`, description));
+    }
+  }
+  return lines.join("\n");
+}
+const categories = [
+  { name: "core", title: "Core" },
+  { name: "navigation", title: "Navigation" },
+  { name: "keyboard", title: "Keyboard" },
+  { name: "mouse", title: "Mouse" },
+  { name: "export", title: "Save as" },
+  { name: "tabs", title: "Tabs" },
+  { name: "storage", title: "Storage" },
+  { name: "devtools", title: "DevTools" },
+  { name: "session", title: "Sessions" }
+];
+function generateHelp() {
+  const lines = [];
+  lines.push("Usage: playwright-cli <command> [args] [options]");
+  const commandsByCategory = /* @__PURE__ */ new Map();
+  for (const c of categories)
+    commandsByCategory.set(c.name, []);
+  for (const command of Object.values(import_commands.commands))
+    commandsByCategory.get(command.category).push(command);
+  for (const c of categories) {
+    const cc = commandsByCategory.get(c.name);
+    if (!cc.length)
+      continue;
+    lines.push(`
+${c.title}:`);
+    for (const command of cc)
+      lines.push(generateHelpEntry(command));
+  }
+  return lines.join("\n");
+}
+function generateHelpEntry(command) {
+  const args = commandArgs(command);
+  const prefix = `  ${command.name} ${commandArgsText(args)}`;
+  const suffix = command.description.toLowerCase();
+  return formatWithGap(prefix, suffix);
+}
+async function main() {
+  const help = {
+    global: generateHelp(),
+    commands: Object.fromEntries(
+      Object.entries(import_commands.commands).map(([name, command]) => [name, generateCommandHelp(command)])
+    )
+  };
+  const fileName = import_path.default.resolve(__dirname, "help.json").replace("lib", "src");
+  console.log("Writing ", import_path.default.relative(process.cwd(), fileName));
+  await import_fs.default.promises.writeFile(fileName, JSON.stringify(help, null, 2));
+  console.log(help.global);
+}
+function formatWithGap(prefix, text) {
+  const indent = Math.max(1, 30 - prefix.length);
+  return prefix + " ".repeat(indent) + text;
+}
+void main();

package/lib/mcp/terminal/program.js

@@ -0,0 +1,365 @@
+"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, {
+  printResponse: () => printResponse,
+  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);
+    await printResponse(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);
+}
+async function printResponse(response) {
+  const { sections } = response;
+  if (!sections) {
+    console.log("### Error\n" + response.text);
+    return;
+  }
+  const text = [];
+  for (const section of sections) {
+    text.push(`### ${section.title}`);
+    for (const result of section.content) {
+      if (!result.file) {
+        if (result.text !== void 0)
+          text.push(result.text);
+        continue;
+      }
+      const generatedFileName = await outputFile(dateAsFileName(result.file.prefix, result.file.ext), { origin: "code" });
+      const fileName = result.file.suggestedFilename ? await outputFile(result.file.suggestedFilename, { origin: "llm" }) : generatedFileName;
+      text.push(`- [${result.title}](${import_path.default.relative(process.cwd(), fileName)})`);
+      if (result.data)
+        await import_fs.default.promises.writeFile(fileName, result.data);
+      else if (result.isBase64)
+        await import_fs.default.promises.writeFile(fileName, Buffer.from(result.text, "base64"));
+      else
+        await import_fs.default.promises.writeFile(fileName, result.text);
+    }
+  }
+  console.log(text.join("\n"));
+}
+function dateAsFileName(prefix, extension) {
+  const date = /* @__PURE__ */ new Date();
+  return `${prefix}-${date.toISOString().replace(/[:.]/g, "-")}.${extension}`;
+}
+const outputDir = import_path.default.join(process.cwd(), ".playwright-cli");
+async function outputFile(fileName, options) {
+  await import_fs.default.promises.mkdir(outputDir, { recursive: true });
+  if (options.origin === "code")
+    return import_path.default.resolve(outputDir, fileName);
+  if (options.origin === "llm") {
+    fileName = fileName.split("\\").join("/");
+    const resolvedFile = import_path.default.resolve(outputDir, fileName);
+    if (!resolvedFile.startsWith(import_path.default.resolve(outputDir) + import_path.default.sep))
+      throw new Error(`Resolved file path ${resolvedFile} is outside of the output directory ${outputDir}. Use relative file names to stay within the output directory.`);
+    return resolvedFile;
+  }
+  return import_path.default.join(outputDir, sanitizeForFilePath(fileName));
+}
+function sanitizeForFilePath(s) {
+  const sanitize = (s2) => s2.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, "-");
+  const separator = s.lastIndexOf(".");
+  if (separator === -1)
+    return sanitize(s);
+  return sanitize(s.substring(0, separator)) + "." + sanitize(s.substring(separator + 1));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  printResponse,
+  program
+});