patchright-core 1.57.0 → 1.59.0

package/lib/cli/program.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,39 +15,25 @@ 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 program_exports = {};
 __export(program_exports, {
   program: () => import_utilsBundle2.program
 });
 module.exports = __toCommonJS(program_exports);
-var import_fs = __toESM(require("fs"));
-var import_os = __toESM(require("os"));
-var import_path = __toESM(require("path"));
-var playwright = __toESM(require("../.."));
-var import_driver = require("./driver");
-var import_server = require("../server");
+var import_bootstrap = require("../bootstrap");
 var import_utils = require("../utils");
-var import_traceViewer = require("../server/trace/viewer/traceViewer");
-var import_utils2 = require("../utils");
-var import_ascii = require("../server/utils/ascii");
+var import_traceCli = require("../tools/trace/traceCli");
 var import_utilsBundle = require("../utilsBundle");
 var import_utilsBundle2 = require("../utilsBundle");
 const packageJSON = require("../../package.json");
 import_utilsBundle.program.version("Version " + (process.env.PW_CLI_DISPLAY_VERSION || packageJSON.version)).name(buildBasePlaywrightCLICommand(process.env.PW_LANG_NAME));
-import_utilsBundle.program.command("mark-docker-image [dockerImageNameTemplate]", { hidden: true }).description("mark docker image").allowUnknownOption(true).action(function(dockerImageNameTemplate) {
-  (0, import_utils2.assert)(dockerImageNameTemplate, "dockerImageNameTemplate is required");
-  (0, import_server.writeDockerVersion)(dockerImageNameTemplate).catch(logErrorAndExit);
+import_utilsBundle.program.command("mark-docker-image [dockerImageNameTemplate]", { hidden: true }).description("mark docker image").allowUnknownOption(true).action(async function(dockerImageNameTemplate) {
+  const { markDockerImage } = require("./installActions");
+  markDockerImage(dockerImageNameTemplate).catch(logErrorAndExit);
 });
-commandWithOpenOptions("open [url]", "open page in browser specified via -b, --browser", []).action(function(url, options) {
+commandWithOpenOptions("open [url]", "open page in browser specified via -b, --browser", []).action(async function(url, options) {
+  const { open } = require("./browserActions");
   open(options, url).catch(logErrorAndExit);
 }).addHelpText("afterAll", `
 Examples:
@@ -65,6 +49,7 @@ commandWithOpenOptions(
     ["--test-id-attribute <attributeName>", "use the specified attribute to generate data test ID selectors"]
   ]
 ).action(async function(url, options) {
+  const { codegen } = require("./browserActions");
   await codegen(options, url);
 }).addHelpText("afterAll", `
 Examples:
@@ -72,112 +57,10 @@ Examples:
   $ codegen
   $ codegen --target=python
   $ codegen -b webkit https://example.com`);
-function printInstalledBrowsers(browsers2) {
-  const browserPaths = /* @__PURE__ */ new Set();
-  for (const browser of browsers2)
-    browserPaths.add(browser.browserPath);
-  console.log(`  Browsers:`);
-  for (const browserPath of [...browserPaths].sort())
-    console.log(`    ${browserPath}`);
-  console.log(`  References:`);
-  const references = /* @__PURE__ */ new Set();
-  for (const browser of browsers2)
-    references.add(browser.referenceDir);
-  for (const reference of [...references].sort())
-    console.log(`    ${reference}`);
-}
-function printGroupedByPlaywrightVersion(browsers2) {
-  const dirToVersion = /* @__PURE__ */ new Map();
-  for (const browser of browsers2) {
-    if (dirToVersion.has(browser.referenceDir))
-      continue;
-    const packageJSON2 = require(import_path.default.join(browser.referenceDir, "package.json"));
-    const version = packageJSON2.version;
-    dirToVersion.set(browser.referenceDir, version);
-  }
-  const groupedByPlaywrightMinorVersion = /* @__PURE__ */ new Map();
-  for (const browser of browsers2) {
-    const version = dirToVersion.get(browser.referenceDir);
-    let entries = groupedByPlaywrightMinorVersion.get(version);
-    if (!entries) {
-      entries = [];
-      groupedByPlaywrightMinorVersion.set(version, entries);
-    }
-    entries.push(browser);
-  }
-  const sortedVersions = [...groupedByPlaywrightMinorVersion.keys()].sort((a, b) => {
-    const aComponents = a.split(".");
-    const bComponents = b.split(".");
-    const aMajor = parseInt(aComponents[0], 10);
-    const bMajor = parseInt(bComponents[0], 10);
-    if (aMajor !== bMajor)
-      return aMajor - bMajor;
-    const aMinor = parseInt(aComponents[1], 10);
-    const bMinor = parseInt(bComponents[1], 10);
-    if (aMinor !== bMinor)
-      return aMinor - bMinor;
-    return aComponents.slice(2).join(".").localeCompare(bComponents.slice(2).join("."));
-  });
-  for (const version of sortedVersions) {
-    console.log(`
-Playwright version: ${version}`);
-    printInstalledBrowsers(groupedByPlaywrightMinorVersion.get(version));
-  }
-}
-import_utilsBundle.program.command("install [browser...]").description("ensure browsers necessary for this version of Playwright are installed").option("--with-deps", "install system dependencies for browsers").option("--dry-run", "do not execute installation, only print information").option("--list", "prints list of browsers from all playwright installations").option("--force", "force reinstall of stable browser channels").option("--only-shell", "only install headless shell when installing chromium").option("--no-shell", "do not install chromium headless shell").action(async function(args, options) {
-  if ((0, import_utils.isLikelyNpxGlobal)()) {
-    console.error((0, import_ascii.wrapInASCIIBox)([
-      `WARNING: It looks like you are running 'npx playwright install' without first`,
-      `installing your project's dependencies.`,
-      ``,
-      `To avoid unexpected behavior, please install your dependencies first, and`,
-      `then run Playwright's install command:`,
-      ``,
-      `    npm install`,
-      `    npx playwright install`,
-      ``,
-      `If your project does not yet depend on Playwright, first install the`,
-      `applicable npm package (most commonly @playwright/test), and`,
-      `then run Playwright's install command to download the browsers:`,
-      ``,
-      `    npm install @playwright/test`,
-      `    npx playwright install`,
-      ``
-    ].join("\n"), 1));
-  }
+import_utilsBundle.program.command("install [browser...]").description("ensure browsers necessary for this version of Playwright are installed").option("--with-deps", "install system dependencies for browsers").option("--dry-run", "do not execute installation, only print information").option("--list", "prints list of browsers from all playwright installations").option("--force", "force reinstall of already installed browsers").option("--only-shell", "only install headless shell when installing chromium").option("--no-shell", "do not install chromium headless shell").action(async function(args, options) {
   try {
-    if (options.shell === false && options.onlyShell)
-      throw new Error(`Only one of --no-shell and --only-shell can be specified`);
-    const shell = options.shell === false ? "no" : options.onlyShell ? "only" : void 0;
-    const executables = import_server.registry.resolveBrowsers(args, { shell });
-    if (options.withDeps)
-      await import_server.registry.installDeps(executables, !!options.dryRun);
-    if (options.dryRun && options.list)
-      throw new Error(`Only one of --dry-run and --list can be specified`);
-    if (options.dryRun) {
-      for (const executable of executables) {
-        const version = executable.browserVersion ? `version ` + executable.browserVersion : "";
-        console.log(`browser: ${executable.name}${version ? " " + version : ""}`);
-        console.log(`  Install location:    ${executable.directory ?? "<system>"}`);
-        if (executable.downloadURLs?.length) {
-          const [url, ...fallbacks] = executable.downloadURLs;
-          console.log(`  Download url:        ${url}`);
-          for (let i = 0; i < fallbacks.length; ++i)
-            console.log(`  Download fallback ${i + 1}: ${fallbacks[i]}`);
-        }
-        console.log(``);
-      }
-    } else if (options.list) {
-      const browsers2 = await import_server.registry.listInstalledBrowsers();
-      printGroupedByPlaywrightVersion(browsers2);
-    } else {
-      const force = args.length === 0 ? false : !!options.force;
-      await import_server.registry.install(executables, { force });
-      await import_server.registry.validateHostRequirementsForExecutablesIfNeeded(executables, process.env.PW_LANG_NAME || "javascript").catch((e) => {
-        e.name = "Playwright Host validation warning";
-        console.error(e);
-      });
-    }
+    const { installBrowsers } = require("./installActions");
+    await installBrowsers(args, options);
   } catch (e) {
     console.log(`Failed to install browsers
 ${e}`);
@@ -190,20 +73,15 @@ Examples:
     Install default browsers.
 
   - $ install chrome firefox
-    Install custom browsers, supports ${import_server.registry.suggestedBrowsersToInstall()}.`);
+    Install custom browsers, supports chromium, firefox, webkit, chromium-headless-shell.`);
 import_utilsBundle.program.command("uninstall").description("Removes browsers used by this installation of Playwright from the system (chromium, firefox, webkit, ffmpeg). This does not include branded channels.").option("--all", "Removes all browsers used by any Playwright installation from the system.").action(async (options) => {
-  delete process.env.PLAYWRIGHT_SKIP_BROWSER_GC;
-  await import_server.registry.uninstall(!!options.all).then(({ numberOfBrowsersLeft }) => {
-    if (!options.all && numberOfBrowsersLeft > 0) {
-      console.log("Successfully uninstalled Playwright browsers for the current Playwright installation.");
-      console.log(`There are still ${numberOfBrowsersLeft} browsers left, used by other Playwright installations.
-To uninstall Playwright browsers for all installations, re-run with --all flag.`);
-    }
-  }).catch(logErrorAndExit);
+  const { uninstallBrowsers } = require("./installActions");
+  uninstallBrowsers(options).catch(logErrorAndExit);
 });
 import_utilsBundle.program.command("install-deps [browser...]").description("install dependencies necessary to run browsers (will ask for sudo permissions)").option("--dry-run", "Do not execute installation commands, only print them").action(async function(args, options) {
   try {
-    await import_server.registry.installDeps(import_server.registry.resolveBrowsers(args, {}), !!options.dryRun);
+    const { installDeps } = require("./installActions");
+    await installDeps(args, options);
   } catch (e) {
     console.log(`Failed to install browser dependencies
 ${e}`);
@@ -215,14 +93,15 @@ Examples:
     Install dependencies for default browsers.
 
   - $ install-deps chrome firefox
-    Install dependencies for specific browsers, supports ${import_server.registry.suggestedBrowsersToInstall()}.`);
+    Install dependencies for specific browsers, supports chromium, firefox, webkit, chromium-headless-shell.`);
 const browsers = [
   { alias: "cr", name: "Chromium", type: "chromium" },
   { alias: "ff", name: "Firefox", type: "firefox" },
   { alias: "wk", name: "WebKit", type: "webkit" }
 ];
 for (const { alias, name, type } of browsers) {
-  commandWithOpenOptions(`${alias} [url]`, `open page in ${name}`, []).action(function(url, options) {
+  commandWithOpenOptions(`${alias} [url]`, `open page in ${name}`, []).action(async function(url, options) {
+    const { open } = require("./browserActions");
     open({ ...options, browser: type }, url).catch(logErrorAndExit);
   }).addHelpText("afterAll", `
 Examples:
@@ -237,7 +116,8 @@ commandWithOpenOptions(
     ["--wait-for-timeout <timeout>", "wait for timeout in milliseconds before taking a screenshot"],
     ["--full-page", "whether to take a full page screenshot (entire scrollable area)"]
   ]
-).action(function(url, filename, command) {
+).action(async function(url, filename, command) {
+  const { screenshot } = require("./browserActions");
   screenshot(command, command, url, filename).catch(logErrorAndExit);
 }).addHelpText("afterAll", `
 Examples:
@@ -251,31 +131,37 @@ commandWithOpenOptions(
     ["--wait-for-selector <selector>", "wait for given selector before saving as pdf"],
     ["--wait-for-timeout <timeout>", "wait for given timeout in milliseconds before saving as pdf"]
   ]
-).action(function(url, filename, options) {
+).action(async function(url, filename, options) {
+  const { pdf } = require("./browserActions");
   pdf(options, options, url, filename).catch(logErrorAndExit);
 }).addHelpText("afterAll", `
 Examples:
 
   $ pdf https://example.com example.pdf`);
-import_utilsBundle.program.command("run-driver", { hidden: true }).action(function(options) {
-  (0, import_driver.runDriver)();
+import_utilsBundle.program.command("run-driver", { hidden: true }).action(async function(options) {
+  const { runDriver } = require("./driver");
+  runDriver();
 });
-import_utilsBundle.program.command("run-server", { hidden: true }).option("--port <port>", "Server port").option("--host <host>", "Server host").option("--path <path>", "Endpoint Path", "/").option("--max-clients <maxClients>", "Maximum clients").option("--mode <mode>", 'Server mode, either "default" or "extension"').action(function(options) {
-  (0, import_driver.runServer)({
+import_utilsBundle.program.command("run-server", { hidden: true }).option("--port <port>", "Server port").option("--host <host>", "Server host").option("--path <path>", "Endpoint Path", "/").option("--max-clients <maxClients>", "Maximum clients").option("--mode <mode>", 'Server mode, either "default" or "extension"').option("--artifacts-dir <artifactsDir>", "Artifacts directory").action(async function(options) {
+  const { runServer } = require("./driver");
+  runServer({
     port: options.port ? +options.port : void 0,
     host: options.host,
     path: options.path,
     maxConnections: options.maxClients ? +options.maxClients : Infinity,
-    extension: options.mode === "extension" || !!process.env.PW_EXTENSION_MODE
+    extension: options.mode === "extension" || !!process.env.PW_EXTENSION_MODE,
+    artifactsDir: options.artifactsDir
   }).catch(logErrorAndExit);
 });
-import_utilsBundle.program.command("print-api-json", { hidden: true }).action(function(options) {
-  (0, import_driver.printApiJson)();
+import_utilsBundle.program.command("print-api-json", { hidden: true }).action(async function(options) {
+  const { printApiJson } = require("./driver");
+  printApiJson();
 });
-import_utilsBundle.program.command("launch-server", { hidden: true }).requiredOption("--browser <browserName>", 'Browser name, one of "chromium", "firefox" or "webkit"').option("--config <path-to-config-file>", "JSON file with launchServer options").action(function(options) {
-  (0, import_driver.launchBrowserServer)(options.browser, options.config);
+import_utilsBundle.program.command("launch-server", { hidden: true }).requiredOption("--browser <browserName>", 'Browser name, one of "chromium", "firefox" or "webkit"').option("--config <path-to-config-file>", "JSON file with launchServer options").action(async function(options) {
+  const { launchBrowserServer } = require("./driver");
+  launchBrowserServer(options.browser, options.config);
 });
-import_utilsBundle.program.command("show-trace [trace]").option("-b, --browser <browserType>", "browser to use, one of cr, chromium, ff, firefox, wk, webkit", "chromium").option("-h, --host <host>", "Host to serve trace on; specifying this option opens trace in a browser tab").option("-p, --port <port>", "Port to serve trace on, 0 for any free port; specifying this option opens trace in a browser tab").option("--stdin", "Accept trace URLs over stdin to update the viewer").description("show trace viewer").action(function(trace, options) {
+import_utilsBundle.program.command("show-trace [trace]").option("-b, --browser <browserType>", "browser to use, one of cr, chromium, ff, firefox, wk, webkit", "chromium").option("-h, --host <host>", "Host to serve trace on; specifying this option opens trace in a browser tab").option("-p, --port <port>", "Port to serve trace on, 0 for any free port; specifying this option opens trace in a browser tab").option("--stdin", "Accept trace URLs over stdin to update the viewer").description("show trace viewer").action(async function(trace, options) {
   if (options.browser === "cr")
     options.browser = "chromium";
   if (options.browser === "ff")
@@ -287,273 +173,22 @@ import_utilsBundle.program.command("show-trace [trace]").option("-b, --browser <
     port: +options.port,
     isServer: !!options.stdin
   };
+  const { runTraceInBrowser, runTraceViewerApp } = require("../server/trace/viewer/traceViewer");
   if (options.port !== void 0 || options.host !== void 0)
-    (0, import_traceViewer.runTraceInBrowser)(trace, openOptions).catch(logErrorAndExit);
+    runTraceInBrowser(trace, openOptions).catch(logErrorAndExit);
   else
-    (0, import_traceViewer.runTraceViewerApp)(trace, options.browser, openOptions, true).catch(logErrorAndExit);
+    runTraceViewerApp(trace, options.browser, openOptions).catch(logErrorAndExit);
 }).addHelpText("afterAll", `
 Examples:
 
   $ show-trace
   $ show-trace https://example.com/trace.zip`);
-async function launchContext(options, extraOptions) {
-  validateOptions(options);
-  const browserType = lookupBrowserType(options);
-  const launchOptions = extraOptions;
-  if (options.channel)
-    launchOptions.channel = options.channel;
-  launchOptions.handleSIGINT = false;
-  const contextOptions = (
-    // Copy the device descriptor since we have to compare and modify the options.
-    options.device ? { ...playwright.devices[options.device] } : {}
-  );
-  if (!extraOptions.headless)
-    contextOptions.deviceScaleFactor = import_os.default.platform() === "darwin" ? 2 : 1;
-  if (browserType.name() === "webkit" && process.platform === "linux") {
-    delete contextOptions.hasTouch;
-    delete contextOptions.isMobile;
-  }
-  if (contextOptions.isMobile && browserType.name() === "firefox")
-    contextOptions.isMobile = void 0;
-  if (options.blockServiceWorkers)
-    contextOptions.serviceWorkers = "block";
-  if (options.proxyServer) {
-    launchOptions.proxy = {
-      server: options.proxyServer
-    };
-    if (options.proxyBypass)
-      launchOptions.proxy.bypass = options.proxyBypass;
-  }
-  if (options.viewportSize) {
-    try {
-      const [width, height] = options.viewportSize.split(",").map((n) => +n);
-      if (isNaN(width) || isNaN(height))
-        throw new Error("bad values");
-      contextOptions.viewport = { width, height };
-    } catch (e) {
-      throw new Error('Invalid viewport size format: use "width,height", for example --viewport-size="800,600"');
-    }
-  }
-  if (options.geolocation) {
-    try {
-      const [latitude, longitude] = options.geolocation.split(",").map((n) => parseFloat(n.trim()));
-      contextOptions.geolocation = {
-        latitude,
-        longitude
-      };
-    } catch (e) {
-      throw new Error('Invalid geolocation format, should be "lat,long". For example --geolocation="37.819722,-122.478611"');
-    }
-    contextOptions.permissions = ["geolocation"];
-  }
-  if (options.userAgent)
-    contextOptions.userAgent = options.userAgent;
-  if (options.lang)
-    contextOptions.locale = options.lang;
-  if (options.colorScheme)
-    contextOptions.colorScheme = options.colorScheme;
-  if (options.timezone)
-    contextOptions.timezoneId = options.timezone;
-  if (options.loadStorage)
-    contextOptions.storageState = options.loadStorage;
-  if (options.ignoreHttpsErrors)
-    contextOptions.ignoreHTTPSErrors = true;
-  if (options.saveHar) {
-    contextOptions.recordHar = { path: import_path.default.resolve(process.cwd(), options.saveHar), mode: "minimal" };
-    if (options.saveHarGlob)
-      contextOptions.recordHar.urlFilter = options.saveHarGlob;
-    contextOptions.serviceWorkers = "block";
-  }
-  let browser;
-  let context;
-  if (options.userDataDir) {
-    context = await browserType.launchPersistentContext(options.userDataDir, { ...launchOptions, ...contextOptions });
-    browser = context.browser();
-  } else {
-    browser = await browserType.launch(launchOptions);
-    context = await browser.newContext(contextOptions);
-  }
-  let closingBrowser = false;
-  async function closeBrowser() {
-    if (closingBrowser)
-      return;
-    closingBrowser = true;
-    if (options.saveStorage)
-      await context.storageState({ path: options.saveStorage }).catch((e) => null);
-    if (options.saveHar)
-      await context.close();
-    await browser.close();
-  }
-  context.on("page", (page) => {
-    page.on("dialog", () => {
-    });
-    page.on("close", () => {
-      const hasPage = browser.contexts().some((context2) => context2.pages().length > 0);
-      if (hasPage)
-        return;
-      closeBrowser().catch(() => {
-      });
-    });
-  });
-  process.on("SIGINT", async () => {
-    await closeBrowser();
-    (0, import_utils.gracefullyProcessExitDoNotHang)(130);
-  });
-  const timeout = options.timeout ? parseInt(options.timeout, 10) : 0;
-  context.setDefaultTimeout(timeout);
-  context.setDefaultNavigationTimeout(timeout);
-  delete launchOptions.headless;
-  delete launchOptions.executablePath;
-  delete launchOptions.handleSIGINT;
-  delete contextOptions.deviceScaleFactor;
-  return { browser, browserName: browserType.name(), context, contextOptions, launchOptions, closeBrowser };
-}
-async function openPage(context, url) {
-  let page = context.pages()[0];
-  if (!page)
-    page = await context.newPage();
-  if (url) {
-    if (import_fs.default.existsSync(url))
-      url = "file://" + import_path.default.resolve(url);
-    else if (!url.startsWith("http") && !url.startsWith("file://") && !url.startsWith("about:") && !url.startsWith("data:"))
-      url = "http://" + url;
-    await page.goto(url);
-  }
-  return page;
-}
-async function open(options, url) {
-  const { context } = await launchContext(options, { headless: !!process.env.PWTEST_CLI_HEADLESS, executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH });
-  await openPage(context, url);
-}
-async function codegen(options, url) {
-  const { target: language, output: outputFile, testIdAttribute: testIdAttributeName } = options;
-  const tracesDir = import_path.default.join(import_os.default.tmpdir(), `playwright-recorder-trace-${Date.now()}`);
-  const { context, browser, launchOptions, contextOptions, closeBrowser } = await launchContext(options, {
-    headless: !!process.env.PWTEST_CLI_HEADLESS,
-    executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH,
-    tracesDir
-  });
-  const donePromise = new import_utils.ManualPromise();
-  maybeSetupTestHooks(browser, closeBrowser, donePromise);
-  import_utilsBundle.dotenv.config({ path: "playwright.env" });
-  await context._enableRecorder({
-    language,
-    launchOptions,
-    contextOptions,
-    device: options.device,
-    saveStorage: options.saveStorage,
-    mode: "recording",
-    testIdAttributeName,
-    outputFile: outputFile ? import_path.default.resolve(outputFile) : void 0,
-    handleSIGINT: false
-  });
-  await openPage(context, url);
-  donePromise.resolve();
-}
-async function maybeSetupTestHooks(browser, closeBrowser, donePromise) {
-  if (!process.env.PWTEST_CLI_IS_UNDER_TEST)
-    return;
-  const logs = [];
-  require("playwright-core/lib/utilsBundle").debug.log = (...args) => {
-    const line = require("util").format(...args) + "\n";
-    logs.push(line);
-    process.stderr.write(line);
-  };
-  browser.on("disconnected", () => {
-    const hasCrashLine = logs.some((line) => line.includes("process did exit:") && !line.includes("process did exit: exitCode=0, signal=null"));
-    if (hasCrashLine) {
-      process.stderr.write("Detected browser crash.\n");
-      (0, import_utils.gracefullyProcessExitDoNotHang)(1);
-    }
-  });
-  const close = async () => {
-    await donePromise;
-    await closeBrowser();
-  };
-  if (process.env.PWTEST_CLI_EXIT_AFTER_TIMEOUT) {
-    setTimeout(close, +process.env.PWTEST_CLI_EXIT_AFTER_TIMEOUT);
-    return;
-  }
-  let stdin = "";
-  process.stdin.on("data", (data) => {
-    stdin += data.toString();
-    if (stdin.startsWith("exit")) {
-      process.stdin.destroy();
-      close();
-    }
-  });
-}
-async function waitForPage(page, captureOptions) {
-  if (captureOptions.waitForSelector) {
-    console.log(`Waiting for selector ${captureOptions.waitForSelector}...`);
-    await page.waitForSelector(captureOptions.waitForSelector);
-  }
-  if (captureOptions.waitForTimeout) {
-    console.log(`Waiting for timeout ${captureOptions.waitForTimeout}...`);
-    await page.waitForTimeout(parseInt(captureOptions.waitForTimeout, 10));
-  }
-}
-async function screenshot(options, captureOptions, url, path2) {
-  const { context } = await launchContext(options, { headless: true });
-  console.log("Navigating to " + url);
-  const page = await openPage(context, url);
-  await waitForPage(page, captureOptions);
-  console.log("Capturing screenshot into " + path2);
-  await page.screenshot({ path: path2, fullPage: !!captureOptions.fullPage });
-  await page.close();
-}
-async function pdf(options, captureOptions, url, path2) {
-  if (options.browser !== "chromium")
-    throw new Error("PDF creation is only working with Chromium");
-  const { context } = await launchContext({ ...options, browser: "chromium" }, { headless: true });
-  console.log("Navigating to " + url);
-  const page = await openPage(context, url);
-  await waitForPage(page, captureOptions);
-  console.log("Saving as pdf into " + path2);
-  await page.pdf({ path: path2, format: captureOptions.paperFormat });
-  await page.close();
-}
-function lookupBrowserType(options) {
-  let name = options.browser;
-  if (options.device) {
-    const device = playwright.devices[options.device];
-    name = device.defaultBrowserType;
-  }
-  let browserType;
-  switch (name) {
-    case "chromium":
-      browserType = playwright.chromium;
-      break;
-    case "webkit":
-      browserType = playwright.webkit;
-      break;
-    case "firefox":
-      browserType = playwright.firefox;
-      break;
-    case "cr":
-      browserType = playwright.chromium;
-      break;
-    case "wk":
-      browserType = playwright.webkit;
-      break;
-    case "ff":
-      browserType = playwright.firefox;
-      break;
-  }
-  if (browserType)
-    return browserType;
-  import_utilsBundle.program.help();
-}
-function validateOptions(options) {
-  if (options.device && !(options.device in playwright.devices)) {
-    const lines = [`Device descriptor not found: '${options.device}', available devices are:`];
-    for (const name in playwright.devices)
-      lines.push(`  "${name}"`);
-    throw new Error(lines.join("\n"));
-  }
-  if (options.colorScheme && !["light", "dark"].includes(options.colorScheme))
-    throw new Error('Invalid color scheme, should be one of "light", "dark"');
-}
+(0, import_traceCli.addTraceCommands)(import_utilsBundle.program, logErrorAndExit);
+import_utilsBundle.program.command("cli", { hidden: true }).allowExcessArguments(true).allowUnknownOption(true).action(async (options) => {
+  const { program: cliProgram } = require("../tools/cli-client/program");
+  process.argv.splice(process.argv.indexOf("cli"), 1);
+  cliProgram().catch(logErrorAndExit);
+});
 function logErrorAndExit(e) {
   if (process.env.PWDEBUGIMPL)
     console.error(e);
@@ -579,7 +214,7 @@ function buildBasePlaywrightCLICommand(cliTargetLang) {
     case "csharp":
       return `pwsh bin/Debug/netX/playwright.ps1`;
     default: {
-      const packageManagerCommand = (0, import_utils2.getPackageManagerExecCommand)();
+      const packageManagerCommand = (0, import_utils.getPackageManagerExecCommand)();
       return `${packageManagerCommand} playwright`;
     }
   }

package/lib/client/android.js

@@ -35,7 +35,7 @@ var import_timeoutSettings = require("./timeoutSettings");
 var import_rtti = require("../utils/isomorphic/rtti");
 var import_time = require("../utils/isomorphic/time");
 var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
-var import_webSocket = require("./webSocket");
+var import_connect = require("./connect");
 class Android extends import_channelOwner.ChannelOwner {
   static from(android) {
     return android._object;
@@ -56,12 +56,12 @@ class Android extends import_channelOwner.ChannelOwner {
       throw new Error("Launching server is not supported");
     return await this._serverLauncher.launchServer(options);
   }
-  async connect(wsEndpoint, options = {}) {
+  async connect(endpoint, options = {}) {
     return await this._wrapApiCall(async () => {
       const deadline = options.timeout ? (0, import_time.monotonicTime)() + options.timeout : 0;
       const headers = { "x-playwright-browser": "android", ...options.headers };
-      const connectParams = { wsEndpoint, headers, slowMo: options.slowMo, timeout: options.timeout || 0 };
-      const connection = await (0, import_webSocket.connectOverWebSocket)(this._connection, connectParams);
+      const connectParams = { endpoint, headers, slowMo: options.slowMo, timeout: options.timeout || 0 };
+      const connection = await (0, import_connect.connectToEndpoint)(this._connection, connectParams);
       let device;
       connection.on("close", () => {
         device?._didClose();

package/lib/client/api.js

@@ -33,6 +33,7 @@ __export(api_exports, {
   Clock: () => import_clock.Clock,
   ConsoleMessage: () => import_consoleMessage.ConsoleMessage,
   Coverage: () => import_coverage.Coverage,
+  Debugger: () => import_debugger.Debugger,
   Dialog: () => import_dialog.Dialog,
   Download: () => import_download.Download,
   Electron: () => import_electron.Electron,
@@ -68,6 +69,7 @@ var import_browserType = require("./browserType");
 var import_clock = require("./clock");
 var import_consoleMessage = require("./consoleMessage");
 var import_coverage = require("./coverage");
+var import_debugger = require("./debugger");
 var import_dialog = require("./dialog");
 var import_download = require("./download");
 var import_electron = require("./electron");
@@ -105,6 +107,7 @@ var import_webError = require("./webError");
   Clock,
   ConsoleMessage,
   Coverage,
+  Debugger,
   Dialog,
   Download,
   Electron,

package/lib/client/browser.js

@@ -36,6 +36,7 @@ class Browser extends import_channelOwner.ChannelOwner {
     this._shouldCloseConnectionOnClose = false;
     this._options = {};
     this._name = initializer.name;
+    this._browserName = initializer.browserName;
     this._channel.on("context", ({ context }) => this._didCreateContext(import_browserContext.BrowserContext.from(context)));
     this._channel.on("close", () => this._didClose());
     this._closedPromise = new Promise((f) => this.once(import_events.Events.Browser.Disconnected, f));
@@ -62,11 +63,9 @@ class Browser extends import_channelOwner.ChannelOwner {
     context._onClose();
     await this._channel.disconnectFromReusedContext({ reason });
   }
-  async _innerNewContext(options = {}, forReuse) {
-    options = this._browserType._playwright.selectors._withSelectorOptions({
-      ...this._browserType._playwright._defaultContextOptions,
-      ...options
-    });
+  async _innerNewContext(userOptions = {}, forReuse) {
+    const options = this._browserType._playwright.selectors._withSelectorOptions(userOptions);
+    await this._instrumentation.runBeforeCreateBrowserContext(options);
     const contextOptions = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
     const response = forReuse ? await this._channel.newContextForReuse(contextOptions) : await this._channel.newContext(contextOptions);
     const context = import_browserContext.BrowserContext.from(response.context);
@@ -105,6 +104,13 @@ class Browser extends import_channelOwner.ChannelOwner {
   version() {
     return this._initializer.version;
   }
+  async bind(title, options = {}) {
+    const { endpoint } = await this._channel.startServer({ title, ...options });
+    return { endpoint };
+  }
+  async unbind() {
+    await this._channel.stopServer();
+  }
   async newPage(options = {}) {
     return await this._wrapApiCall(async () => {
       const context = await this.newContext(options);