@deeeed/metamask-harness 0.36.0 → 0.38.0

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

@@ -0,0 +1,37 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { observeNativeUi } from '../platform/observe-ui.mjs';
+import {
+  normalizeVisibleAssetsState,
+  resolveVisibleAssetsOptions,
+} from '../../shared/assets/visible-state.mjs';
+
+runAdapter(async (input) => {
+  const options = resolveVisibleAssetsOptions(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 Assets state is unavailable${warning ? `: ${warning}` : '.'}`);
+  }
+  const items = [...(visible.items ?? []), ...(visible.hidden_or_offscreen ?? [])]
+    .filter((item) => String(item.test_id ?? '').startsWith('asset-'))
+    .map((item) => ({
+      testId: item.test_id,
+      label: item.label,
+      symbol: String(item.test_id).slice('asset-'.length),
+    }));
+  return {
+    action: input.action,
+    ...normalizeVisibleAssetsState({
+      route: screen.route,
+      title: screen.title,
+      items,
+      truncated: visible.truncated,
+    }, options, 'mobile'),
+    proofPath: 'native-accessibility',
+  };
+});

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

@@ -0,0 +1,31 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { observeNativeUi } from '../platform/observe-ui.mjs';
+import {
+  normalizeVisiblePerpsState,
+  resolveVisibleStateOptions,
+} from '../../shared/perps/visible-state.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',
+  };
+});

package/library/actions/mobile/platform/native-session-name.mjs

@@ -0,0 +1,5 @@
+export function nativeSessionName(env, device, app = 'io.metamask') {
+  const configured = String(env.METAMASK_RECIPE_MOBILE_SESSION ?? '').trim();
+  const source = configured || `mm-harness-${app}-${device}`;
+  return source.replace(/[^A-Za-z0-9._-]/gu, '-').slice(0, 120);
+}

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

@@ -1,12 +1,14 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { createAgentDeviceClient } from 'agent-device';
 
 import { bridgeCommand } from './bridge.mjs';
+import { nativeSessionName } from './native-session-name.mjs';
 import { mobileToolRecovery, resolveMobileToolPath } from './tool-paths.mjs';
 
 const execFileAsync = promisify(execFile);
-const VISIBLE_LIMIT = 50;
-const HIDDEN_LIMIT = 50;
+const VISIBLE_LIMIT = 200;
+const HIDDEN_LIMIT = 100;
 
 export async function observeNativeUi(payload, context) {
   await hideAccessibilityMaskingHud(payload, context);
@@ -111,6 +113,9 @@ async function readAndroidHierarchy(node, env) {
     );
   }
   const serial = await resolveAndroidSerial(adbPath, node, env);
+  if (isOpaqueRuntime(env)) {
+    return readAndroidAgentDeviceHierarchy(serial, env);
+  }
   const { stdout } = await execFileAsync(
     adbPath,
     ['-s', serial, 'exec-out', 'uiautomator', 'dump', '/dev/tty'],
@@ -135,6 +140,85 @@ async function readAndroidHierarchy(node, env) {
   );
 }
 
+async function readAndroidAgentDeviceHierarchy(serial, env) {
+  const app = text(env.ANDROID_PACKAGE_ID) ?? 'io.metamask';
+  const session = nativeSessionName(env, serial, app);
+  const client = createAgentDeviceClient({
+    session,
+    lockPolicy: 'reject',
+    lockPlatform: 'android',
+  });
+  try {
+    const snapshot = await client.capture.snapshot({
+      platform: 'android',
+      target: 'mobile',
+      serial,
+      session,
+      app,
+      interactiveOnly: false,
+      forceFull: true,
+    });
+    const hierarchy = flattenAgentDeviceHierarchy(
+      snapshot.nodes,
+      app,
+    );
+    if (hierarchy.nodeCount === 0) {
+      throw new Error('Agent Device returned an empty Android accessibility hierarchy.');
+    }
+    return normalizedHierarchy(
+      'agent-device-accessibility',
+      'android',
+      serial,
+      hierarchy.visible,
+      hierarchy.hidden,
+      hierarchy,
+    );
+  } finally {
+    await client.sessions.close({ session, shutdown: false });
+  }
+}
+
+function flattenAgentDeviceHierarchy(nodes, appId) {
+  const visible = [];
+  const hidden = [];
+  let screenName;
+  for (const source of Array.isArray(nodes) ? nodes : []) {
+    const node = record(source);
+    const bundleId = text(node.bundleId);
+    if (bundleId && bundleId !== appId) continue;
+    const bounds = normalizeBounds(node.rect ?? node.bounds);
+    const label = text(node.label) ?? text(node.value);
+    const role = text(node.type)?.toLowerCase();
+    const testId = text(node.identifier);
+    if (!isActionableRole(role) && !testId) continue;
+    screenName ??= label;
+    const item = compactItem({
+      role,
+      label,
+      test_id: testId,
+      enabled: boolean(node.enabled),
+      selected: boolean(node.selected),
+      focused: boolean(node.focused),
+      bounds,
+    });
+    if (hasVisibleBounds(bounds)) {
+      visible.push(item);
+    } else {
+      hidden.push({ ...item, reason: 'hidden_or_offscreen' });
+    }
+  }
+  return {
+    visible,
+    hidden,
+    nodeCount: Array.isArray(nodes) ? nodes.length : 0,
+    screenName,
+  };
+}
+
+function isOpaqueRuntime(env) {
+  return env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === '1';
+}
+
 function normalizedHierarchy(
   provider,
   platform,

package/library/actions/mobile/swap_bridge/native-session.mjs

@@ -0,0 +1,45 @@
+import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
+import { createAgentDeviceClient } from 'agent-device';
+import { nativeSessionName } from '../platform/native-session-name.mjs';
+
+export function createSwapNativeSession(input) {
+  const env = { ...process.env, ...(input.context?.env ?? {}) };
+  const device = String(env.ADB_SERIAL ?? env.ANDROID_SERIAL ?? '').trim();
+  if (!device) throw new Error('Opaque Mobile Swap actions require one explicit Android device serial.');
+  const app = String(env.ANDROID_PACKAGE_ID ?? 'io.metamask');
+  const session = nativeSessionName(env, device, app);
+  const client = createAgentDeviceClient({ session, lockPolicy: 'reject', lockPlatform: 'android' });
+  const selection = { platform: 'android', target: 'mobile', serial: device, session };
+  const transport = createAgentDeviceUiTransport({ platform: 'android', device, app, session, client });
+  const context = {
+    nodeId: String(input.context?.nodeId ?? 'action'),
+    projectRoot: input.context.projectRoot,
+    artifactsDir: input.context.artifactsDir,
+    env,
+  };
+  return {
+    client,
+    transport,
+    selection,
+    context,
+    app,
+    execute: (action, node) => transport.execute(action, node, context),
+    snapshot: () => client.capture.snapshot({ ...selection, app, interactiveOnly: false, forceFull: true }),
+  };
+}
+
+export async function closeSwapNativeSession(session) {
+  try {
+    await session.transport.close();
+  } catch (error) {
+    if (!/No active session|SESSION_NOT_FOUND/iu.test(String(error?.message ?? error))) throw error;
+  }
+}
+
+export function nativeNode(snapshot, identifier) {
+  return snapshot.nodes.find((node) => String(node.identifier ?? '') === identifier);
+}
+
+export function nativeLabel(node) {
+  return String(node?.label ?? node?.value ?? '').replace(/\s+/gu, ' ').trim();
+}

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

@@ -0,0 +1,31 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { observeNativeUi } from '../platform/observe-ui.mjs';
+import {
+  normalizeVisibleSwapBridgeState,
+  resolveVisibleSwapBridgeOptions,
+} from '../../shared/swap-bridge/visible-state.mjs';
+
+runAdapter(async (input) => {
+  const options = resolveVisibleSwapBridgeOptions(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 Swap state is unavailable${warning ? `: ${warning}` : '.'}`);
+  }
+  return {
+    action: input.action,
+    ...normalizeVisibleSwapBridgeState({
+      route: screen.route,
+      title: screen.title,
+      items: visible.items,
+      offscreenItems: visible.hidden_or_offscreen,
+      truncated: visible.truncated,
+    }, options, 'mobile'),
+    proofPath: 'native-accessibility',
+  };
+});

package/library/actions/mobile/swap_bridge/select_assets.mjs

@@ -0,0 +1,94 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { resolveAssetSelectionOptions } from '../../shared/swap-bridge/transaction.mjs';
+import {
+  closeSwapNativeSession,
+  createSwapNativeSession,
+  nativeLabel,
+  nativeNode,
+} from './native-session.mjs';
+
+async function waitFor(session, identifier, timeoutMs) {
+  await session.execute('ui.wait_for', {
+    test_id: identifier,
+    expected: 'visible',
+    timeout_ms: timeoutMs,
+    settle: false,
+  });
+}
+
+function androidChainId(chain) {
+  const match = String(chain).match(/^eip155:(\d+)$/u);
+  return match ? `0x${Number(match[1]).toString(16)}` : String(chain);
+}
+
+async function selectAsset(session, role, asset, timeoutMs, pickerAlreadyOpen = false) {
+  const picker = role === 'source' ? 'source-token-area' : 'dest-token-area';
+  if (!pickerAlreadyOpen) await session.execute('ui.press', { test_id: picker, timeout_ms: timeoutMs });
+  await waitFor(session, 'bridge-token-search-input', timeoutMs);
+  await session.execute('ui.press', { text: 'All', timeout_ms: timeoutMs });
+  await session.execute('ui.set_input', {
+    test_id: 'bridge-token-search-input',
+    value: asset.query,
+    timeout_ms: timeoutMs,
+  });
+  const row = `asset-${androidChainId(asset.chain)}-${asset.symbol}`;
+  await session.execute('ui.key_press', { key: 'BACK', timeout_ms: timeoutMs });
+  await revealAssetRow(session, row, timeoutMs);
+  await session.execute('ui.press', { test_id: row, timeout_ms: timeoutMs });
+  await waitFor(session, picker, timeoutMs);
+  const selected = nativeLabel(nativeNode(await session.snapshot(), picker));
+  if (!selected.toUpperCase().includes(asset.symbol)) {
+    throw new Error(`Swap ${role} asset ${asset.symbol} was not selected; observed ${JSON.stringify(selected)}.`);
+  }
+  return { role, testId: row, symbol: asset.symbol, chain: asset.chain };
+}
+
+async function revealAssetRow(session, row, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    if (nativeNode(await session.snapshot(), row)) return;
+    await session.execute('ui.scroll', {
+      direction: 'down',
+      amount: 0.75,
+      timeout_ms: Math.max(1, deadline - Date.now()),
+      settle: false,
+    });
+  }
+  throw new Error(`Swap asset row ${row} was not visible in the all-network token list.`);
+}
+
+async function closeOpenPicker(session, timeoutMs) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const snapshot = await session.snapshot();
+    if (!nativeNode(snapshot, 'bridge-token-search-input')) return;
+    await session.execute('ui.key_press', { key: 'BACK', timeout_ms: timeoutMs });
+  }
+  if (nativeNode(await session.snapshot(), 'bridge-token-search-input')) {
+    throw new Error('Swap token picker remained open after dismissing its keyboard and sheet.');
+  }
+}
+
+runAdapter(async (input) => {
+  const options = resolveAssetSelectionOptions(input.node);
+  if (options.sourceAssetId || options.destinationAssetId) {
+    throw new Error('Mobile Swap selection cannot disambiguate asset IDs from native accessibility. Next: omit source_asset_id and destination_asset_id or run the Extension recipe.');
+  }
+  const session = createSwapNativeSession(input);
+  try {
+    await closeOpenPicker(session, options.timeoutMs);
+    await waitFor(session, 'source-token-area-input', options.timeoutMs);
+    const source = await selectAsset(session, 'source', {
+      chain: options.sourceChain,
+      symbol: options.sourceSymbol,
+      query: options.sourceQuery,
+    }, options.timeoutMs);
+    const destination = await selectAsset(session, 'destination', {
+      chain: options.destinationChain,
+      symbol: options.destinationSymbol,
+      query: options.destinationQuery,
+    }, options.timeoutMs);
+    return { action: input.action, source, destination, proofPath: 'native-accessibility-selection' };
+  } finally {
+    await closeSwapNativeSession(session);
+  }
+});

package/library/actions/mobile/swap_bridge/set_amount.mjs

@@ -0,0 +1,73 @@
+import { runAdapter } from '../platform/bridge.mjs';
+import { resolveAmountOptions } from '../../shared/swap-bridge/transaction.mjs';
+import {
+  closeSwapNativeSession,
+  createSwapNativeSession,
+  nativeLabel,
+  nativeNode,
+} from './native-session.mjs';
+
+async function replaceNumericInput(session, amount, timeoutMs) {
+  await session.execute('ui.press', {
+    test_id: 'source-token-area-input',
+    timeout_ms: timeoutMs,
+    settle: false,
+  });
+  let current = nativeLabel(nativeNode(await session.snapshot(), 'source-token-area-input'));
+  for (let index = 0; index < Math.min(50, current.length + 2); index += 1) {
+    await session.execute('ui.press', {
+      test_id: 'keypad-delete-button',
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+  }
+  current = nativeLabel(nativeNode(await session.snapshot(), 'source-token-area-input'));
+  if (current !== '0' && current !== '') {
+    throw new Error(`Swap amount keypad could not clear the previous value ${JSON.stringify(current)}.`);
+  }
+  const keys = amount.startsWith('0.') && current === '0' ? amount.slice(1) : amount;
+  for (const key of keys) {
+    if (!/[0-9.]/u.test(key)) throw new Error(`Swap amount contains unsupported keypad character ${JSON.stringify(key)}.`);
+    await session.execute('ui.press', {
+      test_id: key === '.' ? 'keypad-key-dot' : `keypad-key-${key}`,
+      timeout_ms: timeoutMs,
+      settle: false,
+    });
+  }
+  await new Promise((resolve) => setTimeout(resolve, 300));
+}
+
+runAdapter(async (input) => {
+  const options = resolveAmountOptions(input.node);
+  const session = createSwapNativeSession(input);
+  try {
+    await replaceNumericInput(session, options.amount, options.timeoutMs);
+    const deadline = Date.now() + Math.max(1_000, options.timeoutMs - 10_000);
+    let observed;
+    do {
+      const snapshot = await session.snapshot();
+      const sourceAmount = nativeLabel(nativeNode(snapshot, 'source-token-area-input'));
+      const destinationAmount = nativeLabel(nativeNode(snapshot, 'dest-token-area-input'));
+      const cta = nativeNode(snapshot, 'bridge-confirm-button') ?? nativeNode(snapshot, 'bridge-confirm-button-keypad');
+      const noQuote = nativeNode(snapshot, 'bridge-no-quotes');
+      observed = {
+        sourceAmount,
+        destinationAmount,
+        cta: nativeLabel(cta) || null,
+        ctaEnabled: cta?.enabled !== false,
+        noQuote: Boolean(noQuote),
+      };
+      if (!options.waitForQuote || observed.noQuote || (Number(destinationAmount) > 0 && cta)) break;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    } while (Date.now() < deadline);
+    if (observed.sourceAmount !== options.amount) {
+      throw new Error(`Swap source amount mismatch: expected ${options.amount}, observed ${observed.sourceAmount}.`);
+    }
+    if (options.waitForQuote && !observed.noQuote && !(Number(observed.destinationAmount) > 0 && observed.cta)) {
+      throw new Error(`Swap quote did not resolve within ${options.timeoutMs}ms.`);
+    }
+    return { action: input.action, ...observed, proofPath: 'native-accessibility-amount' };
+  } finally {
+    await closeSwapNativeSession(session);
+  }
+});