@cotestdev/mcp_playwright 0.0.51 → 0.0.52

package/lib/mcp/browser/browserContextFactory.js

@@ -128,7 +128,7 @@ class IsolatedContextFactory extends BaseContextFactory {
       handleSIGTERM: false
     }).catch((error) => {
       if (error.message.includes("Executable doesn't exist"))
-        throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+        throwBrowserIsNotInstalledError(this.config);
       throw error;
     });
   }
@@ -201,7 +201,7 @@ class PersistentContextFactory {
         return { browserContext, close };
       } catch (error) {
         if (error.message.includes("Executable doesn't exist"))
-          throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+          throwBrowserIsNotInstalledError(this.config);
         if (error.message.includes("cannot open shared object file: No such file or directory")) {
           const browserName = launchOptions.channel ?? this.config.browser.browserName;
           throw new Error(`Missing system dependencies required to run browser ${browserName}. Install them with: sudo npx playwright install-deps ${browserName}`);
@@ -306,12 +306,12 @@ class SharedContextFactory {
 async function computeTracesDir(config, clientInfo) {
   if (!config.saveTrace && !config.capabilities?.includes("devtools"))
     return;
-  return await (0, import_config.outputFile)(config, clientInfo, `traces`, { origin: "code", title: "Collecting trace" });
+  return await (0, import_config.outputFile)(config, clientInfo, `traces`, { origin: "code" });
 }
 async function browserContextOptionsFromConfig(config, clientInfo) {
   const result = { ...config.browser.contextOptions };
   if (config.saveVideo) {
-    const dir = await (0, import_config.outputFile)(config, clientInfo, `videos`, { origin: "code", title: "Saving video" });
+    const dir = await (0, import_config.outputFile)(config, clientInfo, `videos`, { origin: "code" });
     result.recordVideo = {
       dir,
       size: config.saveVideo
@@ -319,6 +319,13 @@ async function browserContextOptionsFromConfig(config, clientInfo) {
   }
   return result;
 }
+function throwBrowserIsNotInstalledError(config) {
+  const channel = config.browser.launchOptions?.channel ?? config.browser.browserName;
+  if (config.skillMode)
+    throw new Error(`Browser "${channel}" is not installed. Run \`playwright-cli install-browser ${channel}\` to install`);
+  else
+    throw new Error(`Browser "${channel}" is not installed. Either install it (likely) or change the config.`);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SharedContextFactory,

package/lib/mcp/browser/browserServerBackend.js

@@ -41,7 +41,6 @@ class BrowserServerBackend {
       sessionLog: this._sessionLog,
       clientInfo
     });
-    this._context.onBrowserContextClosed = () => this.onBrowserContextClosed?.();
   }
   async listTools() {
     return this._tools.map((tool) => (0, import_tool.toMcpTool)(tool.schema));
@@ -58,13 +57,12 @@ Tool "${name}" not found` }],
     const parsedArguments = tool.schema.inputSchema.parse(rawArguments || {});
     const cwd = rawArguments?._meta && typeof rawArguments?._meta === "object" && rawArguments._meta?.cwd;
     const context = this._context;
-    const response = import_response.Response.create(context, name, parsedArguments);
+    const response = new import_response.Response(context, name, parsedArguments, cwd);
     context.setRunningTool(name);
     let responseObject;
     try {
       await tool.handle(context, parsedArguments, response);
-      const sections = await response.build();
-      responseObject = await (0, import_response.serializeResponse)(context, sections, cwd ?? context.firstRootPath());
+      responseObject = await response.serialize();
       this._sessionLog?.logResponse(name, parsedArguments, responseObject);
     } catch (error) {
       return {

package/lib/mcp/browser/config.js

@@ -40,7 +40,9 @@ __export(config_exports, {
   resolutionParser: () => resolutionParser,
   resolveCLIConfig: () => resolveCLIConfig,
   resolveConfig: () => resolveConfig,
-  semicolonSeparatedList: () => semicolonSeparatedList
+  semicolonSeparatedList: () => semicolonSeparatedList,
+  workspaceDir: () => workspaceDir,
+  workspaceFile: () => workspaceFile
 });
 module.exports = __toCommonJS(config_exports);
 var import_fs = __toESM(require("fs"));
@@ -59,7 +61,8 @@ const defaultConfig = {
     },
     contextOptions: {
       viewport: null
-    }
+    },
+    isolated: false
   },
   console: {
     level: "info"
@@ -79,38 +82,35 @@ const defaultConfig = {
     navigation: 6e4
   }
 };
-const defaultDaemonConfig = (cliOptions) => mergeConfig(defaultConfig, {
+const defaultDaemonConfig = mergeConfig(defaultConfig, {
   browser: {
-    userDataDir: cliOptions.extension ? void 0 : "<daemon-data-dir>",
-    // Use default user profile with extension.
     launchOptions: {
-      headless: !cliOptions.daemonHeaded
+      headless: true
     },
-    contextOptions: {
-      viewport: cliOptions.daemonHeaded ? null : { width: 1280, height: 720 }
-    }
-  },
-  outputMode: "file",
-  snapshot: {
-    mode: "full"
+    isolated: true
   }
 });
 async function resolveConfig(config) {
   return mergeConfig(defaultConfig, config);
 }
 async function resolveCLIConfig(cliOptions) {
-  const configInFile = await loadConfig(cliOptions.config);
   const envOverrides = configFromEnv();
+  const daemonOverrides = await configForDaemonSession(cliOptions);
   const cliOverrides = configFromCLIOptions(cliOptions);
-  let result = cliOptions.daemon ? defaultDaemonConfig(cliOptions) : defaultConfig;
+  const configFile = cliOverrides.configFile ?? envOverrides.configFile ?? daemonOverrides.configFile;
+  const configInFile = await loadConfig(configFile);
+  let result = cliOptions.daemonSession ? defaultDaemonConfig : defaultConfig;
   result = mergeConfig(result, configInFile);
+  result = mergeConfig(result, daemonOverrides);
   result = mergeConfig(result, envOverrides);
   result = mergeConfig(result, cliOverrides);
-  if (cliOptions.daemon)
+  if (daemonOverrides.sessionConfig) {
     result.skillMode = true;
-  if (result.browser.userDataDir === "<daemon-data-dir>") {
-    const browserToken = result.browser.launchOptions?.channel ?? result.browser?.browserName;
-    result.browser.userDataDir = `${cliOptions.daemonDataDir}-${browserToken}`;
+    if (!result.extension && !result.browser.userDataDir && daemonOverrides.sessionConfig.userDataDirPrefix) {
+      const browserToken = result.browser.launchOptions?.channel ?? result.browser?.browserName;
+      const userDataDir = `${daemonOverrides.sessionConfig.userDataDirPrefix}-${browserToken}`;
+      result.browser.userDataDir = userDataDir;
+    }
   }
   if (result.browser.browserName === "chromium" && result.browser.launchOptions.chromiumSandbox === void 0) {
     if (process.platform === "linux")
@@ -118,6 +118,10 @@ async function resolveCLIConfig(cliOptions) {
     else
       result.browser.launchOptions.chromiumSandbox = true;
   }
+  result.configFile = configFile;
+  result.sessionConfig = daemonOverrides.sessionConfig;
+  if (result.sessionConfig && result.browser.launchOptions.headless !== false)
+    result.browser.contextOptions.viewport ??= { width: 1280, height: 720 };
   await validateConfig(result);
   return result;
 }
@@ -189,7 +193,7 @@ function configFromCLIOptions(cliOptions) {
     contextOptions.serviceWorkers = "block";
   if (cliOptions.grantPermissions)
     contextOptions.permissions = cliOptions.grantPermissions;
-  const result = {
+  const config = {
     browser: {
       browserName,
       isolated: cliOptions.isolated,
@@ -198,6 +202,7 @@ function configFromCLIOptions(cliOptions) {
       contextOptions,
       cdpEndpoint: cliOptions.cdpEndpoint,
       cdpHeaders: cliOptions.cdpHeader,
+      cdpTimeout: cliOptions.cdpTimeout,
       initPage: cliOptions.initPage,
       initScript: cliOptions.initScript
     },
@@ -232,7 +237,7 @@ function configFromCLIOptions(cliOptions) {
       navigation: cliOptions.timeoutNavigation
     }
   };
-  return result;
+  return { ...config, configFile: cliOptions.config };
 }
 function configFromEnv() {
   const options = {};
@@ -245,6 +250,7 @@ function configFromEnv() {
   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.cdpTimeout = numberParser(process.env.PLAYWRIGHT_MCP_CDP_TIMEOUT);
   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);
@@ -281,6 +287,22 @@ function configFromEnv() {
   options.viewportSize = resolutionParser("--viewport-size", process.env.PLAYWRIGHT_MCP_VIEWPORT_SIZE);
   return configFromCLIOptions(options);
 }
+async function configForDaemonSession(cliOptions) {
+  if (!cliOptions.daemonSession)
+    return {};
+  const sessionConfig = await import_fs.default.promises.readFile(cliOptions.daemonSession, "utf-8").then((data) => JSON.parse(data));
+  const config = configFromCLIOptions({
+    config: sessionConfig.cli.config,
+    browser: sessionConfig.cli.browser,
+    isolated: sessionConfig.cli.persistent === true ? false : void 0,
+    headless: sessionConfig.cli.headed ? false : void 0,
+    extension: sessionConfig.cli.extension,
+    userDataDir: sessionConfig.cli.profile,
+    outputMode: "file",
+    snapshotMode: "full"
+  });
+  return { ...config, sessionConfig };
+}
 async function loadConfig(configFile) {
   if (!configFile)
     return {};
@@ -290,31 +312,38 @@ async function loadConfig(configFile) {
     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 workspaceDir(clientInfo) {
+  return import_path.default.resolve((0, import_server.firstRootPath)(clientInfo) ?? process.cwd());
+}
+async function workspaceFile(config, clientInfo, fileName, perCallWorkspaceDir) {
+  const workspace = perCallWorkspaceDir ?? workspaceDir(clientInfo);
+  const resolvedName = import_path.default.resolve(workspace, fileName);
+  await checkFile(config, clientInfo, resolvedName, { origin: "code" });
+  return resolvedName;
 }
 function outputDir(config, clientInfo) {
+  if (config.outputDir)
+    return import_path.default.resolve(config.outputDir);
   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));
+  if (rootPath)
+    return import_path.default.resolve(rootPath, config.skillMode ? ".playwright-cli" : ".playwright-mcp");
+  const tmpDir = process.env.PW_TMPDIR_FOR_TEST ?? import_os.default.tmpdir();
+  return import_path.default.resolve(tmpDir, "playwright-mcp-output", 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.title, file);
-  return file;
+  const resolvedFile = import_path.default.resolve(outputDir(config, clientInfo), fileName);
+  await checkFile(config, clientInfo, resolvedFile, options);
+  await import_fs.default.promises.mkdir(import_path.default.dirname(resolvedFile), { recursive: true });
+  (0, import_utilsBundle.debug)("pw:mcp:file")(resolvedFile);
+  return resolvedFile;
 }
-async function resolveFile(config, clientInfo, fileName, options) {
-  const dir = outputDir(config, clientInfo);
+async function checkFile(config, clientInfo, resolvedFilename, options) {
   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));
+    return;
+  const output = outputDir(config, clientInfo);
+  const workspace = workspaceDir(clientInfo);
+  if (!resolvedFilename.startsWith(output) && !resolvedFilename.startsWith(workspace))
+    throw new Error(`Resolved file path ${resolvedFilename} is outside of the output directory ${output} and workspace directory ${workspace}. Use relative file names to stay within the output directory.`);
 }
 function pickDefined(obj) {
   return Object.fromEntries(
@@ -425,13 +454,6 @@ function envToBoolean(value) {
 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,
@@ -446,5 +468,7 @@ function sanitizeForFilePath(s) {
   resolutionParser,
   resolveCLIConfig,
   resolveConfig,
-  semicolonSeparatedList
+  semicolonSeparatedList,
+  workspaceDir,
+  workspaceFile
 });

package/lib/mcp/browser/context.js

@@ -31,11 +31,11 @@ __export(context_exports, {
   Context: () => Context
 });
 module.exports = __toCommonJS(context_exports);
+var import_os = __toESM(require("os"));
 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_url = require("url");
-var import_os = __toESM(require("os"));
 var import_log = require("../log");
 var import_tab = require("./tab");
 var import_config = require("./config");
@@ -43,6 +43,7 @@ const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
 class Context {
   constructor(options) {
     this._tabs = [];
+    this._routes = [];
     this._abortController = new AbortController();
     this.config = options.config;
     this.sessionLog = options.sessionLog;
@@ -97,8 +98,39 @@ class Context {
     await tab.page.close();
     return url;
   }
-  async outputFile(fileName, options) {
-    return (0, import_config.outputFile)(this.config, this._clientInfo, fileName, options);
+  async workspaceFile(fileName, perCallWorkspaceDir) {
+    return await (0, import_config.workspaceFile)(this.config, this._clientInfo, fileName, perCallWorkspaceDir);
+  }
+  async outputFile(template, options) {
+    const baseName = template.suggestedFilename || `${template.prefix}-${(template.date ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}${template.ext ? "." + template.ext : ""}`;
+    return await (0, import_config.outputFile)(this.config, this._clientInfo, baseName, options);
+  }
+  async startVideoRecording(params) {
+    if (this._video)
+      throw new Error("Video recording has already been started.");
+    const listener = (page) => {
+      this._video?.allVideos.add(page.video());
+      page.video().start(params).catch(() => {
+      });
+    };
+    this._video = { allVideos: /* @__PURE__ */ new Set(), listener };
+    const browserContext = await this.ensureBrowserContext();
+    browserContext.pages().forEach(listener);
+    browserContext.on("page", listener);
+  }
+  async stopVideoRecording() {
+    if (!this._video)
+      throw new Error("Video recording has not been started.");
+    const video = this._video;
+    if (this._browserContextPromise) {
+      const { browserContext } = await this._browserContextPromise;
+      browserContext.off("page", video.listener);
+      for (const page of browserContext.pages())
+        await page.video().stop().catch(() => {
+        });
+    }
+    this._video = void 0;
+    return video.allVideos;
   }
   _onPageCreated(page) {
     const tab = new import_tab.Tab(this, page, (tab2) => this._onPageClosed(tab2));
@@ -122,6 +154,33 @@ class Context {
     await this._closeBrowserContextPromise;
     this._closeBrowserContextPromise = void 0;
   }
+  routes() {
+    return this._routes;
+  }
+  async addRoute(entry) {
+    const { browserContext } = await this._ensureBrowserContext();
+    await browserContext.route(entry.pattern, entry.handler);
+    this._routes.push(entry);
+  }
+  async removeRoute(pattern) {
+    if (!this._browserContextPromise)
+      return 0;
+    const { browserContext } = await this._browserContextPromise;
+    let removed = 0;
+    if (pattern) {
+      const toRemove = this._routes.filter((r) => r.pattern === pattern);
+      for (const route of toRemove)
+        await browserContext.unroute(route.pattern, route.handler);
+      this._routes = this._routes.filter((r) => r.pattern !== pattern);
+      removed = toRemove.length;
+    } else {
+      for (const route of this._routes)
+        await browserContext.unroute(route.pattern, route.handler);
+      removed = this._routes.length;
+      this._routes = [];
+    }
+    return removed;
+  }
   isRunningTool() {
     return this._runningToolName !== void 0;
   }
@@ -186,7 +245,6 @@ class Context {
     for (const page of browserContext.pages())
       this._onPageCreated(page);
     browserContext.on("page", (page) => this._onPageCreated(page));
-    browserContext.on("close", () => this.onBrowserContextClosed?.());
     if (this.config.saveTrace) {
       await browserContext.tracing.start({
         name: "trace-" + Date.now(),
@@ -229,6 +287,9 @@ function allRootPaths(clientInfo) {
   return paths;
 }
 function originOrHostGlob(originOrHost) {
+  const wildcardPortMatch = originOrHost.match(/^(https?:\/\/[^/:]+):\*$/);
+  if (wildcardPortMatch)
+    return `${wildcardPortMatch[1]}:*/**`;
   try {
     const url = new URL(originOrHost);
     if (url.origin !== "null")

package/lib/mcp/browser/logFile.js

@@ -0,0 +1,96 @@
+"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 logFile_exports = {};
+__export(logFile_exports, {
+  LogFile: () => LogFile
+});
+module.exports = __toCommonJS(logFile_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_log = require("../log");
+class LogFile {
+  constructor(context, startTime, filePrefix, title) {
+    this._stopped = false;
+    this._line = 0;
+    this._entries = 0;
+    this._lastLine = 0;
+    this._lastEntries = 0;
+    this._writeChain = Promise.resolve();
+    this._context = context;
+    this._startTime = startTime;
+    this._filePrefix = filePrefix;
+    this._title = title;
+  }
+  appendLine(wallTime, text) {
+    this._writeChain = this._writeChain.then(() => this._write(wallTime, text)).catch(import_log.logUnhandledError);
+  }
+  stop() {
+    this._stopped = true;
+  }
+  async take(relativeTo) {
+    const logChunk = await this._take();
+    if (!logChunk)
+      return void 0;
+    const logFilePath = relativeTo ? import_path.default.relative(relativeTo, logChunk.file) : logChunk.file;
+    const lineRange = logChunk.fromLine === logChunk.toLine ? `#L${logChunk.fromLine}` : `#L${logChunk.fromLine}-L${logChunk.toLine}`;
+    return `${logFilePath}${lineRange}`;
+  }
+  async _take() {
+    await this._writeChain;
+    if (!this._file || this._entries === this._lastEntries)
+      return void 0;
+    const chunk = {
+      type: this._title.toLowerCase(),
+      file: this._file,
+      fromLine: this._lastLine + 1,
+      toLine: this._line,
+      entryCount: this._entries - this._lastEntries
+    };
+    this._lastLine = this._line;
+    this._lastEntries = this._entries;
+    return chunk;
+  }
+  async _write(wallTime, text) {
+    if (this._stopped)
+      return;
+    this._file ??= await this._context.outputFile({ prefix: this._filePrefix, ext: "log", date: new Date(this._startTime) }, { origin: "code" });
+    const relativeTime = Math.round(wallTime - this._startTime);
+    const renderedText = await text();
+    const logLine = `[${String(relativeTime).padStart(8, " ")}ms] ${renderedText}
+`;
+    await import_fs.default.promises.appendFile(this._file, logLine);
+    const lineCount = logLine.split("\n").length - 1;
+    this._line += lineCount;
+    this._entries++;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogFile
+});