@deeeed/metamask-harness 0.79.0 → 0.81.0

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

@@ -14,6 +14,14 @@ import {
 import { ensureUnlocked } from '../wallet/ensure_unlocked.mjs';
 import { selectAccount } from '../wallet/select_account.mjs';
 import { observeNativeUi } from '../platform/observe-ui.mjs';
+import {
+  assertFlatBeforeRoundTrip,
+  assertHouseLimitPosition,
+  closeImmediatelyRequested,
+  orderNetwork,
+  requireHouseNotional,
+  requirePerpsOrderAllowed,
+} from '../../shared/perps/order-policy.mjs';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -1281,7 +1289,7 @@ function closePositionParams(input, position) {
   return params;
 }
 
-async function closePositionItem(input, position) {
+async function closePositionItem(input, position, bound = null) {
   const maxAttempts = Number(input.node?.close_attempts ?? 3);
   const retryDelayMs = Number(input.node?.close_retry_delay_ms ?? 1000);
   const deadline = deadlineFromTimeout(
@@ -1293,7 +1301,7 @@ async function closePositionItem(input, position) {
   let lastResult = null;
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     if (Date.now() >= deadline) break;
-    const currentPositions = await readPositions(input);
+    const currentPositions = bound ? await readBoundPositions(input, bound) : await readPositions(input);
     const currentPosition = currentPositions.find((candidate) => symbolForItem(candidate) === baseParams.symbol);
     if (!currentPosition) return { symbol: baseParams.symbol, result: { success: true, alreadyClosed: true }, attempts };
 
@@ -1301,8 +1309,12 @@ async function closePositionItem(input, position) {
     const params = { ...baseParams, position: currentPosition, priceAtCalculation };
     const result = await evalAsync(
       input,
-      `Engine.context.PerpsController.closePosition(${JSON.stringify(params)}).then(function(r){return JSON.stringify(r)})`,
+      `(function(){ ${boundContextGuard(bound)}
+        return Engine.context.PerpsController.closePosition(${sourceLiteral(params)}).then(function(r){return JSON.stringify(r)}); })()`,
     );
+    if (result?.contextChanged) {
+      throw new Error(`Close of ${baseParams.symbol} stopped: the selected account or network changed; nothing more was sent.`);
+    }
     attempts.push({ attempt, priceAtCalculation, result });
     lastResult = result;
     if (result?.success === false) {
@@ -1394,7 +1406,37 @@ export async function placeOrder(input) {
   const maxSlippageBps = Number(input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300);
   const isBuy = orderSideIsBuy(side);
   const orderType = resolveOrderType(input);
+  const closeImmediately = closeImmediatelyRequested(input.node);
+  const runtime = await readPerpsRuntimeState(input);
+  const network = orderNetwork({ declared: input.node?.network, liveIsTestnet: runtime?.isTestnet });
+  // The account and network the rule allows, rechecked at dispatch and before any close.
+  const bound = { network, address: String((await readSelectedAddress(input)) ?? '').toLowerCase() };
+  const policy = await requirePerpsOrderAllowed({
+    network,
+    amount,
+    leverage,
+    orderType,
+    closeImmediately,
+    projectRoot: input.context?.projectRoot,
+    selectedAddress: bound.address,
+  });
+  if ((closeImmediately || network === 'mainnet') && input.node?.size != null) {
+    throw new Error('close_immediately and mainnet orders are sized from amount; drop size.');
+  }
+  if (closeImmediately) {
+    const book = await readBoundBook(input, bound);
+    assertFlatBeforeRoundTrip(book.positions, symbol, symbolForItem, book.orders);
+  }
   const currentPrice = await currentPriceForOrder(input, symbol);
+  const houseNotional = requireHouseNotional({
+    network,
+    symbol,
+    amount,
+    leverage,
+    price: currentPrice,
+    szDecimals: network === 'mainnet' ? await readSizeDecimals(input, symbol) : null,
+    maxSlippageBps,
+  });
   const limitPrice = orderType === 'limit'
     ? resolveLimitPrice(input, isBuy, currentPrice)
     : null;
@@ -1426,16 +1468,179 @@ export async function placeOrder(input) {
       priceAtCalculation: currentPrice,
       maxSlippageBps,
     };
-  const result = await evalAsync(input, `Engine.context.PerpsController.placeOrder(${JSON.stringify(orderParams)}).then(function(r){return JSON.stringify(r)})`);
-  if (result?.success === false || result == null) {
-    throw new Error(`Failed to place ${symbol} ${side}: ${result?.error || JSON.stringify(result)}`);
+  if (await tradingContextChanged(input, bound)) {
+    throw new Error('Perps order not dispatched: the selected account or network changed after the order rule allowed it.');
+  }
+  let result;
+  try {
+    result = await evalAsync(input, `(function(){ ${boundContextGuard(bound)}
+      return Engine.context.PerpsController.placeOrder(${sourceLiteral(orderParams)}).then(function(r){return JSON.stringify(r)}); })()`);
+    if (result?.contextChanged) {
+      throw Object.assign(
+        new Error('Perps order not dispatched: the selected account or network changed after the order rule allowed it.'),
+        { knownNotDispatched: true },
+      );
+    }
+    if (result?.success === false || result == null) {
+      throw new Error(`Failed to place ${symbol} ${side}: ${result?.error || JSON.stringify(result)}`);
+    }
+    if (orderType === 'limit') {
+      await waitForSelectedState(input, readOpenOrders, true, Number(input.node?.timeout_ms ?? 30000));
+    } else {
+      await waitForPositionPresent(input, symbol, Number(input.node?.timeout_ms ?? 30000));
+    }
+  } catch (error) {
+    if (!closeImmediately || error?.knownNotDispatched) throw error;
+    throw await closeAfterFailedPlacement(input, symbol, error, bound);
+  }
+  const placed = { action: input.action, market: symbol, side, orderType, amount, size, leverage, limitPrice, submitted: true, result, network, policy: policy.lane, ...(houseNotional ? { houseNotional } : {}), proofPath: 'mobile-perps-controller-place-order' };
+  if (!closeImmediately) return placed;
+  return { ...placed, roundTrip: await closeOpenedPosition(input, symbol, bound) };
+}
+
+// close_immediately started from a flat market (checked before dispatch), so a
+// position in it after a failed placement is this order's: close it rather
+// than leave it open, and say what happened.
+async function closeAfterFailedPlacement(input, symbol, error, bound) {
+  const message = error instanceof Error ? error.message : String(error);
+  let outcome;
+  try {
+    if (await tradingContextChanged(input, bound)) {
+      return new Error(`${message} close_immediately: the selected account or network changed, so nothing was closed; check ${symbol} on the original account now.`);
+    }
+    const position = (await readBoundPositions(input, bound)).find((candidate) => symbolForItem(candidate) === symbol);
+    if (!position) {
+      outcome = `no ${symbol} position is open`;
+    } else {
+      await closePositionItem(fullCloseInput(input), position, bound);
+      outcome = await waitForBoundPositionAbsent(input, bound, symbol, Number(input.node?.timeout_ms ?? 30000))
+        ? `the ${symbol} position it opened was closed`
+        : `the ${symbol} position is STILL OPEN after a close; close it now`;
+    }
+  } catch (closeError) {
+    outcome = `the ${symbol} position could not be checked or closed (${closeError instanceof Error ? closeError.message : String(closeError)}); check it now`;
+  }
+  return new Error(`${message} close_immediately: ${outcome}.`);
+}
+
+async function readSizeDecimals(input, symbol) {
+  const markets = await evalAsync(
+    input,
+    `Engine.context.PerpsController.getMarkets({ symbols: [${sourceLiteral(symbol)}] }).then(function(r){return JSON.stringify((r||[]).map(function(m){return { name: m.name, szDecimals: m.szDecimals };}))})`,
+  );
+  return (Array.isArray(markets) ? markets : []).find((market) => normalizeMarketSymbol(market?.name ?? '') === symbol)?.szDecimals ?? null;
+}
+
+// The close takes the whole position: the order's own size or amount never
+// becomes a partial close size.
+function fullCloseInput(input) {
+  const { size: _size, amount: _amount, notional: _notional, ...node } = input.node ?? {};
+  return { ...input, node };
+}
+
+// Bridge sources embed values as JSON literals. JSON.stringify leaves `<`, `>`,
+// `/` and U+2028/U+2029 raw; escape them so no value can end a script context
+// or a statement in the evaluated source.
+const UNSAFE_SOURCE_CHARS = { '<': '\\u003C', '>': '\\u003E', '/': '\\u002F', '\u2028': '\\u2028', '\u2029': '\\u2029' };
+export function sourceLiteral(value) {
+  return JSON.stringify(value).replace(/[<>/\u2028\u2029]/gu, (char) => UNSAFE_SOURCE_CHARS[char]);
+}
+
+// Bridge source that resolves to { contextChanged: true } unless the selected
+// account and Perps network are still the bound ones. It runs in the same
+// evaluation as the controller call it guards, so a switch can't slip between.
+function boundContextGuard(bound) {
+  if (!bound) return '';
+  return `var __account = Engine.context.AccountsController.getSelectedAccount();
+    var __address = String((__account && __account.address) || '').toLowerCase();
+    var __network = Engine.context.PerpsController.state.isTestnet ? 'testnet' : 'mainnet';
+    if (__address !== ${sourceLiteral(bound.address)} || __network !== ${sourceLiteral(bound.network)}) {
+      return Promise.resolve(JSON.stringify({ success: false, contextChanged: true }));
+    }`;
+}
+
+// The positions of the bound account on the bound network, read in one guarded
+// evaluation; a changed context throws instead of reading another account.
+async function readBoundPositions(input, bound) {
+  const positions = await evalAsync(input, `(function(){ ${boundContextGuard(bound)}
+    return Engine.context.PerpsController.getPositions().then(function(r){return JSON.stringify(r)}); })()`);
+  if (positions?.contextChanged) {
+    throw new Error('Perps positions not read: the selected account or network changed after the order rule allowed it. Check the order\'s market on the original account now.');
+  }
+  if (!Array.isArray(positions)) throw new Error('PerpsController.getPositions returned a non-array result.');
+  return positions;
+}
+
+// The flat-market baseline: the bound account's positions and resting orders,
+// read in one evaluation with the context guard before, between and after the
+// reads, so a switch to another account's book and back can't pass as flat.
+async function readBoundBook(input, bound) {
+  const guard = `(function(){ ${boundContextGuard(bound)} return null; })()`;
+  const book = await evalAsync(input, `(function(){
+    var controller = Engine.context.PerpsController;
+    var positions;
+    return ${guard} || controller.getPositions().then(function(r){
+      positions = r;
+      return ${guard} || controller.getOpenOrders().then(function(orders){
+        return ${guard} || JSON.stringify({ positions: positions, orders: orders });
+      });
+    }); })()`);
+  if (book?.contextChanged) {
+    throw new Error('Perps order not dispatched: the selected account or network changed while the market was checked flat.');
+  }
+  if (!Array.isArray(book?.positions) || !Array.isArray(book?.orders)) {
+    throw new Error('PerpsController.getPositions or getOpenOrders returned a non-array result.');
+  }
+  return book;
+}
+
+async function waitForBoundPositionAbsent(input, bound, symbol, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const positions = await readBoundPositions(input, bound);
+    if (!positions.some((position) => symbolForItem(position) === symbol)) return true;
+    if (Date.now() >= deadline) return false;
+    await sleep(1000);
+  }
+}
+
+async function tradingContextChanged(input, bound) {
+  const runtime = await readPerpsRuntimeState(input);
+  const network = runtime?.isTestnet === true ? 'testnet' : runtime?.isTestnet === false ? 'mainnet' : null;
+  const address = String((await readSelectedAddress(input)) ?? '').toLowerCase();
+  return network !== bound.network || address !== bound.address;
+}
+
+async function readSelectedAddress(input) {
+  return evalAsync(input, 'JSON.stringify(Engine.context.AccountsController.getSelectedAccount()?.address ?? null)');
+}
+
+// close_immediately: close the position this order opened and prove the market
+// is flat. On mainnet the opened position must be isolated 1x; it is closed
+// either way before that check fails the action.
+async function closeOpenedPosition(input, symbol, bound) {
+  const { network } = bound;
+  if (await tradingContextChanged(input, bound)) {
+    throw new Error(`close_immediately did not close ${symbol}: the selected account or network changed after the order. The order's position is still open on the original account; close it now.`);
+  }
+  const position = (await readBoundPositions(input, bound)).find((candidate) => symbolForItem(candidate) === symbol);
+  if (!position) {
+    throw new Error(`close_immediately could not find the ${symbol} position the order opened; it may still fill. Check ${symbol} now and close it if it opened.`);
+  }
+  let limitError = null;
+  if (network === 'mainnet') {
+    try {
+      assertHouseLimitPosition(position, symbol);
+    } catch (error) {
+      limitError = error;
+    }
   }
-  if (orderType === 'limit') {
-    await waitForSelectedState(input, readOpenOrders, true, Number(input.node?.timeout_ms ?? 30000));
-  } else {
-    await waitForPositionPresent(input, symbol, Number(input.node?.timeout_ms ?? 30000));
+  const closed = await closePositionItem(fullCloseInput(input), position, bound);
+  if (!(await waitForBoundPositionAbsent(input, bound, symbol, Number(input.node?.timeout_ms ?? 30000)))) {
+    throw new Error(`close_immediately left the ${symbol} position open: ${JSON.stringify(redactPosition(position))}. Close it now.`);
   }
-  return { action: input.action, market: symbol, side, orderType, amount, size, leverage, limitPrice, submitted: true, result, proofPath: 'mobile-perps-controller-place-order' };
+  if (limitError) throw limitError;
+  return { opened: redactPosition(position), closed: true, result: closed.result };
 }
 
 export async function ensurePositions(input) {

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

@@ -1,8 +1,10 @@
 // Submit a Perps order through the Mobile controller and assert a matching open position.
+// With close_immediately the order's position is already closed again, so the market must be flat.
 import { runAdapter } from '../platform/bridge.mjs';
+import { closeImmediatelyRequested } from '../../shared/perps/order-policy.mjs';
 import { assertPositions, placeOrder } from './perps.mjs';
 runAdapter(async (input) => {
   const order = await placeOrder(input);
-  const assertion = await assertPositions(input, true);
+  const assertion = await assertPositions(input, !closeImmediatelyRequested(input.node));
   return { ...assertion, submitted: order.submitted === true, order };
 });

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

@@ -4,7 +4,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 
 import { runAdapter } from '../platform/bridge.mjs';
-import { resolveMobileToolPath } from '../platform/tool-paths.mjs';
+import { resolveMobileToolPath } from '@farmslot/adapter-rn';
 
 const execFileAsync = promisify(execFile);
 

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

@@ -8,10 +8,10 @@ import { promisify } from 'node:util';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import bridgeErrors from '../../../../adapters/mobile/bridge-runtime/lib/bridge-errors.cjs';
-import brokerModule from '../../../../adapters/mobile/bridge-runtime/lib/cdp-broker.cjs';
-import configModule from '../../../../adapters/mobile/bridge-runtime/lib/config.cjs';
-import { resolveMobileToolPath } from './tool-paths.mjs';
+import bridgeErrors from '@farmslot/adapter-rn/bridge-runtime/lib/bridge-errors.cjs';
+import brokerModule from '@farmslot/recipe-runner/cdp-broker';
+import configModule from '@farmslot/adapter-rn/bridge-runtime/lib/config.cjs';
+import { resolveMobileToolPath } from '@farmslot/adapter-rn';
 
 const {
   BRIDGE_ERROR_CODES,
@@ -155,8 +155,8 @@ export async function bridgeEnv(input) {
     ...(input.context?.env || {}),
     CDP_TIMEOUT: String(input.node?.cdp_timeout_ms ?? process.env.CDP_TIMEOUT ?? '10000'),
   };
-  if (adbPath) env.MM_HARNESS_ADB_PATH = adbPath;
-  if (idbPath) env.MM_HARNESS_IDB_PATH = idbPath;
+  if (adbPath) env.RECIPE_RN_ADB_PATH = adbPath;
+  if (idbPath) env.RECIPE_RN_IDB_PATH = idbPath;
   const target = resolveMobileTarget(input);
   const requestedPlatform = target.requestedPlatform;
   const watcherPort = target.watcherPort;
@@ -238,8 +238,8 @@ export function resolveMobileTarget(input) {
     input.node?.sim_udid ?? contextEnv.SIM_UDID ?? process.env.SIM_UDID;
   const configuredPlatform = String(
     input.node?.platform ??
-      contextEnv.MM_HARNESS_EXPLICIT_PLATFORM ??
-      process.env.MM_HARNESS_EXPLICIT_PLATFORM ??
+      contextEnv.RECIPE_RN_EXPLICIT_PLATFORM ??
+      process.env.RECIPE_RN_EXPLICIT_PLATFORM ??
       contextEnv.PLATFORM ??
       process.env.PLATFORM ??
       '',

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

@@ -1,7 +1,27 @@
 // Derive native session names and device-specific state directories, honoring configured overrides.
 import path from 'node:path';
 
-export function nativeSessionName(env, device, app = 'io.metamask') {
+// The host adapter supplies the app under test in the action env
+// (ANDROID_PACKAGE_ID / IOS_BUNDLE_ID, display name in
+// METAMASK_RECIPE_MOBILE_APP_LABEL); the library has no default app.
+export function nativeAppId(env, platform) {
+  const key = platform === 'android' ? 'ANDROID_PACKAGE_ID' : 'IOS_BUNDLE_ID';
+  const app = String(env[key] ?? '').trim();
+  if (!app) {
+    throw new Error(`Mobile native UI needs the app identity in ${key}. Next: run through mm-harness run or call, or set ${key}.`);
+  }
+  return app;
+}
+
+export function nativeAppLabel(env) {
+  const label = String(env.METAMASK_RECIPE_MOBILE_APP_LABEL ?? '').trim();
+  if (!label) {
+    throw new Error('Mobile native UI needs the app display name in METAMASK_RECIPE_MOBILE_APP_LABEL. Next: run through mm-harness run or call, or set METAMASK_RECIPE_MOBILE_APP_LABEL.');
+  }
+  return label;
+}
+
+export function nativeSessionName(env, device, app) {
   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/native-session.mjs

@@ -1,6 +1,6 @@
 // Create device-targeted native UI sessions for actions and accessibility snapshots.
 // Opening an instrumented iOS session hides the accessibility-masking HUD.
-import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
+import { createAgentDeviceUiTransport } from '@farmslot/adapter-rn';
 import { createAgentDeviceClient } from 'agent-device';
 
 import { resolveMobileTarget } from './bridge.mjs';
@@ -8,6 +8,7 @@ import { hideAccessibilityMaskingHud } from './observe-ui.mjs';
 
 import {
   nativeAgentDeviceStateDir,
+  nativeAppId,
   nativeSessionName,
 } from './native-session-name.mjs';
 
@@ -19,9 +20,7 @@ export function createNativeSession(input, domain, sessionSuffix = '') {
     ? target.adbSerial ?? ''
     : input.node?.sim_udid ?? env.SIM_UDID ?? target.iosSimulator ?? '').trim();
   if (!device) throw new Error(`Mobile ${domain} native actions require one explicit ${platform} device. Next: pass --device <device>.`);
-  const app = String(platform === 'android'
-    ? env.ANDROID_PACKAGE_ID ?? 'io.metamask'
-    : env.IOS_BUNDLE_ID ?? 'io.metamask.MetaMask');
+  const app = nativeAppId(env, platform);
   const baseSession = nativeSessionName(env, device, app);
   const session = sessionSuffix
     ? `${baseSession}-${String(sessionSuffix).replace(/[^A-Za-z0-9._-]/gu, '-')}`.slice(0, 120)

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

@@ -7,9 +7,11 @@ import { createAgentDeviceClient } from 'agent-device';
 import { bridgeCommand } from './bridge.mjs';
 import {
   nativeAgentDeviceStateDir,
+  nativeAppId,
+  nativeAppLabel,
   nativeSessionName,
 } from './native-session-name.mjs';
-import { mobileToolRecovery, resolveMobileToolPath } from './tool-paths.mjs';
+import { mobileToolRecovery, resolveMobileToolPath } from '@farmslot/adapter-rn';
 
 const execFileAsync = promisify(execFile);
 const VISIBLE_LIMIT = 200;
@@ -93,8 +95,13 @@ async function readNativeHierarchy(payload, context) {
     env.METAMASK_RECIPE_PROJECT_ROOT = String(context.projectRoot);
   }
   const platform = resolvePlatform(node, env);
-  if (platform === 'android') return readAndroidHierarchy(node, env);
-  return readIosHierarchy(node, env);
+  const appLabel = nativeAppLabel(env);
+  const hierarchy = platform === 'android'
+    ? await readAndroidHierarchy(node, env)
+    : await readIosHierarchy(node, env);
+  // No screen name and no labelled item: name the screen after the app.
+  hierarchy.screen.name ??= appLabel;
+  return hierarchy;
 }
 
 async function readIosHierarchy(node, env) {
@@ -166,7 +173,7 @@ async function readAndroidHierarchy(node, env) {
 }
 
 async function readAndroidAgentDeviceHierarchy(serial, env) {
-  const app = text(env.ANDROID_PACKAGE_ID) ?? 'io.metamask';
+  const app = nativeAppId(env, 'android');
   const session = nativeSessionName(env, serial, app);
   const stateDir = nativeAgentDeviceStateDir(env, env.METAMASK_RECIPE_PROJECT_ROOT ?? process.cwd(), serial);
   const client = createAgentDeviceClient({
@@ -257,8 +264,7 @@ function normalizedHierarchy(
   const items = nodes.slice(0, VISIBLE_LIMIT);
   const hiddenOrOffscreen = hiddenNodes.slice(0, HIDDEN_LIMIT);
   const name = metadata.screenName ??
-    items.find((item) => item.label)?.label ??
-    'MetaMask';
+    items.find((item) => item.label)?.label;
   return {
     screen: {
       provider,

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

@@ -1,9 +1,10 @@
 // Navigate Android Home, Swap, and Perps through native controls and verify visible destinations.
 // Switch Perps Lite or Pro mode through visible controls on Android and iOS.
-import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
+import { createAgentDeviceUiTransport } from '@farmslot/adapter-rn';
 import { createAgentDeviceClient } from 'agent-device';
 import {
   nativeAgentDeviceStateDir,
+  nativeAppId,
   nativeSessionName,
 } from '../platform/native-session-name.mjs';
 import { bridgeCommand } from '../platform/bridge.mjs';
@@ -51,7 +52,7 @@ export async function navigateOpaqueMobile(input, destination) {
   if (!device) {
     throw new Error('Opaque Mobile navigation requires one explicit Android device serial.');
   }
-  const app = String(env.ANDROID_PACKAGE_ID ?? 'io.metamask');
+  const app = nativeAppId(env, 'android');
   const session = nativeSessionName(env, device, app);
   const stateDir = nativeAgentDeviceStateDir(env, input.context.projectRoot, device);
   const client = createAgentDeviceClient({
@@ -184,7 +185,7 @@ export async function ensureVisibleAndroidPerpsMode(input, perpsMode) {
       'Android Perps mode requires one explicit device serial.',
     );
   }
-  const app = String(env.ANDROID_PACKAGE_ID ?? 'io.metamask');
+  const app = nativeAppId(env, 'android');
   const session = nativeSessionName(env, device, app);
   const stateDir = nativeAgentDeviceStateDir(env, input.context.projectRoot, device);
   const client = createAgentDeviceClient({

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

@@ -1,9 +1,10 @@
 // Drive Android wallet onboarding, lock, unlock, and reset through native accessibility.
 // Wallet observations can navigate home and open the address list to verify the selected account.
-import { createAgentDeviceUiTransport } from '@farmslot/expo-recipe';
+import { createAgentDeviceUiTransport } from '@farmslot/adapter-rn';
 import { createAgentDeviceClient } from 'agent-device';
 import {
   nativeAgentDeviceStateDir,
+  nativeAppId,
   nativeSessionName,
 } from '../platform/native-session-name.mjs';
 
@@ -249,7 +250,7 @@ function nativeSession(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 UI execution requires one explicit Android device serial.');
-  const app = String(env.ANDROID_PACKAGE_ID ?? 'io.metamask');
+  const app = nativeAppId(env, 'android');
   const session = nativeSessionName(env, device, app);
   const stateDir = nativeAgentDeviceStateDir(env, input.context.projectRoot, device);
   const client = createAgentDeviceClient({

package/library/actions/shared/analytics/_adapter.mjs

@@ -1,6 +1,6 @@
 // Minimal adapter IO for the shared analytics actions.
 //
-// Mirrors the live-adapter contract in src/live-adapter-contract.ts. Neither
+// Mirrors the live-adapter contract in @farmslot/recipe-cli/harness. Neither
 // existing runAdapter fits: extension's lives under actions/extension/platform
 // and core's carries PerpsController teardown and expect_error handling. A
 // `shared/` action importing either would couple every platform to one of them,

package/library/actions/shared/console-findings.mjs

@@ -1,6 +1,6 @@
 // The one console matcher: classify application console events and apply a
 // recipe-library allowlist of known noise. Used by run diagnostics
-// (src/run-diagnostics.ts), the assert_no_console_errors action, the
+// (src/console-classifier.ts), the assert_no_console_errors action, the
 // allowlist generator, and the recipe library's checks/console-guard.mjs
 // (which imports this file), so every caller judges an event the same way.
 //