@cotestdev/mcp_playwright 0.0.14 → 0.0.15

package/lib/mcp/browser/browserContextFactory.js

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browserContextFactory_exports = {};
 __export(browserContextFactory_exports, {
   SharedContextFactory: () => SharedContextFactory,
-  contextFactory: () => contextFactory
+  contextFactory: () => contextFactory,
+  identityBrowserContextFactory: () => identityBrowserContextFactory
 });
 module.exports = __toCommonJS(browserContextFactory_exports);
 var import_crypto = __toESM(require("crypto"));
@@ -53,6 +54,17 @@ function contextFactory(config) {
     return new IsolatedContextFactory(config);
   return new PersistentContextFactory(config);
 }
+function identityBrowserContextFactory(browserContext) {
+  return {
+    createContext: async (clientInfo, abortSignal, toolName) => {
+      return {
+        browserContext,
+        close: async () => {
+        }
+      };
+    }
+  };
+}
 class BaseContextFactory {
   constructor(name, config) {
     this._logName = name;
@@ -80,16 +92,20 @@ class BaseContextFactory {
     const browser = await this._obtainBrowser(clientInfo);
     const browserContext = await this._doCreateContext(browser);
     await addInitScript(browserContext, this.config.browser.initScript);
-    return { browserContext, close: () => this._closeBrowserContext(browserContext, browser) };
+    return {
+      browserContext,
+      close: (afterClose) => this._closeBrowserContext(browserContext, browser, afterClose)
+    };
   }
   async _doCreateContext(browser) {
     throw new Error("Not implemented");
   }
-  async _closeBrowserContext(browserContext, browser) {
+  async _closeBrowserContext(browserContext, browser, afterClose) {
     (0, import_log.testDebug)(`close browser context (${this._logName})`);
     if (browser.contexts().length === 1)
       this._browserPromise = void 0;
     await browserContext.close().catch(import_log.logUnhandledError);
+    await afterClose();
     if (browser.contexts().length === 0) {
       (0, import_log.testDebug)(`close browser (${this._logName})`);
       await browser.close().catch(import_log.logUnhandledError);
@@ -103,8 +119,8 @@ class IsolatedContextFactory extends BaseContextFactory {
   async _doObtainBrowser(clientInfo) {
     await injectCdpPort(this.config.browser);
     const browserType = playwright[this.config.browser.browserName];
-    const tracesDir = await (0, import_config.outputFile)(this.config, clientInfo, `traces`, { origin: "code" });
-    if (this.config.saveTrace)
+    const tracesDir = await computeTracesDir(this.config, clientInfo);
+    if (tracesDir && this.config.saveTrace)
       await startTraceServer(this.config, tracesDir);
     return browserType.launch({
       tracesDir,
@@ -118,7 +134,7 @@ class IsolatedContextFactory extends BaseContextFactory {
     });
   }
   async _doCreateContext(browser) {
-    return browser.newContext(this.config.browser.contextOptions);
+    return browser.newContext(browserContextOptionsFromConfig(this.config));
   }
 }
 class CdpContextFactory extends BaseContextFactory {
@@ -158,8 +174,8 @@ class PersistentContextFactory {
     await injectCdpPort(this.config.browser);
     (0, import_log.testDebug)("create browser context (persistent)");
     const userDataDir = this.config.browser.userDataDir ?? await this._createUserDataDir(clientInfo);
-    const tracesDir = await (0, import_config.outputFile)(this.config, clientInfo, `traces`, { origin: "code" });
-    if (this.config.saveTrace)
+    const tracesDir = await computeTracesDir(this.config, clientInfo);
+    if (tracesDir && this.config.saveTrace)
       await startTraceServer(this.config, tracesDir);
     this._userDataDirs.add(userDataDir);
     (0, import_log.testDebug)("lock user data dir", userDataDir);
@@ -168,7 +184,7 @@ class PersistentContextFactory {
       const launchOptions = {
         tracesDir,
         ...this.config.browser.launchOptions,
-        ...this.config.browser.contextOptions,
+        ...browserContextOptionsFromConfig(this.config),
         handleSIGINT: false,
         handleSIGTERM: false,
         ignoreDefaultArgs: [
@@ -179,7 +195,7 @@ class PersistentContextFactory {
       try {
         const browserContext = await browserType.launchPersistentContext(userDataDir, launchOptions);
         await addInitScript(browserContext, this.config.browser.initScript);
-        const close = () => this._closeBrowserContext(browserContext, userDataDir);
+        const close = (afterClose) => this._closeBrowserContext(browserContext, userDataDir, afterClose);
         return { browserContext, close };
       } catch (error) {
         if (error.message.includes("Executable doesn't exist"))
@@ -193,12 +209,15 @@ class PersistentContextFactory {
     }
     throw new Error(`Browser is already in use for ${userDataDir}, use --isolated to run multiple instances of the same browser`);
   }
-  async _closeBrowserContext(browserContext, userDataDir) {
+  async _closeBrowserContext(browserContext, userDataDir, afterClose) {
     (0, import_log.testDebug)("close browser context (persistent)");
     (0, import_log.testDebug)("release user data dir", userDataDir);
     await browserContext.close().catch(() => {
     });
+    await afterClose();
     this._userDataDirs.delete(userDataDir);
+    if (process.env.PWMCP_PROFILES_DIR_FOR_TEST && userDataDir.startsWith(process.env.PWMCP_PROFILES_DIR_FOR_TEST))
+      await import_fs.default.promises.rm(userDataDir, { recursive: true }).catch(import_log.logUnhandledError);
     (0, import_log.testDebug)("close browser context complete (persistent)");
   }
   async _createUserDataDir(clientInfo) {
@@ -275,11 +294,28 @@ class SharedContextFactory {
     if (!contextPromise)
       return;
     const { close } = await contextPromise;
-    await close();
+    await close(async () => {
+    });
+  }
+}
+async function computeTracesDir(config, clientInfo) {
+  if (!config.saveTrace && !config.capabilities?.includes("tracing"))
+    return;
+  return await (0, import_config.outputFile)(config, clientInfo, `traces`, { origin: "code", reason: "Collecting trace" });
+}
+function browserContextOptionsFromConfig(config) {
+  const result = { ...config.browser.contextOptions };
+  if (config.saveVideo) {
+    result.recordVideo = {
+      dir: (0, import_config.tmpDir)(),
+      size: config.saveVideo
+    };
   }
+  return result;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SharedContextFactory,
-  contextFactory
+  contextFactory,
+  identityBrowserContextFactory
 });

package/lib/mcp/browser/browserServerBackend.js

@@ -33,7 +33,7 @@ class BrowserServerBackend {
     this._browserContextFactory = factory;
     this._tools = (0, import_tools.filteredTools)(config);
   }
-  async initialize(server, clientInfo) {
+  async initialize(clientInfo) {
     this._sessionLog = this._config.saveSession ? await import_sessionLog.SessionLog.create(this._config, clientInfo) : void 0;
     this._context = new import_context.Context({
       config: this._config,
@@ -52,6 +52,7 @@ class BrowserServerBackend {
     const parsedArguments = tool.schema.inputSchema.parse(rawArguments || {});
     const context = this._context;
     const response = new import_response.Response(context, name, parsedArguments);
+    response.logBegin();
     context.setRunningTool(name);
     try {
       await tool.handle(context, parsedArguments, response);
@@ -62,7 +63,9 @@ class BrowserServerBackend {
     } finally {
       context.setRunningTool(void 0);
     }
-    return response.serialize();
+    response.logEnd();
+    const _meta = rawArguments?._meta;
+    return response.serialize({ _meta });
   }
   serverClosed() {
     void this._context?.dispose().catch(import_log.logUnhandledError);

package/lib/mcp/browser/config.js

@@ -32,12 +32,16 @@ __export(config_exports, {
   configFromCLIOptions: () => configFromCLIOptions,
   defaultConfig: () => defaultConfig,
   dotenvFileLoader: () => dotenvFileLoader,
+  enumParser: () => enumParser,
   headerParser: () => headerParser,
   numberParser: () => numberParser,
+  outputDir: () => outputDir,
   outputFile: () => outputFile,
+  resolutionParser: () => resolutionParser,
   resolveCLIConfig: () => resolveCLIConfig,
   resolveConfig: () => resolveConfig,
-  semicolonSeparatedList: () => semicolonSeparatedList
+  semicolonSeparatedList: () => semicolonSeparatedList,
+  tmpDir: () => tmpDir
 });
 module.exports = __toCommonJS(config_exports);
 var import_fs = __toESM(require("fs"));
@@ -59,12 +63,18 @@ const defaultConfig = {
       viewport: null
     }
   },
+  console: {
+    level: "info"
+  },
   network: {
     allowedOrigins: void 0,
     blockedOrigins: void 0
   },
   server: {},
   saveTrace: false,
+  snapshot: {
+    mode: "incremental"
+  },
   timeouts: {
     action: 5e3,
     navigation: 6e4
@@ -91,6 +101,14 @@ async function validateConfig(config) {
         throw new Error(`Init script file does not exist: ${script}`);
     }
   }
+  if (config.browser.initPage) {
+    for (const page of config.browser.initPage) {
+      if (!await (0, import_util.fileExistsAsync)(page))
+        throw new Error(`Init page file does not exist: ${page}`);
+    }
+  }
+  if (config.sharedBrowserContext && config.saveVideo)
+    throw new Error("saveVideo is not supported when sharedBrowserContext is true");
 }
 function configFromCLIOptions(cliOptions) {
   let browserName;
@@ -136,16 +154,8 @@ function configFromCLIOptions(cliOptions) {
     contextOptions.storageState = cliOptions.storageState;
   if (cliOptions.userAgent)
     contextOptions.userAgent = cliOptions.userAgent;
-  if (cliOptions.viewportSize) {
-    try {
-      const [width, height] = cliOptions.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 (cliOptions.viewportSize)
+    contextOptions.viewport = cliOptions.viewportSize;
   if (cliOptions.ignoreHttpsErrors)
     contextOptions.ignoreHTTPSErrors = true;
   if (cliOptions.blockServiceWorkers)
@@ -161,23 +171,31 @@ function configFromCLIOptions(cliOptions) {
       contextOptions,
       cdpEndpoint: cliOptions.cdpEndpoint,
       cdpHeaders: cliOptions.cdpHeader,
+      initPage: cliOptions.initPage,
       initScript: cliOptions.initScript
     },
     server: {
       port: cliOptions.port,
-      host: cliOptions.host
+      host: cliOptions.host,
+      allowedHosts: cliOptions.allowedHosts
     },
     capabilities: cliOptions.caps,
+    console: {
+      level: cliOptions.consoleLevel
+    },
     network: {
       allowedOrigins: cliOptions.allowedOrigins,
       blockedOrigins: cliOptions.blockedOrigins
     },
     saveSession: cliOptions.saveSession,
     saveTrace: cliOptions.saveTrace,
+    saveVideo: cliOptions.saveVideo,
     secrets: cliOptions.secrets,
     sharedBrowserContext: cliOptions.sharedBrowserContext,
+    snapshot: cliOptions.snapshotMode ? { mode: cliOptions.snapshotMode } : void 0,
     outputDir: cliOptions.outputDir,
     imageResponses: cliOptions.imageResponses,
+    testIdAttribute: cliOptions.testIdAttribute,
     timeouts: {
       action: cliOptions.timeoutAction,
       navigation: cliOptions.timeoutNavigation
@@ -187,6 +205,7 @@ function configFromCLIOptions(cliOptions) {
 }
 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);
@@ -195,31 +214,38 @@ function configFromEnv() {
   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);
+  if (process.env.PLAYWRIGHT_MCP_CONSOLE_LEVEL)
+    options.consoleLevel = enumParser("--console-level", ["error", "warning", "info", "debug"], process.env.PLAYWRIGHT_MCP_CONSOLE_LEVEL);
   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 initPage = envToString(process.env.PLAYWRIGHT_MCP_INIT_PAGE);
+  if (initPage)
+    options.initPage = [initPage];
   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";
+  if (process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES)
+    options.imageResponses = enumParser("--image-responses", ["allow", "omit"], process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES);
   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 = envToString(process.env.PLAYWRIGHT_MCP_VIEWPORT_SIZE);
+  options.viewportSize = resolutionParser("--viewport-size", process.env.PLAYWRIGHT_MCP_VIEWPORT_SIZE);
   return configFromCLIOptions(options);
 }
 async function loadConfig(configFile) {
@@ -231,19 +257,31 @@ async function loadConfig(configFile) {
     throw new Error(`Failed to load config file: ${configFile}, ${error}`);
   }
 }
-async function outputFile(config, clientInfo, fileName, options) {
+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);
-  const outputDir = config.outputDir ?? (rootPath ? import_path.default.join(rootPath, ".playwright-mcp") : void 0) ?? import_path.default.join(process.env.PW_TMPDIR_FOR_TEST ?? import_os.default.tmpdir(), "playwright-mcp-output", String(clientInfo.timestamp));
+  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);
+  await import_fs.default.promises.mkdir(import_path.default.dirname(file), { recursive: true });
+  (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(outputDir, fileName);
+    return import_path.default.resolve(dir, fileName);
   if (options.origin === "llm") {
     fileName = fileName.split("\\").join("/");
-    const resolvedFile = import_path.default.resolve(outputDir, fileName);
-    if (!resolvedFile.startsWith(import_path.default.resolve(outputDir) + import_path.default.sep))
-      throw new Error(`Resolved file path for ${fileName} is outside of the output directory`);
+    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(outputDir, sanitizeForFilePath(fileName));
+  return import_path.default.join(dir, sanitizeForFilePath(fileName));
 }
 function pickDefined(obj) {
   return Object.fromEntries(
@@ -272,6 +310,10 @@ function mergeConfig(base, overrides) {
     ...pickDefined(base),
     ...pickDefined(overrides),
     browser,
+    console: {
+      ...pickDefined(base.console),
+      ...pickDefined(overrides.console)
+    },
     network: {
       ...pickDefined(base.network),
       ...pickDefined(overrides.network)
@@ -280,6 +322,10 @@ function mergeConfig(base, overrides) {
       ...pickDefined(base.server),
       ...pickDefined(overrides.server)
     },
+    snapshot: {
+      ...pickDefined(base.snapshot),
+      ...pickDefined(overrides.snapshot)
+    },
     timeouts: {
       ...pickDefined(base.timeouts),
       ...pickDefined(overrides.timeouts)
@@ -306,6 +352,23 @@ function numberParser(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 || {};
@@ -314,6 +377,11 @@ function headerParser(arg, previous) {
   result[name] = value;
   return result;
 }
+function enumParser(name, options, value) {
+  if (!options.includes(value))
+    throw new Error(`Invalid ${name}: ${value}. Valid values are: ${options.join(", ")}`);
+  return value;
+}
 function envToBoolean(value) {
   if (value === "true" || value === "1")
     return true;
@@ -337,10 +405,14 @@ function sanitizeForFilePath(s) {
   configFromCLIOptions,
   defaultConfig,
   dotenvFileLoader,
+  enumParser,
   headerParser,
   numberParser,
+  outputDir,
   outputFile,
+  resolutionParser,
   resolveCLIConfig,
   resolveConfig,
-  semicolonSeparatedList
+  semicolonSeparatedList,
+  tmpDir
 });

package/lib/mcp/browser/context.js

@@ -32,11 +32,14 @@ __export(context_exports, {
   InputRecorder: () => InputRecorder
 });
 module.exports = __toCommonJS(context_exports);
+var import_fs = __toESM(require("fs"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils = require("playwright-core/lib/utils");
+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_utils2 = require("./tools/utils");
 const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
 class Context {
   constructor(options) {
@@ -135,7 +138,27 @@ class Context {
     await promise.then(async ({ browserContext, close }) => {
       if (this.config.saveTrace)
         await browserContext.tracing.stop();
-      await close();
+      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_utils2.dateAsFileName)("webm"), { origin: "code", reason: "Saving video" });
+          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() {
@@ -170,6 +193,8 @@ class Context {
   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);
@@ -190,7 +215,7 @@ class Context {
   }
   lookupSecret(secretName) {
     if (!this.config.secrets?.[secretName])
-      return { value: secretName, code: codegen.quote(secretName) };
+      return { value: secretName, code: (0, import_utils.escapeWithQuotes)(secretName, "'") };
     return {
       value: this.config.secrets[secretName],
       code: `process.env['${secretName}']`