@skyramp/mcp 0.3.4 → 0.3.6-rc.1

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

@@ -28,16 +28,20 @@ const assertToolSchema = {
   name: "browser_assert",
   title: "Assert element state",
   description: [
-    "Assert that an element has expected text, value, or is visible.",
+    "Assert that an element has expected text, value, or state.",
     "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.'
+    'Types: "text" checks element text content, "value" checks input field value,',
+    '"checked" checks checkbox/radio state, "disabled" checks disabled/enabled state,',
+    '"visible" checks the element is visible,',
+    `"count" counts elements sharing the referenced element's role (or exact text)`,
+    "across the page, e.g. ref one option of an open dropdown to assert the number of options."
   ].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"),
+    type: import_mcpBundle.z.enum(["text", "value", "checked", "disabled", "visible", "count"]).describe(`Type of assertion: "text" for text content, "value" for input field value, "checked" for checkbox/radio state, "disabled" for disabled/enabled state ("false" asserts the element is enabled), "visible" for element visibility, "count" for the number of elements with the referenced element's role`),
+    ref: import_mcpBundle.z.string().describe('Element reference from the latest snapshot. For "count", reference one exemplar element (e.g. one option in an open dropdown).'),
     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"),
+    expected: import_mcpBundle.z.string().optional().describe('Expected text or value ("text"/"value"), "true"/"false" ("checked"/"disabled", default "true"; "disabled" with "false" asserts enabled), the expected element count ("count"). Not used for "visible".'),
     substring: import_mcpBundle.z.boolean().optional().default(true).describe("For text assertions: match as substring (true) or exact match (false)")
   }),
   type: "readOnly"

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

@@ -370,6 +370,22 @@ async function performClientAction(page, actionInContext) {
         throw new Error(`assertVisible failed: element is not visible`);
       return;
     }
+    case "assertDisabled": {
+      if (typeof action.disabled !== "boolean")
+        throw new Error(`assertDisabled failed: trace line has no boolean "disabled" field`);
+      const disabled = await locator.isDisabled(opts);
+      if (disabled !== action.disabled)
+        throw new Error(`assertDisabled failed: expected disabled=${action.disabled}, got ${disabled}`);
+      return;
+    }
+    case "assertCount": {
+      await locator.first().waitFor(opts).catch(() => {
+      });
+      const count = await locator.count();
+      if (count !== action.count)
+        throw new Error(`assertCount failed: expected ${action.count} element(s), got ${count}`);
+      return;
+    }
     default:
       return;
   }

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

@@ -61,6 +61,8 @@ const ACTION_NAMES = /* @__PURE__ */ new Set([
   "assertValue",
   "assertChecked",
   "assertVisible",
+  "assertDisabled",
+  "assertCount",
   "assertSnapshot",
   "visualSnapshot",
   "assertTableCell",

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

@@ -855,6 +855,14 @@ Continue recording with browser_* tools, then call skyramp_export_zip to write t
         return { toolName: "browser_assert", code: `assertChecked:${a.selector}:${!!a.checked}`, args: { type: "checked", selector: a.selector, checked: !!a.checked } };
       case "assertVisible":
         return { toolName: "browser_assert", code: `assertVisible:${a.selector}`, args: { type: "visible", selector: a.selector } };
+      case "assertDisabled":
+        if (typeof a.disabled !== "boolean")
+          return null;
+        return { toolName: "browser_assert", code: `assertDisabled:${a.selector}:${a.disabled}`, args: { type: "disabled", selector: a.selector, disabled: a.disabled } };
+      case "assertCount":
+        if (typeof a.count !== "number" || !Number.isInteger(a.count) || a.count < 0)
+          return null;
+        return { toolName: "browser_assert", code: `assertCount:${a.selector}:${a.count}`, args: { type: "count", selector: a.selector, count: a.count } };
       case "visualSnapshot": {
         const args = this._seedVisualSnapshotArgs(a);
         return args ? { toolName: "browser_visual_snapshot", code: "", args } : null;
@@ -1260,8 +1268,13 @@ Linked GoJS nodes ${params.fromKey} \u2192 ${params.toKey} (${params.fromPort}\u
    */
   async _handleAssert(params) {
     const timestamp = Date.now();
-    if (!params.expected)
+    if (!params.expected && (params.type === "text" || params.type === "value" || params.type === "count"))
       return { content: [{ type: "text", text: '### Error\n"expected" parameter is required.' }], isError: true };
+    if (params.type === "count" && !/^\d+$/.test(params.expected))
+      return { content: [{ type: "text", text: '### Error\nFor "count" assertions, "expected" must be a non-negative integer.' }], isError: true };
+    if ((params.type === "checked" || params.type === "disabled") && params.expected !== void 0 && params.expected !== "true" && params.expected !== "false")
+      return { content: [{ type: "text", text: `### Error
+For "${params.type}" assertions, "expected" must be "true" or "false".` }], isError: true };
     const hoverResult = await this._browserBackend.callTool("browser_hover", {
       element: params.element,
       ref: params.ref
@@ -1312,30 +1325,105 @@ Could not parse locator: ${locatorExpr}` }], isError: true };
     }
     let passed = false;
     let details = "";
+    let countSelector = "";
     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 {
+    } else if (params.type === "value") {
       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}".`;
+    } else if (params.type === "checked" || params.type === "disabled") {
+      if (!refLine) {
+        passed = false;
+        details = `${params.type === "checked" ? "Checked" : "Disabled"} assertion FAILED: "${params.element}" (ref=${params.ref}) is not in the current snapshot \u2014 re-snapshot and retry with a fresh ref.`;
+      } else if (params.type === "checked") {
+        const expectChecked = params.expected !== "false";
+        const isChecked = refLine.includes("[checked]");
+        const isMixed = refLine.includes("[checked=mixed]");
+        passed = expectChecked ? isChecked : !isChecked && !isMixed;
+        details = passed ? `Checked assertion passed: "${params.element}" is ${expectChecked ? "checked" : "unchecked"}.` : `Checked assertion FAILED: "${params.element}" is ${isMixed ? "mixed" : isChecked ? "checked" : "unchecked"}, expected ${expectChecked ? "checked" : "unchecked"}.`;
+      } else {
+        const expectDisabled = params.expected !== "false";
+        const isDisabled = refLine.includes("[disabled]");
+        passed = expectDisabled === isDisabled;
+        details = passed ? `Disabled assertion passed: "${params.element}" is ${expectDisabled ? "disabled" : "enabled"}.` : `Disabled assertion FAILED: "${params.element}" is ${isDisabled ? "disabled" : "enabled"}, expected ${expectDisabled ? "disabled" : "enabled"}.`;
+      }
+    } else if (params.type === "visible") {
+      passed = !!refLine;
+      details = passed ? `Visibility assertion passed: "${params.element}" is visible.` : `Visibility assertion FAILED: "${params.element}" (ref=${params.ref}) is not in the current snapshot.`;
+    } else {
+      const refRole = (parsed.locator.kind === "role" ? String(parsed.locator.body) : "") || refLine.match(/^\s*-\s*(\w+)/)?.[1] || "";
+      if (!refRole) {
+        return { content: [{ type: "text", text: `### Assertion Failed
+Could not determine the role of ref=${params.ref} for a count assertion.` }], isError: true };
+      }
+      if (!TraceRecordingBackend.COUNTABLE_ROLES.has(refRole)) {
+        return { content: [{ type: "text", text: `### Assertion Failed
+Role "${refRole}" is not countable \u2014 reference an exemplar with a semantic role (listitem, option, row, button, link, \u2026).` }], isError: true };
+      }
+      const tab = this._browserBackend.context?.currentTab();
+      if (!tab) {
+        return { content: [{ type: "text", text: "### Assertion Failed\nNo active page." }], isError: true };
+      }
+      countSelector = `internal:role=${refRole}`;
+      let countActual;
+      try {
+        countActual = await tab.page.getByRole(refRole).count();
+      } catch (e) {
+        return { content: [{ type: "text", text: `### Assertion Failed
+Could not count "${refRole}" elements: ${e.message}` }], isError: true };
+      }
+      passed = countActual === Number(params.expected);
+      details = passed ? `Count assertion passed: ${countActual} "${refRole}" element(s) on the page.` : `Count assertion FAILED: found ${countActual} "${refRole}" element(s), expected ${params.expected}.`;
     }
     if (passed) {
       const recordedExpected = params.type === "text" && params.substring !== false ? (0, import_utils.stableTextLead)(params.expected) : params.expected;
       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 === recordedExpected) {
+      const tautological = Boolean((params.type === "text" || params.type === "value") && selectorText && selectorText === recordedExpected);
+      if (tautological) {
         traceDebug(`Skipped tautological assertion: selector already matches "${recordedExpected}"`);
       } else {
-        const assertName = params.type === "value" ? "assertValue" : "assertText";
-        this._trackedActions.push({
-          toolName: "browser_assert",
-          // Pass selector/expected as structured args so assertActionToJsonl can
-          // decode unambiguously (the colon-encoded code below corrupts values
-          // that contain ':', e.g. URLs). The code string is a fallback only.
-          args: { type: params.type, ref: params.ref, selector: parsed.selector, expected: recordedExpected, ...params.type === "text" ? { substring: params.substring } : {} },
-          code: `${assertName}:${parsed.selector}:${recordedExpected}${params.type === "text" ? ":" + params.substring : ""}`,
-          timestamp
-        });
-        traceDebug(`Assert: ${assertName} with selector ${parsed.selector}`);
+        let assertName;
+        let args;
+        let code;
+        switch (params.type) {
+          case "checked": {
+            const expectChecked = params.expected !== "false";
+            assertName = "assertChecked";
+            args = { type: "checked", ref: params.ref, selector: parsed.selector, checked: expectChecked };
+            code = `assertChecked:${parsed.selector}:${expectChecked}`;
+            break;
+          }
+          case "disabled": {
+            const expectDisabled = params.expected !== "false";
+            assertName = "assertDisabled";
+            args = { type: "disabled", ref: params.ref, selector: parsed.selector, disabled: expectDisabled };
+            code = `assertDisabled:${parsed.selector}:${expectDisabled}`;
+            break;
+          }
+          case "visible":
+            assertName = "assertVisible";
+            args = { type: "visible", ref: params.ref, selector: parsed.selector };
+            code = `assertVisible:${parsed.selector}`;
+            break;
+          case "count":
+            assertName = "assertCount";
+            args = { type: "count", ref: params.ref, selector: countSelector, count: Number(params.expected) };
+            code = `assertCount:${countSelector}:${params.expected}`;
+            break;
+          case "value":
+            assertName = "assertValue";
+            args = { type: "value", ref: params.ref, selector: parsed.selector, expected: recordedExpected };
+            code = `assertValue:${parsed.selector}:${recordedExpected}`;
+            break;
+          default:
+            assertName = "assertText";
+            args = { type: "text", ref: params.ref, selector: parsed.selector, expected: recordedExpected, substring: params.substring };
+            code = `assertText:${parsed.selector}:${recordedExpected}:${params.substring}`;
+            break;
+        }
+        this._trackedActions.push({ toolName: "browser_assert", args, code, timestamp });
+        traceDebug(`Assert: ${assertName} with selector ${args.selector}`);
       }
     }
     return {
@@ -1570,6 +1658,19 @@ Cell row ${params.row}, column ${params.column} has "${actual}", expected "${par
       "menuitem"
     ]);
   }
+  static {
+    // Roles browser_assert type:"count" may generalize page-wide. Superset of
+    // ASSERTABLE_ROLES (kept separate — that set is for name-bearing
+    // single-element selector extraction; widening one must not loosen the
+    // other) plus the collection-item roles that are the natural count targets.
+    this.COUNTABLE_ROLES = /* @__PURE__ */ new Set([
+      ...TraceRecordingBackend.ASSERTABLE_ROLES,
+      "listitem",
+      "article",
+      "gridcell",
+      "treeitem"
+    ]);
+  }
   _extractLocatorForRef(refLine) {
     const testidMatch = refLine.match(/testid="([^"]+)"/);
     if (testidMatch) {

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

@@ -437,6 +437,10 @@ function assertActionToJsonl(action, pageGuid, timestamp) {
       expected = args.expected ?? "";
     } else if (assertType === "checked") {
       expected = String(args.checked === true || args.expected === "true" || args.expected === true);
+    } else if (assertType === "disabled") {
+      expected = String(args.disabled === true || args.expected === "true" || args.expected === true);
+    } else if (assertType === "count") {
+      expected = String(args.count ?? args.expected ?? "");
     }
   } else {
     const parts = code.split(":");
@@ -446,7 +450,7 @@ function assertActionToJsonl(action, pageGuid, timestamp) {
       substring = parts[parts.length - 1] === "true";
       expected = parts[parts.length - 2] || "";
       selector = parts.slice(1, parts.length - 2).join(":");
-    } else if (assertType === "value" || assertType === "checked") {
+    } else if (assertType === "value" || assertType === "checked" || assertType === "disabled" || assertType === "count") {
       expected = parts[parts.length - 1] || "";
       selector = parts.slice(1, parts.length - 1).join(":");
     }
@@ -461,6 +465,14 @@ function assertActionToJsonl(action, pageGuid, timestamp) {
       return JSON.stringify({ name: "assertValue", selector, value: expected, locator, ...base });
     case "checked":
       return JSON.stringify({ name: "assertChecked", selector, checked: expected === "true", locator, ...base });
+    case "disabled":
+      return JSON.stringify({ name: "assertDisabled", selector, disabled: expected === "true", locator, ...base });
+    case "count": {
+      const count = Number(expected);
+      if (!/^\d+$/.test(expected) || !Number.isInteger(count))
+        return null;
+      return JSON.stringify({ name: "assertCount", selector, count, locator, ...base });
+    }
     default:
       return null;
   }

package/node_modules/playwright/node_modules/playwright-core/lib/server/codegen/skyramp/jsonlReader.js

@@ -128,6 +128,8 @@ const _ACTION_NAMES = /* @__PURE__ */ new Set([
   "assertValue",
   "assertChecked",
   "assertVisible",
+  "assertDisabled",
+  "assertCount",
   "assertSnapshot",
   "visualSnapshot",
   "assertTableCell",