@cotestdev/mcp_playwright 0.0.50 → 0.0.52

package/lib/mcp/browser/tools/cookies.js

@@ -0,0 +1,152 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cookies_exports = {};
+__export(cookies_exports, {
+  default: () => cookies_default
+});
+module.exports = __toCommonJS(cookies_exports);
+var import_mcpBundle = require("../../../mcpBundle");
+var import_tool = require("./tool");
+const cookieList = (0, import_tool.defineTool)({
+  capability: "storage",
+  schema: {
+    name: "browser_cookie_list",
+    title: "List cookies",
+    description: "List all cookies (optionally filtered by domain/path)",
+    inputSchema: import_mcpBundle.z.object({
+      domain: import_mcpBundle.z.string().optional().describe("Filter cookies by domain"),
+      path: import_mcpBundle.z.string().optional().describe("Filter cookies by path")
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    let cookies = await browserContext.cookies();
+    if (params.domain)
+      cookies = cookies.filter((c) => c.domain.includes(params.domain));
+    if (params.path)
+      cookies = cookies.filter((c) => c.path.startsWith(params.path));
+    if (cookies.length === 0)
+      response.addTextResult("No cookies found");
+    else
+      response.addTextResult(cookies.map((c) => `${c.name}=${c.value} (domain: ${c.domain}, path: ${c.path})`).join("\n"));
+    response.addCode(`await page.context().cookies();`);
+  }
+});
+const cookieGet = (0, import_tool.defineTool)({
+  capability: "storage",
+  schema: {
+    name: "browser_cookie_get",
+    title: "Get cookie",
+    description: "Get a specific cookie by name",
+    inputSchema: import_mcpBundle.z.object({
+      name: import_mcpBundle.z.string().describe("Cookie name to get")
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    const cookies = await browserContext.cookies();
+    const cookie = cookies.find((c) => c.name === params.name);
+    if (!cookie)
+      response.addTextResult(`Cookie '${params.name}' not found`);
+    else
+      response.addTextResult(`${cookie.name}=${cookie.value} (domain: ${cookie.domain}, path: ${cookie.path}, httpOnly: ${cookie.httpOnly}, secure: ${cookie.secure}, sameSite: ${cookie.sameSite})`);
+    response.addCode(`await page.context().cookies();`);
+  }
+});
+const cookieSet = (0, import_tool.defineTool)({
+  capability: "storage",
+  schema: {
+    name: "browser_cookie_set",
+    title: "Set cookie",
+    description: "Set a cookie with optional flags (domain, path, expires, httpOnly, secure, sameSite)",
+    inputSchema: import_mcpBundle.z.object({
+      name: import_mcpBundle.z.string().describe("Cookie name"),
+      value: import_mcpBundle.z.string().describe("Cookie value"),
+      domain: import_mcpBundle.z.string().optional().describe("Cookie domain"),
+      path: import_mcpBundle.z.string().optional().describe("Cookie path"),
+      expires: import_mcpBundle.z.number().optional().describe("Cookie expiration as Unix timestamp"),
+      httpOnly: import_mcpBundle.z.boolean().optional().describe("Whether the cookie is HTTP only"),
+      secure: import_mcpBundle.z.boolean().optional().describe("Whether the cookie is secure"),
+      sameSite: import_mcpBundle.z.enum(["Strict", "Lax", "None"]).optional().describe("Cookie SameSite attribute")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    const tab = await context.ensureTab();
+    const url = new URL(tab.page.url());
+    const cookie = {
+      name: params.name,
+      value: params.value,
+      domain: params.domain || url.hostname,
+      path: params.path || "/"
+    };
+    if (params.expires !== void 0)
+      cookie.expires = params.expires;
+    if (params.httpOnly !== void 0)
+      cookie.httpOnly = params.httpOnly;
+    if (params.secure !== void 0)
+      cookie.secure = params.secure;
+    if (params.sameSite !== void 0)
+      cookie.sameSite = params.sameSite;
+    await browserContext.addCookies([cookie]);
+    response.addCode(`await page.context().addCookies([${JSON.stringify(cookie)}]);`);
+  }
+});
+const cookieDelete = (0, import_tool.defineTool)({
+  capability: "storage",
+  schema: {
+    name: "browser_cookie_delete",
+    title: "Delete cookie",
+    description: "Delete a specific cookie",
+    inputSchema: import_mcpBundle.z.object({
+      name: import_mcpBundle.z.string().describe("Cookie name to delete")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    await browserContext.clearCookies({ name: params.name });
+    response.addCode(`await page.context().clearCookies({ name: '${params.name}' });`);
+  }
+});
+const cookieClear = (0, import_tool.defineTool)({
+  capability: "storage",
+  schema: {
+    name: "browser_cookie_clear",
+    title: "Clear cookies",
+    description: "Clear all cookies",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    await browserContext.clearCookies();
+    response.addCode(`await page.context().clearCookies();`);
+  }
+});
+var cookies_default = [
+  cookieList,
+  cookieGet,
+  cookieSet,
+  cookieDelete,
+  cookieClear
+];

package/lib/mcp/browser/tools/install.js

@@ -62,6 +62,7 @@ const install = (0, import_tool.defineTool)({
           reject(new Error(`Failed to install browser: ${output.join("")}`));
       });
     });
+    response.addTextResult(`Browser ${channel} installed.`);
     const tabHeaders = await Promise.all(context.tabs().map((tab) => tab.headerSnapshot()));
     const result = (0, import_response.renderTabsMarkdown)(tabHeaders);
     response.addTextResult(result.join("\n"));

package/lib/mcp/browser/tools/network.js

@@ -18,7 +18,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var network_exports = {};
 __export(network_exports, {
-  default: () => network_default
+  default: () => network_default,
+  isFetch: () => isFetch,
+  renderRequest: () => renderRequest
 });
 module.exports = __toCommonJS(network_exports);
 var import_mcpBundle = require("../../../mcpBundle");
@@ -39,11 +41,11 @@ const requests = (0, import_tool.defineTabTool)({
     const requests2 = await tab.requests();
     const text = [];
     for (const request of requests2) {
-      const rendered = await renderRequest(request, params.includeStatic);
-      if (rendered)
-        text.push(rendered);
+      if (!params.includeStatic && !isFetch(request) && isSuccessfulResponse(request))
+        continue;
+      text.push(await renderRequest(request));
     }
-    response.addResult("Network", text.join("\n"), { prefix: "network", ext: "log", suggestedFilename: params.filename });
+    await response.addResult("Network", text.join("\n"), { prefix: "network", ext: "log", suggestedFilename: params.filename });
   }
 });
 const networkClear = (0, import_tool.defineTabTool)({
@@ -60,19 +62,31 @@ const networkClear = (0, import_tool.defineTabTool)({
     await tab.clearRequests();
   }
 });
-async function renderRequest(request, includeStatic) {
-  const response = request._hasResponse ? await request.response() : void 0;
-  const isStaticRequest = ["document", "stylesheet", "image", "media", "font", "script", "manifest"].includes(request.resourceType());
-  const isSuccessfulRequest = !response || response.status() < 400;
-  if (isStaticRequest && isSuccessfulRequest && !includeStatic)
-    return void 0;
+function isSuccessfulResponse(request) {
+  if (request.failure())
+    return false;
+  const response = request.existingResponse();
+  return !!response && response.status() < 400;
+}
+function isFetch(request) {
+  return ["fetch", "xhr"].includes(request.resourceType());
+}
+async function renderRequest(request) {
+  const response = request.existingResponse();
   const result = [];
   result.push(`[${request.method().toUpperCase()}] ${request.url()}`);
   if (response)
     result.push(`=> [${response.status()}] ${response.statusText()}`);
+  else if (request.failure())
+    result.push(`=> [FAILED] ${request.failure()?.errorText ?? "Unknown error"}`);
   return result.join(" ");
 }
 var network_default = [
   requests,
   networkClear
 ];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFetch,
+  renderRequest
+});

package/lib/mcp/browser/tools/pdf.js

@@ -24,7 +24,6 @@ module.exports = __toCommonJS(pdf_exports);
 var import_mcpBundle = require("../../../mcpBundle");
 var import_utils = require("playwright-core/lib/utils");
 var import_tool = require("./tool");
-var import_utils2 = require("./utils");
 const pdfSchema = import_mcpBundle.z.object({
   filename: import_mcpBundle.z.string().optional().describe("File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified. Prefer relative file names to stay within the output directory.")
 });
@@ -39,9 +38,9 @@ const pdf = (0, import_tool.defineTabTool)({
   },
   handle: async (tab, params, response) => {
     const data = await tab.page.pdf();
-    const suggestedFilename = params.filename ?? (0, import_utils2.dateAsFileName)("page", "pdf");
-    response.addResult("Page as pdf", data, { prefix: "page", ext: "pdf", suggestedFilename });
-    response.addCode(`await page.pdf(${(0, import_utils.formatObject)({ path: suggestedFilename })});`);
+    const result = await response.resolveClientFile({ prefix: "page", ext: "pdf", suggestedFilename: params.filename }, "Page as pdf");
+    await response.addFileResult(result, data);
+    response.addCode(`await page.pdf(${(0, import_utils.formatObject)({ path: result.relativeName })});`);
   }
 });
 var pdf_default = [

package/lib/mcp/browser/tools/route.js

@@ -0,0 +1,140 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var route_exports = {};
+__export(route_exports, {
+  default: () => route_default
+});
+module.exports = __toCommonJS(route_exports);
+var import_mcpBundle = require("../../../mcpBundle");
+var import_tool = require("./tool");
+const route = (0, import_tool.defineTool)({
+  capability: "network",
+  schema: {
+    name: "browser_route",
+    title: "Mock network requests",
+    description: "Set up a route to mock network requests matching a URL pattern",
+    inputSchema: import_mcpBundle.z.object({
+      pattern: import_mcpBundle.z.string().describe('URL pattern to match (e.g., "**/api/users", "**/*.{png,jpg}")'),
+      status: import_mcpBundle.z.number().optional().describe("HTTP status code to return (default: 200)"),
+      body: import_mcpBundle.z.string().optional().describe("Response body (text or JSON string)"),
+      contentType: import_mcpBundle.z.string().optional().describe('Content-Type header (e.g., "application/json", "text/html")'),
+      headers: import_mcpBundle.z.array(import_mcpBundle.z.string()).optional().describe('Headers to add in "Name: Value" format'),
+      removeHeaders: import_mcpBundle.z.string().optional().describe("Comma-separated list of header names to remove from request")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const addHeaders = params.headers ? Object.fromEntries(params.headers.map((h) => {
+      const colonIndex = h.indexOf(":");
+      return [h.substring(0, colonIndex).trim(), h.substring(colonIndex + 1).trim()];
+    })) : void 0;
+    const removeHeaders = params.removeHeaders ? params.removeHeaders.split(",").map((h) => h.trim()) : void 0;
+    const handler = async (route2) => {
+      if (params.body !== void 0 || params.status !== void 0) {
+        await route2.fulfill({
+          status: params.status ?? 200,
+          contentType: params.contentType,
+          body: params.body
+        });
+        return;
+      }
+      const headers = { ...route2.request().headers() };
+      if (addHeaders) {
+        for (const [key, value] of Object.entries(addHeaders))
+          headers[key] = value;
+      }
+      if (removeHeaders) {
+        for (const header of removeHeaders)
+          delete headers[header.toLowerCase()];
+      }
+      await route2.continue({ headers });
+    };
+    const entry = {
+      pattern: params.pattern,
+      status: params.status,
+      body: params.body,
+      contentType: params.contentType,
+      addHeaders,
+      removeHeaders,
+      handler
+    };
+    await context.addRoute(entry);
+    response.addTextResult(`Route added for pattern: ${params.pattern}`);
+    response.addCode(`await page.context().route('${params.pattern}', async route => { /* route handler */ });`);
+  }
+});
+const routeList = (0, import_tool.defineTool)({
+  capability: "network",
+  schema: {
+    name: "browser_route_list",
+    title: "List network routes",
+    description: "List all active network routes",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const routes = context.routes();
+    if (routes.length === 0) {
+      response.addTextResult("No active routes");
+      return;
+    }
+    const lines = [];
+    for (let i = 0; i < routes.length; i++) {
+      const route2 = routes[i];
+      const details = [];
+      if (route2.status !== void 0)
+        details.push(`status=${route2.status}`);
+      if (route2.body !== void 0)
+        details.push(`body=${route2.body.length > 50 ? route2.body.substring(0, 50) + "..." : route2.body}`);
+      if (route2.contentType)
+        details.push(`contentType=${route2.contentType}`);
+      if (route2.addHeaders)
+        details.push(`addHeaders=${JSON.stringify(route2.addHeaders)}`);
+      if (route2.removeHeaders)
+        details.push(`removeHeaders=${route2.removeHeaders.join(",")}`);
+      const detailsStr = details.length ? ` (${details.join(", ")})` : "";
+      lines.push(`${i + 1}. ${route2.pattern}${detailsStr}`);
+    }
+    response.addTextResult(lines.join("\n"));
+  }
+});
+const unroute = (0, import_tool.defineTool)({
+  capability: "network",
+  schema: {
+    name: "browser_unroute",
+    title: "Remove network routes",
+    description: "Remove network routes matching a pattern (or all routes if no pattern specified)",
+    inputSchema: import_mcpBundle.z.object({
+      pattern: import_mcpBundle.z.string().optional().describe("URL pattern to unroute (omit to remove all routes)")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const removed = await context.removeRoute(params.pattern);
+    if (params.pattern)
+      response.addTextResult(`Removed ${removed} route(s) for pattern: ${params.pattern}`);
+    else
+      response.addTextResult(`Removed all ${removed} route(s)`);
+  }
+});
+var route_default = [
+  route,
+  routeList,
+  unroute
+];

package/lib/mcp/browser/tools/runCode.js

@@ -35,7 +35,6 @@ var import_vm = __toESM(require("vm"));
 var import_utils = require("playwright-core/lib/utils");
 var import_mcpBundle = require("../../../mcpBundle");
 var import_ai_runner_fake = require("@cotestdev/ai-runner-fake");
-var import_test = require("@playwright/test");
 var import_tool = require("./tool");
 var import_schema = require("./schema");
 const codeSchema = import_schema.baseSchema.extend({
@@ -92,7 +91,6 @@ const runScript = (0, import_tool.defineTabTool)({
   handle: async (tab, params, response) => {
     response.setIncludeSnapshot();
     const runner = import_ai_runner_fake.Runner.NewInstance(params.projectId, params.testId);
-    runner.setExternalContext({ "expect": import_test.expect });
     await runner.init(tab.page, tab.page.context(), params.params);
     const result = await runner.runScript(params.testId, params.code);
     const code = `// Returns the out parameters of the reusable test

package/lib/mcp/browser/tools/screenshot.js

@@ -27,7 +27,6 @@ var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var import_utils2 = require("playwright-core/lib/utils");
 var import_mcpBundle = require("../../../mcpBundle");
 var import_tool = require("./tool");
-var import_utils3 = require("./utils");
 var import_schema = require("./schema");
 const screenshotSchema = import_schema.baseSchema.extend({
   type: import_mcpBundle.z.enum(["png", "jpeg"]).default("png").describe("Image format for the screenshot. Default is png."),
@@ -58,14 +57,14 @@ const screenshot = (0, import_tool.defineTabTool)({
     const screenshotTarget = params.ref ? params.element || "element" : params.fullPage ? "full page" : "viewport";
     const ref = params.ref ? await tab.refLocator({ element: params.element || "", ref: params.ref }) : null;
     const data = ref ? await ref.locator.screenshot(options) : await tab.page.screenshot(options);
-    const suggestedFilename = params.filename || (0, import_utils3.dateAsFileName)(ref ? "element" : "page", fileType);
-    response.addCode(`// Screenshot ${screenshotTarget} and save it as ${suggestedFilename}`);
+    const resolvedFile = await response.resolveClientFile({ prefix: ref ? "element" : "page", ext: fileType, suggestedFilename: params.filename }, `Screenshot of ${screenshotTarget}`);
+    response.addCode(`// Screenshot ${screenshotTarget} and save it as ${resolvedFile.relativeName}`);
     if (ref)
-      response.addCode(`await page.${ref.resolved}.screenshot(${(0, import_utils2.formatObject)({ ...options, path: suggestedFilename })});`);
+      response.addCode(`await page.${ref.resolved}.screenshot(${(0, import_utils2.formatObject)({ ...options, path: resolvedFile.relativeName })});`);
     else
-      response.addCode(`await page.screenshot(${(0, import_utils2.formatObject)({ ...options, path: suggestedFilename })});`);
-    const contentType = fileType === "png" ? "image/png" : "image/jpeg";
-    response.addResult(`Screenshot of ${screenshotTarget}`, data, { prefix: ref ? "element" : "page", ext: fileType, suggestedFilename, contentType });
+      response.addCode(`await page.screenshot(${(0, import_utils2.formatObject)({ ...options, path: resolvedFile.relativeName })});`);
+    await response.addFileResult(resolvedFile, data);
+    await response.registerImageResult(data, fileType);
   }
 });
 function scaleImageToFitMessage(buffer, imageType) {

package/lib/mcp/browser/tools/storage.js

@@ -23,7 +23,6 @@ __export(storage_exports, {
 module.exports = __toCommonJS(storage_exports);
 var import_mcpBundle = require("../../../mcpBundle");
 var import_tool = require("./tool");
-var import_utils = require("./utils");
 const storageState = (0, import_tool.defineTool)({
   capability: "storage",
   schema: {
@@ -38,10 +37,10 @@ const storageState = (0, import_tool.defineTool)({
   handle: async (context, params, response) => {
     const browserContext = await context.ensureBrowserContext();
     const state = await browserContext.storageState();
-    const suggestedFilename = params.filename || (0, import_utils.dateAsFileName)("storage-state", "json");
     const serializedState = JSON.stringify(state, null, 2);
-    response.addResult("Storage state", serializedState, { prefix: "storage-state", ext: "json", suggestedFilename });
-    response.addCode(`await page.context().storageState({ path: '${suggestedFilename}' });`);
+    const resolvedFile = await response.resolveClientFile({ prefix: "storage-state", ext: "json", suggestedFilename: params.filename }, "Storage state");
+    response.addCode(`await page.context().storageState({ path: '${resolvedFile.relativeName}' });`);
+    await response.addFileResult(resolvedFile, serializedState);
   }
 });
 const setStorageState = (0, import_tool.defineTool)({

package/lib/mcp/browser/tools/tracing.js

@@ -34,7 +34,7 @@ const tracingStart = (0, import_tool.defineTool)({
   },
   handle: async (context, params, response) => {
     const browserContext = await context.ensureBrowserContext();
-    const tracesDir = await context.outputFile(`traces`, { origin: "code", title: "Collecting trace" });
+    const tracesDir = await context.outputFile({ prefix: "", suggestedFilename: `traces`, ext: "" }, { origin: "code" });
     const name = "trace-" + Date.now();
     await browserContext.tracing.start({
       name,
@@ -42,12 +42,11 @@ const tracingStart = (0, import_tool.defineTool)({
       snapshots: true,
       _live: true
     });
-    const traceLegend = `- Action log: ${tracesDir}/${name}.trace
-- Network log: ${tracesDir}/${name}.network
-- Resources with content by sha1: ${tracesDir}/resources`;
-    response.addTextResult(`Tracing started, saving to ${tracesDir}.
-${traceLegend}`);
-    browserContext.tracing[traceLegendSymbol] = traceLegend;
+    response.addTextResult(`Trace recording started`);
+    response.addFileLink("Action log", `${tracesDir}/${name}.trace`);
+    response.addFileLink("Network log", `${tracesDir}/${name}.network`);
+    response.addFileLink("Resources", `${tracesDir}/resources`);
+    browserContext.tracing[traceLegendSymbol] = { tracesDir, name };
   }
 });
 const tracingStop = (0, import_tool.defineTool)({
@@ -63,8 +62,10 @@ const tracingStop = (0, import_tool.defineTool)({
     const browserContext = await context.ensureBrowserContext();
     await browserContext.tracing.stop();
     const traceLegend = browserContext.tracing[traceLegendSymbol];
-    response.addTextResult(`Tracing stopped.
-${traceLegend}`);
+    response.addTextResult(`Trace recording stopped.`);
+    response.addFileLink("Trace", `${traceLegend.tracesDir}/${traceLegend.name}.trace`);
+    response.addFileLink("Network log", `${traceLegend.tracesDir}/${traceLegend.name}.network`);
+    response.addFileLink("Resources", `${traceLegend.tracesDir}/resources`);
   }
 });
 var tracing_default = [

package/lib/mcp/browser/tools/utils.js

@@ -19,7 +19,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   callOnPageNoTrace: () => callOnPageNoTrace,
-  dateAsFileName: () => dateAsFileName,
   eventWaiter: () => eventWaiter,
   waitForCompletion: () => waitForCompletion
 });
@@ -62,10 +61,6 @@ async function waitForCompletion(tab, callback) {
 async function callOnPageNoTrace(page, callback) {
   return await page._wrapApiCall(() => callback(page), { internal: true });
 }
-function dateAsFileName(prefix, extension) {
-  const date = /* @__PURE__ */ new Date();
-  return `${prefix}-${date.toISOString().replace(/[:.]/g, "-")}.${extension}`;
-}
 function eventWaiter(page, event, timeout) {
   const disposables = [];
   const eventPromise = new Promise((resolve, reject) => {
@@ -88,7 +83,6 @@ function eventWaiter(page, event, timeout) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   callOnPageNoTrace,
-  dateAsFileName,
   eventWaiter,
   waitForCompletion
 });

package/lib/mcp/browser/tools/video.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,16 +17,24 @@ 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 video_exports = {};
 __export(video_exports, {
   default: () => video_default
 });
 module.exports = __toCommonJS(video_exports);
+var import_path = __toESM(require("path"));
 var import_mcpBundle = require("../../../mcpBundle");
 var import_tool = require("./tool");
-var import_utils = require("./utils");
-const startVideo = (0, import_tool.defineTabTool)({
+const startVideo = (0, import_tool.defineTool)({
   capability: "devtools",
   schema: {
     name: "browser_start_video",
@@ -38,12 +48,12 @@ const startVideo = (0, import_tool.defineTabTool)({
     }),
     type: "readOnly"
   },
-  handle: async (tab, params, response) => {
-    await tab.page.video().start({ size: params.size });
+  handle: async (context, params, response) => {
+    await context.startVideoRecording({ size: params.size });
     response.addTextResult("Video recording started.");
   }
 });
-const stopVideo = (0, import_tool.defineTabTool)({
+const stopVideo = (0, import_tool.defineTool)({
   capability: "devtools",
   schema: {
     name: "browser_stop_video",
@@ -54,15 +64,23 @@ const stopVideo = (0, import_tool.defineTabTool)({
     }),
     type: "readOnly"
   },
-  handle: async (tab, params, response) => {
-    let videoPath;
-    if (params.filename) {
-      const suggestedFilename = params.filename ?? (0, import_utils.dateAsFileName)("video", "webm");
-      videoPath = await tab.context.outputFile(suggestedFilename, { origin: "llm", title: "Saving video" });
+  handle: async (context, params, response) => {
+    const videos = await context.stopVideoRecording();
+    if (!videos.size) {
+      response.addTextResult("No videos were recorded.");
+      return;
+    }
+    for (const [index, video] of [...videos].entries()) {
+      const suffix = index ? `-${index}` : "";
+      let suggestedFilename = params.filename;
+      if (suggestedFilename && suffix) {
+        const ext = import_path.default.extname(suggestedFilename);
+        suggestedFilename = import_path.default.basename(suggestedFilename, ext) + suffix + ext;
+      }
+      const resolvedFile = await response.resolveClientFile({ prefix: "video" + suffix, ext: "webm", suggestedFilename }, "Video");
+      await video.saveAs(resolvedFile.fileName);
+      await response.addFileResult(resolvedFile, null);
     }
-    await tab.page.video().stop({ path: videoPath });
-    const tmpPath = await tab.page.video().path();
-    response.addTextResult(`Video recording stopped: ${videoPath ?? tmpPath}`);
   }
 });
 var video_default = [