@deeeed/metamask-harness 0.34.4 → 0.36.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## 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
+
+- Make Extension and Mobile launch verification fail when their in-app EVM network client cannot complete a live RPC, with exact Infura configuration and retry guidance.
+- Make Extension doctor require checkout-pinned Playwright Chromium and report the exact install command when it is missing.
+- Make doctor report the exact dependency-install command when `--fix` finds stale or missing dependencies instead of implying they were repaired.
+- Make the setup prompt reuse configured skill sources and require consent before cloning or editing shell startup files.
+- Keep installed overlays delegated to the source runner that installed them before falling back to a potentially stale global runner.
+
 ## 0.34.4 - 2026-08-12
 
 ### Changed

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/core/inject.sh

@@ -88,11 +88,11 @@ install_v1_runner_assets() {
     if [ -n "$METAMASK_RUNNER_PROTOCOL_ROOT" ]; then
       printf 'export FARMSLOT_ROOT=${FARMSLOT_ROOT:-%s}\n' "$runner_protocol_root_q"
     fi
-    # Resolve the runner at run time (override > global install > install-time
-    # record); the recorded path is last resort so a moved checkout is not pinned.
+    # The recorded runner owns the installed overlay and must remain ahead of an
+    # unrelated global version. MM_HARNESS_BIN is the explicit override.
     printf '%s\n' 'if [ -n "${MM_HARNESS_BIN:-}" ] && [ -x "${MM_HARNESS_BIN}" ]; then exec "${MM_HARNESS_BIN}" "$@"; fi'
-    printf '%s\n' 'if command -v mm-harness >/dev/null 2>&1; then exec mm-harness "$@"; fi'
     printf 'if [ -x %s ]; then exec %s "$@"; fi\n' "$runner_exec_q" "$runner_exec_q"
+    printf '%s\n' 'if command -v mm-harness >/dev/null 2>&1; then exec mm-harness "$@"; fi'
     printf '%s\n' 'echo "mm-harness not found. Next: npm i -g @deeeed/metamask-harness" >&2'
     printf '%s\n' 'exit 127'
   } > "$HARNESS_DIR/runner/bin/mm-harness"

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

@@ -69,17 +69,16 @@ fs.mkdirSync(path.join(harnessDir, 'runner/recipes'), { recursive: true });
 fs.rmSync(path.join(harnessDir, 'scripts'), { recursive: true, force: true });
 fs.mkdirSync(path.join(harnessDir, 'scripts/lib'), { recursive: true });
 
-// Resolve the runner at run time so a moved or shared checkout is never bound to
-// an install-time absolute path: explicit override, then a global install, then
-// the runner recorded at install time as a last resort; teach install on miss.
+// Prefer the runner that installed the overlay so its runtime checks match the
+// installed scripts. Explicit overrides still support controlled delegation.
 const pinnedBin = shellQuote(path.join(runnerDir, 'bin/mm-harness'));
 const delegate = [
   '#!/usr/bin/env bash',
   'set -euo pipefail',
   protocolRoot ? `export FARMSLOT_ROOT=\${FARMSLOT_ROOT:-${shellQuote(protocolRoot)}}` : null,
   'if [ -n "${MM_HARNESS_BIN:-}" ] && [ -x "${MM_HARNESS_BIN}" ]; then exec "${MM_HARNESS_BIN}" "$@"; fi',
-  'if command -v mm-harness >/dev/null 2>&1; then exec mm-harness "$@"; fi',
   `if [ -x ${pinnedBin} ]; then exec ${pinnedBin} "$@"; fi`,
+  'if command -v mm-harness >/dev/null 2>&1; then exec mm-harness "$@"; fi',
   'echo "mm-harness not found. Next: npm i -g @deeeed/metamask-harness" >&2',
   'exit 127',
 ].filter(Boolean).join('\n') + '\n';
@@ -103,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/inject.sh

@@ -44,7 +44,7 @@ for rel in "$HARNESS_REL" "$HARNESS_REL/runner" "$HARNESS_REL/scripts"; do
   done
 done
 
-rm -rf "$HARNESS_DIR/runner" "$HARNESS_DIR/scripts"
+rm -rf "$HARNESS_DIR/runner" "$HARNESS_DIR/scripts" "$HARNESS_DIR/bridge-runtime"
 mkdir -p "$HARNESS_DIR/runner/bin" "$HARNESS_DIR/runner/manifests" "$HARNESS_DIR/runner/recipes" "$HARNESS_DIR/scripts/lib"
 
 RUNNER_EXEC_Q="$(printf '%q' "$RUNNER_DIR/bin/mm-harness")"
@@ -62,8 +62,8 @@ PROTOCOL_ROOT_Q="$(printf '%q' "$PROTOCOL_ROOT")"
     printf 'export METAMASK_RUNNER_PROTOCOL_ROOT=${METAMASK_RUNNER_PROTOCOL_ROOT:-%s}\n' "$PROTOCOL_ROOT_Q"
   fi
   printf '%s\n' 'if [ -n "${MM_HARNESS_BIN:-}" ] && [ -x "$MM_HARNESS_BIN" ]; then exec "$MM_HARNESS_BIN" "$@"; fi'
-  printf '%s\n' 'if command -v mm-harness >/dev/null 2>&1; then exec mm-harness "$@"; fi'
   printf 'if [ -x %s ]; then exec %s "$@"; fi\n' "$RUNNER_EXEC_Q" "$RUNNER_EXEC_Q"
+  printf '%s\n' 'if command -v mm-harness >/dev/null 2>&1; then exec mm-harness "$@"; fi'
   printf '%s\n' 'echo "mm-harness not found. Next: npm i -g @deeeed/metamask-harness@latest" >&2' 'exit 127'
 } > "$HARNESS_DIR/runner/bin/mm-harness"
 chmod +x "$HARNESS_DIR/runner/bin/mm-harness"
@@ -77,6 +77,7 @@ rsync -a --delete "$RUNNER_DIR/library/recipes/" "$HARNESS_DIR/runner/recipes/"
 rm -rf "$HARNESS_DIR/runner/flows"
 rm -f "$HARNESS_DIR/runner/library.json"
 cp "$RUNNER_DIR/adapters/mobile/verify.sh" "$HARNESS_DIR/scripts/verify.sh"
+cp -R "$RUNNER_DIR/adapters/mobile/bridge-runtime" "$HARNESS_DIR/bridge-runtime"
 cp "$RUNNER_DIR/adapters/shared/harness-path.sh" "$HARNESS_DIR/scripts/lib/harness-path.sh"
 cp "$RUNNER_DIR/adapters/shared/path-defaults.json" "$HARNESS_DIR/scripts/lib/path-defaults.json"
 chmod -R u+rwX,go+rX "$HARNESS_DIR"
@@ -114,7 +115,7 @@ fs.writeFileSync(manifestPath, JSON.stringify({
   actionManifestPath: `${harnessRel}/action-manifest.json`,
   runnerEntrypoint: `${harnessRel}/runner/bin/mm-harness`,
   runtimeHelpers: { verify: `${harnessRel}/scripts/verify.sh` },
-  harnessInstalledPaths: [`${harnessRel}/runner`, `${harnessRel}/scripts`, `${harnessRel}/action-manifest.json`],
+  harnessInstalledPaths: [`${harnessRel}/runner`, `${harnessRel}/scripts`, `${harnessRel}/bridge-runtime`, `${harnessRel}/action-manifest.json`],
   productOwnedPaths: ['app/dev-tools/AgenticService', 'app/core/NavigationService/NavigationService.ts'],
   cleanupCommand,
   productDiffExcludes: [`:(exclude)${harnessRoot}`],