@deeeed/metamask-harness 0.34.0 → 0.34.2

package/adapters/mobile/open-device.sh

@@ -90,19 +90,29 @@ ios_app_installed() {
 }
 
 run_ios_native_build() (
-  local sim_target="$1" reason="$2" build_env=""
-  printf '%s; installing with yarn start:ios (WATCHER_PORT=%s)\n' "$reason" "$PORT" >&2
+  local sim_target="$1" bundle_id="$2" reason="$3" build_env="" build_script="" build_type=""
+  case "$bundle_id" in
+    io.metamask.MetaMask|io.metamask) build_script="start:ios"; build_type="main" ;;
+    io.metamask.MetaMask-Flask) build_script="start:ios:flask"; build_type="flask" ;;
+    *)
+      printf 'open-device: no supported local build script for iOS bundle %s\n' "$bundle_id" >&2
+      return 1
+      ;;
+  esac
+  printf '%s; installing with yarn %s (WATCHER_PORT=%s)\n' "$reason" "$build_script" "$PORT" >&2
   build_env="$(mktemp "${TMPDIR:-/tmp}/mm-harness-ios-build-env.XXXXXX")" || return 1
   chmod 600 "$build_env" || { rm -f "$build_env"; return 1; }
   trap 'rm -f "$build_env"' EXIT HUP INT TERM
   {
     printf 'export MM_HARNESS_BUILD_WATCHER_PORT=%q\n' "$PORT"
     printf 'export MM_HARNESS_BUILD_IOS_SIMULATOR=%q\n' "$sim_target"
+    printf 'export MM_HARNESS_BUILD_TYPE=%q\n' "$build_type"
     cat <<'BUILD_ENV'
 mm_harness_restore_build_target() {
   export WATCHER_PORT="$MM_HARNESS_BUILD_WATCHER_PORT"
   export METRO_PORT="$MM_HARNESS_BUILD_WATCHER_PORT"
   export IOS_SIMULATOR="$MM_HARNESS_BUILD_IOS_SIMULATOR"
+  export METAMASK_BUILD_TYPE="$MM_HARNESS_BUILD_TYPE"
 }
 eval() {
   builtin eval "$@"
@@ -122,7 +132,7 @@ BUILD_ENV
   (
     cd "$TARGET"
     command -v activate_repo_ruby_best_effort >/dev/null 2>&1 && activate_repo_ruby_best_effort "$TARGET"
-    BASH_ENV="$build_env" WATCHER_PORT="$PORT" METRO_PORT="$PORT" IOS_SIMULATOR="$sim_target" EXPO_NO_TYPESCRIPT_SETUP=1 yarn start:ios 2>&1
+    BASH_ENV="$build_env" WATCHER_PORT="$PORT" METRO_PORT="$PORT" IOS_SIMULATOR="$sim_target" METAMASK_BUILD_TYPE="$build_type" EXPO_NO_TYPESCRIPT_SETUP=1 yarn "$build_script" 2>&1
   )
 )
 
@@ -138,10 +148,16 @@ ensure_ios_app_for_mode() {
       ;;
     auto|default)
       if ios_app_installed "$sim_target" "$bundle_id"; then return 0; fi
-      run_ios_native_build "$sim_target" "iOS dev client ${bundle_id} not installed on ${sim_target}"
+      if ! run_ios_native_build "$sim_target" "$bundle_id" "iOS dev client ${bundle_id} not installed on ${sim_target}"; then
+        printf 'open-device: iOS native build failed\n' >&2
+        return 1
+      fi
       ;;
     rebuild-native|clean)
-      run_ios_native_build "$sim_target" "Rebuilding iOS dev client ${bundle_id} (--preflight-mode ${mode})"
+      if ! run_ios_native_build "$sim_target" "$bundle_id" "Rebuilding iOS dev client ${bundle_id} (--preflight-mode ${mode})"; then
+        printf 'open-device: iOS native build failed\n' >&2
+        return 1
+      fi
       ;;
     *)
       printf 'open-device: unknown --preflight-mode: %s\n' "$mode" >&2; return 2 ;;
@@ -264,14 +280,113 @@ android_app_installed() {
   "$ADB_BIN" "$@" shell pm list packages 2>/dev/null | grep -q "package:${pkg}"
 }
 
-run_android_native_build() {
-  local reason="$1"
-  printf '%s; installing with yarn start:android (WATCHER_PORT=%s)\n' "$reason" "$PORT" >&2
-  (cd "$TARGET" && WATCHER_PORT="$PORT" yarn start:android 2>&1)
+run_android_native_build() (
+  local serial="$1" expo_device="$2" pkg="$3" reason="$4" build_env="" build_script=""
+  case "$pkg" in
+    io.metamask) build_script="start:android" ;;
+    io.metamask.flask) build_script="start:android:flask" ;;
+    *)
+      printf 'open-device: no supported local build script for Android package %s\n' "$pkg" >&2
+      return 1
+      ;;
+  esac
+  printf '%s; installing with yarn %s (WATCHER_PORT=%s)\n' "$reason" "$build_script" "$PORT" >&2
+  build_env="$(mktemp "${TMPDIR:-/tmp}/mm-harness-android-build-env.XXXXXX")" || return 1
+  chmod 600 "$build_env" || { rm -f "$build_env"; return 1; }
+  trap 'rm -f "$build_env"' EXIT HUP INT TERM
+  {
+    printf 'export MM_HARNESS_BUILD_ANDROID_SERIAL=%q\n' "$serial"
+    printf 'export MM_HARNESS_BUILD_ANDROID_EXPO_DEVICE=%q\n' "$expo_device"
+    printf 'export MM_HARNESS_BUILD_WATCHER_PORT=%q\n' "$PORT"
+    cat <<'BUILD_ENV'
+mm_harness_restore_android_build_target() {
+  export WATCHER_PORT="$MM_HARNESS_BUILD_WATCHER_PORT"
+  export METRO_PORT="$MM_HARNESS_BUILD_WATCHER_PORT"
+  export ADB_SERIAL="$MM_HARNESS_BUILD_ANDROID_SERIAL"
+  export ANDROID_SERIAL="$MM_HARNESS_BUILD_ANDROID_SERIAL"
+}
+eval() {
+  builtin eval "$@"
+  local status=$?
+  mm_harness_restore_android_build_target
+  return "$status"
+}
+source() {
+  builtin source "$@"
+  local status=$?
+  mm_harness_restore_android_build_target
+  return "$status"
+}
+yarn() {
+  if [ "${1:-}" = expo ] && [ "${2:-}" = run:android ]; then
+    command yarn "$@" "$MM_HARNESS_BUILD_ANDROID_EXPO_DEVICE"
+  else
+    command yarn "$@"
+  fi
+}
+mm_harness_restore_android_build_target
+BUILD_ENV
+  } > "$build_env"
+  (
+    cd "$TARGET"
+    BASH_ENV="$build_env" \
+      WATCHER_PORT="$PORT" METRO_PORT="$PORT" \
+      ADB_SERIAL="$serial" ANDROID_SERIAL="$serial" \
+      EXPO_NO_TYPESCRIPT_SETUP=1 yarn "$build_script" 2>&1
+  )
+)
+
+resolve_android_expo_device() {
+  local serial="$1" rows="" selected_line="" expo_device="" row_serial="" row_state="" row_name="" matches=0
+  [ -n "$serial" ] || return 0
+  rows="$($ADB_BIN devices -l 2>/dev/null || true)"
+  selected_line="$(printf '%s\n' "$rows" | awk -v wanted="$serial" '$1 == wanted { print; exit }')"
+  if [ -z "$selected_line" ]; then
+    printf 'open-device: configured Android device %s is not attached\n' "$serial" >&2
+    return 1
+  fi
+  row_state="$(printf '%s\n' "$selected_line" | awk '{print $2}')"
+  if [ "$row_state" != "device" ]; then
+    printf 'open-device: configured Android device %s is not ready (state: %s)\n' "$serial" "$row_state" >&2
+    return 1
+  fi
+  if printf '%s' "$serial" | grep -q '^emulator-'; then
+    expo_device="$($ADB_BIN -s "$serial" emu avd name 2>/dev/null | tr -d '\r' | sed '/^OK$/d' | head -1 || true)"
+  else
+    expo_device="$(printf '%s\n' "$selected_line" | awk '{ for (i = 3; i <= NF; i += 1) if ($i ~ /^model:/) { sub(/^model:/, "", $i); print $i; exit } }')"
+  fi
+  [ -n "$expo_device" ] || expo_device="${ANDROID_TARGET_DEVICE_NAME:-}"
+  expo_device="${expo_device// /_}"
+  if [ -z "$expo_device" ]; then
+    printf 'open-device: could not resolve Expo device name for Android serial %s\n' "$serial" >&2
+    return 1
+  fi
+
+  while IFS= read -r selected_line; do
+    row_serial="$(printf '%s\n' "$selected_line" | awk '{print $1}')"
+    row_state="$(printf '%s\n' "$selected_line" | awk '{print $2}')"
+    [ "$row_state" = "device" ] || continue
+    if printf '%s' "$row_serial" | grep -q '^emulator-'; then
+      row_name="$($ADB_BIN -s "$row_serial" emu avd name 2>/dev/null | tr -d '\r' | sed '/^OK$/d' | head -1 || true)"
+    else
+      row_name="$(printf '%s\n' "$selected_line" | awk '{ for (i = 3; i <= NF; i += 1) if ($i ~ /^model:/) { sub(/^model:/, "", $i); print $i; exit } }')"
+    fi
+    row_name="${row_name// /_}"
+    [ "$row_name" = "$expo_device" ] && matches=$((matches + 1))
+  done <<EOF
+$rows
+EOF
+  if [ "$matches" -ne 1 ]; then
+    printf 'open-device: Expo device name %s is ambiguous across %s attached Android devices; Expo cannot select serial %s safely\n' \
+      "$expo_device" "$matches" "$serial" >&2
+    return 1
+  fi
+  printf '%s\n' "$expo_device"
 }
 
 ensure_android_app_for_mode() {
   local pkg="$1" mode="$2"
+  local expo_device=""
   shift 2
   case "$mode" in
     fast)
@@ -281,10 +396,26 @@ ensure_android_app_for_mode() {
       ;;
     auto|default)
       if android_app_installed "$pkg" "$@"; then return 0; fi
-      run_android_native_build "Android dev client ${pkg} not installed"
+      if [ -n "$ADB_SERIAL_ARG" ]; then
+        expo_device="$(resolve_android_expo_device "$ADB_SERIAL_ARG")" || return 1
+      fi
+      [ -n "$expo_device" ] || expo_device="${ANDROID_TARGET_DEVICE_NAME:-}"
+      expo_device="${expo_device// /_}"
+      if ! run_android_native_build "$ADB_SERIAL_ARG" "$expo_device" "$pkg" "Android dev client ${pkg} not installed"; then
+        printf 'open-device: Android native build failed\n' >&2
+        return 1
+      fi
       ;;
     rebuild-native|clean)
-      run_android_native_build "Rebuilding Android dev client ${pkg} (--preflight-mode ${mode})"
+      if [ -n "$ADB_SERIAL_ARG" ]; then
+        expo_device="$(resolve_android_expo_device "$ADB_SERIAL_ARG")" || return 1
+      fi
+      [ -n "$expo_device" ] || expo_device="${ANDROID_TARGET_DEVICE_NAME:-}"
+      expo_device="${expo_device// /_}"
+      if ! run_android_native_build "$ADB_SERIAL_ARG" "$expo_device" "$pkg" "Rebuilding Android dev client ${pkg} (--preflight-mode ${mode})"; then
+        printf 'open-device: Android native build failed\n' >&2
+        return 1
+      fi
       ;;
     *)
       printf 'open-device: unknown --preflight-mode: %s\n' "$mode" >&2; return 2 ;;
@@ -301,8 +432,16 @@ PY
 
 # --- dispatch -----------------------------------------------------------------
 
-BUNDLE_IDS=("${IOS_BUNDLE_ID:-io.metamask.MetaMask}" "io.metamask" "io.metamask.flask" "io.metamask.qa")
-ANDROID_PKGS=("${ANDROID_PACKAGE_ID:-io.metamask}" "io.metamask.flask" "io.metamask.qa")
+if [ -n "${IOS_BUNDLE_ID:-}" ]; then
+  BUNDLE_IDS=("$IOS_BUNDLE_ID")
+else
+  BUNDLE_IDS=("io.metamask.MetaMask" "io.metamask" "io.metamask.MetaMask-Flask" "io.metamask.qa")
+fi
+if [ -n "${ANDROID_PACKAGE_ID:-}" ]; then
+  ANDROID_PKGS=("$ANDROID_PACKAGE_ID")
+else
+  ANDROID_PKGS=("io.metamask" "io.metamask.flask" "io.metamask.qa")
+fi
 
 if [ "$PLATFORM" = "ios" ]; then
   SIM_TARGET="$(sim_udid_for_target "$SIMULATOR")"
@@ -330,7 +469,12 @@ if [ "$PLATFORM" = "ios" ]; then
 
   LAUNCHED=false
   for BUNDLE_ID in "${BUNDLE_IDS[@]}"; do
-    ensure_ios_app_for_mode "$SIM_TARGET" "$BUNDLE_ID" "$PREFLIGHT_MODE" || continue
+    if ! ensure_ios_app_for_mode "$SIM_TARGET" "$BUNDLE_ID" "$PREFLIGHT_MODE"; then
+      case "$PREFLIGHT_MODE" in
+        fast) continue ;;
+        *) exit 1 ;;
+      esac
+    fi
     if $RESTART; then
       xcrun simctl terminate "$SIM_TARGET" "$BUNDLE_ID" >/dev/null 2>&1 || true
       printf 'Restarting iOS dev client %s on %s\n' "$BUNDLE_ID" "$SIM_TARGET" >&2
@@ -378,18 +522,25 @@ else
   ADB_ARGS=()
   [ -n "$ADB_SERIAL_ARG" ] && ADB_ARGS+=("-s" "$ADB_SERIAL_ARG")
 
-  # Reverse-tunnel Metro port so the device can reach localhost:PORT.
-  "$ADB_BIN" "${ADB_ARGS[@]}" reverse "tcp:${PORT}" "tcp:${PORT}" >/dev/null 2>&1 || \
-    printf 'open-device: adb reverse failed (non-fatal — device may already be reachable)\n' >&2
-
   LAUNCHED=false
   for PKG in "${ANDROID_PKGS[@]}"; do
-    ensure_android_app_for_mode "$PKG" "$PREFLIGHT_MODE" "${ADB_ARGS[@]}" || continue
+    if ! ensure_android_app_for_mode "$PKG" "$PREFLIGHT_MODE" "${ADB_ARGS[@]}"; then
+      case "$PREFLIGHT_MODE" in
+        fast) continue ;;
+        *) exit 1 ;;
+      esac
+    fi
     if $RESTART; then
       "$ADB_BIN" "${ADB_ARGS[@]}" shell am force-stop "$PKG" >/dev/null 2>&1 || true
       printf 'Restarting Android dev client %s\n' "$PKG" >&2
     fi
 
+    # Installing/rebuilding a dev client can invalidate adb reverse mappings.
+    # Restore Metro reachability only after the app is ensured, immediately
+    # before opening the development-client URL.
+    "$ADB_BIN" "${ADB_ARGS[@]}" reverse "tcp:${PORT}" "tcp:${PORT}" >/dev/null 2>&1 || \
+      printf 'open-device: adb reverse failed (non-fatal — device may already be reachable)\n' >&2
+
     ENCODED_URL="$(urlencode "http://localhost:${PORT}?disableOnboarding=1" 2>/dev/null \
       || printf 'http%%3A%%2F%%2Flocalhost%%3A%s%%3FdisableOnboarding%%3D1' "$PORT")"
     DEEP_LINK="expo-metamask://expo-development-client/?url=${ENCODED_URL}"

package/adapters/mobile/start-metro.sh

@@ -2,9 +2,10 @@
 # start-metro — ensure the Metro bundler is running for this MetaMask Mobile checkout.
 #
 # Checks if Metro is already running and owned by this checkout with required env vars.
-# Clears stale or foreign listeners before starting. Uses yarn expo start --port (not
-# yarn start), sources .js.env/.env/.env.local, sets EXPO_NO_TYPESCRIPT_SETUP=1, and
-# caps METRO_MAX_WORKERS to 6 (or the physical CPU count).
+# Clears stale or foreign listeners before starting. Uses the checkout's canonical
+# yarn watch script and sets EXPO_NO_TYPESCRIPT_SETUP=1. Cache clearing is
+# injected as Expo --clear without invoking Mobile's global watchman cleanup.
+# Metro owns its default worker count; METRO_MAX_WORKERS is an explicit override.
 #
 # Inputs:
 #   --target <metamask-mobile dir>  (default $PWD)
@@ -49,7 +50,7 @@ fi
 # only ever inspect or signal a Metro listening on $PORT.
 # shellcheck disable=SC1091
 . "$SCRIPT_DIR/lib/metro-listener.sh"
-MOBILE_METRO_REQUIRED_ENV="${MOBILE_METRO_REQUIRED_ENV:-MM_INFURA_PROJECT_ID} MM_HARNESS_METRO_PROJECT_ROOT EXPO_OVERRIDE_METRO_CONFIG"
+MOBILE_METRO_REQUIRED_ENV="${MOBILE_METRO_REQUIRED_ENV:-MM_INFURA_PROJECT_ID METAMASK_BUILD_TYPE METAMASK_ENVIRONMENT}"
 
 # RECIPE_RUNTIME_DIR (relative, validated) makes runtime state per-run so jobs
 # sharing one checkout do not collide on metro.log / metro.pid / metro.tmux.
@@ -57,39 +58,90 @@ LOG_DIR="$TARGET/$(recipe_runtime_dir)" || exit 1
 mkdir -p "$LOG_DIR"
 LOG_FILE="$LOG_DIR/metro.log"
 PID_FILE="$LOG_DIR/metro.pid"
-INLINE_ENV_FILE="$LOG_DIR/metro-inline-env.sh"
+METRO_BUILD_ENV_FILE="$LOG_DIR/metro-build-env.sh"
 
 # --- helpers ------------------------------------------------------------------
 
-default_metro_workers() {
-  local cores=""
-  if command -v sysctl >/dev/null 2>&1; then
-    cores="$(sysctl -n hw.perflevel0.physicalcpu 2>/dev/null || sysctl -n hw.physicalcpu 2>/dev/null || true)"
-  fi
-  if printf '%s' "${cores:-}" | grep -Eq '^[0-9]+$' && [ "${cores:-0}" -gt 0 ]; then
-    [ "${cores:-4}" -gt 6 ] && cores=6
-    printf '%s\n' "$cores"
+write_metro_build_env() {
+  local temporary name staged_name product_values build_type environment sentry_dsn clear_value=0
+  for name in $MOBILE_METRO_REQUIRED_ENV; do
+    if ! printf '%s' "$name" | grep -Eq '^[A-Za-z_][A-Za-z0-9_]*$'; then
+      printf 'start-metro: invalid required environment variable name: %s\n' "$name" >&2
+      return 1
+    fi
+  done
+  temporary="$(mktemp "$LOG_DIR/.metro-build-env.XXXXXX")" || return 1
+  chmod 600 "$temporary" || { rm -f "$temporary"; return 1; }
+  product_values="$(
+    cd "$TARGET" || exit 1
+    set -a
+    # shellcheck disable=SC1091
+    [ ! -f .js.env ] || eval "$(tr -d '\r' < .js.env)"
+    set +a
+    METAMASK_BUILD_TYPE="${METAMASK_BUILD_TYPE:-main}"
+    METAMASK_ENVIRONMENT="${METAMASK_ENVIRONMENT:-dev}"
+    printf 'build_type=%q\n' "$METAMASK_BUILD_TYPE"
+    printf 'environment=%q\n' "$METAMASK_ENVIRONMENT"
+    printf 'sentry_dsn=%q\n' "${MM_SENTRY_DSN:-${MM_SENTRY_DSN_DEV:-}}"
+    for name in $MOBILE_METRO_REQUIRED_ENV; do
+      printf 'required_%s=%q\n' "$name" "${!name-}"
+    done
+  )" || { rm -f "$temporary"; return 1; }
+  eval "$product_values"
+  [ "$CLEAR" = true ] && clear_value=1
+  {
+    printf 'export MM_HARNESS_METRO_WATCHER_PORT=%q\n' "$PORT"
+    printf 'export MM_HARNESS_METRO_BUILD_TYPE=%q\n' "$build_type"
+    printf 'export MM_HARNESS_METRO_ENVIRONMENT=%q\n' "$environment"
+    printf 'export MM_HARNESS_METRO_SENTRY_DSN=%q\n' "$sentry_dsn"
+    printf 'export MM_HARNESS_METRO_CLEAR=%q\n' "$clear_value"
+    cat <<'BUILD_ENV'
+mm_harness_restore_metro_env() {
+  export WATCHER_PORT="$MM_HARNESS_METRO_WATCHER_PORT"
+  export METRO_PORT="$MM_HARNESS_METRO_WATCHER_PORT"
+  export METAMASK_BUILD_TYPE="$MM_HARNESS_METRO_BUILD_TYPE"
+  export METAMASK_ENVIRONMENT="$MM_HARNESS_METRO_ENVIRONMENT"
+  export MM_SENTRY_DSN="$MM_HARNESS_METRO_SENTRY_DSN"
+BUILD_ENV
+    for name in $MOBILE_METRO_REQUIRED_ENV; do
+      staged_name="required_$name"
+      printf '  export %s=%q\n' "$name" "${!staged_name}"
+    done
+    for name in \
+      SEGMENT_PROXY_URL \
+      SEGMENT_WRITE_KEY \
+      SEGMENT_FLUSH_INTERVAL \
+      SEGMENT_FLUSH_EVENT_LIMIT
+    do
+      if declare -p "$name" >/dev/null 2>&1; then
+        printf '  export %s=%q\n' "$name" "${!name}"
+      fi
+    done
+    cat <<'BUILD_ENV'
+}
+eval() {
+  builtin eval "$@"
+  local status=$?
+  mm_harness_restore_metro_env
+  return "$status"
+}
+source() {
+  builtin source "$@"
+  local status=$?
+  mm_harness_restore_metro_env
+  return "$status"
+}
+yarn() {
+  if [ "$MM_HARNESS_METRO_CLEAR" = 1 ] && [ "${1:-}" = expo ] && [ "${2:-}" = start ]; then
+    command yarn "$@" --clear
   else
-    printf '4\n'
+    command yarn "$@"
   fi
 }
-
-write_inline_metro_env() {
-  local temporary name
-  temporary="$(mktemp "$LOG_DIR/.metro-inline-env.XXXXXX")" || return 1
-  chmod 600 "$temporary" || { rm -f "$temporary"; return 1; }
-  for name in \
-    SEGMENT_PROXY_URL \
-    SEGMENT_WRITE_KEY \
-    SEGMENT_FLUSH_INTERVAL \
-    SEGMENT_FLUSH_EVENT_LIMIT
-  do
-    if declare -p "$name" >/dev/null 2>&1; then
-      printf 'export %s=%q\n' "$name" "${!name}" >> "$temporary" \
-        || { rm -f "$temporary"; return 1; }
-    fi
-  done
-  mv -f "$temporary" "$INLINE_ENV_FILE"
+mm_harness_restore_metro_env
+BUILD_ENV
+  } > "$temporary" || { rm -f "$temporary"; return 1; }
+  mv -f "$temporary" "$METRO_BUILD_ENV_FILE"
 }
 
 # Log-tail viewer window (session-safe): sourced so its run-owned-session rule is
@@ -99,37 +151,20 @@ write_inline_metro_env() {
 
 write_metro_runner() {
   local runner="$1"
-  local clear_flag=""
-  [ "$CLEAR" = true ] && clear_flag=' --clear'
+  local watcher_script="watch"
+  local worker_env_line='unset METRO_MAX_WORKERS'
+  if [ -n "$METRO_WORKERS" ]; then
+    worker_env_line="export METRO_MAX_WORKERS=$(printf '%q' "$METRO_WORKERS")"
+  fi
   cat > "$runner" <<EOF
 #!/usr/bin/env bash
 set -uo pipefail
 cd "$(printf '%q' "$TARGET")"
 : > "$(printf '%q' "$LOG_FILE")"
-set -a
-[ ! -f .js.env ]    || . ./.js.env
-[ ! -f .env ]       || . ./.env
-[ ! -f .env.local ] || . ./.env.local
-set +a
-[ -n "\${METAMASK_BUILD_TYPE:-}" ] || export METAMASK_BUILD_TYPE=main
-# build.sh remaps MM_SENTRY_DSN from MM_SENTRY_DSN_DEV for dev builds; quick-launch
-# bypasses it, so without this Sentry never initializes in the dev client.
-[ -n "\${MM_SENTRY_DSN:-}" ] || export MM_SENTRY_DSN="\${MM_SENTRY_DSN_DEV:-}"
-[ ! -f $(printf '%q' "$INLINE_ENV_FILE") ] || {
-  . $(printf '%q' "$INLINE_ENV_FILE")
-  rm -f $(printf '%q' "$INLINE_ENV_FILE")
-}
 export EXPO_NO_TYPESCRIPT_SETUP=1
 export WATCHER_PORT="$(printf '%q' "$PORT")" METRO_PORT="$(printf '%q' "$PORT")"
-export METRO_MAX_WORKERS="$(printf '%q' "$METRO_WORKERS")"
-export MM_HARNESS_METRO_PROJECT_ROOT="$(printf '%q' "$TARGET")"
-if [ -n "\${EXPO_OVERRIDE_METRO_CONFIG:-}" ]; then
-  export MM_HARNESS_METRO_BASE_CONFIG="\$EXPO_OVERRIDE_METRO_CONFIG"
-else
-  export MM_HARNESS_METRO_BASE_CONFIG=$(printf '%q' "$TARGET/metro.config.js")
-fi
-export EXPO_OVERRIDE_METRO_CONFIG="$(printf '%q' "$SCRIPT_DIR/metro-config.cjs")"
-yarn expo start --port "$(printf '%q' "$PORT")"$clear_flag 2>&1 | tee -a "$(printf '%q' "$LOG_FILE")"
+$worker_env_line
+BASH_ENV=$(printf '%q' "$METRO_BUILD_ENV_FILE") command yarn $(printf '%q' "$watcher_script") 2>&1 | tee -a "$(printf '%q' "$LOG_FILE")"
 EOF
   chmod +x "$runner"
 }
@@ -180,64 +215,61 @@ fi
 
 stop_metro_listener || exit 1
 
-METRO_WORKERS="${METRO_MAX_WORKERS:-$(default_metro_workers)}"
+METRO_WORKERS="${METRO_MAX_WORKERS:-}"
+if [ -n "$METRO_WORKERS" ] && ! printf '%s' "$METRO_WORKERS" | grep -Eq '^[1-9][0-9]*$'; then
+  printf 'start-metro: METRO_MAX_WORKERS must be a positive integer, got %s\n' "$METRO_WORKERS" >&2
+  exit 2
+fi
+READY_TIMEOUT="${MOBILE_METRO_READY_TIMEOUT_SECONDS:-180}"
+if ! printf '%s' "$READY_TIMEOUT" | grep -Eq '^[1-9][0-9]*$'; then
+  printf 'start-metro: MOBILE_METRO_READY_TIMEOUT_SECONDS must be a positive integer, got %s\n' "$READY_TIMEOUT" >&2
+  exit 2
+fi
 CLEAR_LABEL=""
 [ "$CLEAR" = true ] && CLEAR_LABEL=", clear"
 
-printf 'Starting Metro on port %s (workers=%s%s)\n' \
-  "$PORT" "$METRO_WORKERS" "$CLEAR_LABEL" >&2
+if [ -n "$METRO_WORKERS" ]; then
+  printf 'Starting Metro on port %s (workers=%s%s)\n' \
+    "$PORT" "$METRO_WORKERS" "$CLEAR_LABEL" >&2
+else
+  printf 'Starting Metro on port %s (workers=Metro default%s)\n' \
+    "$PORT" "$CLEAR_LABEL" >&2
+fi
 printf '(Full log: %s — mm-harness logs | mm-harness logs --full)\n' "$LOG_FILE" >&2
 
-write_inline_metro_env || {
-  printf 'start-metro: could not stage inline Metro environment\n' >&2
+write_metro_build_env || {
+  printf 'start-metro: could not stage the scoped Metro environment\n' >&2
   exit 1
 }
 
-if ! start_metro_tmux; then
+STARTED_METRO_PID=""
+STARTED_METRO_TMUX=""
+if start_metro_tmux; then
+  STARTED_METRO_TMUX="$(cat "$LOG_DIR/metro.tmux" 2>/dev/null || true)"
+else
   # Metro runs detached, writing to the log. The tmux window is a read-only tail.
   (
     cd "$TARGET"
     : > "$LOG_FILE"
-    # Source product env files (provides MM_INFURA_PROJECT_ID and friends).
-    set -a
-    # shellcheck disable=SC1091
-    [ ! -f .js.env ]    || . ./.js.env
-    # shellcheck disable=SC1091
-    [ ! -f .env ]       || . ./.env
-    # shellcheck disable=SC1091
-    [ ! -f .env.local ] || . ./.env.local
-    set +a
-    # The quick-launch runs `expo start` directly, bypassing scripts/build.sh which
-    # passes the build type as an argument (start:ios = build.sh ios main dev). The
-    # fixture .js.env ships METAMASK_BUILD_TYPE="" (empty), which Metro's transform
-    # rejects. Default to the main dev client (what runway installs / launch targets)
-    # so already-installed slots work without re-syncing fixtures.
-    [ -n "${METAMASK_BUILD_TYPE:-}" ] || export METAMASK_BUILD_TYPE=main
-    # build.sh remaps MM_SENTRY_DSN from MM_SENTRY_DSN_DEV for dev builds (start:ios
-    # = build.sh ios main dev); quick-launch bypasses build.sh, so without this the
-    # dev client's MM_SENTRY_DSN stays empty and Sentry never initializes.
-    [ -n "${MM_SENTRY_DSN:-}" ] || export MM_SENTRY_DSN="${MM_SENTRY_DSN_DEV:-}"
-    [ ! -f "$INLINE_ENV_FILE" ] || {
-      # shellcheck disable=SC1090
-      . "$INLINE_ENV_FILE"
-      rm -f "$INLINE_ENV_FILE"
-    }
     export EXPO_NO_TYPESCRIPT_SETUP=1
     export WATCHER_PORT="${PORT}" METRO_PORT="${PORT}"
-    export METRO_MAX_WORKERS="${METRO_WORKERS}"
-    export MM_HARNESS_METRO_PROJECT_ROOT="$TARGET"
-    export MM_HARNESS_METRO_BASE_CONFIG="${EXPO_OVERRIDE_METRO_CONFIG:-$TARGET/metro.config.js}"
-    export EXPO_OVERRIDE_METRO_CONFIG="$SCRIPT_DIR/metro-config.cjs"
+    if [ -n "$METRO_WORKERS" ]; then
+      export METRO_MAX_WORKERS="${METRO_WORKERS}"
+    else
+      unset METRO_MAX_WORKERS
+    fi
     launcher_args=(
       --target "$TARGET"
       --port "$PORT"
       --log "$LOG_FILE"
       --pid-file "$PID_FILE"
-      --workers "$METRO_WORKERS"
+      --build-env "$METRO_BUILD_ENV_FILE"
     )
+    [ -z "$METRO_WORKERS" ] || launcher_args+=(--workers "$METRO_WORKERS")
     [ "$CLEAR" = true ] && launcher_args+=(--clear)
     node "$SCRIPT_DIR/launch-metro.cjs" "${launcher_args[@]}"
   ) || exit 1
+  STARTED_METRO_PID="$(cat "$PID_FILE" 2>/dev/null || true)"
 
   start_viewer_window "$LOG_FILE"
 fi
@@ -256,9 +288,11 @@ if [ -f "$LOG_TUI" ] && command -v node >/dev/null 2>&1 \
   TAIL_PID=$!
 fi
 
-# Ready-poll: 90 × 1s = 90 s timeout.
+# Cold main bundles can spend more than 90 seconds initializing Metro before the
+# status listener opens. Keep the wait bounded, but do not trigger a duplicate
+# recovery process while the checkout-owned launch is still making progress.
 READY=false
-for _i in $(seq 1 90); do
+for _i in $(seq 1 "$READY_TIMEOUT"); do
   if metro_ready; then
     READY=true
     break
@@ -277,12 +311,50 @@ if [ "$READY" = true ]; then
   exit 0
 fi
 
+cleanup_timed_out_metro() {
+  local pid pgid i group_alive=false owned_listener_alive=false listener_pid command
+  pid="$STARTED_METRO_PID"
+  # launch-metro creates a detached group whose PGID equals its initial child
+  # PID. The leader can exit before Expo, so probe the group rather than the PID.
+  pgid="$pid"
+  if [ -n "$pgid" ] && kill -0 -- "-$pgid" 2>/dev/null; then
+    printf 'start-metro: stopping timed-out Metro process group %s\n' "$pgid" >&2
+    kill -TERM -- "-$pgid" 2>/dev/null || true
+    for i in $(seq 1 20); do
+      kill -0 -- "-$pgid" 2>/dev/null || break
+      sleep 0.25
+    done
+    if kill -0 -- "-$pgid" 2>/dev/null; then
+      kill -KILL -- "-$pgid" 2>/dev/null || true
+      for i in $(seq 1 20); do
+        kill -0 -- "-$pgid" 2>/dev/null || break
+        sleep 0.25
+      done
+    fi
+    kill -0 -- "-$pgid" 2>/dev/null && group_alive=true
+  fi
+  if [ -n "$STARTED_METRO_TMUX" ] && command -v tmux >/dev/null 2>&1; then
+    tmux kill-window -t "$STARTED_METRO_TMUX" >/dev/null 2>&1 || true
+  fi
+  for listener_pid in $(metro_listener_pids); do
+    command="$(ps eww -p "$listener_pid" -o command= 2>/dev/null || true)"
+    case "$command" in *"$TARGET"*) owned_listener_alive=true ;; esac
+  done
+  if [ "$group_alive" = true ] || [ "$owned_listener_alive" = true ]; then
+    printf 'start-metro: timed-out checkout-owned process is still alive; retaining launch metadata for recovery\n' >&2
+    return 1
+  fi
+  rm -f "$PID_FILE" "$LOG_DIR/metro-launch.json" "$LOG_DIR/metro-build-env.sh" "$LOG_DIR/metro.tmux"
+  return 0
+}
+
 # Failure: dump log events for diagnosis.
 if [ -f "$LOG_TUI" ] && command -v node >/dev/null 2>&1; then
   node "$LOG_TUI" events --log "$LOG_FILE" --events 20 >&2 || true
 else
   tail -40 "$LOG_FILE" >&2 || true
 fi
-printf 'start-metro: Metro did not become ready on port %s within 90s\n' "$PORT" >&2
+cleanup_timed_out_metro || true
+printf 'start-metro: Metro did not become ready on port %s within %ss\n' "$PORT" "$READY_TIMEOUT" >&2
 printf '  Next: check %s for errors, or run mm-harness logs\n' "$LOG_FILE" >&2
 exit 1

package/adapters/mobile/stop-metro.sh

@@ -62,6 +62,7 @@ fi
 set +e
 rm -f "$PID_FILE"
 rm -f "$LOG_DIR/metro-launch.json"
+rm -f "$LOG_DIR/metro-build-env.sh"
 
 # start-metro runs a per-checkout console-forwarder holding the device debugger
 # slot; Metro going down must take it too, or the orphan keeps polling and later

package/dist/adapters/mobile/prepare.js

@@ -116,10 +116,7 @@ async function prepareMobile(target, opts = {}) {
       );
     }
     const launch = await dispatchActionSequence(
-      withAppRestart(
-        launchActions(path.resolve(target)),
-        restartApp || iosAccessibilityChanged
-      ),
+      withAppRestart(launchActions(path.resolve(target)), true),
       target,
       platform,
       json,