@deeeed/metamask-harness 0.84.0 → 0.86.0

package/library/actions/extension/platform/cdp.mjs

@@ -76,6 +76,32 @@ export function extensionTarget(targets, extensionId = null, cdpTargetId = null)
   return home ?? sidepanel ?? null;
 }
 
+// The recipe-runner HUD (app.hud's clear) removed from every extension page on
+// the slot's CDP port. Launches nothing; each step is bounded and a missing
+// port or browser clears nothing.
+const CLEAR_HUD_EXPRESSION = "(() => { const hud = document.getElementById('farmslot-recipe-hud'); hud?.remove(); document.getElementById('farmslot-recipe-hud-reserved-space')?.remove(); document.documentElement.style.removeProperty('--farmslot-recipe-hud-height'); document.body?.style.removeProperty('padding-bottom'); return Boolean(hud); })()";
+
+export async function clearExtensionHud(env = process.env, timeoutMs = 2000) {
+  const port = Number(env.CDP_PORT ?? env.RECIPE_CDP_PORT);
+  if (!Number.isInteger(port) || port <= 0) return { cleared: 0 };
+  const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(timeoutMs) }).catch(() => null);
+  const targets = response?.ok ? await response.json().catch(() => []) : [];
+  let cleared = 0;
+  for (const target of Array.isArray(targets) ? targets : []) {
+    if (target?.type !== 'page' || !String(target.url ?? '').startsWith('chrome-extension://') || !target.webSocketDebuggerUrl) continue;
+    let session;
+    try {
+      session = await CdpSession.connect(target.webSocketDebuggerUrl, { timeoutMs });
+      const result = await session.call('Runtime.evaluate', { expression: CLEAR_HUD_EXPRESSION, returnByValue: true }, { timeoutMs });
+      if (result?.result?.value === true) cleared += 1;
+    } catch {
+      // A busy or closing page keeps nothing worth failing the run for.
+    } finally {
+      session?.close();
+    }
+  }
+  return { cleared };
+}
 
 function resolveRelativeArtifactPath(artifactsDir, relPath) {
   const relative = relPath || 'screenshots/extension-page.png';
@@ -955,8 +981,52 @@ export class ExtensionPage extends CdpWebPage {
       location.hash = ${JSON.stringify(normalizedHash)};
       return { before, href: location.href };
     })()`);
-    await this.waitForDocumentReady({ expectedUrl: navigation.href, timeoutMs });
-    return { ...navigation, sameDocument: true };
+    const ready = await this.waitForDocumentReady({ expectedUrl: navigation.href, timeoutMs });
+    return {
+      before: navigation.before,
+      requestedHref: navigation.href,
+      href: ready.url,
+      redirected: ready.redirected,
+      sameDocument: true,
+    };
+  }
+
+  // The Extension router may replace a requested hash with its canonical route
+  // in the same document (e.g. Perps symbol casing). The runtime still decides
+  // readiness; this accepts the rewritten URL once it holds for two polls. Any
+  // other origin, page or query still fails.
+  async waitForDocumentReady({ expectedUrl, timeoutMs = 10000 } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    let url;
+    let redirectCandidate;
+    while (true) {
+      await super.waitForDocumentReady({ timeoutMs: Math.max(1, deadline - Date.now()) });
+      // A context lost between the two probes counts as an unmatched poll.
+      url = await this.evaluate('location.href').catch(() => undefined);
+      if (!expectedUrl || url === expectedUrl) return { url, redirected: false };
+      const redirect = this.isSameDocumentRedirect(expectedUrl, url) ? url : undefined;
+      if (redirect && redirect === redirectCandidate) return { url, redirected: true };
+      redirectCandidate = redirect;
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) break;
+      await sleep(Math.min(50, remainingMs));
+    }
+    throw new Error(`Extension page did not reach ${expectedUrl} within ${timeoutMs}ms (last URL ${url ?? 'unavailable'})`);
+  }
+
+  isSameDocumentRedirect(expectedUrl, actualUrl) {
+    try {
+      const expected = new URL(expectedUrl);
+      const actual = new URL(actualUrl);
+      return `${expected.protocol}//${expected.host}` === this.origin
+        && actual.protocol === expected.protocol
+        && actual.host === expected.host
+        && actual.pathname === expected.pathname
+        && actual.search === expected.search
+        && actual.hash !== expected.hash;
+    } catch {
+      return false;
+    }
   }
 
   async readPositions() {

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

@@ -591,7 +591,9 @@ export async function navigateExtensionUi(input) {
   const url = input.node?.url;
   if (typeof url === 'string' && url.length > 0) {
     const navigation = await page.navigate(url);
-    return { action: input.action, url, navigation, proofPath: 'ui-navigation' };
+    // The router may canonicalize the requested route; report where it landed.
+    const href = await currentHref(page);
+    return { action: input.action, url, href, navigation, proofPath: 'ui-navigation' };
   }
 
   const hash = input.node?.hash ?? input.node?.path;

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

@@ -1,9 +1,10 @@
-// Selects an account by address, ID, or name through the background request hook.
-// Falls back to visible account search when that hook is unavailable and checks the selected address.
+// Selects an account by address, ID, or account group/internal name through the background request hook.
+// Returns without a write when the account is already selected. Falls back to visible account search
+// when that hook is unavailable and checks the selected address.
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import {
-  listWalletAccountsExpression,
   readWalletStateExpression,
+  resolveWalletAccountExpression,
   selectWalletAccountExpression,
 } from './state.mjs';
 
@@ -18,25 +19,24 @@ runAdapter((input) => withExtensionPage(input, async (page) => {
   if (!requestedAddress && !requestedId && !requestedName) {
     throw new Error('metamask.wallet.select_account extension live adapter requires node.address, node.id, or node.name.');
   }
+  const criteria = { address: requestedAddress, id: requestedId, name: requestedName };
   try {
-    const selected = await page.evaluate(selectWalletAccountExpression({
-      address: requestedAddress,
-      id: requestedId,
-      name: requestedName,
-    }), { awaitPromise: true });
-    return { action: input.action, selected, proofPath: 'extension-background-account-selection' };
+    const { alreadySelected, ...selected } = await page.evaluate(
+      selectWalletAccountExpression(criteria),
+      { awaitPromise: true },
+    );
+    return {
+      action: input.action,
+      selected,
+      ...(alreadySelected ? { alreadySelected: true } : {}),
+      proofPath: 'extension-background-account-selection',
+    };
   } catch (error) {
     if (!String(error?.message ?? error).includes('submitRequestToBackground is unavailable')) throw error;
   }
 
-  let searchAddress = requestedAddress;
-  if (!searchAddress) {
-    const listed = await page.evaluate(listWalletAccountsExpression('all'), { awaitPromise: true });
-    const account = listed.accounts.find((entry) =>
-      (requestedId && entry.id === requestedId) ||
-      (requestedName && entry.name === requestedName));
-    searchAddress = normalize(account?.address);
-  }
+  const resolved = await page.evaluate(resolveWalletAccountExpression(criteria), { awaitPromise: true });
+  const searchAddress = normalize(resolved?.address);
   if (!searchAddress) throw new Error('Requested account does not have a searchable EVM address.');
 
   await page.navigateHash('#/account-list');

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

@@ -94,40 +94,94 @@ export function listWalletAccountsExpression(scope) {
   })()`;
 }
 
+// Resolves id, address, or internal metadata name against internalAccounts first. A name
+// with no internal match falls back to AccountTreeController group names (multichain
+// wallets keep fixture names there, e.g. group "dev1" over internal "Account 1") and
+// selects the group's EVM account; a group without one is rejected.
+const resolveAccountPreamble = `
+    const resolveRequestedAccount = (state, criteria) => {
+      const accounts = state.internal.accounts || {};
+      const entries = Object.entries(accounts);
+      const isEvm = (account) => /^0x[0-9a-f]{40}$/iu.test(String(account?.address || ''));
+      const direct = entries.find(([id, account]) =>
+        (criteria.id && id === criteria.id) ||
+        (criteria.address && String(account?.address || '').toLowerCase() === criteria.address) ||
+        (criteria.name && account?.metadata?.name === criteria.name));
+      if (direct) return { id: direct[0], accountGroup: null };
+      if (!criteria.name) return null;
+      const groups = [];
+      for (const wallet of Object.values(state.metamask.accountTree?.wallets || {})) {
+        for (const [groupId, group] of Object.entries(wallet?.groups || {})) {
+          if (group?.metadata?.name === criteria.name) groups.push({ id: groupId, accounts: group.accounts || [] });
+        }
+      }
+      if (groups.length > 1) {
+        throw new Error('Requested account name ' + JSON.stringify(criteria.name) + ' matches ' + groups.length +
+          ' account groups; select by address instead.');
+      }
+      if (!groups.length) return null;
+      const id = groups[0].accounts.find((candidate) => isEvm(accounts[candidate]));
+      if (!id) {
+        throw new Error('Account group ' + JSON.stringify(criteria.name) +
+          ' has no EVM account; select by id instead.');
+      }
+      return { id, accountGroup: { id: groups[0].id, name: criteria.name } };
+    };
+    const describeAccount = (state, resolved) => {
+      const account = state.internal.accounts?.[resolved.id];
+      return {
+        id: resolved.id,
+        address: account?.address || null,
+        name: account?.metadata?.name || null,
+        type: account?.type || null,
+        ...(resolved.accountGroup ? { accountGroup: resolved.accountGroup } : {}),
+      };
+    };
+`;
+
+function criteriaLiteral(criteria) {
+  return JSON.stringify({
+    address: criteria.address || null,
+    id: criteria.id || null,
+    name: criteria.name || null,
+  });
+}
+
+export function resolveWalletAccountExpression(criteria) {
+  return `(async () => {
+    ${walletStatePreamble}
+    ${resolveAccountPreamble}
+    const state = await readWalletState();
+    const resolved = resolveRequestedAccount(state, ${criteriaLiteral(criteria)});
+    if (!resolved) throw new Error('Requested account was not found in account groups or internalAccounts.');
+    return {
+      ...describeAccount(state, resolved),
+      alreadySelected: resolved.id === (state.internal.selectedAccount || null),
+    };
+  })()`;
+}
+
 export function selectWalletAccountExpression(criteria, timeoutMs = 5000) {
   return `(async () => {
     ${walletStatePreamble}
+    ${resolveAccountPreamble}
     const before = await readWalletState();
-    const accounts = before.internal.accounts || {};
-    const requestedAddress = ${JSON.stringify(criteria.address)};
-    const requestedId = ${JSON.stringify(criteria.id)};
-    const requestedName = ${JSON.stringify(criteria.name)};
-    const match = Object.entries(accounts).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 resolved = resolveRequestedAccount(before, ${criteriaLiteral(criteria)});
+    if (!resolved) throw new Error('Requested account was not found in account groups or internalAccounts.');
+    const id = resolved.id;
+    if ((before.internal.selectedAccount || null) === id) {
+      return { ...describeAccount(before, resolved), alreadySelected: true };
+    }
     if (typeof before.hooks.submitRequestToBackground !== 'function') {
       throw new Error('stateHooks.submitRequestToBackground is unavailable.');
     }
-    const [id] = match;
     await before.hooks.submitRequestToBackground('setSelectedInternalAccount', [id]);
     const deadline = Date.now() + ${Number(timeoutMs)};
     let observedId = before.internal.selectedAccount || null;
     while (Date.now() <= deadline) {
       const after = await readWalletState();
       observedId = after.internal.selectedAccount || null;
-      if (observedId === id) {
-        const selected = after.internal.accounts?.[observedId];
-        return {
-          id: observedId,
-          address: selected?.address || null,
-          name: selected?.metadata?.name || null,
-          type: selected?.type || null,
-        };
-      }
+      if (observedId === id) return describeAccount(after, resolved);
       await new Promise((resolve) => setTimeout(resolve, 100));
     }
     throw new Error(

package/library/actions/mobile/app/assert_no_console_errors.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+// Fail the recipe when the app logged an error or uncaught exception that no
+// console allowlist marks as known noise. Reads app-console.log, written by the
+// adapter-rn console forwarder (adapters/mobile/start-console-forwarder.sh).
+// The same classifier and allowlist feed run diagnostics.
+//
+// Window: since "launch" (the default) judges the events since the launch
+// began, by their own timestamps. A launch records its start once its
+// refusals are behind it and before anything can restart the app
+// (app-console.launch.json, recordMobileConsoleLaunch in
+// src/adapters/mobile/launch.ts); a recovery attempt that restarts the app
+// records it again. Stamps come from the device's clock, so the window is
+// moved onto it by the offset the capture control line shows. Every launch
+// restarts the forwarder, and start-console-forwarder.sh empties
+// app-console.log and the forwarder's replay cursor as it does, so a
+// relaunched app's first lines are kept; but on a launch that keeps the app
+// runtime, the new forwarder replays that runtime's console from before the
+// launch. The forwarder stamps each line with the event's own runtime time,
+// so a record stamped before the launch is left out. Without a mark the
+// action fails as unavailable. since "start-of-log" reads the whole file.
+//
+// Device: app-console.log holds every device the forwarder sees; only the
+// device the control line came back from (the one the bridge selects for this
+// run) is judged. When that line names no device, every device is, and the
+// output says so (devices: "all").
+//
+// It never passes on missing evidence: the forwarder named by
+// console-forwarder.pid must be alive and writing this checkout's
+// app-console.log, and a control line logged inside the app through the debug
+// bridge must reach that file; otherwise the action fails as unavailable. The
+// opaque runtime (an installed release build) has no bridge, so it always
+// fails as unavailable.
+
+import { randomUUID } from 'node:crypto';
+import { existsSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { recipeRuntimeDir } from '@farmslot/recipe-cli/harness';
+
+import { captureUnavailable, consoleLevels, inWindow, nearestInstant, judgeConsole, nodeAllowlist, readFrom, readLaunchMark, reportVerdict, throwOnFindings } from '../../shared/console-assert.mjs';
+import { CAPTURE_CONTROL_MARK, controlLineReached, fileSize, processCommand, readPid } from '../../shared/console-collector.mjs';
+import { consoleRecords, recordStamp } from '../../shared/console-findings.mjs';
+import { evalSync, runAdapter } from '../platform/bridge.mjs';
+
+const LOG = 'app-console.log';
+const LAUNCH_MARK = 'app-console.launch.json';
+const unavailable = (detail) => captureUnavailable(detail, 'The app console');
+
+// The forwarder start-console-forwarder.sh started for this checkout: a live
+// process running console-forwarder.cjs whose --out is this runtime's
+// app-console.log, as the script writes it (the checkout's resolved path).
+export function forwarderStatus({ pidFile, log }) {
+  const pid = readPid(pidFile);
+  if (!pid) return { ok: false, detail: `no console forwarder pid in ${pidFile}` };
+  const command = processCommand(pid);
+  if (!command) return { ok: false, detail: `console forwarder pid ${pid} is not running` };
+  if (!/\/console-forwarder\.cjs --port \S+ --out /u.test(command) || !command.endsWith(` --out ${log}`)) {
+    return { ok: false, detail: `pid ${pid} is not this checkout's console forwarder` };
+  }
+  return { ok: true, detail: `console forwarder pid ${pid}` };
+}
+
+// Log a control line inside the app; the forwarder writes it at info level,
+// and the classifier never reports a capture control line anyway.
+function logInApp(input, line) {
+  return evalSync(input, `(console.info(${JSON.stringify(line)}), true)`);
+}
+
+export async function assertNoConsoleErrors(input, env = process.env, deps = {}) {
+  const node = input.node ?? {};
+  const levels = consoleLevels(node);
+  if (env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === '1') {
+    throw unavailable('the opaque runtime has no debug bridge to log a control line through');
+  }
+  const projectRoot = input.context?.projectRoot;
+  if (!projectRoot || !existsSync(projectRoot)) throw unavailable(`no checkout at ${projectRoot}`);
+  const runtime = path.join(realpathSync(projectRoot), recipeRuntimeDir());
+  const log = path.join(runtime, LOG);
+  const forwarder = (deps.forwarderStatus ?? forwarderStatus)({ pidFile: path.join(runtime, 'console-forwarder.pid'), log });
+  if (!forwarder.ok) throw unavailable(forwarder.detail);
+  const mark = node.since === 'start-of-log' ? null : readLaunchMark(path.join(runtime, LAUNCH_MARK), unavailable);
+  const nonce = randomUUID();
+  const start = fileSize(log);
+  const clock = deps.clock ?? (() => deps.now ?? Date.now());
+  const before = clock();
+  try {
+    await (deps.logInApp ?? logInApp)(input, `${CAPTURE_CONTROL_MARK} ${nonce}`);
+  } catch (error) {
+    // No line logged: the capture is unproven, which is this action's failure.
+    throw unavailable(`could not log the capture control line in the app (${error.message})`);
+  }
+  const after = clock();
+  const timeoutMs = Number(node.timeout_ms) > 0 ? Number(node.timeout_ms) : 8000;
+  if (!await controlLineReached(log, start, nonce, timeoutMs)) {
+    throw unavailable(`the capture control line logged in the app did not reach ${log} within ${timeoutMs}ms`);
+  }
+  const { text } = readFrom(log, { offset: 0 });
+  // The control line names the device, and its stamp, from the device's clock,
+  // bounds that clock's offset from this machine's (a physical device's clock
+  // can run minutes off; the simulator shares the host's). The line was
+  // logged between `before` and `after` on the host, so bridge latency only
+  // widens the bound; it never moves the launch past a fresh record.
+  const control = consoleRecords(text).find((record) => record.line.includes(nonce));
+  const controlStamp = control ? recordStamp(control) : null;
+  const device = controlStamp?.device ?? null;
+  const controlAt = controlStamp ? nearestInstant(controlStamp.clock, before) : null;
+  const offset = controlAt === null ? { min: 0, max: 0 } : { min: controlAt - after, max: controlAt - before };
+  const allowlist = nodeAllowlist(node, env);
+  const keep = inWindow({ sinceMs: mark?.launchedAtMs ?? null, device, now: clock(), offset });
+  const { findings, allowlisted } = judgeConsole([text], { levels, allowlist, keep });
+  const output = {
+    action: input.action,
+    since: node.since ?? 'launch',
+    devices: device ?? 'all',
+    levels: [...levels],
+    findings,
+    allowlisted,
+    allowlistProblems: allowlist.problems,
+    capture: { forwarder: forwarder.detail, control: `control line from the app reached ${LOG}` },
+    proofPath: 'mobile-console-capture',
+  };
+  throwOnFindings(findings, allowlist.problems);
+  return output;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  reportVerdict(() => runAdapter((input) => assertNoConsoleErrors(input)));
+}

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

@@ -1,4 +1,5 @@
 // Select a wallet account by address, ID, or name and verify the resulting selection.
+// A name with no internal account match falls back to AccountTreeController group names.
 // Observe ambiguous bridge write failures until the deadline without repeating the switch.
 import { pathToFileURL } from 'node:url';
 import {
@@ -34,13 +35,13 @@ function withRemainingDeadline(input, deadline, attemptTimeoutMs) {
   };
 }
 
-async function readSelectedAccount(input, deadline) {
+async function readBridge(input, deadline, args, timeoutMessage) {
   let lastError = null;
   while (Date.now() < deadline) {
     try {
       return await bridgeCommand(
         withRemainingDeadline(input, deadline, READ_ATTEMPT_TIMEOUT_MS),
-        ['get-selected-account'],
+        args,
       );
     } catch (error) {
       if (!TRANSIENT_READ_CODES.has(error?.code)) throw error;
@@ -48,24 +49,34 @@ async function readSelectedAccount(input, deadline) {
       await sleep(Math.min(100, Math.max(0, deadline - Date.now())));
     }
   }
-  throw lastError ?? new Error('Timed out reading the selected Mobile account.');
+  throw lastError ?? new Error(timeoutMessage);
 }
 
-async function readAccounts(input, deadline) {
-  let lastError = null;
-  while (Date.now() < deadline) {
-    try {
-      return await bridgeCommand(
-        withRemainingDeadline(input, deadline, READ_ATTEMPT_TIMEOUT_MS),
-        ['list-accounts'],
-      );
-    } catch (error) {
-      if (!TRANSIENT_READ_CODES.has(error?.code)) throw error;
-      lastError = error;
-      await sleep(Math.min(100, Math.max(0, deadline - Date.now())));
+const readSelectedAccount = (input, deadline) =>
+  readBridge(input, deadline, ['get-selected-account'], 'Timed out reading the selected Mobile account.');
+
+const readAccounts = (input, deadline) =>
+  readBridge(input, deadline, ['list-accounts'], 'Timed out reading Mobile accounts.');
+
+// Multichain wallets name the account group, not always the internal account.
+async function findAccountByGroupName(input, deadline, accounts, name) {
+  const wallets = await readBridge(
+    input,
+    deadline,
+    ['get-state', 'engine.backgroundState.AccountTreeController.accountTree.wallets'],
+    'Timed out reading Mobile account groups.',
+  );
+  const groups = [];
+  for (const wallet of Object.values(wallets && typeof wallets === 'object' ? wallets : {})) {
+    for (const [groupId, group] of Object.entries(wallet?.groups ?? {})) {
+      if (group?.metadata?.name === name) groups.push({ id: groupId, accounts: group.accounts ?? [] });
     }
   }
-  throw lastError ?? new Error('Timed out reading Mobile accounts.');
+  if (groups.length > 1) {
+    throw new Error(`Requested mobile account name ${JSON.stringify(name)} matches ${groups.length} account groups; select by address instead.`);
+  }
+  const match = accounts.find((account) => groups[0]?.accounts.includes(account?.id));
+  return match ? { ...match, accountGroup: { id: groups[0].id, name } } : null;
 }
 
 function ambiguousWriteFailure(writeError, match, finalSelected, readError) {
@@ -98,7 +109,7 @@ export async function selectAccount(input) {
   if (!Array.isArray(accounts)) {
     throw new Error(`metamask.wallet.select_account expected list-accounts to return an array, got ${typeof accounts}.`);
   }
-  const match = accounts.find((account) => {
+  let match = accounts.find((account) => {
     const address = String(account?.address ?? '').toLowerCase();
     const id = String(account?.id ?? '');
     const name = String(account?.name ?? '');
@@ -106,8 +117,11 @@ export async function selectAccount(input) {
       (requestedId && id === requestedId) ||
       (requestedName && name === requestedName);
   });
+  if (!match && requestedName) {
+    match = await findAccountByGroupName(input, deadline, accounts, requestedName);
+  }
   if (!match?.address) {
-    throw new Error(`Requested mobile account was not found in list-accounts: ${JSON.stringify({ address: requestedAddress, id: requestedId, name: requestedName })}`);
+    throw new Error(`Requested mobile account was not found in list-accounts or account groups: ${JSON.stringify({ address: requestedAddress, id: requestedId, name: requestedName })}`);
   }
   const current = await readSelectedAccount(input, deadline);
   const matchAddress = String(match.address).toLowerCase();
@@ -118,6 +132,7 @@ export async function selectAccount(input) {
         address: current?.address ?? match.address,
         id: current?.id ?? match.id,
         name: current?.name ?? match.name,
+        ...(match.accountGroup ? { accountGroup: match.accountGroup } : {}),
       },
       alreadySelected: true,
       proofPath: 'agentic-account-selection',
@@ -172,6 +187,7 @@ export async function selectAccount(input) {
       address: selected?.address ?? result?.address ?? match.address,
       id: selected?.id ?? result?.id ?? match.id,
       name: selected?.name ?? result?.name ?? match.name,
+      ...(match.accountGroup ? { accountGroup: match.accountGroup } : {}),
     },
     ...(ambiguousWriteError
       ? { recoveredAfterAmbiguousWrite: true }