playwright-codegen-pro-core 1.0.0

package/lib/tools/trace/traceScreenshot.js

@@ -0,0 +1,68 @@
+"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 traceScreenshot_exports = {};
+__export(traceScreenshot_exports, {
+  traceScreenshot: () => traceScreenshot
+});
+module.exports = __toCommonJS(traceScreenshot_exports);
+var import_traceUtils = require("./traceUtils");
+async function traceScreenshot(actionId, options) {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  const action = trace.resolveActionId(actionId);
+  if (!action) {
+    console.error(`Action '${actionId}' not found.`);
+    process.exitCode = 1;
+    return;
+  }
+  const pageId = action.pageId;
+  if (!pageId) {
+    console.error(`Action '${actionId}' has no associated page.`);
+    process.exitCode = 1;
+    return;
+  }
+  const callId = action.callId;
+  const storage = trace.loader.storage();
+  const snapshotNames = ["input", "before", "after"];
+  let sha1;
+  for (const name of snapshotNames) {
+    const renderer = storage.snapshotByName(pageId, `${name}@${callId}`);
+    sha1 = renderer?.closestScreenshot();
+    if (sha1)
+      break;
+  }
+  if (!sha1) {
+    console.error(`No screenshot found for action '${actionId}'.`);
+    process.exitCode = 1;
+    return;
+  }
+  const blob = await trace.loader.resourceForSha1(sha1);
+  if (!blob) {
+    console.error(`Screenshot resource not found.`);
+    process.exitCode = 1;
+    return;
+  }
+  const defaultName = `screenshot-${actionId}.png`;
+  const buffer = Buffer.from(await blob.arrayBuffer());
+  const outFile = await (0, import_traceUtils.saveOutputFile)(defaultName, buffer, options.output);
+  console.log(`  Screenshot saved to ${outFile}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  traceScreenshot
+});

package/lib/tools/trace/traceSnapshot.js

@@ -0,0 +1,149 @@
+"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 traceSnapshot_exports = {};
+__export(traceSnapshot_exports, {
+  traceSnapshot: () => traceSnapshot
+});
+module.exports = __toCommonJS(traceSnapshot_exports);
+var import_browserBackend = require("../backend/browserBackend");
+var import_tools = require("../backend/tools");
+var playwright = __toESM(require("../../.."));
+var import_utils = require("../../utils");
+var import_command = require("../cli-daemon/command");
+var import_minimist = require("../cli-client/minimist");
+var import_commands = require("../cli-daemon/commands");
+var import_traceUtils = require("./traceUtils");
+async function traceSnapshot(actionId, options) {
+  const trace = await (0, import_traceUtils.loadTrace)();
+  const action = trace.resolveActionId(actionId);
+  if (!action) {
+    console.error(`Action '${actionId}' not found.`);
+    process.exitCode = 1;
+    return;
+  }
+  const pageId = action.pageId;
+  if (!pageId) {
+    console.error(`Action '${actionId}' has no associated page.`);
+    process.exitCode = 1;
+    return;
+  }
+  const callId = action.callId;
+  const storage = trace.loader.storage();
+  let snapshotName;
+  let renderer;
+  if (options.name) {
+    snapshotName = options.name;
+    renderer = storage.snapshotByName(pageId, `${snapshotName}@${callId}`);
+  } else {
+    for (const candidate of ["input", "before", "after"]) {
+      renderer = storage.snapshotByName(pageId, `${candidate}@${callId}`);
+      if (renderer) {
+        snapshotName = candidate;
+        break;
+      }
+    }
+  }
+  if (!renderer || !snapshotName) {
+    console.error(`No snapshot found for action '${actionId}'.`);
+    process.exitCode = 1;
+    return;
+  }
+  const snapshotKey = `${snapshotName}@${callId}`;
+  const server = await serveTraceSnapshot(storage, trace.loader, pageId, snapshotKey);
+  if (options.serve) {
+    console.log(`Serving snapshot at ${server.url}`);
+    await new Promise(() => {
+    });
+    return;
+  }
+  await runCommandOnSnapshot(server, options.browserArgs || []);
+}
+async function serveTraceSnapshot(storage, loader, pageId, snapshotKey) {
+  const { SnapshotServer } = require("../../utils/isomorphic/trace/snapshotServer");
+  const { HttpServer } = require("../../server/utils/httpServer");
+  const snapshotServer = new SnapshotServer(storage, (sha1) => loader.resourceForSha1(sha1));
+  const httpServer = new HttpServer();
+  httpServer.routePrefix("/snapshot", (request, response) => {
+    const url = new URL("http://localhost" + request.url);
+    const searchParams = url.searchParams;
+    searchParams.set("name", snapshotKey);
+    const snapshotResponse = snapshotServer.serveSnapshot(pageId, searchParams, "/snapshot");
+    response.statusCode = snapshotResponse.status;
+    snapshotResponse.headers.forEach((value, key) => response.setHeader(key, value));
+    snapshotResponse.text().then((text) => response.end(text));
+    return true;
+  });
+  httpServer.routePrefix("/", (_request, response) => {
+    response.statusCode = 302;
+    response.setHeader("Location", "/snapshot");
+    response.end();
+    return true;
+  });
+  await httpServer.start({ preferredPort: 0 });
+  return { url: httpServer.urlPrefix("human-readable"), stop: () => httpServer.stop() };
+}
+async function runCommandOnSnapshot(server, browserArgs) {
+  const browser = await playwright.chromium.launch({ headless: true });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  await page.goto(server.url);
+  const backend = new import_browserBackend.BrowserBackend({
+    snapshot: { mode: "full" },
+    outputMode: "file",
+    skillMode: true
+  }, context, import_tools.browserTools);
+  await backend.initialize({ cwd: process.cwd() });
+  try {
+    if (!browserArgs.length)
+      browserArgs = ["snapshot"];
+    const args = (0, import_minimist.minimist)(browserArgs, { string: ["_"] });
+    const command = import_commands.commands[args._[0]];
+    if (!command)
+      throw new Error(`Unknown command: ${args._[0]}`);
+    const { toolName, toolParams } = (0, import_command.parseCommand)(command, args);
+    const result = await backend.callTool(toolName, toolParams);
+    const text = result.content[0]?.type === "text" ? result.content[0].text : void 0;
+    if (text)
+      console.log(text);
+    if (result.isError) {
+      console.error("Command failed.");
+      process.exitCode = 1;
+    }
+  } catch (e) {
+    console.error(e.message);
+    process.exitCode = 1;
+  } finally {
+    await server.stop().catch((e) => console.error(e));
+    await (0, import_utils.gracefullyCloseAll)();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  traceSnapshot
+});

package/lib/tools/trace/traceUtils.js

@@ -0,0 +1,135 @@
+"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 traceUtils_exports = {};
+__export(traceUtils_exports, {
+  LoadedTrace: () => LoadedTrace,
+  actionTitle: () => actionTitle,
+  formatTimestamp: () => formatTimestamp,
+  loadTrace: () => loadTrace,
+  openTrace: () => openTrace,
+  saveOutputFile: () => saveOutputFile
+});
+module.exports = __toCommonJS(traceUtils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_traceModel = require("../../utils/isomorphic/trace/traceModel");
+var import_traceLoader = require("../../utils/isomorphic/trace/traceLoader");
+var import_protocolFormatter = require("../../utils/isomorphic/protocolFormatter");
+var import_traceParser = require("./traceParser");
+const traceDir = import_path.default.join(".playwright-cli", "trace");
+const cliOutputDir = ".playwright-cli";
+class LoadedTrace {
+  constructor(model, loader, ordinals) {
+    this.model = model;
+    this.loader = loader;
+    this.ordinalToCallId = ordinals.ordinalToCallId;
+    this.callIdToOrdinal = ordinals.callIdToOrdinal;
+  }
+  resolveActionId(actionId) {
+    const ordinal = parseInt(actionId, 10);
+    if (!isNaN(ordinal)) {
+      const callId = this.ordinalToCallId.get(ordinal);
+      if (callId)
+        return this.model.actions.find((a) => a.callId === callId);
+    }
+    return this.model.actions.find((a) => a.callId === actionId);
+  }
+}
+function ensureTraceOpen() {
+  if (!import_fs.default.existsSync(traceDir))
+    throw new Error(`No trace opened. Run 'npx playwright trace open <file>' first.`);
+  return traceDir;
+}
+async function openTrace(traceFile) {
+  const filePath = import_path.default.resolve(traceFile);
+  if (!import_fs.default.existsSync(filePath))
+    throw new Error(`Trace file not found: ${filePath}`);
+  if (import_fs.default.existsSync(traceDir))
+    await import_fs.default.promises.rm(traceDir, { recursive: true });
+  await import_fs.default.promises.mkdir(traceDir, { recursive: true });
+  await (0, import_traceParser.extractTrace)(filePath, traceDir);
+}
+async function loadTrace() {
+  const dir = ensureTraceOpen();
+  const backend = new import_traceParser.DirTraceLoaderBackend(dir);
+  const loader = new import_traceLoader.TraceLoader();
+  await loader.load(backend, () => void 0);
+  const model = new import_traceModel.TraceModel(dir, loader.contextEntries);
+  return new LoadedTrace(model, loader, buildOrdinalMap(model));
+}
+function formatTimestamp(ms, base) {
+  const relative = ms - base;
+  if (relative < 0)
+    return "0:00.000";
+  const totalMs = Math.floor(relative);
+  const minutes = Math.floor(totalMs / 6e4);
+  const seconds = Math.floor(totalMs % 6e4 / 1e3);
+  const millis = totalMs % 1e3;
+  return `${minutes}:${seconds.toString().padStart(2, "0")}.${millis.toString().padStart(3, "0")}`;
+}
+function actionTitle(action) {
+  return (0, import_protocolFormatter.renderTitleForCall)({ ...action, type: action.class }) || `${action.class}.${action.method}`;
+}
+async function saveOutputFile(fileName, content, explicitOutput) {
+  let outFile;
+  if (explicitOutput) {
+    outFile = explicitOutput;
+  } else {
+    await import_fs.default.promises.mkdir(cliOutputDir, { recursive: true });
+    outFile = import_path.default.join(cliOutputDir, fileName);
+  }
+  await import_fs.default.promises.writeFile(outFile, content);
+  return outFile;
+}
+function buildOrdinalMap(model) {
+  const actions = model.actions.filter((a) => a.group !== "configuration");
+  const { rootItem } = (0, import_traceModel.buildActionTree)(actions);
+  const ordinalToCallId = /* @__PURE__ */ new Map();
+  const callIdToOrdinal = /* @__PURE__ */ new Map();
+  let ordinal = 1;
+  const visit = (item) => {
+    ordinalToCallId.set(ordinal, item.action.callId);
+    callIdToOrdinal.set(item.action.callId, ordinal);
+    ordinal++;
+    for (const child of item.children)
+      visit(child);
+  };
+  for (const child of rootItem.children)
+    visit(child);
+  return { ordinalToCallId, callIdToOrdinal };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoadedTrace,
+  actionTitle,
+  formatTimestamp,
+  loadTrace,
+  openTrace,
+  saveOutputFile
+});

package/lib/tools/utils/connect.js

@@ -0,0 +1,32 @@
+"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 connect_exports = {};
+__export(connect_exports, {
+  connectToBrowserAcrossVersions: () => connectToBrowserAcrossVersions
+});
+module.exports = __toCommonJS(connect_exports);
+async function connectToBrowserAcrossVersions(descriptor) {
+  const pw = require(descriptor.playwrightLib);
+  const browserType = pw[descriptor.browser.browserName];
+  return await browserType.connect(descriptor.pipeName);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connectToBrowserAcrossVersions
+});

package/lib/tools/utils/mcp/http.js

@@ -0,0 +1,152 @@
+"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 http_exports = {};
+__export(http_exports, {
+  addressToString: () => addressToString,
+  startMcpHttpServer: () => startMcpHttpServer
+});
+module.exports = __toCommonJS(http_exports);
+var import_assert = __toESM(require("assert"));
+var import_crypto = __toESM(require("crypto"));
+var import_utilsBundle = require("../../../utilsBundle");
+var mcpBundle = __toESM(require("../../../mcpBundle"));
+var import_network = require("../../../server/utils/network");
+var mcpServer = __toESM(require("./server"));
+const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
+async function startMcpHttpServer(config, serverBackendFactory, allowedHosts) {
+  const httpServer = (0, import_network.createHttpServer)();
+  await (0, import_network.startHttpServer)(httpServer, config);
+  return await installHttpTransport(httpServer, serverBackendFactory, allowedHosts);
+}
+function addressToString(address, options) {
+  (0, import_assert.default)(address, "Could not bind server socket");
+  if (typeof address === "string")
+    throw new Error("Unexpected address type: " + address);
+  let host = address.family === "IPv4" ? address.address : `[${address.address}]`;
+  if (options.normalizeLoopback && (host === "0.0.0.0" || host === "[::]" || host === "[::1]" || host === "127.0.0.1"))
+    host = "localhost";
+  return `${options.protocol}://${host}:${address.port}`;
+}
+async function installHttpTransport(httpServer, serverBackendFactory, allowedHosts) {
+  const url = addressToString(httpServer.address(), { protocol: "http", normalizeLoopback: true });
+  const host = new URL(url).host;
+  allowedHosts = (allowedHosts || [host]).map((h) => h.toLowerCase());
+  const allowAnyHost = allowedHosts.includes("*");
+  const sseSessions = /* @__PURE__ */ new Map();
+  const streamableSessions = /* @__PURE__ */ new Map();
+  httpServer.on("request", async (req, res) => {
+    if (!allowAnyHost) {
+      const host2 = req.headers.host?.toLowerCase();
+      if (!host2) {
+        res.statusCode = 400;
+        return res.end("Missing host");
+      }
+      if (!allowedHosts.includes(host2)) {
+        res.statusCode = 403;
+        return res.end("Access is only allowed at " + allowedHosts.join(", "));
+      }
+    }
+    const url2 = new URL(`http://localhost${req.url}`);
+    if (url2.pathname === "/killkillkill" && req.method === "GET") {
+      res.statusCode = 200;
+      res.end("Killing process");
+      process.emit("SIGINT");
+      return;
+    }
+    if (url2.pathname.startsWith("/sse"))
+      await handleSSE(serverBackendFactory, req, res, url2, sseSessions);
+    else
+      await handleStreamable(serverBackendFactory, req, res, streamableSessions);
+  });
+  return url;
+}
+async function handleSSE(serverBackendFactory, req, res, url, sessions) {
+  if (req.method === "POST") {
+    const sessionId = url.searchParams.get("sessionId");
+    if (!sessionId) {
+      res.statusCode = 400;
+      return res.end("Missing sessionId");
+    }
+    const transport = sessions.get(sessionId);
+    if (!transport) {
+      res.statusCode = 404;
+      return res.end("Session not found");
+    }
+    return await transport.handlePostMessage(req, res);
+  } else if (req.method === "GET") {
+    const transport = new mcpBundle.SSEServerTransport("/sse", res);
+    sessions.set(transport.sessionId, transport);
+    testDebug(`create SSE session`);
+    await mcpServer.connect(serverBackendFactory, transport, false);
+    res.on("close", () => {
+      testDebug(`delete SSE session`);
+      sessions.delete(transport.sessionId);
+    });
+    return;
+  }
+  res.statusCode = 405;
+  res.end("Method not allowed");
+}
+async function handleStreamable(serverBackendFactory, req, res, sessions) {
+  const sessionId = req.headers["mcp-session-id"];
+  if (sessionId) {
+    const transport = sessions.get(sessionId);
+    if (!transport) {
+      res.statusCode = 404;
+      res.end("Session not found");
+      return;
+    }
+    return await transport.handleRequest(req, res);
+  }
+  if (req.method === "POST") {
+    const transport = new mcpBundle.StreamableHTTPServerTransport({
+      sessionIdGenerator: () => import_crypto.default.randomUUID(),
+      onsessioninitialized: async (sessionId2) => {
+        testDebug(`create http session`);
+        await mcpServer.connect(serverBackendFactory, transport, true);
+        sessions.set(sessionId2, transport);
+      }
+    });
+    transport.onclose = () => {
+      if (!transport.sessionId)
+        return;
+      sessions.delete(transport.sessionId);
+      testDebug(`delete http session`);
+    };
+    await transport.handleRequest(req, res);
+    return;
+  }
+  res.statusCode = 400;
+  res.end("Invalid request");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addressToString,
+  startMcpHttpServer
+});