@deeeed/metamask-harness 0.2.0

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

@@ -0,0 +1,48 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+function normalize(value) {
+  return String(value ?? '').toLowerCase();
+}
+
+runAdapter((input) => withExtensionPage(input, async (page) => {
+  const requestedAddress = normalize(input.node?.address);
+  const requestedId = input.node?.id ? String(input.node.id) : null;
+  const requestedName = input.node?.name ? String(input.node.name) : null;
+  if (!requestedAddress && !requestedId && !requestedName) {
+    throw new Error('metamask.wallet.select_account extension live adapter requires node.address, node.id, or node.name.');
+  }
+  const selected = await page.evaluate(`(async () => {
+    const hooks = globalThis.stateHooks;
+    const store = hooks && hooks.store;
+    const request = hooks && hooks.submitRequestToBackground;
+    if (!store || typeof store.getState !== 'function') throw new Error('stateHooks.store.getState is unavailable.');
+    if (typeof request !== 'function') throw new Error('stateHooks.submitRequestToBackground is unavailable.');
+    const state = store.getState() || {};
+    const internal = state.metamask?.internalAccounts || {};
+    const accounts = internal.accounts || {};
+    const requestedAddress = ${JSON.stringify(requestedAddress)};
+    const requestedId = ${JSON.stringify(requestedId)};
+    const requestedName = ${JSON.stringify(requestedName)};
+    const entries = Object.entries(accounts);
+    const match = entries.find(([id, account]) => {
+      const metadata = account?.metadata || {};
+      return (requestedId && id === requestedId) ||
+        (requestedAddress && String(account?.address || '').toLowerCase() === requestedAddress) ||
+        (requestedName && metadata.name === requestedName);
+    });
+    if (!match) throw new Error('Requested account was not found in internalAccounts.');
+    const [id, account] = match;
+    await request('setSelectedInternalAccount', [id]);
+    const after = store.getState()?.metamask?.internalAccounts || {};
+    const selectedId = after.selectedAccount;
+    const selected = after.accounts?.[selectedId];
+    if (selectedId !== id) throw new Error('Expected selected account ' + id + ', got ' + selectedId);
+    return {
+      id: selectedId,
+      address: selected?.address || null,
+      name: selected?.metadata?.name || null,
+      type: selected?.type || null
+    };
+  })()`, { awaitPromise: true });
+  return { action: input.action, selected, proofPath: 'extension-account-selection' };
+}));

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

@@ -0,0 +1,35 @@
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+
+runAdapter((input) => withExtensionPage(input, async (page) => {
+  const state = await page.evaluate(`(() => {
+    const passwordInput = Boolean(document.querySelector('input[type="password"]'));
+    const hooks = globalThis.stateHooks;
+    const store = hooks && hooks.store;
+    const root = store && typeof store.getState === 'function' ? store.getState() : {};
+    const metamask = root.metamask || {};
+    const internal = metamask.internalAccounts || {};
+    const accounts = internal.accounts || {};
+    const selectedId = internal.selectedAccount || null;
+    const selected = selectedId && accounts[selectedId] ? accounts[selectedId] : null;
+    return {
+      href: String(globalThis.location && globalThis.location.href || ''),
+      passwordInput,
+      completedOnboarding: Boolean(metamask.completedOnboarding),
+      selectedAccount: selected ? {
+        id: selectedId,
+        address: selected.address || null,
+      } : null,
+    };
+  })()`);
+  const seededProfilePresent = Boolean(state?.passwordInput || (state?.completedOnboarding && state?.selectedAccount?.address));
+  if (!seededProfilePresent) {
+    throw new Error(`Extension fixture profile is not ready; expected a locked password screen or completed onboarding with a selected account, got ${JSON.stringify(state)}`);
+  }
+  return {
+    action: input.action,
+    setup: 'preseeded-profile-verified',
+    targetUrl: page.target.url,
+    runtimeState: state,
+    proofPath: 'extension-fixture-profile',
+  };
+}));

package/library/actions/mobile/app-overlay/app/dev-tools/AgenticService/AgentStepHud.tsx.patch

@@ -0,0 +1,185 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import { StyleSheet, Text, View } from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { FullWindowOverlay } from 'react-native-screens';
+
+interface Step {
+  id: string;
+  intent: string;
+  status?: string;
+  progress?: { current?: number; total?: number };
+  detail?: string;
+  error?: string;
+  nodeId?: string;
+  debug?: { nodeId?: string; proofTarget?: unknown };
+}
+
+// Step bus. The HUD owns the registry so nothing outside this leaf module needs
+// to import AgenticService — keeping the bridge off the static import graph, so
+// it is dead-code-eliminated from release builds. AgenticService emits through
+// `emitStepHud`; the mounted HUD registers its setState as the sink.
+let stepSink: ((step: Step | null) => void) | null = null;
+
+export function emitStepHud(step: Step | null) {
+  stepSink?.(step);
+}
+
+function registerStepHudCallback(sink: ((step: Step | null) => void) | null) {
+  stepSink = sink;
+}
+
+function statusForStep(step: Step) {
+  const id = typeof step.id === 'string' ? step.id : '';
+  return String(step.status ?? id.split(/\s+/)[0] ?? '').toLowerCase();
+}
+
+function progressForStep(step: Step) {
+  if (
+    typeof step.progress?.current === 'number' &&
+    typeof step.progress?.total === 'number'
+  ) {
+    return `${step.progress.current}/${step.progress.total}`;
+  }
+  const progressPattern = /\b\d+\s*\/\s*\d+\b/;
+  const id = typeof step.id === 'string' ? step.id : '';
+  const match = progressPattern.exec(id);
+  return match ? match[0].replace(/\s+/g, '') : null;
+}
+
+function badgeTextForStep(step: Step) {
+  const rawStatus = statusForStep(step);
+  const status = rawStatus === 'running' ? 'run' : rawStatus;
+  const progress = progressForStep(step);
+  return [status || 'run', progress].filter(Boolean).join(' ').toUpperCase();
+}
+
+function statusToneForStep(step: Step) {
+  const status = statusForStep(step);
+  if (status === 'fail' || status === 'failed' || status === 'error') {
+    return 'fail';
+  }
+  if (status === 'pass' || status === 'passed' || status === 'success') {
+    return 'pass';
+  }
+  return 'running';
+}
+
+function displayStateForStep(step: Step) {
+  const intent = step.intent.trim();
+  const secondary = [
+    step.error ? `error: ${step.error}` : null,
+    step.detail && step.detail !== intent ? step.detail : null,
+  ].filter((part): part is string => Boolean(part));
+  return {
+    intent,
+    secondary: secondary.filter(
+      (part, index) => secondary.indexOf(part) === index,
+    ),
+  };
+}
+
+// Debug-only overlay — intentionally uses hardcoded colors for guaranteed
+// contrast on both light and dark themes. Design tokens would defeat the purpose.
+/* eslint-disable react-native/no-color-literals, @metamask/design-tokens/color-no-hex */
+const styles = StyleSheet.create({
+  container: {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    zIndex: 9999,
+    backgroundColor: 'rgba(0, 0, 0, 0.58)',
+    paddingVertical: 3,
+  },
+  line: {
+    color: '#FFFFFF',
+    fontSize: 11,
+    fontWeight: '700',
+    lineHeight: 14,
+  },
+  badgeText: {
+    fontFamily: 'Courier',
+    fontSize: 9,
+    fontWeight: '800',
+  },
+  badgeTextRunning: {
+    color: '#00FF88',
+  },
+  badgeTextPass: {
+    color: '#00FF88',
+  },
+  badgeTextFail: {
+    color: '#FF4D4F',
+  },
+  secondary: {
+    color: '#E6E6E6',
+    fontSize: 10,
+    fontWeight: '400',
+    lineHeight: 12,
+  },
+});
+/* eslint-enable react-native/no-color-literals, @metamask/design-tokens/color-no-hex */
+
+// Inner component — hooks always called unconditionally, per rules of React.
+const AgentStepHudInner = () => {
+  const [step, setStep] = useState<Step | null>(null);
+  const insets = useSafeAreaInsets();
+
+  const containerStyle = useMemo(
+    () => [
+      styles.container,
+      {
+        bottom: Math.max(insets.bottom, 0),
+        paddingLeft: Math.max(insets.left, 10),
+        paddingRight: Math.max(insets.right, 10),
+      },
+    ],
+    [insets.left, insets.right, insets.bottom],
+  );
+
+  useEffect(() => {
+    registerStepHudCallback(setStep);
+    return () => {
+      registerStepHudCallback(null);
+    };
+  }, []);
+
+  if (!step) return null;
+
+  const { intent, secondary } = displayStateForStep(step);
+  const badge = badgeTextForStep(step);
+  const tone = statusToneForStep(step);
+  const badgeTextStyle =
+    tone === 'fail'
+      ? styles.badgeTextFail
+      : tone === 'pass'
+        ? styles.badgeTextPass
+        : styles.badgeTextRunning;
+
+  // FullWindowOverlay (iOS) renders the HUD in a UIWindow above every native
+  // layer — including native-stack modal screens (perps close-position/TPSL,
+  // etc.), which a plain absolute/zIndex View in the JS root cannot reach. On
+  // Android it is a passthrough, so root-level rendering is preserved.
+  return (
+    <FullWindowOverlay>
+      <View style={containerStyle} pointerEvents="none">
+        <Text style={styles.line}>
+          <Text style={[styles.badgeText, badgeTextStyle]}>{badge}</Text>
+          {intent ? `  ${intent}` : ''}
+        </Text>
+        {secondary.map((detail) => (
+          <Text key={detail} style={styles.secondary}>
+            {detail}
+          </Text>
+        ))}
+      </View>
+    </FullWindowOverlay>
+  );
+};
+
+// Outer guard — never calls hooks, so the __DEV__ early return is fine.
+const AgentStepHud = () => {
+  if (!__DEV__) return null;
+  return <AgentStepHudInner />;
+};
+
+export default AgentStepHud;