patchright-core 1.56.1 → 1.58.2

package/lib/server/utils/network.js

@@ -35,22 +35,20 @@ __export(network_exports, {
   createProxyAgent: () => createProxyAgent,
   fetchData: () => fetchData,
   httpRequest: () => httpRequest,
-  isURLAvailable: () => isURLAvailable
+  isURLAvailable: () => isURLAvailable,
+  startHttpServer: () => startHttpServer
 });
 module.exports = __toCommonJS(network_exports);
 var import_http = __toESM(require("http"));
 var import_http2 = __toESM(require("http2"));
 var import_https = __toESM(require("https"));
-var import_url = __toESM(require("url"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_happyEyeballs = require("./happyEyeballs");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 const NET_DEFAULT_TIMEOUT = 3e4;
 function httpRequest(params, onResponse, onError) {
-  const parsedUrl = import_url.default.parse(params.url);
-  let options = {
-    ...parsedUrl,
-    agent: parsedUrl.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent,
+  let url = new URL(params.url);
+  const options = {
     method: params.method || "GET",
     headers: params.headers
   };
@@ -58,21 +56,16 @@ function httpRequest(params, onResponse, onError) {
     options.rejectUnauthorized = params.rejectUnauthorized;
   const proxyURL = (0, import_utilsBundle.getProxyForUrl)(params.url);
   if (proxyURL) {
-    const parsedProxyURL = import_url.default.parse(proxyURL);
+    const parsedProxyURL = normalizeProxyURL(proxyURL);
     if (params.url.startsWith("http:")) {
-      options = {
-        path: parsedUrl.href,
-        host: parsedProxyURL.hostname,
-        port: parsedProxyURL.port,
-        headers: options.headers,
-        method: options.method
-      };
+      parsedProxyURL.pathname = url.toString();
+      url = parsedProxyURL;
     } else {
-      parsedProxyURL.secureProxy = parsedProxyURL.protocol === "https:";
       options.agent = new import_utilsBundle.HttpsProxyAgent(parsedProxyURL);
       options.rejectUnauthorized = false;
     }
   }
+  options.agent ??= url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent;
   let cancelRequest;
   const requestCallback = (res) => {
     const statusCode = res.statusCode || 0;
@@ -83,7 +76,7 @@ function httpRequest(params, onResponse, onError) {
       onResponse(res);
     }
   };
-  const request = options.protocol === "https:" ? import_https.default.request(options, requestCallback) : import_http.default.request(options, requestCallback);
+  const request = url.protocol === "https:" ? import_https.default.request(url, options, requestCallback) : import_http.default.request(url, options, requestCallback);
   request.on("error", onError);
   if (params.socketTimeout !== void 0) {
     request.setTimeout(params.socketTimeout, () => {
@@ -122,7 +115,7 @@ async function fetchData(progress, params, onError) {
     throw error;
   }
 }
-function shouldBypassProxy(url2, bypass) {
+function shouldBypassProxy(url, bypass) {
   if (!bypass)
     return false;
   const domains = bypass.split(",").map((s) => {
@@ -131,30 +124,36 @@ function shouldBypassProxy(url2, bypass) {
       s = "." + s;
     return s;
   });
-  const domain = "." + url2.hostname;
+  const domain = "." + url.hostname;
   return domains.some((d) => domain.endsWith(d));
 }
+function normalizeProxyURL(proxy) {
+  proxy = proxy.trim();
+  if (!/^\w+:\/\//.test(proxy))
+    proxy = "http://" + proxy;
+  return new URL(proxy);
+}
 function createProxyAgent(proxy, forUrl) {
   if (!proxy)
     return;
   if (forUrl && proxy.bypass && shouldBypassProxy(forUrl, proxy.bypass))
     return;
-  let proxyServer = proxy.server.trim();
-  if (!/^\w+:\/\//.test(proxyServer))
-    proxyServer = "http://" + proxyServer;
-  const proxyOpts = import_url.default.parse(proxyServer);
-  if (proxyOpts.protocol?.startsWith("socks")) {
-    return new import_utilsBundle.SocksProxyAgent({
-      host: proxyOpts.hostname,
-      port: proxyOpts.port || void 0
-    });
+  const proxyURL = normalizeProxyURL(proxy.server);
+  if (proxyURL.protocol?.startsWith("socks")) {
+    if (proxyURL.protocol === "socks5:")
+      proxyURL.protocol = "socks5h:";
+    else if (proxyURL.protocol === "socks4:")
+      proxyURL.protocol = "socks4a:";
+    return new import_utilsBundle.SocksProxyAgent(proxyURL);
+  }
+  if (proxy.username) {
+    proxyURL.username = proxy.username;
+    proxyURL.password = proxy.password || "";
   }
-  if (proxy.username)
-    proxyOpts.auth = `${proxy.username}:${proxy.password || ""}`;
   if (forUrl && ["ws:", "wss:"].includes(forUrl.protocol)) {
-    return new import_utilsBundle.HttpsProxyAgent(proxyOpts);
+    return new import_utilsBundle.HttpsProxyAgent(proxyURL);
   }
-  return new import_utilsBundle.HttpsProxyAgent(proxyOpts);
+  return new import_utilsBundle.HttpsProxyAgent(proxyURL);
 }
 function createHttpServer(...args) {
   const server = import_http.default.createServer(...args);
@@ -171,20 +170,35 @@ function createHttp2Server(...args) {
   decorateServer(server);
   return server;
 }
-async function isURLAvailable(url2, ignoreHTTPSErrors, onLog, onStdErr) {
-  let statusCode = await httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr);
-  if (statusCode === 404 && url2.pathname === "/") {
-    const indexUrl = new URL(url2);
+async function startHttpServer(server, options) {
+  const { host = "localhost", port = 0 } = options;
+  const errorPromise = new import_manualPromise.ManualPromise();
+  const errorListener = (error) => errorPromise.reject(error);
+  server.on("error", errorListener);
+  try {
+    server.listen(port, host);
+    await Promise.race([
+      new Promise((cb) => server.once("listening", cb)),
+      errorPromise
+    ]);
+  } finally {
+    server.removeListener("error", errorListener);
+  }
+}
+async function isURLAvailable(url, ignoreHTTPSErrors, onLog, onStdErr) {
+  let statusCode = await httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr);
+  if (statusCode === 404 && url.pathname === "/") {
+    const indexUrl = new URL(url);
     indexUrl.pathname = "/index.html";
     statusCode = await httpStatusCode(indexUrl, ignoreHTTPSErrors, onLog, onStdErr);
   }
   return statusCode >= 200 && statusCode < 404;
 }
-async function httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr) {
+async function httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr) {
   return new Promise((resolve) => {
-    onLog?.(`HTTP GET: ${url2}`);
+    onLog?.(`HTTP GET: ${url}`);
     httpRequest({
-      url: url2.toString(),
+      url: url.toString(),
       headers: { Accept: "*/*" },
       rejectUnauthorized: !ignoreHTTPSErrors
     }, (res) => {
@@ -195,7 +209,7 @@ async function httpStatusCode(url2, ignoreHTTPSErrors, onLog, onStdErr) {
     }, (error) => {
       if (error.code === "DEPTH_ZERO_SELF_SIGNED_CERT")
         onStdErr?.(`[WebServer] Self-signed certificate detected. Try adding ignoreHTTPSErrors: true to config.webServer.`);
-      onLog?.(`Error while checking if ${url2} is available: ${error.message}`);
+      onLog?.(`Error while checking if ${url} is available: ${error.message}`);
       resolve(0);
     });
   });
@@ -223,5 +237,6 @@ function decorateServer(server) {
   createProxyAgent,
   fetchData,
   httpRequest,
-  isURLAvailable
+  isURLAvailable,
+  startHttpServer
 });

package/lib/server/utils/nodePlatform.js

@@ -42,6 +42,7 @@ var import_utilsBundle = require("../../utilsBundle");
 var import_debugLogger = require("./debugLogger");
 var import_zones = require("./zones");
 var import_debug = require("./debug");
+var import_mcpBundle = require("../../mcpBundle");
 const pipelineAsync = util.promisify(import_stream.pipeline);
 class NodeZone {
   constructor(zone) {
@@ -105,6 +106,11 @@ const nodePlatform = {
   streamWritable: (channel) => {
     return new WritableStreamImpl(channel);
   },
+  zodToJsonSchema: (schema) => {
+    if ("_zod" in schema)
+      return import_mcpBundle.z.toJSONSchema(schema);
+    return (0, import_mcpBundle.zodToJsonSchema)(schema);
+  },
   zones: {
     current: () => new NodeZone((0, import_zones.currentZone)()),
     empty: new NodeZone(import_zones.emptyZone)

package/lib/server/{chromium/videoRecorder.js → videoRecorder.js}

@@ -21,31 +21,26 @@ __export(videoRecorder_exports, {
   VideoRecorder: () => VideoRecorder
 });
 module.exports = __toCommonJS(videoRecorder_exports);
-var import_utils = require("../../utils");
-var import_page = require("../page");
-var import_processLauncher = require("../utils/processLauncher");
+var import_utils = require("../utils");
+var import_processLauncher = require("./utils/processLauncher");
 const fps = 25;
 class VideoRecorder {
-  constructor(page, ffmpegPath) {
+  constructor(ffmpegPath, options) {
     this._process = null;
     this._gracefullyClose = null;
     this._lastWritePromise = Promise.resolve();
-    this._lastFrameTimestamp = 0;
-    this._lastFrameBuffer = null;
-    this._lastWriteTimestamp = 0;
+    this._firstFrameTimestamp = 0;
+    this._lastFrame = null;
+    this._lastWriteNodeTime = 0;
     this._frameQueue = [];
     this._isStopped = false;
     this._ffmpegPath = ffmpegPath;
-    page.on(import_page.Page.Events.ScreencastFrame, (frame) => this.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
-  }
-  static async launch(page, ffmpegPath, options) {
     if (!options.outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    const recorder = new VideoRecorder(page, ffmpegPath);
-    await recorder._launch(options);
-    return recorder;
+    this._launchPromise = this._launch(options).catch((e) => e);
   }
   async _launch(options) {
+    await (0, import_utils.mkdirIfNeeded)(options.outputFile);
     const w = options.width;
     const h = options.height;
     const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(" ");
@@ -74,19 +69,27 @@ class VideoRecorder {
     this._gracefullyClose = gracefullyClose;
   }
   writeFrame(frame, timestamp) {
+    this._launchPromise.then((error) => {
+      if (error)
+        return;
+      this._writeFrame(frame, timestamp);
+    });
+  }
+  _writeFrame(frame, timestamp) {
     (0, import_utils.assert)(this._process);
     if (this._isStopped)
       return;
-    if (this._lastFrameBuffer) {
-      const durationSec = timestamp - this._lastFrameTimestamp;
-      const repeatCount = Math.max(1, Math.round(fps * durationSec));
+    if (!this._firstFrameTimestamp)
+      this._firstFrameTimestamp = timestamp;
+    const frameNumber = Math.floor((timestamp - this._firstFrameTimestamp) * fps);
+    if (this._lastFrame) {
+      const repeatCount = frameNumber - this._lastFrame.frameNumber;
       for (let i = 0; i < repeatCount; ++i)
-        this._frameQueue.push(this._lastFrameBuffer);
+        this._frameQueue.push(this._lastFrame.buffer);
       this._lastWritePromise = this._lastWritePromise.then(() => this._sendFrames());
     }
-    this._lastFrameBuffer = frame;
-    this._lastFrameTimestamp = timestamp;
-    this._lastWriteTimestamp = (0, import_utils.monotonicTime)();
+    this._lastFrame = { buffer: frame, timestamp, frameNumber };
+    this._lastWriteNodeTime = (0, import_utils.monotonicTime)();
   }
   async _sendFrames() {
     while (this._frameQueue.length)
@@ -99,12 +102,20 @@ class VideoRecorder {
     });
   }
   async stop() {
-    if (this._isStopped)
+    const error = await this._launchPromise;
+    if (error)
+      throw error;
+    if (this._isStopped || !this._lastFrame)
       return;
-    this.writeFrame(Buffer.from([]), this._lastFrameTimestamp + ((0, import_utils.monotonicTime)() - this._lastWriteTimestamp) / 1e3);
+    const addTime = Math.max(((0, import_utils.monotonicTime)() - this._lastWriteNodeTime) / 1e3, 1);
+    this._writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
     this._isStopped = true;
-    await this._lastWritePromise;
-    await this._gracefullyClose();
+    try {
+      await this._lastWritePromise;
+      await this._gracefullyClose();
+    } catch (e) {
+      import_utils.debugLogger.log("error", `ffmpeg failed to stop: ${String(e)}`);
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/webkit/webkit.js

@@ -38,7 +38,6 @@ var import_ascii = require("../utils/ascii");
 var import_browserType = require("../browserType");
 var import_wkBrowser = require("../webkit/wkBrowser");
 var import_spawnAsync = require("../utils/spawnAsync");
-var import_registry = require("../registry");
 class WebKit extends import_browserType.BrowserType {
   constructor(parent) {
     super(parent, "webkit");
@@ -49,16 +48,13 @@ class WebKit extends import_browserType.BrowserType {
   amendEnvironment(env, userDataDir, isPersistent, options) {
     return {
       ...env,
-      CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0,
-      WEBKIT_EXECUTABLE: options.channel === "webkit-wsl" ? import_registry.registry.findExecutable("webkit-wsl").wslExecutablePath : void 0
+      CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0
     };
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes("Failed to open display") || error.logs.includes("cannot open display"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    return error;
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Failed to open display") || logs.includes("cannot open display"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
   }
   attemptToGracefullyCloseBrowser(transport) {
     transport.send({ method: "Playwright.close", params: {}, id: import_wkConnection.kBrowserCloseMessageId });
@@ -71,13 +67,6 @@ class WebKit extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const webkitArguments = ["--inspector-pipe"];
-    if (options.channel === "webkit-wsl") {
-      if (options.executablePath)
-        throw new Error('Cannot specify executablePath when using the "webkit-wsl" channel.');
-      webkitArguments.unshift(
-        import_path.default.join(__dirname, "wsl/webkit-wsl-transport-server.js")
-      );
-    }
     if (process.platform === "win32" && options.channel !== "webkit-wsl")
       webkitArguments.push("--disable-accelerated-compositing");
     if (headless)

package/lib/server/webkit/wkBrowser.js

@@ -56,7 +56,6 @@ class WKBrowser extends import_browser.Browser {
     this._browserSession.on("Playwright.downloadCreated", this._onDownloadCreated.bind(this));
     this._browserSession.on("Playwright.downloadFilenameSuggested", this._onDownloadFilenameSuggested.bind(this));
     this._browserSession.on("Playwright.downloadFinished", this._onDownloadFinished.bind(this));
-    this._browserSession.on("Playwright.screencastFinished", this._onScreencastFinished.bind(this));
     this._browserSession.on(import_wkConnection.kPageProxyMessageReceived, this._onPageProxyMessageReceived.bind(this));
   }
   static async connect(parent, transport, options) {
@@ -79,7 +78,7 @@ class WKBrowser extends import_browser.Browser {
       wkPage.didClose();
     this._wkPages.clear();
     for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError());
+      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
     this._idToVideo.clear();
     this._didClose();
   }
@@ -131,9 +130,6 @@ class WKBrowser extends import_browser.Browser {
   _onDownloadFinished(payload) {
     this._downloadFinished(payload.uuid, payload.error);
   }
-  _onScreencastFinished(payload) {
-    this._takeVideo(payload.screencastId)?.reportFinished();
-  }
   _onPageProxyCreated(event) {
     const pageProxyId = event.pageProxyId;
     let context = null;
@@ -315,7 +311,7 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      await Promise.all(this._wkPages().map((wkPage) => wkPage._stopVideo()));
+      await Promise.all(this._wkPages().map((wkPage) => wkPage._page.screencast.stopVideoRecording()));
       await this._browser.close({ reason });
     } else {
       await this._browser._browserSession.send("Playwright.deleteContext", { browserContextId: this._browserContextId });

package/lib/server/webkit/wkConnection.js

@@ -89,11 +89,6 @@ class WKSession extends import_events.EventEmitter {
     this.connection = connection;
     this.sessionId = sessionId;
     this._rawSend = rawSend;
-    this.on = super.on;
-    this.off = super.removeListener;
-    this.addListener = super.addListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
   }
   async send(method, params) {
     if (this._crashed || this._disposed || this.connection._browserDisconnectedLogs)
@@ -134,7 +129,7 @@ class WKSession extends import_events.EventEmitter {
         callback.resolve(object.result);
       }
     } else if (object.id && !object.error) {
-      (0, import_utils.assert)(this.isDisposed());
+      (0, import_utils.assert)(this.isDisposed(), JSON.stringify(object));
     } else {
       Promise.resolve().then(() => this.emit(object.method, object.params));
     }

package/lib/server/webkit/wkInterceptableRequest.js

@@ -54,7 +54,7 @@ class WKInterceptableRequest {
   constructor(session, frame, event, redirectedFrom, documentId) {
     this._session = session;
     this._requestId = event.requestId;
-    const resourceType = event.type ? event.type.toLowerCase() : redirectedFrom ? redirectedFrom.request.resourceType() : "other";
+    const resourceType = event.type ? toResourceType(event.type) : redirectedFrom ? redirectedFrom.request.resourceType() : "other";
     let postDataBuffer = null;
     this._timestamp = event.timestamp;
     this._wallTime = event.walltime * 1e3;
@@ -162,6 +162,34 @@ function wkMillisToRoundishMillis(value) {
   }
   return (value * 1e3 | 0) / 1e3;
 }
+function toResourceType(type) {
+  switch (type) {
+    case "Document":
+      return "document";
+    case "StyleSheet":
+      return "stylesheet";
+    case "Image":
+      return "image";
+    case "Font":
+      return "font";
+    case "Script":
+      return "script";
+    case "XHR":
+      return "xhr";
+    case "Fetch":
+      return "fetch";
+    case "Ping":
+      return "ping";
+    case "Beacon":
+      return "beacon";
+    case "WebSocket":
+      return "websocket";
+    case "EventSource":
+      return "eventsource";
+    default:
+      return "other";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WKInterceptableRequest,