patchright-core 1.57.0 → 1.58.2

package/browsers.json

@@ -3,59 +3,58 @@
   "browsers": [
     {
       "name": "chromium",
-      "revision": "1200",
+      "revision": "1208",
       "installByDefault": true,
-      "browserVersion": "143.0.7499.4"
+      "browserVersion": "145.0.7632.6",
+      "title": "Chrome for Testing"
     },
     {
       "name": "chromium-headless-shell",
-      "revision": "1200",
+      "revision": "1208",
       "installByDefault": true,
-      "browserVersion": "143.0.7499.4"
+      "browserVersion": "145.0.7632.6",
+      "title": "Chrome Headless Shell"
     },
     {
       "name": "chromium-tip-of-tree",
-      "revision": "1380",
+      "revision": "1401",
       "installByDefault": false,
-      "browserVersion": "143.0.7488.0"
+      "browserVersion": "146.0.7644.0",
+      "title": "Chrome Canary for Testing"
     },
     {
       "name": "chromium-tip-of-tree-headless-shell",
-      "revision": "1380",
+      "revision": "1401",
       "installByDefault": false,
-      "browserVersion": "143.0.7488.0"
+      "browserVersion": "146.0.7644.0",
+      "title": "Chrome Canary Headless Shell"
     },
     {
       "name": "firefox",
-      "revision": "1497",
+      "revision": "1509",
       "installByDefault": true,
-      "browserVersion": "144.0.2"
+      "browserVersion": "146.0.1",
+      "title": "Firefox"
     },
     {
       "name": "firefox-beta",
-      "revision": "1493",
+      "revision": "1504",
       "installByDefault": false,
-      "browserVersion": "145.0b10"
+      "browserVersion": "146.0b8",
+      "title": "Firefox Beta"
     },
     {
       "name": "webkit",
-      "revision": "2227",
+      "revision": "2248",
       "installByDefault": true,
       "revisionOverrides": {
         "debian11-x64": "2105",
         "debian11-arm64": "2105",
-        "mac10.14": "1446",
-        "mac10.15": "1616",
-        "mac11": "1816",
-        "mac11-arm64": "1816",
-        "mac12": "2009",
-        "mac12-arm64": "2009",
-        "mac13": "2140",
-        "mac13-arm64": "2140",
         "ubuntu20.04-x64": "2092",
         "ubuntu20.04-arm64": "2092"
       },
-      "browserVersion": "26.0"
+      "browserVersion": "26.0",
+      "title": "WebKit"
     },
     {
       "name": "ffmpeg",

package/lib/cli/program.js

@@ -124,7 +124,7 @@ Playwright version: ${version}`);
     printInstalledBrowsers(groupedByPlaywrightMinorVersion.get(version));
   }
 }
-import_utilsBundle.program.command("install [browser...]").description("ensure browsers necessary for this version of Playwright are installed").option("--with-deps", "install system dependencies for browsers").option("--dry-run", "do not execute installation, only print information").option("--list", "prints list of browsers from all playwright installations").option("--force", "force reinstall of stable browser channels").option("--only-shell", "only install headless shell when installing chromium").option("--no-shell", "do not install chromium headless shell").action(async function(args, options) {
+import_utilsBundle.program.command("install [browser...]").description("ensure browsers necessary for this version of Playwright are installed").option("--with-deps", "install system dependencies for browsers").option("--dry-run", "do not execute installation, only print information").option("--list", "prints list of browsers from all playwright installations").option("--force", "force reinstall of already installed browsers").option("--only-shell", "only install headless shell when installing chromium").option("--no-shell", "do not install chromium headless shell").action(async function(args, options) {
   if ((0, import_utils.isLikelyNpxGlobal)()) {
     console.error((0, import_ascii.wrapInASCIIBox)([
       `WARNING: It looks like you are running 'npx playwright install' without first`,
@@ -156,8 +156,7 @@ import_utilsBundle.program.command("install [browser...]").description("ensure b
       throw new Error(`Only one of --dry-run and --list can be specified`);
     if (options.dryRun) {
       for (const executable of executables) {
-        const version = executable.browserVersion ? `version ` + executable.browserVersion : "";
-        console.log(`browser: ${executable.name}${version ? " " + version : ""}`);
+        console.log(import_server.registry.calculateDownloadTitle(executable));
         console.log(`  Install location:    ${executable.directory ?? "<system>"}`);
         if (executable.downloadURLs?.length) {
           const [url, ...fallbacks] = executable.downloadURLs;
@@ -171,8 +170,7 @@ import_utilsBundle.program.command("install [browser...]").description("ensure b
       const browsers2 = await import_server.registry.listInstalledBrowsers();
       printGroupedByPlaywrightVersion(browsers2);
     } else {
-      const force = args.length === 0 ? false : !!options.force;
-      await import_server.registry.install(executables, { force });
+      await import_server.registry.install(executables, { force: options.force });
       await import_server.registry.validateHostRequirementsForExecutablesIfNeeded(executables, process.env.PW_LANG_NAME || "javascript").catch((e) => {
         e.name = "Playwright Host validation warning";
         console.error(e);
@@ -423,6 +421,7 @@ async function openPage(context, url) {
 }
 async function open(options, url) {
   const { context } = await launchContext(options, { headless: !!process.env.PWTEST_CLI_HEADLESS, executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH });
+  await context._exposeConsoleApi();
   await openPage(context, url);
 }
 async function codegen(options, url) {

package/lib/client/api.js

@@ -46,6 +46,7 @@ __export(api_exports, {
   Locator: () => import_locator.Locator,
   Mouse: () => import_input.Mouse,
   Page: () => import_page.Page,
+  PageAgent: () => import_pageAgent.PageAgent,
   Playwright: () => import_playwright.Playwright,
   Request: () => import_network.Request,
   Response: () => import_network.Response,
@@ -81,6 +82,7 @@ var import_jsHandle = require("./jsHandle");
 var import_network = require("./network");
 var import_fetch = require("./fetch");
 var import_page = require("./page");
+var import_pageAgent = require("./pageAgent");
 var import_selectors = require("./selectors");
 var import_tracing = require("./tracing");
 var import_video = require("./video");
@@ -118,6 +120,7 @@ var import_webError = require("./webError");
   Locator,
   Mouse,
   Page,
+  PageAgent,
   Playwright,
   Request,
   Response,

package/lib/client/browser.js

@@ -62,11 +62,9 @@ class Browser extends import_channelOwner.ChannelOwner {
     context._onClose();
     await this._channel.disconnectFromReusedContext({ reason });
   }
-  async _innerNewContext(options = {}, forReuse) {
-    options = this._browserType._playwright.selectors._withSelectorOptions({
-      ...this._browserType._playwright._defaultContextOptions,
-      ...options
-    });
+  async _innerNewContext(userOptions = {}, forReuse) {
+    const options = this._browserType._playwright.selectors._withSelectorOptions(userOptions);
+    await this._instrumentation.runBeforeCreateBrowserContext(options);
     const contextOptions = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
     const response = forReuse ? await this._channel.newContextForReuse(contextOptions) : await this._channel.newContext(contextOptions);
     const context = import_browserContext.BrowserContext.from(response.context);

package/lib/client/browserContext.js

@@ -77,6 +77,7 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this.tracing = import_tracing.Tracing.from(initializer.tracing);
     this.request = import_fetch.APIRequestContext.from(initializer.requestContext);
     this.request._timeoutSettings = this._timeoutSettings;
+    this.request._checkUrlAllowed = (url) => this._checkUrlAllowed(url);
     this.clock = new import_clock.Clock(this);
     this._channel.on("bindingCall", ({ binding }) => this._onBinding(import_page.BindingCall.from(binding)));
     this._channel.on("close", () => this._onClose());
@@ -119,11 +120,11 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
         hasListeners = page.emit(import_events.Events.Page.Dialog, dialogObject) || hasListeners;
       if (!hasListeners) {
         if (dialogObject.type() === "beforeunload")
-          dialog.accept({}).catch(() => {
-          });
+          dialogObject._wrapApiCall(() => dialog.accept({}).catch(() => {
+          }), { internal: true });
         else
-          dialog.dismiss().catch(() => {
-          });
+          dialogObject._wrapApiCall(() => dialog.dismiss().catch(() => {
+          }), { internal: true });
       }
     });
     this._channel.on("request", ({ request, page }) => this._onRequest(network.Request.from(request), import_page.Page.fromNullable(page)));
@@ -478,6 +479,40 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this._onRecorderEventSink = void 0;
     await this._channel.disableRecorder();
   }
+  async _exposeConsoleApi() {
+    await this._channel.exposeConsoleApi();
+  }
+  _setAllowedProtocols(protocols) {
+    this._allowedProtocols = protocols;
+  }
+  _checkUrlAllowed(url) {
+    if (!this._allowedProtocols)
+      return;
+    let parsedURL;
+    try {
+      parsedURL = new URL(url);
+    } catch (e) {
+      throw new Error(`Access to ${url} is blocked. Invalid URL: ${e.message}`);
+    }
+    if (!this._allowedProtocols.includes(parsedURL.protocol))
+      throw new Error(`Access to "${parsedURL.protocol}" URL is blocked. Allowed protocols: ${this._allowedProtocols.join(", ")}. Attempted URL: ${url}`);
+  }
+  _setAllowedDirectories(rootDirectories) {
+    this._allowedDirectories = rootDirectories;
+  }
+  _checkFileAccess(filePath) {
+    if (!this._allowedDirectories)
+      return;
+    const path = this._platform.path().resolve(filePath);
+    const isInsideDir = (container, child) => {
+      const path2 = this._platform.path();
+      const rel = path2.relative(container, child);
+      return !!rel && !rel.startsWith("..") && !path2.isAbsolute(rel);
+    };
+    if (this._allowedDirectories.some((root) => isInsideDir(root, path)))
+      return;
+    throw new Error(`File access denied: ${filePath} is outside allowed roots. Allowed roots: ${this._allowedDirectories.length ? this._allowedDirectories.join(", ") : "none"}`);
+  }
   async installInjectRoute() {
     if (this.routeInjecting) return;
     await this.route("**/*", async (route) => {
@@ -492,6 +527,7 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
         await route.fallback();
       }
     });
+    this.routeInjecting = true;
   }
 }
 async function prepareStorageState(platform, storageState) {

package/lib/client/browserType.js

@@ -73,13 +73,13 @@ class BrowserType extends import_channelOwner.ChannelOwner {
     return await this._serverLauncher.launchServer(options);
   }
   async launchPersistentContext(userDataDir, options = {}) {
-    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
     (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
     options = this._playwright.selectors._withSelectorOptions({
       ...this._playwright._defaultLaunchOptions,
-      ...this._playwright._defaultContextOptions,
       ...options
     });
+    await this._instrumentation.runBeforeCreateBrowserContext(options);
+    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
     const contextParams = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
     const persistentParams = {
       ...contextParams,
@@ -169,7 +169,8 @@ class BrowserType extends import_channelOwner.ChannelOwner {
       endpointURL,
       headers,
       slowMo: params.slowMo,
-      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).timeout(params)
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).timeout(params),
+      isLocal: params.isLocal
     });
     const browser = import_browser.Browser.from(result.browser);
     browser._connectToBrowserType(this, {}, params.logger);

package/lib/client/connection.js

@@ -48,6 +48,7 @@ var import_worker = require("./worker");
 var import_writableStream = require("./writableStream");
 var import_validator = require("../protocol/validator");
 var import_stackTrace = require("../utils/isomorphic/stackTrace");
+var import_pageAgent = require("./pageAgent");
 class Root extends import_channelOwner.ChannelOwner {
   constructor(connection) {
     super(connection, "Root", "", {});
@@ -261,6 +262,9 @@ class Connection extends import_eventEmitter.EventEmitter {
       case "Page":
         result = new import_page.Page(parent, type, guid, initializer);
         break;
+      case "PageAgent":
+        result = new import_pageAgent.PageAgent(parent, type, guid, initializer);
+        break;
       case "Playwright":
         result = new import_playwright.Playwright(parent, type, guid, initializer);
         break;

package/lib/client/elementHandle.js

@@ -230,6 +230,9 @@ async function convertInputFiles(platform, files, context) {
     if (!items.every((item) => typeof item === "string"))
       throw new Error("File paths cannot be mixed with buffers");
     const [localPaths, localDirectory] = await resolvePathsAndDirectoryForInputFiles(platform, items);
+    localPaths?.forEach((path) => context._checkFileAccess(path));
+    if (localDirectory)
+      context._checkFileAccess(localDirectory);
     if (context._connection.isRemote()) {
       const files2 = localDirectory ? (await platform.fs().promises.readdir(localDirectory, { withFileTypes: true, recursive: true })).filter((f) => f.isFile()).map((f) => platform.path().join(f.path, f.name)) : localPaths;
       const { writableStreams, rootDir } = await context._wrapApiCall(async () => context._channel.createTempFiles({

package/lib/client/events.js

@@ -78,6 +78,9 @@ const Events = {
     WebSocket: "websocket",
     Worker: "worker"
   },
+  PageAgent: {
+    Turn: "turn"
+  },
   WebSocket: {
     Close: "close",
     Error: "socketerror",

package/lib/client/fetch.js

@@ -39,10 +39,8 @@ class APIRequest {
     this._playwright = playwright;
   }
   async newContext(options = {}) {
-    options = {
-      ...this._playwright._defaultContextOptions,
-      ...options
-    };
+    options = { ...options };
+    await this._playwright._instrumentation.runBeforeCreateRequestContext(options);
     const storageState = typeof options.storageState === "string" ? JSON.parse(await this._playwright._platform.fs().promises.readFile(options.storageState, "utf8")) : options.storageState;
     const context = APIRequestContext.from((await this._playwright._channel.newRequest({
       ...options,
@@ -135,6 +133,7 @@ class APIRequestContext extends import_channelOwner.ChannelOwner {
       (0, import_assert.assert)(options.maxRedirects === void 0 || options.maxRedirects >= 0, `'maxRedirects' must be greater than or equal to '0'`);
       (0, import_assert.assert)(options.maxRetries === void 0 || options.maxRetries >= 0, `'maxRetries' must be greater than or equal to '0'`);
       const url = options.url !== void 0 ? options.url : options.request.url();
+      this._checkUrlAllowed?.(url);
       const method = options.method || options.request?.method();
       let encodedParams = void 0;
       if (typeof options.params === "string")

package/lib/client/frame.js

@@ -101,6 +101,7 @@ class Frame extends import_channelOwner.ChannelOwner {
   }
   async goto(url, options = {}) {
     const waitUntil = verifyLoadState("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
+    this.page().context()._checkUrlAllowed(url);
     return network.Response.fromNullable((await this._channel.goto({ url, ...options, waitUntil, timeout: this._navigationTimeout(options) })).response);
   }
   _setupNavigationWaiter(options) {
@@ -161,7 +162,15 @@ class Frame extends import_channelOwner.ChannelOwner {
   async waitForURL(url, options = {}) {
     if ((0, import_urlMatch.urlMatches)(this._page?.context()._options.baseURL, this.url(), url))
       return await this.waitForLoadState(options.waitUntil, options);
-    await this.waitForNavigation({ url, ...options });
+    try {
+      await this.waitForNavigation({ url, ...options });
+    } catch (error) {
+      if ((0, import_urlMatch.urlMatches)(this._page?.context()._options.baseURL, this.url(), url)) {
+        await this.waitForLoadState(options.waitUntil, options);
+        return;
+      }
+      throw error;
+    }
   }
   async frameElement() {
     return import_elementHandle.ElementHandle.from((await this._channel.frameElement()).element);

package/lib/client/locator.js

@@ -99,6 +99,10 @@ class Locator {
     });
   }
   async evaluate(pageFunction, arg, options, isolatedContext = true) {
+    if (typeof options === "boolean") {
+      isolatedContext = options;
+      options = void 0;
+    }
     return await this._withElement(
       async (h) => (0, import_jsHandle.parseResult)(
         (await h._channel.evaluateExpression({
@@ -118,6 +122,10 @@ class Locator {
     return await this._frame.$$eval(this._selector, pageFunction, arg, isolatedContext);
   }
   async evaluateHandle(pageFunction, arg, options, isolatedContext = true) {
+    if (typeof options === "boolean") {
+      isolatedContext = options;
+      options = void 0;
+    }
     return await this._withElement(
       async (h) => import_jsHandle.JSHandle.from(
         (await h._channel.evaluateExpressionHandle({

package/lib/client/network.js

@@ -128,7 +128,11 @@ class Request extends import_channelOwner.ChannelOwner {
     return await this._actualHeadersPromise;
   }
   async allHeaders() {
-    return (await this._actualHeaders()).headers();
+    const headers = await this._actualHeaders();
+    const page = this._safePage();
+    if (page?._closeWasCalled)
+      throw new import_errors.TargetClosedError();
+    return headers.headers();
   }
   async headersArray() {
     return (await this._actualHeaders()).headersArray();

package/lib/client/page.js

@@ -48,6 +48,7 @@ var import_urlMatch = require("../utils/isomorphic/urlMatch");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_rtti = require("../utils/isomorphic/rtti");
 var import_consoleMessage = require("./consoleMessage");
+var import_pageAgent = require("./pageAgent");
 class Page extends import_channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
@@ -63,6 +64,7 @@ class Page extends import_channelOwner.ChannelOwner {
     this._harRouters = [];
     this._locatorHandlers = /* @__PURE__ */ new Map();
     this.routeInjecting = false;
+    this._instrumentation.onPage(this);
     this._browserContext = parent;
     this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform, this._browserContext._timeoutSettings);
     this.keyboard = new import_input.Keyboard(this);
@@ -506,7 +508,8 @@ class Page extends import_channelOwner.ChannelOwner {
   }
   async close(options = {}) {
     this._closeReason = options.reason;
-    this._closeWasCalled = true;
+    if (!options.runBeforeUnload)
+      this._closeWasCalled = true;
     try {
       if (this._ownedContext)
         await this._ownedContext.close();
@@ -677,6 +680,30 @@ class Page extends import_channelOwner.ChannelOwner {
     }
     return result.pdf;
   }
+  // @ts-expect-error agents are hidden
+  async agent(options = {}) {
+    const params = {
+      api: options.provider?.api,
+      apiEndpoint: options.provider?.apiEndpoint,
+      apiKey: options.provider?.apiKey,
+      apiTimeout: options.provider?.apiTimeout,
+      apiCacheFile: options.provider?._apiCacheFile,
+      doNotRenderActive: options._doNotRenderActive,
+      model: options.provider?.model,
+      cacheFile: options.cache?.cacheFile,
+      cacheOutFile: options.cache?.cacheOutFile,
+      maxTokens: options.limits?.maxTokens,
+      maxActions: options.limits?.maxActions,
+      maxActionRetries: options.limits?.maxActionRetries,
+      // @ts-expect-error runAgents is hidden
+      secrets: options.secrets ? Object.entries(options.secrets).map(([name, value]) => ({ name, value })) : void 0,
+      systemPrompt: options.systemPrompt
+    };
+    const { agent } = await this._channel.agent(params);
+    const pageAgent = import_pageAgent.PageAgent.from(agent);
+    pageAgent._expectTimeout = options?.expect?.timeout;
+    return pageAgent;
+  }
   async _snapshotForAI(options = {}) {
     return await this._channel.snapshotForAI({ timeout: this._timeoutSettings.timeout(options), track: options.track });
   }
@@ -694,6 +721,7 @@ class Page extends import_channelOwner.ChannelOwner {
         await route.fallback();
       }
     });
+    this.routeInjecting = true;
   }
 }
 class BindingCall extends import_channelOwner.ChannelOwner {

package/lib/client/pageAgent.js

@@ -0,0 +1,64 @@
+"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 pageAgent_exports = {};
+__export(pageAgent_exports, {
+  PageAgent: () => PageAgent
+});
+module.exports = __toCommonJS(pageAgent_exports);
+var import_channelOwner = require("./channelOwner");
+var import_events = require("./events");
+var import_page = require("./page");
+class PageAgent extends import_channelOwner.ChannelOwner {
+  static from(channel) {
+    return channel._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._page = import_page.Page.from(initializer.page);
+    this._channel.on("turn", (params) => this.emit(import_events.Events.PageAgent.Turn, params));
+  }
+  async expect(expectation, options = {}) {
+    const timeout = options.timeout ?? this._expectTimeout ?? 5e3;
+    await this._channel.expect({ expectation, ...options, timeout });
+  }
+  async perform(task, options = {}) {
+    const timeout = this._page._timeoutSettings.timeout(options);
+    const { usage } = await this._channel.perform({ task, ...options, timeout });
+    return { usage };
+  }
+  async extract(query, schema, options = {}) {
+    const timeout = this._page._timeoutSettings.timeout(options);
+    const { result, usage } = await this._channel.extract({ query, schema: this._page._platform.zodToJsonSchema(schema), ...options, timeout });
+    return { result, usage };
+  }
+  async usage() {
+    const { usage } = await this._channel.usage({});
+    return usage;
+  }
+  async dispose() {
+    await this._channel.dispose();
+  }
+  async [Symbol.asyncDispose]() {
+    await this.dispose();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PageAgent
+});

package/lib/client/platform.js

@@ -66,6 +66,9 @@ const emptyPlatform = {
   streamWritable: (channel) => {
     throw new Error("Streams are not available");
   },
+  zodToJsonSchema: (schema) => {
+    throw new Error("Zod is not available");
+  },
   zones: { empty: noopZone, current: () => noopZone }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/lib/client/tracing.js

@@ -34,7 +34,7 @@ class Tracing extends import_channelOwner.ChannelOwner {
     return channel._object;
   }
   async start(options = {}) {
-    await this._parent.installInjectRoute();
+    if (typeof this._parent.installInjectRoute === "function") await this._parent.installInjectRoute();
     await this._wrapApiCall(async () => {
       this._includeSources = !!options.sources;
       this._isLive = !!options._live;