@smoothdeploy/playwright-core 1.57.1 → 1.58.1-beta-1770452953000

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

@@ -76,6 +76,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());
@@ -474,6 +475,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 function prepareStorageState(platform, storageState) {
   if (typeof storageState !== "string")

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/channelOwner.js

@@ -125,7 +125,7 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
                 const validatedParams = validator(params, "", this._validatorToWireContext());
                 if (!apiZone.internal && !apiZone.reported) {
                   apiZone.reported = true;
-                  this._instrumentation.onApiCallBegin(apiZone, { type: this._type, method: prop, params });
+                  this._instrumentation.onApiCallBegin(apiZone, { type: this._type, method: prop, params, object: this });
                   logApiCall(this._platform, this._logger, `=> ${apiZone.apiName} started`);
                   return await this._connection.sendMessageToServer(this, prop, validatedParams, apiZone);
                 }
@@ -151,7 +151,7 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
       const result = await this._platform.zones.current().push(apiZone).run(async () => await func(apiZone));
       if (!options?.internal) {
         logApiCall(this._platform, logger, `<= ${apiZone.apiName} succeeded`);
-        this._instrumentation.onApiCallEnd(apiZone);
+        await this._instrumentation.onApiCallEnd(apiZone);
       }
       return result;
     } catch (e) {
@@ -166,7 +166,8 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
       if (!options?.internal) {
         apiZone.error = e;
         logApiCall(this._platform, logger, `<= ${apiZone.apiName} failed`);
-        this._instrumentation.onApiCallEnd(apiZone);
+        await this._instrumentation.onApiCallEnd(apiZone).catch(() => {
+        });
       }
       throw e;
     }

package/lib/client/clientInstrumentation.js

@@ -39,6 +39,16 @@ function createInstrumentation() {
             await listener[prop]?.(...params);
         };
       }
+      if (prop === "onApiCallEnd") {
+        return async (...params) => {
+          for (const listener of listeners) {
+            try {
+              await listener[prop]?.(...params);
+            } catch {
+            }
+          }
+        };
+      }
       if (prop.startsWith("on")) {
         return (...params) => {
           for (const listener of listeners)

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) {

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);
@@ -62,6 +63,7 @@ class Page extends import_channelOwner.ChannelOwner {
     this._closeWasCalled = false;
     this._harRouters = [];
     this._locatorHandlers = /* @__PURE__ */ new Map();
+    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);
@@ -502,7 +504,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();
@@ -673,6 +676,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 });
   }

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: