@skyramp/mcp 0.2.0 → 0.2.1

package/build/playwright/registerPlaywrightTools.js

@@ -45,6 +45,7 @@ export async function registerPlaywrightTools(server, options) {
         'browser_wait_for',
         'browser_take_screenshot',
         'browser_assert',
+        'browser_assert_api_request',
         'skyramp_export_zip',
         // DOM Analyzer tools (Phase C)
         'browser_blueprint',

package/build/utils/docker.test.js

@@ -54,7 +54,7 @@ describe("dockerImageExistsLocally", () => {
     });
 });
 describe("pullDockerImage", () => {
-    const IMAGE = "skyramp/executor:v1.3.25";
+    const IMAGE = "skyramp/executor:v1.3.26";
     beforeEach(() => jest.clearAllMocks());
     describe("on amd64 host", () => {
         const originalArch = process.arch;

package/build/utils/versions.js

@@ -1,3 +1,3 @@
-export const SKYRAMP_IMAGE_VERSION = "v1.3.25";
+export const SKYRAMP_IMAGE_VERSION = "v1.3.26";
 export const EXECUTOR_DOCKER_IMAGE = `skyramp/executor:${SKYRAMP_IMAGE_VERSION}`;
 export const WORKER_DOCKER_IMAGE = `skyramp/worker:${SKYRAMP_IMAGE_VERSION}`;

package/node_modules/playwright/lib/mcp/skyramp/assertApiRequestTool.js

@@ -0,0 +1,46 @@
+"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 assertApiRequestTool_exports = {};
+__export(assertApiRequestTool_exports, {
+  assertApiRequestMcpTool: () => assertApiRequestMcpTool,
+  assertApiRequestSchema: () => assertApiRequestSchema
+});
+module.exports = __toCommonJS(assertApiRequestTool_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("../sdk/tool");
+const assertApiRequestSchema = {
+  name: "browser_assert_api_request",
+  title: "Assert API request payload",
+  description: [
+    "Mark the NEXT user action for API request payload assertion.",
+    "Call this tool IMMEDIATELY BEFORE the click or action that triggers an API request you want to validate.",
+    "The generated test will capture the request payload and assert it matches on replay.",
+    'Example: call this tool, then call browser_click on a "Save" button that sends a POST request.'
+  ].join(" "),
+  inputSchema: import_mcpBundle.z.object({}),
+  type: "readOnly"
+};
+function assertApiRequestMcpTool() {
+  return (0, import_tool.toMcpTool)(assertApiRequestSchema);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertApiRequestMcpTool,
+  assertApiRequestSchema
+});

package/node_modules/playwright/lib/mcp/skyramp/traceRecordingBackend.js

@@ -43,6 +43,7 @@ var import_log = require("../log");
 var import_skyRampExport = require("../test/skyRampExport");
 var import_exportTool = require("./exportTool");
 var import_assertTool = require("./assertTool");
+var import_assertApiRequestTool = require("./assertApiRequestTool");
 var import_types = require("./types");
 const traceDebug = (0, import_utilsBundle.debug)("pw:mcp:trace");
 class TraceRecordingBackend {
@@ -115,7 +116,7 @@ class TraceRecordingBackend {
   }
   async listTools() {
     const browserTools = await this._browserBackend.listTools();
-    return [...browserTools, (0, import_exportTool.exportZipMcpTool)(), (0, import_assertTool.assertMcpTool)()];
+    return [...browserTools, (0, import_exportTool.exportZipMcpTool)(), (0, import_assertTool.assertMcpTool)(), (0, import_assertApiRequestTool.assertApiRequestMcpTool)()];
   }
   async callTool(name, args, progress) {
     if (!this._initialized)
@@ -142,6 +143,19 @@ class TraceRecordingBackend {
       const parsed = import_assertTool.assertToolSchema.inputSchema.parse(args || {});
       return this._handleAssert(parsed);
     }
+    if (name === import_assertApiRequestTool.assertApiRequestSchema.name) {
+      this._trackedActions.push({
+        toolName: "browser_assert_api_request",
+        args: {},
+        code: "",
+        timestamp: Date.now(),
+        pageAlias: this._currentPageAlias
+      });
+      traceDebug("Assert API request marker recorded");
+      return {
+        content: [{ type: "text", text: "### Result\nAPI request assertion marker recorded. The next action that triggers a network request will have its payload captured for validation in the generated test." }]
+      };
+    }
     if (name === "browser_select_option") {
       const result2 = await this._handleSelectOption(args || {});
       return result2;
@@ -178,6 +192,7 @@ class TraceRecordingBackend {
           timestamp: ts,
           pageAlias: this._currentPageAlias
         });
+        await this._enableFlutterAccessibility();
         const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
         return {
           content: [
@@ -191,17 +206,88 @@ Reloaded current page: ${currentUrl}
     }
     const timestampBeforeAction = Date.now();
     const pageAliasBeforeAction = this._currentPageAlias;
+    const stripRestore = await this._maybeStripWrapperRoles(name, args);
     let preClickHoverCode = null;
-    if (name === "browser_click" && args?.ref) {
-      const hoverResult = await this._browserBackend.callTool("browser_hover", {
-        element: args.element || "element",
-        ref: args.ref
-      });
-      if (!hoverResult.isError)
-        preClickHoverCode = (0, import_response.parseResponse)(hoverResult)?.code ?? null;
+    let preClickSnapshot = null;
+    let preClickLocatorCount = 0;
+    let preClickParentChain = null;
+    let result;
+    try {
+      if (name === "browser_click" && args?.ref) {
+        const hoverResult = await this._browserBackend.callTool("browser_hover", {
+          element: args.element || "element",
+          ref: args.ref
+        });
+        if (!hoverResult.isError) {
+          const parsed = (0, import_response.parseResponse)(hoverResult);
+          preClickHoverCode = parsed?.code ?? null;
+          preClickSnapshot = parsed?.snapshot ?? null;
+          if (preClickHoverCode) {
+            const roleCountMatch = preClickHoverCode.match(/getByRole\(\s*['"](\w+)['"]\s*(?:,\s*\{[^}]*name:\s*(?:'([^']*)'|"([^"]*)")\s*[^}]*\})?\s*\)/);
+            if (roleCountMatch) {
+              try {
+                const page = this._browserBackend.context?.currentTab()?.page;
+                if (page) {
+                  const r = roleCountMatch[1];
+                  const n = roleCountMatch[2] ?? roleCountMatch[3];
+                  preClickLocatorCount = n ? await page.getByRole(r, { name: n }).count() : await page.getByRole(r).count();
+                  traceDebug(`[pre-click count] getByRole("${r}"${n ? `, { name: "${n}" }` : ""}) = ${preClickLocatorCount}`);
+                }
+              } catch {
+              }
+            }
+          }
+          try {
+            const page = this._browserBackend.context?.currentTab()?.page;
+            if (page) {
+              preClickParentChain = await page.locator(`aria-ref=${args.ref}`).evaluate((el) => {
+                const ARIA_LANDMARKS = /* @__PURE__ */ new Set(["navigation", "main", "banner", "contentinfo", "complementary", "search", "form"]);
+                const SEMANTIC_TAGS_UNIQUE_CANDIDATES = ["nav", "main", "header", "footer", "aside"];
+                const SKIP_TESTID = /^(container|wrapper|content|main|root|app)$/i;
+                const SKIP_ID = /^(root|app|main|container|wrapper|content)$/i;
+                const isDynamic = (s) => /[-_]\d+$/.test(s) || /^[0-9a-f]{8,}/.test(s);
+                let cur = el.parentElement;
+                while (cur && cur !== el.ownerDocument.body) {
+                  const tid = cur.getAttribute("data-testid") || cur.getAttribute("data-test-id");
+                  if (tid && !isDynamic(tid) && !SKIP_TESTID.test(tid))
+                    return `getByTestId(${JSON.stringify(tid)})`;
+                  const id = cur.id;
+                  if (id && !isDynamic(id) && !SKIP_ID.test(id)) {
+                    const escapedId = id.replace(/(["\\])/g, "\\$1");
+                    return `locator(${JSON.stringify("#" + escapedId)})`;
+                  }
+                  const role = cur.getAttribute("role");
+                  if (role && ARIA_LANDMARKS.has(role)) {
+                    const ariaLabel = cur.getAttribute("aria-label");
+                    if (ariaLabel)
+                      return `getByRole(${JSON.stringify(role)}, { name: ${JSON.stringify(ariaLabel)} })`;
+                    if (el.ownerDocument.querySelectorAll(`[role="${role}"]`).length === 1)
+                      return `getByRole(${JSON.stringify(role)})`;
+                  }
+                  const tag = cur.tagName.toLowerCase();
+                  if (SEMANTIC_TAGS_UNIQUE_CANDIDATES.includes(tag)) {
+                    if (el.ownerDocument.querySelectorAll(tag).length === 1)
+                      return `locator(${JSON.stringify(tag)})`;
+                  }
+                  cur = cur.parentElement;
+                }
+                return null;
+              }).catch(() => null);
+              traceDebug(`[pre-click parent chain] ${preClickParentChain}`);
+            }
+          } catch {
+          }
+        }
+      }
+      result = await this._browserBackend.callTool(name, args);
+    } finally {
+      if (stripRestore)
+        await stripRestore();
+    }
+    if (name === "browser_navigate" && !result.isError) {
+      await this._enableFlutterAccessibility();
     }
-    let result = await this._browserBackend.callTool(name, args);
-    result = await this._improveActionSelector(name, args || {}, result, preClickHoverCode);
+    result = await this._improveActionSelector(name, args || {}, result, preClickHoverCode, preClickSnapshot, preClickLocatorCount, preClickParentChain);
     if (name === "browser_fill_form" && result.isError) {
       const resultText = result.content?.[0]?.type === "text" ? result.content[0].text : "";
       if (resultText.includes("not a <select> element") || resultText.includes("selectOption") && resultText.includes("Timeout")) {
@@ -563,7 +649,7 @@ ${details}` }]
    * preClickHoverCode: hover result taken BEFORE the click (needed for navigation clicks
    * where the element ref is no longer valid after navigation).
    */
-  async _improveActionSelector(toolName, args, result, preClickHoverCode = null) {
+  async _improveActionSelector(toolName, args, result, preClickHoverCode = null, preClickSnapshot = null, preClickLocatorCount = 0, preClickParentChain = null) {
     if (result.isError)
       return result;
     const selectorTools = /* @__PURE__ */ new Set(["browser_click", "browser_hover", "browser_type", "browser_fill"]);
@@ -606,43 +692,64 @@ ${details}` }]
       }
       return result;
     }
-    const roleMatch = code.match(/getByRole\(\s*['"](\w+)['"]\s*\)(?!\s*\.(?:filter|nth|first|last))/);
-    if (!roleMatch)
+    if (code.includes(".filter(") || code.includes(".nth(") || code.includes(".first(") || code.includes(".last("))
       return result;
-    const role = roleMatch[1];
+    if (/page\.(getByTestId|locator|getByRole)\([^)]*\)\.getByRole/.test(code))
+      return result;
+    const bareRoleMatch = code.match(/getByRole\(\s*['"](\w+)['"]\s*\)/);
+    const namedRoleMatch = code.match(/getByRole\(\s*['"](\w+)['"]\s*,\s*\{[^}]*name:\s*(?:'([^']*)'|"([^"]*)")/);
+    if (!bareRoleMatch && !namedRoleMatch)
+      return result;
+    const role = bareRoleMatch?.[1] ?? namedRoleMatch[1];
+    const roleName = namedRoleMatch ? namedRoleMatch[2] ?? namedRoleMatch[3] : void 0;
     const ref = args.ref;
     if (!ref)
       return result;
-    const snapText = parsed?.snapshot ?? "";
-    if (!snapText)
-      return result;
-    const snapLines = snapText.split("\n");
+    const snapText = preClickSnapshot || parsed?.snapshot || "";
+    const snapLines = (snapText || "").split("\n");
     const rolePattern = new RegExp(`^\\s*-\\s*${role}\\s+`, "m");
-    const roleCount = snapLines.filter((l) => rolePattern.test(l)).length;
-    if (roleCount <= 1) {
-      traceDebug(`Role "${role}" is unique, no improvement needed`);
-      return result;
+    let snapshotMatchCount = 0;
+    if (snapText) {
+      if (roleName) {
+        const escapedName = roleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const namedPattern = new RegExp(`^\\s*-\\s*${role}\\s+"[^"]*${escapedName}`, "i");
+        snapshotMatchCount = snapLines.filter((l) => namedPattern.test(l)).length;
+      } else {
+        snapshotMatchCount = snapLines.filter((l) => rolePattern.test(l)).length;
+      }
     }
-    traceDebug(`Role "${role}" appears ${roleCount} times \u2014 attempting to disambiguate`);
+    const ambiguousCount = Math.max(preClickLocatorCount, snapshotMatchCount);
+    traceDebug(`[disambig] role="${role}" name="${roleName ?? ""}" preClickCount=${preClickLocatorCount} snapshotCount=${snapshotMatchCount} \u2192 ambiguousCount=${ambiguousCount}`);
+    traceDebug(`Role "${role}"${roleName ? ` name="${roleName}"` : ""} matches ${ambiguousCount} elements \u2014 attempting to disambiguate`);
     const refPattern = `[ref=${ref}]`;
     const refIdx = snapLines.findIndex((l) => l.includes(refPattern));
     if (refIdx < 0)
       return result;
     const refLine = snapLines[refIdx];
-    const textMatch = refLine.match(/^\s*-\s*\w+\s+"([^"]*)"/);
-    if (textMatch && textMatch[1]) {
-      const visibleText = textMatch[1];
-      const textPattern = new RegExp(`^\\s*-\\s*${role}\\s+"[^"]*${visibleText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i");
-      const textCount = snapLines.filter((l) => textPattern.test(l)).length;
-      if (textCount === 1) {
-        const improvedCode = code.replace(
-          /getByRole\((\s*['"](\w+)['"]\s*)\)/,
-          `getByRole($1).filter({ hasText: "${visibleText}" })`
-        );
-        traceDebug(`Improved selector with text filter: ${visibleText}`);
-        return this._modifyResultCode(result, improvedCode);
+    if (!roleName && ambiguousCount > 1) {
+      const textMatch = refLine.match(/^\s*-\s*\w+\s+"([^"]*)"/);
+      if (textMatch && textMatch[1]) {
+        const visibleText = textMatch[1];
+        const textPattern = new RegExp(`^\\s*-\\s*${role}\\s+"[^"]*${visibleText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i");
+        const textCount = snapLines.filter((l) => textPattern.test(l)).length;
+        if (textCount === 1) {
+          const improvedCode = code.replace(
+            /getByRole\((\s*['"](\w+)['"]\s*)\)/,
+            `getByRole($1).filter({ hasText: "${visibleText}" })`
+          );
+          traceDebug(`Improved selector with text filter: ${visibleText}`);
+          return this._modifyResultCode(result, improvedCode);
+        }
       }
     }
+    if (preClickParentChain) {
+      const improvedCode = code.replace(
+        /await\s+page\./,
+        `await page.${preClickParentChain}.`
+      );
+      traceDebug(`Improved selector by chaining from parent: ${preClickParentChain}`);
+      return this._modifyResultCode(result, improvedCode);
+    }
     const refIndent = refLine.match(/^(\s*)/)?.[1]?.length ?? 0;
     for (let i = refIdx - 1; i >= 0; i--) {
       const line = snapLines[i];
@@ -667,7 +774,7 @@ ${details}` }]
               /await\s+page\./,
               `await page.getByTestId("${testid}").`
             );
-            traceDebug(`Improved selector by chaining from test-id: ${testid}`);
+            traceDebug(`Improved selector by chaining from test-id (snapshot walk): ${testid}`);
             return this._modifyResultCode(result, improvedCode);
           }
         }
@@ -676,22 +783,24 @@ ${details}` }]
       if (indent === 0)
         break;
     }
-    const roleRefs = [];
-    for (const line of snapLines) {
-      if (rolePattern.test(line)) {
-        const m = line.match(/\[ref=(\w+)\]/);
-        if (m)
-          roleRefs.push(m[1]);
+    if (ambiguousCount > 1) {
+      const roleRefs = [];
+      for (const line of snapLines) {
+        if (rolePattern.test(line)) {
+          const m = line.match(/\[ref=(\w+)\]/);
+          if (m)
+            roleRefs.push(m[1]);
+        }
+      }
+      const index = roleRefs.indexOf(ref);
+      if (index >= 0) {
+        const improvedCode = code.replace(
+          /getByRole\((\s*['"][^'"]+['"](?:\s*,\s*\{[^}]*\})?)\s*\)/,
+          `getByRole($1).nth(${index})`
+        );
+        traceDebug(`Improved selector with .nth(${index})`);
+        return this._modifyResultCode(result, improvedCode);
       }
-    }
-    const index = roleRefs.indexOf(ref);
-    if (index >= 0) {
-      const improvedCode = code.replace(
-        /getByRole\((\s*['"](\w+)['"]\s*)\)/,
-        `getByRole($1).nth(${index})`
-      );
-      traceDebug(`Improved selector with .nth(${index})`);
-      return this._modifyResultCode(result, improvedCode);
     }
     return result;
   }
@@ -779,6 +888,51 @@ ${details}` }]
       });
     });
   }
+  /**
+   * SKYR-3728: detect a wrapper-button around args.ref and, if found, strip
+   * role="button"/role="link" from every wrapper in the document so that
+   * upstream's closestCrossShadow can't retarget UP during selector
+   * regeneration. Returns a restore function the caller MUST invoke (via
+   * try/finally) once the click has been recorded.
+   *
+   * Works for browser_click, browser_type, browser_fill, browser_hover —
+   * anything that goes through tab.refLocator → upstream generateSelector.
+   */
+  async _maybeStripWrapperRoles(toolName, args) {
+    const interactiveTools = /* @__PURE__ */ new Set(["browser_click", "browser_type", "browser_fill", "browser_hover"]);
+    if (!interactiveTools.has(toolName))
+      return null;
+    const ref = args?.ref;
+    if (!ref)
+      return null;
+    const tab = this._browserBackend.context?.currentTab();
+    const page = tab?.page;
+    if (!page)
+      return null;
+    let stripped = false;
+    try {
+      const handle = await page.locator(`aria-ref=${ref}`).elementHandle({ timeout: 1e3 });
+      if (!handle)
+        return null;
+      try {
+        stripped = await page.evaluate(pageEvaluateStripWrapperRoles, handle);
+      } finally {
+        await handle.dispose();
+      }
+    } catch {
+      return null;
+    }
+    if (!stripped)
+      return null;
+    traceDebug(`Wrapper-leak detected for ref=${ref}; stripped role=button/link document-wide for the action`);
+    return async () => {
+      try {
+        await page.evaluate(pageEvaluateRestoreWrapperRoles);
+        traceDebug("Restored stripped roles");
+      } catch {
+      }
+    };
+  }
   _maybeTrackAction(toolName, args, result, timestamp, pageAliasBeforeAction) {
     if (result.isError)
       return;
@@ -809,6 +963,54 @@ ${details}` }]
       return url.replace(/\/$/, "");
     }
   }
+  /**
+   * Enable Flutter web accessibility mode by clicking the hidden
+   * flt-semantics-placeholder button. Flutter web apps render to canvas by
+   * default, making DOM automation impossible. This creates a parallel ARIA
+   * tree that Playwright can interact with.
+   */
+  async _enableFlutterAccessibility() {
+    const page = this._browserBackend.context?.currentTab()?.page;
+    if (!page) return;
+    const url = page.url();
+    if (url.startsWith("chrome-extension://") || url.startsWith("about:") || url.startsWith("file://"))
+      return;
+    const alreadyEnabled = await page.evaluate(() => {
+      const host = document.querySelector("flt-semantics-host");
+      return host && host.children.length > 0;
+    }).catch(() => false);
+    if (alreadyEnabled) {
+      traceDebug("Flutter accessibility already enabled");
+      return;
+    }
+    let isFlutter = await page.evaluate(
+      () => !!document.querySelector("flt-glass-pane, flutter-view, flt-semantics-placeholder")
+    ).catch(() => false);
+    if (!isFlutter) {
+      const hasCanvas = await page.evaluate(() => !!document.querySelector("canvas")).catch(() => false);
+      if (hasCanvas) {
+        isFlutter = await page.waitForFunction(
+          () => !!document.querySelector("flt-glass-pane, flutter-view, flt-semantics-placeholder"),
+          { timeout: 5e3 }
+        ).then(() => true).catch(() => false);
+      }
+    }
+    if (!isFlutter) return;
+    const placeholder = page.locator("flt-semantics-placeholder").first();
+    const clicked = await placeholder.click({ force: true }).then(() => true).catch(() => false);
+    if (!clicked) {
+      traceDebug("Flutter detected but placeholder click failed");
+      return;
+    }
+    const enabled = await page.waitForFunction(() => {
+      const host = document.querySelector("flt-semantics-host");
+      return host && host.children.length > 0;
+    }, { timeout: 5e3 }).then(() => true).catch(() => false);
+    if (enabled)
+      traceDebug("Flutter accessibility mode enabled");
+    else
+      traceDebug("Flutter placeholder clicked but semantics host did not appear");
+  }
   /** Clean up temp directory and optionally recreate it for next session. */
   _cleanupTempDir(recreate = false) {
     try {
@@ -838,6 +1040,51 @@ ${details}` }]
     this._cleanupTempDir(false);
   }
 }
+function pageEvaluateStripWrapperRoles(target) {
+  const TOKEN = "__skyr_3728_stripped__";
+  const w = window;
+  if (w[TOKEN])
+    return false;
+  if (!target || !(target instanceof Element))
+    return false;
+  const labelSelector = 'input, textarea, select, label, [role="checkbox"], [role="radio"], [role="switch"], [role="textbox"], [role="combobox"]';
+  let wrapper = null;
+  for (let el = target; el; el = el.parentElement) {
+    const role = el.getAttribute && el.getAttribute("role");
+    if (role !== "button" && role !== "link")
+      continue;
+    if (el.children.length === 0)
+      continue;
+    if (!el.querySelector(labelSelector))
+      continue;
+    wrapper = el;
+    break;
+  }
+  if (!wrapper)
+    return false;
+  const stripped = [];
+  document.querySelectorAll('[role="button"], [role="link"]').forEach((el) => {
+    if (el.children.length === 0)
+      return;
+    const role = el.getAttribute("role");
+    stripped.push({ el, role });
+    el.removeAttribute("role");
+  });
+  w[TOKEN] = stripped;
+  return true;
+}
+function pageEvaluateRestoreWrapperRoles() {
+  const TOKEN = "__skyr_3728_stripped__";
+  const w = window;
+  const stripped = w[TOKEN];
+  if (!stripped)
+    return;
+  for (const { el, role } of stripped) {
+    if (el.isConnected)
+      el.setAttribute("role", role);
+  }
+  delete w[TOKEN];
+}
 function splitExtensionPaths(value) {
   if (!value)
     return void 0;

package/node_modules/playwright/lib/mcp/test/skyRampExport.js

@@ -495,6 +495,11 @@ function buildJsonlContent(actions, browserName, harPath) {
       }
       continue;
     }
+    if (action.toolName === "browser_assert_api_request") {
+      lines.push(JSON.stringify({ name: "assertApiRequest", signals: [], timestamp: String(action.timestamp), pageGuid, pageAlias: alias, framePath: DEFAULT_FRAME_PATH }));
+      actionCount++;
+      continue;
+    }
     if ((action.toolName === "browser_type" || action.toolName === "browser_press_sequentially") && action.args.submit) {
       const fillLine = trackedActionToJsonl(action, pageGuid, action.timestamp);
       if (fillLine) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",
@@ -55,7 +55,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@playwright/test": "^1.55.0",
-    "@skyramp/skyramp": "1.3.25",
+    "@skyramp/skyramp": "1.3.26",
     "dockerode": "^5.0.0",
     "fast-glob": "^3.3.3",
     "js-yaml": "^4.1.1",

package/node_modules/playwright/lib/mcp/browser/tools/domAnalyzer.js

@@ -1,261 +0,0 @@
-"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 domAnalyzer_exports = {};
-__export(domAnalyzer_exports, {
-  default: () => domAnalyzer_default
-});
-module.exports = __toCommonJS(domAnalyzer_exports);
-var crypto = __toESM(require("crypto"));
-var fs = __toESM(require("fs"));
-var import_mcpBundle = require("playwright-core/lib/mcpBundle");
-var import_tool = require("./tool");
-var import_crawler = require("../../../dom-analyzer/crawler");
-var import_blueprint = require("../../../dom-analyzer/blueprint");
-var import_serialization = require("../../../dom-analyzer/serialization");
-function hashStorageState(path) {
-  if (!path)
-    return null;
-  try {
-    const contents = fs.readFileSync(path, "utf-8");
-    return crypto.createHash("sha256").update(contents).digest("hex").slice(0, 16);
-  } catch {
-    const pathHash = crypto.createHash("sha256").update(path).digest("hex").slice(0, 16);
-    return `unreadable:${pathHash}`;
-  }
-}
-function cacheKey(entryUrl, storageStateHash, probeButtons) {
-  return `${entryUrl}::${storageStateHash ?? "no-auth"}::${probeButtons}`;
-}
-function humanDuration(ms) {
-  if (ms < 6e4)
-    return `${Math.round(ms / 1e3)}s`;
-  return `${Math.round(ms / 6e4)}m`;
-}
-const sitemapBuild = (0, import_tool.defineTool)({
-  capability: "core",
-  schema: {
-    name: "browser_sitemap_build",
-    title: "Build Sitemap (graph of PageBlueprints)",
-    description: [
-      "Crawl an application starting from a URL and build a Sitemap \u2014 a graph of PageBlueprints (one per URL)",
-      "connected by navigation edges. The Sitemap is cached in the session.",
-      "",
-      "Call once at the start of a session. Subsequent calls within the TTL (~30 minutes) reuse the cached",
-      "Sitemap unless `refresh: true` is passed. Use `browser_sitemap_query` to read already-crawled pages",
-      "rather than re-calling this tool.",
-      "",
-      "Depth defaults to 5, maxPages to 50 (the real bound in practice).",
-      "",
-      '\u26A0\uFE0F SAFETY: By default, `probeButtons: "immutable-only"` skips destructive-looking buttons',
-      "(Delete / Submit / Place Order / etc.) and buttons inside forms to prevent side effects during",
-      'crawling. Use `probeButtons: "all"` only against dev / staging environments \u2014 it will click every',
-      "unique button, which can submit forms, create records, send notifications, or mutate server state."
-    ].join("\n"),
-    inputSchema: import_mcpBundle.z.object({
-      url: import_mcpBundle.z.string().describe("Entry URL to start crawling from"),
-      depth: import_mcpBundle.z.number().optional().default(5).describe("Max crawl depth (default: 5)"),
-      maxPages: import_mcpBundle.z.number().optional().default(50).describe("Max pages to visit (default: 50)"),
-      sameOriginOnly: import_mcpBundle.z.boolean().optional().default(true).describe("Only follow same-origin links (default: true)"),
-      probeButtons: import_mcpBundle.z.enum(["immutable-only", "all", "none"]).optional().default("immutable-only").describe('Button-probing safety mode. Default: immutable-only (safe; skips destructive-verb buttons and buttons inside forms). Use "all" only against dev/staging \u2014 probes every button. "none" disables button probing entirely.'),
-      playwrightStoragePath: import_mcpBundle.z.string().optional().describe("Path to a Playwright storageState.json file \u2014 cookies, localStorage, sessionStorage per origin. Use this to crawl apps behind a login."),
-      refresh: import_mcpBundle.z.boolean().optional().default(false).describe("Force a full re-crawl, bypassing the cache")
-    }),
-    type: "readOnly"
-  },
-  handle: async (context, params, response) => {
-    const { url, depth, maxPages, sameOriginOnly, probeButtons, playwrightStoragePath, refresh } = params;
-    const normalizedUrl = (0, import_serialization.normalizeUrl)(url);
-    const storageStateHash = hashStorageState(playwrightStoragePath);
-    const probeMode = probeButtons;
-    const key = cacheKey(normalizedUrl, storageStateHash, probeMode);
-    const cached = context.sitemapCache.get(key);
-    if (cached && !refresh) {
-      const age = Date.now() - new Date(cached.sitemap.cachedAt).getTime();
-      if (age < import_serialization.CRAWL_TTL_MS) {
-        const pageCount2 = Object.keys(cached.sitemap.pages).length;
-        response.addTextResult(
-          `Reusing cached Sitemap from ${humanDuration(age)} ago.
-Entry: ${cached.sitemap.entryUrl}
-Pages: ${pageCount2}
-Edges: ${cached.sitemap.edges.length}
-Storage state: ${storageStateHash ? `auth hash ${storageStateHash}` : "none"}
-Probe mode: ${probeMode}
-
-Use browser_sitemap_query to read any page. Pass refresh=true to recrawl.`
-        );
-        return;
-      }
-    }
-    let sitemap;
-    if (depth > 0) {
-      sitemap = await (0, import_crawler.crawl)(url, {
-        depth,
-        maxPages,
-        sameOriginOnly,
-        probeButtons: probeMode,
-        playwrightStoragePath
-      });
-    } else {
-      sitemap = await (0, import_crawler.crawlSinglePage)(url, { playwrightStoragePath });
-    }
-    context.sitemapCache.set(key, { sitemap, storageStateHash, probeButtonsMode: probeMode });
-    const pageCount = Object.keys(sitemap.pages).length;
-    const pageList = Object.keys(sitemap.pages).map((u) => {
-      const bp = sitemap.pages[u];
-      const elCount = bp.sections.reduce((sum, s) => sum + s.elements.length + s.repeatingElements.length, 0);
-      return `  - ${u} (${elCount} elements across ${bp.sections.length} sections)`;
-    }).join("\n");
-    response.addTextResult(
-      `Sitemap built for ${sitemap.entryUrl}
-Pages: ${pageCount}
-Edges: ${sitemap.edges.length}
-Storage state: ${storageStateHash ? `auth hash ${storageStateHash}` : "none"}
-Probe mode: ${probeMode}
-
-Pages:
-${pageList}
-
-Use browser_sitemap_query to read page blueprints, edges, or derived views (mapJson, outline).`
-    );
-  }
-});
-const sitemapQuery = (0, import_tool.defineTool)({
-  capability: "core",
-  schema: {
-    name: "browser_sitemap_query",
-    title: "Query the cached Sitemap",
-    description: [
-      "Query the Sitemap cached by browser_sitemap_build. Use this instead of re-calling sitemap_build.",
-      "",
-      "Modes:",
-      "  page     \u2014 returns the full canonical PageBlueprint for the given URL",
-      "             (sections with enrichment, logical names, XPaths)",
-      "  edges    \u2014 returns navigation edges originating from the given URL",
-      "  mapJson  \u2014 returns the derived flat logicalName \u2192 xpath map for the URL",
-      "  outline  \u2014 returns the derived textual section-to-element hierarchy for the URL",
-      "  overview \u2014 (when url is omitted) returns page list + edge list summary"
-    ].join("\n"),
-    inputSchema: import_mcpBundle.z.object({
-      type: import_mcpBundle.z.enum(["page", "edges", "mapJson", "outline"]).optional().describe("Query mode. Omit with url to get overview."),
-      url: import_mcpBundle.z.string().optional().describe("Page URL to query. Omit to get overview across all pages.")
-    }),
-    type: "readOnly"
-  },
-  handle: async (context, params, response) => {
-    if (context.sitemapCache.size === 0) {
-      response.addError("No Sitemap available. Run browser_sitemap_build first.");
-      return;
-    }
-    const latest = [...context.sitemapCache.values()].sort(
-      (a, b) => new Date(b.sitemap.cachedAt).getTime() - new Date(a.sitemap.cachedAt).getTime()
-    )[0];
-    const sitemap = latest.sitemap;
-    const { type, url } = params;
-    if (!url || !type) {
-      const overview = {
-        schemaVersion: sitemap.schemaVersion,
-        entryUrl: sitemap.entryUrl,
-        cachedAt: sitemap.cachedAt,
-        pages: Object.keys(sitemap.pages).map((u) => ({
-          url: u,
-          sections: sitemap.pages[u].sections.length,
-          elements: sitemap.pages[u].sections.reduce(
-            (s, sec) => s + sec.elements.length + sec.repeatingElements.length,
-            0
-          ),
-          pageHash: sitemap.pages[u].pageHash
-        })),
-        edges: sitemap.edges
-      };
-      response.addTextResult(JSON.stringify(overview, null, 2));
-      return;
-    }
-    const normalizedQueryUrl = (0, import_serialization.normalizeUrl)(url);
-    const blueprint2 = sitemap.pages[normalizedQueryUrl];
-    if (!blueprint2) {
-      response.addError(
-        `Page not found in Sitemap: ${normalizedQueryUrl}. Available pages: ${Object.keys(sitemap.pages).join(", ")}`
-      );
-      return;
-    }
-    if (type === "page") {
-      response.addTextResult(JSON.stringify(blueprint2, null, 2));
-      return;
-    }
-    if (type === "edges") {
-      const edges = sitemap.edges.filter((e) => e.from === normalizedQueryUrl);
-      response.addTextResult(JSON.stringify({ url: normalizedQueryUrl, edges }, null, 2));
-      return;
-    }
-    if (type === "mapJson") {
-      response.addTextResult(JSON.stringify((0, import_blueprint.buildMap)(blueprint2), null, 2));
-      return;
-    }
-    if (type === "outline") {
-      response.addTextResult((0, import_blueprint.buildOutline)(blueprint2));
-      return;
-    }
-  }
-});
-const blueprint = (0, import_tool.defineTabTool)({
-  capability: "core",
-  schema: {
-    name: "browser_blueprint",
-    title: "Build PageBlueprint for the current page",
-    description: [
-      "Build a PageBlueprint for the currently loaded page. Returns the canonical `sections` tree",
-      "containing singular elements and repeating-element shapes, each carrying enrichment fields",
-      "(mutability, widgetType, framePath, shadowRoot, stableId, testId).",
-      "",
-      "Call this only when the DOM has changed since the last known-good blueprint \u2014 e.g. after a",
-      "modal opens, a form submits, a filter changes a list, or any mutable action. For pure navigation",
-      "to an already-crawled URL, reuse the Sitemap cache via browser_sitemap_query.",
-      "",
-      "Logical names are stable \u2014 use them in generated test code. Refs (from browser_snapshot) are",
-      "ephemeral \u2014 use them only for dispatching the next interaction, never in generated code."
-    ].join("\n"),
-    inputSchema: import_mcpBundle.z.object({}),
-    type: "readOnly"
-  },
-  handle: async (tab, _params, response) => {
-    try {
-      const bp = await (0, import_blueprint.buildPageBlueprint)(tab.page);
-      response.addTextResult(JSON.stringify(bp, null, 2));
-    } catch (err) {
-      if (err instanceof import_blueprint.BlueprintInvariantError) {
-        response.addError(
-          `Blueprint invariant violated: ${err.message}. This is a builder bug; please file an issue with the URL of the page that triggered it.`
-        );
-        return;
-      }
-      throw err;
-    }
-  }
-});
-var domAnalyzer_default = [sitemapBuild, sitemapQuery, blueprint];