@pedropaulovc/playwright 1.59.0-next

package/lib/mcp/terminal/cli.js

@@ -0,0 +1,296 @@
+"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_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");
+const packageJSON = require("../../../package.json");
+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 = 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(() => {
+          });
+      }
+    }
+    const cliPath = import_path.default.join(__dirname, "../../../cli.js");
+    debugCli(`Will launch daemon process: ${cliPath}`);
+    const userDataDir = import_path.default.resolve(daemonSocketDir, `${sessionName}-user-data`);
+    const child = (0, import_child_process.spawn)(process.execPath, [cliPath, "run-mcp-server", `--daemon=${socketPath}`, `--user-data-dir=${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);
+})();
+async function main() {
+  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(packageJSON.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);
+}
+main().catch((e) => {
+  console.error(e.message);
+  process.exit(1);
+});

package/lib/mcp/terminal/command.js

@@ -0,0 +1,56 @@
+"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 command_exports = {};
+__export(command_exports, {
+  declareCommand: () => declareCommand,
+  parseCommand: () => parseCommand
+});
+module.exports = __toCommonJS(command_exports);
+function declareCommand(command) {
+  return command;
+}
+function parseCommand(command, args) {
+  const shape = command.args ? command.args.shape : {};
+  const argv = args["_"];
+  const options = command.options?.parse({ ...args, _: void 0 }) ?? {};
+  const argsObject = {};
+  let i = 0;
+  for (const name of Object.keys(shape))
+    argsObject[name] = argv[++i];
+  let parsedArgsObject = {};
+  try {
+    parsedArgsObject = command.args?.parse(argsObject) ?? {};
+  } catch (e) {
+    throw new Error(formatZodError(e));
+  }
+  const toolName = typeof command.toolName === "function" ? command.toolName(parsedArgsObject, options) : command.toolName;
+  const toolParams = command.toolParams({ ...parsedArgsObject, ...options });
+  return { toolName, toolParams };
+}
+function formatZodError(error) {
+  const issue = error.issues[0];
+  if (issue.code === "invalid_type")
+    return `${issue.message} in <${issue.path.join(".")}>`;
+  return error.issues.map((i) => i.message).join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  declareCommand,
+  parseCommand
+});