patchright-core 1.57.0 → 1.59.0

package/lib/tools/backend/logFile.js

@@ -0,0 +1,95 @@
+"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 logFile_exports = {};
+__export(logFile_exports, {
+  LogFile: () => LogFile
+});
+module.exports = __toCommonJS(logFile_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("../../utilsBundle");
+class LogFile {
+  constructor(context, startTime, filePrefix, title) {
+    this._stopped = false;
+    this._line = 0;
+    this._entries = 0;
+    this._lastLine = 0;
+    this._lastEntries = 0;
+    this._writeChain = Promise.resolve();
+    this._context = context;
+    this._startTime = startTime;
+    this._filePrefix = filePrefix;
+    this._title = title;
+  }
+  appendLine(wallTime, text) {
+    this._writeChain = this._writeChain.then(() => this._write(wallTime, text)).catch((e) => (0, import_utilsBundle.debug)("pw:tools:error")(e));
+  }
+  stop() {
+    this._stopped = true;
+  }
+  async take(relativeTo) {
+    const logChunk = await this._take();
+    if (!logChunk)
+      return void 0;
+    const logFilePath = relativeTo ? import_path.default.relative(relativeTo, logChunk.file) : logChunk.file;
+    const lineRange = logChunk.fromLine === logChunk.toLine ? `#L${logChunk.fromLine}` : `#L${logChunk.fromLine}-L${logChunk.toLine}`;
+    return `${logFilePath}${lineRange}`;
+  }
+  async _take() {
+    await this._writeChain;
+    if (!this._file || this._entries === this._lastEntries)
+      return void 0;
+    const chunk = {
+      type: this._title.toLowerCase(),
+      file: this._file,
+      fromLine: this._lastLine + 1,
+      toLine: this._line,
+      entryCount: this._entries - this._lastEntries
+    };
+    this._lastLine = this._line;
+    this._lastEntries = this._entries;
+    return chunk;
+  }
+  async _write(wallTime, text) {
+    if (this._stopped)
+      return;
+    this._file ??= await this._context.outputFile({ prefix: this._filePrefix, ext: "log", date: new Date(this._startTime) }, { origin: "code" });
+    const relativeTime = Math.round(wallTime - this._startTime);
+    const logLine = `[${String(relativeTime).padStart(8, " ")}ms] ${text}
+`;
+    await import_fs.default.promises.appendFile(this._file, logLine);
+    const lineCount = logLine.split("\n").length - 1;
+    this._line += lineCount;
+    this._entries++;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogFile
+});

package/lib/tools/backend/mouse.js

@@ -0,0 +1,168 @@
+"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 mouse_exports = {};
+__export(mouse_exports, {
+  default: () => mouse_default
+});
+module.exports = __toCommonJS(mouse_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_stringUtils = require("../../utils/isomorphic/stringUtils");
+var import_tool = require("./tool");
+const mouseMove = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_move_xy",
+    title: "Move mouse",
+    description: "Move mouse to a given position",
+    inputSchema: import_zodBundle.z.object({
+      x: import_zodBundle.z.number().describe("X coordinate"),
+      y: import_zodBundle.z.number().describe("Y coordinate")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`// Move mouse to (${params.x}, ${params.y})`);
+    response.addCode(`await page.mouse.move(${params.x}, ${params.y});`);
+    await tab.page.mouse.move(params.x, params.y);
+  }
+});
+const mouseDown = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_down",
+    title: "Press mouse down",
+    description: "Press mouse down",
+    inputSchema: import_zodBundle.z.object({
+      button: import_zodBundle.z.enum(["left", "right", "middle"]).optional().describe("Button to press, defaults to left")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    const options = { button: params.button };
+    const optionsArg = (0, import_stringUtils.formatObjectOrVoid)(options);
+    response.addCode(`// Press mouse down`);
+    response.addCode(`await page.mouse.down(${optionsArg});`);
+    await tab.page.mouse.down(options);
+  }
+});
+const mouseUp = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_up",
+    title: "Press mouse up",
+    description: "Press mouse up",
+    inputSchema: import_zodBundle.z.object({
+      button: import_zodBundle.z.enum(["left", "right", "middle"]).optional().describe("Button to press, defaults to left")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    const options = { button: params.button };
+    const optionsArg = (0, import_stringUtils.formatObjectOrVoid)(options);
+    response.addCode(`// Press mouse up`);
+    response.addCode(`await page.mouse.up(${optionsArg});`);
+    await tab.page.mouse.up(options);
+  }
+});
+const mouseWheel = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_wheel",
+    title: "Scroll mouse wheel",
+    description: "Scroll mouse wheel",
+    inputSchema: import_zodBundle.z.object({
+      deltaX: import_zodBundle.z.number().default(0).describe("X delta"),
+      deltaY: import_zodBundle.z.number().default(0).describe("Y delta")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`// Scroll mouse wheel`);
+    response.addCode(`await page.mouse.wheel(${params.deltaX}, ${params.deltaY});`);
+    await tab.page.mouse.wheel(params.deltaX, params.deltaY);
+  }
+});
+const mouseClick = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_click_xy",
+    title: "Click",
+    description: "Click mouse button at a given position",
+    inputSchema: import_zodBundle.z.object({
+      x: import_zodBundle.z.number().describe("X coordinate"),
+      y: import_zodBundle.z.number().describe("Y coordinate"),
+      button: import_zodBundle.z.enum(["left", "right", "middle"]).optional().describe("Button to click, defaults to left"),
+      clickCount: import_zodBundle.z.number().optional().describe("Number of clicks, defaults to 1"),
+      delay: import_zodBundle.z.number().optional().describe("Time to wait between mouse down and mouse up in milliseconds, defaults to 0")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const options = {
+      button: params.button,
+      clickCount: params.clickCount,
+      delay: params.delay
+    };
+    const formatted = (0, import_stringUtils.formatObjectOrVoid)(options);
+    const optionsArg = formatted ? `, ${formatted}` : "";
+    response.addCode(`// Click mouse at coordinates (${params.x}, ${params.y})`);
+    response.addCode(`await page.mouse.click(${params.x}, ${params.y}${optionsArg});`);
+    await tab.waitForCompletion(async () => {
+      await tab.page.mouse.click(params.x, params.y, options);
+    });
+  }
+});
+const mouseDrag = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_drag_xy",
+    title: "Drag mouse",
+    description: "Drag left mouse button to a given position",
+    inputSchema: import_zodBundle.z.object({
+      startX: import_zodBundle.z.number().describe("Start X coordinate"),
+      startY: import_zodBundle.z.number().describe("Start Y coordinate"),
+      endX: import_zodBundle.z.number().describe("End X coordinate"),
+      endY: import_zodBundle.z.number().describe("End Y coordinate")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    response.addCode(`// Drag mouse from (${params.startX}, ${params.startY}) to (${params.endX}, ${params.endY})`);
+    response.addCode(`await page.mouse.move(${params.startX}, ${params.startY});`);
+    response.addCode(`await page.mouse.down();`);
+    response.addCode(`await page.mouse.move(${params.endX}, ${params.endY});`);
+    response.addCode(`await page.mouse.up();`);
+    await tab.waitForCompletion(async () => {
+      await tab.page.mouse.move(params.startX, params.startY);
+      await tab.page.mouse.down();
+      await tab.page.mouse.move(params.endX, params.endY);
+      await tab.page.mouse.up();
+    });
+  }
+});
+var mouse_default = [
+  mouseMove,
+  mouseClick,
+  mouseDrag,
+  mouseDown,
+  mouseUp,
+  mouseWheel
+];

package/lib/tools/backend/navigate.js

@@ -0,0 +1,106 @@
+"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 navigate_exports = {};
+__export(navigate_exports, {
+  default: () => navigate_default
+});
+module.exports = __toCommonJS(navigate_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_tool = require("./tool");
+const navigate = (0, import_tool.defineTool)({
+  capability: "core-navigation",
+  schema: {
+    name: "browser_navigate",
+    title: "Navigate to a URL",
+    description: "Navigate to a URL",
+    inputSchema: import_zodBundle.z.object({
+      url: import_zodBundle.z.string().describe("The URL to navigate to")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const tab = await context.ensureTab();
+    let url = params.url;
+    try {
+      new URL(url);
+    } catch (e) {
+      if (url.startsWith("localhost"))
+        url = "http://" + url;
+      else
+        url = "https://" + url;
+    }
+    context.checkUrlAllowed(url);
+    await tab.navigate(url);
+    response.setIncludeSnapshot();
+    response.addCode(`await page.goto('${url}');`);
+  }
+});
+const goBack = (0, import_tool.defineTabTool)({
+  capability: "core-navigation",
+  schema: {
+    name: "browser_navigate_back",
+    title: "Go back",
+    description: "Go back to the previous page in the history",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    await tab.page.goBack(tab.navigationTimeoutOptions);
+    response.setIncludeSnapshot();
+    response.addCode(`await page.goBack();`);
+  }
+});
+const goForward = (0, import_tool.defineTabTool)({
+  capability: "core-navigation",
+  skillOnly: true,
+  schema: {
+    name: "browser_navigate_forward",
+    title: "Go forward",
+    description: "Go forward to the next page in the history",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    await tab.page.goForward(tab.navigationTimeoutOptions);
+    response.setIncludeSnapshot();
+    response.addCode(`await page.goForward();`);
+  }
+});
+const reload = (0, import_tool.defineTabTool)({
+  capability: "core-navigation",
+  skillOnly: true,
+  schema: {
+    name: "browser_reload",
+    title: "Reload the page",
+    description: "Reload the current page",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    await tab.page.reload(tab.navigationTimeoutOptions);
+    response.setIncludeSnapshot();
+    response.addCode(`await page.reload();`);
+  }
+});
+var navigate_default = [
+  navigate,
+  goBack,
+  goForward,
+  reload
+];

package/lib/tools/backend/network.js

@@ -0,0 +1,135 @@
+"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 network_exports = {};
+__export(network_exports, {
+  default: () => network_default,
+  isFetch: () => isFetch,
+  renderRequest: () => renderRequest
+});
+module.exports = __toCommonJS(network_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_tool = require("./tool");
+const requests = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_network_requests",
+    title: "List network requests",
+    description: "Returns all network requests since loading the page",
+    inputSchema: import_zodBundle.z.object({
+      static: import_zodBundle.z.boolean().default(false).describe("Whether to include successful static resources like images, fonts, scripts, etc. Defaults to false."),
+      requestBody: import_zodBundle.z.boolean().default(false).describe("Whether to include request body. Defaults to false."),
+      requestHeaders: import_zodBundle.z.boolean().default(false).describe("Whether to include request headers. Defaults to false."),
+      filter: import_zodBundle.z.string().optional().describe('Only return requests whose URL matches this regexp (e.g. "/api/.*user").'),
+      filename: import_zodBundle.z.string().optional().describe("Filename to save the network requests to. If not provided, requests are returned as text.")
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const requests2 = await tab.requests();
+    const filter = params.filter ? new RegExp(params.filter) : void 0;
+    const text = [];
+    for (const request of requests2) {
+      if (!params.static && !isFetch(request) && isSuccessfulResponse(request))
+        continue;
+      if (filter) {
+        filter.lastIndex = 0;
+        if (!filter.test(request.url()))
+          continue;
+      }
+      text.push(await renderRequest(request, params.requestBody, params.requestHeaders));
+    }
+    await response.addResult("Network", text.join("\n"), { prefix: "network", ext: "log", suggestedFilename: params.filename });
+  }
+});
+const networkClear = (0, import_tool.defineTabTool)({
+  capability: "core",
+  skillOnly: true,
+  schema: {
+    name: "browser_network_clear",
+    title: "Clear network requests",
+    description: "Clear all network requests",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    await tab.clearRequests();
+  }
+});
+function isSuccessfulResponse(request) {
+  if (request.failure())
+    return false;
+  const response = request.existingResponse();
+  return !!response && response.status() < 400;
+}
+function isFetch(request) {
+  return ["fetch", "xhr"].includes(request.resourceType());
+}
+async function renderRequest(request, includeBody = false, includeHeaders = false) {
+  const response = request.existingResponse();
+  const result = [];
+  result.push(`[${request.method().toUpperCase()}] ${request.url()}`);
+  if (response)
+    result.push(` => [${response.status()}] ${response.statusText()}`);
+  else if (request.failure())
+    result.push(` => [FAILED] ${request.failure()?.errorText ?? "Unknown error"}`);
+  if (includeHeaders) {
+    const headers = request.headers();
+    const headerLines = Object.entries(headers).map(([k, v]) => `    ${k}: ${v}`).join("\n");
+    if (headerLines)
+      result.push(`
+  Request headers:
+${headerLines}`);
+  }
+  if (includeBody) {
+    const postData = request.postData();
+    if (postData)
+      result.push(`
+  Request body: ${postData}`);
+  }
+  return result.join("");
+}
+const networkStateSet = (0, import_tool.defineTool)({
+  capability: "network",
+  schema: {
+    name: "browser_network_state_set",
+    title: "Set network state",
+    description: "Sets the browser network state to online or offline. When offline, all network requests will fail.",
+    inputSchema: import_zodBundle.z.object({
+      state: import_zodBundle.z.enum(["online", "offline"]).describe('Set to "offline" to simulate offline mode, "online" to restore network connectivity')
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    const offline = params.state === "offline";
+    await browserContext.setOffline(offline);
+    response.addTextResult(`Network is now ${params.state}`);
+    response.addCode(`await page.context().setOffline(${offline});`);
+  }
+});
+var network_default = [
+  requests,
+  networkClear,
+  networkStateSet
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFetch,
+  renderRequest
+});

package/lib/tools/backend/pdf.js

@@ -0,0 +1,48 @@
+"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 pdf_exports = {};
+__export(pdf_exports, {
+  default: () => pdf_default
+});
+module.exports = __toCommonJS(pdf_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_stringUtils = require("../../utils/isomorphic/stringUtils");
+var import_tool = require("./tool");
+const pdfSchema = import_zodBundle.z.object({
+  filename: import_zodBundle.z.string().optional().describe("File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified. Prefer relative file names to stay within the output directory.")
+});
+const pdf = (0, import_tool.defineTabTool)({
+  capability: "pdf",
+  schema: {
+    name: "browser_pdf_save",
+    title: "Save as PDF",
+    description: "Save page as PDF",
+    inputSchema: pdfSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const data = await tab.page.pdf();
+    const result = await response.resolveClientFile({ prefix: "page", ext: "pdf", suggestedFilename: params.filename }, "Page as pdf");
+    await response.addFileResult(result, data);
+    response.addCode(`await page.pdf(${(0, import_stringUtils.formatObject)({ path: result.relativeName })});`);
+  }
+});
+var pdf_default = [
+  pdf
+];