@cotestdev/mcp_playwright 0.0.34 → 0.0.36

package/lib/common/testType.js

@@ -23,7 +23,7 @@ __export(testType_exports, {
   rootTestType: () => rootTestType
 });
 module.exports = __toCommonJS(testType_exports);
-var import_playwright_core = require("playwright-core");
+var import_playwright_core = require("../mcpBundleImpl");
 var import_utils = require("playwright-core/lib/utils");
 var import_globals = require("./globals");
 var import_test = require("./test");

package/lib/mcp/browser/browserContextFactory.js

@@ -56,7 +56,7 @@ function contextFactory(config) {
 }
 function identityBrowserContextFactory(browserContext) {
   return {
-    createContext: async (clientInfo, abortSignal, toolName) => {
+    createContext: async (clientInfo, abortSignal, options) => {
       return {
         browserContext,
         close: async () => {
@@ -70,11 +70,11 @@ class BaseContextFactory {
     this._logName = name;
     this.config = config;
   }
-  async _obtainBrowser(clientInfo) {
+  async _obtainBrowser(clientInfo, options) {
     if (this._browserPromise)
       return this._browserPromise;
     (0, import_log.testDebug)(`obtain browser (${this._logName})`);
-    this._browserPromise = this._doObtainBrowser(clientInfo);
+    this._browserPromise = this._doObtainBrowser(clientInfo, options);
     void this._browserPromise.then((browser) => {
       browser.on("disconnected", () => {
         this._browserPromise = void 0;
@@ -84,12 +84,12 @@ class BaseContextFactory {
     });
     return this._browserPromise;
   }
-  async _doObtainBrowser(clientInfo) {
+  async _doObtainBrowser(clientInfo, options) {
     throw new Error("Not implemented");
   }
-  async createContext(clientInfo) {
+  async createContext(clientInfo, _, options) {
     (0, import_log.testDebug)(`create browser context (${this._logName})`);
-    const browser = await this._obtainBrowser(clientInfo);
+    const browser = await this._obtainBrowser(clientInfo, options);
     const browserContext = await this._doCreateContext(browser, clientInfo);
     await addInitScript(browserContext, this.config.browser.initScript);
     return {
@@ -115,7 +115,7 @@ class IsolatedContextFactory extends BaseContextFactory {
   constructor(config) {
     super("isolated", config);
   }
-  async _doObtainBrowser(clientInfo) {
+  async _doObtainBrowser(clientInfo, options) {
     await injectCdpPort(this.config.browser);
     const browserType = playwright[this.config.browser.browserName];
     const tracesDir = await computeTracesDir(this.config, clientInfo);
@@ -172,7 +172,7 @@ class PersistentContextFactory {
     this._userDataDirs = /* @__PURE__ */ new Set();
     this.config = config;
   }
-  async createContext(clientInfo) {
+  async createContext(clientInfo, abortSignal, options) {
     await injectCdpPort(this.config.browser);
     (0, import_log.testDebug)("create browser context (persistent)");
     const userDataDir = this.config.browser.userDataDir ?? await this._createUserDataDir(clientInfo);
@@ -277,10 +277,10 @@ class SharedContextFactory {
   constructor(baseFactory) {
     this._baseFactory = baseFactory;
   }
-  async createContext(clientInfo, abortSignal, toolName) {
+  async createContext(clientInfo, abortSignal, options) {
     if (!this._contextPromise) {
       (0, import_log.testDebug)("create shared browser context");
-      this._contextPromise = this._baseFactory.createContext(clientInfo, abortSignal, toolName);
+      this._contextPromise = this._baseFactory.createContext(clientInfo, abortSignal, options);
     }
     const { browserContext } = await this._contextPromise;
     (0, import_log.testDebug)(`shared context client connected`);
@@ -306,12 +306,12 @@ class SharedContextFactory {
 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" });
+  return await (0, import_config.outputFile)(config, clientInfo, `traces`, { origin: "code", title: "Collecting trace" });
 }
 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", reason: "Saving video" });
+    const dir = await (0, import_config.outputFile)(config, clientInfo, `videos`, { origin: "code", title: "Saving video" });
     result.recordVideo = {
       dir,
       size: config.saveVideo

package/lib/mcp/browser/browserServerBackend.js

@@ -28,10 +28,11 @@ var import_sessionLog = require("./sessionLog");
 var import_tools = require("./tools");
 var import_tool = require("../sdk/tool");
 class BrowserServerBackend {
-  constructor(config, factory) {
+  constructor(config, factory, options = {}) {
     this._config = config;
     this._browserContextFactory = factory;
-    this._tools = (0, import_tools.filteredTools)(config);
+    this._tools = options.allTools ? import_tools.browserTools : (0, import_tools.filteredTools)(config);
+    this._isStructuredOutput = options.structuredOutput ?? false;
   }
   async initialize(clientInfo) {
     this._sessionLog = this._config.saveSession ? await import_sessionLog.SessionLog.create(this._config, clientInfo) : void 0;
@@ -47,25 +48,36 @@ class BrowserServerBackend {
   }
   async callTool(name, rawArguments) {
     const tool = this._tools.find((tool2) => tool2.schema.name === name);
-    if (!tool)
-      throw new Error(`Tool "${name}" not found`);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `### Error
+Tool "${name}" not found` }],
+        isError: true
+      };
+    }
     const parsedArguments = tool.schema.inputSchema.parse(rawArguments || {});
     const context = this._context;
-    const response = new import_response.Response(context, name, parsedArguments);
-    response.logBegin();
+    const response = import_response.Response.create(context, name, parsedArguments);
     context.setRunningTool(name);
+    let responseObject;
     try {
       await tool.handle(context, parsedArguments, response);
-      await response.finish();
-      this._sessionLog?.logResponse(response);
+      const sections = await response.build();
+      if (this._isStructuredOutput)
+        responseObject = await (0, import_response.serializeStructuredResponse)(sections);
+      else
+        responseObject = await (0, import_response.serializeResponse)(context, sections, context.firstRootPath());
+      this._sessionLog?.logResponse(name, parsedArguments, responseObject);
     } catch (error) {
-      response.addError(String(error));
+      return {
+        content: [{ type: "text", text: `### Error
+${String(error)}` }],
+        isError: true
+      };
     } finally {
       context.setRunningTool(void 0);
     }
-    response.logEnd();
-    const _meta = rawArguments?._meta;
-    return response.serialize({ _meta });
+    return responseObject;
   }
   serverClosed() {
     void this._context?.dispose().catch(import_log.logUnhandledError);

package/lib/mcp/browser/config.js

@@ -55,8 +55,7 @@ const defaultConfig = {
     browserName: "chromium",
     launchOptions: {
       channel: "chrome",
-      headless: import_os.default.platform() === "linux" && !process.env.DISPLAY,
-      chromiumSandbox: true
+      headless: import_os.default.platform() === "linux" && !process.env.DISPLAY
     },
     contextOptions: {
       viewport: null
@@ -72,13 +71,30 @@ const defaultConfig = {
   server: {},
   saveTrace: false,
   snapshot: {
-    mode: "incremental"
+    mode: "incremental",
+    output: "stdout"
   },
   timeouts: {
     action: 5e3,
     navigation: 6e4
   }
 };
+const defaultDaemonConfig = (cliOptions) => mergeConfig(defaultConfig, {
+  browser: {
+    userDataDir: "<daemon-data-dir>",
+    launchOptions: {
+      headless: !cliOptions.daemonHeaded
+    },
+    contextOptions: {
+      viewport: cliOptions.daemonHeaded ? null : { width: 1280, height: 720 }
+    }
+  },
+  outputMode: "file",
+  codegen: "none",
+  snapshot: {
+    mode: "full"
+  }
+});
 async function resolveConfig(config) {
   return mergeConfig(defaultConfig, config);
 }
@@ -86,10 +102,22 @@ async function resolveCLIConfig(cliOptions) {
   const configInFile = await loadConfig(cliOptions.config);
   const envOverrides = configFromEnv();
   const cliOverrides = configFromCLIOptions(cliOptions);
-  let result = defaultConfig;
+  let result = cliOptions.daemon ? defaultDaemonConfig(cliOptions) : defaultConfig;
   result = mergeConfig(result, configInFile);
   result = mergeConfig(result, envOverrides);
   result = mergeConfig(result, cliOverrides);
+  if (cliOptions.daemon)
+    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.browser.browserName === "chromium" && result.browser.launchOptions.chromiumSandbox === void 0) {
+    if (process.platform === "linux")
+      result.browser.launchOptions.chromiumSandbox = result.browser.launchOptions.channel !== "chromium";
+    else
+      result.browser.launchOptions.chromiumSandbox = true;
+  }
   await validateConfig(result);
   return result;
 }
@@ -137,8 +165,8 @@ function configFromCLIOptions(cliOptions) {
     executablePath: cliOptions.executablePath,
     headless: cliOptions.headless
   };
-  if (cliOptions.sandbox === false)
-    launchOptions.chromiumSandbox = false;
+  if (cliOptions.sandbox !== void 0)
+    launchOptions.chromiumSandbox = cliOptions.sandbox;
   if (cliOptions.proxyServer) {
     launchOptions.proxy = {
       server: cliOptions.proxyServer
@@ -187,12 +215,14 @@ function configFromCLIOptions(cliOptions) {
       blockedOrigins: cliOptions.blockedOrigins
     },
     allowUnrestrictedFileAccess: cliOptions.allowUnrestrictedFileAccess,
+    codegen: cliOptions.codegen,
     saveSession: cliOptions.saveSession,
     saveTrace: cliOptions.saveTrace,
     saveVideo: cliOptions.saveVideo,
     secrets: cliOptions.secrets,
     sharedBrowserContext: cliOptions.sharedBrowserContext,
     snapshot: cliOptions.snapshotMode ? { mode: cliOptions.snapshotMode } : void 0,
+    outputMode: cliOptions.outputMode,
     outputDir: cliOptions.outputDir,
     imageResponses: cliOptions.imageResponses,
     testIdAttribute: cliOptions.testIdAttribute,
@@ -268,7 +298,7 @@ function outputDir(config, clientInfo) {
 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);
+  (0, import_utilsBundle.debug)("pw:mcp:file")(options.title, file);
   return file;
 }
 async function resolveFile(config, clientInfo, fileName, options) {

package/lib/mcp/browser/context.js

@@ -28,8 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var context_exports = {};
 __export(context_exports, {
-  Context: () => Context,
-  InputRecorder: () => InputRecorder
+  Context: () => Context
 });
 module.exports = __toCommonJS(context_exports);
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
@@ -67,7 +66,7 @@ class Context {
   }
   currentTabOrDie() {
     if (!this._currentTab)
-      throw new Error('No open pages available. Use the "browser_navigate" tool to navigate to a page first.');
+      throw new Error("No open pages available.");
     return this._currentTab;
   }
   async newTab() {
@@ -162,12 +161,12 @@ class Context {
     return browserContext;
   }
   _ensureBrowserContext() {
-    if (!this._browserContextPromise) {
-      this._browserContextPromise = this._setupBrowserContext();
-      this._browserContextPromise.catch(() => {
-        this._browserContextPromise = void 0;
-      });
-    }
+    if (this._browserContextPromise)
+      return this._browserContextPromise;
+    this._browserContextPromise = this._setupBrowserContext();
+    this._browserContextPromise.catch(() => {
+      this._browserContextPromise = void 0;
+    });
     return this._browserContextPromise;
   }
   async _setupBrowserContext() {
@@ -175,15 +174,15 @@ class Context {
       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 result = await this._browserContextFactory.createContext(this._clientInfo, this._abortController.signal, { toolName: this._runningToolName });
     const { browserContext } = result;
     if (!this.config.allowUnrestrictedFileAccess) {
-      browserContext._setAllowedProtocols(["http:", "https:", "about:", "data:"]);
-      browserContext._setAllowedDirectories(allRootPaths(this._clientInfo));
+      if (typeof browserContext._setAllowedProtocols === "function")
+        browserContext._setAllowedProtocols(["http:", "https:", "about:", "data:"]);
+      if (typeof browserContext._setAllowedDirectories === "function")
+        browserContext._setAllowedDirectories(allRootPaths(this._clientInfo));
     }
     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));
@@ -205,6 +204,9 @@ class Context {
       code: `process.env['${secretName}']`
     };
   }
+  firstRootPath() {
+    return allRootPaths(this._clientInfo)[0];
+  }
 }
 function allRootPaths(clientInfo) {
   const paths = [];
@@ -234,55 +236,7 @@ function originOrHostGlob(originOrHost) {
   }
   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
+  Context
 });