@swmansion/argent 0.15.1-next.4 → 0.15.1-next.6

package/dist/tool-server.cjs

@@ -126102,7 +126102,10 @@ var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 var zodSchema16 = external_exports.object({
   udid: external_exports.string().describe("Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id)."),
   x: external_exports.number().describe("Normalized horizontal position 0.0\u20131.0 (left=0, right=1), not pixels"),
-  y: external_exports.number().describe("Normalized vertical position 0.0\u20131.0 (top=0, bottom=1), not pixels")
+  y: external_exports.number().describe("Normalized vertical position 0.0\u20131.0 (top=0, bottom=1), not pixels"),
+  clickCount: external_exports.number().int().min(1).max(10).optional().describe(
+    "Number of taps/clicks dispatched as ONE multi-tap gesture (2 = double-tap / double-click). The taps land inside the OS double-tap window; on Chromium each click carries an escalating CDP clickCount so dblclick actually fires. Default 1."
+  )
 });
 var capability8 = {
   apple: { simulator: true, device: true },
@@ -126110,19 +126113,25 @@ var capability8 = {
   android: { emulator: true, device: true, unknown: true },
   chromium: { app: true }
 };
-async function tapChromium(api, x, y) {
+var TAP_HOLD_MS = 50;
+var MULTI_TAP_GAP_MS = 100;
+async function tapChromium(api, x, y, clickCount) {
   const vp = api.getViewport();
   const pxX = Math.max(0, Math.min(vp.width, x * vp.width));
   const pxY = Math.max(0, Math.min(vp.height, y * vp.height));
   await api.dispatchMouseEvent({ type: "mouseMoved", x: pxX, y: pxY });
-  await api.dispatchMouseEvent({ type: "mousePressed", x: pxX, y: pxY, clickCount: 1 });
-  await sleep2(50);
-  await api.dispatchMouseEvent({ type: "mouseReleased", x: pxX, y: pxY, clickCount: 1 });
+  for (let i = 1; i <= clickCount; i++) {
+    if (i > 1) await sleep2(MULTI_TAP_GAP_MS);
+    await api.dispatchMouseEvent({ type: "mousePressed", x: pxX, y: pxY, clickCount: i });
+    await sleep2(TAP_HOLD_MS);
+    await api.dispatchMouseEvent({ type: "mouseReleased", x: pxX, y: pxY, clickCount: i });
+  }
 }
 var gestureTapTool = {
   id: "gesture-tap",
   description: `Press the device screen (iOS simulator, Android emulator, or Chromium app) at normalized coordinates: x and y are fractions of screen width and height in 0.0\u20131.0 (not pixels).
 Sends a Down event followed by an Up event at the same point. For Chromium, this dispatches a CDP mouse-press/release on the renderer.
+Set clickCount: 2 for a double-tap / double-click \u2014 the taps are dispatched as one gesture with proper click counting, which two separate tap calls cannot guarantee.
 Use when you need to tap a button, link, or any tappable element on the screen.
 Returns { tapped: true, timestampMs }. Fails if the simulator-server / emulator backend / Chromium CDP is not reachable for the given device.
 Before tapping, determine the correct coordinates by using discovery tools \u2014 pick by platform: iOS / Android use \`describe\`, \`native-describe-screen\`, or \`debugger-component-tree\`; Chromium uses \`describe\` (the DOM walker), since the native and RN-specific discovery tools don't apply. More information in \`argent-device-interact\` skill`,
@@ -126140,29 +126149,33 @@ Before tapping, determine the correct coordinates by using discovery tools \u201
   async execute(services, params) {
     const device = resolveDevice(params.udid);
     const timestampMs = Date.now();
+    const clickCount = params.clickCount ?? 1;
     if (device.platform === "chromium") {
       const chromium = services.chromium;
-      await tapChromium(chromium, params.x, params.y);
+      await tapChromium(chromium, params.x, params.y, clickCount);
       return { tapped: true, timestampMs };
     }
     const api = services.simulatorServer;
-    sendCommand(api, {
-      cmd: "touch",
-      type: "Down",
-      x: params.x,
-      y: params.y,
-      second_x: null,
-      second_y: null
-    });
-    await sleep2(50);
-    sendCommand(api, {
-      cmd: "touch",
-      type: "Up",
-      x: params.x,
-      y: params.y,
-      second_x: null,
-      second_y: null
-    });
+    for (let i = 1; i <= clickCount; i++) {
+      if (i > 1) await sleep2(MULTI_TAP_GAP_MS);
+      sendCommand(api, {
+        cmd: "touch",
+        type: "Down",
+        x: params.x,
+        y: params.y,
+        second_x: null,
+        second_y: null
+      });
+      await sleep2(TAP_HOLD_MS);
+      sendCommand(api, {
+        cmd: "touch",
+        type: "Up",
+        x: params.x,
+        y: params.y,
+        second_x: null,
+        second_y: null
+      });
+    }
     return { tapped: true, timestampMs };
   }
 };
@@ -133155,7 +133168,7 @@ async function describeVega(_serial) {
 
 // ../tool-server/src/utils/ui-tree-match.ts
 init_zod();
-var selectorSchema = external_exports.object({
+var selectorFieldsSchema = external_exports.object({
   text: external_exports.string().min(1).optional().describe("Case-insensitive substring of the element's visible label or value."),
   identifier: external_exports.string().min(1).optional().describe(
     "The element's identifier (accessibilityIdentifier / resource-id / testid), matched case-insensitively as the exact identifier or the unqualified resource-id name ('submit' matches 'com.example.app:id/submit')."
@@ -133163,9 +133176,13 @@ var selectorSchema = external_exports.object({
   role: external_exports.string().min(1).optional().describe(
     "Case-insensitive substring of the element's role (e.g. AXButton, button, TextView)."
   )
-}).refine((s) => Boolean(s.text || s.identifier || s.role), {
-  message: "selector needs at least one of text, identifier, or role"
-});
+}).strict();
+var selectorSchema = selectorFieldsSchema.refine(
+  (s) => Boolean(s.text || s.identifier || s.role),
+  {
+    message: "selector needs at least one of text, identifier, or role"
+  }
+);
 function nodeText(node) {
   return [node.label, node.value].filter(Boolean).join(" ");
 }
@@ -133182,15 +133199,32 @@ function identifierMatches(actual, needle) {
   if (!actual) return false;
   return equalsCI(actual, needle) || actual.toLowerCase().endsWith(`:id/${needle.toLowerCase()}`);
 }
+var uiTreeMatchInternals = {
+  createRegExp(pattern) {
+    return new RegExp(pattern);
+  }
+};
+function regexMatchesNonEmpty(regex, actual) {
+  if (!actual) return false;
+  return regex.test(actual);
+}
 function textMatches(actual, expected, mode) {
+  if (mode === "matches") {
+    return regexMatchesNonEmpty(uiTreeMatchInternals.createRegExp(expected), actual);
+  }
   return mode === "equals" ? equalsCI(actual, expected) : includesCI(actual, expected);
 }
-function matchNode(node, selector) {
+function matchNodeWithRegex(node, selector, textRegex) {
   if (selector.text !== void 0) {
     if (!includesCI(node.label, selector.text) && !includesCI(node.value, selector.text)) {
       return false;
     }
   }
+  if (textRegex !== void 0) {
+    if (!regexMatchesNonEmpty(textRegex, node.label) && !regexMatchesNonEmpty(textRegex, node.value)) {
+      return false;
+    }
+  }
   if (selector.identifier !== void 0 && !identifierMatches(node.identifier, selector.identifier)) {
     return false;
   }
@@ -133199,13 +133233,17 @@ function matchNode(node, selector) {
   }
   return true;
 }
-function collectMatches(node, selector, acc) {
-  if (matchNode(node, selector)) acc.push(node);
-  for (const child of node.children) collectMatches(child, selector, acc);
+function selectorTextRegex(selector) {
+  return selector.textMatches === void 0 ? void 0 : uiTreeMatchInternals.createRegExp(selector.textMatches);
+}
+function collectMatches(node, selector, textRegex, acc) {
+  if (matchNodeWithRegex(node, selector, textRegex)) acc.push(node);
+  for (const child of node.children) collectMatches(child, selector, textRegex, acc);
 }
 function findAll(root2, selector) {
   const acc = [];
-  for (const child of root2.children) collectMatches(child, selector, acc);
+  const textRegex = selectorTextRegex(selector);
+  for (const child of root2.children) collectMatches(child, selector, textRegex, acc);
   return acc;
 }
 function isVisible(node) {
@@ -133269,21 +133307,29 @@ function nodeAtPoint(root2, point) {
   for (const child of root2.children) walk(child);
   return best;
 }
-function exactFieldCount(node, selector) {
+function fullConsumptionRegex(selector) {
+  return selector.textMatches === void 0 ? void 0 : uiTreeMatchInternals.createRegExp(`^(?:${selector.textMatches})$`);
+}
+function exactFieldCount(node, selector, fullTextRegex) {
   let count = 0;
   if (selector.text !== void 0 && (equalsCI(node.label, selector.text) || equalsCI(node.value, selector.text))) {
     count++;
   }
+  if (fullTextRegex !== void 0 && (regexMatchesNonEmpty(fullTextRegex, node.label) || regexMatchesNonEmpty(fullTextRegex, node.value))) {
+    count++;
+  }
   if (selector.identifier !== void 0 && equalsCI(node.identifier, selector.identifier)) count++;
   if (selector.role !== void 0 && equalsCI(node.role, selector.role)) count++;
   return count;
 }
 function selectorToFrame(root2, selector) {
   const visible = findAll(root2, selector).filter(isVisible);
+  if (visible.length === 0) return void 0;
+  const fullTextRegex = fullConsumptionRegex(selector);
   let best;
   let bestExact = -1;
   for (const n of visible) {
-    const exact = exactFieldCount(n, selector);
+    const exact = exactFieldCount(n, selector, fullTextRegex);
     if (best === void 0 || exact !== bestExact) {
       if (exact > bestExact) {
         best = n;
@@ -133567,7 +133613,7 @@ a prior tap), use individual tool calls instead.
 
 Allowed tools and their args (udid is auto-injected, do NOT include it in args):
 
-  gesture-tap:    { x: number, y: number }                                                                              [ios/android/chromium]
+  gesture-tap:    { x: number, y: number, clickCount?: number }                                                        [ios/android/chromium]
   gesture-swipe:  { fromX: number, fromY: number, toX: number, toY: number, durationMs?: number }                       [ios/android]
   gesture-scroll: { x: number, y: number, deltaX?: number, deltaY?: number, durationMs?: number }                       [chromium only]
   gesture-drag:   { fromX: number, fromY: number, toX: number, toY: number, durationMs?: number }                       [chromium only]
@@ -144506,14 +144552,67 @@ function chromiumLaunchSpec(launch) {
   return typeof c === "string" ? { path: c } : { path: c.path, args: c.args };
 }
 function selectorToYaml(sel) {
+  if (sel.text !== void 0 && sel.textMatches !== void 0) {
+    throw new Error(
+      'Cannot serialize flow selector without losing constraints: both `text` and `textMatches` are set, but flow YAML can represent only one `text` constraint (a literal string or `{ matches: "<regex>" }`). Use either literal or regex text matching.'
+    );
+  }
+  if (sel.loose && sel.text !== void 0 && (typeof sel.text !== "string" || sel.text.length === 0)) {
+    throw new Error(
+      "Cannot serialize loose flow selector: `text` must be a non-empty string so bare-string YAML can round-trip through selector validation."
+    );
+  }
+  if (sel.loose && (sel.text === void 0 || sel.textMatches !== void 0 || sel.identifier !== void 0 || sel.role !== void 0)) {
+    const incompatible = [
+      sel.textMatches !== void 0 ? "textMatches" : void 0,
+      sel.identifier !== void 0 ? "identifier" : void 0,
+      sel.role !== void 0 ? "role" : void 0
+    ].filter((field) => field !== void 0);
+    throw new Error(
+      "Cannot serialize loose flow selector without changing its meaning: bare-string YAML can represent only a loose text-only selector" + (incompatible.length > 0 ? `; incompatible fields: ${incompatible.join(", ")}` : "") + "."
+    );
+  }
   if (sel.loose && sel.text !== void 0 && sel.identifier === void 0 && sel.role === void 0) {
     return sel.text;
   }
-  const { loose: _loose, identifier, ...rest } = sel;
-  return identifier === void 0 ? { ...rest } : { ...rest, id: identifier };
+  const { loose: _loose, identifier, textMatches: textMatches2, ...rest } = sel;
+  const out = { ...rest };
+  if (textMatches2 !== void 0) out.text = { matches: textMatches2 };
+  if (identifier !== void 0) out.id = identifier;
+  return out;
 }
 function describeSelector(s) {
-  return Object.entries(s).filter(([k]) => k !== "loose").map(([k, v]) => `${k === "identifier" ? "id" : k}="${v}"`).join(" ");
+  return Object.entries(s).filter(([k]) => k !== "loose").map(
+    ([k, v]) => k === "textMatches" ? `text=/${v}/` : `${k === "identifier" ? "id" : k}="${v}"`
+  ).join(" ");
+}
+function describeTextExpectation(expectedText, textMatch, verbForm = "mode") {
+  const expected = expectedText ?? "";
+  const mode = textMatch ?? "contains";
+  switch (mode) {
+    case "contains":
+      return `${verbForm === "infinitive" ? "contain" : mode} ${JSON.stringify(expected)}`;
+    case "equals":
+      return `${verbForm === "infinitive" ? "equal" : mode} ${JSON.stringify(expected)}`;
+    case "matches":
+      return `${verbForm === "infinitive" ? "match" : mode} /${expected}/`;
+  }
+}
+function textWaitToYaml(selector, expectedText, textMatch) {
+  const expected = expectedText ?? "";
+  const mode = textMatch ?? "contains";
+  switch (mode) {
+    case "contains":
+      return { text: { in: selector, contains: expected } };
+    case "equals":
+      return { text: { in: selector, equals: expected } };
+    case "matches":
+      return { text: { in: selector, matches: expected } };
+    default: {
+      const exhaustive = mode;
+      throw new Error(`Unsupported text match mode: ${exhaustive}`);
+    }
+  }
 }
 function waitToYaml(condition, selector, expectedText, textMatch, timeoutMs) {
   const sel = selectorToYaml(selector);
@@ -144529,7 +144628,7 @@ function waitToYaml(condition, selector, expectedText, textMatch, timeoutMs) {
       body = { hidden: sel };
       break;
     case "text":
-      body = textMatch === "equals" ? { text: { in: sel, equals: expectedText ?? "" } } : { text: { in: sel, contains: expectedText ?? "" } };
+      body = textWaitToYaml(sel, expectedText, textMatch);
       break;
   }
   if (timeoutMs !== void 0) body.timeout = timeoutMs;
@@ -144544,7 +144643,12 @@ function toYamlStep(step) {
     case "run":
       return { run: step.flow };
     case "tap": {
-      const body = step.selector ? selectorToYaml(step.selector) : { x: step.x, y: step.y };
+      if (step.selector) {
+        const sel = selectorToYaml(step.selector);
+        return { tap: step.times !== void 0 ? { on: sel, times: step.times } : sel };
+      }
+      const body = { x: step.x, y: step.y };
+      if (step.times !== void 0) body.times = step.times;
       return { tap: body };
     }
     case "long-press": {
@@ -144617,6 +144721,16 @@ function badEntry(raw, detail) {
     error_kind: "validation"
   });
 }
+function validatePattern(raw, pattern, where) {
+  try {
+    new RegExp(pattern);
+  } catch (err) {
+    badEntry(
+      raw,
+      `${where} \`matches\` is not a valid regular expression: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 function editDistance(a, b) {
   let prevPrev = new Array(b.length + 1);
   let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
@@ -144680,11 +144794,46 @@ function parseSelector(raw, where) {
     }
     normalized = { ...rest, identifier: id };
   }
+  if (normalized !== null && typeof normalized === "object") {
+    const { text, ...rest } = normalized;
+    if (text !== null && typeof text === "object") {
+      const keys = Object.keys(text);
+      if (!Array.isArray(text)) {
+        rejectUnknownKeys(
+          raw,
+          text,
+          ["matches"],
+          `${where}: text matcher`
+        );
+      }
+      const pattern = text.matches;
+      if (keys.length !== 1 || keys[0] !== "matches") {
+        badEntry(
+          raw,
+          `${where}: a text matcher takes exactly { matches: '<regex>' } \u2014 for a substring, use the plain-string form (text: "\u2026")`
+        );
+      }
+      if (typeof pattern !== "string" || pattern.length === 0) {
+        badEntry(raw, `${where}: text matcher needs a non-empty \`matches\` pattern`);
+      }
+      validatePattern(raw, pattern, `${where}: text`);
+      const fields = selectorFieldsSchema.safeParse(rest);
+      if (!fields.success) {
+        badEntry(raw, `${where}: ${fields.error.issues[0]?.message ?? "invalid selector"}`);
+      }
+      return { ...fields.data, textMatches: pattern };
+    }
+  }
   const r = selectorSchema.safeParse(normalized);
   if (!r.success) badEntry(raw, `${where}: ${r.error.issues[0]?.message ?? "invalid selector"}`);
   return r.data;
 }
 var WAIT_CONDITIONS = ["exists", "visible", "hidden", "text"];
+var TEXT_MATCH_MODES = Object.keys({
+  contains: true,
+  equals: true,
+  matches: true
+});
 var SCROLL_DIRECTIONS = ["up", "down", "left", "right"];
 function parseWaitFields(raw, kind) {
   if (raw === null || typeof raw !== "object") {
@@ -144724,22 +144873,30 @@ function parseWaitFields(raw, kind) {
   if (condition === "text") {
     const t = b.text;
     if (t === null || typeof t !== "object") {
-      badEntry({ [kind]: b }, `${kind} text needs { in: <selector>, contains|equals: <string> }`);
+      badEntry(
+        { [kind]: b },
+        `${kind} text needs { in: <selector>, contains|equals|matches: <string> }`
+      );
     }
     const tb = t;
     if (!Array.isArray(tb)) {
-      rejectUnknownKeys({ [kind]: b }, tb, ["in", "contains", "equals"], `${kind}.text`);
+      rejectUnknownKeys({ [kind]: b }, tb, ["in", ...TEXT_MATCH_MODES], `${kind}.text`);
     }
-    const hasContains = "contains" in tb;
-    const hasEquals = "equals" in tb;
-    if (hasContains === hasEquals) {
-      badEntry({ [kind]: b }, `${kind} text needs exactly one of \`contains\` or \`equals\``);
+    const comparators = TEXT_MATCH_MODES.filter((mode) => mode in tb);
+    if (comparators.length !== 1) {
+      badEntry(
+        { [kind]: b },
+        `${kind} text needs exactly one of \`contains\`, \`equals\`, or \`matches\``
+      );
     }
-    const textMatch = hasEquals ? "equals" : "contains";
-    const expected = hasEquals ? tb.equals : tb.contains;
+    const textMatch = comparators[0];
+    const expected = tb[textMatch];
     if (typeof expected !== "string" || expected.length === 0) {
       badEntry({ [kind]: b }, `${kind} text needs a non-empty \`${textMatch}\``);
     }
+    if (textMatch === "matches") {
+      validatePattern({ [kind]: b }, expected, `${kind} text`);
+    }
     return {
       condition: "text",
       selector: parseSelector(tb.in, `${kind}.text.in`),
@@ -144839,6 +144996,50 @@ function parseLongPress(body, entry) {
   }
   return { kind: "long-press", selector: parseSelector(body, "long-press") };
 }
+function parseTapTimes(raw, entry) {
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1 || raw > 10) {
+    badEntry(entry, "tap.times must be an integer between 1 and 10 (2 = double-tap)");
+  }
+  return raw === 1 ? void 0 : raw;
+}
+function parseTap(body, entry) {
+  const obj = body !== null && typeof body === "object" ? body : {};
+  if (obj.x !== void 0 || obj.y !== void 0) {
+    if (obj.on !== void 0 || obj.text !== void 0 || obj.id !== void 0 || obj.identifier !== void 0 || obj.role !== void 0) {
+      badEntry(entry, "tap takes a selector or x/y coordinates, not both");
+    }
+    if (typeof obj.x !== "number" || typeof obj.y !== "number") {
+      badEntry(entry, "a coordinate tap needs numeric x and y");
+    }
+    if (!Object.keys(obj).every((k) => k === "x" || k === "y" || k === "times")) {
+      badEntry(entry, "a coordinate tap takes only { x, y, times }");
+    }
+    const step = { kind: "tap", x: obj.x, y: obj.y };
+    const times = parseTapTimes(obj.times, entry);
+    if (times !== void 0) step.times = times;
+    return step;
+  }
+  if (obj.on !== void 0 || obj.times !== void 0) {
+    if (obj.text !== void 0 || obj.id !== void 0 || obj.identifier !== void 0 || obj.role !== void 0) {
+      badEntry(
+        entry,
+        'the tap options form takes a nested selector \u2014 e.g. tap: { on: { text: "Photo" }, times: 2 }'
+      );
+    }
+    if (!Object.keys(obj).every((k) => k === "on" || k === "times")) {
+      badEntry(entry, "the tap options form accepts only { on, times }");
+    }
+    if (obj.on === void 0) {
+      badEntry(entry, 'tap with times needs a target \u2014 e.g. tap: { on: "Photo", times: 2 }');
+    }
+    const step = { kind: "tap", selector: parseSelector(obj.on, "tap.on") };
+    const times = parseTapTimes(obj.times, entry);
+    if (times !== void 0) step.times = times;
+    return step;
+  }
+  return { kind: "tap", selector: parseSelector(body, "tap") };
+}
 function fromYamlStep(raw) {
   const entry = raw;
   const kinds = STEP_DIRECTIVE_KEYS.filter((k) => k in entry);
@@ -144864,23 +145065,7 @@ function fromYamlStep(raw) {
   if ("echo" in raw) return { kind: "echo", message: String(raw.echo) };
   if ("launch" in raw) return { kind: "launch", app: parseLaunch(raw.launch) };
   if ("run" in raw) return { kind: "run", flow: String(raw.run) };
-  if ("tap" in raw) {
-    const body = raw.tap;
-    const obj = body !== null && typeof body === "object" ? body : {};
-    if (body !== null && typeof body === "object" && !Array.isArray(body)) {
-      rejectUnknownKeys(raw, obj, [...SELECTOR_KEYS, "x", "y"], "tap");
-    }
-    if (obj.x !== void 0 || obj.y !== void 0) {
-      if (obj.text !== void 0 || obj.id !== void 0 || obj.identifier !== void 0 || obj.role !== void 0) {
-        badEntry(raw, "tap takes a selector or x/y coordinates, not both");
-      }
-      if (typeof obj.x !== "number" || typeof obj.y !== "number") {
-        badEntry(raw, "a coordinate tap needs numeric x and y");
-      }
-      return { kind: "tap", x: obj.x, y: obj.y };
-    }
-    return { kind: "tap", selector: parseSelector(body, "tap") };
-  }
+  if ("tap" in raw) return parseTap(raw.tap, raw);
   if ("long-press" in raw) {
     return parseLongPress(raw["long-press"], raw);
   }
@@ -145719,13 +145904,15 @@ If a step was recorded by mistake, edit the .yaml file directly to remove it.`,
       const runTarget = params.command === RUN_TARGET_COMMAND && params.delayMs === void 0 ? await captureRunTarget(session, args) : void 0;
       const strippedArgs = stripDeviceKeys(args);
       const isLaunch = params.command === "restart-app" && params.delayMs === void 0 && typeof strippedArgs.bundleId === "string" && Object.keys(strippedArgs).length === 1;
+      const cc = args.clickCount;
+      const tapTimes = isTap && typeof cc === "number" && Number.isInteger(cc) && cc >= 2 && cc <= 10 ? { times: cc } : {};
       let step;
       let warning;
       if (captured?.selector) {
-        step = { kind: "tap", selector: captured.selector };
+        step = { kind: "tap", selector: captured.selector, ...tapTimes };
         warning = captured.warning;
       } else if (isTap) {
-        step = { kind: "tap", x: args.x, y: args.y };
+        step = { kind: "tap", x: args.x, y: args.y, ...tapTimes };
         warning = captured?.warning;
       } else if (isLaunch) {
         step = { kind: "launch", app: strippedArgs.bundleId };
@@ -145821,7 +146008,14 @@ You can still edit the .yaml file directly afterwards to remove or reorder steps
           return `${n}. type: ${selectorLabel(step.into)} \u2190 "${step.text}"`;
         case "await":
         case "assert": {
-          const tail = step.condition === "text" ? `text ${selectorLabel(step.selector)} == "${step.expectedText ?? ""}"` : `${step.condition} ${selectorLabel(step.selector)}`;
+          let tail;
+          if (step.condition !== "text") {
+            tail = `${step.condition} ${selectorLabel(step.selector)}`;
+          } else {
+            const selector = selectorLabel(step.selector);
+            const expected = step.expectedText ?? "";
+            tail = step.textMatch === "matches" ? `text ${selector} matches /${expected}/` : step.textMatch === "equals" ? `text ${selector} == ${JSON.stringify(expected)}` : `text ${selector} contains ${JSON.stringify(expected)}`;
+          }
           return `${n}. ${step.kind}: ${tail}`;
         }
         case "wait":
@@ -146101,7 +146295,10 @@ async function runTap(env, target) {
   } else {
     return { ok: false, reason: "tap needs a selector or x/y coordinates" };
   }
-  await invokeOnDevice(env, "gesture-tap", point);
+  await invokeOnDevice(env, "gesture-tap", {
+    ...point,
+    ...target.times !== void 0 ? { clickCount: target.times } : {}
+  });
   return { ok: true };
 }
 var DEFAULT_LONG_PRESS_MS = 800;
@@ -146212,11 +146409,11 @@ function assertReason(condition, selector, expectedText, textMatch, matches2) {
     case "text": {
       const first = firstInReadingOrder(matches2.filter(isVisible)) ?? firstInReadingOrder(matches2);
       if (!first) return `no element matched selector ${sel}`;
-      const wanted = textMatch === "equals" ? "equal" : "contain";
+      const wanted = describeTextExpectation(expectedText, textMatch, "infinitive");
       const shown = assertText(first);
       const own = nodeText(first);
       const ownNote = own && own !== shown ? ` (own text "${own}")` : "";
-      return `element matched ${sel} but its text was "${shown}"${ownNote} (wanted to ${wanted} "${expectedText}")`;
+      return `element matched ${sel} but its text was "${shown}"${ownNote} (wanted to ${wanted})`;
     }
     default:
       return `assertion failed for selector ${sel}`;
@@ -148712,6 +148909,7 @@ function pushReport(state3, report) {
 function selectorLabel2(sel) {
   const parts = [];
   if (sel.text !== void 0) parts.push(`"${sel.text}"`);
+  if (sel.textMatches !== void 0) parts.push(`/${sel.textMatches}/`);
   if (sel.identifier) parts.push(`id=${sel.identifier}`);
   if (sel.role) parts.push(`role=${sel.role}`);
   return parts.join(" ");
@@ -148730,7 +148928,7 @@ function stepTarget(step) {
     case "assert": {
       const sel = selectorLabel2(step.selector);
       if (step.condition === "text") {
-        return `${sel} ${step.textMatch ?? "contains"} "${step.expectedText ?? ""}"`;
+        return `${sel} ${describeTextExpectation(step.expectedText, step.textMatch)}`;
       }
       return `${step.condition} ${sel}`;
     }
@@ -149631,7 +149829,7 @@ function normLabel(s) {
   return (s || "").toLowerCase().replace(/-/g, "").replace(/[\s,]+/g, " ").trim();
 }
 var MAX_FRAME_AREA = 0.85;
-function matchNode2(n, match, needle) {
+function matchNode(n, match, needle) {
   const label = normLabel(n.label);
   const ident = normLabel(n.identifier);
   const value = normLabel(n.value);
@@ -149658,7 +149856,7 @@ function findElementMatch(tree, match) {
   const candidates = [];
   const walk = (n) => {
     if (!n || typeof n !== "object") return;
-    const m = matchNode2(n, match, needle);
+    const m = matchNode(n, match, needle);
     if (m && n.frame) {
       const f = n.frame;
       const cx = f.x + f.width / 2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.15.1-next.4",
+  "version": "0.15.1-next.6",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",
   "repository": {

package/skills/argent-create-flow/SKILL.md

@@ -23,7 +23,7 @@ Beyond raw `tool:` steps and `echo:`, flows support declarative directives inter
 | Directive    | YAML                                                                                                     | Meaning                                                                 |
 | ------------ | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
 | `launch`     | `- launch: com.acme.app` or `- launch: { ios: …, android: … }`                                           | start the app from scratch (terminate + relaunch) and wait until ready  |
-| `tap`        | `- tap: Login` or `- tap: { x: 0.5, y: 0.57 }`                                                           | tap an element by selector (auto-waits), or a raw normalized point      |
+| `tap`        | `- tap: Login`, `- tap: { x: 0.5, y: 0.57 }`, `- tap: { on: Login, times: 2 }`                           | tap by selector (auto-waits) or raw point; `times: 2` = double-tap      |
 | `long-press` | `- long-press: Row 3` or `- long-press: { on: <sel>, duration: 1200 }`                                   | press and hold an element (default 800ms; Chromium: mouse press-hold)   |
 | `type`       | `- type: { into: email, text: "a@b.com" }`                                                               | focus a field, type, then press Enter to submit + dismiss the keyboard  |
 | `scroll-to`  | `- scroll-to: "Order #1234"` (scrolls down) or `- scroll-to: { target: …, direction: right, within: … }` | momentum-free scroll until the target is visible                        |
@@ -37,7 +37,9 @@ Beyond raw `tool:` steps and `echo:`, flows support declarative directives inter
 
 A **selector** is `{ text?, id?, role? }` (all-must-match; `text`/`role` are case-insensitive substrings, `id` matches the element's testID / accessibilityIdentifier / resource-id exactly, case-insensitive, also accepting the unqualified Android resource-id name — `submit` matches `com.example.app:id/submit`) — the same semantics `await-ui-element` uses, though that tool spells the `id` field `identifier` (flow YAML also accepts `identifier` as an alias for `id`, but `id` is the canonical spelling and what the recorder writes). A bare string is a _loose_ selector: it resolves **identifier-first, then falls back to text** (label/value), so `tap: Login` matches a `testID="Login"` or, failing that, visible text "Login" — no need to know which. Loose fallback applies uniformly to every selector slot (`tap`, `type.into`, `await`, `assert`, `scroll-to`). Use the map form to be strict: `{ id: submit-btn }` (identifier only) or `{ text: Login }` (text only, no fallback).
 
-Selectors resolve against the **full native hierarchy** (iOS: the UIView tree; Android: the complete accessibility hierarchy including not-important views) — strictly more than `describe` or the raw `await-ui-element` tool see (both use the trimmed tree), with complete `testID`/`resource-id` coverage. So an `id` selector works even when `describe` collapses or omits the element — don't fall back to coordinate taps just because a testID isn't visible in `describe` output. And when several elements match — a container aggregates its descendants' text, so `text: "Inner"` matches the wrapping containers too — the action directives (`tap`, `type`, `scroll-to`) pick the **most specific** match: an exact text/identifier match beats a substring hit, then the smallest frame wins.
+`text` also takes a **regex matcher map** — `{ text: { matches: '^Order #\d+$' } }`, in any selector slot — for dynamic text no literal can pin. It tests each node's native **own** label/value (not the adapter-hoisted `subtreeText`), though on iOS a container's own label may itself aggregate descendant text, so a wrapper and its leaf can both match. Same regex rules as `text.in`'s `matches` (see _`await` and `assert`_): unanchored, **case-sensitive**, single-quoted, invalid pattern fails at parse. So `assert: { visible: { text: { matches: '^Taps: \d+$' } } }` asserts a counter is on screen with no locator at all, and `tap: { text: { matches: '^Order #\d+$' } }` taps a dynamic row — though a stable `id` stays the more robust action target.
+
+Selectors resolve against the **full native hierarchy** (iOS: the UIView tree; Android: the complete accessibility hierarchy including not-important views) — strictly more than `describe` or the raw `await-ui-element` tool see (both use the trimmed tree), with complete `testID`/`resource-id` coverage. So an `id` selector works even when `describe` collapses or omits the element — don't fall back to coordinate taps just because a testID isn't visible in `describe` output. And when several elements match — including wrappers whose native text aggregates descendant content — the action directives (`tap`, `type`, `scroll-to`) pick the **most specific** match: an exact text/identifier match beats a substring hit (for a regex matcher, a pattern consuming the element's whole text counts as exact), then the smallest frame wins.
 
 **Quote strings YAML would mangle.** An unquoted `#` starts a YAML comment — `tap: Order #1234` silently parses as `tap: Order` — and bare `yes`/`no`/`on`/`off`/numbers coerce to non-strings. When a selector or typed text contains `#`, `:`, quotes, or could read as a boolean/number, wrap it: `tap: "Order #1234"`.
 
@@ -47,6 +49,7 @@ The **condition is the key**, and its value is the selector:
 
 - `{ visible: Home }`, `{ exists: { id: row } }`, `{ hidden: spinner }`
 - `{ text: { in: <selector>, contains: "Taps:" } }` or `{ text: { in: <selector>, equals: "Taps: 0" } }` — `text` locates an element (`in`) and checks its rendered content against exactly one of `contains` (case-insensitive substring) or `equals` (case-insensitive exact match — use it when boundaries matter: `contains: "Taps: 3"` is also satisfied by "Taps: 30"). Reach for `text` only when the locator is an identifier/role; to assert a string is simply on screen, prefer `{ visible: "Taps: 0" }`.
+- `{ text: { in: total, matches: 'Total: \$\d+\.\d{2}' } }` — the third comparator: a JS regex for dynamic content (counters, prices, dates) that neither literal mode can pin. Unanchored like `contains` (anchor with `^…$` for the `equals` analog) and — unlike the literal modes — **case-sensitive**: the pattern carries its own semantics. An invalid pattern fails at parse time. **Quote the pattern in single quotes**: single-quoted and plain YAML scalars keep backslashes; double quotes would need `\\d`. To assert a dynamic string is simply on screen with no locator, prefer a regex **selector** — `{ visible: { text: { matches: '^Taps: \d+$' } } }` (see Selectors); `text.in` + `matches` is for checking a specific element's aggregated text.
 - A container's text aggregates its descendants' text (space-joined), so `text` can assert what a testID wrapper visibly shows even when the string lives in a child node. That also means `equals` against a wrapper must match _everything_ it shows or exactly the wrapper's own label/value — targeting the leaf holding exactly the value (or using `contains`) stays the clearer spelling.
 
 This condition-as-key form is the only spelling. `await` also accepts an optional `timeout` sibling key in milliseconds — `- await: { visible: Home, timeout: 15000 }` — for a transition that legitimately needs longer than the default budget. **Omit `timeout` by default**: the default budget covers normal transitions, and a habitual generous override just delays failure reporting on every broken step. Add one only after a step demonstrably needs it — it timed out at the default and the wait is legitimately slow (a cold start, a network round-trip, a long animation). `assert` has no timeout override: a check that needs seconds to become true is a wait — spell it `await`.