@cotestdev/mcp_playwright 0.0.51 → 0.0.53

package/lib/mcp/terminal/commands.js

@@ -23,24 +23,53 @@ __export(commands_exports, {
 module.exports = __toCommonJS(commands_exports);
 var import_mcpBundle = require("../../mcpBundle");
 var import_command = require("./command");
+const numberArg = import_mcpBundle.z.preprocess((val, ctx) => {
+  const number = Number(val);
+  if (Number.isNaN(number)) {
+    ctx.issues.push({
+      code: "custom",
+      message: `expected number, received '${val}'`,
+      input: val
+    });
+  }
+  return number;
+}, import_mcpBundle.z.number());
 const open = (0, import_command.declareCommand)({
   name: "open",
-  description: "Open URL",
+  description: "Open the browser",
   category: "core",
   args: import_mcpBundle.z.object({
-    url: import_mcpBundle.z.string().describe("The URL to navigate to")
+    url: import_mcpBundle.z.string().optional().describe("The URL to navigate to")
+  }),
+  options: import_mcpBundle.z.object({
+    browser: import_mcpBundle.z.string().optional().describe("Browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge."),
+    config: import_mcpBundle.z.string().optional().describe("Path to the configuration file, defaults to .playwright/cli.config.json"),
+    extension: import_mcpBundle.z.boolean().optional().describe("Connect to browser extension"),
+    headed: import_mcpBundle.z.boolean().optional().describe("Run browser in headed mode"),
+    persistent: import_mcpBundle.z.boolean().optional().describe("Use persistent browser profile"),
+    profile: import_mcpBundle.z.string().optional().describe("Use persistent browser profile, store profile in specified directory.")
   }),
   toolName: "browser_navigate",
-  toolParams: ({ url }) => ({ url })
+  toolParams: ({ url }) => ({ url: url || "about:blank" })
 });
 const close = (0, import_command.declareCommand)({
   name: "close",
-  description: "Close the page",
+  description: "Close the browser",
   category: "core",
   args: import_mcpBundle.z.object({}),
   toolName: "",
   toolParams: () => ({})
 });
+const goto = (0, import_command.declareCommand)({
+  name: "goto",
+  description: "Navigate to a URL",
+  category: "core",
+  args: import_mcpBundle.z.object({
+    url: import_mcpBundle.z.string().describe("The URL to navigate to")
+  }),
+  toolName: "browser_navigate",
+  toolParams: ({ url }) => ({ url })
+});
 const goBack = (0, import_command.declareCommand)({
   name: "go-back",
   description: "Go back to the previous page",
@@ -113,8 +142,8 @@ const mouseMove = (0, import_command.declareCommand)({
   description: "Move mouse to a given position",
   category: "mouse",
   args: import_mcpBundle.z.object({
-    x: import_mcpBundle.z.number().describe("X coordinate"),
-    y: import_mcpBundle.z.number().describe("Y coordinate")
+    x: numberArg.describe("X coordinate"),
+    y: numberArg.describe("Y coordinate")
   }),
   toolName: "browser_mouse_move_xy",
   toolParams: ({ x, y }) => ({ x, y })
@@ -144,8 +173,8 @@ const mouseWheel = (0, import_command.declareCommand)({
   description: "Scroll mouse wheel",
   category: "mouse",
   args: import_mcpBundle.z.object({
-    dx: import_mcpBundle.z.number().describe("Y delta"),
-    dy: import_mcpBundle.z.number().describe("X delta")
+    dx: numberArg.describe("Y delta"),
+    dy: numberArg.describe("X delta")
   }),
   toolName: "browser_mouse_wheel",
   toolParams: ({ dx: deltaY, dy: deltaX }) => ({ deltaY, deltaX })
@@ -186,9 +215,6 @@ const drag = (0, import_command.declareCommand)({
     startRef: import_mcpBundle.z.string().describe("Exact source element reference from the page snapshot"),
     endRef: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
   }),
-  options: import_mcpBundle.z.object({
-    headed: import_mcpBundle.z.boolean().default(false).describe("Run browser in headed mode")
-  }),
   toolName: "browser_drag",
   toolParams: ({ startRef, endRef }) => ({ startRef, endRef })
 });
@@ -302,8 +328,8 @@ const resize = (0, import_command.declareCommand)({
   description: "Resize the browser window",
   category: "core",
   args: import_mcpBundle.z.object({
-    w: import_mcpBundle.z.number().describe("Width of the browser window"),
-    h: import_mcpBundle.z.number().describe("Height of the browser window")
+    w: numberArg.describe("Width of the browser window"),
+    h: numberArg.describe("Height of the browser window")
   }),
   toolName: "browser_resize",
   toolParams: ({ w: width, h: height }) => ({ width, height })
@@ -341,7 +367,7 @@ const tabClose = (0, import_command.declareCommand)({
   description: "Close a browser tab",
   category: "tabs",
   args: import_mcpBundle.z.object({
-    index: import_mcpBundle.z.number().optional().describe("Tab index. If omitted, current tab is closed.")
+    index: numberArg.optional().describe("Tab index. If omitted, current tab is closed.")
   }),
   toolName: "browser_tabs",
   toolParams: ({ index }) => ({ action: "close", index })
@@ -351,11 +377,226 @@ const tabSelect = (0, import_command.declareCommand)({
   description: "Select a browser tab",
   category: "tabs",
   args: import_mcpBundle.z.object({
-    index: import_mcpBundle.z.number().describe("Tab index")
+    index: numberArg.describe("Tab index")
   }),
   toolName: "browser_tabs",
   toolParams: ({ index }) => ({ action: "select", index })
 });
+const stateLoad = (0, import_command.declareCommand)({
+  name: "state-load",
+  description: "Loads browser storage (authentication) state from a file",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    filename: import_mcpBundle.z.string().describe("File name to load the storage state from.")
+  }),
+  toolName: "browser_set_storage_state",
+  toolParams: ({ filename }) => ({ filename })
+});
+const stateSave = (0, import_command.declareCommand)({
+  name: "state-save",
+  description: "Saves the current storage (authentication) state to a file",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    filename: import_mcpBundle.z.string().optional().describe("File name to save the storage state to.")
+  }),
+  toolName: "browser_storage_state",
+  toolParams: ({ filename }) => ({ filename })
+});
+const cookieList = (0, import_command.declareCommand)({
+  name: "cookie-list",
+  description: "List all cookies (optionally filtered by domain/path)",
+  category: "storage",
+  args: import_mcpBundle.z.object({}),
+  options: 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")
+  }),
+  toolName: "browser_cookie_list",
+  toolParams: ({ domain, path }) => ({ domain, path })
+});
+const cookieGet = (0, import_command.declareCommand)({
+  name: "cookie-get",
+  description: "Get a specific cookie by name",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    name: import_mcpBundle.z.string().describe("Cookie name")
+  }),
+  toolName: "browser_cookie_get",
+  toolParams: ({ name }) => ({ name })
+});
+const cookieSet = (0, import_command.declareCommand)({
+  name: "cookie-set",
+  description: "Set a cookie with optional flags",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    name: import_mcpBundle.z.string().describe("Cookie name"),
+    value: import_mcpBundle.z.string().describe("Cookie value")
+  }),
+  options: import_mcpBundle.z.object({
+    domain: import_mcpBundle.z.string().optional().describe("Cookie domain"),
+    path: import_mcpBundle.z.string().optional().describe("Cookie path"),
+    expires: numberArg.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")
+  }),
+  toolName: "browser_cookie_set",
+  toolParams: ({ name, value, domain, path, expires, httpOnly, secure, sameSite }) => ({ name, value, domain, path, expires, httpOnly, secure, sameSite })
+});
+const cookieDelete = (0, import_command.declareCommand)({
+  name: "cookie-delete",
+  description: "Delete a specific cookie",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    name: import_mcpBundle.z.string().describe("Cookie name")
+  }),
+  toolName: "browser_cookie_delete",
+  toolParams: ({ name }) => ({ name })
+});
+const cookieClear = (0, import_command.declareCommand)({
+  name: "cookie-clear",
+  description: "Clear all cookies",
+  category: "storage",
+  args: import_mcpBundle.z.object({}),
+  toolName: "browser_cookie_clear",
+  toolParams: () => ({})
+});
+const localStorageList = (0, import_command.declareCommand)({
+  name: "localstorage-list",
+  description: "List all localStorage key-value pairs",
+  category: "storage",
+  args: import_mcpBundle.z.object({}),
+  toolName: "browser_localstorage_list",
+  toolParams: () => ({})
+});
+const localStorageGet = (0, import_command.declareCommand)({
+  name: "localstorage-get",
+  description: "Get a localStorage item by key",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    key: import_mcpBundle.z.string().describe("Key to get")
+  }),
+  toolName: "browser_localstorage_get",
+  toolParams: ({ key }) => ({ key })
+});
+const localStorageSet = (0, import_command.declareCommand)({
+  name: "localstorage-set",
+  description: "Set a localStorage item",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    key: import_mcpBundle.z.string().describe("Key to set"),
+    value: import_mcpBundle.z.string().describe("Value to set")
+  }),
+  toolName: "browser_localstorage_set",
+  toolParams: ({ key, value }) => ({ key, value })
+});
+const localStorageDelete = (0, import_command.declareCommand)({
+  name: "localstorage-delete",
+  description: "Delete a localStorage item",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    key: import_mcpBundle.z.string().describe("Key to delete")
+  }),
+  toolName: "browser_localstorage_delete",
+  toolParams: ({ key }) => ({ key })
+});
+const localStorageClear = (0, import_command.declareCommand)({
+  name: "localstorage-clear",
+  description: "Clear all localStorage",
+  category: "storage",
+  args: import_mcpBundle.z.object({}),
+  toolName: "browser_localstorage_clear",
+  toolParams: () => ({})
+});
+const sessionStorageList = (0, import_command.declareCommand)({
+  name: "sessionstorage-list",
+  description: "List all sessionStorage key-value pairs",
+  category: "storage",
+  args: import_mcpBundle.z.object({}),
+  toolName: "browser_sessionstorage_list",
+  toolParams: () => ({})
+});
+const sessionStorageGet = (0, import_command.declareCommand)({
+  name: "sessionstorage-get",
+  description: "Get a sessionStorage item by key",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    key: import_mcpBundle.z.string().describe("Key to get")
+  }),
+  toolName: "browser_sessionstorage_get",
+  toolParams: ({ key }) => ({ key })
+});
+const sessionStorageSet = (0, import_command.declareCommand)({
+  name: "sessionstorage-set",
+  description: "Set a sessionStorage item",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    key: import_mcpBundle.z.string().describe("Key to set"),
+    value: import_mcpBundle.z.string().describe("Value to set")
+  }),
+  toolName: "browser_sessionstorage_set",
+  toolParams: ({ key, value }) => ({ key, value })
+});
+const sessionStorageDelete = (0, import_command.declareCommand)({
+  name: "sessionstorage-delete",
+  description: "Delete a sessionStorage item",
+  category: "storage",
+  args: import_mcpBundle.z.object({
+    key: import_mcpBundle.z.string().describe("Key to delete")
+  }),
+  toolName: "browser_sessionstorage_delete",
+  toolParams: ({ key }) => ({ key })
+});
+const sessionStorageClear = (0, import_command.declareCommand)({
+  name: "sessionstorage-clear",
+  description: "Clear all sessionStorage",
+  category: "storage",
+  args: import_mcpBundle.z.object({}),
+  toolName: "browser_sessionstorage_clear",
+  toolParams: () => ({})
+});
+const routeMock = (0, import_command.declareCommand)({
+  name: "route",
+  description: "Mock network requests matching a URL pattern",
+  category: "network",
+  args: import_mcpBundle.z.object({
+    pattern: import_mcpBundle.z.string().describe('URL pattern to match (e.g., "**/api/users")')
+  }),
+  options: import_mcpBundle.z.object({
+    status: numberArg.optional().describe("HTTP status code (default: 200)"),
+    body: import_mcpBundle.z.string().optional().describe("Response body (text or JSON string)"),
+    ["content-type"]: import_mcpBundle.z.string().optional().describe("Content-Type header"),
+    header: import_mcpBundle.z.union([import_mcpBundle.z.string(), import_mcpBundle.z.array(import_mcpBundle.z.string())]).optional().transform((v) => v ? Array.isArray(v) ? v : [v] : void 0).describe('Header to add in "Name: Value" format (repeatable)'),
+    ["remove-header"]: import_mcpBundle.z.string().optional().describe("Comma-separated header names to remove")
+  }),
+  toolName: "browser_route",
+  toolParams: ({ pattern, status, body, ["content-type"]: contentType, header: headers, ["remove-header"]: removeHeaders }) => ({
+    pattern,
+    status,
+    body,
+    contentType,
+    headers,
+    removeHeaders
+  })
+});
+const routeList = (0, import_command.declareCommand)({
+  name: "route-list",
+  description: "List all active network routes",
+  category: "network",
+  args: import_mcpBundle.z.object({}),
+  toolName: "browser_route_list",
+  toolParams: () => ({})
+});
+const unroute = (0, import_command.declareCommand)({
+  name: "unroute",
+  description: "Remove routes matching a pattern (or all routes)",
+  category: "network",
+  args: import_mcpBundle.z.object({
+    pattern: import_mcpBundle.z.string().optional().describe("URL pattern to unroute (omit to remove all)")
+  }),
+  toolName: "browser_unroute",
+  toolParams: ({ pattern }) => ({ pattern })
+});
 const screenshot = (0, import_command.declareCommand)({
   name: "screenshot",
   description: "screenshot of the current page or element",
@@ -441,54 +682,71 @@ const videoStop = (0, import_command.declareCommand)({
   toolParams: ({ filename }) => ({ filename })
 });
 const sessionList = (0, import_command.declareCommand)({
-  name: "session-list",
-  description: "List all sessions",
-  category: "session",
+  name: "list",
+  description: "List browser sessions",
+  category: "browsers",
   args: import_mcpBundle.z.object({}),
+  options: import_mcpBundle.z.object({
+    all: import_mcpBundle.z.boolean().optional().describe("List all browser sessions across all workspaces")
+  }),
   toolName: "",
   toolParams: () => ({})
 });
-const sessionStop = (0, import_command.declareCommand)({
-  name: "session-stop",
-  description: "Stop session",
-  category: "session",
-  args: import_mcpBundle.z.object({
-    name: import_mcpBundle.z.string().optional().describe("Name of the session to stop. If omitted, current session is stopped.")
-  }),
+const sessionCloseAll = (0, import_command.declareCommand)({
+  name: "close-all",
+  description: "Close all browser sessions",
+  category: "browsers",
   toolName: "",
   toolParams: () => ({})
 });
-const sessionStopAll = (0, import_command.declareCommand)({
-  name: "session-stop-all",
-  description: "Stop all sessions",
-  category: "session",
+const killAll = (0, import_command.declareCommand)({
+  name: "kill-all",
+  description: "Forcefully kill all browser sessions (for stale/zombie processes)",
+  category: "browsers",
   toolName: "",
   toolParams: () => ({})
 });
-const sessionDelete = (0, import_command.declareCommand)({
-  name: "session-delete",
+const deleteData = (0, import_command.declareCommand)({
+  name: "delete-data",
   description: "Delete session data",
-  category: "session",
-  args: import_mcpBundle.z.object({
-    name: import_mcpBundle.z.string().optional().describe("Name of the session to delete. If omitted, current session is deleted.")
-  }),
+  category: "core",
   toolName: "",
-  toolParams: ({ name }) => ({ name })
+  toolParams: () => ({})
 });
-const config = (0, import_command.declareCommand)({
-  name: "config",
-  description: "Restart session with new config, defaults to `playwright-cli.json`",
+const configPrint = (0, import_command.declareCommand)({
+  name: "config-print",
+  description: "Print the final resolved config after merging CLI options, environment variables and config file.",
   category: "config",
-  args: import_mcpBundle.z.object({
-    config: import_mcpBundle.z.string().optional().describe("Path to the configuration file")
+  hidden: true,
+  toolName: "browser_get_config",
+  toolParams: () => ({})
+});
+const install = (0, import_command.declareCommand)({
+  name: "install",
+  description: "Initialize workspace",
+  category: "install",
+  args: import_mcpBundle.z.object({}),
+  options: import_mcpBundle.z.object({
+    skills: import_mcpBundle.z.boolean().optional().describe("Install skills for Claude / GitHub Copilot")
   }),
   toolName: "",
   toolParams: () => ({})
 });
+const installBrowser = (0, import_command.declareCommand)({
+  name: "install-browser",
+  description: "Install browser",
+  category: "install",
+  options: import_mcpBundle.z.object({
+    browser: import_mcpBundle.z.string().optional().describe("Browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge")
+  }),
+  toolName: "browser_install",
+  toolParams: () => ({})
+});
 const commandsArray = [
   // core category
   open,
   close,
+  goto,
   type,
   click,
   doubleClick,
@@ -506,6 +764,7 @@ const commandsArray = [
   dialogDismiss,
   resize,
   runCode,
+  deleteData,
   // navigation category
   goBack,
   goForward,
@@ -527,8 +786,33 @@ const commandsArray = [
   tabNew,
   tabClose,
   tabSelect,
-  // config
-  config,
+  // storage category
+  stateLoad,
+  stateSave,
+  cookieList,
+  cookieGet,
+  cookieSet,
+  cookieDelete,
+  cookieClear,
+  localStorageList,
+  localStorageGet,
+  localStorageSet,
+  localStorageDelete,
+  localStorageClear,
+  sessionStorageList,
+  sessionStorageGet,
+  sessionStorageSet,
+  sessionStorageDelete,
+  sessionStorageClear,
+  // network category
+  routeMock,
+  routeList,
+  unroute,
+  // config category
+  configPrint,
+  // install category
+  install,
+  installBrowser,
   // devtools category
   networkRequests,
   tracingStart,
@@ -537,9 +821,8 @@ const commandsArray = [
   videoStop,
   // session category
   sessionList,
-  sessionStop,
-  sessionStopAll,
-  sessionDelete
+  sessionCloseAll,
+  killAll
 ];
 const commands = Object.fromEntries(commandsArray.map((cmd) => [cmd.name, cmd]));
 // Annotate the CommonJS export names for ESM import in node:

package/lib/mcp/terminal/daemon.js

@@ -38,6 +38,7 @@ var import_path = __toESM(require("path"));
 var import_url = __toESM(require("url"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var import_utils = require("playwright-core/lib/utils");
+var import_browserServerBackend = require("../browser/browserServerBackend");
 var import_socketConnection = require("./socketConnection");
 var import_commands = require("./commands");
 var import_command = require("./command");
@@ -51,7 +52,9 @@ async function socketExists(socketPath) {
   }
   return false;
 }
-async function startMcpDaemonServer(socketPath, serverBackendFactory, daemonVersion) {
+async function startMcpDaemonServer(config, contextFactory) {
+  const sessionConfig = config.sessionConfig;
+  const { socketPath, version } = sessionConfig;
   if (import_os.default.platform() !== "win32" && await socketExists(socketPath)) {
     daemonDebug(`Socket already exists, removing: ${socketPath}`);
     try {
@@ -61,37 +64,38 @@ async function startMcpDaemonServer(socketPath, serverBackendFactory, daemonVers
       throw error;
     }
   }
-  const backend = serverBackendFactory.create();
   const cwd = import_url.default.pathToFileURL(process.cwd()).href;
-  await backend.initialize?.({
+  const clientInfo = {
     name: "playwright-cli",
-    version: "1.0.0",
+    version: sessionConfig.version,
     roots: [{
       uri: cwd,
       name: "cwd"
     }],
     timestamp: Date.now()
+  };
+  const { browserContext, close } = await contextFactory.createContext(clientInfo, new AbortController().signal, {});
+  browserContext.on("close", () => {
+    daemonDebug("browser closed, shutting down daemon");
+    shutdown(0);
   });
+  const existingContextFactory = {
+    createContext: () => Promise.resolve({ browserContext, close })
+  };
+  const backend = new import_browserServerBackend.BrowserServerBackend(config, existingContextFactory, { allTools: true });
+  await backend.initialize?.(clientInfo);
   await import_promises.default.mkdir(import_path.default.dirname(socketPath), { recursive: true });
+  const shutdown = (exitCode) => {
+    daemonDebug(`shutting down daemon with exit code ${exitCode}`);
+    server.close();
+    (0, import_utils.gracefullyProcessExitDoNotHang)(exitCode);
+  };
   const server = import_net.default.createServer((socket) => {
     daemonDebug("new client connection");
-    const connection = new import_socketConnection.SocketConnection(socket, daemonVersion);
+    const connection = new import_socketConnection.SocketConnection(socket, version);
     connection.onclose = () => {
       daemonDebug("client disconnected");
     };
-    connection.onversionerror = (id, e) => {
-      if (daemonVersion === "undefined-for-test")
-        return false;
-      if (semverGreater(daemonVersion, e.received)) {
-        connection.send({ id, error: `Client is too old: daemon is ${daemonVersion}, client is ${e.received}.` }).catch((e2) => console.error(e2));
-      } else {
-        (0, import_utils.gracefullyProcessExitDoNotHang)(0, async () => {
-          await connection.send({ id, error: `Daemon is too old: daemon is ${daemonVersion}, client is ${e.received}. Stopping it.` }).catch((e2) => console.error(e2));
-          server.close();
-        });
-      }
-      return true;
-    };
     connection.onmessage = async (message) => {
       const { id, method, params } = message;
       try {
@@ -107,23 +111,18 @@ async function startMcpDaemonServer(socketPath, serverBackendFactory, daemonVers
           const { toolName, toolParams } = parseCliCommand(params.args);
           if (params.cwd)
             toolParams._meta = { cwd: params.cwd };
-          const response = await backend.callTool(toolName, toolParams, () => {
-          });
+          const response = await backend.callTool(toolName, toolParams);
           await connection.send({ id, result: formatResult(response) });
         } else {
           throw new Error(`Unknown method: ${method}`);
         }
       } catch (e) {
         daemonDebug("command failed", e);
-        await connection.send({ id, error: e.message });
+        const error = process.env.PWDEBUGIMPL ? e.stack || e.message : e.message;
+        await connection.send({ id, error });
       }
     };
   });
-  backend.onBrowserContextClosed = () => {
-    daemonDebug("browser closed, shutting down daemon");
-    server.close();
-    (0, import_utils.gracefullyProcessExitDoNotHang)(0);
-  };
   return new Promise((resolve, reject) => {
     server.on("error", (error) => {
       daemonDebug(`server error: ${error.message}`);
@@ -146,19 +145,6 @@ function parseCliCommand(args) {
     throw new Error("Command is required");
   return (0, import_command.parseCommand)(command, args);
 }
-function semverGreater(a, b) {
-  a = a.replace(/-next$/, "");
-  b = b.replace(/-next$/, "");
-  const aParts = a.split(".").map(Number);
-  const bParts = b.split(".").map(Number);
-  for (let i = 0; i < 4; i++) {
-    if (aParts[i] > bParts[i])
-      return true;
-    if (aParts[i] < bParts[i])
-      return false;
-  }
-  return false;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   startMcpDaemonServer

package/lib/mcp/terminal/helpGenerator.js

@@ -23,6 +23,7 @@ __export(helpGenerator_exports, {
   generateReadme: () => generateReadme
 });
 module.exports = __toCommonJS(helpGenerator_exports);
+var import_mcpBundle = require("../../mcpBundle");
 var import_commands = require("./commands");
 function commandArgs(command) {
   const args = [];
@@ -68,18 +69,24 @@ const categories = [
   { name: "export", title: "Save as" },
   { name: "tabs", title: "Tabs" },
   { name: "storage", title: "Storage" },
+  { name: "network", title: "Network" },
   { name: "devtools", title: "DevTools" },
+  { name: "install", title: "Install" },
   { name: "config", title: "Configuration" },
-  { name: "session", title: "Sessions" }
+  { name: "browsers", title: "Browser sessions" }
 ];
 function generateHelp() {
   const lines = [];
   lines.push("Usage: playwright-cli <command> [args] [options]");
+  lines.push("Usage: playwright-cli -s=<session> <command> [args] [options]");
   const commandsByCategory = /* @__PURE__ */ new Map();
   for (const c of categories)
     commandsByCategory.set(c.name, []);
-  for (const command of Object.values(import_commands.commands))
+  for (const command of Object.values(import_commands.commands)) {
+    if (command.hidden)
+      continue;
     commandsByCategory.get(command.category).push(command);
+  }
   for (const c of categories) {
     const cc = commandsByCategory.get(c.name);
     if (!cc.length)
@@ -90,11 +97,7 @@ ${c.title}:`);
       lines.push(generateHelpEntry(command));
   }
   lines.push("\nGlobal options:");
-  lines.push(formatWithGap("  --config <path>", "create a session with custom config, defaults to `playwright-cli.json`"));
-  lines.push(formatWithGap("  --extension", "connect to a running browser instance using Playwright MCP Bridge extension"));
-  lines.push(formatWithGap("  --headed", "create a headed session"));
   lines.push(formatWithGap("  --help [command]", "print help"));
-  lines.push(formatWithGap("  --session", "run command in the scope of a specific session"));
   lines.push(formatWithGap("  --version", "print version"));
   return lines.join("\n");
 }
@@ -132,12 +135,29 @@ function generateReadmeEntry(command) {
   const suffix = "# " + command.description.toLowerCase();
   return formatWithGap(prefix, suffix, 40);
 }
+function unwrapZodType(schema) {
+  if ("unwrap" in schema && typeof schema.unwrap === "function")
+    return unwrapZodType(schema.unwrap());
+  return schema;
+}
 function generateHelpJSON() {
+  const booleanOptions = /* @__PURE__ */ new Set();
+  for (const command of Object.values(import_commands.commands)) {
+    if (!command.options)
+      continue;
+    const optionsShape = command.options.shape;
+    for (const [name, schema] of Object.entries(optionsShape)) {
+      const innerSchema = unwrapZodType(schema);
+      if (innerSchema instanceof import_mcpBundle.z.ZodBoolean)
+        booleanOptions.add(name);
+    }
+  }
   const help = {
     global: generateHelp(),
     commands: Object.fromEntries(
       Object.entries(import_commands.commands).map(([name, command]) => [name, generateCommandHelp(command)])
-    )
+    ),
+    booleanOptions: [...booleanOptions]
   };
   return help;
 }