@deeeed/metamask-harness 0.44.2 → 0.45.0

package/library/actions/mobile/perps/read_visible_state.mjs

@@ -1,31 +1,4 @@
 import { runAdapter } from '../platform/bridge.mjs';
-import { observeNativeUi } from '../platform/observe-ui.mjs';
-import {
-  normalizeVisiblePerpsState,
-  resolveVisibleStateOptions,
-} from '../../shared/perps/visible-state.mjs';
+import { readVisiblePerpsState } from './read-visible-state-loop.mjs';
 
-runAdapter(async (input) => {
-  const options = resolveVisibleStateOptions(input.node);
-  const observed = await observeNativeUi(
-    { refs: ['ui.screen', 'ui.visible'], node: input.node },
-    input.context,
-  );
-  const screen = observed.observations?.['ui.screen'];
-  const visible = observed.observations?.['ui.visible'];
-  if (!screen || !visible) {
-    const warning = observed.warnings?.map((entry) => entry.message).filter(Boolean).join('; ');
-    throw new Error(`Mobile visible Perps state is unavailable${warning ? `: ${warning}` : '.'}`);
-  }
-  return {
-    action: input.action,
-    ...normalizeVisiblePerpsState({
-      route: screen.route,
-      title: screen.title,
-      items: visible.items,
-      offscreenItems: visible.hidden_or_offscreen,
-      truncated: visible.truncated,
-    }, options, 'mobile'),
-    proofPath: 'native-accessibility',
-  };
-});
+runAdapter(readVisiblePerpsState);

package/library/actions/mobile/platform/bridge.mjs

@@ -227,7 +227,7 @@ export function shouldResolveAndroidTargetModel(
   return Boolean(serial && !targetName && (!device || device === serial));
 }
 
-function resolveMobileTarget(input) {
+export function resolveMobileTarget(input) {
   const contextEnv = input.context?.env || {};
   const explicitSimulatorUdid =
     input.node?.sim_udid ?? contextEnv.SIM_UDID ?? process.env.SIM_UDID;

package/library/actions/mobile/platform/observe-ui.mjs

@@ -134,7 +134,7 @@ async function readAndroidHierarchy(node, env) {
   );
   const hierarchy = parseAndroidHierarchy(stdout);
   if (hierarchy.nodeCount === 0) {
-    throw new Error('adb returned an empty UIAutomator hierarchy.');
+    return readAndroidAgentDeviceHierarchy(serial, env);
   }
   return normalizedHierarchy(
     'adb-uiautomator',
@@ -364,7 +364,7 @@ function flattenIosHierarchy(value) {
       screenName ??= label;
       screenBounds ??= bounds;
     }
-    if (isActionableRole(role)) {
+    if (isActionableRole(role) || testId) {
       const normalized = compactItem({
         role,
         label,

package/library/actions/mobile/ui/native-navigation.mjs

@@ -4,6 +4,10 @@ import {
   nativeAgentDeviceStateDir,
   nativeSessionName,
 } from '../platform/native-session-name.mjs';
+import { bridgeCommand } from '../platform/bridge.mjs';
+import {
+  observeNativeUi,
+} from '../platform/observe-ui.mjs';
 
 const IDS = {
   wallet: ['wallet-safe-area', 'homepage-container'],
@@ -151,6 +155,215 @@ export async function navigateOpaqueMobile(input, destination) {
   }
 }
 
+export async function ensureVisibleAndroidPerpsMode(input, perpsMode) {
+  if (!['lite', 'pro'].includes(perpsMode)) {
+    throw new Error('Opaque Mobile Perps mode must be lite or pro.');
+  }
+  const env = { ...process.env, ...(input.context?.env ?? {}) };
+  const device = String(
+    env.ADB_SERIAL ?? env.ANDROID_SERIAL ?? env.ANDROID_DEVICE ?? '',
+  ).trim();
+  if (!device) {
+    throw new Error(
+      'Android Perps mode requires one explicit device serial.',
+    );
+  }
+  const app = String(env.ANDROID_PACKAGE_ID ?? 'io.metamask');
+  const session = nativeSessionName(env, device, app);
+  const stateDir = nativeAgentDeviceStateDir(env, input.context.projectRoot, device);
+  const client = createAgentDeviceClient({
+    session,
+    stateDir,
+    lockPolicy: 'reject',
+    lockPlatform: 'android',
+  });
+  const selection = { platform: 'android', target: 'mobile', serial: device, session };
+  const transport = createAgentDeviceUiTransport({
+    platform: 'android',
+    device,
+    app,
+    session,
+    stateDir,
+    client,
+  });
+  const context = {
+    nodeId: String(input.context?.nodeId ?? 'navigate'),
+    projectRoot: input.context.projectRoot,
+    artifactsDir: input.context.artifactsDir,
+    env,
+  };
+  const press = (testId) => transport.execute('ui.press', {
+    test_id: testId,
+    timeout_ms: Number(input.node?.timeout_ms ?? 30_000),
+    settle: false,
+  }, context);
+  const snapshot = () => client.capture.snapshot({
+    platform: 'android',
+    target: 'mobile',
+    serial: device,
+    session,
+    app,
+    interactiveOnly: false,
+    forceFull: true,
+  });
+  const identifiers = async () => new Set(
+    (await snapshot()).nodes
+      .filter((node) => node.visibleToUser !== false)
+      .map((node) => String(node.identifier ?? '')),
+  );
+
+  try {
+    const deadline = Date.now() + Number(input.node?.timeout_ms ?? 30_000);
+    const expectedToggle = perpsMode === 'pro' ? IDS.modeTogglePro : IDS.modeToggleLite;
+    const currentToggle = perpsMode === 'pro' ? IDS.modeToggleLite : IDS.modeTogglePro;
+    const option = perpsMode === 'pro' ? IDS.modePro : IDS.modeLite;
+    let expectedStreak = 0;
+    let currentStreak = 0;
+    let optionStreak = 0;
+    let currentAttempts = 0;
+    let optionAttempts = 0;
+    let lastObservationError;
+    while (Date.now() <= deadline) {
+      let ids;
+      try {
+        ids = await identifiers();
+        lastObservationError = undefined;
+      } catch (error) {
+        lastObservationError = String(error?.message ?? error);
+        expectedStreak = 0;
+        currentStreak = 0;
+        optionStreak = 0;
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        continue;
+      }
+      if (ids.has(expectedToggle)) {
+        expectedStreak += 1;
+        if (expectedStreak >= 2) {
+          return {
+            mode: perpsMode,
+            observedScreen: expectedToggle,
+            provider: 'android-native-accessibility',
+            proofPath: 'visible-native-navigation',
+          };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        continue;
+      }
+      expectedStreak = 0;
+      if (ids.has(option)) {
+        optionStreak += 1;
+        if (optionAttempts === 0 || (optionStreak >= 2 && optionAttempts < 2)) {
+          optionAttempts += 1;
+          optionStreak = 0;
+          await pressCurrent(press, option);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        continue;
+      }
+      optionStreak = 0;
+      if (
+        (ids.has(IDS.market) || ids.has(IDS.proMarket)) &&
+        ids.has(currentToggle)
+      ) {
+        currentStreak += 1;
+        if (currentAttempts === 0 || (currentStreak >= 2 && currentAttempts < 2)) {
+          currentAttempts += 1;
+          currentStreak = 0;
+          await pressCurrent(press, currentToggle);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        continue;
+      }
+      currentStreak = 0;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(
+      `Android navigation did not visibly switch Perps to ${perpsMode} mode` +
+      `${lastObservationError ? `: ${lastObservationError}` : '.'}`,
+    );
+  } finally {
+    await closeNativeSession(client, selection);
+  }
+}
+
+export async function ensureVisibleIosPerpsMode(input, perpsMode) {
+  if (!['lite', 'pro'].includes(perpsMode)) {
+    throw new Error('iOS Perps mode must be lite or pro.');
+  }
+  const expectedToggle = perpsMode === 'pro' ? IDS.modeTogglePro : IDS.modeToggleLite;
+  const currentToggle = perpsMode === 'pro' ? IDS.modeToggleLite : IDS.modeTogglePro;
+  const option = perpsMode === 'pro' ? IDS.modePro : IDS.modeLite;
+  const deadline = Date.now() + Number(input.node?.timeout_ms ?? 30_000);
+  let lastObserved = [];
+  let lastWarning;
+  let expectedStreak = 0;
+  let currentStreak = 0;
+  let optionStreak = 0;
+  let currentAttempts = 0;
+  let optionAttempts = 0;
+  while (Date.now() <= deadline) {
+    let observed;
+    try {
+      observed = await observeNativeUi(
+        { refs: ['ui.visible'], node: input.node },
+        input.context,
+      );
+    } catch (error) {
+      lastWarning = String(error?.message ?? error);
+      expectedStreak = 0;
+      currentStreak = 0;
+      optionStreak = 0;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      continue;
+    }
+    lastWarning = observed.warnings?.map((warning) => warning.message).filter(Boolean).join('; ');
+    const items = observed.observations?.['ui.visible']?.items ?? [];
+    const ids = new Set(items.map((item) => String(item.test_id ?? '')));
+    lastObserved = [...ids].filter(Boolean).slice(0, 20);
+    if (ids.has(expectedToggle)) {
+      expectedStreak += 1;
+      if (expectedStreak >= 2) {
+        return {
+          mode: perpsMode,
+          observedScreen: expectedToggle,
+          provider: 'ios-native-accessibility',
+          proofPath: 'visible-native-navigation',
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      continue;
+    }
+    expectedStreak = 0;
+    if (ids.has(option)) {
+      optionStreak += 1;
+      if (optionAttempts === 0 || (optionStreak >= 2 && optionAttempts < 2)) {
+        optionAttempts += 1;
+        optionStreak = 0;
+        await bridgeCommand(input, ['press-test-id', option]);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      continue;
+    }
+    optionStreak = 0;
+    if (ids.has(currentToggle)) {
+      currentStreak += 1;
+      if (currentAttempts === 0 || (currentStreak >= 2 && currentAttempts < 2)) {
+        currentAttempts += 1;
+        currentStreak = 0;
+        await bridgeCommand(input, ['press-test-id', currentToggle]);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      continue;
+    }
+    currentStreak = 0;
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error(
+    `iOS navigation did not visibly switch Perps to ${perpsMode} mode. ` +
+    `Observed: ${lastObserved.join(', ') || 'none'}${lastWarning ? `. ${lastWarning}` : ''}`,
+  );
+}
+
 async function navigateSwap({ identifiers, press, wait, back }) {
   let ids = await identifiers();
   if (ids.has(IDS.swapSourceInput)) return IDS.swapSourceInput;

package/library/actions/mobile/ui/navigate.mjs

@@ -1,5 +1,13 @@
-import { navigate, runAdapter } from '../platform/bridge.mjs';
-import { navigateOpaqueMobile } from './native-navigation.mjs';
+import {
+  navigate,
+  resolveMobileTarget,
+  runAdapter,
+} from '../platform/bridge.mjs';
+import {
+  ensureVisibleAndroidPerpsMode,
+  ensureVisibleIosPerpsMode,
+  navigateOpaqueMobile,
+} from './native-navigation.mjs';
 
 const PAGE_ROUTES = {
   home: { route: 'WalletView', params: {} },
@@ -44,8 +52,33 @@ runAdapter(async (input) => {
     ) {
       return navigateOpaqueMobile(input, alias);
     }
-    const navigation = await navigate(input, alias.route, alias.params);
-    return { action: input.action, ...alias, navigation, proofPath: 'agentic-navigation' };
+    const navigationParams = alias.page === 'perps-market'
+      ? { market: alias.params.market }
+      : alias.params;
+    const navigation = await navigate(input, alias.route, navigationParams);
+    const requestedPlatform = resolveMobileTarget(input).requestedPlatform;
+    const env = { ...process.env, ...(input.context?.env ?? {}) };
+    const platform =
+      requestedPlatform ||
+      (env.ADB_SERIAL || env.ANDROID_SERIAL || env.ANDROID_DEVICE
+        ? 'android'
+        : 'ios');
+    const visibleMode =
+      alias.page === 'perps-market' && text(input.node?.mode)
+      ? platform === 'android'
+        ? await ensureVisibleAndroidPerpsMode(input, alias.params.mode)
+        : await ensureVisibleIosPerpsMode(input, alias.params.mode)
+      : undefined;
+    return {
+      action: input.action,
+      ...alias,
+      params: navigationParams,
+      navigation,
+      ...(visibleMode ? { visibleMode } : {}),
+      proofPath: visibleMode
+        ? 'agentic-navigation+visible-native-navigation'
+        : 'agentic-navigation',
+    };
   }
 
   const route = input.node?.route ?? input.node?.screen;

package/library/actions/mobile/wallet/ensure_unlocked.mjs

@@ -56,8 +56,7 @@ async function statusBeforeDeadline(input, deadline) {
       30000,
   );
   const probeTimeoutMs = Math.min(
-    15000,
-    Math.max(5000, Math.floor(remainingMs / 3)),
+    Math.max(750, Math.floor(remainingMs / 3)),
     remainingMs,
     Number.isFinite(configuredMs) && configuredMs > 0 ? configuredMs : 30000,
   );
@@ -141,32 +140,41 @@ function isUnlockedStatus(status, input) {
   );
 }
 
-async function waitForStableUnlocked(input, initialStatus, stableMs = 750) {
+async function waitForStableUnlocked(
+  input,
+  initialStatus,
+  stableMs = 750,
+  recoveryTimeoutMs = 30000,
+) {
   if (!isUnlockedStatus(initialStatus, input)) return null;
-  const deadline = Date.now() + stableMs;
+  if (stableMs <= 0) return initialStatus;
+  const deadline =
+    Date.now() + Math.max(stableMs + 250, recoveryTimeoutMs);
+  let stableSince = Date.now();
   let last = initialStatus;
-  let transientDrops = 0;
   while (Date.now() < deadline) {
+    if (stableSince !== null && Date.now() - stableSince >= stableMs) {
+      return last;
+    }
     await new Promise((resolve) => setTimeout(resolve, 250));
     try {
       last = await statusBeforeDeadline(input, deadline);
       if (!isUnlockedStatus(last, input)) {
         if (routeName(last, input) === 'Login') return null;
-        transientDrops += 1;
-        if (transientDrops > 2) return null;
+        stableSince = null;
         continue;
       }
-      transientDrops = 0;
+      stableSince ??= Date.now();
     } catch {
-      // Recovery is correct: a bridge error during the stability window is the
-      // same signal as an unlocked-state drop — count it toward the transient
-      // threshold; exceeding it returns null so the caller runs the real
-      // password unlock instead of reporting a false alreadyUnlocked.
-      transientDrops += 1;
-      if (transientDrops > 2) return null;
+      // The Hermes page can rotate after Login -> Home. Keep waiting for the
+      // same pinned runtime to become observable again; do not restart Metro or
+      // the app, and restart the stability window when it returns.
+      stableSince = null;
     }
   }
-  return isUnlockedStatus(last, input) ? last : null;
+  return stableSince !== null && Date.now() - stableSince >= stableMs
+    ? last
+    : null;
 }
 
 export async function ensureUnlocked(input) {
@@ -194,7 +202,12 @@ export async function ensureUnlocked(input) {
     targetStatus,
     Math.max(0, targetDeadline - Date.now()),
   );
-  const stableBefore = await waitForStableUnlocked(input, before, Number(input.node?.stable_unlocked_ms ?? 750));
+  const stableBefore = await waitForStableUnlocked(
+    input,
+    before,
+    Number(input.node?.stable_unlocked_ms ?? 750),
+    Math.max(0, targetDeadline - Date.now()),
+  );
   if (stableBefore) {
     return {
       action: input.action,
@@ -251,10 +264,12 @@ export async function ensureUnlocked(input) {
   }
   const remainingUnlockMs = Math.max(1, unlockDeadline - Date.now());
   const after = await waitForUnlocked(input, remainingUnlockMs);
+  const remainingStabilityMs = Math.max(1, unlockDeadline - Date.now());
   const stableAfter = await waitForStableUnlocked(
     input,
     after,
     Number(input.node?.stable_unlocked_ms ?? 750),
+    remainingStabilityMs,
   );
   if (!stableAfter) {
     throw new Error('Mobile wallet did not remain unlocked for the required stability window.');

package/library/manifests/mobile.action-manifest.json

@@ -2162,6 +2162,11 @@
             "type": "integer",
             "minimum": 1,
             "default": 100
+          },
+          "timeout_ms": {
+            "type": "integer",
+            "minimum": 1000,
+            "default": 30000
           }
         },
         "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.44.2",
+  "version": "0.45.0",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"
@@ -24,7 +24,7 @@
     "@farmslot/expo-recipe": "0.8.1",
     "@farmslot/handoff": "^0.3.1",
     "@farmslot/protocol": "0.21.0",
-    "@farmslot/recipe-harness": "0.15.0",
+    "@farmslot/recipe-harness": "0.15.1",
     "agent-device": "0.19.3",
     "commander": "^12.0.0",
     "es-module-lexer": "2.3.1",