patchright-core 1.52.4 → 1.55.0

package/lib/server/download.js

@@ -37,14 +37,14 @@ var import_utils = require("../utils");
 var import_artifact = require("./artifact");
 class Download {
   constructor(page, downloadsPath, uuid, url, suggestedFilename) {
-    const unaccessibleErrorMessage = page._browserContext._options.acceptDownloads === "deny" ? "Pass { acceptDownloads: true } when you are creating your browser context." : void 0;
+    const unaccessibleErrorMessage = page.browserContext._options.acceptDownloads === "deny" ? "Pass { acceptDownloads: true } when you are creating your browser context." : void 0;
     this.artifact = new import_artifact.Artifact(page, import_path.default.join(downloadsPath, uuid), unaccessibleErrorMessage, () => {
-      return this._page._browserContext.cancelDownload(uuid);
+      return this._page.browserContext.cancelDownload(uuid);
     });
     this._page = page;
     this.url = url;
     this._suggestedFilename = suggestedFilename;
-    page._browserContext._downloads.add(this);
+    page.browserContext._downloads.add(this);
     if (suggestedFilename !== void 0)
       this._fireDownloadEvent();
   }

package/lib/server/electron/electron.js

@@ -36,7 +36,6 @@ var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
 var readline = __toESM(require("readline"));
-var import_timeoutSettings = require("../timeoutSettings");
 var import_utils = require("../../utils");
 var import_ascii = require("../utils/ascii");
 var import_debugLogger = require("../utils/debugLogger");
@@ -51,14 +50,12 @@ var import_helper = require("../helper");
 var import_instrumentation = require("../instrumentation");
 var js = __toESM(require("../javascript"));
 var import_processLauncher = require("../utils/processLauncher");
-var import_progress = require("../progress");
 var import_transport = require("../transport");
 const ARTIFACTS_FOLDER = import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-");
 class ElectronApplication extends import_instrumentation.SdkObject {
   constructor(parent, browser, nodeConnection, process2) {
     super(parent, "electron-app");
     this._nodeElectronHandlePromise = new import_utils.ManualPromise();
-    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings();
     this._process = process2;
     this._browserContext = browser._defaultContext;
     this._nodeConnection = nodeConnection;
@@ -117,7 +114,7 @@ class ElectronApplication extends import_instrumentation.SdkObject {
     await this._browserContext.close({ reason: "Application exited" });
   }
   async browserWindow(page) {
-    const targetId = page._delegate._targetId;
+    const targetId = page.delegate._targetId;
     const electronHandle = await this._nodeElectronHandlePromise;
     return await electronHandle.evaluateHandle(({ BrowserWindow, webContents }, targetId2) => {
       const wc = webContents.fromDevToolsTargetId(targetId2);
@@ -128,84 +125,79 @@ class ElectronApplication extends import_instrumentation.SdkObject {
 class Electron extends import_instrumentation.SdkObject {
   constructor(playwright) {
     super(playwright, "electron");
+    this.logName = "browser";
   }
-  async launch(options) {
-    const {
-      args = []
-    } = options;
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this);
-    controller.setLogName("browser");
-    return controller.run(async (progress) => {
-      let app = void 0;
-      let electronArguments = ["--inspect=0", "--remote-debugging-port=0", ...args];
-      if (import_os.default.platform() === "linux") {
-        const runningAsRoot = process.geteuid && process.geteuid() === 0;
-        if (runningAsRoot && electronArguments.indexOf("--no-sandbox") === -1)
-          electronArguments.unshift("--no-sandbox");
-      }
-      const artifactsDir = await import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
-      const browserLogsCollector = new import_debugLogger.RecentLogsCollector();
-      const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
-      let command;
-      if (options.executablePath) {
-        command = options.executablePath;
-      } else {
-        try {
-          command = require("electron/index.js");
-        } catch (error) {
-          if (error?.code === "MODULE_NOT_FOUND") {
-            throw new Error("\n" + (0, import_ascii.wrapInASCIIBox)([
-              "Electron executablePath not found!",
-              "Please install it using `npm install -D electron` or set the executablePath to your Electron executable."
-            ].join("\n"), 1));
-          }
-          throw error;
+  async launch(progress, options) {
+    let app = void 0;
+    let electronArguments = ["--inspect=0", "--remote-debugging-port=0", ...options.args || []];
+    if (import_os.default.platform() === "linux") {
+      const runningAsRoot = process.geteuid && process.geteuid() === 0;
+      if (runningAsRoot && electronArguments.indexOf("--no-sandbox") === -1)
+        electronArguments.unshift("--no-sandbox");
+    }
+    const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
+    const browserLogsCollector = new import_debugLogger.RecentLogsCollector();
+    const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
+    let command;
+    if (options.executablePath) {
+      command = options.executablePath;
+    } else {
+      try {
+        command = require("electron/index.js");
+      } catch (error) {
+        if (error?.code === "MODULE_NOT_FOUND") {
+          throw new Error("\n" + (0, import_ascii.wrapInASCIIBox)([
+            "Electron executablePath not found!",
+            "Please install it using `npm install -D electron` or set the executablePath to your Electron executable."
+          ].join("\n"), 1));
         }
-        electronArguments.unshift("-r", require.resolve("./loader"));
+        throw error;
       }
-      let shell = false;
-      if (process.platform === "win32") {
-        shell = true;
-        command = `"${command}"`;
-        electronArguments = electronArguments.map((arg) => `"${arg}"`);
-      }
-      delete env.NODE_OPTIONS;
-      const { launchedProcess, gracefullyClose, kill } = await (0, import_processLauncher.launchProcess)({
-        command,
-        args: electronArguments,
-        env,
-        log: (message) => {
-          progress.log(message);
-          browserLogsCollector.log(message);
-        },
-        shell,
-        stdio: "pipe",
-        cwd: options.cwd,
-        tempDirectories: [artifactsDir],
-        attemptToGracefullyClose: () => app.close(),
-        handleSIGINT: true,
-        handleSIGTERM: true,
-        handleSIGHUP: true,
-        onExit: () => app?.emit(ElectronApplication.Events.Close)
-      });
-      const waitForXserverError = new Promise(async (resolve, reject) => {
-        waitForLine(progress, launchedProcess, /Unable to open X display/).then(() => reject(new Error([
-          "Unable to open X display!",
-          `================================`,
-          "Most likely this is because there is no X server available.",
-          "Use 'xvfb-run' on Linux to launch your tests with an emulated display server.",
-          "For example: 'xvfb-run npm run test:e2e'",
-          `================================`,
-          progress.metadata.log
-        ].join("\n")))).catch(() => {
-        });
-      });
-      const nodeMatchPromise = waitForLine(progress, launchedProcess, /^Debugger listening on (ws:\/\/.*)$/);
-      const chromeMatchPromise = waitForLine(progress, launchedProcess, /^DevTools listening on (ws:\/\/.*)$/);
-      const debuggerDisconnectPromise = waitForLine(progress, launchedProcess, /Waiting for the debugger to disconnect\.\.\./);
+      electronArguments.unshift("-r", require.resolve("./loader"));
+    }
+    let shell = false;
+    if (process.platform === "win32") {
+      shell = true;
+      command = `"${command}"`;
+      electronArguments = electronArguments.map((arg) => `"${arg}"`);
+    }
+    delete env.NODE_OPTIONS;
+    const { launchedProcess, gracefullyClose, kill } = await (0, import_processLauncher.launchProcess)({
+      command,
+      args: electronArguments,
+      env,
+      log: (message) => {
+        progress.log(message);
+        browserLogsCollector.log(message);
+      },
+      shell,
+      stdio: "pipe",
+      cwd: options.cwd,
+      tempDirectories: [artifactsDir],
+      attemptToGracefullyClose: () => app.close(),
+      handleSIGINT: true,
+      handleSIGTERM: true,
+      handleSIGHUP: true,
+      onExit: () => app?.emit(ElectronApplication.Events.Close)
+    });
+    const waitForXserverError = waitForLine(progress, launchedProcess, /Unable to open X display/).then(() => {
+      throw new Error([
+        "Unable to open X display!",
+        `================================`,
+        "Most likely this is because there is no X server available.",
+        "Use 'xvfb-run' on Linux to launch your tests with an emulated display server.",
+        "For example: 'xvfb-run npm run test:e2e'",
+        `================================`,
+        progress.metadata.log
+      ].join("\n"));
+    });
+    const nodeMatchPromise = waitForLine(progress, launchedProcess, /^Debugger listening on (ws:\/\/.*)$/);
+    const chromeMatchPromise = waitForLine(progress, launchedProcess, /^DevTools listening on (ws:\/\/.*)$/);
+    const debuggerDisconnectPromise = waitForLine(progress, launchedProcess, /Waiting for the debugger to disconnect\.\.\./);
+    try {
       const nodeMatch = await nodeMatchPromise;
       const nodeTransport = await import_transport.WebSocketTransport.connect(progress, nodeMatch[1]);
-      const nodeConnection = new import_crConnection.CRConnection(nodeTransport, import_helper.helper.debugProtocolLogger(), browserLogsCollector);
+      const nodeConnection = new import_crConnection.CRConnection(this, nodeTransport, import_helper.helper.debugProtocolLogger(), browserLogsCollector);
       debuggerDisconnectPromise.then(() => {
         nodeTransport.close();
       }).catch(() => {
@@ -239,36 +231,37 @@ class Electron extends import_instrumentation.SdkObject {
         originalLaunchOptions: {}
       };
       (0, import_browserContext.validateBrowserContextOptions)(contextOptions, browserOptions);
-      const browser = await import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions);
+      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
       app = new ElectronApplication(this, browser, nodeConnection, launchedProcess);
-      await app.initialize();
+      await progress.race(app.initialize());
       return app;
-    }, import_timeoutSettings.TimeoutSettings.launchTimeout(options));
+    } catch (error) {
+      await kill();
+      throw error;
+    }
   }
 }
-function waitForLine(progress, process2, regex) {
-  return new Promise((resolve, reject) => {
-    const rl = readline.createInterface({ input: process2.stderr });
-    const failError = new Error("Process failed to launch!");
-    const listeners = [
-      import_eventsHelper.eventsHelper.addEventListener(rl, "line", onLine),
-      import_eventsHelper.eventsHelper.addEventListener(rl, "close", reject.bind(null, failError)),
-      import_eventsHelper.eventsHelper.addEventListener(process2, "exit", reject.bind(null, failError)),
-      // It is Ok to remove error handler because we did not create process and there is another listener.
-      import_eventsHelper.eventsHelper.addEventListener(process2, "error", reject.bind(null, failError))
-    ];
-    progress.cleanupWhenAborted(cleanup);
-    function onLine(line) {
-      const match = line.match(regex);
-      if (!match)
-        return;
-      cleanup();
-      resolve(match);
-    }
-    function cleanup() {
-      import_eventsHelper.eventsHelper.removeEventListeners(listeners);
-    }
-  });
+async function waitForLine(progress, process2, regex) {
+  const promise = new import_utils.ManualPromise();
+  const rl = readline.createInterface({ input: process2.stderr });
+  const failError = new Error("Process failed to launch!");
+  const listeners = [
+    import_eventsHelper.eventsHelper.addEventListener(rl, "line", onLine),
+    import_eventsHelper.eventsHelper.addEventListener(rl, "close", () => promise.reject(failError)),
+    import_eventsHelper.eventsHelper.addEventListener(process2, "exit", () => promise.reject(failError)),
+    // It is Ok to remove error handler because we did not create process and there is another listener.
+    import_eventsHelper.eventsHelper.addEventListener(process2, "error", () => promise.reject(failError))
+  ];
+  function onLine(line) {
+    const match = line.match(regex);
+    if (match)
+      promise.resolve(match);
+  }
+  try {
+    return await progress.race(promise);
+  } finally {
+    import_eventsHelper.eventsHelper.removeEventListeners(listeners);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/electron/loader.js

@@ -2,7 +2,7 @@
 const { app } = require("electron");
 const { chromiumSwitches } = require("../chromium/chromiumSwitches");
 process.argv.splice(1, process.argv.indexOf("--remote-debugging-port=0"));
-for (const arg of chromiumSwitches) {
+for (const arg of chromiumSwitches()) {
   const match = arg.match(/--([^=]*)=?(.*)/);
   app.commandLine.appendSwitch(match[1], match[2]);
 }

package/lib/server/fetch.js

@@ -38,7 +38,6 @@ var import_https = __toESM(require("https"));
 var import_stream = require("stream");
 var import_tls = require("tls");
 var zlib = __toESM(require("zlib"));
-var import_timeoutSettings = require("./timeoutSettings");
 var import_utils = require("../utils");
 var import_crypto = require("./utils/crypto");
 var import_userAgent = require("./utils/userAgent");
@@ -55,7 +54,6 @@ class APIRequestContext extends import_instrumentation.SdkObject {
     super(parent, "request-context");
     this.fetchResponses = /* @__PURE__ */ new Map();
     this.fetchLog = /* @__PURE__ */ new Map();
-    this._activeProgressControllers = /* @__PURE__ */ new Set();
     APIRequestContext.allInstances.add(this);
   }
   static {
@@ -91,7 +89,7 @@ class APIRequestContext extends import_instrumentation.SdkObject {
     this.fetchResponses.set(uid, body);
     return uid;
   }
-  async fetch(params, metadata) {
+  async fetch(progress, params) {
     const defaults = this._defaultOptions();
     const headers = {
       "user-agent": defaults.userAgent,
@@ -123,15 +121,11 @@ class APIRequestContext extends import_instrumentation.SdkObject {
       agent = (0, import_utils.createProxyAgent)(proxy, requestUrl);
     let maxRedirects = params.maxRedirects ?? (defaults.maxRedirects ?? 20);
     maxRedirects = maxRedirects === 0 ? -1 : maxRedirects;
-    const timeout = defaults.timeoutSettings.timeout(params);
-    const deadline = timeout && (0, import_utils.monotonicTime)() + timeout;
     const options = {
       method,
       headers,
       agent,
       maxRedirects,
-      timeout,
-      deadline,
       ...(0, import_socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, requestUrl.origin),
       __testHookLookup: params.__testHookLookup
     };
@@ -140,12 +134,9 @@ class APIRequestContext extends import_instrumentation.SdkObject {
     const postData = serializePostData(params, headers);
     if (postData)
       setHeader(headers, "content-length", String(postData.byteLength));
-    const controller = new import_progress.ProgressController(metadata, this);
-    const fetchResponse = await controller.run((progress) => {
-      return this._sendRequestWithRetries(progress, requestUrl, options, postData, params.maxRetries);
-    });
+    const fetchResponse = await this._sendRequestWithRetries(progress, requestUrl, options, postData, params.maxRetries);
     const fetchUid = this._storeResponseBody(fetchResponse.body);
-    this.fetchLog.set(fetchUid, controller.metadata.log);
+    this.fetchLog.set(fetchUid, progress.metadata.log);
     const failOnStatusCode = params.failOnStatusCode !== void 0 ? params.failOnStatusCode : !!defaults.failOnStatusCode;
     if (failOnStatusCode && (fetchResponse.status < 200 || fetchResponse.status >= 400)) {
       let responseText = "";
@@ -183,10 +174,11 @@ ${text}`;
     }
     return cookies;
   }
-  async _updateRequestCookieHeader(url, headers) {
+  async _updateRequestCookieHeader(progress, url, headers) {
     if (getHeader(headers, "cookie") !== void 0)
       return;
-    const cookies = await this._cookies(url);
+    const contextCookies = await progress.race(this._cookies(url));
+    const cookies = contextCookies.filter((c) => new import_cookieStore.Cookie(c).matches(url));
     if (cookies.length) {
       const valueArray = cookies.map((c) => `${c.name}=${c.value}`);
       setHeader(headers, "cookie", valueArray.join("; "));
@@ -199,22 +191,24 @@ ${text}`;
       try {
         return await this._sendRequest(progress, url, options, postData);
       } catch (e) {
+        if ((0, import_progress.isAbortError)(e))
+          throw e;
         e = (0, import_socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(e);
         if (maxRetries === 0)
           throw e;
-        if (i === maxRetries || options.deadline && (0, import_utils.monotonicTime)() + backoff > options.deadline)
+        if (i === maxRetries)
           throw new Error(`Failed after ${i + 1} attempt(s): ${e}`);
         if (e.code !== "ECONNRESET")
           throw e;
         progress.log(`  Received ECONNRESET, will retry after ${backoff}ms.`);
-        await new Promise((f) => setTimeout(f, backoff));
+        await progress.wait(backoff);
         backoff *= 2;
       }
     }
     throw new Error("Unreachable");
   }
   async _sendRequest(progress, url, options, postData) {
-    await this._updateRequestCookieHeader(url, options.headers);
+    await this._updateRequestCookieHeader(progress, url, options.headers);
     const requestCookies = getHeader(options.headers, "cookie")?.split(";").map((p) => {
       const [name, value] = p.split("=").map((v) => v.trim());
       return { name, value };
@@ -227,7 +221,8 @@ ${text}`;
       postData
     };
     this.emit(APIRequestContext.Events.Request, requestEvent);
-    return new Promise((fulfill, reject) => {
+    let destroyRequest;
+    const resultPromise = new Promise((fulfill, reject) => {
       const requestConstructor = (url.protocol === "https:" ? import_https.default : import_http.default).request;
       const agent = options.agent || (url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent);
       const requestOptions = { ...options, agent };
@@ -308,8 +303,6 @@ ${text}`;
             headers,
             agent: options.agent,
             maxRedirects: options.maxRedirects - 1,
-            timeout: options.timeout,
-            deadline: options.deadline,
             ...(0, import_socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, url.origin),
             __testHookLookup: options.__testHookLookup
           };
@@ -387,6 +380,7 @@ ${text}`;
         body.on("end", notifyBodyFinished);
       });
       request.on("error", reject);
+      destroyRequest = () => request.destroy();
       listeners.push(
         import_utils.eventsHelper.addEventListener(this, APIRequestContext.Events.Dispose, () => {
           reject(new Error("Request context disposed."));
@@ -434,22 +428,14 @@ ${text}`;
         for (const [name, value] of Object.entries(options.headers))
           progress.log(`  ${name}: ${value}`);
       }
-      if (options.deadline) {
-        const rejectOnTimeout = () => {
-          reject(new Error(`Request timed out after ${options.timeout}ms`));
-          request.destroy();
-        };
-        const remaining = options.deadline - (0, import_utils.monotonicTime)();
-        if (remaining <= 0) {
-          rejectOnTimeout();
-          return;
-        }
-        request.setTimeout(remaining, rejectOnTimeout);
-      }
       if (postData)
         request.write(postData);
       request.end();
     });
+    return progress.race(resultPromise).catch((error) => {
+      destroyRequest?.();
+      throw error;
+    });
   }
   _getHttpCredentials(url) {
     if (!this._defaultOptions().httpCredentials?.origin || url.origin.toLowerCase() === this._defaultOptions().httpCredentials?.origin?.toLowerCase())
@@ -494,7 +480,6 @@ class BrowserContextAPIRequestContext extends APIRequestContext {
       failOnStatusCode: void 0,
       httpCredentials: this._context._options.httpCredentials,
       proxy: this._context._options.proxy || this._context._browser.options.proxy,
-      timeoutSettings: this._context._timeoutSettings,
       ignoreHTTPSErrors: this._context._options.ignoreHTTPSErrors,
       baseURL: this._context._options.baseURL,
       clientCertificates: this._context._options.clientCertificates
@@ -506,8 +491,8 @@ class BrowserContextAPIRequestContext extends APIRequestContext {
   async _cookies(url) {
     return await this._context.cookies(url.toString());
   }
-  async storageState(indexedDB) {
-    return this._context.storageState(indexedDB);
+  async storageState(progress, indexedDB) {
+    return this._context.storageState(progress, indexedDB);
   }
 }
 class GlobalAPIRequestContext extends APIRequestContext {
@@ -515,9 +500,6 @@ class GlobalAPIRequestContext extends APIRequestContext {
     super(playwright);
     this._cookieStore = new import_cookieStore.CookieStore();
     this.attribution.context = this;
-    const timeoutSettings = new import_timeoutSettings.TimeoutSettings();
-    if (options.timeout !== void 0)
-      timeoutSettings.setDefaultTimeout(options.timeout);
     if (options.storageState) {
       this._origins = options.storageState.origins?.map((origin) => ({ indexedDB: [], ...origin }));
       this._cookieStore.addCookies(options.storageState.cookies || []);
@@ -532,8 +514,7 @@ class GlobalAPIRequestContext extends APIRequestContext {
       maxRedirects: options.maxRedirects,
       httpCredentials: options.httpCredentials,
       clientCertificates: options.clientCertificates,
-      proxy: options.proxy,
-      timeoutSettings
+      proxy: options.proxy
     };
     this._tracing = new import_tracing.Tracing(this, options.tracesDir);
   }
@@ -555,7 +536,7 @@ class GlobalAPIRequestContext extends APIRequestContext {
   async _cookies(url) {
     return this._cookieStore.cookies(url);
   }
-  async storageState(indexedDB = false) {
+  async storageState(progress, indexedDB = false) {
     return {
       cookies: this._cookieStore.allCookies(),
       origins: (this._origins || []).map((origin) => ({ ...origin, indexedDB: indexedDB ? origin.indexedDB : [] }))

package/lib/server/fileUploadUtils.js

@@ -55,7 +55,7 @@ async function prepareFilesForUpload(frame, params) {
       (0, import_assert.assert)(import_path.default.isAbsolute(p) && import_path.default.resolve(p) === p, "Paths provided to localPaths must be absolute and fully resolved.");
   }
   let fileBuffers = payloads;
-  if (!frame._page._browserContext._browser._isCollocatedWithServer) {
+  if (!frame._page.browserContext._browser._isCollocatedWithServer) {
     if (localPaths) {
       if (await filesExceedUploadLimit(localPaths))
         throw new Error("Cannot transfer files larger than 50Mb to a browser not co-located with the server");