@zohodesk/testinglibrary 3.2.11 → 3.2.13

package/playwright-mcp-test/node_modules/playwright/lib/mcp/browser/config.js

@@ -0,0 +1,385 @@
+"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 config_exports = {};
+__export(config_exports, {
+  commaSeparatedList: () => commaSeparatedList,
+  configFromCLIOptions: () => configFromCLIOptions,
+  defaultConfig: () => defaultConfig,
+  dotenvFileLoader: () => dotenvFileLoader,
+  headerParser: () => headerParser,
+  numberParser: () => numberParser,
+  outputDir: () => outputDir,
+  outputFile: () => outputFile,
+  resolutionParser: () => resolutionParser,
+  resolveCLIConfig: () => resolveCLIConfig,
+  resolveConfig: () => resolveConfig,
+  semicolonSeparatedList: () => semicolonSeparatedList
+});
+module.exports = __toCommonJS(config_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_playwright_core = require("playwright-core");
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_util = require("../../util");
+var import_server = require("../sdk/server");
+const defaultConfig = {
+  browser: {
+    browserName: "chromium",
+    launchOptions: {
+      channel: "chrome",
+      headless: import_os.default.platform() === "linux" && !process.env.DISPLAY,
+      chromiumSandbox: true
+    },
+    contextOptions: {
+      viewport: null
+    }
+  },
+  network: {
+    allowedOrigins: void 0,
+    blockedOrigins: void 0
+  },
+  server: {},
+  saveTrace: false,
+  timeouts: {
+    action: 5e3,
+    navigation: 6e4
+  }
+};
+async function resolveConfig(config) {
+  return mergeConfig(defaultConfig, config);
+}
+async function resolveCLIConfig(cliOptions) {
+  const configInFile = await loadConfig(cliOptions.config);
+  const envOverrides = configFromEnv();
+  const cliOverrides = configFromCLIOptions(cliOptions);
+  let result = defaultConfig;
+  result = mergeConfig(result, configInFile);
+  result = mergeConfig(result, envOverrides);
+  result = mergeConfig(result, cliOverrides);
+  await validateConfig(result);
+  return result;
+}
+async function validateConfig(config) {
+  if (config.browser.initScript) {
+    for (const script of config.browser.initScript) {
+      if (!await (0, import_util.fileExistsAsync)(script))
+        throw new Error(`Init script file does not exist: ${script}`);
+    }
+  }
+  if (config.sharedBrowserContext && config.saveVideo)
+    throw new Error("saveVideo is not supported when sharedBrowserContext is true");
+}
+function configFromCLIOptions(cliOptions) {
+  let browserName;
+  let channel;
+  switch (cliOptions.browser) {
+    case "chrome":
+    case "chrome-beta":
+    case "chrome-canary":
+    case "chrome-dev":
+    case "chromium":
+    case "msedge":
+    case "msedge-beta":
+    case "msedge-canary":
+    case "msedge-dev":
+      browserName = "chromium";
+      channel = cliOptions.browser;
+      break;
+    case "firefox":
+      browserName = "firefox";
+      break;
+    case "webkit":
+      browserName = "webkit";
+      break;
+  }
+  const launchOptions = {
+    channel,
+    executablePath: cliOptions.executablePath,
+    headless: cliOptions.headless
+  };
+  if (cliOptions.sandbox === false)
+    launchOptions.chromiumSandbox = false;
+  if (cliOptions.proxyServer) {
+    launchOptions.proxy = {
+      server: cliOptions.proxyServer
+    };
+    if (cliOptions.proxyBypass)
+      launchOptions.proxy.bypass = cliOptions.proxyBypass;
+  }
+  if (cliOptions.device && cliOptions.cdpEndpoint)
+    throw new Error("Device emulation is not supported with cdpEndpoint.");
+  const contextOptions = cliOptions.device ? import_playwright_core.devices[cliOptions.device] : {};
+  if (cliOptions.storageState)
+    contextOptions.storageState = cliOptions.storageState;
+  if (cliOptions.userAgent)
+    contextOptions.userAgent = cliOptions.userAgent;
+  if (cliOptions.viewportSize)
+    contextOptions.viewport = cliOptions.viewportSize;
+  if (cliOptions.ignoreHttpsErrors)
+    contextOptions.ignoreHTTPSErrors = true;
+  if (cliOptions.blockServiceWorkers)
+    contextOptions.serviceWorkers = "block";
+  if (cliOptions.grantPermissions)
+    contextOptions.permissions = cliOptions.grantPermissions;
+  if (cliOptions.saveVideo) {
+    contextOptions.recordVideo = {
+      // Videos are moved to output directory on saveAs.
+      dir: tmpDir(),
+      size: cliOptions.saveVideo
+    };
+  }
+  const result = {
+    browser: {
+      browserName,
+      isolated: cliOptions.isolated,
+      userDataDir: cliOptions.userDataDir,
+      launchOptions,
+      contextOptions,
+      cdpEndpoint: cliOptions.cdpEndpoint,
+      cdpHeaders: cliOptions.cdpHeader,
+      initScript: cliOptions.initScript
+    },
+    server: {
+      port: cliOptions.port,
+      host: cliOptions.host,
+      allowedHosts: cliOptions.allowedHosts
+    },
+    capabilities: cliOptions.caps,
+    network: {
+      allowedOrigins: cliOptions.allowedOrigins,
+      blockedOrigins: cliOptions.blockedOrigins
+    },
+    saveSession: cliOptions.saveSession,
+    saveTrace: cliOptions.saveTrace,
+    saveVideo: cliOptions.saveVideo,
+    secrets: cliOptions.secrets,
+    sharedBrowserContext: cliOptions.sharedBrowserContext,
+    outputDir: cliOptions.outputDir,
+    imageResponses: cliOptions.imageResponses,
+    testIdAttribute: cliOptions.testIdAttribute,
+    timeouts: {
+      action: cliOptions.timeoutAction,
+      navigation: cliOptions.timeoutNavigation
+    }
+  };
+  return result;
+}
+function configFromEnv() {
+  const options = {};
+  options.allowedHosts = commaSeparatedList(process.env.PLAYWRIGHT_MCP_ALLOWED_HOSTNAMES);
+  options.allowedOrigins = semicolonSeparatedList(process.env.PLAYWRIGHT_MCP_ALLOWED_ORIGINS);
+  options.blockedOrigins = semicolonSeparatedList(process.env.PLAYWRIGHT_MCP_BLOCKED_ORIGINS);
+  options.blockServiceWorkers = envToBoolean(process.env.PLAYWRIGHT_MCP_BLOCK_SERVICE_WORKERS);
+  options.browser = envToString(process.env.PLAYWRIGHT_MCP_BROWSER);
+  options.caps = commaSeparatedList(process.env.PLAYWRIGHT_MCP_CAPS);
+  options.cdpEndpoint = envToString(process.env.PLAYWRIGHT_MCP_CDP_ENDPOINT);
+  options.cdpHeader = headerParser(process.env.PLAYWRIGHT_MCP_CDP_HEADERS, {});
+  options.config = envToString(process.env.PLAYWRIGHT_MCP_CONFIG);
+  options.device = envToString(process.env.PLAYWRIGHT_MCP_DEVICE);
+  options.executablePath = envToString(process.env.PLAYWRIGHT_MCP_EXECUTABLE_PATH);
+  options.grantPermissions = commaSeparatedList(process.env.PLAYWRIGHT_MCP_GRANT_PERMISSIONS);
+  options.headless = envToBoolean(process.env.PLAYWRIGHT_MCP_HEADLESS);
+  options.host = envToString(process.env.PLAYWRIGHT_MCP_HOST);
+  options.ignoreHttpsErrors = envToBoolean(process.env.PLAYWRIGHT_MCP_IGNORE_HTTPS_ERRORS);
+  const initScript = envToString(process.env.PLAYWRIGHT_MCP_INIT_SCRIPT);
+  if (initScript)
+    options.initScript = [initScript];
+  options.isolated = envToBoolean(process.env.PLAYWRIGHT_MCP_ISOLATED);
+  if (process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES === "omit")
+    options.imageResponses = "omit";
+  options.sandbox = envToBoolean(process.env.PLAYWRIGHT_MCP_SANDBOX);
+  options.outputDir = envToString(process.env.PLAYWRIGHT_MCP_OUTPUT_DIR);
+  options.port = numberParser(process.env.PLAYWRIGHT_MCP_PORT);
+  options.proxyBypass = envToString(process.env.PLAYWRIGHT_MCP_PROXY_BYPASS);
+  options.proxyServer = envToString(process.env.PLAYWRIGHT_MCP_PROXY_SERVER);
+  options.saveTrace = envToBoolean(process.env.PLAYWRIGHT_MCP_SAVE_TRACE);
+  options.saveVideo = resolutionParser("--save-video", process.env.PLAYWRIGHT_MCP_SAVE_VIDEO);
+  options.secrets = dotenvFileLoader(process.env.PLAYWRIGHT_MCP_SECRETS_FILE);
+  options.storageState = envToString(process.env.PLAYWRIGHT_MCP_STORAGE_STATE);
+  options.testIdAttribute = envToString(process.env.PLAYWRIGHT_MCP_TEST_ID_ATTRIBUTE);
+  options.timeoutAction = numberParser(process.env.PLAYWRIGHT_MCP_TIMEOUT_ACTION);
+  options.timeoutNavigation = numberParser(process.env.PLAYWRIGHT_MCP_TIMEOUT_NAVIGATION);
+  options.userAgent = envToString(process.env.PLAYWRIGHT_MCP_USER_AGENT);
+  options.userDataDir = envToString(process.env.PLAYWRIGHT_MCP_USER_DATA_DIR);
+  options.viewportSize = resolutionParser("--viewport-size", process.env.PLAYWRIGHT_MCP_VIEWPORT_SIZE);
+  return configFromCLIOptions(options);
+}
+async function loadConfig(configFile) {
+  if (!configFile)
+    return {};
+  try {
+    return JSON.parse(await import_fs.default.promises.readFile(configFile, "utf8"));
+  } catch (error) {
+    throw new Error(`Failed to load config file: ${configFile}, ${error}`);
+  }
+}
+function tmpDir() {
+  return import_path.default.join(process.env.PW_TMPDIR_FOR_TEST ?? import_os.default.tmpdir(), "playwright-mcp-output");
+}
+function outputDir(config, clientInfo) {
+  const rootPath = (0, import_server.firstRootPath)(clientInfo);
+  return config.outputDir ?? (rootPath ? import_path.default.join(rootPath, ".playwright-mcp") : void 0) ?? import_path.default.join(tmpDir(), String(clientInfo.timestamp));
+}
+async function outputFile(config, clientInfo, fileName, options) {
+  const file = await resolveFile(config, clientInfo, fileName, options);
+  (0, import_utilsBundle.debug)("pw:mcp:file")(options.reason, file);
+  return file;
+}
+async function resolveFile(config, clientInfo, fileName, options) {
+  const dir = outputDir(config, clientInfo);
+  if (options.origin === "code")
+    return import_path.default.resolve(dir, fileName);
+  if (options.origin === "llm") {
+    fileName = fileName.split("\\").join("/");
+    const resolvedFile = import_path.default.resolve(dir, fileName);
+    if (!resolvedFile.startsWith(import_path.default.resolve(dir) + import_path.default.sep))
+      throw new Error(`Resolved file path ${resolvedFile} is outside of the output directory ${dir}. Use relative file names to stay within the output directory.`);
+    return resolvedFile;
+  }
+  return import_path.default.join(dir, sanitizeForFilePath(fileName));
+}
+function pickDefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj ?? {}).filter(([_, v]) => v !== void 0)
+  );
+}
+function mergeConfig(base, overrides) {
+  const browser = {
+    ...pickDefined(base.browser),
+    ...pickDefined(overrides.browser),
+    browserName: overrides.browser?.browserName ?? base.browser?.browserName ?? "chromium",
+    isolated: overrides.browser?.isolated ?? base.browser?.isolated ?? false,
+    launchOptions: {
+      ...pickDefined(base.browser?.launchOptions),
+      ...pickDefined(overrides.browser?.launchOptions),
+      ...{ assistantMode: true }
+    },
+    contextOptions: {
+      ...pickDefined(base.browser?.contextOptions),
+      ...pickDefined(overrides.browser?.contextOptions)
+    }
+  };
+  if (browser.browserName !== "chromium" && browser.launchOptions)
+    delete browser.launchOptions.channel;
+  return {
+    ...pickDefined(base),
+    ...pickDefined(overrides),
+    browser,
+    network: {
+      ...pickDefined(base.network),
+      ...pickDefined(overrides.network)
+    },
+    server: {
+      ...pickDefined(base.server),
+      ...pickDefined(overrides.server)
+    },
+    timeouts: {
+      ...pickDefined(base.timeouts),
+      ...pickDefined(overrides.timeouts)
+    }
+  };
+}
+function semicolonSeparatedList(value) {
+  if (!value)
+    return void 0;
+  return value.split(";").map((v) => v.trim());
+}
+function commaSeparatedList(value) {
+  if (!value)
+    return void 0;
+  return value.split(",").map((v) => v.trim());
+}
+function dotenvFileLoader(value) {
+  if (!value)
+    return void 0;
+  return import_utilsBundle.dotenv.parse(import_fs.default.readFileSync(value, "utf8"));
+}
+function numberParser(value) {
+  if (!value)
+    return void 0;
+  return +value;
+}
+function resolutionParser(name, value) {
+  if (!value)
+    return void 0;
+  if (value.includes("x")) {
+    const [width, height] = value.split("x").map((v) => +v);
+    if (isNaN(width) || isNaN(height) || width <= 0 || height <= 0)
+      throw new Error(`Invalid resolution format: use ${name}="800x600"`);
+    return { width, height };
+  }
+  if (value.includes(",")) {
+    const [width, height] = value.split(",").map((v) => +v);
+    if (isNaN(width) || isNaN(height) || width <= 0 || height <= 0)
+      throw new Error(`Invalid resolution format: use ${name}="800x600"`);
+    return { width, height };
+  }
+  throw new Error(`Invalid resolution format: use ${name}="800x600"`);
+}
+function headerParser(arg, previous) {
+  if (!arg)
+    return previous || {};
+  const result = previous || {};
+  const [name, value] = arg.split(":").map((v) => v.trim());
+  result[name] = value;
+  return result;
+}
+function envToBoolean(value) {
+  if (value === "true" || value === "1")
+    return true;
+  if (value === "false" || value === "0")
+    return false;
+  return void 0;
+}
+function envToString(value) {
+  return value ? value.trim() : void 0;
+}
+function sanitizeForFilePath(s) {
+  const sanitize = (s2) => s2.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, "-");
+  const separator = s.lastIndexOf(".");
+  if (separator === -1)
+    return sanitize(s);
+  return sanitize(s.substring(0, separator)) + "." + sanitize(s.substring(separator + 1));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  commaSeparatedList,
+  configFromCLIOptions,
+  defaultConfig,
+  dotenvFileLoader,
+  headerParser,
+  numberParser,
+  outputDir,
+  outputFile,
+  resolutionParser,
+  resolveCLIConfig,
+  resolveConfig,
+  semicolonSeparatedList
+});

package/playwright-mcp-test/node_modules/playwright/lib/mcp/browser/context.js

@@ -0,0 +1,287 @@
+"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 context_exports = {};
+__export(context_exports, {
+  Context: () => Context,
+  InputRecorder: () => InputRecorder
+});
+module.exports = __toCommonJS(context_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_playwright_core = require("playwright-core");
+var import_log = require("../log");
+var import_tab = require("./tab");
+var import_config = require("./config");
+var codegen = __toESM(require("./codegen"));
+var import_utils = require("./tools/utils");
+const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
+class Context {
+  constructor(options) {
+    this._tabs = [];
+    this._abortController = new AbortController();
+    this.config = options.config;
+    this.sessionLog = options.sessionLog;
+    this.options = options;
+    this._browserContextFactory = options.browserContextFactory;
+    this._clientInfo = options.clientInfo;
+    testDebug("create context");
+    Context._allContexts.add(this);
+  }
+  static {
+    this._allContexts = /* @__PURE__ */ new Set();
+  }
+  static async disposeAll() {
+    await Promise.all([...Context._allContexts].map((context) => context.dispose()));
+  }
+  tabs() {
+    return this._tabs;
+  }
+  currentTab() {
+    return this._currentTab;
+  }
+  currentTabOrDie() {
+    if (!this._currentTab)
+      throw new Error('No open pages available. Use the "browser_navigate" tool to navigate to a page first.');
+    return this._currentTab;
+  }
+  async newTab() {
+    const { browserContext } = await this._ensureBrowserContext();
+    const page = await browserContext.newPage();
+    this._currentTab = this._tabs.find((t) => t.page === page);
+    return this._currentTab;
+  }
+  async selectTab(index) {
+    const tab = this._tabs[index];
+    if (!tab)
+      throw new Error(`Tab ${index} not found`);
+    await tab.page.bringToFront();
+    this._currentTab = tab;
+    return tab;
+  }
+  async ensureTab() {
+    const { browserContext } = await this._ensureBrowserContext();
+    if (!this._currentTab)
+      await browserContext.newPage();
+    return this._currentTab;
+  }
+  async closeTab(index) {
+    const tab = index === void 0 ? this._currentTab : this._tabs[index];
+    if (!tab)
+      throw new Error(`Tab ${index} not found`);
+    const url = tab.page.url();
+    await tab.page.close();
+    return url;
+  }
+  async outputFile(fileName, options) {
+    return (0, import_config.outputFile)(this.config, this._clientInfo, fileName, options);
+  }
+  _onPageCreated(page) {
+    const tab = new import_tab.Tab(this, page, (tab2) => this._onPageClosed(tab2));
+    this._tabs.push(tab);
+    if (!this._currentTab)
+      this._currentTab = tab;
+  }
+  _onPageClosed(tab) {
+    const index = this._tabs.indexOf(tab);
+    if (index === -1)
+      return;
+    this._tabs.splice(index, 1);
+    if (this._currentTab === tab)
+      this._currentTab = this._tabs[Math.min(index, this._tabs.length - 1)];
+    if (!this._tabs.length)
+      void this.closeBrowserContext();
+  }
+  async closeBrowserContext() {
+    if (!this._closeBrowserContextPromise)
+      this._closeBrowserContextPromise = this._closeBrowserContextImpl().catch(import_log.logUnhandledError);
+    await this._closeBrowserContextPromise;
+    this._closeBrowserContextPromise = void 0;
+  }
+  isRunningTool() {
+    return this._runningToolName !== void 0;
+  }
+  setRunningTool(name) {
+    this._runningToolName = name;
+  }
+  async _closeBrowserContextImpl() {
+    if (!this._browserContextPromise)
+      return;
+    testDebug("close context");
+    const promise = this._browserContextPromise;
+    this._browserContextPromise = void 0;
+    await promise.then(async ({ browserContext, close }) => {
+      if (this.config.saveTrace)
+        await browserContext.tracing.stop();
+      const videos = this.config.saveVideo ? browserContext.pages().map((page) => page.video()).filter((video) => !!video) : [];
+      await close(async () => {
+        for (const video of videos) {
+          const name = await this.outputFile((0, import_utils.dateAsFileName)("webm"), { origin: "code", reason: "Saving video" });
+          await import_fs.default.promises.mkdir(import_path.default.dirname(name), { recursive: true });
+          const p = await video.path();
+          if (import_fs.default.existsSync(p)) {
+            try {
+              await import_fs.default.promises.rename(p, name);
+            } catch (e) {
+              if (e.code !== "EXDEV")
+                (0, import_log.logUnhandledError)(e);
+              try {
+                await import_fs.default.promises.copyFile(p, name);
+                await import_fs.default.promises.unlink(p);
+              } catch (e2) {
+                (0, import_log.logUnhandledError)(e2);
+              }
+            }
+          }
+        }
+      });
+    });
+  }
+  async dispose() {
+    this._abortController.abort("MCP context disposed");
+    await this.closeBrowserContext();
+    Context._allContexts.delete(this);
+  }
+  async _setupRequestInterception(context) {
+    if (this.config.network?.allowedOrigins?.length) {
+      await context.route("**", (route) => route.abort("blockedbyclient"));
+      for (const origin of this.config.network.allowedOrigins)
+        await context.route(originOrHostGlob(origin), (route) => route.continue());
+    }
+    if (this.config.network?.blockedOrigins?.length) {
+      for (const origin of this.config.network.blockedOrigins)
+        await context.route(originOrHostGlob(origin), (route) => route.abort("blockedbyclient"));
+    }
+  }
+  async ensureBrowserContext() {
+    const { browserContext } = await this._ensureBrowserContext();
+    return browserContext;
+  }
+  _ensureBrowserContext() {
+    if (!this._browserContextPromise) {
+      this._browserContextPromise = this._setupBrowserContext();
+      this._browserContextPromise.catch(() => {
+        this._browserContextPromise = void 0;
+      });
+    }
+    return this._browserContextPromise;
+  }
+  async _setupBrowserContext() {
+    if (this._closeBrowserContextPromise)
+      throw new Error("Another browser context is being closed.");
+    if (this.config.testIdAttribute)
+      import_playwright_core.selectors.setTestIdAttribute(this.config.testIdAttribute);
+    const result = await this._browserContextFactory.createContext(this._clientInfo, this._abortController.signal, this._runningToolName);
+    const { browserContext } = result;
+    await this._setupRequestInterception(browserContext);
+    if (this.sessionLog)
+      await InputRecorder.create(this, browserContext);
+    for (const page of browserContext.pages())
+      this._onPageCreated(page);
+    browserContext.on("page", (page) => this._onPageCreated(page));
+    if (this.config.saveTrace) {
+      await browserContext.tracing.start({
+        name: "trace-" + Date.now(),
+        screenshots: true,
+        snapshots: true,
+        _live: true
+      });
+    }
+    return result;
+  }
+  lookupSecret(secretName) {
+    if (!this.config.secrets?.[secretName])
+      return { value: secretName, code: codegen.quote(secretName) };
+    return {
+      value: this.config.secrets[secretName],
+      code: `process.env['${secretName}']`
+    };
+  }
+}
+function originOrHostGlob(originOrHost) {
+  try {
+    const url = new URL(originOrHost);
+    if (url.origin !== "null")
+      return `${url.origin}/**`;
+  } catch {
+  }
+  return `*://${originOrHost}/**`;
+}
+class InputRecorder {
+  constructor(context, browserContext) {
+    this._context = context;
+    this._browserContext = browserContext;
+  }
+  static async create(context, browserContext) {
+    const recorder = new InputRecorder(context, browserContext);
+    await recorder._initialize();
+    return recorder;
+  }
+  async _initialize() {
+    const sessionLog = this._context.sessionLog;
+    await this._browserContext._enableRecorder({
+      mode: "recording",
+      recorderMode: "api"
+    }, {
+      actionAdded: (page, data, code) => {
+        if (this._context.isRunningTool())
+          return;
+        const tab = import_tab.Tab.forPage(page);
+        if (tab)
+          sessionLog.logUserAction(data.action, tab, code, false);
+      },
+      actionUpdated: (page, data, code) => {
+        if (this._context.isRunningTool())
+          return;
+        const tab = import_tab.Tab.forPage(page);
+        if (tab)
+          sessionLog.logUserAction(data.action, tab, code, true);
+      },
+      signalAdded: (page, data) => {
+        if (this._context.isRunningTool())
+          return;
+        if (data.signal.name !== "navigation")
+          return;
+        const tab = import_tab.Tab.forPage(page);
+        const navigateAction = {
+          name: "navigate",
+          url: data.signal.url,
+          signals: []
+        };
+        if (tab)
+          sessionLog.logUserAction(navigateAction, tab, `await page.goto('${data.signal.url}');`, false);
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context,
+  InputRecorder
+});