rebrowser-playwright-core 1.49.1 → 1.52.0

package/lib/remote/playwrightConnection.js

@@ -1,222 +1,205 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 playwrightConnection_exports = {};
+__export(playwrightConnection_exports, {
+  PlaywrightConnection: () => PlaywrightConnection
 });
-exports.PlaywrightConnection = void 0;
-var _server = require("../server");
-var _browser = require("../server/browser");
-var _instrumentation = require("../server/instrumentation");
-var _socksProxy = require("../common/socksProxy");
-var _utils = require("../utils");
-var _android = require("../server/android/android");
-var _debugControllerDispatcher = require("../server/dispatchers/debugControllerDispatcher");
-var _debugLogger = require("../utils/debugLogger");
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
+module.exports = __toCommonJS(playwrightConnection_exports);
+var import_socksProxy = require("../server/utils/socksProxy");
+var import_server = require("../server");
+var import_android = require("../server/android/android");
+var import_browser = require("../server/browser");
+var import_debugControllerDispatcher = require("../server/dispatchers/debugControllerDispatcher");
+var import_instrumentation = require("../server/instrumentation");
+var import_assert = require("../utils/isomorphic/assert");
+var import_debug = require("../server/utils/debug");
+var import_profiler = require("../server/utils/profiler");
+var import_utils = require("../utils");
+var import_debugLogger = require("../server/utils/debugLogger");
 class PlaywrightConnection {
   constructor(lock, clientType, ws, options, preLaunched, id, onClose) {
-    this._ws = void 0;
-    this._onClose = void 0;
-    this._dispatcherConnection = void 0;
     this._cleanups = [];
-    this._id = void 0;
     this._disconnected = false;
-    this._preLaunched = void 0;
-    this._options = void 0;
-    this._root = void 0;
-    this._profileName = void 0;
     this._ws = ws;
     this._preLaunched = preLaunched;
     this._options = options;
-    options.launchOptions = filterLaunchOptions(options.launchOptions);
-    if (clientType === 'reuse-browser' || clientType === 'pre-launched-browser-or-android') (0, _utils.assert)(preLaunched.playwright);
-    if (clientType === 'pre-launched-browser-or-android') (0, _utils.assert)(preLaunched.browser || preLaunched.androidDevice);
+    options.launchOptions = filterLaunchOptions(options.launchOptions, options.allowFSPaths);
+    if (clientType === "reuse-browser" || clientType === "pre-launched-browser-or-android")
+      (0, import_assert.assert)(preLaunched.playwright);
+    if (clientType === "pre-launched-browser-or-android")
+      (0, import_assert.assert)(preLaunched.browser || preLaunched.androidDevice);
     this._onClose = onClose;
     this._id = id;
-    this._profileName = `${new Date().toISOString()}-${clientType}`;
-    this._dispatcherConnection = new _server.DispatcherConnection();
-    this._dispatcherConnection.onmessage = async message => {
+    this._profileName = `${(/* @__PURE__ */ new Date()).toISOString()}-${clientType}`;
+    this._dispatcherConnection = new import_server.DispatcherConnection();
+    this._dispatcherConnection.onmessage = async (message) => {
       await lock;
       if (ws.readyState !== ws.CLOSING) {
         const messageString = JSON.stringify(message);
-        if (_debugLogger.debugLogger.isEnabled('server:channel')) _debugLogger.debugLogger.log('server:channel', `[${this._id}] ${(0, _utils.monotonicTime)() * 1000} SEND ► ${messageString}`);
-        if (_debugLogger.debugLogger.isEnabled('server:metadata')) this.logServerMetadata(message, messageString, 'SEND');
+        if (import_debugLogger.debugLogger.isEnabled("server:channel"))
+          import_debugLogger.debugLogger.log("server:channel", `[${this._id}] ${(0, import_utils.monotonicTime)() * 1e3} SEND \u25BA ${messageString}`);
+        if (import_debugLogger.debugLogger.isEnabled("server:metadata"))
+          this.logServerMetadata(message, messageString, "SEND");
         ws.send(messageString);
       }
     };
-    ws.on('message', async message => {
+    ws.on("message", async (message) => {
       await lock;
       const messageString = Buffer.from(message).toString();
       const jsonMessage = JSON.parse(messageString);
-      if (_debugLogger.debugLogger.isEnabled('server:channel')) _debugLogger.debugLogger.log('server:channel', `[${this._id}] ${(0, _utils.monotonicTime)() * 1000} ◀ RECV ${messageString}`);
-      if (_debugLogger.debugLogger.isEnabled('server:metadata')) this.logServerMetadata(jsonMessage, messageString, 'RECV');
+      if (import_debugLogger.debugLogger.isEnabled("server:channel"))
+        import_debugLogger.debugLogger.log("server:channel", `[${this._id}] ${(0, import_utils.monotonicTime)() * 1e3} \u25C0 RECV ${messageString}`);
+      if (import_debugLogger.debugLogger.isEnabled("server:metadata"))
+        this.logServerMetadata(jsonMessage, messageString, "RECV");
       this._dispatcherConnection.dispatch(jsonMessage);
     });
-    ws.on('close', () => this._onDisconnect());
-    ws.on('error', error => this._onDisconnect(error));
-    if (clientType === 'controller') {
+    ws.on("close", () => this._onDisconnect());
+    ws.on("error", (error) => this._onDisconnect(error));
+    if (clientType === "controller") {
       this._root = this._initDebugControllerMode();
       return;
     }
-    this._root = new _server.RootDispatcher(this._dispatcherConnection, async (scope, options) => {
-      await (0, _utils.startProfiling)();
-      if (clientType === 'reuse-browser') return await this._initReuseBrowsersMode(scope);
-      if (clientType === 'pre-launched-browser-or-android') return this._preLaunched.browser ? await this._initPreLaunchedBrowserMode(scope) : await this._initPreLaunchedAndroidMode(scope);
-      if (clientType === 'launch-browser') return await this._initLaunchBrowserMode(scope, options);
-      throw new Error('Unsupported client type: ' + clientType);
+    this._root = new import_server.RootDispatcher(this._dispatcherConnection, async (scope, options2) => {
+      await (0, import_profiler.startProfiling)();
+      if (clientType === "reuse-browser")
+        return await this._initReuseBrowsersMode(scope);
+      if (clientType === "pre-launched-browser-or-android")
+        return this._preLaunched.browser ? await this._initPreLaunchedBrowserMode(scope) : await this._initPreLaunchedAndroidMode(scope);
+      if (clientType === "launch-browser")
+        return await this._initLaunchBrowserMode(scope, options2);
+      throw new Error("Unsupported client type: " + clientType);
     });
   }
   async _initLaunchBrowserMode(scope, options) {
-    _debugLogger.debugLogger.log('server', `[${this._id}] engaged launch mode for "${this._options.browserName}"`);
-    const playwright = (0, _server.createPlaywright)({
-      sdkLanguage: options.sdkLanguage,
-      isServer: true
-    });
+    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged launch mode for "${this._options.browserName}"`);
+    const playwright = (0, import_server.createPlaywright)({ sdkLanguage: options.sdkLanguage, isServer: true });
     const ownedSocksProxy = await this._createOwnedSocksProxy(playwright);
-    const browser = await playwright[this._options.browserName].launch((0, _instrumentation.serverSideCallMetadata)(), this._options.launchOptions);
+    let browserName = this._options.browserName;
+    if ("bidi" === browserName) {
+      if (this._options.launchOptions?.channel?.toLocaleLowerCase().includes("firefox"))
+        browserName = "bidiFirefox";
+      else
+        browserName = "bidiChromium";
+    }
+    const browser = await playwright[browserName].launch((0, import_instrumentation.serverSideCallMetadata)(), this._options.launchOptions);
     this._cleanups.push(async () => {
-      for (const browser of playwright.allBrowsers()) await browser.close({
-        reason: 'Connection terminated'
-      });
+      for (const browser2 of playwright.allBrowsers())
+        await browser2.close({ reason: "Connection terminated" });
     });
-    browser.on(_browser.Browser.Events.Disconnected, () => {
-      // Underlying browser did close for some reason - force disconnect the client.
-      this.close({
-        code: 1001,
-        reason: 'Browser closed'
-      });
+    browser.on(import_browser.Browser.Events.Disconnected, () => {
+      this.close({ code: 1001, reason: "Browser closed" });
     });
-    return new _server.PlaywrightDispatcher(scope, playwright, ownedSocksProxy, browser);
+    return new import_server.PlaywrightDispatcher(scope, playwright, ownedSocksProxy, browser);
   }
   async _initPreLaunchedBrowserMode(scope) {
-    var _this$_preLaunched$so;
-    _debugLogger.debugLogger.log('server', `[${this._id}] engaged pre-launched (browser) mode`);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged pre-launched (browser) mode`);
     const playwright = this._preLaunched.playwright;
-
-    // Note: connected client owns the socks proxy and configures the pattern.
-    (_this$_preLaunched$so = this._preLaunched.socksProxy) === null || _this$_preLaunched$so === void 0 || _this$_preLaunched$so.setPattern(this._options.socksProxyPattern);
+    this._preLaunched.socksProxy?.setPattern(this._options.socksProxyPattern);
     const browser = this._preLaunched.browser;
-    browser.on(_browser.Browser.Events.Disconnected, () => {
-      // Underlying browser did close for some reason - force disconnect the client.
-      this.close({
-        code: 1001,
-        reason: 'Browser closed'
-      });
+    browser.on(import_browser.Browser.Events.Disconnected, () => {
+      this.close({ code: 1001, reason: "Browser closed" });
     });
-    const playwrightDispatcher = new _server.PlaywrightDispatcher(scope, playwright, this._preLaunched.socksProxy, browser);
-    // In pre-launched mode, keep only the pre-launched browser.
+    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, this._preLaunched.socksProxy, browser);
     for (const b of playwright.allBrowsers()) {
-      if (b !== browser) await b.close({
-        reason: 'Connection terminated'
-      });
+      if (b !== browser)
+        await b.close({ reason: "Connection terminated" });
     }
     this._cleanups.push(() => playwrightDispatcher.cleanup());
     return playwrightDispatcher;
   }
   async _initPreLaunchedAndroidMode(scope) {
-    _debugLogger.debugLogger.log('server', `[${this._id}] engaged pre-launched (Android) mode`);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged pre-launched (Android) mode`);
     const playwright = this._preLaunched.playwright;
     const androidDevice = this._preLaunched.androidDevice;
-    androidDevice.on(_android.AndroidDevice.Events.Close, () => {
-      // Underlying browser did close for some reason - force disconnect the client.
-      this.close({
-        code: 1001,
-        reason: 'Android device disconnected'
-      });
+    androidDevice.on(import_android.AndroidDevice.Events.Close, () => {
+      this.close({ code: 1001, reason: "Android device disconnected" });
     });
-    const playwrightDispatcher = new _server.PlaywrightDispatcher(scope, playwright, undefined, undefined, androidDevice);
+    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, void 0, void 0, androidDevice);
     this._cleanups.push(() => playwrightDispatcher.cleanup());
     return playwrightDispatcher;
   }
   _initDebugControllerMode() {
-    _debugLogger.debugLogger.log('server', `[${this._id}] engaged reuse controller mode`);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse controller mode`);
     const playwright = this._preLaunched.playwright;
-    // Always create new instance based on the reused Playwright instance.
-    return new _debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, playwright.debugController);
+    return new import_debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, playwright.debugController);
   }
   async _initReuseBrowsersMode(scope) {
-    // Note: reuse browser mode does not support socks proxy, because
-    // clients come and go, while the browser stays the same.
-
-    _debugLogger.debugLogger.log('server', `[${this._id}] engaged reuse browsers mode for ${this._options.browserName}`);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse browsers mode for ${this._options.browserName}`);
     const playwright = this._preLaunched.playwright;
     const requestedOptions = launchOptionsHash(this._options.launchOptions);
-    let browser = playwright.allBrowsers().find(b => {
-      if (b.options.name !== this._options.browserName) return false;
+    let browser = playwright.allBrowsers().find((b) => {
+      if (b.options.name !== this._options.browserName)
+        return false;
       const existingOptions = launchOptionsHash(b.options.originalLaunchOptions);
       return existingOptions === requestedOptions;
     });
-
-    // Close remaining browsers of this type+channel. Keep different browser types for the speed.
     for (const b of playwright.allBrowsers()) {
-      if (b === browser) continue;
-      if (b.options.name === this._options.browserName && b.options.channel === this._options.launchOptions.channel) await b.close({
-        reason: 'Connection terminated'
-      });
+      if (b === browser)
+        continue;
+      if (b.options.name === this._options.browserName && b.options.channel === this._options.launchOptions.channel)
+        await b.close({ reason: "Connection terminated" });
     }
     if (!browser) {
-      browser = await playwright[this._options.browserName || 'chromium'].launch((0, _instrumentation.serverSideCallMetadata)(), {
+      browser = await playwright[this._options.browserName || "chromium"].launch((0, import_instrumentation.serverSideCallMetadata)(), {
         ...this._options.launchOptions,
         headless: !!process.env.PW_DEBUG_CONTROLLER_HEADLESS
       });
-      browser.on(_browser.Browser.Events.Disconnected, () => {
-        // Underlying browser did close for some reason - force disconnect the client.
-        this.close({
-          code: 1001,
-          reason: 'Browser closed'
-        });
+      browser.on(import_browser.Browser.Events.Disconnected, () => {
+        this.close({ code: 1001, reason: "Browser closed" });
       });
     }
     this._cleanups.push(async () => {
-      // Don't close the pages so that user could debug them,
-      // but close all the empty browsers and contexts to clean up.
-      for (const browser of playwright.allBrowsers()) {
-        for (const context of browser.contexts()) {
-          if (!context.pages().length) await context.close({
-            reason: 'Connection terminated'
-          });else await context.stopPendingOperations('Connection closed');
+      for (const browser2 of playwright.allBrowsers()) {
+        for (const context of browser2.contexts()) {
+          if (!context.pages().length)
+            await context.close({ reason: "Connection terminated" });
+          else
+            await context.stopPendingOperations("Connection closed");
         }
-        if (!browser.contexts()) await browser.close({
-          reason: 'Connection terminated'
-        });
+        if (!browser2.contexts())
+          await browser2.close({ reason: "Connection terminated" });
       }
     });
-    const playwrightDispatcher = new _server.PlaywrightDispatcher(scope, playwright, undefined, browser);
+    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, void 0, browser);
     return playwrightDispatcher;
   }
   async _createOwnedSocksProxy(playwright) {
-    if (!this._options.socksProxyPattern) return;
-    const socksProxy = new _socksProxy.SocksProxy();
+    if (!this._options.socksProxyPattern)
+      return;
+    const socksProxy = new import_socksProxy.SocksProxy();
     socksProxy.setPattern(this._options.socksProxyPattern);
     playwright.options.socksProxyPort = await socksProxy.listen(0);
-    _debugLogger.debugLogger.log('server', `[${this._id}] started socks proxy on port ${playwright.options.socksProxyPort}`);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] started socks proxy on port ${playwright.options.socksProxyPort}`);
     this._cleanups.push(() => socksProxy.close());
     return socksProxy;
   }
   async _onDisconnect(error) {
     this._disconnected = true;
-    _debugLogger.debugLogger.log('server', `[${this._id}] disconnected. error: ${error}`);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] disconnected. error: ${error}`);
     this._root._dispose();
-    _debugLogger.debugLogger.log('server', `[${this._id}] starting cleanup`);
-    for (const cleanup of this._cleanups) await cleanup().catch(() => {});
-    await (0, _utils.stopProfiling)(this._profileName);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] starting cleanup`);
+    for (const cleanup of this._cleanups)
+      await cleanup().catch(() => {
+      });
+    await (0, import_profiler.stopProfiling)(this._profileName);
     this._onClose();
-    _debugLogger.debugLogger.log('server', `[${this._id}] finished cleanup`);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] finished cleanup`);
   }
   logServerMetadata(message, messageString, direction) {
     const serverLogMetadata = {
@@ -224,31 +207,32 @@ class PlaywrightConnection {
       id: message.id,
       guid: message.guid,
       method: message.method,
-      payloadSizeInBytes: Buffer.byteLength(messageString, 'utf-8')
+      payloadSizeInBytes: Buffer.byteLength(messageString, "utf-8")
     };
-    _debugLogger.debugLogger.log('server:metadata', (direction === 'SEND' ? 'SEND ► ' : '◀ RECV ') + JSON.stringify(serverLogMetadata));
+    import_debugLogger.debugLogger.log("server:metadata", (direction === "SEND" ? "SEND \u25BA " : "\u25C0 RECV ") + JSON.stringify(serverLogMetadata));
   }
   async close(reason) {
-    if (this._disconnected) return;
-    _debugLogger.debugLogger.log('server', `[${this._id}] force closing connection: ${(reason === null || reason === void 0 ? void 0 : reason.reason) || ''} (${(reason === null || reason === void 0 ? void 0 : reason.code) || 0})`);
+    if (this._disconnected)
+      return;
+    import_debugLogger.debugLogger.log("server", `[${this._id}] force closing connection: ${reason?.reason || ""} (${reason?.code || 0})`);
     try {
-      this._ws.close(reason === null || reason === void 0 ? void 0 : reason.code, reason === null || reason === void 0 ? void 0 : reason.reason);
-    } catch (e) {}
+      this._ws.close(reason?.code, reason?.reason);
+    } catch (e) {
+    }
   }
 }
-exports.PlaywrightConnection = PlaywrightConnection;
 function launchOptionsHash(options) {
-  const copy = {
-    ...options
-  };
+  const copy = { ...options };
   for (const k of Object.keys(copy)) {
     const key = k;
-    if (copy[key] === defaultLaunchOptions[key]) delete copy[key];
+    if (copy[key] === defaultLaunchOptions[key])
+      delete copy[key];
   }
-  for (const key of optionsThatAllowBrowserReuse) delete copy[key];
+  for (const key of optionsThatAllowBrowserReuse)
+    delete copy[key];
   return JSON.stringify(copy);
 }
-function filterLaunchOptions(options) {
+function filterLaunchOptions(options, allowFSPaths) {
   return {
     channel: options.channel,
     args: options.args,
@@ -260,7 +244,8 @@ function filterLaunchOptions(options) {
     chromiumSandbox: options.chromiumSandbox,
     firefoxUserPrefs: options.firefoxUserPrefs,
     slowMo: options.slowMo,
-    executablePath: (0, _utils.isUnderTest)() ? options.executablePath : undefined
+    executablePath: (0, import_debug.isUnderTest)() || allowFSPaths ? options.executablePath : void 0,
+    downloadsPath: allowFSPaths ? options.downloadsPath : void 0
   };
 }
 const defaultLaunchOptions = {
@@ -271,4 +256,11 @@ const defaultLaunchOptions = {
   headless: true,
   devtools: false
 };
-const optionsThatAllowBrowserReuse = ['headless', 'tracesDir'];
+const optionsThatAllowBrowserReuse = [
+  "headless",
+  "tracesDir"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlaywrightConnection
+});

package/lib/remote/playwrightServer.js

@@ -1,102 +1,105 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 playwrightServer_exports = {};
+__export(playwrightServer_exports, {
+  PlaywrightServer: () => PlaywrightServer
 });
-exports.PlaywrightServer = void 0;
-var _playwright = require("../server/playwright");
-var _playwrightConnection = require("./playwrightConnection");
-var _semaphore = require("../utils/semaphore");
-var _debugLogger = require("../utils/debugLogger");
-var _utils = require("../utils");
-var _wsServer = require("../utils/wsServer");
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
+module.exports = __toCommonJS(playwrightServer_exports);
+var import_playwrightConnection = require("./playwrightConnection");
+var import_playwright = require("../server/playwright");
+var import_debugLogger = require("../server/utils/debugLogger");
+var import_semaphore = require("../utils/isomorphic/semaphore");
+var import_wsServer = require("../server/utils/wsServer");
+var import_ascii = require("../server/utils/ascii");
+var import_userAgent = require("../server/utils/userAgent");
 class PlaywrightServer {
   constructor(options) {
-    this._preLaunchedPlaywright = void 0;
-    this._options = void 0;
-    this._wsServer = void 0;
     this._options = options;
-    if (options.preLaunchedBrowser) this._preLaunchedPlaywright = options.preLaunchedBrowser.attribution.playwright;
-    if (options.preLaunchedAndroidDevice) this._preLaunchedPlaywright = options.preLaunchedAndroidDevice._android.attribution.playwright;
-    const browserSemaphore = new _semaphore.Semaphore(this._options.maxConnections);
-    const controllerSemaphore = new _semaphore.Semaphore(1);
-    const reuseBrowserSemaphore = new _semaphore.Semaphore(1);
-    this._wsServer = new _wsServer.WSServer({
+    if (options.preLaunchedBrowser)
+      this._preLaunchedPlaywright = options.preLaunchedBrowser.attribution.playwright;
+    if (options.preLaunchedAndroidDevice)
+      this._preLaunchedPlaywright = options.preLaunchedAndroidDevice._android.attribution.playwright;
+    const browserSemaphore = new import_semaphore.Semaphore(this._options.maxConnections);
+    const controllerSemaphore = new import_semaphore.Semaphore(1);
+    const reuseBrowserSemaphore = new import_semaphore.Semaphore(1);
+    this._wsServer = new import_wsServer.WSServer({
       onUpgrade: (request, socket) => {
-        const uaError = (0, _utils.userAgentVersionMatchesErrorMessage)(request.headers['user-agent'] || '');
-        if (uaError) return {
-          error: `HTTP/${request.httpVersion} 428 Precondition Required\r\n\r\n${uaError}`
-        };
+        const uaError = userAgentVersionMatchesErrorMessage(request.headers["user-agent"] || "");
+        if (uaError)
+          return { error: `HTTP/${request.httpVersion} 428 Precondition Required\r
+\r
+${uaError}` };
       },
-      onHeaders: headers => {
-        if (process.env.PWTEST_SERVER_WS_HEADERS) headers.push(process.env.PWTEST_SERVER_WS_HEADERS);
+      onHeaders: (headers) => {
+        if (process.env.PWTEST_SERVER_WS_HEADERS)
+          headers.push(process.env.PWTEST_SERVER_WS_HEADERS);
       },
       onConnection: (request, url, ws, id) => {
-        const browserHeader = request.headers['x-playwright-browser'];
-        const browserName = url.searchParams.get('browser') || (Array.isArray(browserHeader) ? browserHeader[0] : browserHeader) || null;
-        const proxyHeader = request.headers['x-playwright-proxy'];
-        const proxyValue = url.searchParams.get('proxy') || (Array.isArray(proxyHeader) ? proxyHeader[0] : proxyHeader);
-        const launchOptionsHeader = request.headers['x-playwright-launch-options'] || '';
+        const browserHeader = request.headers["x-playwright-browser"];
+        const browserName = url.searchParams.get("browser") || (Array.isArray(browserHeader) ? browserHeader[0] : browserHeader) || null;
+        const proxyHeader = request.headers["x-playwright-proxy"];
+        const proxyValue = url.searchParams.get("proxy") || (Array.isArray(proxyHeader) ? proxyHeader[0] : proxyHeader);
+        const launchOptionsHeader = request.headers["x-playwright-launch-options"] || "";
         const launchOptionsHeaderValue = Array.isArray(launchOptionsHeader) ? launchOptionsHeader[0] : launchOptionsHeader;
-        const launchOptionsParam = url.searchParams.get('launch-options');
+        const launchOptionsParam = url.searchParams.get("launch-options");
         let launchOptions = {};
         try {
           launchOptions = JSON.parse(launchOptionsParam || launchOptionsHeaderValue);
-        } catch (e) {}
-
-        // Instantiate playwright for the extension modes.
-        const isExtension = this._options.mode === 'extension';
+        } catch (e) {
+        }
+        const isExtension = this._options.mode === "extension";
         if (isExtension) {
-          if (!this._preLaunchedPlaywright) this._preLaunchedPlaywright = (0, _playwright.createPlaywright)({
-            sdkLanguage: 'javascript',
-            isServer: true
-          });
+          if (!this._preLaunchedPlaywright)
+            this._preLaunchedPlaywright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
         }
-        let clientType = 'launch-browser';
+        let clientType = "launch-browser";
         let semaphore = browserSemaphore;
-        if (isExtension && url.searchParams.has('debug-controller')) {
-          clientType = 'controller';
+        if (isExtension && url.searchParams.has("debug-controller")) {
+          clientType = "controller";
           semaphore = controllerSemaphore;
         } else if (isExtension) {
-          clientType = 'reuse-browser';
+          clientType = "reuse-browser";
           semaphore = reuseBrowserSemaphore;
-        } else if (this._options.mode === 'launchServer') {
-          clientType = 'pre-launched-browser-or-android';
+        } else if (this._options.mode === "launchServer") {
+          clientType = "pre-launched-browser-or-android";
           semaphore = browserSemaphore;
         }
-        return new _playwrightConnection.PlaywrightConnection(semaphore.acquire(), clientType, ws, {
-          socksProxyPattern: proxyValue,
-          browserName,
-          launchOptions
-        }, {
-          playwright: this._preLaunchedPlaywright,
-          browser: this._options.preLaunchedBrowser,
-          androidDevice: this._options.preLaunchedAndroidDevice,
-          socksProxy: this._options.preLaunchedSocksProxy
-        }, id, () => semaphore.release());
+        return new import_playwrightConnection.PlaywrightConnection(
+          semaphore.acquire(),
+          clientType,
+          ws,
+          { socksProxyPattern: proxyValue, browserName, launchOptions, allowFSPaths: this._options.mode === "extension" },
+          {
+            playwright: this._preLaunchedPlaywright,
+            browser: this._options.preLaunchedBrowser,
+            androidDevice: this._options.preLaunchedAndroidDevice,
+            socksProxy: this._options.preLaunchedSocksProxy
+          },
+          id,
+          () => semaphore.release()
+        );
       },
       onClose: async () => {
-        _debugLogger.debugLogger.log('server', 'closing browsers');
-        if (this._preLaunchedPlaywright) await Promise.all(this._preLaunchedPlaywright.allBrowsers().map(browser => browser.close({
-          reason: 'Playwright Server stopped'
-        })));
-        _debugLogger.debugLogger.log('server', 'closed browsers');
+        import_debugLogger.debugLogger.log("server", "closing browsers");
+        if (this._preLaunchedPlaywright)
+          await Promise.all(this._preLaunchedPlaywright.allBrowsers().map((browser) => browser.close({ reason: "Playwright Server stopped" })));
+        import_debugLogger.debugLogger.log("server", "closed browsers");
       }
     });
   }
@@ -107,4 +110,30 @@ class PlaywrightServer {
     await this._wsServer.close();
   }
 }
-exports.PlaywrightServer = PlaywrightServer;
+function userAgentVersionMatchesErrorMessage(userAgent) {
+  const match = userAgent.match(/^Playwright\/(\d+\.\d+\.\d+)/);
+  if (!match) {
+    return;
+  }
+  const received = match[1].split(".").slice(0, 2).join(".");
+  const expected = (0, import_userAgent.getPlaywrightVersion)(true);
+  if (received !== expected) {
+    return (0, import_ascii.wrapInASCIIBox)([
+      `Playwright version mismatch:`,
+      `  - server version: v${expected}`,
+      `  - client version: v${received}`,
+      ``,
+      `If you are using VSCode extension, restart VSCode.`,
+      ``,
+      `If you are connecting to a remote service,`,
+      `keep your local Playwright version in sync`,
+      `with the remote service version.`,
+      ``,
+      `<3 Playwright Team`
+    ].join("\n"), 1);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlaywrightServer
+});