patchright-core 1.57.0 → 1.58.2

package/lib/server/dispatchers/pageAgentDispatcher.js

@@ -0,0 +1,96 @@
+"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 pageAgentDispatcher_exports = {};
+__export(pageAgentDispatcher_exports, {
+  PageAgentDispatcher: () => PageAgentDispatcher
+});
+module.exports = __toCommonJS(pageAgentDispatcher_exports);
+var import_dispatcher = require("./dispatcher");
+var import_pageAgent = require("../agent/pageAgent");
+var import_instrumentation = require("../instrumentation");
+var import_context = require("../agent/context");
+class PageAgentDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, options) {
+    super(scope, new import_instrumentation.SdkObject(scope._object, "pageAgent"), "PageAgent", { page: scope });
+    this._type_PageAgent = true;
+    this._type_EventTarget = true;
+    this._usage = { turns: 0, inputTokens: 0, outputTokens: 0 };
+    this._page = scope._object;
+    this._context = new import_context.Context(this._page, options, this._eventSupport());
+  }
+  async perform(params, progress) {
+    try {
+      await (0, import_pageAgent.pageAgentPerform)(progress, this._context, params.task, params);
+    } finally {
+      this._context.pushHistory({ type: "perform", description: params.task });
+    }
+    return { usage: this._usage };
+  }
+  async expect(params, progress) {
+    try {
+      await (0, import_pageAgent.pageAgentExpect)(progress, this._context, params.expectation, params);
+    } finally {
+      this._context.pushHistory({ type: "expect", description: params.expectation });
+    }
+    return { usage: this._usage };
+  }
+  async extract(params, progress) {
+    const result = await (0, import_pageAgent.pageAgentExtract)(progress, this._context, params.query, params.schema, params);
+    return { result, usage: this._usage };
+  }
+  async usage(params, progress) {
+    return { usage: this._usage };
+  }
+  async dispose(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
+    void this.stopPendingOperations(new Error("The agent is disposed"));
+    this._dispose();
+  }
+  _eventSupport() {
+    const self = this;
+    return {
+      onBeforeTurn(params) {
+        const userMessage = params.conversation.messages.find((m) => m.role === "user");
+        self._dispatchEvent("turn", { role: "user", message: userMessage?.content ?? "" });
+      },
+      onAfterTurn(params) {
+        const usage = { inputTokens: params.totalUsage.input, outputTokens: params.totalUsage.output };
+        const intent = params.assistantMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+        self._dispatchEvent("turn", { role: "assistant", message: intent, usage });
+        if (!params.assistantMessage.content.filter((c) => c.type === "tool_call").length)
+          self._dispatchEvent("turn", { role: "assistant", message: `no tool calls`, usage });
+        self._usage = { turns: self._usage.turns + 1, inputTokens: self._usage.inputTokens + usage.inputTokens, outputTokens: self._usage.outputTokens + usage.outputTokens };
+      },
+      onBeforeToolCall(params) {
+        self._dispatchEvent("turn", { role: "assistant", message: `call tool "${params.toolCall.name}"` });
+      },
+      onAfterToolCall(params) {
+        const suffix = params.toolCall.result?.isError ? "failed" : "succeeded";
+        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" ${suffix}` });
+      },
+      onToolCallError(params) {
+        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" failed: ${params.error.message}` });
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PageAgentDispatcher
+});

package/lib/server/dispatchers/pageDispatcher.js

@@ -36,6 +36,7 @@ var import_networkDispatchers3 = require("./networkDispatchers");
 var import_webSocketRouteDispatcher = require("./webSocketRouteDispatcher");
 var import_instrumentation = require("../instrumentation");
 var import_urlMatch = require("../../utils/isomorphic/urlMatch");
+var import_pageAgentDispatcher = require("./pageAgentDispatcher");
 class PageDispatcher extends import_dispatcher.Dispatcher {
   constructor(parentScope, page) {
     const mainFrame = import_frameDispatcher.FrameDispatcher.from(parentScope, page.mainFrame());
@@ -288,6 +289,9 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     const coverage = this._page.coverage;
     return await coverage.stopCSSCoverage();
   }
+  async agent(params, progress) {
+    return { agent: new import_pageAgentDispatcher.PageAgentDispatcher(this, params) };
+  }
   _onFrameAttached(frame) {
     this._dispatchEvent("frameAttached", { frame: import_frameDispatcher.FrameDispatcher.from(this.parentScope(), frame) });
   }

package/lib/server/dom.js

@@ -255,6 +255,7 @@ class ElementHandle extends js.JSHandle {
   async _retryAction(progress, actionName, action, options) {
     let retry = 0;
     const waitTime = [0, 20, 100, 100, 500];
+    const noAutoWaiting = options.__testHookNoAutoWaiting ?? options.noAutoWaiting;
     while (true) {
       if (retry) {
         progress.log(`retrying ${actionName} action${options.trial ? " (trial run)" : ""}`);
@@ -268,35 +269,43 @@ class ElementHandle extends js.JSHandle {
       } else {
         progress.log(`attempting ${actionName} action${options.trial ? " (trial run)" : ""}`);
       }
-      if (!options.skipActionPreChecks && !options.force)
+      if (!options.skipActionPreChecks && !options.force && !noAutoWaiting)
         await this._frame._page.performActionPreChecks(progress);
       const result = await action(retry);
       ++retry;
       if (result === "error:notvisible") {
-        if (options.force)
+        if (options.force || noAutoWaiting)
           throw new NonRecoverableDOMError("Element is not visible");
         progress.log("  element is not visible");
         continue;
       }
       if (result === "error:notinviewport") {
-        if (options.force)
+        if (options.force || noAutoWaiting)
           throw new NonRecoverableDOMError("Element is outside of the viewport");
         progress.log("  element is outside of the viewport");
         continue;
       }
       if (result === "error:optionsnotfound") {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError("Did not find some options");
         progress.log("  did not find some options");
         continue;
       }
       if (result === "error:optionnotenabled") {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError("Option being selected is not enabled");
         progress.log("  option being selected is not enabled");
         continue;
       }
       if (typeof result === "object" && "hitTargetDescription" in result) {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError(`${result.hitTargetDescription} intercepts pointer events`);
         progress.log(`  ${result.hitTargetDescription} intercepts pointer events`);
         continue;
       }
       if (typeof result === "object" && "missingState" in result) {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError(`Element is not ${result.missingState}`);
         progress.log(`  element is not ${result.missingState}`);
         continue;
       }

package/lib/server/electron/electron.js

@@ -158,8 +158,8 @@ class Electron extends import_instrumentation.SdkObject {
     let shell = false;
     if (process.platform === "win32") {
       shell = true;
-      command = `"${command}"`;
-      electronArguments = electronArguments.map((arg) => `"${arg}"`);
+      command = [command, ...electronArguments].map((arg) => `"${escapeDoubleQuotes(arg)}"`).join(" ");
+      electronArguments = [];
     }
     delete env.NODE_OPTIONS;
     const { launchedProcess, gracefullyClose, kill } = await (0, import_processLauncher.launchProcess)({
@@ -263,6 +263,9 @@ async function waitForLine(progress, process2, regex) {
     import_eventsHelper.eventsHelper.removeEventListeners(listeners);
   }
 }
+function escapeDoubleQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Electron,

package/lib/server/firefox/ffBrowser.js

@@ -54,7 +54,6 @@ class FFBrowser extends import_browser.Browser {
     this.session.on("Browser.detachedFromTarget", this._onDetachedFromTarget.bind(this));
     this.session.on("Browser.downloadCreated", this._onDownloadCreated.bind(this));
     this.session.on("Browser.downloadFinished", this._onDownloadFinished.bind(this));
-    this.session.on("Browser.videoRecordingFinished", this._onVideoRecordingFinished.bind(this));
   }
   static async connect(parent, transport, options) {
     const connection = new import_ffConnection.FFConnection(transport, options.protocolLogger, options.browserLogsCollector);
@@ -141,12 +140,9 @@ class FFBrowser extends import_browser.Browser {
     const error = payload.canceled ? "canceled" : payload.error;
     this._downloadFinished(payload.uuid, error);
   }
-  _onVideoRecordingFinished(payload) {
-    this._takeVideo(payload.screencastId)?.reportFinished();
-  }
   _onDisconnect() {
     for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError());
+      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
     this._idToVideo.clear();
     for (const ffPage of this._ffPages.values())
       ffPage.didClose();
@@ -199,15 +195,13 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
       promises.push(this.doUpdateOffline());
     promises.push(this.doUpdateDefaultEmulatedMedia());
     if (this._options.recordVideo) {
-      promises.push(this._ensureVideosPath().then(() => {
-        return this._browser.session.send("Browser.setVideoRecordingOptions", {
-          // validateBrowserContextOptions ensures correct video size.
-          options: {
-            ...this._options.recordVideo.size,
-            dir: this._options.recordVideo.dir
-          },
-          browserContextId: this._browserContextId
-        });
+      promises.push(this._browser.session.send("Browser.setScreencastOptions", {
+        // validateBrowserContextOptions ensures correct video size.
+        options: {
+          ...this._options.recordVideo.size,
+          quality: 90
+        },
+        browserContextId: this._browserContextId
       }));
     }
     const proxy = this._options.proxyOverride || this._options.proxy;
@@ -379,12 +373,8 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      if (this._options.recordVideo) {
-        await this._browser.session.send("Browser.setVideoRecordingOptions", {
-          options: void 0,
-          browserContextId: this._browserContextId
-        });
-      }
+      if (this._options.recordVideo)
+        await Promise.all(this._ffPages().map((ffPage) => ffPage._page.screencast.stopVideoRecording()));
       await this._browser.close({ reason });
     } else {
       await this._browser.session.send("Browser.removeBrowserContext", { browserContextId: this._browserContextId });

package/lib/server/firefox/ffConnection.js

@@ -90,11 +90,6 @@ class FFSession extends import_events.EventEmitter {
     this._connection = connection;
     this._sessionId = sessionId;
     this._rawSend = rawSend;
-    this.on = super.on;
-    this.addListener = super.addListener;
-    this.off = super.removeListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
   }
   markAsCrashed() {
     this._crashed = true;

package/lib/server/firefox/ffNetworkManager.js

@@ -170,9 +170,9 @@ const causeToResourceType = {
   TYPE_FONT: "font",
   TYPE_MEDIA: "media",
   TYPE_WEBSOCKET: "websocket",
-  TYPE_CSP_REPORT: "other",
+  TYPE_CSP_REPORT: "cspreport",
   TYPE_XSLT: "other",
-  TYPE_BEACON: "other",
+  TYPE_BEACON: "beacon",
   TYPE_FETCH: "fetch",
   TYPE_IMAGESET: "image",
   TYPE_WEB_MANIFEST: "manifest"

package/lib/server/firefox/ffPage.js

@@ -41,9 +41,9 @@ var import_ffConnection = require("./ffConnection");
 var import_ffExecutionContext = require("./ffExecutionContext");
 var import_ffInput = require("./ffInput");
 var import_ffNetworkManager = require("./ffNetworkManager");
-var import_debugLogger = require("../utils/debugLogger");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var import_errors = require("../errors");
+var import_debugLogger = require("../utils/debugLogger");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
 class FFPage {
   constructor(session, browserContext, opener) {
@@ -83,13 +83,16 @@ class FFPage {
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.workerDestroyed", this._onWorkerDestroyed.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.dispatchMessageFromWorker", this._onDispatchMessageFromWorker.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.crashed", this._onCrashed.bind(this)),
-      import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.videoRecordingStarted", this._onVideoRecordingStarted.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketCreated", this._onWebSocketCreated.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketClosed", this._onWebSocketClosed.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketFrameReceived", this._onWebSocketFrameReceived.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketFrameSent", this._onWebSocketFrameSent.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.screencastFrame", this._onScreencastFrame.bind(this))
     ];
+    const screencast = this._page.screencast;
+    const videoOptions = screencast.launchVideoRecorder();
+    if (videoOptions)
+      screencast.startVideoRecording(videoOptions).catch((e) => import_debugLogger.debugLogger.log("error", e));
     this._session.once("Page.ready", () => {
       if (this._reportedAsNew)
         return;
@@ -272,11 +275,8 @@ class FFPage {
     this._session.markAsCrashed();
     this._page._didCrash();
   }
-  _onVideoRecordingStarted(event) {
-    this._browserContext._browser._videoStarted(this._browserContext, event.screencastId, event.file, this._page.waitForInitializedOrError());
-  }
   didClose() {
-    this._markAsError(new import_errors.TargetClosedError());
+    this._markAsError(new import_errors.TargetClosedError(this._page.closeReason()));
     this._session.dispose();
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
     this._networkManager.dispose();
@@ -417,24 +417,21 @@ class FFPage {
       throw e;
     });
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      const { screencastId } = await this._session.send("Page.startScreencast", options);
-      this._screencastId = screencastId;
-    } else {
-      await this._session.send("Page.stopScreencast");
-    }
+  async startScreencast(options) {
+    await this._session.send("Page.startScreencast", options);
+  }
+  async stopScreencast() {
+    await this._session.sendMayFail("Page.stopScreencast");
   }
   _onScreencastFrame(event) {
-    if (!this._screencastId)
-      return;
-    const screencastId = this._screencastId;
-    this._page.throttleScreencastFrameAck(() => {
-      this._session.send("Page.screencastFrameAck", { screencastId }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+    this._page.screencast.throttleFrameAck(() => {
+      this._session.sendMayFail("Page.screencastFrameAck");
     });
     const buffer = Buffer.from(event.data, "base64");
     this._page.emit(import_page2.Page.Events.ScreencastFrame, {
       buffer,
+      frameSwapWallTime: event.timestamp * 1e3,
+      // timestamp is in seconds, we need to convert to milliseconds.
       width: event.deviceWidth,
       height: event.deviceHeight
     });

package/lib/server/firefox/firefox.js

@@ -56,15 +56,13 @@ class Firefox extends import_browserType.BrowserType {
   connectToTransport(transport, options) {
     return import_ffBrowser.FFBrowser.connect(this.attribution.playwright, transport, options);
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes(`as root in a regular user's session is not supported.`))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
+  doRewriteStartupLog(logs) {
+    if (logs.includes(`as root in a regular user's session is not supported.`))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(`Firefox is unable to launch if the $HOME folder isn't owned by the current user.
 Workaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ? " in your GitHub Actions workflow file" : ""} when running Playwright.`, 1);
-    if (error.logs.includes("no DISPLAY environment variable specified"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    return error;
+    if (logs.includes("no DISPLAY environment variable specified"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
   }
   amendEnvironment(env) {
     if (!import_path.default.isAbsolute(import_os.default.homedir()))

package/lib/server/frameSelectors.js

@@ -51,7 +51,9 @@ class FrameSelectors {
     if (!resolved)
       throw new Error(`Failed to find frame for selector "${selector}"`);
     return await resolved.injected.evaluateHandle((injected, { info, scope: scope2 }) => {
-      return injected.querySelectorAll(info.parsed, scope2 || document);
+      const elements = injected.querySelectorAll(info.parsed, scope2 || document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements;
     }, { info: resolved.info, scope: resolved.scope });
   }
   async queryCount(selector, options) {
@@ -60,7 +62,9 @@ class FrameSelectors {
       throw new Error(`Failed to find frame for selector "${selector}"`);
     await options.__testHookBeforeQuery?.();
     return await resolved.injected.evaluate((injected, { info }) => {
-      return injected.querySelectorAll(info.parsed, document).length;
+      const elements = injected.querySelectorAll(info.parsed, document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements.length;
     }, { info: resolved.info });
   }
   async queryAll(selector, scope) {
@@ -68,7 +72,9 @@ class FrameSelectors {
     if (!resolved)
       return [];
     const arrayHandle = await resolved.injected.evaluateHandle((injected, { info, scope: scope2 }) => {
-      return injected.querySelectorAll(info.parsed, scope2 || document);
+      const elements = injected.querySelectorAll(info.parsed, scope2 || document);
+      injected.checkDeprecatedSelectorUsage(info.parsed, elements);
+      return elements;
     }, { info: resolved.info, scope: resolved.scope });
     const properties = await arrayHandle.getProperties();
     arrayHandle.dispose();
@@ -158,6 +164,7 @@ class FrameSelectors {
     if (!resolved)
       return;
     const context = await resolved.frame._context(options?.mainWorld ? "main" : resolved.info.world);
+    if (!context) throw new Error("Frame was detached");
     const injected = await context.injectedScript();
     return { injected, info: resolved.info, frame: resolved.frame, scope: resolved.scope };
   }
@@ -287,7 +294,7 @@ class FrameSelectors {
     }
     for (const child of queryingElement.children || []) {
       const childrenNodeIndex = queryingElement.children.indexOf(child);
-      const childIndex = this._findElementPositionInDomTree(element, child, documentScope, currentIndex + childrenNodeIndex.toString());
+      const childIndex = this._findElementPositionInDomTree(element, child, documentScope, currentIndex + "." + childrenNodeIndex.toString());
       if (childIndex !== null) return childIndex;
     }
     if (queryingElement.shadowRoots && Array.isArray(queryingElement.shadowRoots)) {
@@ -297,6 +304,11 @@ class FrameSelectors {
           const childIndex = this._findElementPositionInDomTree(element, shadowRootHandle, documentScope, currentIndex);
           if (childIndex !== null) return childIndex;
         }
+        for (const shadowChild of shadowRoot.children || []) {
+          const shadowChildIndex = (shadowRoot.children || []).indexOf(shadowChild);
+          const childIndex = this._findElementPositionInDomTree(element, shadowChild, documentScope, currentIndex + "." + shadowChildIndex.toString());
+          if (childIndex !== null) return childIndex;
+        }
       }
     }
     return null;