@deeeed/metamask-harness 0.35.0 → 0.36.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.36.0 - 2026-08-13
+
+### Added
+
+- Add a composable Mobile and Extension wallet import recipe that either verifies an existing fixture-backed profile or imports the primary mnemonic through visible onboarding UI, with secret-safe inputs, privacy-preserving defaults, and configurable MetaMetrics and Mobile interests.
+- Add `fixtures reset` plus a shared Mobile/Extension reset-import recipe. Extension resets its owned browser profile; Mobile clears only the selected app's data while preserving its installed build. The visible recipe separately proves the real user reset and import flow.
+
+### Fixed
+
+- Restart a harness-owned Extension watcher when its effective Infura credential differs from the current product configuration, and preflight compiled Ethereum and Linea credentials before Chrome starts, preventing a forced-red validation from poisoning later launches or opening a native HTTP authentication dialog.
+- Make normal Extension launch and runtime recovery use the product's `yarn start` development build, while keeping production-like LavaMoat builds behind explicit `launch --build`.
+- Require wallet profile reuse to match the requested account, wait for Mobile onboarding to reach a terminal route, and resolve the exact Mobile reset device and prewarm its bundle before relaunching after app-data reset.
+- Refuse ambiguous installed Mobile app variants during reset, prefer complete environment wallet credentials without parsing a stale fixture, and reject bad Extension RPC configuration before replacing the loaded runtime snapshot.
+- Validate recovery credentials, fixture structure, and platform-specific onboarding choices before destructive resets; prove Mobile reset by the visible import control; honor persisted MetaMetrics consent through Security settings; and keep file-backed wallet secrets out of bridge errors.
+
 ## 0.35.0 - 2026-08-12
 
 ### Fixed

package/README.md

@@ -88,10 +88,14 @@ mm-harness stop
 mm-harness logs
 mm-harness debug
 mm-harness fixtures set
+
+# Delete the current wallet, then reapply the canonical fixture from clean state.
+mm-harness fixtures reset
 ```
 
 Extension `launch` keeps its incremental watcher running. Refresh the active
-page after a successful rebuild; use `launch --build` only for a clean rebuild.
+page after a successful rebuild; use `launch --build` only for an explicit
+production-like LavaMoat rebuild.
 
 Log sources stay separate:
 
@@ -115,6 +119,10 @@ mm-harness call metamask.wallet.ensure_unlocked
 mm-harness run --list
 mm-harness run perps.clean-market-testnet --describe
 mm-harness run wallet.smoke --describe
+mm-harness run wallet.import method=auto
+
+# Use visible client UI to delete and import the wallet again.
+mm-harness run wallet.reset-import
 mm-harness run path/to/recipe.json market=ETH --plan
 mm-harness run path/to/recipe.json
 ```

package/adapters/extension/check-infura-readiness.cjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const https = require('node:https');
+const path = require('node:path');
+
+const args = {};
+for (let index = 2; index < process.argv.length; index += 1) {
+  const key = process.argv[index];
+  if (key === '--help' || key === '-h') {
+    process.stdout.write('Usage: check-infura-readiness.cjs --target <metamask-extension> --runtime-dist <dist>\n');
+    process.exit(0);
+  }
+  if (!key.startsWith('--') || index + 1 >= process.argv.length) {
+    throw new Error(`invalid argument: ${key}`);
+  }
+  args[key.slice(2)] = process.argv[++index];
+}
+
+for (const key of ['target', 'runtime-dist']) {
+  if (!args[key]) throw new Error(`--${key} is required`);
+}
+
+const target = path.resolve(args.target);
+const runtimeDist = path.resolve(args['runtime-dist']);
+const config = require('./lib/product-config.cjs');
+
+async function main() {
+  const resolution = config.resolveExtensionInfuraProjectId(target, process.env);
+  if (resolution.kind !== 'configured') {
+    fail('the effective Extension product configuration has no usable Infura project ID');
+  }
+  if (!compiledScriptsContain(runtimeDist, resolution.value)) {
+    fail('the compiled Extension scripts do not match the effective Infura project ID');
+  }
+  for (const host of ['mainnet.infura.io', 'linea-mainnet.infura.io']) {
+    const response = await rpcProbe(host, resolution.value);
+    if (response.statusCode < 200 || response.statusCode >= 300 || response.jsonRpcResult !== true) {
+      fail(`${host} rejected the effective Infura project ID (HTTP ${response.statusCode})`);
+    }
+  }
+  process.stdout.write('Infura readiness preflight passed for Ethereum and Linea.\n');
+}
+
+function compiledScriptsContain(root, value) {
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const file = path.join(current, entry.name);
+      if (entry.isDirectory()) pending.push(file);
+      else if (entry.isFile() && entry.name.endsWith('.js') && fs.readFileSync(file, 'utf8').includes(value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function rpcProbe(host, projectId) {
+  const body = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'eth_chainId', params: [] });
+  return new Promise((resolve, reject) => {
+    const request = https.request({
+      hostname: host,
+      path: `/v3/${encodeURIComponent(projectId)}`,
+      method: 'POST',
+      timeout: 10_000,
+      headers: {
+        'content-type': 'application/json',
+        'content-length': Buffer.byteLength(body),
+      },
+    }, (response) => {
+      let text = '';
+      response.setEncoding('utf8');
+      response.on('data', (chunk) => { text += chunk; });
+      response.on('end', () => {
+        let jsonRpcResult = false;
+        try {
+          const parsed = JSON.parse(text);
+          jsonRpcResult = typeof parsed.result === 'string' && parsed.result.startsWith('0x');
+        } catch {
+          jsonRpcResult = false;
+        }
+        resolve({ statusCode: response.statusCode || 0, jsonRpcResult });
+      });
+    });
+    request.on('timeout', () => request.destroy(new Error(`${host} timed out`)));
+    request.on('error', reject);
+    request.end(body);
+  });
+}
+
+function fail(detail) {
+  process.stderr.write(
+    `EVM_RPC_UNREACHABLE: Infura readiness preflight failed before browser launch: ${detail}.\n` +
+      `Next: stop the stale watcher, confirm ${path.join(target, '.metamaskrc')} has a real INFURA_PROJECT_ID, then rerun mm-harness launch --verify --target ${JSON.stringify(target)}.\n`,
+  );
+  process.exit(1);
+}
+
+main().catch((error) => fail(error instanceof Error ? error.message : String(error)));

package/adapters/extension/inject.mjs

@@ -102,6 +102,7 @@ copyFile(path.join(runnerDir, 'adapters/extension/build-lavamoat.sh'), path.join
 copyFile(path.join(runnerDir, 'adapters/extension/launch-webpack.cjs'), path.join(harnessDir, 'scripts/launch-webpack.cjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/sync-webpack-dist.cjs'), path.join(harnessDir, 'scripts/sync-webpack-dist.cjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/configure-runtime-manifest.cjs'), path.join(harnessDir, 'scripts/configure-runtime-manifest.cjs'));
+copyFile(path.join(runnerDir, 'adapters/extension/check-infura-readiness.cjs'), path.join(harnessDir, 'scripts/check-infura-readiness.cjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/stamp-runtime-title.cjs'), path.join(harnessDir, 'scripts/stamp-runtime-title.cjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/stop-viewers.sh'), path.join(harnessDir, 'scripts/stop-viewers.sh'));
 copyFile(path.join(runnerDir, 'adapters/extension/snapshot-dist.sh'), path.join(harnessDir, 'scripts/snapshot-dist.sh'));

package/adapters/extension/live.sh

@@ -6,13 +6,16 @@
 # Purpose:
 #   Builds the per-run prepare command from the named feature scripts
 #   (watch, dist snapshot, fixture seed, detached chrome, CDP poll), then
-#   runs launch.sh and verify.sh under a timestamped artifact dir.
+#   runs launch.sh and, unless --launch-only is set, verify.sh under a
+#   timestamped artifact dir.
 #
 # Inputs (flags / env):
 #   --target <metamask-extension> (default $PWD)
 #   --cdp-port <port> (optional; inferred from checkout context/pool when omitted)
 #   --launch-existing-dist | --start-watch | --build-lavamoat | --prepare-cmd <cmd>
 #       (env RECIPE_HARNESS_EXTENSION_LAUNCH_CMD)
+#   --launch-only (skip recipe verification; used by fixture application while
+#       its checkout lock is held)
 #   --dist-dir <rel> (default dist/chrome), --chrome-user-data-dir <dir>,
 #   --remote-flag <KEY=VARIANT[,KEY=VARIANT...]> (pins manifest _flags into the
 #       ephemeral runtime-dist snapshot before launch; omit for default behavior)
@@ -44,6 +47,7 @@ DIST_DIR="dist/chrome"
 CHROME_USER_DATA_DIR="${CHROME_USER_DATA_DIR:-}"
 REMOTE_FLAGS=""
 REMOTE_FLAGS_APPLIED=false
+RUN_VERIFY=true
 while [ "$#" -gt 0 ]; do
   case "$1" in
     --target) [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; TARGET="$2"; shift 2 ;;
@@ -55,10 +59,11 @@ while [ "$#" -gt 0 ]; do
     --start-url) [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; START_URL="$2"; shift 2 ;;
     --start-watch|--start-test-watch) START_WATCH=true; LAUNCH_EXISTING_DIST=true; shift ;;
     --build-lavamoat) BUILD_LAVAMOAT=true; LAUNCH_EXISTING_DIST=true; shift ;;
+    --launch-only) RUN_VERIFY=false; shift ;;
     --dist-dir) [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; DIST_DIR="$2"; shift 2 ;;
     --chrome-user-data-dir) [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; CHROME_USER_DATA_DIR="$2"; shift 2 ;;
     --remote-flag) [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; REMOTE_FLAGS="$2"; shift 2 ;;
-    -h|--help) echo "Usage: live.sh [--target <metamask-extension>] [--out <recipes-dir>] [--cdp-port <port>] [--launch-existing-dist|--start-watch|--build-lavamoat|--prepare-cmd <cmd>] [--dist-dir dist/chrome] [--remote-flag KEY=VARIANT] [--artifacts-dir <dir>]"; exit 0 ;;
+    -h|--help) echo "Usage: live.sh [--target <metamask-extension>] [--out <recipes-dir>] [--cdp-port <port>] [--launch-existing-dist|--start-watch|--build-lavamoat|--prepare-cmd <cmd>] [--launch-only] [--dist-dir dist/chrome] [--remote-flag KEY=VARIANT] [--artifacts-dir <dir>]"; exit 0 ;;
     *) echo "Unknown arg: $1" >&2; exit 2 ;;
   esac
 done
@@ -177,6 +182,7 @@ NODE
   quoted_build_lavamoat="$(printf '%q' "$SCRIPT_DIR/build-lavamoat.sh")"
   quoted_snapshot_dist="$(printf '%q' "$SCRIPT_DIR/snapshot-dist.sh")"
   quoted_configure_manifest="$(printf '%q' "$SCRIPT_DIR/configure-runtime-manifest.cjs")"
+  quoted_check_infura="$(printf '%q' "$SCRIPT_DIR/check-infura-readiness.cjs")"
   quoted_stamp_title="$(printf '%q' "$SCRIPT_DIR/stamp-runtime-title.cjs")"
   quoted_chrome_launcher="$(printf '%q' "$SCRIPT_DIR/launch-browser.cjs")"
   quoted_fixture_state="$(printf '%q' "$FIXTURE_STATE_ABS")"
@@ -257,9 +263,10 @@ NODE
   if $BUILD_LAVAMOAT; then
     prepare_parts+=("bash ${quoted_build_lavamoat} --target ${quoted_target} --runtime-dir ${quoted_runtime_dir}")
   fi
-  prepare_parts+=("node ${quoted_chrome_launcher} --stop-only 1 --reset-profile 1 --chrome-bin ${quoted_chrome} --profile ${quoted_profile} --cdp-port ${CDP_PORT} --extension-dir ${quoted_runtime_dist} --chrome-log ${quoted_chrome_log} --chrome-pid ${quoted_chrome_pid}")
+  prepare_parts+=("node ${quoted_check_infura} --target ${quoted_target} --runtime-dist ${quoted_dist}")
   prepare_parts+=("bash ${quoted_snapshot_dist} --dist ${quoted_dist} --runtime-dist ${quoted_runtime_dist}")
   prepare_parts+=("node ${quoted_configure_manifest} --target ${quoted_target} --manifest ${quoted_runtime_dist}/manifest.json")
+  prepare_parts+=("node ${quoted_chrome_launcher} --stop-only 1 --reset-profile 1 --chrome-bin ${quoted_chrome} --profile ${quoted_profile} --cdp-port ${CDP_PORT} --extension-dir ${quoted_runtime_dist} --chrome-log ${quoted_chrome_log} --chrome-pid ${quoted_chrome_pid}")
   prepare_parts+=("node ${quoted_stamp_title} --target ${quoted_target} --runtime-dist ${quoted_runtime_dist} --runtime-dir ${quoted_runtime_dir}")
   # Optional A/B feature-flag pinning: patch the ephemeral snapshot manifest so
   # manifest._flags wins over the fetched ClientConfigApi value. No-op unless
@@ -301,7 +308,7 @@ printf '  '
 printf '%q ' "${display_args[@]}"
 printf '\n'
 echo "Launch artifacts: $ARTIFACTS/launch"
-echo "Verify artifacts: $ARTIFACTS/verify"
+$RUN_VERIFY && echo "Verify artifacts: $ARTIFACTS/verify"
 
 launch_args=(--target "$TARGET" --cdp-port "$CDP_PORT" --artifacts-dir "$ARTIFACTS/launch")
 [ -n "$PREPARE_CMD" ] && launch_args+=(--prepare-cmd "$PREPARE_CMD")
@@ -312,18 +319,21 @@ set +e
 launch_status=$?
 set -e
 
-verify_status=1
-if [ "$launch_status" -eq 0 ]; then
+verify_status=0
+if [ "$launch_status" -eq 0 ] && $RUN_VERIFY; then
   echo "[recipe-harness] phase 2/2: live verify (readiness + smoke recipe)" >&2
   set +e
   "$VERIFY_SH" --target "$TARGET" --out "$OUT" --cdp-port "$CDP_PORT" --artifacts-dir "$ARTIFACTS/verify"
   verify_status=$?
   set -e
-else
+elif [ "$launch_status" -ne 0 ]; then
+  verify_status=1
   echo "Skipping Extension live verify because launch failed; see $ARTIFACTS/launch/summary.json" >&2
+else
+  echo "Skipping Extension live verify for launch-only fixture application." >&2
 fi
 
-TARGET_FOR_SUMMARY="$TARGET" ARTIFACTS_FOR_SUMMARY="$ARTIFACTS" CDP_PORT_FOR_SUMMARY="$CDP_PORT" LAUNCH_STATUS="$launch_status" VERIFY_STATUS="$verify_status" LAUNCH_EXISTING_DIST="$LAUNCH_EXISTING_DIST" START_WATCH="$START_WATCH" BUILD_LAVAMOAT="$BUILD_LAVAMOAT" node <<'NODE'
+TARGET_FOR_SUMMARY="$TARGET" ARTIFACTS_FOR_SUMMARY="$ARTIFACTS" CDP_PORT_FOR_SUMMARY="$CDP_PORT" LAUNCH_STATUS="$launch_status" VERIFY_STATUS="$verify_status" RUN_VERIFY="$RUN_VERIFY" LAUNCH_EXISTING_DIST="$LAUNCH_EXISTING_DIST" START_WATCH="$START_WATCH" BUILD_LAVAMOAT="$BUILD_LAVAMOAT" node <<'NODE'
 const fs = require('fs');
 const path = require('path');
 const artifacts = process.env.ARTIFACTS_FOR_SUMMARY;
@@ -331,6 +341,7 @@ const launchSummary = path.join(artifacts, 'launch', 'summary.json');
 const verifySummary = path.join(artifacts, 'verify', 'summary.json');
 const launchStatus = Number(process.env.LAUNCH_STATUS);
 const verifyStatus = Number(process.env.VERIFY_STATUS);
+const runVerify = process.env.RUN_VERIFY === 'true';
 fs.writeFileSync(path.join(artifacts, 'summary.json'), `${JSON.stringify({
   adapter: 'extension',
   action: 'live',
@@ -341,9 +352,13 @@ fs.writeFileSync(path.join(artifacts, 'summary.json'), `${JSON.stringify({
   startWatch: process.env.START_WATCH === 'true',
   buildLavaMoat: process.env.BUILD_LAVAMOAT === 'true',
   launch: { exitCode: launchStatus, summaryPath: fs.existsSync(launchSummary) ? launchSummary : null },
-  verify: { exitCode: verifyStatus, summaryPath: fs.existsSync(verifySummary) ? verifySummary : null },
+  verify: runVerify
+    ? { status: verifyStatus === 0 ? 'pass' : 'fail', exitCode: verifyStatus, summaryPath: fs.existsSync(verifySummary) ? verifySummary : null }
+    : { status: 'skipped', exitCode: null, summaryPath: null },
   easyCommand: `mm-harness launch --verify --target <repo>`,
-  note: 'Runs launch then live verify so a developer can validate browser startup, CDP readiness, recipe bridge, screenshots/fallback classification, and sample recipes from one runner-owned command.',
+  note: runVerify
+    ? 'Runs launch then live verify so a developer can validate browser startup, CDP readiness, recipe bridge, screenshots/fallback classification, and sample recipes from one runner-owned command.'
+    : 'Runs launch validation only for fixture application while the checkout lock is held.',
   generatedAt: new Date().toISOString(),
 }, null, 2)}\n`);
 NODE

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/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",

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

package/adapters/mobile/reset-app-data.sh

@@ -0,0 +1,154 @@
+#!/usr/bin/env bash
+# Reset one installed MetaMask Mobile app without rebuilding it.
+set -euo pipefail
+
+PLATFORM="${PLATFORM:-ios}"
+TARGET="$PWD"
+SIMULATOR="${SIM_UDID:-${IOS_SIMULATOR:-booted}}"
+ADB_SERIAL_ARG="${ADB_SERIAL:-${ANDROID_SERIAL:-}}"
+ADB_BIN="${MM_HARNESS_ADB_PATH:-}"
+MM_RESET_TEMP_ROOT=""
+MM_RESET_STAGING_DIR=""
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --platform) PLATFORM="$2"; shift 2 ;;
+    --target) TARGET="$2"; shift 2 ;;
+    --simulator) SIMULATOR="$2"; shift 2 ;;
+    --adb-serial) ADB_SERIAL_ARG="$2"; shift 2 ;;
+    -h|--help)
+      printf 'Usage: reset-app-data.sh --platform ios|android [--target <dir>] [--simulator <udid|name>] [--adb-serial <serial>]\n'
+      exit 0
+      ;;
+    *) printf 'reset-app-data: unknown arg: %s\n' "$1" >&2; exit 2 ;;
+  esac
+done
+
+TARGET="$(cd "$TARGET" && pwd -P)"
+
+reset_ios() {
+  local bundle_id="" app_source="" candidate="" staged_app=""
+  local temp_root="${TMPDIR:-/tmp}" staging_dir=""
+  local -a candidates installed_ids installed_paths
+
+  temp_root="${temp_root%/}"
+  [ -n "$temp_root" ] && [ "$temp_root" != "/" ] && [ -d "$temp_root" ] && [ ! -L "$temp_root" ] || {
+    printf 'reset-app-data: unsafe temporary directory: %s\n' "$temp_root" >&2
+    return 1
+  }
+  if [ -n "${IOS_BUNDLE_ID:-}" ]; then
+    candidates=("$IOS_BUNDLE_ID")
+  else
+    candidates=("io.metamask.MetaMask" "io.metamask" "io.metamask.MetaMask-Flask" "io.metamask.qa")
+  fi
+  for candidate in "${candidates[@]}"; do
+    if app_source="$(xcrun simctl get_app_container "$SIMULATOR" "$candidate" app 2>/dev/null)"; then
+      installed_ids+=("$candidate")
+      installed_paths+=("$app_source")
+    fi
+  done
+  if [ "${#installed_ids[@]}" -gt 1 ]; then
+    printf 'reset-app-data: multiple MetaMask iOS variants are installed on simulator %s: %s.\n' "$SIMULATOR" "${installed_ids[*]}" >&2
+    printf 'Next: set IOS_BUNDLE_ID to the exact variant and retry.\n' >&2
+    return 1
+  fi
+  bundle_id="${installed_ids[0]:-}"
+  app_source="${installed_paths[0]:-}"
+  [ -n "$bundle_id" ] && [ -n "$app_source" ] || {
+    printf 'reset-app-data: no installed MetaMask app was found on iOS simulator %s.\n' "$SIMULATOR" >&2
+    printf "Next: mm-harness launch --adapter mobile --platform ios --target '%s'\n" "$TARGET" >&2
+    return 1
+  }
+  case "$app_source" in
+    */Library/Developer/CoreSimulator/Devices/*/data/Containers/Bundle/Application/*/*.app) ;;
+    *) printf 'reset-app-data: refusing unexpected iOS app path: %s\n' "$app_source" >&2; return 1 ;;
+  esac
+  [ -d "$app_source" ] && [ ! -L "$app_source" ] || {
+    printf 'reset-app-data: iOS app is not a real directory: %s\n' "$app_source" >&2
+    return 1
+  }
+
+  staging_dir="$(mktemp -d "$temp_root/mm-harness-ios-reset.XXXXXX")"
+  case "$staging_dir" in
+    "$temp_root"/mm-harness-ios-reset.*) ;;
+    *) printf 'reset-app-data: refusing unexpected staging path: %s\n' "$staging_dir" >&2; return 1 ;;
+  esac
+  [ -d "$staging_dir" ] && [ ! -L "$staging_dir" ] || return 1
+  staged_app="$staging_dir/$(basename "$app_source")"
+  MM_RESET_TEMP_ROOT="$temp_root"
+  MM_RESET_STAGING_DIR="$staging_dir"
+  cleanup_staging() {
+    case "$MM_RESET_STAGING_DIR" in
+      "$MM_RESET_TEMP_ROOT"/mm-harness-ios-reset.*)
+        [ -d "$MM_RESET_STAGING_DIR" ] && [ ! -L "$MM_RESET_STAGING_DIR" ] && rm -r -- "$MM_RESET_STAGING_DIR"
+        ;;
+      *) printf 'reset-app-data: staging cleanup refused: %s\n' "$MM_RESET_STAGING_DIR" >&2 ;;
+    esac
+  }
+  trap cleanup_staging EXIT HUP INT TERM
+
+  ditto "$app_source" "$staged_app"
+  [ -d "$staged_app" ] && [ ! -L "$staged_app" ] || {
+    printf 'reset-app-data: failed to preserve the installed iOS app.\n' >&2
+    return 1
+  }
+  printf 'Resetting iOS app data: simulator=%s bundle=%s\n' "$SIMULATOR" "$bundle_id" >&2
+  xcrun simctl terminate "$SIMULATOR" "$bundle_id" >/dev/null 2>&1 || true
+  xcrun simctl uninstall "$SIMULATOR" "$bundle_id"
+  xcrun simctl install "$SIMULATOR" "$staged_app"
+  xcrun simctl get_app_container "$SIMULATOR" "$bundle_id" app >/dev/null
+  printf 'Mobile app data reset; preserved installed iOS build %s.\n' "$bundle_id" >&2
+}
+
+reset_android() {
+  local package_id="" candidate="" clear_output=""
+  local -a candidates adb_target installed_ids
+  if [ -z "$ADB_BIN" ]; then
+    ADB_BIN="$(command -v adb 2>/dev/null || true)"
+  fi
+  [ -n "$ADB_BIN" ] && [ "${ADB_BIN#/}" != "$ADB_BIN" ] && [ -x "$ADB_BIN" ] || {
+    printf 'reset-app-data: Android SDK Platform-Tools (adb) is required.\n' >&2
+    printf 'Next: brew install android-platform-tools\n' >&2
+    return 1
+  }
+  [ -n "$ADB_SERIAL_ARG" ] || {
+    printf 'reset-app-data: an Android serial is required.\n' >&2
+    printf 'Next: mm-harness devices --adapter mobile --json\n' >&2
+    return 1
+  }
+  adb_target=(-s "$ADB_SERIAL_ARG")
+  if [ -n "${ANDROID_PACKAGE_ID:-}" ]; then
+    candidates=("$ANDROID_PACKAGE_ID")
+  else
+    candidates=("io.metamask" "io.metamask.flask" "io.metamask.qa")
+  fi
+  for candidate in "${candidates[@]}"; do
+    if "$ADB_BIN" "${adb_target[@]}" shell pm path "$candidate" 2>/dev/null | grep -q '^package:'; then
+      installed_ids+=("$candidate")
+    fi
+  done
+  if [ "${#installed_ids[@]}" -gt 1 ]; then
+    printf 'reset-app-data: multiple MetaMask Android variants are installed on device %s: %s.\n' "$ADB_SERIAL_ARG" "${installed_ids[*]}" >&2
+    printf 'Next: set ANDROID_PACKAGE_ID to the exact variant and retry.\n' >&2
+    return 1
+  fi
+  package_id="${installed_ids[0]:-}"
+  [ -n "$package_id" ] || {
+    printf 'reset-app-data: no installed MetaMask app was found on Android device %s.\n' "$ADB_SERIAL_ARG" >&2
+    printf "Next: mm-harness launch --adapter mobile --platform android --target '%s' --device '%s'\n" "$TARGET" "$ADB_SERIAL_ARG" >&2
+    return 1
+  }
+  printf 'Resetting Android app data: device=%s package=%s\n' "$ADB_SERIAL_ARG" "$package_id" >&2
+  clear_output="$("$ADB_BIN" "${adb_target[@]}" shell pm clear "$package_id")"
+  [ "$clear_output" = "Success" ] || {
+    printf 'reset-app-data: Android package clear failed: %s\n' "$clear_output" >&2
+    return 1
+  }
+  printf 'Mobile app data reset; preserved installed Android build %s.\n' "$package_id" >&2
+}
+
+case "$PLATFORM" in
+  ios) reset_ios ;;
+  android) reset_android ;;
+  *) printf 'reset-app-data: --platform must be ios or android (got: %s)\n' "$PLATFORM" >&2; exit 2 ;;
+esac