feat: Geutebruck GeViScope/GeViSoft Action Mapping System - MVP

This MVP release provides a complete full-stack solution for managing action mappings
in Geutebruck's GeViScope and GeViSoft video surveillance systems.

## Features

### Flutter Web Application (Port 8081)
- Modern, responsive UI for managing action mappings
- Action picker dialog with full parameter configuration
- Support for both GSC (GeViScope) and G-Core server actions
- Consistent UI for input and output actions with edit/delete capabilities
- Real-time action mapping creation, editing, and deletion
- Server categorization (GSC: prefix for GeViScope, G-Core: prefix for G-Core servers)

### FastAPI REST Backend (Port 8000)
- RESTful API for action mapping CRUD operations
- Action template service with comprehensive action catalog (247 actions)
- Server management (G-Core and GeViScope servers)
- Configuration tree reading and writing
- JWT authentication with role-based access control
- PostgreSQL database integration

### C# SDK Bridge (gRPC, Port 50051)
- Native integration with GeViSoft SDK (GeViProcAPINET_4_0.dll)
- Action mapping creation with correct binary format
- Support for GSC and G-Core action types
- Proper Camera parameter inclusion in action strings (fixes CrossSwitch bug)
- Action ID lookup table with server-specific action IDs
- Configuration reading/writing via SetupClient

## Bug Fixes
- **CrossSwitch Bug**: GSC and G-Core actions now correctly display camera/PTZ head parameters in GeViSet
- Action strings now include Camera parameter: `@ PanLeft (Comment: "", Camera: 101028)`
- Proper filter flags and VideoInput=0 for action mappings
- Correct action ID assignment (4198 for GSC, 9294 for G-Core PanLeft)

## Technical Stack
- **Frontend**: Flutter Web, Dart, Dio HTTP client
- **Backend**: Python FastAPI, PostgreSQL, Redis
- **SDK Bridge**: C# .NET 8.0, gRPC, GeViSoft SDK
- **Authentication**: JWT tokens
- **Configuration**: GeViSoft .set files (binary format)

## Credentials
- GeViSoft/GeViScope: username=sysadmin, password=masterkey
- Default admin: username=admin, password=admin123

## Deployment
All services run on localhost:
- Flutter Web: http://localhost:8081
- FastAPI: http://localhost:8000
- SDK Bridge gRPC: localhost:50051
- GeViServer: localhost (default port)

Generated with Claude Code (https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/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_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const close = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_close",
+    title: "Close browser",
+    description: "Close the page",
+    inputSchema: import_bundle.z.object({}),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    await context.closeBrowserContext();
+    response.setIncludeTabs();
+    response.addCode(`await page.close()`);
+  }
+});
+const resize = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_resize",
+    title: "Resize browser window",
+    description: "Resize the browser window",
+    inputSchema: import_bundle.z.object({
+      width: import_bundle.z.number().describe("Width of the browser window"),
+      height: import_bundle.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.waitForCompletion(async () => {
+      await tab.page.setViewportSize({ width: params.width, height: params.height });
+    });
+  }
+});
+var common_default = [
+  close,
+  resize
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/console.js

@@ -0,0 +1,44 @@
+"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_bundle = require("../../sdk/bundle");
+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_bundle.z.object({
+      onlyErrors: import_bundle.z.boolean().optional().describe("Only return error messages")
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const messages = await tab.consoleMessages(params.onlyErrors ? "error" : void 0);
+    messages.map((message) => response.addResult(message.toString()));
+  }
+});
+var console_default = [
+  console
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/dialogs.js

@@ -0,0 +1,60 @@
+"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 dialogs_exports = {};
+__export(dialogs_exports, {
+  default: () => dialogs_default,
+  handleDialog: () => handleDialog
+});
+module.exports = __toCommonJS(dialogs_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const handleDialog = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_handle_dialog",
+    title: "Handle a dialog",
+    description: "Handle a dialog",
+    inputSchema: import_bundle.z.object({
+      accept: import_bundle.z.boolean().describe("Whether to accept the dialog."),
+      promptText: import_bundle.z.string().optional().describe("The text of the prompt in case of a prompt dialog.")
+    }),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const dialogState = tab.modalStates().find((state) => state.type === "dialog");
+    if (!dialogState)
+      throw new Error("No dialog visible");
+    tab.clearModalState(dialogState);
+    await tab.waitForCompletion(async () => {
+      if (params.accept)
+        await dialogState.dialog.accept(params.promptText);
+      else
+        await dialogState.dialog.dismiss();
+    });
+  },
+  clearsModalState: "dialog"
+});
+var dialogs_default = [
+  handleDialog
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleDialog
+});

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/evaluate.js

@@ -0,0 +1,69 @@
+"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 evaluate_exports = {};
+__export(evaluate_exports, {
+  default: () => evaluate_default
+});
+module.exports = __toCommonJS(evaluate_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+var javascript = __toESM(require("../codegen"));
+const evaluateSchema = import_bundle.z.object({
+  function: import_bundle.z.string().describe("() => { /* code */ } or (element) => { /* code */ } when element is provided"),
+  element: import_bundle.z.string().optional().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: import_bundle.z.string().optional().describe("Exact target element reference from the page snapshot")
+});
+const evaluate = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_evaluate",
+    title: "Evaluate JavaScript",
+    description: "Evaluate JavaScript expression on page or element",
+    inputSchema: evaluateSchema,
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    let locator;
+    if (params.ref && params.element) {
+      locator = await tab.refLocator({ ref: params.ref, element: params.element });
+      response.addCode(`await page.${locator.resolved}.evaluate(${javascript.quote(params.function)});`);
+    } else {
+      response.addCode(`await page.evaluate(${javascript.quote(params.function)});`);
+    }
+    await tab.waitForCompletion(async () => {
+      const receiver = locator?.locator ?? tab.page;
+      const result = await receiver._evaluateFunction(params.function);
+      response.addResult(JSON.stringify(result, null, 2) || "undefined");
+    });
+  }
+});
+var evaluate_default = [
+  evaluate
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/files.js

@@ -0,0 +1,58 @@
+"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 files_exports = {};
+__export(files_exports, {
+  default: () => files_default,
+  uploadFile: () => uploadFile
+});
+module.exports = __toCommonJS(files_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const uploadFile = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_file_upload",
+    title: "Upload files",
+    description: "Upload one or multiple files",
+    inputSchema: import_bundle.z.object({
+      paths: import_bundle.z.array(import_bundle.z.string()).optional().describe("The absolute paths to the files to upload. Can be single file or multiple files. If omitted, file chooser is cancelled.")
+    }),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const modalState = tab.modalStates().find((state) => state.type === "fileChooser");
+    if (!modalState)
+      throw new Error("No file chooser visible");
+    response.addCode(`await fileChooser.setFiles(${JSON.stringify(params.paths)})`);
+    tab.clearModalState(modalState);
+    await tab.waitForCompletion(async () => {
+      if (params.paths)
+        await modalState.fileChooser.setFiles(params.paths);
+    });
+  },
+  clearsModalState: "fileChooser"
+});
+var files_default = [
+  uploadFile
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uploadFile
+});

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/form.js

@@ -0,0 +1,73 @@
+"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 form_exports = {};
+__export(form_exports, {
+  default: () => form_default
+});
+module.exports = __toCommonJS(form_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+var codegen = __toESM(require("../codegen"));
+const fillForm = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_fill_form",
+    title: "Fill form",
+    description: "Fill multiple form fields",
+    inputSchema: import_bundle.z.object({
+      fields: import_bundle.z.array(import_bundle.z.object({
+        name: import_bundle.z.string().describe("Human-readable field name"),
+        type: import_bundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the field"),
+        ref: import_bundle.z.string().describe("Exact target field reference from the page snapshot"),
+        value: import_bundle.z.string().describe("Value to fill in the field. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.")
+      })).describe("Fields to fill in")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    for (const field of params.fields) {
+      const { locator, resolved } = await tab.refLocator({ element: field.name, ref: field.ref });
+      const locatorSource = `await page.${resolved}`;
+      if (field.type === "textbox" || field.type === "slider") {
+        const secret = tab.context.lookupSecret(field.value);
+        await locator.fill(secret.value);
+        response.addCode(`${locatorSource}.fill(${secret.code});`);
+      } else if (field.type === "checkbox" || field.type === "radio") {
+        await locator.setChecked(field.value === "true");
+        response.addCode(`${locatorSource}.setChecked(${field.value});`);
+      } else if (field.type === "combobox") {
+        await locator.selectOption({ label: field.value });
+        response.addCode(`${locatorSource}.selectOption(${codegen.quote(field.value)});`);
+      }
+    }
+  }
+});
+var form_default = [
+  fillForm
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/install.js

@@ -0,0 +1,69 @@
+"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 install_exports = {};
+__export(install_exports, {
+  default: () => install_default
+});
+module.exports = __toCommonJS(install_exports);
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"));
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const install = (0, import_tool.defineTool)({
+  capability: "core-install",
+  schema: {
+    name: "browser_install",
+    title: "Install the browser specified in the config",
+    description: "Install the browser specified in the config. Call this if you get an error about the browser not being installed.",
+    inputSchema: import_bundle.z.object({}),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const channel = context.config.browser?.launchOptions?.channel ?? context.config.browser?.browserName ?? "chrome";
+    const cliPath = import_path.default.join(require.resolve("playwright/package.json"), "../cli.js");
+    const child = (0, import_child_process.fork)(cliPath, ["install", channel], {
+      stdio: "pipe"
+    });
+    const output = [];
+    child.stdout?.on("data", (data) => output.push(data.toString()));
+    child.stderr?.on("data", (data) => output.push(data.toString()));
+    await new Promise((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code === 0)
+          resolve();
+        else
+          reject(new Error(`Failed to install browser: ${output.join("")}`));
+      });
+    });
+    response.setIncludeTabs();
+  }
+});
+var install_default = [
+  install
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/keyboard.js

@@ -0,0 +1,84 @@
+"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 keyboard_exports = {};
+__export(keyboard_exports, {
+  default: () => keyboard_default
+});
+module.exports = __toCommonJS(keyboard_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+var import_snapshot = require("./snapshot");
+const pressKey = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_press_key",
+    title: "Press a key",
+    description: "Press a key on the keyboard",
+    inputSchema: import_bundle.z.object({
+      key: import_bundle.z.string().describe("Name of the key to press or a character to generate, such as `ArrowLeft` or `a`")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    response.addCode(`// Press ${params.key}`);
+    response.addCode(`await page.keyboard.press('${params.key}');`);
+    await tab.waitForCompletion(async () => {
+      await tab.page.keyboard.press(params.key);
+    });
+  }
+});
+const typeSchema = import_snapshot.elementSchema.extend({
+  text: import_bundle.z.string().describe("Text to type into the element"),
+  submit: import_bundle.z.boolean().optional().describe("Whether to submit entered text (press Enter after)"),
+  slowly: import_bundle.z.boolean().optional().describe("Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.")
+});
+const type = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_type",
+    title: "Type text",
+    description: "Type text into editable element",
+    inputSchema: typeSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    const { locator, resolved } = await tab.refLocator(params);
+    const secret = tab.context.lookupSecret(params.text);
+    await tab.waitForCompletion(async () => {
+      if (params.slowly) {
+        response.setIncludeSnapshot();
+        response.addCode(`await page.${resolved}.pressSequentially(${secret.code});`);
+        await locator.pressSequentially(secret.value);
+      } else {
+        response.addCode(`await page.${resolved}.fill(${secret.code});`);
+        await locator.fill(secret.value);
+      }
+      if (params.submit) {
+        response.setIncludeSnapshot();
+        response.addCode(`await page.${resolved}.press('Enter');`);
+        await locator.press("Enter");
+      }
+    });
+  }
+});
+var keyboard_default = [
+  pressKey,
+  type
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/mouse.js

@@ -0,0 +1,107 @@
+"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 mouse_exports = {};
+__export(mouse_exports, {
+  default: () => mouse_default
+});
+module.exports = __toCommonJS(mouse_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const elementSchema = import_bundle.z.object({
+  element: import_bundle.z.string().describe("Human-readable element description used to obtain permission to interact with the element")
+});
+const mouseMove = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_move_xy",
+    title: "Move mouse",
+    description: "Move mouse to a given position",
+    inputSchema: elementSchema.extend({
+      x: import_bundle.z.number().describe("X coordinate"),
+      y: import_bundle.z.number().describe("Y coordinate")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`// Move mouse to (${params.x}, ${params.y})`);
+    response.addCode(`await page.mouse.move(${params.x}, ${params.y});`);
+    await tab.waitForCompletion(async () => {
+      await tab.page.mouse.move(params.x, params.y);
+    });
+  }
+});
+const mouseClick = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_click_xy",
+    title: "Click",
+    description: "Click left mouse button at a given position",
+    inputSchema: elementSchema.extend({
+      x: import_bundle.z.number().describe("X coordinate"),
+      y: import_bundle.z.number().describe("Y coordinate")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    response.addCode(`// Click mouse at coordinates (${params.x}, ${params.y})`);
+    response.addCode(`await page.mouse.move(${params.x}, ${params.y});`);
+    response.addCode(`await page.mouse.down();`);
+    response.addCode(`await page.mouse.up();`);
+    await tab.waitForCompletion(async () => {
+      await tab.page.mouse.move(params.x, params.y);
+      await tab.page.mouse.down();
+      await tab.page.mouse.up();
+    });
+  }
+});
+const mouseDrag = (0, import_tool.defineTabTool)({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_drag_xy",
+    title: "Drag mouse",
+    description: "Drag left mouse button to a given position",
+    inputSchema: elementSchema.extend({
+      startX: import_bundle.z.number().describe("Start X coordinate"),
+      startY: import_bundle.z.number().describe("Start Y coordinate"),
+      endX: import_bundle.z.number().describe("End X coordinate"),
+      endY: import_bundle.z.number().describe("End Y coordinate")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    response.addCode(`// Drag mouse from (${params.startX}, ${params.startY}) to (${params.endX}, ${params.endY})`);
+    response.addCode(`await page.mouse.move(${params.startX}, ${params.startY});`);
+    response.addCode(`await page.mouse.down();`);
+    response.addCode(`await page.mouse.move(${params.endX}, ${params.endY});`);
+    response.addCode(`await page.mouse.up();`);
+    await tab.waitForCompletion(async () => {
+      await tab.page.mouse.move(params.startX, params.startY);
+      await tab.page.mouse.down();
+      await tab.page.mouse.move(params.endX, params.endY);
+      await tab.page.mouse.up();
+    });
+  }
+});
+var mouse_default = [
+  mouseMove,
+  mouseClick,
+  mouseDrag
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/navigate.js

@@ -0,0 +1,62 @@
+"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 navigate_exports = {};
+__export(navigate_exports, {
+  default: () => navigate_default
+});
+module.exports = __toCommonJS(navigate_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const navigate = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_navigate",
+    title: "Navigate to a URL",
+    description: "Navigate to a URL",
+    inputSchema: import_bundle.z.object({
+      url: import_bundle.z.string().describe("The URL to navigate to")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const tab = await context.ensureTab();
+    await tab.navigate(params.url);
+    response.setIncludeSnapshot();
+    response.addCode(`await page.goto('${params.url}');`);
+  }
+});
+const goBack = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_navigate_back",
+    title: "Go back",
+    description: "Go back to the previous page",
+    inputSchema: import_bundle.z.object({}),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    await tab.page.goBack();
+    response.setIncludeSnapshot();
+    response.addCode(`await page.goBack();`);
+  }
+});
+var navigate_default = [
+  navigate,
+  goBack
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/network.js

@@ -0,0 +1,54 @@
+"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 network_exports = {};
+__export(network_exports, {
+  default: () => network_default
+});
+module.exports = __toCommonJS(network_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const requests = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_network_requests",
+    title: "List network requests",
+    description: "Returns all network requests since loading the page",
+    inputSchema: import_bundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const requests2 = await tab.requests();
+    for (const request of requests2)
+      response.addResult(await renderRequest(request));
+  }
+});
+async function renderRequest(request) {
+  const result = [];
+  result.push(`[${request.method().toUpperCase()}] ${request.url()}`);
+  const hasResponse = request._hasResponse;
+  if (hasResponse) {
+    const response = await request.response();
+    if (response)
+      result.push(`=> [${response.status()}] ${response.statusText()}`);
+  }
+  return result.join(" ");
+}
+var network_default = [
+  requests
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/pdf.js

@@ -0,0 +1,59 @@
+"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 pdf_exports = {};
+__export(pdf_exports, {
+  default: () => pdf_default
+});
+module.exports = __toCommonJS(pdf_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+var javascript = __toESM(require("../codegen"));
+var import_utils = require("./utils");
+const pdfSchema = import_bundle.z.object({
+  filename: import_bundle.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.")
+});
+const pdf = (0, import_tool.defineTabTool)({
+  capability: "pdf",
+  schema: {
+    name: "browser_pdf_save",
+    title: "Save as PDF",
+    description: "Save page as PDF",
+    inputSchema: pdfSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const fileName = await tab.context.outputFile(params.filename ?? (0, import_utils.dateAsFileName)("pdf"), { origin: "llm", reason: "Saving PDF" });
+    response.addCode(`await page.pdf(${javascript.formatObject({ path: fileName })});`);
+    response.addResult(`Saved page as ${fileName}`);
+    await tab.page.pdf({ path: fileName });
+  }
+});
+var pdf_default = [
+  pdf
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/runCode.js

@@ -0,0 +1,75 @@
+"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 runCode_exports = {};
+__export(runCode_exports, {
+  default: () => runCode_default
+});
+module.exports = __toCommonJS(runCode_exports);
+var import_vm = __toESM(require("vm"));
+var import_utils = require("playwright-core/lib/utils");
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const codeSchema = import_bundle.z.object({
+  code: import_bundle.z.string().describe(`Playwright code snippet to run. The snippet should access the \`page\` object to interact with the page. Can make multiple statements. For example: \`await page.getByRole('button', { name: 'Submit' }).click();\``)
+});
+const runCode = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_run_code",
+    title: "Run Playwright code",
+    description: "Run Playwright code snippet",
+    inputSchema: codeSchema,
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    response.addCode(params.code);
+    const __end__ = new import_utils.ManualPromise();
+    const context = {
+      page: tab.page,
+      __end__
+    };
+    import_vm.default.createContext(context);
+    await tab.waitForCompletion(async () => {
+      const snippet = `(async () => {
+        try {
+          ${params.code};
+          __end__.resolve();
+        } catch (e) {
+          __end__.reject(e);
+        }
+      })()`;
+      import_vm.default.runInContext(snippet, context);
+      await __end__;
+    });
+  }
+});
+var runCode_default = [
+  runCode
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/screenshot.js

@@ -0,0 +1,106 @@
+"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 screenshot_exports = {};
+__export(screenshot_exports, {
+  default: () => screenshot_default,
+  scaleImageToFitMessage: () => scaleImageToFitMessage
+});
+module.exports = __toCommonJS(screenshot_exports);
+var import_fs = __toESM(require("fs"));
+var import_utils = require("playwright-core/lib/utils");
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+var javascript = __toESM(require("../codegen"));
+var import_utils2 = require("./utils");
+const screenshotSchema = import_bundle.z.object({
+  type: import_bundle.z.enum(["png", "jpeg"]).default("png").describe("Image format for the screenshot. Default is png."),
+  filename: import_bundle.z.string().optional().describe("File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified. Prefer relative file names to stay within the output directory."),
+  element: import_bundle.z.string().optional().describe("Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too."),
+  ref: import_bundle.z.string().optional().describe("Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too."),
+  fullPage: import_bundle.z.boolean().optional().describe("When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots.")
+});
+const screenshot = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_take_screenshot",
+    title: "Take a screenshot",
+    description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
+    inputSchema: screenshotSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    if (!!params.element !== !!params.ref)
+      throw new Error("Both element and ref must be provided or neither.");
+    if (params.fullPage && params.ref)
+      throw new Error("fullPage cannot be used with element screenshots.");
+    const fileType = params.type || "png";
+    const fileName = await tab.context.outputFile(params.filename || (0, import_utils2.dateAsFileName)(fileType), { origin: "llm", reason: "Saving screenshot" });
+    const options = {
+      type: fileType,
+      quality: fileType === "png" ? void 0 : 90,
+      scale: "css",
+      ...params.fullPage !== void 0 && { fullPage: params.fullPage }
+    };
+    const isElementScreenshot = params.element && params.ref;
+    const screenshotTarget = isElementScreenshot ? params.element : params.fullPage ? "full page" : "viewport";
+    response.addCode(`// Screenshot ${screenshotTarget} and save it as ${fileName}`);
+    const ref = params.ref ? await tab.refLocator({ element: params.element || "", ref: params.ref }) : null;
+    if (ref)
+      response.addCode(`await page.${ref.resolved}.screenshot(${javascript.formatObject(options)});`);
+    else
+      response.addCode(`await page.screenshot(${javascript.formatObject(options)});`);
+    const buffer = ref ? await ref.locator.screenshot(options) : await tab.page.screenshot(options);
+    await (0, import_utils.mkdirIfNeeded)(fileName);
+    await import_fs.default.promises.writeFile(fileName, buffer);
+    response.addResult(`Took the ${screenshotTarget} screenshot and saved it as ${fileName}`);
+    response.addImage({
+      contentType: fileType === "png" ? "image/png" : "image/jpeg",
+      data: scaleImageToFitMessage(buffer, fileType)
+    });
+  }
+});
+function scaleImageToFitMessage(buffer, imageType) {
+  const image = imageType === "png" ? import_utilsBundle.PNG.sync.read(buffer) : import_utilsBundle.jpegjs.decode(buffer, { maxMemoryUsageInMB: 512 });
+  const pixels = image.width * image.height;
+  const shrink = Math.min(1568 / image.width, 1568 / image.height, Math.sqrt(1.15 * 1024 * 1024 / pixels));
+  if (shrink > 1)
+    return buffer;
+  const width = image.width * shrink | 0;
+  const height = image.height * shrink | 0;
+  const scaledImage = (0, import_utils.scaleImageToSize)(image, { width, height });
+  return imageType === "png" ? import_utilsBundle.PNG.sync.write(scaledImage) : import_utilsBundle.jpegjs.encode(scaledImage, 80).data;
+}
+var screenshot_default = [
+  screenshot
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  scaleImageToFitMessage
+});

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/snapshot.js

@@ -0,0 +1,181 @@
+"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 snapshot_exports = {};
+__export(snapshot_exports, {
+  default: () => snapshot_default,
+  elementSchema: () => elementSchema
+});
+module.exports = __toCommonJS(snapshot_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+var javascript = __toESM(require("../codegen"));
+const snapshot = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_snapshot",
+    title: "Page snapshot",
+    description: "Capture accessibility snapshot of the current page, this is better than screenshot",
+    inputSchema: import_bundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    await context.ensureTab();
+    response.setIncludeSnapshot("full");
+  }
+});
+const elementSchema = import_bundle.z.object({
+  element: import_bundle.z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: import_bundle.z.string().describe("Exact target element reference from the page snapshot")
+});
+const clickSchema = elementSchema.extend({
+  doubleClick: import_bundle.z.boolean().optional().describe("Whether to perform a double click instead of a single click"),
+  button: import_bundle.z.enum(["left", "right", "middle"]).optional().describe("Button to click, defaults to left"),
+  modifiers: import_bundle.z.array(import_bundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
+});
+const click = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_click",
+    title: "Click",
+    description: "Perform click on a web page",
+    inputSchema: clickSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const { locator, resolved } = await tab.refLocator(params);
+    const options = {
+      button: params.button,
+      modifiers: params.modifiers
+    };
+    const formatted = javascript.formatObject(options, " ", "oneline");
+    const optionsAttr = formatted !== "{}" ? formatted : "";
+    if (params.doubleClick)
+      response.addCode(`await page.${resolved}.dblclick(${optionsAttr});`);
+    else
+      response.addCode(`await page.${resolved}.click(${optionsAttr});`);
+    await tab.waitForCompletion(async () => {
+      if (params.doubleClick)
+        await locator.dblclick(options);
+      else
+        await locator.click(options);
+    });
+  }
+});
+const drag = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_drag",
+    title: "Drag mouse",
+    description: "Perform drag and drop between two elements",
+    inputSchema: import_bundle.z.object({
+      startElement: import_bundle.z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
+      startRef: import_bundle.z.string().describe("Exact source element reference from the page snapshot"),
+      endElement: import_bundle.z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
+      endRef: import_bundle.z.string().describe("Exact target element reference from the page snapshot")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const [start, end] = await tab.refLocators([
+      { ref: params.startRef, element: params.startElement },
+      { ref: params.endRef, element: params.endElement }
+    ]);
+    await tab.waitForCompletion(async () => {
+      await start.locator.dragTo(end.locator);
+    });
+    response.addCode(`await page.${start.resolved}.dragTo(page.${end.resolved});`);
+  }
+});
+const hover = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_hover",
+    title: "Hover mouse",
+    description: "Hover over element on page",
+    inputSchema: elementSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const { locator, resolved } = await tab.refLocator(params);
+    response.addCode(`await page.${resolved}.hover();`);
+    await tab.waitForCompletion(async () => {
+      await locator.hover();
+    });
+  }
+});
+const selectOptionSchema = elementSchema.extend({
+  values: import_bundle.z.array(import_bundle.z.string()).describe("Array of values to select in the dropdown. This can be a single value or multiple values.")
+});
+const selectOption = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_select_option",
+    title: "Select option",
+    description: "Select an option in a dropdown",
+    inputSchema: selectOptionSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const { locator, resolved } = await tab.refLocator(params);
+    response.addCode(`await page.${resolved}.selectOption(${javascript.formatObject(params.values)});`);
+    await tab.waitForCompletion(async () => {
+      await locator.selectOption(params.values);
+    });
+  }
+});
+const pickLocator = (0, import_tool.defineTabTool)({
+  capability: "testing",
+  schema: {
+    name: "browser_generate_locator",
+    title: "Create locator for element",
+    description: "Generate locator for the given element to use in tests",
+    inputSchema: elementSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const { resolved } = await tab.refLocator(params);
+    response.addResult(resolved);
+  }
+});
+var snapshot_default = [
+  snapshot,
+  click,
+  drag,
+  hover,
+  selectOption,
+  pickLocator
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  elementSchema
+});

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/tabs.js

@@ -0,0 +1,67 @@
+"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 tabs_exports = {};
+__export(tabs_exports, {
+  default: () => tabs_default
+});
+module.exports = __toCommonJS(tabs_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const browserTabs = (0, import_tool.defineTool)({
+  capability: "core-tabs",
+  schema: {
+    name: "browser_tabs",
+    title: "Manage tabs",
+    description: "List, create, close, or select a browser tab.",
+    inputSchema: import_bundle.z.object({
+      action: import_bundle.z.enum(["list", "new", "close", "select"]).describe("Operation to perform"),
+      index: import_bundle.z.number().optional().describe("Tab index, used for close/select. If omitted for close, current tab is closed.")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    switch (params.action) {
+      case "list": {
+        await context.ensureTab();
+        response.setIncludeTabs();
+        return;
+      }
+      case "new": {
+        await context.newTab();
+        response.setIncludeTabs();
+        return;
+      }
+      case "close": {
+        await context.closeTab(params.index);
+        response.setIncludeSnapshot("full");
+        return;
+      }
+      case "select": {
+        if (params.index === void 0)
+          throw new Error("Tab index is required");
+        await context.selectTab(params.index);
+        response.setIncludeSnapshot("full");
+        return;
+      }
+    }
+  }
+});
+var tabs_default = [
+  browserTabs
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/tool.js

@@ -0,0 +1,49 @@
+"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 tool_exports = {};
+__export(tool_exports, {
+  defineTabTool: () => defineTabTool,
+  defineTool: () => defineTool
+});
+module.exports = __toCommonJS(tool_exports);
+function defineTool(tool) {
+  return tool;
+}
+function defineTabTool(tool) {
+  return {
+    ...tool,
+    handle: async (context, params, response) => {
+      const tab = await context.ensureTab();
+      const modalStates = tab.modalStates().map((state) => state.type);
+      if (tool.clearsModalState && !modalStates.includes(tool.clearsModalState))
+        response.addError(`Error: The tool "${tool.schema.name}" can only be used when there is related modal state present.
+` + tab.modalStatesMarkdown().join("\n"));
+      else if (!tool.clearsModalState && modalStates.length)
+        response.addError(`Error: Tool "${tool.schema.name}" does not handle the modal state.
+` + tab.modalStatesMarkdown().join("\n"));
+      else
+        return tool.handle(tab, params, response);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineTabTool,
+  defineTool
+});

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/tracing.js

@@ -0,0 +1,74 @@
+"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 tracing_exports = {};
+__export(tracing_exports, {
+  default: () => tracing_default
+});
+module.exports = __toCommonJS(tracing_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const tracingStart = (0, import_tool.defineTool)({
+  capability: "tracing",
+  schema: {
+    name: "browser_start_tracing",
+    title: "Start tracing",
+    description: "Start trace recording",
+    inputSchema: import_bundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    const tracesDir = await context.outputFile(`traces`, { origin: "code", reason: "Collecting trace" });
+    const name = "trace-" + Date.now();
+    await browserContext.tracing.start({
+      name,
+      screenshots: true,
+      snapshots: true,
+      _live: true
+    });
+    const traceLegend = `- Action log: ${tracesDir}/${name}.trace
+- Network log: ${tracesDir}/${name}.network
+- Resources with content by sha1: ${tracesDir}/resources`;
+    response.addResult(`Tracing started, saving to ${tracesDir}.
+${traceLegend}`);
+    browserContext.tracing[traceLegendSymbol] = traceLegend;
+  }
+});
+const tracingStop = (0, import_tool.defineTool)({
+  capability: "tracing",
+  schema: {
+    name: "browser_stop_tracing",
+    title: "Stop tracing",
+    description: "Stop trace recording",
+    inputSchema: import_bundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    await browserContext.tracing.stop();
+    const traceLegend = browserContext.tracing[traceLegendSymbol];
+    response.addResult(`Tracing stopped.
+${traceLegend}`);
+  }
+});
+var tracing_default = [
+  tracingStart,
+  tracingStop
+];
+const traceLegendSymbol = Symbol("tracesDir");

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/utils.js

@@ -0,0 +1,89 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  callOnPageNoTrace: () => callOnPageNoTrace,
+  dateAsFileName: () => dateAsFileName,
+  waitForCompletion: () => waitForCompletion
+});
+module.exports = __toCommonJS(utils_exports);
+async function waitForCompletion(tab, callback) {
+  const requests = /* @__PURE__ */ new Set();
+  let frameNavigated = false;
+  let waitCallback = () => {
+  };
+  const waitBarrier = new Promise((f) => {
+    waitCallback = f;
+  });
+  const responseListener = (request) => {
+    requests.delete(request);
+    if (!requests.size)
+      waitCallback();
+  };
+  const requestListener = (request) => {
+    requests.add(request);
+    void request.response().then(() => responseListener(request)).catch(() => {
+    });
+  };
+  const frameNavigateListener = (frame) => {
+    if (frame.parentFrame())
+      return;
+    frameNavigated = true;
+    dispose();
+    clearTimeout(timeout);
+    void tab.waitForLoadState("load").then(waitCallback);
+  };
+  const onTimeout = () => {
+    dispose();
+    waitCallback();
+  };
+  tab.page.on("request", requestListener);
+  tab.page.on("requestfailed", responseListener);
+  tab.page.on("framenavigated", frameNavigateListener);
+  const timeout = setTimeout(onTimeout, 1e4);
+  const dispose = () => {
+    tab.page.off("request", requestListener);
+    tab.page.off("requestfailed", responseListener);
+    tab.page.off("framenavigated", frameNavigateListener);
+    clearTimeout(timeout);
+  };
+  try {
+    const result = await callback();
+    if (!requests.size && !frameNavigated)
+      waitCallback();
+    await waitBarrier;
+    await tab.waitForTimeout(1e3);
+    return result;
+  } finally {
+    dispose();
+  }
+}
+async function callOnPageNoTrace(page, callback) {
+  return await page._wrapApiCall(() => callback(page), { internal: true });
+}
+function dateAsFileName(extension) {
+  const date = /* @__PURE__ */ new Date();
+  return `page-${date.toISOString().replace(/[:.]/g, "-")}.${extension}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callOnPageNoTrace,
+  dateAsFileName,
+  waitForCompletion
+});

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/verify.js

@@ -0,0 +1,153 @@
+"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 verify_exports = {};
+__export(verify_exports, {
+  default: () => verify_default
+});
+module.exports = __toCommonJS(verify_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+var javascript = __toESM(require("../codegen"));
+const verifyElement = (0, import_tool.defineTabTool)({
+  capability: "testing",
+  schema: {
+    name: "browser_verify_element_visible",
+    title: "Verify element visible",
+    description: "Verify element is visible on the page",
+    inputSchema: import_bundle.z.object({
+      role: import_bundle.z.string().describe('ROLE of the element. Can be found in the snapshot like this: `- {ROLE} "Accessible Name":`'),
+      accessibleName: import_bundle.z.string().describe('ACCESSIBLE_NAME of the element. Can be found in the snapshot like this: `- role "{ACCESSIBLE_NAME}"`')
+    }),
+    type: "assertion"
+  },
+  handle: async (tab, params, response) => {
+    const locator = tab.page.getByRole(params.role, { name: params.accessibleName });
+    if (await locator.count() === 0) {
+      response.addError(`Element with role "${params.role}" and accessible name "${params.accessibleName}" not found`);
+      return;
+    }
+    response.addCode(`await expect(page.getByRole(${javascript.escapeWithQuotes(params.role)}, { name: ${javascript.escapeWithQuotes(params.accessibleName)} })).toBeVisible();`);
+    response.addResult("Done");
+  }
+});
+const verifyText = (0, import_tool.defineTabTool)({
+  capability: "testing",
+  schema: {
+    name: "browser_verify_text_visible",
+    title: "Verify text visible",
+    description: `Verify text is visible on the page. Prefer ${verifyElement.schema.name} if possible.`,
+    inputSchema: import_bundle.z.object({
+      text: import_bundle.z.string().describe('TEXT to verify. Can be found in the snapshot like this: `- role "Accessible Name": {TEXT}` or like this: `- text: {TEXT}`')
+    }),
+    type: "assertion"
+  },
+  handle: async (tab, params, response) => {
+    const locator = tab.page.getByText(params.text).filter({ visible: true });
+    if (await locator.count() === 0) {
+      response.addError("Text not found");
+      return;
+    }
+    response.addCode(`await expect(page.getByText(${javascript.escapeWithQuotes(params.text)})).toBeVisible();`);
+    response.addResult("Done");
+  }
+});
+const verifyList = (0, import_tool.defineTabTool)({
+  capability: "testing",
+  schema: {
+    name: "browser_verify_list_visible",
+    title: "Verify list visible",
+    description: "Verify list is visible on the page",
+    inputSchema: import_bundle.z.object({
+      element: import_bundle.z.string().describe("Human-readable list description"),
+      ref: import_bundle.z.string().describe("Exact target element reference that points to the list"),
+      items: import_bundle.z.array(import_bundle.z.string()).describe("Items to verify")
+    }),
+    type: "assertion"
+  },
+  handle: async (tab, params, response) => {
+    const { locator } = await tab.refLocator({ ref: params.ref, element: params.element });
+    const itemTexts = [];
+    for (const item of params.items) {
+      const itemLocator = locator.getByText(item);
+      if (await itemLocator.count() === 0) {
+        response.addError(`Item "${item}" not found`);
+        return;
+      }
+      itemTexts.push(await itemLocator.textContent());
+    }
+    const ariaSnapshot = `\`
+- list:
+${itemTexts.map((t) => `  - listitem: ${javascript.escapeWithQuotes(t, '"')}`).join("\n")}
+\``;
+    response.addCode(`await expect(page.locator('body')).toMatchAriaSnapshot(${ariaSnapshot});`);
+    response.addResult("Done");
+  }
+});
+const verifyValue = (0, import_tool.defineTabTool)({
+  capability: "testing",
+  schema: {
+    name: "browser_verify_value",
+    title: "Verify value",
+    description: "Verify element value",
+    inputSchema: import_bundle.z.object({
+      type: import_bundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the element"),
+      element: import_bundle.z.string().describe("Human-readable element description"),
+      ref: import_bundle.z.string().describe("Exact target element reference that points to the element"),
+      value: import_bundle.z.string().describe('Value to verify. For checkbox, use "true" or "false".')
+    }),
+    type: "assertion"
+  },
+  handle: async (tab, params, response) => {
+    const { locator, resolved } = await tab.refLocator({ ref: params.ref, element: params.element });
+    const locatorSource = `page.${resolved}`;
+    if (params.type === "textbox" || params.type === "slider" || params.type === "combobox") {
+      const value = await locator.inputValue();
+      if (value !== params.value) {
+        response.addError(`Expected value "${params.value}", but got "${value}"`);
+        return;
+      }
+      response.addCode(`await expect(${locatorSource}).toHaveValue(${javascript.quote(params.value)});`);
+    } else if (params.type === "checkbox" || params.type === "radio") {
+      const value = await locator.isChecked();
+      if (value !== (params.value === "true")) {
+        response.addError(`Expected value "${params.value}", but got "${value}"`);
+        return;
+      }
+      const matcher = value ? "toBeChecked" : "not.toBeChecked";
+      response.addCode(`await expect(${locatorSource}).${matcher}();`);
+    }
+    response.addResult("Done");
+  }
+});
+var verify_default = [
+  verifyElement,
+  verifyText,
+  verifyList,
+  verifyValue
+];

.playwright-mcp/node_modules/playwright/lib/mcp/browser/tools/wait.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 wait_exports = {};
+__export(wait_exports, {
+  default: () => wait_default
+});
+module.exports = __toCommonJS(wait_exports);
+var import_bundle = require("../../sdk/bundle");
+var import_tool = require("./tool");
+const wait = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_wait_for",
+    title: "Wait for",
+    description: "Wait for text to appear or disappear or a specified time to pass",
+    inputSchema: import_bundle.z.object({
+      time: import_bundle.z.number().optional().describe("The time to wait in seconds"),
+      text: import_bundle.z.string().optional().describe("The text to wait for"),
+      textGone: import_bundle.z.string().optional().describe("The text to wait for to disappear")
+    }),
+    type: "assertion"
+  },
+  handle: async (context, params, response) => {
+    if (!params.text && !params.textGone && !params.time)
+      throw new Error("Either time, text or textGone must be provided");
+    if (params.time) {
+      response.addCode(`await new Promise(f => setTimeout(f, ${params.time} * 1000));`);
+      await new Promise((f) => setTimeout(f, Math.min(3e4, params.time * 1e3)));
+    }
+    const tab = context.currentTabOrDie();
+    const locator = params.text ? tab.page.getByText(params.text).first() : void 0;
+    const goneLocator = params.textGone ? tab.page.getByText(params.textGone).first() : void 0;
+    if (goneLocator) {
+      response.addCode(`await page.getByText(${JSON.stringify(params.textGone)}).first().waitFor({ state: 'hidden' });`);
+      await goneLocator.waitFor({ state: "hidden" });
+    }
+    if (locator) {
+      response.addCode(`await page.getByText(${JSON.stringify(params.text)}).first().waitFor({ state: 'visible' });`);
+      await locator.waitFor({ state: "visible" });
+    }
+    response.addResult(`Waited for ${params.text || params.textGone || params.time}`);
+    response.setIncludeSnapshot();
+  }
+});
+var wait_default = [
+  wait
+];