@deeeed/metamask-harness 0.34.4 → 0.36.0

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

package/adapters/mobile/verify.sh

@@ -325,6 +325,35 @@ JSON
   ) > "$log_path" 2>&1
 }
 
+evm_rpc_ready() {
+  local log_path="$1"
+  local bridge="$HARNESS_DIR/bridge-runtime/cdp-bridge.cjs"
+  local expression
+  expression="(async function(){try{var engine=globalThis.Engine;var controller=engine&&engine.context&&engine.context.NetworkController;if(!controller||typeof controller.getSelectedNetworkClient!=='function')throw new Error('NetworkController selected client is unavailable');var client=controller.getSelectedNetworkClient();if(!client||!client.provider||typeof client.provider.request!=='function')throw new Error('selected EVM provider is unavailable');var result=await client.provider.request({method:'eth_blockNumber'});if(typeof result!=='string'||!/^0x[0-9a-f]+$/i.test(result))throw new Error('eth_blockNumber returned an invalid result');return {ok:true,result:result};}catch(error){return {ok:false,error:error&&(error.message||String(error))};}})()"
+  [ -f "$bridge" ] || {
+    printf 'Mobile bridge is missing at %s\n' "$bridge" > "$log_path"
+    return 1
+  }
+  if ! run_with_timeout "$log_path" 25 env \
+    APP_ROOT="$TARGET" \
+    WATCHER_PORT="$port" \
+    IOS_SIMULATOR="${IOS_SIMULATOR:-$ios_simulator_resolved}" \
+    ADB_SERIAL="${ADB_SERIAL:-$adb_serial_resolved}" \
+    ANDROID_SERIAL="${ANDROID_SERIAL:-$adb_serial_resolved}" \
+    node "$bridge" eval-async "$expression"; then
+    return 1
+  fi
+  node - "$log_path" <<'NODE'
+const fs = require('fs');
+try {
+  const result = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+  process.exit(result.ok === true ? 0 : 1);
+} catch {
+  process.exit(1);
+}
+NODE
+}
+
 ensure_live_runtime() {
   local device_target="$1"
   local attempt
@@ -419,6 +448,14 @@ JSON
     add_note "Runner v1 live bridge smoke failed; inspect logs/runner-live-smoke.log and runner-live-smoke/trace.json."
     status="fail"
   fi
+
+  if evm_rpc_ready "$ARTIFACTS/logs/evm-rpc-readiness.log"; then
+    checks+=("{\"name\":\"live EVM RPC readiness\",\"status\":\"pass\"}")
+  else
+    checks+=("{\"name\":\"live EVM RPC readiness\",\"status\":\"fail\",\"detail\":\"see logs/evm-rpc-readiness.log\"}")
+    add_note "EVM RPC readiness probe failed. Infura configured ≠ RPC reachable. Next: confirm $TARGET/.js.env has a real MM_INFURA_PROJECT_ID (not 00000000000), then rerun mm-harness launch $PLATFORM --verify --target '$TARGET'."
+    status="fail"
+  fi
 fi
 
 RECIPE_HARNESS_PREFLIGHT_MODE="$PREFLIGHT_MODE" RECIPE_HARNESS_ROOT_EXCLUDE="$HARNESS_ROOT" node - "$ARTIFACTS" "$TARGET" "$status" "${checks[@]}" <<'NODE'

package/dist/adapters/extension/product-config.js

@@ -1,6 +1,31 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
 import path from "node:path";
 import productConfig from "../../../adapters/extension/lib/product-config.cjs";
 import { shellQuote } from "../../commands/parse-args.js";
+const EXTENSION_PRODUCT_CONFIG_FINGERPRINT_FILENAME = "extension-product-config.sha256";
+function extensionProductConfigFingerprint(target, environment = process.env) {
+  const resolution = productConfig.resolveExtensionInfuraProjectId(target, environment);
+  if (resolution.kind !== "configured") return null;
+  return createHash("sha256").update(resolution.value).digest("hex");
+}
+function extensionCompiledScriptsMatchProductConfig(target, dist, environment = process.env) {
+  const resolution = productConfig.resolveExtensionInfuraProjectId(target, environment);
+  if (resolution.kind !== "configured") return true;
+  const pending = [dist];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || !fs.existsSync(current)) continue;
+    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(resolution.value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function extensionProductConfigBlock(target) {
   const resolution = productConfig.resolveExtensionInfuraProjectId(
     target,
@@ -55,5 +80,8 @@ function invalidConfigBlock(target, name, reason) {
   };
 }
 export {
-  extensionProductConfigBlock
+  EXTENSION_PRODUCT_CONFIG_FINGERPRINT_FILENAME,
+  extensionCompiledScriptsMatchProductConfig,
+  extensionProductConfigBlock,
+  extensionProductConfigFingerprint
 };

package/dist/adapters/extension/runtime.js

@@ -153,12 +153,26 @@ async function checkExtensionRuntimeHealth(projectRoot, cdpPort, options = {}) {
     if (runtime.backgroundUnresponsive === true) {
       findings.push("Extension UI reports background connection unresponsive.");
     }
+    if (runtime.ethereumConnectionUnavailable === true) {
+      findings.push('Extension UI reports "Unable to connect to Ethereum".');
+    }
+    if (runtime.evmRpcProbeOk !== true) {
+      const probeError = String(runtime.evmRpcProbeError ?? "unknown error").replace(/[.\s]+$/u, "");
+      findings.push(
+        `EVM RPC readiness probe failed: ${probeError}. Infura configured \u2260 RPC reachable.`
+      );
+    }
     if (runtime.hasSubmitRequest === true && runtime.backgroundProbeOk !== true) {
       warnings.push(`Perps background read probe failed: ${runtime.backgroundProbeError ?? "unknown error"}.`);
     }
     const extensionId = safeExtensionId(target);
+    const evmRpcUnreachable = runtime.ethereumConnectionUnavailable === true || runtime.evmRpcProbeOk !== true;
     return {
       status: findings.length === 0 ? "PASS" : "FAIL",
+      ...evmRpcUnreachable ? {
+        errorCode: "EVM_RPC_UNREACHABLE",
+        userAction: evmRpcRecoveryAction(projectRoot)
+      } : {},
       warnings,
       cdpPort,
       targetUrl: target.url,
@@ -219,21 +233,42 @@ async function evaluateHealth(session, timeoutMs) {
       const storeState = hooks.store?.getState?.() || {};
       const manager = hooks.getPerpsStreamManager?.();
       const accountCache = manager?.account?.cache;
+      const networkConnectionBanner = storeState.metamask?.networkConnectionBanner;
+      const networkClientId = storeState.metamask?.selectedNetworkClientId || networkConnectionBanner?.networkClientId;
       return Promise.race([
         (async () => {
-          let backgroundProbeOk = false;
-          let backgroundProbeError = null;
-          if (typeof hooks.submitRequestToBackground === 'function') {
-            try {
-              const accountState = await hooks.submitRequestToBackground('perpsGetAccountState', []);
-              backgroundProbeOk = Boolean(accountState && typeof accountState === 'object');
-              if (!backgroundProbeOk) backgroundProbeError = 'perpsGetAccountState returned an empty result';
-            } catch (error) {
-              backgroundProbeError = String(error?.message || error);
-            }
-          } else {
-            backgroundProbeError = 'submitRequestToBackground is not a function';
-          }
+          const [backgroundProbe, evmRpcProbe] = await Promise.all([
+            (async () => {
+              if (typeof hooks.submitRequestToBackground !== 'function') {
+                return { ok: false, error: 'submitRequestToBackground is not a function' };
+              }
+              try {
+                const accountState = await hooks.submitRequestToBackground('perpsGetAccountState', []);
+                const ok = Boolean(accountState && typeof accountState === 'object');
+                return { ok, error: ok ? null : 'perpsGetAccountState returned an empty result' };
+              } catch (error) {
+                return { ok: false, error: String(error?.message || error) };
+              }
+            })(),
+            (async () => {
+              if (typeof hooks.submitRequestToBackground !== 'function') {
+                return { ok: false, error: 'submitRequestToBackground is not a function' };
+              }
+              if (typeof networkClientId !== 'string' || networkClientId.length === 0) {
+                return { ok: false, error: 'selected EVM network client is unavailable' };
+              }
+              try {
+                const code = await hooks.submitRequestToBackground('getCode', [
+                  '0x0000000000000000000000000000000000000000',
+                  networkClientId,
+                ]);
+                const ok = typeof code === 'string' && code.startsWith('0x');
+                return { ok, error: ok ? null : 'background EVM RPC returned an invalid result' };
+              } catch (error) {
+                return { ok: false, error: String(error?.message || error) };
+              }
+            })(),
+          ]);
           return {
             href: location.href,
             title: document.title,
@@ -242,14 +277,17 @@ async function evaluateHealth(session, timeoutMs) {
             hasStore: Boolean(hooks.store),
             hasPerpsStreamManager: typeof hooks.getPerpsStreamManager === 'function',
             backgroundUnresponsive: bodyText.includes('Background connection unresponsive') || bodyText.includes('MetaMask had trouble starting'),
+            ethereumConnectionUnavailable: bodyText.includes('Unable to connect to Ethereum'),
             activeProvider: storeState.metamask?.activeProvider || null,
             isTestnet: Boolean(storeState.metamask?.isTestnet),
             perpsManagerInitialized: Boolean(manager?.isInitialized?.()),
             positionsCacheIsArray: Array.isArray(manager?.positions?.cache),
             ordersCacheIsArray: Array.isArray(manager?.orders?.cache),
             accountCachePresent: Boolean(accountCache && typeof accountCache === 'object'),
-            backgroundProbeOk,
-            backgroundProbeError,
+            backgroundProbeOk: backgroundProbe.ok,
+            backgroundProbeError: backgroundProbe.error,
+            evmRpcProbeOk: evmRpcProbe.ok,
+            evmRpcProbeError: evmRpcProbe.error,
           };
         })(),
         new Promise((resolve) => setTimeout(() => resolve({
@@ -260,8 +298,11 @@ async function evaluateHealth(session, timeoutMs) {
           hasStore: Boolean(hooks.store),
           hasPerpsStreamManager: typeof hooks.getPerpsStreamManager === 'function',
           backgroundUnresponsive: bodyText.includes('Background connection unresponsive') || bodyText.includes('MetaMask had trouble starting'),
+          ethereumConnectionUnavailable: bodyText.includes('Unable to connect to Ethereum'),
           backgroundProbeOk: false,
           backgroundProbeError: 'perpsGetAccountState timed out after ${backgroundProbeTimeoutMs}ms',
+          evmRpcProbeOk: false,
+          evmRpcProbeError: 'background EVM RPC timed out after ${backgroundProbeTimeoutMs}ms',
         }), ${backgroundProbeTimeoutMs})),
       ]);
     })()`,
@@ -293,6 +334,9 @@ function compositorRecoveryAction(projectRoot) {
   const recovery = `mm-harness launch --verify --target ${JSON.stringify(projectRoot)}`;
   return process.platform === "darwin" ? `Unlock the macOS session, then rerun: ${recovery}` : `Restore an active display compositor, then rerun: ${recovery}`;
 }
+function evmRpcRecoveryAction(projectRoot) {
+  return `Confirm ${shellQuote(path.join(projectRoot, ".metamaskrc"))} has a real INFURA_PROJECT_ID (not 00000000000), then rerun: mm-harness launch --verify --target ${shellQuote(projectRoot)}`;
+}
 function resolveCdpPort(rawPort, slot) {
   const raw = rawPort ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT ?? slot?.cdpPort;
   const port = Number(raw);
@@ -759,6 +803,7 @@ export {
   assertHealthyExtensionRuntime,
   checkExtensionRuntimeHealth,
   compositorRecoveryAction,
+  evmRpcRecoveryAction,
   extensionBackgroundProbeTimeoutMs,
   formatHealthFailure,
   prepareExtensionRuntime

package/dist/adapters/extension/surface.js

@@ -14,6 +14,10 @@ function watcherStatus(buildLog) {
   if (buildLog === "no-watch") return "down";
   return buildLog;
 }
+function extensionRuntimeNextAction(reasonCode, target) {
+  const resolved = shellQuote(path.resolve(target));
+  return reasonCode === "deps-missing" || reasonCode === "deps-stale" ? `cd ${resolved} && yarn install --immutable` : `mm-harness launch --adapter extension --target ${resolved}`;
+}
 const extensionSurface = {
   adapter: "extension",
   headless: false,
@@ -42,7 +46,7 @@ const extensionSurface = {
       decision: report.decision,
       reasonCode: report.reasonCode,
       reasons: report.reasons,
-      nextAction: report.decision === "ready" ? void 0 : `mm-harness launch --adapter extension --target ${shellQuote(path.resolve(target))}`,
+      nextAction: report.decision === "ready" ? void 0 : extensionRuntimeNextAction(report.reasonCode, target),
       deps: report.checks.deps.status,
       devServer: {
         label: "webpack",
@@ -96,5 +100,6 @@ const extensionSurface = {
   }
 };
 export {
+  extensionRuntimeNextAction,
   extensionSurface
 };

package/dist/adapters/mobile/surface.js

@@ -5,6 +5,10 @@ import { shellQuote } from "../../commands/parse-args.js";
 import { resolveMobileSlotPorts } from "../slot-ports.js";
 import { mobileRuntimeStatus } from "./prepare.js";
 import { hasRunwayProvisionBaseline, provisionRunwayMobile } from "./provision.js";
+function mobileRuntimeNextAction(reasonCode, target, platform) {
+  const resolved = shellQuote(path.resolve(target));
+  return reasonCode === "deps-missing" || reasonCode === "deps-partial" || reasonCode === "deps-stale" ? `cd ${resolved} && yarn setup` : `mm-harness launch ${platform} --adapter mobile --target ${resolved}`;
+}
 const mobileSurface = {
   adapter: "mobile",
   headless: false,
@@ -21,7 +25,7 @@ const mobileSurface = {
       decision: depsPending ? "launch" : report.decision,
       reasonCode: depsPending ? "app-installed-deps-pending" : report.reasonCode,
       reasons: depsPending ? ["Runway app is installed; JavaScript dependencies are pending until dispatch-time launch."] : report.reasons,
-      nextAction: report.decision === "ready" && !depsPending ? void 0 : `mm-harness launch ${platform} --adapter mobile --target ${shellQuote(path.resolve(target))}`,
+      nextAction: report.decision === "ready" && !depsPending ? void 0 : mobileRuntimeNextAction(report.reasonCode, target, platform),
       deps: runwayProvisioned && report.checks?.deps?.status !== "current" ? "pending" : report.checks?.deps?.status,
       devServer: { label: "metro", status: report.checks?.metro?.status ?? "unprobed" }
     };
@@ -58,5 +62,6 @@ const mobileSurface = {
   }
 };
 export {
+  mobileRuntimeNextAction,
   mobileSurface
 };

package/dist/adapters.js

@@ -9,6 +9,7 @@ import { withExtensionPage } from "../library/actions/extension/platform/cdp.mjs
 import { bridgeCommand, evalAsync, evalSync, MOBILE_BRIDGE_ERROR_CODES, selectBridgeStatusEntry, simulatorScreenshot } from "../library/actions/mobile/platform/bridge.mjs";
 import { observeNativeUi } from "../library/actions/mobile/platform/observe-ui.mjs";
 import { resolveMobileToolPath } from "../library/actions/mobile/platform/tool-paths.mjs";
+import { resolveWalletImportCredentials, validateWalletImportOptions } from "../library/actions/shared/wallet/import-source.mjs";
 const execFileAsync = promisify(execFile);
 const NATIVE_PROVIDER_UI_ACTIONS = /* @__PURE__ */ new Set([
   "ui.swipe",
@@ -51,6 +52,8 @@ const CORE_ONLY_PERPS_ACTIONS = /* @__PURE__ */ new Set([
 ]);
 const LIVE_ONLY_WALLET_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.wallet.setup",
+  "metamask.wallet.import",
+  "metamask.wallet.reset",
   "metamask.wallet.ensure_unlocked",
   "metamask.wallet.select_account",
   "metamask.wallet.list_accounts",
@@ -110,6 +113,18 @@ async function semanticResult(platform, action, node, context, forceLive = false
   }
   const output = { platform, action, redacted: true };
   if (action === "metamask.wallet.fixture_status") return { output: fixtureSummary(context.projectRoot) };
+  if (action === "metamask.wallet.validate_import") {
+    validateWalletImportOptions(platform, node);
+    const credentials = await resolveWalletImportCredentials({ node, context });
+    return {
+      output: {
+        ...output,
+        credentialSource: credentials.source,
+        credentialSourceName: credentials.sourceName,
+        expectedAddress: credentials.expectedAddress
+      }
+    };
+  }
   return {
     output: {
       ...output,
@@ -183,7 +198,10 @@ function probeHttpJson(url, timeoutMs = 1e3) {
 function createMetaMaskSemanticAdapters(platform, declaredCustomActions = [], preparedLiveAdapters) {
   const walletActions = [
     "metamask.wallet.fixture_status",
+    "metamask.wallet.validate_import",
     "metamask.wallet.setup",
+    "metamask.wallet.import",
+    "metamask.wallet.reset",
     "metamask.wallet.ensure_unlocked",
     "metamask.wallet.select_account",
     "metamask.wallet.list_accounts",

package/dist/cli-commands.js

@@ -15,7 +15,7 @@ const SPEC = {
     { name: "sync", desc: "Refresh harness + canonicalize wallet fixture", flags: ["--json"] },
     { name: "logs", aliases: ["tail"], desc: "Compact build events or full log", flags: ["--full", "-f", "--window", "--events", "--source", "--json"] },
     { name: "debug", aliases: ["devtools", "inspect"], desc: "Open DevTools UI", flags: ["--json", "--no-open"] },
-    { name: "fixtures", desc: "Manage the canonical wallet fixture (sync/set/generate)", args: ["sync", "set", "generate"], flags: ["--fixture", "--out", "--adapter", "--target", "--device", "--json"] },
+    { name: "fixtures", desc: "Manage the canonical wallet fixture (sync/set/reset/generate)", args: ["sync", "set", "reset", "generate"], flags: ["--fixture", "--out", "--adapter", "--target", "--device", "--json"] },
     { name: "actions", desc: "List runnable recipe actions", flags: ["--json", "--matrix", "--categories", "--category", "--action", "--library"] },
     { name: "doctor", desc: "Check harness/orchestration health", flags: ["--json", "--target", "--adapter", "--runtime-dir", "--expect-live", "--print-ready", "--cdp-port", "--device"] },
     { name: "run", desc: "Execute a proof recipe (path or library name, e.g. run perps.smoke)", args: ["recipe.json|name"], flags: ["--list", "--device"] },

package/dist/cli.js

@@ -47,8 +47,8 @@ DAILY LOOP \u2014 what a teammate runs many times a day:
                mm-harness logs
   debug      Open the debug console (extension DevTools / mobile RN).
                mm-harness debug
-  fixtures   Sync files + set the wallet + generate fixture-state + finalize labels over CDP.
-               mm-harness fixtures sync                 # or: set | generate --fixture <f> --out <o> | finalize \u2026
+  fixtures   Sync files, set/reset the wallet, generate fixture-state, or finalize labels over CDP.
+               mm-harness fixtures sync                 # or: set | reset | generate --fixture <f> --out <o> | finalize \u2026
 
 PROVE \u2014 run recipes and inspect capabilities:
   run        Run a recipe and write evidence (summary/trace/artifacts).

package/dist/command-contract.js

@@ -270,7 +270,7 @@ const PUBLIC_COMMAND_CONTRACTS = {
       "--extension-id-file": value(),
       "--action-manifest": value()
     }),
-    positionals: [{ label: "action", choices: ["init", "sync", "set", "generate", "finalize"] }],
+    positionals: [{ label: "action", choices: ["init", "sync", "set", "reset", "generate", "finalize"] }],
     minimumPositionals: 0
   }
 };

package/dist/commands/device-target.js

@@ -256,6 +256,11 @@ ${formatConnectedDevices(connected)}
       userAction: deviceRecovery(options, opts.rerun)
     };
   }
+  if (targetable.length === 1) {
+    const selected = targetable[0];
+    if (selected.platform === "android") setAndroidDeviceEnv(selected.id, selected.name);
+    else setIosDeviceEnv(selected.id, selected.name);
+  }
   return { ok: true };
 }
 function scopedDevices(devices, allDevices = false) {