@skyramp/mcp 0.0.64-rc.8 → 0.0.64

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

@@ -0,0 +1,52 @@
+"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 assertTool_exports = {};
+__export(assertTool_exports, {
+  assertMcpTool: () => assertMcpTool,
+  assertToolSchema: () => assertToolSchema
+});
+module.exports = __toCommonJS(assertTool_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("../sdk/tool");
+const assertToolSchema = {
+  name: "browser_assert",
+  title: "Assert element state",
+  description: [
+    "Assert that an element has expected text, value, or is visible.",
+    "Use this after key actions to verify the page state is correct.",
+    "The assertion is recorded in the trace for test generation.",
+    'Types: "text" checks element text content, "value" checks input field value.'
+  ].join(" "),
+  inputSchema: import_mcpBundle.z.object({
+    type: import_mcpBundle.z.enum(["text", "value"]).describe('Type of assertion: "text" for text content, "value" for input field value'),
+    ref: import_mcpBundle.z.string().describe("Element reference from the latest snapshot"),
+    element: import_mcpBundle.z.string().describe("Human-readable description of the element being asserted"),
+    expected: import_mcpBundle.z.string().describe("Expected text or value to assert"),
+    substring: import_mcpBundle.z.boolean().optional().default(true).describe("For text assertions: match as substring (true) or exact match (false)")
+  }),
+  type: "readOnly"
+};
+function assertMcpTool() {
+  return (0, import_tool.toMcpTool)(assertToolSchema);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertMcpTool,
+  assertToolSchema
+});

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

@@ -42,6 +42,7 @@ var import_response = require("../browser/response");
 var import_log = require("../log");
 var import_skyRampExport = require("../test/skyRampExport");
 var import_exportTool = require("./exportTool");
+var import_assertTool = require("./assertTool");
 var import_types = require("./types");
 const traceDebug = (0, import_utilsBundle.debug)("pw:mcp:trace");
 class TraceRecordingBackend {
@@ -69,6 +70,7 @@ class TraceRecordingBackend {
           serviceWorkers: "block"
         }
       },
+      capabilities: ["testing"],
       outputDir: this._tempDir,
       timeouts: {
         action: 15e3,
@@ -84,7 +86,7 @@ class TraceRecordingBackend {
   }
   async listTools() {
     const browserTools = await this._browserBackend.listTools();
-    return [...browserTools, (0, import_exportTool.exportZipMcpTool)()];
+    return [...browserTools, (0, import_exportTool.exportZipMcpTool)(), (0, import_assertTool.assertMcpTool)()];
   }
   async callTool(name, args, progress) {
     if (!this._initialized)
@@ -100,7 +102,14 @@ class TraceRecordingBackend {
         rootPath: this._outputDir,
         harPath: this._harPath
       });
-      return handler(parsed);
+      const exportResult = await handler(parsed);
+      if (!exportResult.isError)
+        this._trackedActions = [];
+      return exportResult;
+    }
+    if (name === import_assertTool.assertToolSchema.name) {
+      const parsed = import_assertTool.assertToolSchema.inputSchema.parse(args || {});
+      return this._handleAssert(parsed);
     }
     if (name === "browser_select_option") {
       const result2 = await this._handleSelectOption(args || {});
@@ -143,6 +152,36 @@ class TraceRecordingBackend {
     const result = await this._browserBackend.callTool("browser_select_option", args);
     const resultText = result.content?.[0]?.type === "text" ? result.content[0].text : "";
     if (!result.isError) {
+      const code = (0, import_response.parseResponse)(result)?.code ?? "";
+      const hasCssSelector = code.includes("page.locator('select") || code.includes('page.locator("select') || code.includes(".selectOption(") && !code.includes("getByTestId") && !code.includes("getByRole") && !code.includes("getByLabel");
+      if (hasCssSelector && args.ref) {
+        traceDebug("selectOption used CSS selector, trying to resolve a better one via hover");
+        const hoverResult = await this._browserBackend.callTool("browser_hover", {
+          element: args.element || "select",
+          ref: args.ref
+        });
+        if (!hoverResult.isError) {
+          const hoverCode = (0, import_response.parseResponse)(hoverResult)?.code ?? "";
+          const locatorMatch = hoverCode.match(/await\s+page\.(.*?)\.hover\(\)/s);
+          if (locatorMatch) {
+            const locatorExpr = locatorMatch[1].trim();
+            const parsed = this._codeToLocator(locatorExpr);
+            if (parsed && parsed.locator.kind !== "text") {
+              const values2 = args.values || [];
+              const selectCode = `await page.${locatorExpr}.selectOption(${JSON.stringify(values2.length === 1 ? values2[0] : values2)});`;
+              traceDebug(`Improved select selector: ${selectCode}`);
+              const timestamp = Date.now();
+              this._trackedActions.push({
+                toolName: "browser_select_option",
+                args,
+                code: selectCode,
+                timestamp
+              });
+              return result;
+            }
+          }
+        }
+      }
       this._maybeTrackAction("browser_select_option", args, result);
       return result;
     }
@@ -156,19 +195,24 @@ class TraceRecordingBackend {
     const preSnapResult = await this._browserBackend.callTool("browser_snapshot", {});
     if (preSnapResult.isError)
       return preSnapResult;
-    const preSnapText = preSnapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
-    const comboboxes = [...preSnapText.matchAll(/combobox[^\n]*\[ref=(\w+)\]/g)];
-    const clickableCombo = comboboxes.find((m) => m[0].includes("cursor=pointer"));
-    const comboRef = clickableCombo?.[1] || args.ref;
-    const clickResult = await this._browserBackend.callTool("browser_click", { element: args.element || "dropdown", ref: comboRef });
-    if (clickResult.isError)
-      return { content: [{ type: "text", text: `### Error
+    let snapText = preSnapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
+    const dropdownAlreadyOpen = /listbox[^\n]*\[ref=\w+\]/.test(snapText) && /option\s+"/.test(snapText);
+    if (!dropdownAlreadyOpen) {
+      const comboboxes = [...snapText.matchAll(/combobox[^\n]*\[ref=(\w+)\]/g)];
+      const clickableCombo = comboboxes.find((m) => m[0].includes("cursor=pointer"));
+      const comboRef = clickableCombo?.[1] || args.ref;
+      const clickResult = await this._browserBackend.callTool("browser_click", { element: args.element || "dropdown", ref: comboRef });
+      if (clickResult.isError)
+        return { content: [{ type: "text", text: `### Error
 Failed to open custom dropdown. The dropdown modal may not be visible yet. Try calling browser_snapshot first to check the page state, then ensure the form/modal is open before selecting an option.` }], isError: true };
-    this._maybeTrackAction("browser_click", { element: args.element || "dropdown", ref: comboRef }, clickResult);
-    const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
-    if (snapResult.isError)
-      return snapResult;
-    const snapText = snapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
+      this._maybeTrackAction("browser_click", { element: args.element || "dropdown", ref: comboRef }, clickResult);
+      const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
+      if (snapResult.isError)
+        return snapResult;
+      snapText = snapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
+    } else {
+      traceDebug("Dropdown already open, skipping combobox click");
+    }
     const targetValue = values[0];
     const candidates = [targetValue];
     const lower = targetValue.toLowerCase();
@@ -196,12 +240,243 @@ Failed to open custom dropdown. The dropdown modal may not be visible yet. Try c
 Opened the custom dropdown but could not find a matching option for "${targetValue}". Available options:
 ${optionLines}` }], isError: true };
   }
+  /**
+   * Handle browser_assert by using browser_hover to resolve the ref to a
+   * proper Playwright selector (testid > role > text), then verify the
+   * assertion against the snapshot data.
+   */
+  async _handleAssert(params) {
+    const timestamp = Date.now();
+    if (!params.expected)
+      return { content: [{ type: "text", text: '### Error\n"expected" parameter is required.' }], isError: true };
+    const hoverResult = await this._browserBackend.callTool("browser_hover", {
+      element: params.element,
+      ref: params.ref
+    });
+    if (hoverResult.isError) {
+      const errText = hoverResult.content?.[0]?.type === "text" ? hoverResult.content[0].text : "";
+      return { content: [{ type: "text", text: `### Assertion Failed
+Could not resolve element ref=${params.ref}. ${errText}` }], isError: true };
+    }
+    const hoverCode = (0, import_response.parseResponse)(hoverResult)?.code ?? "";
+    const locatorMatch = hoverCode.match(/await\s+page\.(.*?)\.hover\(\)/s);
+    if (!locatorMatch) {
+      return { content: [{ type: "text", text: `### Assertion Failed
+Could not extract selector from hover result.` }], isError: true };
+    }
+    const locatorExpr = locatorMatch[1].trim();
+    let parsed = this._codeToLocator(locatorExpr);
+    if (!parsed) {
+      return { content: [{ type: "text", text: `### Assertion Failed
+Could not parse locator: ${locatorExpr}` }], isError: true };
+    }
+    const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
+    const snapText = snapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
+    const snapLines = snapText.split("\n");
+    const refLine = snapLines.find((l) => l.includes(`[ref=${params.ref}]`)) || "";
+    const textMatch = refLine.match(/^\s*-\s*\w+\s+"([^"]*)"/);
+    const elementText = textMatch?.[1] || "";
+    const valueMatch = refLine.match(/\]:\s*(.+)$/);
+    const elementValue = valueMatch?.[1]?.trim() || "";
+    if (parsed.locator.kind === "text") {
+      const improved = await this._improveTextSelector(snapLines, params.ref, parsed);
+      if (improved) {
+        traceDebug(`Improved ambiguous text selector to: ${improved.selector}`);
+        parsed = improved;
+      }
+    }
+    let passed = false;
+    let details = "";
+    if (params.type === "text") {
+      passed = elementText.includes(params.expected) || elementValue.includes(params.expected);
+      details = passed ? `Text assertion passed: "${params.element}" contains "${params.expected}".` : `Text assertion FAILED: "${params.element}" has text "${elementText}"${elementValue ? ` / value "${elementValue}"` : ""}, expected "${params.expected}".`;
+    } else {
+      passed = elementValue === params.expected || elementValue.includes(params.expected);
+      details = passed ? `Value assertion passed: "${params.element}" has value "${params.expected}".` : `Value assertion FAILED: "${params.element}" has value "${elementValue}", expected "${params.expected}".`;
+    }
+    if (passed) {
+      const selectorText = parsed.locator.kind === "text" ? parsed.locator.body : parsed.locator.next?.kind === "text" ? parsed.locator.next.body : parsed.locator.options?.name ?? null;
+      if (selectorText && selectorText === params.expected) {
+        traceDebug(`Skipped tautological assertion: selector already matches "${params.expected}"`);
+      } else {
+        const assertName = params.type === "value" ? "assertValue" : "assertText";
+        this._trackedActions.push({
+          toolName: "browser_assert",
+          args: { type: params.type, ref: params.ref, expected: params.expected },
+          code: `${assertName}:${parsed.selector}:${params.expected}${params.type === "text" ? ":" + params.substring : ""}`,
+          timestamp
+        });
+        traceDebug(`Assert: ${assertName} with selector ${parsed.selector}`);
+      }
+    }
+    return {
+      content: [{ type: "text", text: `### ${passed ? "Assertion Passed" : "Assertion Failed"}
+${details}` }]
+    };
+  }
+  /** Convert a Playwright locator expression to a selector + locator object for JSONL. */
+  _codeToLocator(expr) {
+    const testidMatch = expr.match(/getByTestId\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (testidMatch) {
+      return {
+        selector: `internal:testid=[data-testid="${testidMatch[1]}"s]`,
+        locator: { kind: "test-id", body: testidMatch[1], options: {} }
+      };
+    }
+    const roleMatch = expr.match(/getByRole\(\s*['"]([^'"]+)['"](?:\s*,\s*\{[^}]*name:\s*['"]([^'"]+)['"][^}]*\})?\s*\)/);
+    if (roleMatch) {
+      return {
+        selector: roleMatch[2] ? `internal:role=${roleMatch[1]}[name="${roleMatch[2]}"i]` : `internal:role=${roleMatch[1]}`,
+        locator: { kind: "role", body: roleMatch[1], options: { attrs: [], exact: false, ...roleMatch[2] ? { name: roleMatch[2] } : {} } }
+      };
+    }
+    const labelMatch = expr.match(/getByLabel\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (labelMatch) {
+      return {
+        selector: `internal:label="${labelMatch[1]}"i`,
+        locator: { kind: "label", body: labelMatch[1], options: { exact: false } }
+      };
+    }
+    const textMatch = expr.match(/getByText\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (textMatch) {
+      return {
+        selector: `internal:text="${textMatch[1]}"i`,
+        locator: { kind: "text", body: textMatch[1], options: { exact: false } }
+      };
+    }
+    const ariaRefMatch = expr.match(/locator\(\s*['"]aria-ref=(\w+)['"]\s*\)/);
+    if (ariaRefMatch) {
+      return null;
+    }
+    return null;
+  }
+  /**
+   * When hover resolves to a text-based locator (e.g. getByText("$849.98")),
+   * check if that text appears multiple times in the snapshot (ambiguous) and
+   * hover ancestor refs to find a parent with a test-id, producing a chained
+   * selector like `testid >> text` that uniquely identifies the element.
+   */
+  async _improveTextSelector(snapLines, ref, original) {
+    const textBody = original.locator.body;
+    const occurrences = snapLines.filter((l) => l.includes(textBody)).length;
+    if (occurrences <= 1)
+      return null;
+    traceDebug(`Text "${textBody}" appears ${occurrences} times in snapshot \u2014 looking for parent test-id`);
+    const refPattern = `[ref=${ref}]`;
+    const refIdx = snapLines.findIndex((l) => l.includes(refPattern));
+    if (refIdx < 0)
+      return null;
+    const refIndent = snapLines[refIdx].match(/^(\s*)/)?.[1]?.length ?? 0;
+    for (let i = refIdx - 1; i >= 0; i--) {
+      const line = snapLines[i];
+      const indent = line.match(/^(\s*)/)?.[1]?.length ?? 0;
+      if (indent >= refIndent)
+        continue;
+      const ancestorRefMatch = line.match(/\[ref=(\w+)\]/);
+      if (!ancestorRefMatch)
+        continue;
+      const ancestorRef = ancestorRefMatch[1];
+      try {
+        const ancestorHover = await this._browserBackend.callTool("browser_hover", {
+          element: "parent element",
+          ref: ancestorRef
+        });
+        if (!ancestorHover.isError) {
+          const ancestorCode = (0, import_response.parseResponse)(ancestorHover)?.code ?? "";
+          const ancestorLocatorMatch = ancestorCode.match(/await\s+page\.(.*?)\.hover\(\)/s);
+          if (ancestorLocatorMatch) {
+            const ancestorExpr = ancestorLocatorMatch[1].trim();
+            const testidMatch = ancestorExpr.match(/getByTestId\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (testidMatch) {
+              const testid = testidMatch[1];
+              const chainedSelector = `internal:testid=[data-testid="${testid}"s] >> internal:text="${textBody}"i`;
+              traceDebug(`Improved to chained selector: ${chainedSelector}`);
+              return {
+                selector: chainedSelector,
+                locator: {
+                  kind: "test-id",
+                  body: testid,
+                  options: {},
+                  next: { kind: "text", body: textBody, options: { exact: false } }
+                }
+              };
+            }
+          }
+        }
+      } catch {
+      }
+      if (indent === 0)
+        break;
+    }
+    return null;
+  }
+  static {
+    /** Extract selector and locator info from a snapshot line for assertion tracking. */
+    // Roles that map to valid Playwright getByRole() selectors.
+    // 'generic', 'paragraph', etc. are NOT valid for getByRole.
+    this.ASSERTABLE_ROLES = /* @__PURE__ */ new Set([
+      "button",
+      "link",
+      "heading",
+      "textbox",
+      "checkbox",
+      "radio",
+      "combobox",
+      "listbox",
+      "option",
+      "tab",
+      "tabpanel",
+      "dialog",
+      "alert",
+      "img",
+      "navigation",
+      "banner",
+      "main",
+      "form",
+      "table",
+      "row",
+      "cell",
+      "columnheader",
+      "rowheader",
+      "spinbutton",
+      "slider",
+      "switch",
+      "menu",
+      "menuitem"
+    ]);
+  }
+  _extractLocatorForRef(refLine) {
+    const testidMatch = refLine.match(/testid="([^"]+)"/);
+    if (testidMatch) {
+      return {
+        selector: `internal:testid=[data-testid="${testidMatch[1]}"s]`,
+        locator: { kind: "test-id", body: testidMatch[1], options: {} }
+      };
+    }
+    const roleMatch = refLine.match(/^\s*-\s*(\w+)\s+"([^"]*)"/);
+    if (roleMatch && TraceRecordingBackend.ASSERTABLE_ROLES.has(roleMatch[1])) {
+      const role = roleMatch[1];
+      const name = roleMatch[2];
+      return {
+        selector: `internal:role=${role}[name="${name}"i]`,
+        locator: { kind: "role", body: role, options: { attrs: [], exact: false, name } }
+      };
+    }
+    if (roleMatch && roleMatch[2]) {
+      const text = roleMatch[2];
+      return {
+        selector: `internal:text="${text}"i`,
+        locator: { kind: "text", body: text, options: { exact: false } }
+      };
+    }
+    return null;
+  }
   _maybeTrackAction(toolName, args, result, timestamp) {
     if (result.isError)
       return;
     if (toolName === "browser_press_key") {
       const key = String(args.key || "").toLowerCase();
-      if (key.includes("control+") || key.includes("meta+"))
+      if (key.includes("control+") || key.includes("meta+") || key === "tab" || key === "enter" || key === "escape")
         return;
     }
     const parsed = (0, import_response.parseResponse)(result);

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

@@ -229,6 +229,58 @@ function trackedActionToJsonl(action, pageGuid, timestamp) {
     return JSON.stringify({ name: "click", selector, button: "left", modifiers: 0, clickCount: 1, locator: locatorObj, ...base });
   return null;
 }
+function assertActionToJsonl(action, pageGuid, timestamp) {
+  const { args, code } = action;
+  const assertType = args.type;
+  const base = {
+    signals: [],
+    timestamp: String(timestamp),
+    pageGuid,
+    pageAlias: PAGE_ALIAS,
+    framePath: FRAME_PATH
+  };
+  const parts = code.split(":");
+  const selectorPart = parts[1] || "";
+  let selector = "";
+  let expected = "";
+  let substring = true;
+  if (assertType === "visible") {
+    selector = parts.slice(1).join(":");
+  } else if (assertType === "text") {
+    substring = parts[parts.length - 1] === "true";
+    expected = parts[parts.length - 2] || "";
+    selector = parts.slice(1, parts.length - 2).join(":");
+  } else if (assertType === "value") {
+    expected = parts[parts.length - 1] || "";
+    selector = parts.slice(1, parts.length - 1).join(":");
+  }
+  const locator = selectorToLocator(selector);
+  switch (assertType) {
+    case "text":
+      return JSON.stringify({ name: "assertText", selector, text: expected, substring, locator, ...base });
+    case "visible":
+      return JSON.stringify({ name: "assertVisible", selector, locator, ...base });
+    case "value":
+      return JSON.stringify({ name: "assertValue", selector, value: expected, locator, ...base });
+    default:
+      return null;
+  }
+}
+function selectorToLocator(selector) {
+  const testidMatch = selector.match(/internal:testid=\[data-testid="([^"]+)"/);
+  if (testidMatch)
+    return { kind: "test-id", body: testidMatch[1], options: {} };
+  const roleMatch = selector.match(/internal:role=(\w+)\[name="([^"]+)"([is])?\]/);
+  if (roleMatch)
+    return { kind: "role", body: roleMatch[1], options: { attrs: [], exact: roleMatch[3] === "s", name: roleMatch[2] } };
+  const roleOnlyMatch = selector.match(/internal:role=(\w+)$/);
+  if (roleOnlyMatch)
+    return { kind: "role", body: roleOnlyMatch[1], options: { attrs: [] } };
+  const textMatch = selector.match(/internal:text="([^"]+)"([is])?/);
+  if (textMatch)
+    return { kind: "text", body: textMatch[1], options: { exact: textMatch[2] === "s" } };
+  return {};
+}
 function fillFormToJsonl(action, pageGuid, baseTimestamp) {
   const { args } = action;
   if (!args.fields)
@@ -280,6 +332,14 @@ function buildJsonlContent(actions, browserName, harPath) {
       actionCount += formLines.length;
       continue;
     }
+    if (action.toolName === "browser_assert") {
+      const assertLine = assertActionToJsonl(action, pageGuid, action.timestamp);
+      if (assertLine) {
+        lines.push(assertLine);
+        actionCount++;
+      }
+      continue;
+    }
     const line = trackedActionToJsonl(action, pageGuid, action.timestamp);
     if (line) {
       lines.push(line);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.64-rc.8",
+  "version": "0.0.64",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@playwright/test": "^1.55.0",
-    "@skyramp/skyramp": "1.3.16",
+    "@skyramp/skyramp": "1.3.17",
     "dockerode": "^4.0.6",
     "fast-glob": "^3.3.3",
     "playwright": "file:vendor/skyramp-playwright-1.58.2-skyramp.8.9.0.tgz",