patchright-core 1.57.0 → 1.59.0

package/lib/server/bidi/bidiChromium.js

@@ -38,6 +38,7 @@ var import_bidiBrowser = require("./bidiBrowser");
 var import_bidiConnection = require("./bidiConnection");
 var import_chromiumSwitches = require("../chromium/chromiumSwitches");
 var import_chromium = require("../chromium/chromium");
+var import_crBrowser = require("../chromium/crBrowser");
 class BidiChromium extends import_browserType.BrowserType {
   constructor(parent) {
     super(parent, "chromium");
@@ -56,14 +57,12 @@ class BidiChromium extends import_browserType.BrowserType {
       throw e;
     }
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes("Missing X server"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    if (!error.logs.includes("crbug.com/357670") && !error.logs.includes("No usable sandbox!") && !error.logs.includes("crbug.com/638180"))
-      return error;
-    error.logs = [
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Missing X server"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    if (!logs.includes("crbug.com/357670") && !logs.includes("No usable sandbox!") && !logs.includes("crbug.com/638180"))
+      return logs;
+    return [
       `Chromium sandboxing failed!`,
       `================================`,
       `To avoid the sandboxing issue, do either of the following:`,
@@ -72,7 +71,6 @@ class BidiChromium extends import_browserType.BrowserType {
       `================================`,
       ``
     ].join("\n");
-    return error;
   }
   amendEnvironment(env) {
     return env;
@@ -112,8 +110,6 @@ class BidiChromium extends import_browserType.BrowserType {
     if (import_os.default.platform() === "darwin") {
       chromeArguments.push("--enable-unsafe-swiftshader");
     }
-    if (options.devtools)
-      chromeArguments.push("--auto-open-devtools-for-tabs");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(
@@ -133,11 +129,9 @@ class BidiChromium extends import_browserType.BrowserType {
       }
       chromeArguments.push(`--proxy-server=${proxy.server}`);
       const proxyBypassRules = [];
-      if (options.socksProxyPort)
-        proxyBypassRules.push("<-loopback>");
       if (proxy.bypass)
         proxyBypassRules.push(...proxy.bypass.split(",").map((t) => t.trim()).map((t) => t.startsWith(".") ? "*" + t : t));
-      if (!process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK && !proxyBypassRules.includes("<-loopback>"))
+      if (options.socksProxyPort || (0, import_crBrowser.shouldProxyLoopback)(proxy.bypass))
         proxyBypassRules.push("<-loopback>");
       if (proxyBypassRules.length > 0)
         chromeArguments.push(`--proxy-bypass-list=${proxyBypassRules.join(";")}`);
@@ -145,6 +139,21 @@ class BidiChromium extends import_browserType.BrowserType {
     chromeArguments.push(...args);
     return chromeArguments;
   }
+  getExecutableName(options) {
+    switch (options.channel) {
+      case "bidi-chromium":
+        return "chromium";
+      case "bidi-chrome":
+        return "chrome";
+      case "bidi-chrome-beta":
+        return "chrome-beta";
+      case "bidi-chrome-dev":
+        return "chrome-dev";
+      case "bidi-chrome-canary":
+        return "chrome-canary";
+    }
+    throw new Error(`Unsupported Bidi Chromium channel: ${options.channel}`);
+  }
 }
 const kBidiOverCdpWrapper = Symbol("kBidiConnectionWrapper");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/bidi/bidiConnection.js

@@ -173,6 +173,7 @@ class BidiSession extends import_events.EventEmitter {
     this._browsingContexts.clear();
     for (const callback of this._callbacks.values()) {
       callback.error.type = this._crashed ? "crashed" : "closed";
+      callback.error.setMessage(`Internal server error, session ${callback.error.type}.`);
       callback.error.logs = this.connection._browserDisconnectedLogs;
       callback.reject(callback.error);
     }

package/lib/server/bidi/bidiDeserializer.js

@@ -0,0 +1,116 @@
+"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 bidiDeserializer_exports = {};
+__export(bidiDeserializer_exports, {
+  deserializeBidiValue: () => deserializeBidiValue
+});
+module.exports = __toCommonJS(bidiDeserializer_exports);
+var import_javascript = require("../javascript");
+function deserializeBidiValue(result, internalIdMap = /* @__PURE__ */ new Map()) {
+  switch (result.type) {
+    case "undefined":
+      return void 0;
+    case "null":
+      return null;
+    case "number":
+      return typeof result.value === "number" ? result.value : (0, import_javascript.parseUnserializableValue)(result.value);
+    case "boolean":
+      return Boolean(result.value);
+    case "string":
+      return result.value;
+    case "bigint":
+      return BigInt(result.value);
+    case "array":
+      return deserializeBidiList(result, internalIdMap);
+    case "arraybuffer":
+      return getValue(result, internalIdMap, () => ({}));
+    case "date":
+      return getValue(result, internalIdMap, () => new Date(result.value));
+    case "error":
+      return getValue(result, internalIdMap, () => {
+        const error = new Error();
+        error.stack = "";
+        return error;
+      });
+    case "function":
+      return void 0;
+    case "generator":
+      return getValue(result, internalIdMap, () => ({}));
+    case "htmlcollection":
+      return { ...deserializeBidiList(result, internalIdMap) };
+    case "map":
+      return getValue(result, internalIdMap, () => ({}));
+    case "node":
+      return "ref: <Node>";
+    case "nodelist":
+      return { ...deserializeBidiList(result, internalIdMap) };
+    case "object":
+      return deserializeBidiMapping(result, internalIdMap);
+    case "promise":
+      return getValue(result, internalIdMap, () => ({}));
+    case "proxy":
+      return getValue(result, internalIdMap, () => ({}));
+    case "regexp":
+      return getValue(result, internalIdMap, () => new RegExp(result.value.pattern, result.value.flags));
+    case "set":
+      return getValue(result, internalIdMap, () => ({}));
+    case "symbol":
+      return void 0;
+    case "typedarray":
+      return void 0;
+    case "weakmap":
+      return getValue(result, internalIdMap, () => ({}));
+    case "weakset":
+      return getValue(result, internalIdMap, () => ({}));
+    case "window":
+      return "ref: <Window>";
+  }
+}
+function getValue(bidiValue, internalIdMap, defaultValue) {
+  if ("internalId" in bidiValue && bidiValue.internalId) {
+    if (internalIdMap.has(bidiValue.internalId)) {
+      return internalIdMap.get(bidiValue.internalId);
+    } else {
+      const value = defaultValue();
+      internalIdMap.set(bidiValue.internalId, value);
+      return value;
+    }
+  } else {
+    return defaultValue();
+  }
+}
+function deserializeBidiList(bidiValue, internalIdMap) {
+  const result = getValue(bidiValue, internalIdMap, () => []);
+  for (const val of bidiValue.value || [])
+    result.push(deserializeBidiValue(val, internalIdMap));
+  return result;
+}
+function deserializeBidiMapping(bidiValue, internalIdMap) {
+  const result = getValue(bidiValue, internalIdMap, () => ({}));
+  for (const [serializedKey, serializedValue] of bidiValue.value || []) {
+    const key = typeof serializedKey === "string" ? serializedKey : deserializeBidiValue(serializedKey, internalIdMap);
+    const value = deserializeBidiValue(serializedValue, internalIdMap);
+    result[key] = value;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deserializeBidiValue
+});

package/lib/server/bidi/bidiExecutionContext.js

@@ -36,9 +36,9 @@ var import_utils = require("../../utils");
 var import_utilityScriptSerializers = require("../../utils/isomorphic/utilityScriptSerializers");
 var js = __toESM(require("../javascript"));
 var dom = __toESM(require("../dom"));
-var import_bidiDeserializer = require("./third_party/bidiDeserializer");
 var bidi = __toESM(require("./third_party/bidiProtocol"));
 var import_bidiSerializer = require("./third_party/bidiSerializer");
+var import_bidiDeserializer = require("./bidiDeserializer");
 class BidiExecutionContext {
   constructor(session, realmInfo) {
     this._session = session;
@@ -65,7 +65,7 @@ class BidiExecutionContext {
       userActivation: true
     });
     if (response.type === "success")
-      return import_bidiDeserializer.BidiDeserializer.deserialize(response.result);
+      return (0, import_bidiDeserializer.deserializeBidiValue)(response.result);
     if (response.type === "exception")
       throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text);
     throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
@@ -108,7 +108,7 @@ class BidiExecutionContext {
       throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text);
     if (response.type === "success") {
       if (returnByValue)
-        return (0, import_utilityScriptSerializers.parseEvaluationResultValue)(import_bidiDeserializer.BidiDeserializer.deserialize(response.result));
+        return (0, import_utilityScriptSerializers.parseEvaluationResultValue)((0, import_bidiDeserializer.deserializeBidiValue)(response.result));
       return createHandle(utilityScript._context, response.result);
     }
     throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
@@ -123,7 +123,10 @@ class BidiExecutionContext {
       }
       return names2;
     });
-    const values = await Promise.all(names.map((name) => handle.evaluateHandle((object, name2) => object[name2], name)));
+    const values = await Promise.all(names.map(async (name) => {
+      const value = await this._rawCallFunction("(object, name) => object[name]", [{ handle: handle._objectId }, { type: "string", value: name }], true, false);
+      return createHandle(handle._context, value);
+    }));
     const map = /* @__PURE__ */ new Map();
     for (let i = 0; i < names.length; i++)
       map.set(names[i], values[i]);
@@ -152,7 +155,7 @@ class BidiExecutionContext {
     return createHandle(context, result);
   }
   async contentFrameIdForFrame(handle) {
-    const contentWindow = await this._rawCallFunction("e => e.contentWindow", { handle: handle._objectId });
+    const contentWindow = await this._rawCallFunction("e => e.contentWindow", [{ handle: handle._objectId }]);
     if (contentWindow?.type === "window")
       return contentWindow.value.context;
     return null;
@@ -166,17 +169,17 @@ class BidiExecutionContext {
     return null;
   }
   async _remoteValueForReference(reference, createHandle2) {
-    return await this._rawCallFunction("e => e", reference, createHandle2);
+    return await this._rawCallFunction("e => e", [reference], createHandle2);
   }
-  async _rawCallFunction(functionDeclaration, arg, createHandle2) {
+  async _rawCallFunction(functionDeclaration, args, createHandle2, awaitPromise = true) {
     const response = await this._session.send("script.callFunction", {
       functionDeclaration,
       target: this._target,
-      arguments: [arg],
+      arguments: args,
       // "Root" is necessary for the handle to be returned.
       resultOwnership: createHandle2 ? bidi.Script.ResultOwnership.Root : bidi.Script.ResultOwnership.None,
       serializationOptions: { maxObjectDepth: 0, maxDomDepth: 0 },
-      awaitPromise: true,
+      awaitPromise,
       userActivation: true
     });
     if (response.type === "exception")
@@ -186,25 +189,65 @@ class BidiExecutionContext {
     throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
   }
 }
-function renderPreview(remoteObject) {
-  if (remoteObject.type === "undefined")
-    return "undefined";
-  if (remoteObject.type === "null")
-    return "null";
-  if ("value" in remoteObject)
-    return String(remoteObject.value);
-  return `<${remoteObject.type}>`;
-}
-function remoteObjectValue(remoteObject) {
-  if (remoteObject.type === "undefined")
-    return void 0;
-  if (remoteObject.type === "null")
-    return null;
-  if (remoteObject.type === "number" && typeof remoteObject.value === "string")
-    return js.parseUnserializableValue(remoteObject.value);
-  if ("value" in remoteObject)
-    return remoteObject.value;
-  return void 0;
+function renderPreview(remoteObject, nested = false) {
+  switch (remoteObject.type) {
+    case "undefined":
+    case "null":
+      return remoteObject.type;
+    case "number":
+    case "boolean":
+    case "string":
+      return String(remoteObject.value);
+    case "bigint":
+      return `${remoteObject.value}n`;
+    case "date":
+      return String(new Date(remoteObject.value));
+    case "regexp":
+      return String(new RegExp(remoteObject.value.pattern, remoteObject.value.flags));
+    case "node":
+      return remoteObject.value?.localName || "Node";
+    case "object":
+      if (nested)
+        return "Object";
+      const tokens = [];
+      for (const [name, value] of remoteObject.value || []) {
+        if (typeof name === "string")
+          tokens.push(`${name}: ${renderPreview(value, true)}`);
+      }
+      return `{${tokens.join(", ")}}`;
+    case "array":
+    case "htmlcollection":
+    case "nodelist":
+      if (nested || !remoteObject.value)
+        return remoteObject.value ? `Array(${remoteObject.value.length})` : "Array";
+      return `[${remoteObject.value.map((v) => renderPreview(v, true)).join(", ")}]`;
+    case "map":
+      return remoteObject.value ? `Map(${remoteObject.value.length})` : "Map";
+    case "set":
+      return remoteObject.value ? `Set(${remoteObject.value.length})` : "Set";
+    case "arraybuffer":
+      return "ArrayBuffer";
+    case "error":
+      return "Error";
+    case "function":
+      return "Function";
+    case "generator":
+      return "Generator";
+    case "promise":
+      return "Promise";
+    case "proxy":
+      return "Proxy";
+    case "symbol":
+      return "Symbol()";
+    case "typedarray":
+      return "TypedArray";
+    case "weakmap":
+      return "WeakMap";
+    case "weakset":
+      return "WeakSet";
+    case "window":
+      return "Window";
+  }
 }
 function createHandle(context, remoteObject) {
   if (remoteObject.type === "node") {
@@ -212,7 +255,10 @@ function createHandle(context, remoteObject) {
     return new dom.ElementHandle(context, remoteObject.handle);
   }
   const objectId = "handle" in remoteObject ? remoteObject.handle : void 0;
-  return new js.JSHandle(context, remoteObject.type, renderPreview(remoteObject), objectId, remoteObjectValue(remoteObject));
+  const preview = renderPreview(remoteObject);
+  const handle = new js.JSHandle(context, remoteObject.type, preview, objectId, (0, import_bidiDeserializer.deserializeBidiValue)(remoteObject));
+  handle._setPreview(preview);
+  return handle;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/bidi/bidiFirefox.js

@@ -49,15 +49,13 @@ class BidiFirefox extends import_browserType.BrowserType {
   async connectToTransport(transport, options) {
     return import_bidiBrowser.BidiBrowser.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/bidi/bidiNetworkManager.js

@@ -36,6 +36,7 @@ var import_eventsHelper = require("../utils/eventsHelper");
 var import_cookieStore = require("../cookieStore");
 var network = __toESM(require("../network"));
 var bidi = __toESM(require("./third_party/bidiProtocol"));
+const REQUEST_BODY_HEADERS = /* @__PURE__ */ new Set(["content-encoding", "content-language", "content-location", "content-type"]);
 class BidiNetworkManager {
   constructor(bidiSession, page) {
     this._userRequestInterceptionEnabled = false;
@@ -64,12 +65,38 @@ class BidiNetworkManager {
       return;
     if (redirectedFrom)
       this._deleteRequest(redirectedFrom._id);
+    if (param.request.method === "OPTIONS") {
+      const requestHeaders = Object.fromEntries(param.request.headers.map((h) => [h.name.toLowerCase(), bidiBytesValueToString(h.value)]));
+      if (param.initiator?.type === "preflight" || requestHeaders["access-control-request-method"]) {
+        if (param.intercepts) {
+          const responseHeaders = [
+            { name: "Access-Control-Allow-Origin", value: requestHeaders["origin"] || "*" },
+            { name: "Access-Control-Allow-Methods", value: requestHeaders["access-control-request-method"] },
+            { name: "Access-Control-Allow-Credentials", value: "true" }
+          ];
+          if (requestHeaders["access-control-request-headers"])
+            responseHeaders.push({ name: "Access-Control-Allow-Headers", value: requestHeaders["access-control-request-headers"] });
+          this._session.sendMayFail("network.provideResponse", {
+            request: param.request.request,
+            statusCode: 204,
+            headers: toBidiHeaders(responseHeaders)
+          });
+        }
+        return;
+      }
+    }
     let route;
+    let headersOverride;
     if (param.intercepts) {
       if (redirectedFrom) {
         let params = {};
-        if (redirectedFrom._originalRequestRoute?._alreadyContinuedHeaders)
-          params = toBidiRequestHeaders(redirectedFrom._originalRequestRoute._alreadyContinuedHeaders ?? []);
+        if (redirectedFrom._originalRequestRoute?._alreadyContinuedHeaders) {
+          const originalHeaders = fromBidiHeaders(param.request.headers);
+          headersOverride = network.applyHeadersOverrides(originalHeaders, redirectedFrom._originalRequestRoute._alreadyContinuedHeaders);
+          if (redirectedFrom.request.method() === "POST" && param.request.method === "GET")
+            headersOverride = headersOverride.filter(({ name }) => !REQUEST_BODY_HEADERS.has(name.toLowerCase()));
+          params = toBidiRequestHeaders(headersOverride);
+        }
         this._session.sendMayFail("network.continueRequest", {
           request: param.request.request,
           ...params
@@ -78,7 +105,7 @@ class BidiNetworkManager {
         route = new BidiRouteImpl(this._session, param.request.request);
       }
     }
-    const request = new BidiRequest(frame, redirectedFrom, param, route);
+    const request = new BidiRequest(frame, redirectedFrom, param, route, headersOverride);
     this._requests.set(request._id, request);
     this._page.frameManager.requestStarted(request.request, route);
   }
@@ -111,6 +138,7 @@ class BidiNetworkManager {
     const response = new network.Response(request.request, params.response.status, params.response.statusText, fromBidiHeaders(params.response.headers), timing, getResponseBody, false);
     response._serverAddrFinished();
     response._securityDetailsFinished();
+    response._setHttpVersion(params.response.protocol);
     response.setRawResponseHeaders(null);
     response.setResponseHeadersSize(params.response.headersSize);
     this._page.frameManager.requestReceivedResponse(response);
@@ -130,7 +158,6 @@ class BidiNetworkManager {
       this._deleteRequest(request._id);
       response._requestFinished(responseEndTime);
     }
-    response._setHttpVersion(params.response.protocol);
     this._page.frameManager.reportRequestFinished(request.request, response);
   }
   _onFetchError(params) {
@@ -194,13 +221,13 @@ class BidiNetworkManager {
     this._protocolRequestInterceptionEnabled = enabled;
     if (initial && !enabled)
       return;
-    const cachePromise = this._session.send("network.setCacheBehavior", { cacheBehavior: enabled ? "bypass" : "default" });
+    const contexts = [this._page.delegate._session.sessionId];
+    const cachePromise = this._session.send("network.setCacheBehavior", { cacheBehavior: enabled ? "bypass" : "default", contexts });
     let interceptPromise = Promise.resolve(void 0);
     if (enabled) {
       interceptPromise = this._session.send("network.addIntercept", {
-        phases: [bidi.Network.InterceptPhase.AuthRequired, bidi.Network.InterceptPhase.BeforeRequestSent],
-        urlPatterns: [{ type: "pattern" }]
-        // urlPatterns: [{ type: 'string', pattern: '*' }],
+        phases: [bidi.Network.InterceptPhase.BeforeRequestSent],
+        contexts
       }).then((r) => {
         this._intercepId = r.intercept;
       });
@@ -212,7 +239,7 @@ class BidiNetworkManager {
   }
 }
 class BidiRequest {
-  constructor(frame, redirectedFrom, payload, route) {
+  constructor(frame, redirectedFrom, payload, route, headersOverride) {
     this._id = payload.request.request;
     if (redirectedFrom)
       redirectedFrom._redirectedTo = this;
@@ -227,7 +254,7 @@ class BidiRequest {
       resourceTypeFromBidi(payload.request.destination, payload.request.initiatorType, payload.initiator?.type),
       payload.request.method,
       postDataBuffer,
-      fromBidiHeaders(payload.request.headers)
+      headersOverride || fromBidiHeaders(payload.request.headers)
     );
     this.request.setRawRequestHeaders(null);
     this.request._setBodySize(payload.request.bodySize || 0);
@@ -269,11 +296,12 @@ class BidiRouteImpl {
   }
   async fulfill(response) {
     const base64body = response.isBase64 ? response.body : Buffer.from(response.body).toString("base64");
+    const headers = response.headers.filter((h) => h.name.toLowerCase() !== "content-encoding");
     await this._session.sendMayFail("network.provideResponse", {
       request: this._requestId,
       statusCode: response.status,
       reasonPhrase: network.statusText(response.status),
-      ...toBidiResponseHeaders(response.headers),
+      ...toBidiResponseHeaders(headers),
       body: { type: "base64", value: base64body }
     });
   }
@@ -342,7 +370,7 @@ function resourceTypeFromBidi(requestDestination, requestInitiatorType, eventIni
     case "image":
       return "image";
     case "object":
-      return "object";
+      return "other";
     case "paintworklet":
       return "script";
     case "script":