@deeeed/metamask-harness 0.35.0 → 0.37.0

package/adapters/extension/readiness.mjs

@@ -64,10 +64,29 @@ function parseArgs(argv) {
   return out;
 }
 
+function extensionBuildRoot(target) {
+  const runtimeRoot = path.join(target, recipeRuntimeDir());
+  const statePath = path.join(runtimeRoot, 'extension-release-artifact.json');
+  if (!fs.existsSync(statePath)) return path.join(target, 'dist/chrome');
+  try {
+    const stat = fs.lstatSync(statePath);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size <= 0 || stat.size > 64 * 1024) {
+      throw new Error('Loaded release artifact identity is not a regular bounded file.');
+    }
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    const expected = path.join(runtimeRoot, process.env.RECIPE_RUNTIME_DIST_DIR || 'runtime-dist');
+    if (state.schemaVersion === 1 && path.resolve(state.runtimeDist || '') === expected) return expected;
+  } catch (error) {
+    throw new Error(`Loaded release artifact identity is invalid: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  throw new Error('Loaded release artifact identity is invalid.');
+}
+
 function readManifest(target) {
-  const manifestPath = path.join(target, 'dist/chrome/manifest.json');
+  const buildRoot = extensionBuildRoot(target);
+  const manifestPath = path.join(buildRoot, 'manifest.json');
   const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-  return { manifestPath, manifest };
+  return { buildRoot, manifestPath, manifest };
 }
 
 function manifestExpectedFiles(manifest) {
@@ -190,6 +209,17 @@ function resolveWebSocket(target) {
 }
 
 async function cdpEvaluate(target, webSocketDebuggerUrl, expression, timeoutMs = 5000) {
+  const result = await cdpCall(
+    target,
+    webSocketDebuggerUrl,
+    'Runtime.evaluate',
+    { expression, awaitPromise: true, returnByValue: true },
+    timeoutMs,
+  );
+  return result?.result?.value ?? null;
+}
+
+async function cdpCall(target, webSocketDebuggerUrl, method, params, timeoutMs = 5000) {
   assertLocalWebSocketUrl(webSocketDebuggerUrl);
   const WebSocketImpl = resolveWebSocket(target);
   if (!WebSocketImpl) return { skipped: true, reason: 'WebSocket unavailable in this Node runtime' };
@@ -206,8 +236,8 @@ async function cdpEvaluate(target, webSocketDebuggerUrl, expression, timeoutMs =
     const onOpen = () => {
       ws.send(JSON.stringify({
         id: 1,
-        method: 'Runtime.evaluate',
-        params: { expression, awaitPromise: true, returnByValue: true },
+        method,
+        params,
       }));
     };
     const onMessage = (event) => {
@@ -220,11 +250,11 @@ async function cdpEvaluate(target, webSocketDebuggerUrl, expression, timeoutMs =
         reject(new Error(msg.error.message || JSON.stringify(msg.error)));
         return;
       }
-      resolve(msg.result?.result?.value ?? null);
+      resolve(msg.result ?? null);
     };
     const onError = (err) => {
       clearTimeout(timer);
-      reject(new Error(`CDP websocket error while inspecting extension page: ${err?.message || err || 'unknown'}`));
+      reject(new Error(`CDP websocket error during ${method}: ${err?.message || err || 'unknown'}`));
     };
     if (typeof ws.on === 'function') {
       ws.on('open', onOpen);
@@ -286,6 +316,23 @@ async function openExtensionPage(cdpPort, extensionId, pagePath) {
   }
 }
 
+const PAGE_UI_EXPRESSION = `(() => {
+  const text = document.body?.innerText || '';
+  const cell = (sel) => document.querySelector(sel)?.innerText?.trim() || '';
+  const errorBoundaryMessage = cell('[data-testid="error-page-error-message"]');
+  const errorBoundaryName = cell('[data-testid="error-page-error-name"]');
+  const hasErrorBoundary = Boolean(errorBoundaryMessage) || Boolean(errorBoundaryName);
+  return {
+    title: document.title,
+    url: location.href,
+    textSample: text.slice(0, 500),
+    hasStartupError: /MetaMask had trouble starting|Background connection unresponsive|Unknown Infura network/i.test(text),
+    hasErrorBoundary,
+    errorBoundaryName,
+    errorBoundaryMessage: errorBoundaryMessage || (hasErrorBoundary ? text.slice(0, 300) : ''),
+  };
+})()`;
+
 // The page path only, with any '#fragment' or '?query' stripped. The app router
 // rewrites home.html to home.html#/ once loaded, so an exact '/home.html' suffix
 // match must compare against this, not the raw url.
@@ -349,29 +396,7 @@ async function inspectCdp(target, cdpPort, expectedExtensionId, expectedServiceW
   // tab has none; skip inspection and report it rather than opening a duplicate.
   if (pageTarget && typeof pageTarget.webSocketDebuggerUrl === 'string') {
     const slotId = readSlotId(target);
-    ui = await cdpEvaluate(
-      target,
-      pageTarget.webSocketDebuggerUrl,
-      `(() => {
-        const text = document.body?.innerText || '';
-        const cell = (sel) => document.querySelector(sel)?.innerText?.trim() || '';
-        // React error-boundary screen (ui/pages/error-page); deterministic testids.
-        const errorBoundaryMessage = cell('[data-testid="error-page-error-message"]');
-        const errorBoundaryName = cell('[data-testid="error-page-error-name"]');
-        // Testid-only trigger: ui/pages/error-page reliably renders these testids.
-        // Avoid matching the visible phrase in body text (false positives).
-        const hasErrorBoundary = Boolean(errorBoundaryMessage) || Boolean(errorBoundaryName);
-        return {
-          title: document.title,
-          url: location.href,
-          textSample: text.slice(0, 500),
-          hasStartupError: /MetaMask had trouble starting|Background connection unresponsive|Unknown Infura network/i.test(text),
-          hasErrorBoundary,
-          errorBoundaryName,
-          errorBoundaryMessage: errorBoundaryMessage || (hasErrorBoundary ? text.slice(0, 300) : ''),
-        };
-      })()`,
-    );
+    ui = await cdpEvaluate(target, pageTarget.webSocketDebuggerUrl, PAGE_UI_EXPRESSION);
     pageInspected = Boolean(ui) && !ui.skipped;
     if (pageInspected && ui.hasStartupError) {
       throw Object.assign(new Error('MetaMask extension page loaded startup error UI'), {
@@ -385,9 +410,25 @@ async function inspectCdp(target, cdpPort, expectedExtensionId, expectedServiceW
       });
     }
     if (pageInspected && String(ui.url || '').startsWith('chrome-error://')) {
-      throw Object.assign(new Error('MetaMask extension page loaded Chrome error UI'), {
-        report: { cdp: { browser: version.Browser || 'unknown', selectedExtensionId, ui } },
-      });
+      const destination = `chrome-extension://${selectedExtensionId}/${String(extensionPagePath || 'home.html').replace(/^\/+/u, '')}`;
+      await cdpCall(
+        target,
+        pageTarget.webSocketDebuggerUrl,
+        'Page.navigate',
+        { url: destination },
+      );
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      ui = await cdpEvaluate(target, pageTarget.webSocketDebuggerUrl, PAGE_UI_EXPRESSION);
+      if (
+        !ui ||
+        String(ui.url || '').startsWith('chrome-error://') ||
+        ui.hasStartupError ||
+        ui.hasErrorBoundary
+      ) {
+        throw Object.assign(new Error('MetaMask extension page loaded Chrome error UI'), {
+          report: { cdp: { browser: version.Browser || 'unknown', selectedExtensionId, ui } },
+        });
+      }
     }
     if (pageInspected && slotId) {
       const stampedTitle = await cdpEvaluate(
@@ -419,12 +460,12 @@ async function main() {
   const args = parseArgs(process.argv.slice(2));
   const target = path.resolve(args.target);
   const checks = [];
-  const { manifestPath, manifest } = readManifest(target);
+  const { buildRoot, manifestPath, manifest } = readManifest(target);
   const expectedFiles = manifestExpectedFiles(manifest);
   const missingFiles = [];
   for (const rel of expectedFiles) {
-    const exists = fs.existsSync(path.join(target, 'dist/chrome', rel));
-    checks.push({ name: `dist/chrome/${rel}`, status: exists ? 'pass' : 'fail' });
+    const exists = fs.existsSync(path.join(buildRoot, rel));
+    checks.push({ name: `${path.relative(target, buildRoot)}/${rel}`, status: exists ? 'pass' : 'fail' });
     if (!exists) missingFiles.push(rel);
   }
   if (missingFiles.length > 0) {
@@ -434,7 +475,7 @@ async function main() {
     );
   }
 
-  const defaultPage = fs.existsSync(path.join(target, 'dist/chrome/home.html'))
+  const defaultPage = fs.existsSync(path.join(buildRoot, 'home.html'))
     ? 'home.html'
     : manifestDefaultPage(manifest);
   const report = {

package/adapters/extension/snapshot-dist.sh

@@ -9,9 +9,12 @@
 #
 # Inputs (flags):
 #   --dist <dir>           source dist (required, e.g. <repo>/dist/chrome)
+#   --target <dir>         absolute checkout containment root
+#   --runtime-root <dir>   absolute directory that owns the snapshot
 #   --runtime-dist <dir>   snapshot destination (required, recreated)
 #   --wait-iterations <n>  manifest wait loop length, 2s each (default 180)
 #   --summary <file>       optional standard summary.json
+#   --exact                preserve every source entry (release artifacts)
 #
 # Outputs:
 #   <runtime-dist>/ snapshot (excludes _metadata); optional --summary file
@@ -24,24 +27,32 @@
 set -euo pipefail
 
 DIST=""
+TARGET_ROOT=""
+RUNTIME_ROOT=""
 RUNTIME_DIST=""
 WAIT_ITERATIONS=180
 SUMMARY=""
+EXACT=false
 require_value() { [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; }
 while [ "$#" -gt 0 ]; do
   case "$1" in
     --dist) require_value "$@"; DIST="$2"; shift 2 ;;
+    --target) require_value "$@"; TARGET_ROOT="$2"; shift 2 ;;
+    --runtime-root) require_value "$@"; RUNTIME_ROOT="$2"; shift 2 ;;
     --runtime-dist) require_value "$@"; RUNTIME_DIST="$2"; shift 2 ;;
     --wait-iterations) require_value "$@"; WAIT_ITERATIONS="$2"; shift 2 ;;
     --summary) require_value "$@"; SUMMARY="$2"; shift 2 ;;
+    --exact) EXACT=true; shift ;;
     -h|--help)
-      echo "Usage: snapshot-dist.sh --dist <dir> --runtime-dist <dir> [--wait-iterations <n>] [--summary <file>]"
+      echo "Usage: snapshot-dist.sh --dist <dir> --target <dir> --runtime-root <dir> --runtime-dist <dir> [--wait-iterations <n>] [--summary <file>]"
       exit 0
       ;;
     *) echo "Unknown arg: $1" >&2; exit 2 ;;
   esac
 done
 [ -n "$DIST" ] || { echo "Missing --dist" >&2; exit 2; }
+[ -n "$TARGET_ROOT" ] || { echo "Missing --target" >&2; exit 2; }
+[ -n "$RUNTIME_ROOT" ] || { echo "Missing --runtime-root" >&2; exit 2; }
 [ -n "$RUNTIME_DIST" ] || { echo "Missing --runtime-dist" >&2; exit 2; }
 case "$WAIT_ITERATIONS" in ''|*[!0-9]*) echo "Invalid --wait-iterations (must be numeric): $WAIT_ITERATIONS" >&2; exit 2 ;; esac
 
@@ -73,8 +84,82 @@ done
 test -f "$DIST/manifest.json" || { echo "snapshot-dist: no manifest at $DIST/manifest.json" >&2; exit 1; }
 
 echo "[recipe-harness] snapshotting dist -> runtime-dist: $RUNTIME_DIST" >&2
-rm -rf "$RUNTIME_DIST" && mkdir -p "$RUNTIME_DIST" \
-  && rsync -a --delete --exclude _metadata "$DIST/" "$RUNTIME_DIST/" || exit 1
+node - "$DIST" "$TARGET_ROOT" "$RUNTIME_ROOT" "$RUNTIME_DIST" <<'NODE'
+const fs = require('node:fs');
+const path = require('node:path');
+
+const [sourceInput, targetInput, rootInput, destinationInput] = process.argv.slice(2);
+const source = path.resolve(sourceInput);
+const target = path.resolve(targetInput);
+const root = path.resolve(rootInput);
+const destination = path.resolve(destinationInput);
+
+function refuse(message) {
+  throw new Error(`snapshot-dist: ${message}`);
+}
+
+if (![targetInput, rootInput, destinationInput].every(path.isAbsolute)) {
+  refuse('--target, --runtime-root, and --runtime-dist must be absolute paths.');
+}
+const targetStat = fs.lstatSync(target, { throwIfNoEntry: false });
+if (!targetStat?.isDirectory() || targetStat.isSymbolicLink()) {
+  refuse(`target is not a regular directory: ${target}.`);
+}
+const rootRelative = path.relative(target, root);
+if (!rootRelative || rootRelative === '..' || rootRelative.startsWith(`..${path.sep}`) || path.isAbsolute(rootRelative)) {
+  refuse(`runtime root must be a child of ${target}.`);
+}
+const relative = path.relative(root, destination);
+if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+  refuse(`runtime destination must be a child of ${root}.`);
+}
+if (
+  source === destination ||
+  source.startsWith(`${destination}${path.sep}`) ||
+  destination.startsWith(`${source}${path.sep}`)
+) {
+  refuse('source and runtime destination must be separate directory trees.');
+}
+
+function ensureDirectoryTree(base, relativePath) {
+  let current = base;
+  const components = relativePath.split(path.sep).filter(Boolean);
+  for (const component of components) {
+    current = path.join(current, component);
+    const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+    if (!stat) {
+      fs.mkdirSync(current, { mode: 0o700 });
+      continue;
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+      refuse(`runtime path contains an unsafe entry: ${current}.`);
+    }
+  }
+}
+
+ensureDirectoryTree(target, rootRelative);
+ensureDirectoryTree(root, path.relative(root, path.dirname(destination)));
+const realTarget = fs.realpathSync(target);
+const realRoot = fs.realpathSync(root);
+const realParent = fs.realpathSync(path.dirname(destination));
+if (
+  !realRoot.startsWith(`${realTarget}${path.sep}`) ||
+  (realParent !== realRoot && !realParent.startsWith(`${realRoot}${path.sep}`))
+) {
+  refuse(`runtime destination escapes ${root}.`);
+}
+const destinationStat = fs.lstatSync(destination, { throwIfNoEntry: false });
+if (destinationStat && (!destinationStat.isDirectory() || destinationStat.isSymbolicLink())) {
+  refuse(`runtime destination is not a regular directory: ${destination}.`);
+}
+if (destinationStat) fs.rmSync(destination, { recursive: true });
+fs.mkdirSync(destination, { mode: 0o700 });
+NODE
+if $EXACT; then
+  rsync -a --delete "$DIST/" "$RUNTIME_DIST/" || exit 1
+else
+  rsync -a --delete --exclude _metadata "$DIST/" "$RUNTIME_DIST/" || exit 1
+fi
 echo "[recipe-harness] runtime-dist snapshot complete" >&2
 
 # Freshness guard: the loaded runtime-dist must match dist/chrome's git id. A

package/adapters/extension/start-watch.sh

@@ -142,6 +142,21 @@ trap finish EXIT
 
 mkdir -p "$RUNTIME_DIR"
 
+PRODUCT_CONFIG_MODULE="$SCRIPT_DIR/lib/product-config.cjs" \
+  node - "$PWD" "$RUNTIME_DIR/extension-product-config.sha256" <<'NODE'
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const config = require(process.env.PRODUCT_CONFIG_MODULE);
+const [target, destination] = process.argv.slice(2);
+const resolution = config.resolveExtensionInfuraProjectId(target, process.env);
+if (resolution.kind !== 'configured') {
+  fs.rmSync(destination, { force: true });
+  process.exit(0);
+}
+const fingerprint = crypto.createHash('sha256').update(resolution.value).digest('hex');
+fs.writeFileSync(destination, `${fingerprint}\n`);
+NODE
+
 watcher_pids() {
   ps -axo pid=,command= | while read -r current_pid command; do
     [ -n "${current_pid:-}" ] || continue

package/adapters/extension/verify.sh

@@ -344,14 +344,18 @@ let r = {};
 try { r = JSON.parse(fs.readFileSync(dir + "/runtime-decision.json", "utf8")); } catch {}
 const c = r.checks || {};
 const dist = c.dist || { status: "unknown" };
-const distMsg = dist.status === "fresh" ? "dist id matches HEAD; no uncommitted source."
+const distMsg = dist.source === "release-artifact"
+  ? ("release artifact " + (dist.manifestVersion || "?") + " sha256=" + (dist.artifactSha256 || "?") + " matches the loaded runtime snapshot.")
+  : dist.status === "fresh" ? "dist id matches HEAD; no uncommitted source."
   : dist.status === "stale" ? (dist.reason === "uncommitted-source"
       ? ((dist.modified ? dist.modified.length : "some") + " uncommitted source file(s); rebuild or commit.")
       : ("dist id " + (dist.distGitId || "?") + " != HEAD " + (dist.head || "?") + "; rebuild."))
   : dist.status === "no-build" ? "no dist/chrome build."
   : "no git id in dist or not a git checkout; cannot prove parity.";
 fs.writeFileSync(dir + "/dist-freshness.json", JSON.stringify({ ...dist, message: distMsg }));
-const bl = c.buildLog || { status: "unknown" };
+const bl = c.releaseArtifact?.status === "valid"
+  ? { status: "no-watch", source: "release-artifact" }
+  : (c.buildLog || { status: "unknown" });
 const blMsg = bl.status === "ok" ? "webpack compiled."
   : bl.status === "no-watch" ? "no webpack watch log; build-health n/a (e.g. one-shot build)."
   : bl.status === "building" ? "webpack has not reported a successful compile yet."

package/adapters/extension/wallet-fixture-state.cjs

@@ -658,7 +658,9 @@ async function detectExtension(context, extensionDir, extensionIdFile) {
     }
 
     for (const candidate of candidates) {
-      const page = await context.newPage();
+      const page = context.pages().find(
+        (candidatePage) => extensionIdFromUrl(candidatePage.url()) === candidate.id,
+      ) || await context.newPage();
       try {
         await page.goto(`chrome-extension://${candidate.id}/home.html`, {
           waitUntil: 'domcontentloaded',

package/adapters/manifest.json

@@ -58,6 +58,14 @@
       "inputs": "--platform ios|android --target --port; env MOBILE_BUNDLE_PREWARM, MOBILE_BUNDLE_PREWARM_TIMEOUT",
       "outputs": "progress on stderr; exit 0 bundle ready / 1 timeout / 2 bad args"
     },
+    {
+      "id": "mobile/reset-app-data",
+      "entry": "adapters/mobile/reset-app-data.sh",
+      "kind": "bash",
+      "purpose": "Reset exactly one installed MetaMask Mobile app while preserving its install for fixture reapplication.",
+      "inputs": "--platform ios|android --target --simulator --adb-serial; env IOS_BUNDLE_ID, ANDROID_PACKAGE_ID",
+      "outputs": "selected app data cleared and app restored on iOS / cleared on Android; exit 0/1/2"
+    },
     {
       "id": "mobile/open-device",
       "entry": "adapters/mobile/open-device.sh",
@@ -162,6 +170,14 @@
       "inputs": "--target --manifest",
       "outputs": "runtime manifest _flags.testing.infuraProjectId; exit 0/1"
     },
+    {
+      "id": "extension/check-infura-readiness",
+      "entry": "adapters/extension/check-infura-readiness.cjs",
+      "kind": "node",
+      "purpose": "Reject compiled Infura credentials that are stale or unreachable on Ethereum or Linea before Chromium starts.",
+      "inputs": "--target --runtime-dist",
+      "outputs": "readiness result without credential values; exit 0/1/2"
+    },
     {
       "id": "extension/stamp-runtime-title",
       "entry": "adapters/extension/stamp-runtime-title.cjs",
@@ -170,6 +186,14 @@
       "inputs": "--target --runtime-dist; optional --runtime-dir",
       "outputs": "home.html and sidepanel.html titles updated in the isolated runtime only; exit 0/1"
     },
+    {
+      "id": "extension/artifact-runtime-state",
+      "entry": "adapters/extension/artifact-runtime-state.cjs",
+      "kind": "node",
+      "purpose": "Record or clear the acquired release artifact identity bound to the loaded runtime snapshot.",
+      "inputs": "set|clear --target --runtime-dir; set also requires --source-dir --runtime-dist --provenance",
+      "outputs": "<runtime-dir>/extension-release-artifact.json or removal; exit 0/1/2"
+    },
     {
       "id": "extension/stop-viewers",
       "entry": "adapters/extension/stop-viewers.sh",
@@ -191,7 +215,7 @@
       "entry": "adapters/extension/snapshot-dist.sh",
       "kind": "bash",
       "purpose": "Runtime-dist snapshot (rsync, excludes _metadata) with from-git-id freshness guard.",
-      "inputs": "--dist --runtime-dist --wait-iterations --summary",
+      "inputs": "--dist --target --runtime-root --runtime-dist --wait-iterations --summary",
       "outputs": "<runtime-dist>/ snapshot; optional summary; exit 0/1/2"
     },
     {

package/adapters/mobile/bridge-runtime/cdp-bridge.cjs

@@ -84,6 +84,65 @@ const NESTED_ROUTE_PARENTS = {
   DeveloperOptions: 'Settings', NotificationsSettings: 'Settings',
 };
 
+async function setInput(client, testId, value, { deviceName } = {}, redact = false) {
+  if (!testId) {
+    throw new Error('Usage: set-input <testId> <value>');
+  }
+  const expr = `(function() {
+    if (globalThis.__AGENTIC__?.setInput) return globalThis.__AGENTIC__.setInput(${JSON.stringify(testId)}, ${JSON.stringify(value)});
+    var hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook) return { ok: false, error: 'No React DevTools hook' };
+    var renderers = hook.renderers;
+    if (!renderers) return { ok: false, error: 'No renderers' };
+    var getFiberRoots = hook.getFiberRoots;
+    function findByTestId(fiber) {
+      if (!fiber) return null;
+      var props = fiber.memoizedProps;
+      if (props && props.testID === ${JSON.stringify(testId)}) return fiber;
+      return findByTestId(fiber.child) || findByTestId(fiber.sibling);
+    }
+    for (var [id] of renderers) {
+      var roots = getFiberRoots ? getFiberRoots(id) : undefined;
+      if (!roots) continue;
+      var result = null;
+      roots.forEach(function(r) {
+        if (result) return;
+        var fiber = findByTestId(r.current);
+        if (!fiber) return;
+        var cur = fiber;
+        while (cur) {
+          if (cur.memoizedProps && typeof cur.memoizedProps.onChangeText === 'function') {
+            cur.memoizedProps.onChangeText(${JSON.stringify(value)});
+            result = { ok: true, testId: ${JSON.stringify(testId)} };
+            return;
+          }
+          cur = cur.return || null;
+        }
+      });
+      if (result) return result;
+    }
+    return { ok: false, error: 'No component with testID=' + ${JSON.stringify(testId)} + ' found or no onChangeText' };
+  })()`;
+  let result;
+  try {
+    result = await cdpEval(client, expr);
+  } catch (error) {
+    if (redact) {
+      throw new Error(`Secret input could not be applied for testID ${testId}.`);
+    }
+    throw error;
+  }
+  if (redact && result?.ok === false) {
+    result = { ok: false, error: 'Secret input could not be applied.' };
+  }
+  return {
+    ...result,
+    testId,
+    value: redact ? '<redacted>' : value,
+    deviceName,
+  };
+}
+
 const COMMANDS = {
   async navigate(client, args, { deviceName, platform } = {}) {
     const routeName = ROUTE_ALIASES[args[0]] || args[0];
@@ -608,50 +667,21 @@ const COMMANDS = {
     };
   },
 
-  async 'set-input'(client, args, { deviceName } = {}) {
+  async 'set-input'(client, args, context = {}) {
+    return setInput(client, args[0], args.slice(1).join(' '), context);
+  },
+
+  async 'set-input-file'(client, args, context = {}) {
     const testId = args[0];
-    const value = args.slice(1).join(' ');
-    if (!testId) {
-      throw new Error('Usage: set-input <testId> <value>');
+    const file = args[1];
+    if (!testId || !file) {
+      throw new Error('Usage: set-input-file <testId> <value-file>');
     }
-    // Try __AGENTIC__ bridge first, fall back to inline fiber walking
-    const expr = `(function() {
-      if (globalThis.__AGENTIC__?.setInput) return globalThis.__AGENTIC__.setInput(${JSON.stringify(testId)}, ${JSON.stringify(value)});
-      var hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-      if (!hook) return { ok: false, error: 'No React DevTools hook' };
-      var renderers = hook.renderers;
-      if (!renderers) return { ok: false, error: 'No renderers' };
-      var getFiberRoots = hook.getFiberRoots;
-      function findByTestId(fiber) {
-        if (!fiber) return null;
-        var props = fiber.memoizedProps;
-        if (props && props.testID === ${JSON.stringify(testId)}) return fiber;
-        return findByTestId(fiber.child) || findByTestId(fiber.sibling);
-      }
-      for (var [id] of renderers) {
-        var roots = getFiberRoots ? getFiberRoots(id) : undefined;
-        if (!roots) continue;
-        var result = null;
-        roots.forEach(function(r) {
-          if (result) return;
-          var fiber = findByTestId(r.current);
-          if (!fiber) return;
-          var cur = fiber;
-          while (cur) {
-            if (cur.memoizedProps && typeof cur.memoizedProps.onChangeText === 'function') {
-              cur.memoizedProps.onChangeText(${JSON.stringify(value)});
-              result = { ok: true, testId: ${JSON.stringify(testId)}, value: ${JSON.stringify(value)} };
-              return;
-            }
-            cur = cur.return || null;
-          }
-        });
-        if (result) return result;
-      }
-      return { ok: false, error: 'No component with testID=' + ${JSON.stringify(testId)} + ' found or no onChangeText' };
-    })()`;
-    const result = await cdpEval(client, expr);
-    return { ...result, testId, value, deviceName };
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+      throw new Error('set-input-file requires a regular value file.');
+    }
+    return setInput(client, testId, fs.readFileSync(file, 'utf8'), context, true);
   },
 
   async 'sentry-debug'(client, args, { deviceName } = {}) {
@@ -977,6 +1007,7 @@ Commands:
                                        Scroll a ScrollView/FlatList
   measure-scroll-transition <json>    Scroll and measure a visible target using one CDP session
   set-input <testId> <value>           Set text input value by testID (calls onChangeText)
+  set-input-file <testId> <value-file> Set text input from a regular file and redact the value
   sentry-debug [enable|disable]          Patch Sentry to log errors to console with [SENTRY-DEBUG] prefix
   unlock <password>                      Unlock wallet (inject password + press login button via fiber tree)
   profiler-start                       Start Hermes sampling profiler