@swmansion/argent 0.15.1-next.5 → 0.15.1-next.7

package/dist/cli-cmds.mjs

@@ -6324,6 +6324,7 @@ var FAILURE_CODES = {
   CHROMIUM_ELECTRON_EXITED_BEFORE_READY: "CHROMIUM_ELECTRON_EXITED_BEFORE_READY",
   KEYBOARD_KEY_UNSUPPORTED: "KEYBOARD_KEY_UNSUPPORTED",
   KEYBOARD_CHARACTER_UNSUPPORTED: "KEYBOARD_CHARACTER_UNSUPPORTED",
+  SECRET_PLACEHOLDER_UNKNOWN: "SECRET_PLACEHOLDER_UNKNOWN",
   SCREENSHOT_DIFF_INPUT_INVALID: "SCREENSHOT_DIFF_INPUT_INVALID",
   BOOT_DEVICE_TARGET_SELECTION_INVALID: "BOOT_DEVICE_TARGET_SELECTION_INVALID",
   BOOT_IOS_UNSUPPORTED_HOST: "BOOT_IOS_UNSUPPORTED_HOST",

package/dist/installer.mjs

@@ -16231,6 +16231,7 @@ var FAILURE_CODES = {
   CHROMIUM_ELECTRON_EXITED_BEFORE_READY: "CHROMIUM_ELECTRON_EXITED_BEFORE_READY",
   KEYBOARD_KEY_UNSUPPORTED: "KEYBOARD_KEY_UNSUPPORTED",
   KEYBOARD_CHARACTER_UNSUPPORTED: "KEYBOARD_CHARACTER_UNSUPPORTED",
+  SECRET_PLACEHOLDER_UNKNOWN: "SECRET_PLACEHOLDER_UNKNOWN",
   SCREENSHOT_DIFF_INPUT_INVALID: "SCREENSHOT_DIFF_INPUT_INVALID",
   BOOT_DEVICE_TARGET_SELECTION_INVALID: "BOOT_DEVICE_TARGET_SELECTION_INVALID",
   BOOT_IOS_UNSUPPORTED_HOST: "BOOT_IOS_UNSUPPORTED_HOST",

package/dist/mcp-server.mjs

@@ -17750,6 +17750,7 @@ var FAILURE_CODES = {
   CHROMIUM_ELECTRON_EXITED_BEFORE_READY: "CHROMIUM_ELECTRON_EXITED_BEFORE_READY",
   KEYBOARD_KEY_UNSUPPORTED: "KEYBOARD_KEY_UNSUPPORTED",
   KEYBOARD_CHARACTER_UNSUPPORTED: "KEYBOARD_CHARACTER_UNSUPPORTED",
+  SECRET_PLACEHOLDER_UNKNOWN: "SECRET_PLACEHOLDER_UNKNOWN",
   SCREENSHOT_DIFF_INPUT_INVALID: "SCREENSHOT_DIFF_INPUT_INVALID",
   BOOT_DEVICE_TARGET_SELECTION_INVALID: "BOOT_DEVICE_TARGET_SELECTION_INVALID",
   BOOT_IOS_UNSUPPORTED_HOST: "BOOT_IOS_UNSUPPORTED_HOST",
@@ -18981,6 +18982,14 @@ var DEFAULT_DELAY_MS = 1400;
 function autoScreenshotEnabled(options) {
   return !isFlagEnabled("disable-auto-screenshot", options);
 }
+var SECRET_PLACEHOLDER_MARKER = "{{secret:";
+function containsSecretPlaceholder(args) {
+  try {
+    return JSON.stringify(args)?.includes(SECRET_PLACEHOLDER_MARKER) ?? false;
+  } catch {
+    return true;
+  }
+}
 function getUdidFromArgs(args) {
   if (args && typeof args === "object" && "udid" in args && typeof args.udid === "string") {
     return args.udid;
@@ -19209,7 +19218,15 @@ async function startMcpServer(options) {
         content = await toMcpContent(result, outputHint, ctx, params.arguments);
       }
       const udid = getUdidFromArgs(params.arguments);
-      if (autoScreenshotOn && udid && shouldAutoScreenshot(params.name)) {
+      if (autoScreenshotOn && udid && shouldAutoScreenshot(params.name) && containsSecretPlaceholder(params.arguments)) {
+        content = [
+          ...content,
+          {
+            type: "text",
+            text: "Auto-screenshot skipped: the input contains a {{secret:\u2026}} placeholder, and a screenshot of this screen could reveal the typed secret. Submit or navigate away first, then verify the resulting screen as usual."
+          }
+        ];
+      } else if (autoScreenshotOn && udid && shouldAutoScreenshot(params.name)) {
         const maxWaitMs = getAutoScreenshotDelayMs(params.name);
         if (maxWaitMs > 0) {
           try {

package/dist/tool-server.cjs

@@ -404,6 +404,7 @@ var init_failure_codes = __esm({
       CHROMIUM_ELECTRON_EXITED_BEFORE_READY: "CHROMIUM_ELECTRON_EXITED_BEFORE_READY",
       KEYBOARD_KEY_UNSUPPORTED: "KEYBOARD_KEY_UNSUPPORTED",
       KEYBOARD_CHARACTER_UNSUPPORTED: "KEYBOARD_CHARACTER_UNSUPPORTED",
+      SECRET_PLACEHOLDER_UNKNOWN: "SECRET_PLACEHOLDER_UNKNOWN",
       SCREENSHOT_DIFF_INPUT_INVALID: "SCREENSHOT_DIFF_INPUT_INVALID",
       BOOT_DEVICE_TARGET_SELECTION_INVALID: "BOOT_DEVICE_TARGET_SELECTION_INVALID",
       BOOT_IOS_UNSUPPORTED_HOST: "BOOT_IOS_UNSUPPORTED_HOST",
@@ -126687,6 +126688,54 @@ Fails if the device backend is not reachable \u2014 the simulator-server for iOS
 // ../tool-server/src/tools/keyboard/index.ts
 init_zod();
 
+// ../tool-server/src/utils/secrets.ts
+init_src();
+var SECRET_ENV_PREFIX = "ARGENT_SECRET_";
+var SECRET_PLACEHOLDER_MARKER = "{{secret:";
+var PLACEHOLDER_RE = /\{\{secret:([A-Za-z_][A-Za-z0-9_]*)\}\}/g;
+function availableSecretNames(env = process.env) {
+  return Object.keys(env).filter((k) => k.startsWith(SECRET_ENV_PREFIX) && env[k] !== void 0).map((k) => k.slice(SECRET_ENV_PREFIX.length)).sort();
+}
+var REDUNDANT_PREFIX_RE = /^argent_secret_/i;
+function resolveSecretPlaceholders(text, env = process.env) {
+  const secrets = [];
+  const resolved = text.replace(PLACEHOLDER_RE, (placeholder, rawName) => {
+    let name = rawName;
+    let value = env[SECRET_ENV_PREFIX + name];
+    if (value === void 0 && REDUNDANT_PREFIX_RE.test(name)) {
+      name = name.replace(REDUNDANT_PREFIX_RE, "");
+      value = env[SECRET_ENV_PREFIX + name];
+    }
+    if (value === void 0) {
+      const names = availableSecretNames(env);
+      throw new InvalidToolInputError(
+        `Unknown secret "${rawName}" \u2014 no ${SECRET_ENV_PREFIX}${name} environment variable is set on the machine running the tool-server. Available secrets: ${names.length ? names.join(", ") : "(none)"}. To make it available, ask the user to export ${SECRET_ENV_PREFIX}${name} in the tool-server's environment \u2014 never ask the user for the secret value itself.`,
+        {
+          error_code: FAILURE_CODES.SECRET_PLACEHOLDER_UNKNOWN,
+          failure_stage: "secret_placeholder_resolution",
+          error_kind: "validation"
+        }
+      );
+    }
+    if (!secrets.some((s) => s.name === name)) secrets.push({ name, value });
+    return value;
+  });
+  return { text: resolved, secrets };
+}
+function redactSecretsFromError(err, secrets) {
+  const scrub = (s) => secrets.reduce(
+    (acc, { name, value }) => value ? acc.split(value).join(`${SECRET_PLACEHOLDER_MARKER}${name}}}`) : acc,
+    s
+  );
+  if (err instanceof Error) {
+    err.message = scrub(err.message);
+    if (err.stack) err.stack = scrub(err.stack);
+    return err;
+  }
+  if (typeof err === "string") return scrub(err);
+  return err;
+}
+
 // ../tool-server/src/tools/keyboard/simulator-server-keys.ts
 init_src();
 
@@ -127165,7 +127214,9 @@ var zodSchema24 = external_exports.object({
   udid: external_exports.string().describe(
     "Target device id from `list-devices` (iOS UDID, Android serial, Vega serial, or Chromium id)."
   ),
-  text: external_exports.string().optional().describe("Text to type character by character. Handles uppercase and common punctuation."),
+  text: external_exports.string().optional().describe(
+    'Text to type character by character. Handles uppercase and common punctuation. To type a credential without its plaintext ever entering your context, use a secret placeholder: `{{secret:<NAME>}}` types the value of the `ARGENT_SECRET_<NAME>` environment variable set on the machine running the tool-server \u2014 e.g. text: "{{secret:APP_PASSWORD}}" types the value of `ARGENT_SECRET_APP_PASSWORD`. Only env vars with the `ARGENT_SECRET_` prefix are resolvable. Placeholders can be embedded in longer text and are never echoed back resolved. If the secret you need is not set, ask the user to export it as `ARGENT_SECRET_<NAME>` and restart the session \u2014 NEVER ask the user to paste the secret value into the conversation.'
+  ),
   key: external_exports.string().optional().describe(
     "Named key to press: enter, escape, backspace, tab, space, arrow-up, arrow-down, arrow-left, arrow-right, f1\u2013f12. When combined with `text`, the key is pressed AFTER the text is typed (so text + enter types and submits). Not supported on TV targets \u2014 move focus with `tv-remote` (up/down/left/right) instead."
   ),
@@ -127181,12 +127232,21 @@ var capability16 = {
   vega: { vvd: true }
 };
 function createKeyboardTool(registry2) {
+  const dispatch = dispatchByPlatform({
+    toolId: "keyboard",
+    capability: capability16,
+    ios: makeIosImpl3(registry2),
+    iosRemote: makeIosRemoteImpl(registry2),
+    android: makeAndroidImpl(registry2),
+    chromium: makeChromiumImpl(registry2),
+    vega: vegaImpl4
+  });
   return {
     id: "keyboard",
     description: `Type text or press special keys on the device (iOS simulator, Android emulator or device, Chromium app, Vega Virtual Device, or Apple TV / Android TV) using keyboard events.
 Use when you need to enter text or trigger a named key such as enter, escape, or arrow keys. On Vega and Apple TV / Android TV, prefer the remote tools for D-pad navigation; use keyboard to type into a focused text field (e.g. a search or login box).
 Returns { typed: string, keys: number }. Fails if an unsupported key name is provided or the device's input backend is not reachable.
-- text: types a string (supports uppercase, digits, common punctuation)
+- text: types a string (supports uppercase, digits, common punctuation). To type a credential, use \`{{secret:<NAME>}}\` \u2014 resolved server-side from the \`ARGENT_SECRET_<NAME>\` env var (prefix mandatory; \`{{secret:APP_PASSWORD}}\` \u2194 \`ARGENT_SECRET_APP_PASSWORD\`), so the plaintext never enters agent context; the result echoes the placeholder, not the value, and the after-typing auto-screenshot is skipped.
 - key: presses a single named key (enter, escape, backspace, tab, arrow-up/down/left/right, f1\u2013f12) \u2014 NOT supported on TV targets; move focus with \`tv-remote\` instead.
 On a TV target (runtimeKind 'tv') only \`text\` applies \u2014 focus a text field first (with \`tv-remote\`), then type into it (injected HID keyboard on Apple TV, \`adb input text\` on Android TV).
 Provide text, key, or both \u2014 when both are given, the text is typed first and the key is pressed after it (text + key:"enter" types and submits).`,
@@ -127197,15 +127257,17 @@ Provide text, key, or both \u2014 when both are given, the text is typed first a
     // simulator-server, CDP, or Vega adb), since distinguishing a TV target is
     // async and a tvOS udid must never resolve simulator-server.
     services: () => ({}),
-    execute: dispatchByPlatform({
-      toolId: "keyboard",
-      capability: capability16,
-      ios: makeIosImpl3(registry2),
-      iosRemote: makeIosRemoteImpl(registry2),
-      android: makeAndroidImpl(registry2),
-      chromium: makeChromiumImpl(registry2),
-      vega: vegaImpl4
-    })
+    execute: async (services, params, options) => {
+      if (params.text === void 0) return dispatch(services, params, options);
+      const { text, secrets } = resolveSecretPlaceholders(params.text);
+      if (secrets.length === 0) return dispatch(services, params, options);
+      try {
+        const result = await dispatch(services, { ...params, text }, options);
+        return { ...result, typed: params.text };
+      } catch (err) {
+        throw redactSecretsFromError(err, secrets);
+      }
+    }
   };
 }
 
@@ -133168,7 +133230,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')."
@@ -133176,9 +133238,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(" ");
 }
@@ -133195,15 +133261,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;
   }
@@ -133212,13 +133295,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) {
@@ -133282,21 +133369,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;
@@ -133589,6 +133684,7 @@ Allowed tools and their args (udid is auto-injected, do NOT include it in args):
   gesture-rotate: { centerX: number, centerY: number, radius: number, startAngle: number, endAngle: number, durationMs?: number }                    [ios only]
   button:         { button: "home"|"back"|"power"|"volumeUp"|"volumeDown"|"appSwitch"|"actionButton" }                  [ios/android]
   keyboard:       { text?: string, key?: string, delayMs?: number }  (key pressed after text; TV: text only)            [ios/android/chromium/vega/tv]
+                  text supports {{secret:<NAME>}} placeholders, resolved server-side from ARGENT_SECRET_<NAME> env vars (prefix mandatory) \u2014 credentials never enter agent context
   rotate:         { orientation: "Portrait"|"LandscapeLeft"|"LandscapeRight"|"PortraitUpsideDown" }                     [ios/android]
   tv-remote:      { button: <remote button | array of them>, repeat?: number }                                          [apple tv/android tv/vega]
                   buttons: up/down/left/right/select/back/home/menu/playPause (+ rewind/fastForward/next/previous/volumeUp/volumeDown/mute \u2014 work on Android TV and Vega; rejected on the Apple TV simulator)
@@ -144519,14 +144615,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);
@@ -144542,7 +144691,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;
@@ -144635,6 +144784,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);
@@ -144698,11 +144857,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") {
@@ -144742,22 +144936,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`),
@@ -145869,7 +146071,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":
@@ -146263,11 +146472,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}`;
@@ -148763,6 +148972,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(" ");
@@ -148781,7 +148991,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}`;
     }
@@ -149682,7 +149892,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);
@@ -149709,7 +149919,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.5",
+  "version": "0.15.1-next.7",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",
   "repository": {

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

@@ -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`.
@@ -57,6 +60,8 @@ For a custom poll interval or bundleId, drop to an explicit `- tool: await-ui-el
 
 `type` presses Enter after typing to commit the value and dismiss the keyboard, so it can't cover later targets. For a chained form whose fields feed one explicit submit — e.g. email then password then a `tap: "Log in"` — set `submit: false` on the intermediate fields so a premature Enter doesn't fire the form early: `type: { into: password, text: "hunter2", submit: false }`.
 
+Never record a real credential into a flow — the YAML is committed to the repo. Use a secret placeholder instead: `type: { into: password, text: "{{secret:APP_PASSWORD}}" }`. The placeholder is stored verbatim (the YAML stays secret-free) and is resolved at run time by the tool-server from the `ARGENT_SECRET_APP_PASSWORD` environment variable — including agent-less `argent flow run` in CI, where the variable comes from the job's secrets.
+
 `scroll-to` takes an optional `direction` (`up` | `down` | `left` | `right`, default `down` — so the common case is just `- scroll-to: <selector>`) and optionally a `within: <selector>` that anchors the scroll inside a specific container — required to drive a **nested** scroller (e.g. a horizontal carousel inside a vertical list), since the device can't be asked which container to scroll. It scrolls in bounded momentum-free increments, re-checks after each, and stops if a scroll reveals nothing new (end of the container). `tap`/`type` do **not** scroll — add a `scroll-to` before any target that may be off-screen. It's a no-op when the target is already visible, so a defensive `scroll-to` costs nothing on replay and keeps the flow working on smaller screens.
 
 ### TV targets (Vega)

package/skills/argent-device-interact/SKILL.md

@@ -171,6 +171,18 @@ Values: `home`, `back`, `power`, `volumeUp`, `volumeDown`, `appSwitch`, `actionB
 
 Special keys: `enter`, `escape`, `backspace`, `tab`, `space`, `arrow-up`, `arrow-down`, `arrow-left`, `arrow-right`, `f1`–`f12`. Optional: `"delayMs": 100` between keystrokes (default 50ms) — applies to the iOS simulator and Chromium; it is ignored on Android phones/tablets (typed via `adb input text`, no per-key cadence), on Vega, and on TV targets.
 
+**Typing secrets.** To enter a credential without its plaintext ever entering your context, transcript, or logs, use a secret placeholder in `text` (works in `keyboard`, `paste`, `run-sequence` keyboard steps, and flow `type` steps):
+
+```json
+{ "udid": "<UDID>", "text": "{{secret:APP_PASSWORD}}", "key": "enter" }
+```
+
+The placeholder is resolved on the machine running the tool-server from the `ARGENT_SECRET_<NAME>` environment variable (here `ARGENT_SECRET_APP_PASSWORD`) — the CI-native pattern: expose the secret under that prefix in the environment that starts the tool-server. Rules:
+
+- The result echoes the placeholder, never the value. An unknown name fails with the list of available secret _names_.
+- The auto-screenshot after the call is skipped so the typed value cannot re-enter your context as pixels. Do **not** `describe` or `screenshot` a non-secure field you just filled with a secret — submit or navigate away first, then verify the resulting screen.
+- Only `ARGENT_SECRET_*` variables are resolvable; never ask the user to paste a secret value into the conversation — ask them to export the env var instead.
+
 ### rotate — Change orientation
 
 ```json