playwright-codegen-pro-core 1.0.0

package/lib/tools/backend/common.js

@@ -0,0 +1,63 @@
+"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 common_exports = {};
+__export(common_exports, {
+  default: () => common_default
+});
+module.exports = __toCommonJS(common_exports);
+var import_mcpBundle = require("../../mcpBundle");
+var import_tool = require("./tool");
+var import_response = require("./response");
+const close = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_close",
+    title: "Close browser",
+    description: "Close the page",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const result = (0, import_response.renderTabsMarkdown)([]);
+    response.addTextResult(result.join("\n"));
+    response.addCode(`await page.close()`);
+    response.setClose();
+  }
+});
+const resize = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_resize",
+    title: "Resize browser window",
+    description: "Resize the browser window",
+    inputSchema: import_mcpBundle.z.object({
+      width: import_mcpBundle.z.number().describe("Width of the browser window"),
+      height: import_mcpBundle.z.number().describe("Height of the browser window")
+    }),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`await page.setViewportSize({ width: ${params.width}, height: ${params.height} });`);
+    await tab.page.setViewportSize({ width: params.width, height: params.height });
+  }
+});
+var common_default = [
+  close,
+  resize
+];

package/lib/tools/backend/config.js

@@ -0,0 +1,41 @@
+"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 config_exports = {};
+__export(config_exports, {
+  default: () => config_default
+});
+module.exports = __toCommonJS(config_exports);
+var import_mcpBundle = require("../../mcpBundle");
+var import_tool = require("./tool");
+const configShow = (0, import_tool.defineTool)({
+  capability: "config",
+  schema: {
+    name: "browser_get_config",
+    title: "Get config",
+    description: "Get the final resolved config after merging CLI options, environment variables and config file.",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    response.addTextResult(JSON.stringify(context.config, null, 2));
+  }
+});
+var config_default = [
+  configShow
+];

package/lib/tools/backend/console.js

@@ -0,0 +1,66 @@
+"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 console_exports = {};
+__export(console_exports, {
+  default: () => console_default
+});
+module.exports = __toCommonJS(console_exports);
+var import_mcpBundle = require("../../mcpBundle");
+var import_tool = require("./tool");
+const console = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_console_messages",
+    title: "Get console messages",
+    description: "Returns all console messages",
+    inputSchema: import_mcpBundle.z.object({
+      level: import_mcpBundle.z.enum(["error", "warning", "info", "debug"]).default("info").describe('Level of the console messages to return. Each level includes the messages of more severe levels. Defaults to "info".'),
+      all: import_mcpBundle.z.boolean().optional().describe("Return all console messages since the beginning of the session, not just since the last navigation. Defaults to false."),
+      filename: import_mcpBundle.z.string().optional().describe("Filename to save the console messages to. If not provided, messages are returned as text.")
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const count = await tab.consoleMessageCount();
+    const header = [`Total messages: ${count.total} (Errors: ${count.errors}, Warnings: ${count.warnings})`];
+    const messages = await tab.consoleMessages(params.level, params.all);
+    if (messages.length !== count.total)
+      header.push(`Returning ${messages.length} messages for level "${params.level}"`);
+    const text = [...header, "", ...messages.map((message) => message.toString())].join("\n");
+    await response.addResult("Console", text, { prefix: "console", ext: "log", suggestedFilename: params.filename });
+  }
+});
+const consoleClear = (0, import_tool.defineTabTool)({
+  capability: "core",
+  skillOnly: true,
+  schema: {
+    name: "browser_console_clear",
+    title: "Clear console messages",
+    description: "Clear all console messages",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (tab) => {
+    await tab.clearConsoleMessages();
+  }
+});
+var console_default = [
+  console,
+  consoleClear
+];

package/lib/tools/backend/context.js

@@ -0,0 +1,290 @@
+"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,
+  outputDir: () => outputDir,
+  outputFile: () => outputFile,
+  workspaceFile: () => workspaceFile
+});
+module.exports = __toCommonJS(context_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("../../utilsBundle");
+var import_stringUtils = require("../../utils/isomorphic/stringUtils");
+var import__ = require("../../..");
+var import_tab = require("./tab");
+var import_disposable = require("../../server/utils/disposable");
+var import_eventsHelper = require("../../server/utils/eventsHelper");
+const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
+class Context {
+  constructor(browserContext, options) {
+    this._tabs = [];
+    this._routes = [];
+    this._disposables = [];
+    this.config = options.config;
+    this.sessionLog = options.sessionLog;
+    this.options = options;
+    this._rawBrowserContext = browserContext;
+    testDebug("create context");
+  }
+  async dispose() {
+    await (0, import_disposable.disposeAll)(this._disposables);
+    for (const tab of this._tabs)
+      await tab.dispose();
+    this._tabs.length = 0;
+    this._currentTab = void 0;
+    await this.stopVideoRecording();
+  }
+  debugger() {
+    return this._rawBrowserContext.debugger;
+  }
+  tabs() {
+    return this._tabs;
+  }
+  currentTab() {
+    return this._currentTab;
+  }
+  currentTabOrDie() {
+    if (!this._currentTab)
+      throw new Error("No open pages available.");
+    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 workspaceFile(fileName, perCallWorkspaceDir) {
+    return await workspaceFile(this.options, 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 outputFile(this.options, baseName, options);
+  }
+  async startVideoRecording(params) {
+    if (this._video)
+      throw new Error("Video recording has already been started.");
+    this._video = { allVideos: /* @__PURE__ */ new Set(), params };
+    const browserContext = await this.ensureBrowserContext();
+    for (const page of browserContext.pages())
+      await this._startPageVideo(page);
+  }
+  async stopVideoRecording() {
+    if (!this._video)
+      return [];
+    const video = this._video;
+    for (const page of this._rawBrowserContext.pages())
+      await page.video().stop();
+    this._video = void 0;
+    return [...video.allVideos];
+  }
+  async _startPageVideo(page) {
+    if (!this._video)
+      return;
+    this._video.allVideos.add(page.video());
+    await page.video().start(this._video.params);
+  }
+  _onPageCreated(page) {
+    const tab = new import_tab.Tab(this, page, (tab2) => this._onPageClosed(tab2));
+    this._tabs.push(tab);
+    if (!this._currentTab)
+      this._currentTab = tab;
+    this._startPageVideo(page).catch(() => {
+    });
+  }
+  _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)];
+  }
+  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) {
+    let removed = 0;
+    const browserContext = await this.ensureBrowserContext();
+    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;
+  }
+  setRunningTool(name) {
+    this._runningToolName = name;
+  }
+  async _setupRequestInterception(context) {
+    if (this.config.network?.allowedOrigins?.length) {
+      this._disposables.push(await context.route("**", (route) => route.abort("blockedbyclient")));
+      for (const origin of this.config.network.allowedOrigins) {
+        const glob = originOrHostGlob(origin);
+        this._disposables.push(await context.route(glob, (route) => route.continue()));
+      }
+    }
+    if (this.config.network?.blockedOrigins?.length) {
+      for (const origin of this.config.network.blockedOrigins)
+        this._disposables.push(await context.route(originOrHostGlob(origin), (route) => route.abort("blockedbyclient")));
+    }
+  }
+  async ensureBrowserContext() {
+    if (this._browserContextPromise)
+      return this._browserContextPromise;
+    this._browserContextPromise = this._initializeBrowserContext();
+    return this._browserContextPromise;
+  }
+  async _initializeBrowserContext() {
+    if (this.config.testIdAttribute)
+      import__.selectors.setTestIdAttribute(this.config.testIdAttribute);
+    const browserContext = this._rawBrowserContext;
+    await this._setupRequestInterception(browserContext);
+    if (this.config.saveTrace) {
+      await browserContext.tracing.start({
+        name: "trace-" + Date.now(),
+        screenshots: true,
+        snapshots: true,
+        live: true
+      });
+      this._disposables.push({
+        dispose: async () => {
+          await browserContext.tracing.stop();
+        }
+      });
+    }
+    for (const initScript of this.config.browser?.initScript || [])
+      this._disposables.push(await browserContext.addInitScript({ path: import_path.default.resolve(this.options.cwd, initScript) }));
+    for (const page of browserContext.pages())
+      this._onPageCreated(page);
+    this._disposables.push(import_eventsHelper.eventsHelper.addEventListener(browserContext, "page", (page) => this._onPageCreated(page)));
+    return browserContext;
+  }
+  checkUrlAllowed(url) {
+    if (this.config.allowUnrestrictedFileAccess)
+      return;
+    if (!URL.canParse(url))
+      return;
+    if (new URL(url).protocol === "file:")
+      throw new Error(`Access to "file:" protocol is blocked. Attempted URL: "${url}"`);
+  }
+  lookupSecret(secretName) {
+    if (!this.config.secrets?.[secretName])
+      return { value: secretName, code: (0, import_stringUtils.escapeWithQuotes)(secretName, "'") };
+    return {
+      value: this.config.secrets[secretName],
+      code: `process.env['${secretName}']`
+    };
+  }
+}
+function originOrHostGlob(originOrHost) {
+  const wildcardPortMatch = originOrHost.match(/^(https?:\/\/[^/:]+):\*$/);
+  if (wildcardPortMatch)
+    return `${wildcardPortMatch[1]}:*/**`;
+  try {
+    const url = new URL(originOrHost);
+    if (url.origin !== "null")
+      return `${url.origin}/**`;
+  } catch {
+  }
+  return `*://${originOrHost}/**`;
+}
+async function workspaceFile(options, fileName, perCallWorkspaceDir) {
+  const workspace = perCallWorkspaceDir ?? options.cwd;
+  const resolvedName = import_path.default.resolve(workspace, fileName);
+  await checkFile(options, resolvedName, { origin: "llm" });
+  return resolvedName;
+}
+function outputDir(options) {
+  if (options.config.outputDir)
+    return import_path.default.resolve(options.config.outputDir);
+  return import_path.default.resolve(options.cwd, options.config.skillMode ? ".playwright-cli" : ".playwright-mcp");
+}
+async function outputFile(options, fileName, flags) {
+  const resolvedFile = import_path.default.resolve(outputDir(options), fileName);
+  await checkFile(options, resolvedFile, flags);
+  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 checkFile(options, resolvedFilename, flags) {
+  if (flags.origin === "code" || options.config.allowUnrestrictedFileAccess)
+    return;
+  const output = outputDir(options);
+  const workspace = options.cwd;
+  const withinDir = (root) => resolvedFilename === root || resolvedFilename.startsWith(root + import_path.default.sep);
+  if (!withinDir(output) && !withinDir(workspace))
+    throw new Error(`File access denied: ${resolvedFilename} is outside allowed roots. Allowed roots: ${output}, ${workspace}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context,
+  outputDir,
+  outputFile,
+  workspaceFile
+});

package/lib/tools/backend/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/tools/backend/devtools.js

@@ -0,0 +1,69 @@
+"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 devtools_exports = {};
+__export(devtools_exports, {
+  default: () => devtools_default
+});
+module.exports = __toCommonJS(devtools_exports);
+var import_mcpBundle = require("../../mcpBundle");
+var import_tool = require("./tool");
+const resume = (0, import_tool.defineTool)({
+  capability: "devtools",
+  schema: {
+    name: "browser_resume",
+    title: "Resume paused script execution",
+    description: "Resume script execution after it was paused. When called with step set to true, execution will pause again before the next action.",
+    inputSchema: import_mcpBundle.z.object({
+      step: import_mcpBundle.z.boolean().optional().describe("When true, execution will pause again before the next action, allowing step-by-step debugging."),
+      location: import_mcpBundle.z.string().optional().describe('Pause execution at a specific <file>:<line>, e.g. "example.spec.ts:42".')
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    const pausedPromise = new Promise((resolve) => {
+      const listener = () => {
+        if (browserContext.debugger.pausedDetails().length > 0) {
+          browserContext.debugger.off("pausedstatechanged", listener);
+          resolve();
+        }
+      };
+      browserContext.debugger.on("pausedstatechanged", listener);
+    });
+    if (params.location) {
+      const [file, lineStr] = params.location.split(":");
+      let location;
+      if (lineStr) {
+        const line = Number(lineStr);
+        if (isNaN(line))
+          throw new Error(`Invalid location "${params.location}", expected format is <file>:<line>, e.g. "example.spec.ts:42"`);
+        location = { file, line };
+      } else {
+        location = { file: params.location };
+      }
+      await browserContext.debugger.runTo(location);
+    } else if (params.step) {
+      await browserContext.debugger.next();
+    } else {
+      await browserContext.debugger.resume();
+    }
+    await pausedPromise;
+  }
+});
+var devtools_default = [resume];