@deeeed/metamask-harness 0.35.0 → 0.37.0

package/library/actions/extension/wallet/reset.mjs

@@ -0,0 +1,98 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { readWalletStateExpression } from './state.mjs';
+
+const SELECTORS = {
+  accountMenu: '[data-testid="account-options-menu-button"]',
+  lock: '[data-testid="global-menu-lock"]',
+  forgotPassword: '[data-testid="unlock-forgot-password-button"]',
+  resetChoice: '[data-testid="reset-password-modal-button-link"]',
+  confirmReset: '[data-testid="reset-password-modal-button"]',
+};
+
+async function hasSelector(page, selector) {
+  return page.evaluate(`Boolean(document.querySelector(${JSON.stringify(selector)}))`).catch(() => false);
+}
+
+async function waitForSelector(page, selector, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    if (await hasSelector(page, selector)) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Wallet reset timed out waiting for ${selector}.`);
+}
+
+async function clickWhenReady(page, selector, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() <= deadline) {
+    if (await hasSelector(page, selector)) {
+      try {
+        await page.click(selector);
+        return;
+      } catch (error) {
+        const message = String(error?.message ?? error);
+        if (!message.includes('Target is obscured') && !message.includes('Target is not visible')) {
+          throw error;
+        }
+        lastError = error;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw lastError ?? new Error(`Wallet reset timed out waiting for ${selector}.`);
+}
+
+async function readState(page) {
+  return page.evaluate(readWalletStateExpression(), { awaitPromise: true });
+}
+
+function isFreshWallet(state) {
+  return !state.completedOnboarding &&
+    String(state.href ?? '').includes('/onboarding') &&
+    !state.selectedAccount;
+}
+
+async function waitForFreshWallet(page, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let observed;
+  while (Date.now() <= deadline) {
+    observed = await readState(page);
+    if (isFreshWallet(observed)) return observed;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error('Extension wallet reset did not clear onboarding and the selected account.');
+}
+
+runAdapter((input) => withExtensionPage(input, async (page) => {
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+  const before = await readState(page);
+  if (isFreshWallet(before)) {
+    return {
+      action: input.action,
+      alreadyFresh: true,
+      completedOnboarding: false,
+      redacted: true,
+      proofPath: 'extension-visible-wallet-reset',
+    };
+  }
+
+  if (!before.passwordInput) {
+    await page.navigateHash('#/');
+    await waitForSelector(page, SELECTORS.accountMenu, timeoutMs);
+    await clickWhenReady(page, SELECTORS.accountMenu, timeoutMs);
+    await clickWhenReady(page, SELECTORS.lock, timeoutMs);
+    await waitForSelector(page, SELECTORS.forgotPassword, timeoutMs);
+  }
+  await clickWhenReady(page, SELECTORS.forgotPassword, timeoutMs);
+  await clickWhenReady(page, SELECTORS.resetChoice, timeoutMs);
+  await clickWhenReady(page, SELECTORS.confirmReset, timeoutMs);
+  const after = await waitForFreshWallet(page, timeoutMs);
+  return {
+    action: input.action,
+    alreadyFresh: false,
+    completedOnboarding: after.completedOnboarding,
+    redacted: true,
+    proofPath: 'extension-visible-wallet-reset',
+  };
+}));

package/library/actions/extension/wallet/secret-input.mjs

@@ -0,0 +1,98 @@
+export async function setSecretInput(page, selector, value) {
+  const found = await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return false;
+    element.focus();
+    if (typeof element.select === 'function') element.select();
+    return true;
+  })()`);
+  if (!found) throw new Error('Wallet import secret input was not found.');
+
+  await page.session.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Backspace' });
+  await page.session.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Backspace' });
+  await page.session.call('Input.insertText', { text: value });
+
+  const retainedLength = await page.evaluate(`(() => {
+    const element = document.querySelector(${JSON.stringify(selector)});
+    if (!element) return -1;
+    element.dispatchEvent(new Event('change', { bubbles: true }));
+    return typeof element.value === 'string' ? element.value.length : -1;
+  })()`);
+  if (retainedLength !== value.length) {
+    throw new Error('Wallet import secret input did not retain the supplied value.');
+  }
+}
+
+export async function pasteSecretRecoveryPhrase(page, selector, value, timeoutMs) {
+  const bridgeKey = 'mm-harness.wallet.recovery-phrase-paste';
+  const preload = await page.session.call('Page.addScriptToEvaluateOnNewDocument', {
+    source: `(() => {
+      const bridgeKey = Symbol.for(${JSON.stringify(bridgeKey)});
+      const NativeDataTransfer = globalThis.DataTransfer;
+      const NativeClipboardEvent = globalThis.ClipboardEvent;
+      Object.defineProperty(globalThis, bridgeKey, {
+        configurable: true,
+        value(selector) {
+          const element = document.querySelector(selector);
+          if (!element || typeof element.value !== 'string') return false;
+          const clipboardData = new NativeDataTransfer();
+          clipboardData.setData('text', element.value);
+          element.focus();
+          element.dispatchEvent(new NativeClipboardEvent('paste', {
+            bubbles: true,
+            cancelable: true,
+            clipboardData,
+          }));
+          return true;
+        },
+      });
+    })();`,
+  });
+  if (typeof preload?.identifier !== 'string' || preload.identifier.length === 0) {
+    throw new Error('Wallet import recovery phrase preload was not installed.');
+  }
+
+  let actionError;
+  try {
+    await page.session.call('Page.reload', { ignoreCache: false });
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+      const found = await page.evaluate(
+        `Boolean(document.querySelector(${JSON.stringify(selector)}))`,
+      ).catch(() => false);
+      if (found) break;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    await setSecretInput(page, selector, value);
+    const pasted = await page.evaluate(`(() => {
+      const bridge = globalThis[Symbol.for(${JSON.stringify(bridgeKey)})];
+      return typeof bridge === 'function' && bridge(${JSON.stringify(selector)});
+    })()`);
+    if (!pasted) throw new Error('Wallet import Secret Recovery Phrase input was not found.');
+  } catch (error) {
+    actionError = error;
+  }
+
+  const cleanupErrors = [];
+  try {
+    const removed = await page.evaluate(`(() => {
+      const key = Symbol.for(${JSON.stringify(bridgeKey)});
+      delete globalThis[key];
+      return !(key in globalThis);
+    })()`);
+    if (removed !== true) cleanupErrors.push('page bridge removal was not confirmed');
+  } catch (error) {
+    cleanupErrors.push(error instanceof Error ? error.message : String(error));
+  }
+  try {
+    await page.session.call('Page.removeScriptToEvaluateOnNewDocument', {
+      identifier: preload.identifier,
+    });
+  } catch (error) {
+    cleanupErrors.push(error instanceof Error ? error.message : String(error));
+  }
+  if (cleanupErrors.length > 0) {
+    throw new Error(`Wallet import recovery phrase bridge cleanup failed: ${cleanupErrors.join('; ')}.`);
+  }
+  if (actionError) throw actionError;
+}

package/library/actions/extension/wallet/state.mjs

@@ -38,6 +38,7 @@ export function readWalletStateExpression() {
         type: selected.type || null,
       } : null,
       completedOnboarding: Boolean(metamask.completedOnboarding),
+      metametricsOptedIn: typeof metamask.optedIn === 'boolean' ? metamask.optedIn : null,
       selectedNetworkClientId: metamask.selectedNetworkClientId || null,
     };
   })()`;

package/library/actions/mobile/analytics/consent-settings.mjs

@@ -0,0 +1,112 @@
+import { evalAsync, navigate } from '../platform/bridge.mjs';
+
+const SWITCH_IDS = {
+  participate: 'metametrics-switch',
+  marketing: 'data-collection-switch',
+};
+
+function toggleExpression(testId, expected, invoke) {
+  return `(() => {
+    const find = () => {
+      const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      const rootsFor = hook?.getFiberRoots;
+      if (!hook?.renderers || typeof rootsFor !== 'function') return null;
+      const walk = (fiber) => {
+        if (!fiber) return null;
+        if (fiber.memoizedProps?.testID === ${JSON.stringify(testId)}) return fiber;
+        return walk(fiber.child) || walk(fiber.sibling);
+      };
+      for (const [id] of hook.renderers) {
+        for (const root of rootsFor(id) ?? []) {
+          const match = walk(root.current);
+          if (match) return match;
+        }
+      }
+      return null;
+    };
+    const target = find();
+    const props = target?.memoizedProps;
+    if (!props) return { matched: false, found: false, invoked: false };
+    if (Boolean(props.value) === ${JSON.stringify(expected)}) {
+      return { matched: true, found: true, invoked: false };
+    }
+    if (!${JSON.stringify(invoke)}) {
+      return { matched: false, found: true, invoked: false };
+    }
+    if (typeof props.onValueChange !== 'function') {
+      throw new Error('Consent switch has no onValueChange handler: ${testId}');
+    }
+    return Promise.resolve(
+      props.onValueChange(${JSON.stringify(expected)})
+    ).then(() => ({
+      matched: false,
+      found: true,
+      invoked: true
+    }));
+  })()`;
+}
+
+function stateExpression(participate, marketing) {
+  return `(() => {
+    const state = globalThis.store?.getState?.();
+    const analytics = state?.engine?.backgroundState?.AnalyticsController ?? {};
+    const consent = {
+      optedIn: Boolean(analytics.optedIn),
+      dataCollectionForMarketing: Boolean(state?.security?.dataCollectionForMarketing),
+      analyticsId: analytics.analyticsId ? 'set' : null
+    };
+    return {
+      ready:
+        consent.optedIn === ${JSON.stringify(participate)} &&
+        consent.dataCollectionForMarketing === ${JSON.stringify(marketing)} &&
+        (!${JSON.stringify(participate)} || consent.analyticsId === 'set'),
+      consent
+    };
+  })()`;
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function setSwitch(input, testId, expected, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let invoked = false;
+  while (Date.now() < deadline) {
+    const result = await evalAsync(
+      input,
+      toggleExpression(testId, expected, !invoked),
+    );
+    invoked ||= Boolean(result?.invoked);
+    if (result?.matched) {
+      return { ...result, changed: invoked };
+    }
+    await delay(100);
+  }
+  throw new Error(`Timed out setting consent switch ${testId} to ${expected}.`);
+}
+
+async function readConsent(input, participate, marketing, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await evalAsync(
+      input,
+      stateExpression(participate, marketing),
+    );
+    if (result?.ready) {
+      return result.consent;
+    }
+    await delay(100);
+  }
+  throw new Error('Timed out reading back Mobile analytics consent.');
+}
+
+export async function setMobileConsent(input, participate, marketing, timeoutMs) {
+  const navigation = await navigate(input, 'SettingsView', {
+    screen: 'SecuritySettings',
+  }, 'SecuritySettings');
+  await setSwitch(input, SWITCH_IDS.participate, participate, timeoutMs);
+  await setSwitch(input, SWITCH_IDS.marketing, marketing, timeoutMs);
+  const consent = await readConsent(input, participate, marketing, timeoutMs);
+  return { consent, navigation };
+}

package/library/actions/mobile/analytics/set_consent.mjs

@@ -1,120 +1,12 @@
-import { evalAsync, navigate, runAdapter } from '../platform/bridge.mjs';
+import { runAdapter } from '../platform/bridge.mjs';
 import { consentParams } from '../../shared/analytics/consent.mjs';
-
-const SWITCH_IDS = {
-  participate: 'metametrics-switch',
-  marketing: 'data-collection-switch',
-};
-
-function toggleExpression(testId, expected, invoke) {
-  return `(() => {
-    const find = () => {
-      const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-      const rootsFor = hook?.getFiberRoots;
-      if (!hook?.renderers || typeof rootsFor !== 'function') return null;
-      const walk = (fiber) => {
-        if (!fiber) return null;
-        if (fiber.memoizedProps?.testID === ${JSON.stringify(testId)}) return fiber;
-        return walk(fiber.child) || walk(fiber.sibling);
-      };
-      for (const [id] of hook.renderers) {
-        for (const root of rootsFor(id) ?? []) {
-          const match = walk(root.current);
-          if (match) return match;
-        }
-      }
-      return null;
-    };
-    const target = find();
-    const props = target?.memoizedProps;
-    if (!props) return { matched: false, found: false, invoked: false };
-    if (Boolean(props.value) === ${JSON.stringify(expected)}) {
-      return { matched: true, found: true, invoked: false };
-    }
-    if (!${JSON.stringify(invoke)}) {
-      return { matched: false, found: true, invoked: false };
-    }
-    if (typeof props.onValueChange !== 'function') {
-      throw new Error('Consent switch has no onValueChange handler: ${testId}');
-    }
-    return Promise.resolve(
-      props.onValueChange(${JSON.stringify(expected)})
-    ).then(() => ({
-      matched: false,
-      found: true,
-      invoked: true
-    }));
-  })()`;
-}
-
-function stateExpression(participate, marketing) {
-  return `(() => {
-    const state = globalThis.store?.getState?.();
-    const analytics = state?.engine?.backgroundState?.AnalyticsController ?? {};
-    const consent = {
-      optedIn: Boolean(analytics.optedIn),
-      dataCollectionForMarketing: Boolean(state?.security?.dataCollectionForMarketing),
-      analyticsId: analytics.analyticsId ? 'set' : null
-    };
-    return {
-      ready:
-        consent.optedIn === ${JSON.stringify(participate)} &&
-        consent.dataCollectionForMarketing === ${JSON.stringify(marketing)} &&
-        (!${JSON.stringify(participate)} || consent.analyticsId === 'set'),
-      consent
-    };
-  })()`;
-}
-
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function setSwitch(input, testId, expected, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  let invoked = false;
-  while (Date.now() < deadline) {
-    const result = await evalAsync(
-      input,
-      toggleExpression(testId, expected, !invoked),
-    );
-    invoked ||= Boolean(result?.invoked);
-    if (result?.matched) {
-      return { ...result, changed: invoked };
-    }
-    await delay(100);
-  }
-  throw new Error(`Timed out setting consent switch ${testId} to ${expected}.`);
-}
-
-async function readConsent(input, participate, marketing, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const result = await evalAsync(
-      input,
-      stateExpression(participate, marketing),
-    );
-    if (result?.ready) {
-      return result.consent;
-    }
-    await delay(100);
-  }
-  throw new Error('Timed out reading back Mobile analytics consent.');
-}
+import { setMobileConsent } from './consent-settings.mjs';
 
 runAdapter(async (input) => {
   const { participate, marketing, timeoutMs } = consentParams(input.node);
 
-  const navigation = await navigate(input, 'SettingsView', {
-    screen: 'SecuritySettings',
-  }, 'SecuritySettings');
-  await setSwitch(input, SWITCH_IDS.participate, participate, timeoutMs);
-  await setSwitch(input, SWITCH_IDS.marketing, marketing, timeoutMs);
-  const consent = await readConsent(
-    input,
-    participate,
-    marketing,
-    timeoutMs,
+  const { consent, navigation } = await setMobileConsent(
+    input, participate, marketing, timeoutMs,
   );
 
   return {

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

@@ -454,6 +454,9 @@ export async function bridgeCommand(input, args) {
 function redactBridgeArgs(args) {
   const command = String(args[0] ?? '');
   if (command === 'unlock' && args.length > 1) return [command, '<redacted-password>', ...args.slice(2)];
+  if (command === 'set-input' && isSensitiveInputId(args[1])) {
+    return [command, String(args[1]), '<redacted>'];
+  }
   return args.map((arg) => String(arg));
 }
 
@@ -470,9 +473,14 @@ function redactBridgeOutput(output, args) {
 function sensitiveBridgeArgs(args) {
   const command = String(args[0] ?? '');
   if (command === 'unlock' && args.length > 1) return [args[1]];
+  if (command === 'set-input' && isSensitiveInputId(args[1])) return args.slice(2);
   return [];
 }
 
+function isSensitiveInputId(value) {
+  return /(?:confirm-password|password|phrase|seed|srp)/iu.test(String(value ?? ''));
+}
+
 function parseMaybeJson(value) {
   if (typeof value !== 'string') return value;
   try {

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

@@ -1,12 +1,13 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { createAgentDeviceClient } from 'agent-device';
 
 import { bridgeCommand } from './bridge.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 +112,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 +139,84 @@ async function readAndroidHierarchy(node, env) {
   );
 }
 
+async function readAndroidAgentDeviceHierarchy(serial, env) {
+  const session = `mm-harness-observe-${process.pid}-${Date.now()}`;
+  const client = createAgentDeviceClient({
+    session,
+    lockPolicy: 'reject',
+    lockPlatform: 'android',
+  });
+  try {
+    const snapshot = await client.capture.snapshot({
+      platform: 'android',
+      target: 'mobile',
+      serial,
+      session,
+      app: text(env.ANDROID_PACKAGE_ID) ?? 'io.metamask',
+      interactiveOnly: false,
+      forceFull: true,
+    });
+    const hierarchy = flattenAgentDeviceHierarchy(
+      snapshot.nodes,
+      text(env.ANDROID_PACKAGE_ID) ?? 'io.metamask',
+    );
+    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,