patchright-core 1.58.2 → 1.59.0

package/lib/server/videoRecorder.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,17 +17,75 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var videoRecorder_exports = {};
 __export(videoRecorder_exports, {
-  VideoRecorder: () => VideoRecorder
+  VideoRecorder: () => VideoRecorder,
+  startAutomaticVideoRecording: () => startAutomaticVideoRecording
 });
 module.exports = __toCommonJS(videoRecorder_exports);
+var import_path = __toESM(require("path"));
 var import_utils = require("../utils");
 var import_processLauncher = require("./utils/processLauncher");
+var import_utilsBundle = require("../utilsBundle");
+var import_artifact = require("./artifact");
+var import__ = require(".");
 const fps = 25;
 class VideoRecorder {
-  constructor(ffmpegPath, options) {
+  constructor(screencast) {
+    this._screencast = screencast;
+  }
+  start(options) {
+    (0, import_utils.assert)(!this._artifact);
+    const ffmpegPath = import__.registry.findExecutable("ffmpeg").executablePathOrDie(this._screencast.page.browserContext._browser.sdkLanguage());
+    const outputFile = options.fileName ?? import_path.default.join(this._screencast.page.browserContext._browser.options.artifactsDir, (0, import_utils.createGuid)() + ".webm");
+    this._client = {
+      onFrame: (frame) => this._videoRecorder.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3),
+      gracefulClose: () => this.stop(),
+      dispose: () => this.stop().catch((e) => import_utils.debugLogger.log("error", `Failed to stop video recorder: ${String(e)}`)),
+      size: options.size
+    };
+    const { size } = this._screencast.addClient(this._client);
+    const videoSize = options.size ?? size;
+    this._videoRecorder = new FfmpegVideoRecorder(ffmpegPath, videoSize, outputFile);
+    this._artifact = new import_artifact.Artifact(this._screencast.page.browserContext, outputFile);
+    return this._artifact;
+  }
+  async stop() {
+    if (!this._artifact)
+      return;
+    const artifact = this._artifact;
+    this._artifact = void 0;
+    const client = this._client;
+    this._client = void 0;
+    const videoRecorder = this._videoRecorder;
+    this._videoRecorder = void 0;
+    this._screencast.removeClient(client);
+    await videoRecorder.stop();
+    await artifact.reportFinished();
+  }
+}
+function startAutomaticVideoRecording(page) {
+  const recordVideo = page.browserContext._options.recordVideo;
+  if (!recordVideo)
+    return;
+  const recorder = new VideoRecorder(page.screencast);
+  if (page.browserContext._options.recordVideo?.showActions)
+    page.screencast.showActions(page.browserContext._options.recordVideo?.showActions);
+  const dir = recordVideo.dir ?? page.browserContext._browser.options.artifactsDir;
+  const artifact = recorder.start({ size: recordVideo.size, fileName: import_path.default.join(dir, page.guid + ".webm") });
+  page.video = artifact;
+}
+class FfmpegVideoRecorder {
+  constructor(ffmpegPath, size, outputFile) {
     this._process = null;
     this._gracefullyClose = null;
     this._lastWritePromise = Promise.resolve();
@@ -34,17 +94,19 @@ class VideoRecorder {
     this._lastWriteNodeTime = 0;
     this._frameQueue = [];
     this._isStopped = false;
-    this._ffmpegPath = ffmpegPath;
-    if (!options.outputFile.endsWith(".webm"))
+    if (!outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    this._launchPromise = this._launch(options).catch((e) => e);
+    this._outputFile = outputFile;
+    this._ffmpegPath = ffmpegPath;
+    this._size = size;
+    this._launchPromise = this._launch().catch((e) => e);
   }
-  async _launch(options) {
-    await (0, import_utils.mkdirIfNeeded)(options.outputFile);
-    const w = options.width;
-    const h = options.height;
+  async _launch() {
+    await (0, import_utils.mkdirIfNeeded)(this._outputFile);
+    const w = this._size.width;
+    const h = this._size.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(" ");
-    args.push(options.outputFile);
+    args.push(this._outputFile);
     const { launchedProcess, gracefullyClose } = await (0, import_processLauncher.launchProcess)({
       command: this._ffmpegPath,
       args,
@@ -105,8 +167,11 @@ class VideoRecorder {
     const error = await this._launchPromise;
     if (error)
       throw error;
-    if (this._isStopped || !this._lastFrame)
+    if (this._isStopped)
       return;
+    if (!this._lastFrame) {
+      this._writeFrame(createWhiteImage(this._size.width, this._size.height), (0, import_utils.monotonicTime)());
+    }
     const addTime = Math.max(((0, import_utils.monotonicTime)() - this._lastWriteNodeTime) / 1e3, 1);
     this._writeFrame(Buffer.from([]), this._lastFrame.timestamp + addTime);
     this._isStopped = true;
@@ -118,7 +183,12 @@ class VideoRecorder {
     }
   }
 }
+function createWhiteImage(width, height) {
+  const data = Buffer.alloc(width * height * 4, 255);
+  return import_utilsBundle.jpegjs.encode({ data, width, height }, 80).data;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  VideoRecorder
+  VideoRecorder,
+  startAutomaticVideoRecording
 });

package/lib/server/webkit/wkBrowser.js

@@ -38,9 +38,8 @@ var import_browserContext = require("../browserContext");
 var network = __toESM(require("../network"));
 var import_wkConnection = require("./wkConnection");
 var import_wkPage = require("./wkPage");
-var import_errors = require("../errors");
 var import_webkit = require("./webkit");
-const BROWSER_VERSION = "26.0";
+const BROWSER_VERSION = "26.4";
 const DEFAULT_USER_AGENT = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/${BROWSER_VERSION} Safari/605.1.15`;
 class WKBrowser extends import_browser.Browser {
   constructor(parent, transport, options) {
@@ -77,9 +76,6 @@ class WKBrowser extends import_browser.Browser {
     for (const wkPage of this._wkPages.values())
       wkPage.didClose();
     this._wkPages.clear();
-    for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
-    this._idToVideo.clear();
     this._didClose();
   }
   async doCreateNewContext(options) {
@@ -311,7 +307,6 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      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/wkPage.js

@@ -37,6 +37,7 @@ var import_eventsHelper = require("../utils/eventsHelper");
 var import_hostPlatform = require("../utils/hostPlatform");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var import_utilsBundle = require("../../utilsBundle");
+var import_browserContext = require("../browserContext");
 var dialog = __toESM(require("../dialog"));
 var dom = __toESM(require("../dom"));
 var import_errors = require("../errors");
@@ -51,8 +52,9 @@ var import_wkProvisionalPage = require("./wkProvisionalPage");
 var import_wkWorkers = require("./wkWorkers");
 var import_webkit = require("./webkit");
 var import_registry = require("../registry");
+var import_videoRecorder = require("../videoRecorder");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
-const enableFrameSessions = !process.env.WK_DISABLE_FRAME_SESSIONS && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) >= 2245;
+const enableFrameSessions = !process.env.WK_DISABLE_FRAME_SESSIONS && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) >= 2245 && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) <= 2255;
 class WKPage {
   constructor(browserContext, pageProxySession, opener) {
     this._provisionalPage = null;
@@ -115,7 +117,7 @@ class WKPage {
       for (const [key, value] of this._browserContext._permissions)
         promises.push(this._grantPermissions(key, value));
     }
-    promises.push(this._initializeVideoRecording());
+    (0, import_videoRecorder.startAutomaticVideoRecording)(this._page);
     await Promise.all(promises);
   }
   _setSession(session) {
@@ -518,7 +520,7 @@ class WKPage {
         columnNumber: (columnNumber || 1) - 1
       }
     };
-    this._onConsoleRepeatCountUpdated({ count: 1 });
+    this._onConsoleRepeatCountUpdated({ count: 1, timestamp: event.message.timestamp });
   }
   _onConsoleRepeatCountUpdated(event) {
     if (this._lastConsoleMessage) {
@@ -529,8 +531,9 @@ class WKPage {
         count,
         location
       } = this._lastConsoleMessage;
+      const timestamp = event.timestamp ? event.timestamp * 1e3 : Date.now();
       for (let i = count; i < event.count; ++i)
-        this._page.addConsoleMessage(null, derivedType, handles, location, handles.length ? void 0 : text);
+        this._page.addConsoleMessage(null, derivedType, handles, location, handles.length ? void 0 : text, timestamp);
       this._lastConsoleMessage.count = event.count;
     }
   }
@@ -645,9 +648,11 @@ class WKPage {
   async updateUserAgent() {
     const contextOptions = this._browserContext._options;
     this._updateState("Page.overrideUserAgent", { value: contextOptions.userAgent });
+    const { navigatorPlatform } = (0, import_browserContext.calculateUserAgentEmulation)(contextOptions);
+    this._updateState("Page.overridePlatform", navigatorPlatform ? { value: navigatorPlatform } : {});
   }
   async bringToFront() {
-    this._pageProxySession.send("Target.activate", {
+    await this._pageProxySession.send("Target.activate", {
       targetId: this._session.sessionId
     });
   }
@@ -773,12 +778,6 @@ class WKPage {
       return import_hostPlatform.hostPlatform === "mac10.15" ? 55 : 59;
     return 0;
   }
-  async _initializeVideoRecording() {
-    const screencast = this._page.screencast;
-    const videoOptions = screencast.launchVideoRecorder();
-    if (videoOptions)
-      await screencast.startVideoRecording(videoOptions);
-  }
   validateScreenshotDimension(side, omitDeviceScaleFactor) {
     if (process.platform === "darwin")
       return;
@@ -845,29 +844,28 @@ class WKPage {
       throw e;
     });
   }
-  async startScreencast(options) {
-    const { generation } = await this._pageProxySession.send("Screencast.startScreencast", {
+  startScreencast(options) {
+    this._pageProxySession.send("Screencast.startScreencast", {
       quality: options.quality,
       width: options.width,
       height: options.height,
       toolbarHeight: this._toolbarHeight()
+    }).then(({ generation }) => this._screencastGeneration = generation).catch(() => {
     });
-    this._screencastGeneration = generation;
   }
-  async stopScreencast() {
-    await this._pageProxySession.sendMayFail("Screencast.stopScreencast");
+  stopScreencast() {
+    this._pageProxySession.sendMayFail("Screencast.stopScreencast");
   }
   _onScreencastFrame(event) {
     const generation = this._screencastGeneration;
-    this._page.screencast.throttleFrameAck(() => {
-      this._pageProxySession.sendMayFail("Screencast.screencastFrameAck", { generation });
-    });
     const buffer = Buffer.from(event.data, "base64");
-    this._page.emit(import_page.Page.Events.ScreencastFrame, {
+    this._page.screencast.onScreencastFrame({
       buffer,
       frameSwapWallTime: event.timestamp ? event.timestamp * 1e3 : Date.now(),
-      width: event.deviceWidth,
-      height: event.deviceHeight
+      viewportWidth: event.deviceWidth,
+      viewportHeight: event.deviceHeight
+    }, () => {
+      this._pageProxySession.sendMayFail("Screencast.screencastFrameAck", { generation });
     });
   }
   rafCountForStablePosition() {
@@ -981,6 +979,7 @@ class WKPage {
   }
   _handleRequestRedirect(request, requestId, responsePayload, timestamp) {
     const response = request.createResponse(responsePayload);
+    response._setHttpVersion(null);
     response._securityDetailsFinished();
     response._serverAddrFinished();
     response.setResponseHeadersSize(null);
@@ -1033,8 +1032,7 @@ class WKPage {
         validFrom: responseReceivedPayload?.response.security?.certificate?.validFrom,
         validTo: responseReceivedPayload?.response.security?.certificate?.validUntil
       });
-      if (event.metrics?.protocol)
-        response._setHttpVersion(event.metrics.protocol);
+      response._setHttpVersion(event.metrics?.protocol ?? null);
       response.setEncodedBodySize(event.metrics?.responseBodyBytesReceived ?? null);
       response.setResponseHeadersSize(event.metrics?.responseHeaderBytesReceived ?? null);
       response._requestFinished(import_helper.helper.secondsToRoundishMillis(event.timestamp - request._timestamp));
@@ -1058,6 +1056,7 @@ class WKPage {
     if (response) {
       response._serverAddrFinished();
       response._securityDetailsFinished();
+      response._setHttpVersion(null);
       response.setResponseHeadersSize(null);
       response.setEncodedBodySize(null);
       response._requestFinished(import_helper.helper.secondsToRoundishMillis(event.timestamp - request._timestamp));
@@ -1072,7 +1071,8 @@ class WKPage {
     const webPermissionToProtocol = /* @__PURE__ */ new Map([
       ["geolocation", "geolocation"],
       ["notifications", "notifications"],
-      ["clipboard-read", "clipboard-read"]
+      ["clipboard-read", "clipboard-read"],
+      ["screen-wake-lock", "screen-wake-lock"]
     ]);
     const filtered = permissions.map((permission) => {
       const protocolPermission = webPermissionToProtocol.get(permission);
@@ -1088,6 +1088,8 @@ class WKPage {
   shouldToggleStyleSheetToSyncAnimations() {
     return true;
   }
+  async setDockTile(image) {
+  }
 }
 class WKFrame {
   constructor(page, session) {

package/lib/server/webkit/wkWorkers.js

@@ -96,7 +96,8 @@ class WKWorkers {
       lineNumber: (lineNumber || 1) - 1,
       columnNumber: (columnNumber || 1) - 1
     };
-    this._page.addConsoleMessage(worker, derivedType, handles, location, handles.length ? void 0 : text);
+    const timestamp = event.message.timestamp ? event.message.timestamp * 1e3 : Date.now();
+    this._page.addConsoleMessage(worker, derivedType, handles, location, handles.length ? void 0 : text, timestamp);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/serverRegistry.js

@@ -0,0 +1,156 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverRegistry_exports = {};
+__export(serverRegistry_exports, {
+  serverRegistry: () => serverRegistry
+});
+module.exports = __toCommonJS(serverRegistry_exports);
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+const packageVersion = require("../package.json").version;
+class ServerRegistry {
+  async list() {
+    const files = await import_fs.default.promises.readdir(this._browsersDir()).catch(() => []);
+    const result = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      try {
+        const filePath = import_path.default.join(this._browsersDir(), file);
+        const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+        const descriptor = JSON.parse(content);
+        const key = descriptor.workspaceDir ?? "";
+        let list = result.get(key);
+        if (!list) {
+          list = [];
+          result.set(key, list);
+        }
+        list.push(canConnect(descriptor).then((connectable) => ({ ...descriptor, canConnect: connectable, file: filePath })));
+      } catch {
+      }
+    }
+    const resolvedResult = /* @__PURE__ */ new Map();
+    for (const [key, promises] of result) {
+      const entries = await Promise.all(promises);
+      const descriptors = [];
+      for (const entry of entries) {
+        if (!entry.canConnect && !entry.browser.userDataDir) {
+          await import_fs.default.promises.unlink(entry.file).catch(() => {
+          });
+          continue;
+        }
+        descriptors.push(entry);
+      }
+      if (descriptors.length)
+        resolvedResult.set(key, descriptors);
+    }
+    return resolvedResult;
+  }
+  async create(browser, endpoint) {
+    const file = import_path.default.join(this._browsersDir(), browser.guid);
+    await import_fs.default.promises.mkdir(this._browsersDir(), { recursive: true });
+    const descriptor = {
+      playwrightVersion: packageVersion,
+      playwrightLib: require.resolve(".."),
+      title: endpoint.title,
+      browser,
+      endpoint: endpoint.endpoint,
+      workspaceDir: endpoint.workspaceDir
+    };
+    await import_fs.default.promises.writeFile(file, JSON.stringify(descriptor), "utf-8");
+  }
+  async delete(guid) {
+    const file = import_path.default.join(this._browsersDir(), guid);
+    await import_fs.default.promises.unlink(file).catch(() => {
+    });
+  }
+  async deleteUserData(guid) {
+    const filePath = import_path.default.join(this._browsersDir(), guid);
+    const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+    const descriptor = JSON.parse(content);
+    if (descriptor.browser.userDataDir)
+      await import_fs.default.promises.rm(descriptor.browser.userDataDir, { recursive: true, force: true });
+    await import_fs.default.promises.unlink(filePath);
+  }
+  readDescriptor(guid) {
+    const filePath = import_path.default.join(this._browsersDir(), guid);
+    const content = import_fs.default.readFileSync(filePath, "utf-8");
+    const descriptor = JSON.parse(content);
+    return descriptor;
+  }
+  async find(name) {
+    const entries = await this.list();
+    for (const [, browsers] of entries) {
+      for (const browser of browsers) {
+        if (browser.title === name)
+          return browser;
+      }
+    }
+    return null;
+  }
+  _browsersDir() {
+    return process.env.PLAYWRIGHT_SERVER_REGISTRY || registryDirectory;
+  }
+}
+async function canConnect(descriptor) {
+  if (!descriptor.endpoint)
+    return false;
+  if (descriptor.endpoint.startsWith("ws://") || descriptor.endpoint.startsWith("wss://")) {
+    return await new Promise((resolve) => {
+      const url = new URL(descriptor.endpoint);
+      const socket = import_net.default.createConnection(Number(url.port), url.hostname, () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on("error", () => resolve(false));
+    });
+  }
+  return await new Promise((resolve) => {
+    const socket = import_net.default.createConnection(descriptor.endpoint ?? descriptor.pipeName, () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => resolve(false));
+  });
+}
+const defaultCacheDirectory = (() => {
+  if (process.platform === "linux")
+    return process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache");
+  if (process.platform === "darwin")
+    return import_path.default.join(import_os.default.homedir(), "Library", "Caches");
+  if (process.platform === "win32")
+    return process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local");
+  throw new Error("Unsupported platform: " + process.platform);
+})();
+const registryDirectory = import_path.default.join(defaultCacheDirectory, "ms-playwright", "b");
+const serverRegistry = new ServerRegistry();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serverRegistry
+});

package/lib/tools/backend/browserBackend.js

@@ -0,0 +1,79 @@
+"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 browserBackend_exports = {};
+__export(browserBackend_exports, {
+  BrowserBackend: () => BrowserBackend
+});
+module.exports = __toCommonJS(browserBackend_exports);
+var import_context = require("./context");
+var import_response = require("./response");
+var import_sessionLog = require("./sessionLog");
+var import_utilsBundle = require("../../utilsBundle");
+class BrowserBackend {
+  constructor(config, browserContext, tools) {
+    this._config = config;
+    this._tools = tools;
+    this.browserContext = browserContext;
+  }
+  async initialize(clientInfo) {
+    this._sessionLog = this._config.saveSession ? await import_sessionLog.SessionLog.create(this._config, clientInfo.cwd) : void 0;
+    this._context = new import_context.Context(this.browserContext, {
+      config: this._config,
+      sessionLog: this._sessionLog,
+      cwd: clientInfo.cwd
+    });
+  }
+  async dispose() {
+    await this._context?.dispose().catch((e) => (0, import_utilsBundle.debug)("pw:tools:error")(e));
+  }
+  async callTool(name, rawArguments = {}) {
+    const tool = this._tools.find((tool2) => tool2.schema.name === name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `### Error
+Tool "${name}" not found` }],
+        isError: true
+      };
+    }
+    const parsedArguments = tool.schema.inputSchema.parse(rawArguments);
+    const cwd = rawArguments._meta?.cwd;
+    const context = this._context;
+    const response = new import_response.Response(context, name, parsedArguments, cwd);
+    context.setRunningTool(name);
+    let responseObject;
+    try {
+      await tool.handle(context, parsedArguments, response);
+      responseObject = await response.serialize();
+      this._sessionLog?.logResponse(name, parsedArguments, responseObject);
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `### Error
+${String(error)}` }],
+        isError: true
+      };
+    } finally {
+      context.setRunningTool(void 0);
+    }
+    return responseObject;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserBackend
+});

package/lib/tools/backend/common.js

@@ -0,0 +1,63 @@
+"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 common_exports = {};
+__export(common_exports, {
+  default: () => common_default
+});
+module.exports = __toCommonJS(common_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_tool = require("./tool");
+var import_response = require("./response");
+const close = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_close",
+    title: "Close browser",
+    description: "Close the page",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const result = (0, import_response.renderTabsMarkdown)([]);
+    response.addTextResult(result.join("\n"));
+    response.addCode(`await page.close()`);
+    response.setClose();
+  }
+});
+const resize = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_resize",
+    title: "Resize browser window",
+    description: "Resize the browser window",
+    inputSchema: import_zodBundle.z.object({
+      width: import_zodBundle.z.number().describe("Width of the browser window"),
+      height: import_zodBundle.z.number().describe("Height of the browser window")
+    }),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`await page.setViewportSize({ width: ${params.width}, height: ${params.height} });`);
+    await tab.page.setViewportSize({ width: params.width, height: params.height });
+  }
+});
+var common_default = [
+  close,
+  resize
+];

package/lib/tools/backend/config.js

@@ -0,0 +1,41 @@
+"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 config_exports = {};
+__export(config_exports, {
+  default: () => config_default
+});
+module.exports = __toCommonJS(config_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_tool = require("./tool");
+const configShow = (0, import_tool.defineTool)({
+  capability: "config",
+  schema: {
+    name: "browser_get_config",
+    title: "Get config",
+    description: "Get the final resolved config after merging CLI options, environment variables and config file.",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    response.addTextResult(JSON.stringify(context.config, null, 2));
+  }
+});
+var config_default = [
+  configShow
+];