@deeeed/metamask-harness 0.87.0 → 0.89.0

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## Unreleased
 
+## 0.89.0 - 2026-10-11
+
+### Added
+
+- Export the canonical command grammar with the provider so shared hosts validate domain options before constructing an executing provider.
+
+### Changed
+
+- Pin recipe-runner 0.29.0, recipe-cli 0.13.0, adapter-sdk 0.8.6, adapter-node 0.1.12, adapter-rn 0.19.10 and adapter-web 0.6.10 so the provider shares the generic host's signal-aware execution and finalization runtime. Protocol and agent-runtime stay at their current published versions.
+
+## 0.88.0 - 2026-10-11
+
+### Added
+
+- Public `createProvider` and `providerHost` exports for shared recipe commands. The provider reuses MetaMask adapters and funding authorization, loads selected plugins from authorized libraries, and supplies run-owned mainnet cancellation and teardown for explicit runs through the existing abort helper. With the coordinated recipe-cli update, doctor, discovery and recipe previews validate funding policy without creating execution claims, artifact directories or mutation ledgers. Explicit execution still binds the funded plan. Run ownership uses `RECIPE_RUN_OWNER_PID`, preserving approval across invoking processes with the coordinated runner update.
+- Mainnet limit orders on Mobile and Extension `place_order`: Hyperliquid only, from `dev1` only, 1x isolated, at most $15 at the limit price (plus one size step), away from the live market price and sent post-only, with `network: mainnet`. Each one lasts one run: it is tracked before dispatch, and the run cancels whatever is still open when it ends, on success, failure or abort by signal (after a kill, the next run on the checkout), counting it gone only when the Hyperliquid API no longer lists it for the placing address, and writing order ID, cancel result and both reads to `<artifacts>/perps-mainnet-orders.json`. An order that cannot be proven cancelled, or that filled, fails the run with `PERPS_MAINNET_ORDER_LEFT_OPEN`. More than 1x or $15, another account, a `current_price` override, Core, and `ensure_*` opening state stay refused.
+- Extension `metamask.perps.set_network` (default `testnet`): `network=mainnet` switches Perps to mainnet for one run, and the run switches back to testnet at its end.
+
+### Changed
+
+- Pin the coordinated provider runtime: protocol 0.37.0, recipe-runner 0.28.5, recipe-cli 0.12.0, adapter-sdk 0.8.5, adapter-node 0.1.11, adapter-rn 0.19.9, adapter-web 0.6.9 and agent-runtime 0.17.5. Planning uses the read-only policy hook, and approval survives a new run owner while substantive inputs stay bound. Plan JSON now includes `executionPlan` and the `preflight.recipe` step; command context includes `runtimeConfigPath`. Human plans list resolved libraries and describe the artifact directory as "resolved at run time".
+- When capture interruption is the run's only failure, `run`/`call` report `CAPTURE_INTERRUPTED` as `retryable: true` with exit 4. The report links the partial video as "evidence incomplete (capture interrupted)", and proven acceptance criteria become `weak` with that note.
+- A Mobile recording that stopped mid-run but kept a partial video now fails as `CAPTURE_INTERRUPTED`, with the video published and its manifest entry's `interruption`. Previously, the run passed with `recorder.interrupted`. This covers capture-helper 0.3.1 on the emulator mirror and on-device screenrecord. With no video kept, capture-helper fails as `RECORDING_FAILED`; interrupted on-device screenrecord fails as `RECORDER_INTERRUPTED`.
+- `scripts/validate-release-report.mjs` requires `BLOCKED_ENVIRONMENT` and "evidence incomplete (capture interrupted)" when every cited run failed only on `CAPTURE_INTERRUPTED`. Retaining an interrupted attempt preserves a passing or product-failing retry's verdict.
+- On mainnet, `close_orders` cancels only orders the run placed, on Mobile and in the Extension's fixture-policy lane; any other order is refused before dispatch with `PERPS_MAINNET_ORDER_REFUSED`.
+
+### Fixed
+
+- Mobile launch readiness uses the shared adapter-rn matcher for physical Android bridge names. "Google Pixel 6a" matches the "Pixel 6a" device pin; whole-model boundaries and emulator rejection remain enforced. The published adapter-rn 0.19.7 dependency also applies this rule when checking the ready route.
+- Extension: a kept slot profile in which Chrome had disabled MetaMask (for example `disable_reasons: [16777216]`, `DISABLE_UNSUPPORTED_DEVELOPER_EXTENSION`, in `Default/Secure Preferences` on Chrome for Testing 147) no longer blocks every launch with `ERR_BLOCKED_BY_CLIENT`. `--load-extension` re-registers the build but keeps a persisted disable reason, so the launch now stops the profile's browser, clears the reason for the harness extension only (in `Preferences` and `Secure Preferences`, other extensions untouched) and logs the reasons it cleared. The reopen path (`ensure-browser.sh`) uses the same heal, which before rewrote only `Preferences` and re-enabled every extension. When readiness still finds MetaMask blocked, it names the reason (`MetaMask is disabled in the slot profile: DISABLE_UNSUPPORTED_DEVELOPER_EXTENSION`) instead of reporting a Chrome error page.
+
 ## 0.87.0 - 2026-10-10
 
 ### Changed
@@ -25,6 +56,8 @@
 - Mobile `ui.wait_for expected=absent` no longer times out on a control that only a screen hidden in the navigation stack still mounts. The app's tree query also finds test IDs in screens a navigator keeps behind the focused one (the Activity screen's `activity-screen-aggregated-checkbox` under Perps home). A tree hit now counts as absent only when every match is on a provably hidden route (an inactive tab, or a stack screen that is neither modal-presented nor inheriting a modal presentation, with a screen above it that is not modal either) and a complete native observation, read within the wait's remaining time, does not show the test ID. The result then carries `hiddenRoute: true` and `nativeVisible: false`. A modal-family screen, and any screen under a sheet or transparent modal, is never treated as hidden, even when native accessibility omits its controls; a truncated or warned native observation, or a navigator the walk cannot read, keeps the control present. Present-waits are unchanged.
 - Extension `metamask.perps.read_snapshot` states that its `history` section is the funds ledger from `perpsGetUserHistory` (deposits, withdrawals and transfers), not trades or orders. Zero history items with trade rows on screen is expected; read those rows with `read_visible_state` activity.
 
+- Contributors: test leftovers that only run in a sandbox no longer outlive the suites. A server a test started detached in its temp dir (the `mobile-cdp-reliability` fake Metro server, the prepared analytics collector) named nothing of it, so neither the process-group kill nor `ct_cleanup` found it, and some ran for days. `tests/contract/run.sh` now kills a detached leftover that names a test's sandbox when the test ends. After the run, it kills anything still running in a sandbox (working directory), names it on a `LEAK <test> (after the run)` line, and fails the run. Before starting, the contract runner and the unit run's global setup reap an earlier run that was killed outright, and a SIGKILLed contract runner's remover stops what still runs in its sandboxes before removing them. The unit teardown also stops processes running in its TMPDIR. Eight contract tests that replaced `ct_init`'s EXIT trap now end in `ct_cleanup`, and `contract-cleanup` fails a test that drops it.
+
 ## 0.86.2 - 2026-10-09
 
 ### Fixed

package/adapters/extension/ensure-browser.sh

@@ -230,12 +230,9 @@ cleanup_stale_profile_locks
 rm -f "${AGENT_DIR}/browser.pid" "${AGENT_DIR}/extension.id" "${AGENT_DIR}/launcher.pid"
 echo "[cleanup] Reusing profile ${PROFILE}"
 
-# Clear crash recovery state + re-enable any previously-disabled extensions
-# (profile Preferences persists extensions.settings.<id>.state=0 after unsafe
-# shutdowns; --load-extension re-advertises the path but does not flip it back,
-# leaving MV3 service workers inert).
+# Clear crash recovery state left by an unsafe shutdown.
 if [ -f "${PROFILE}/Default/Preferences" ]; then
-  python3 - "${PROFILE}/Default/Preferences" 2>/dev/null <<'PY' && echo "[cleanup] Cleared crash recovery state + re-enabled extensions"
+  python3 - "${PROFILE}/Default/Preferences" 2>/dev/null <<'PY' && echo "[cleanup] Cleared crash recovery state"
 import json
 import sys
 pf = sys.argv[1]
@@ -243,14 +240,13 @@ prefs = json.load(open(pf))
 prefs['profile'] = prefs.get('profile', {})
 prefs['profile']['exit_type'] = 'Normal'
 prefs['profile']['exited_cleanly'] = True
-ext_settings = prefs.get('extensions', {}).get('settings', {})
-for ext_id, ext_prefs in ext_settings.items():
-    if isinstance(ext_prefs, dict) and ext_prefs.get('state') != 1:
-        ext_prefs['state'] = 1
-        ext_prefs.pop('disable_reasons', None)
 json.dump(prefs, open(pf, 'w'))
 PY
 fi
+# Re-enable MetaMask when the profile kept it disabled: --load-extension
+# re-advertises the path but does not lift a persisted disable reason, leaving
+# every extension page blocked and the MV3 service worker inert.
+node "${SCRIPT_DIR}/profile-extension-state.cjs" --profile "${PROFILE}" --extension-dir "${EXTENSION}"
 
 # Readiness gate: wait until webpack emits a loadable background entry before
 # freezing dist/chrome. The entry differs by manifest version — MV3 emits

package/adapters/extension/inject.mjs

@@ -96,6 +96,7 @@ fs.rmSync(path.join(harnessDir, 'runner/library.json'), { force: true });
 // package's source layout.
 copyFile(path.join(runnerDir, 'adapters/extension/launch-browser.cjs'), path.join(harnessDir, 'scripts/launch-browser.cjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/build-handoff.cjs'), path.join(harnessDir, 'scripts/build-handoff.cjs'));
+copyFile(path.join(runnerDir, 'adapters/extension/profile-extension-state.cjs'), path.join(harnessDir, 'scripts/profile-extension-state.cjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/console-tail.mjs'), path.join(harnessDir, 'scripts/console-tail.mjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/launch.sh'), path.join(harnessDir, 'scripts/launch.sh'));
 copyFile(path.join(runnerDir, 'adapters/extension/live.sh'), path.join(harnessDir, 'scripts/live.sh'));

package/adapters/extension/launch-browser.cjs

@@ -4,7 +4,9 @@
 // Runs @farmslot/adapter-web's launchBrowser with what MetaMask owns: the
 // build-handoff lock (no build swaps the dist mid-launch), home.html and its
 // "MetaMask" title, the harness runtime layouts that prove a browser is ours by
-// its --load-extension path, and the mm-harness rerun command.
+// its --load-extension path, and the mm-harness rerun command. A real launch
+// into a kept profile first clears a stale disable mark Chrome left on MetaMask
+// (profile-extension-state.cjs), which --load-extension alone does not lift.
 //
 // Inputs (flags, all required unless noted):
 //   --cdp-port <port> --chrome-bin <path> --profile <dir>
@@ -21,6 +23,7 @@
 const path = require('node:path');
 const { launchBrowser } = require('@farmslot/adapter-web/launch-browser');
 const { acquireBuildHandoff } = require('./build-handoff.cjs');
+const { clearExtensionDisable, extensionDisableReasons } = require('./profile-extension-state.cjs');
 
 if (process.argv.includes('--help') || process.argv.includes('-h')) {
   console.log(
@@ -33,7 +36,7 @@ const args = parseArgs(process.argv.slice(2));
 const cdpPort = Number(args['cdp-port']);
 // Checked here so the error echoes the flag as typed.
 if (!Number.isInteger(cdpPort) || cdpPort <= 0) throw new Error(`Invalid --cdp-port: ${args['cdp-port'] || ''}`);
-launchBrowser({
+const options = {
   cdpPort,
   chromeBin: args['chrome-bin'],
   profile: args.profile,
@@ -48,11 +51,35 @@ launchBrowser({
   homePage: 'home.html',
   defaultTitle: 'MetaMask',
   extensionOwnerRoot: harnessOwnerRootFromExtensionDir,
-  acquireRuntimeLock: acquireBuildHandoff,
+  acquireRuntimeLock: acquireLaunchLock,
   rerunCommand: 'mm-harness launch --adapter extension --build',
   // Unset or invalid falls back to the package default (1000 ms).
   focusSettleMs: Number(process.env.MM_HARNESS_FOCUS_SETTLE_MS),
-});
+};
+launchBrowser(options);
+
+// The build-handoff lock, taken once launchBrowser has checked its inputs and
+// before it stops or starts a browser. A real launch into a profile that keeps
+// MetaMask disabled first releases the profile through launchBrowser's own
+// ownership checks (Chrome rewrites its prefs from memory on exit), then clears
+// the mark. The lock is already held, so that stop does not take it again.
+function acquireLaunchLock(runtimeDir) {
+  const release = acquireBuildHandoff(runtimeDir);
+  try {
+    if (
+      !options.stopOnly &&
+      !options.resetProfile &&
+      extensionDisableReasons(options.profile, options.extensionDir).length > 0
+    ) {
+      launchBrowser({ ...options, stopOnly: true, acquireRuntimeLock: undefined });
+      clearExtensionDisable(options.profile, options.extensionDir);
+    }
+  } catch (error) {
+    release();
+    throw error;
+  }
+  return release;
+}
 
 function parseArgs(argv) {
   const parsed = {};

package/adapters/extension/profile-extension-state.cjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+// profile-extension-state.cjs — the harness extension's disable mark in a slot profile
+//
+// Chrome keeps extensions.settings.<id>.disable_reasons across relaunches, and
+// --load-extension re-registers the unpacked build without clearing them, so a
+// reason recorded once (for example DISABLE_UNSUPPORTED_DEVELOPER_EXTENSION)
+// blocks every MetaMask page (ERR_BLOCKED_BY_CLIENT) on each later launch.
+// Chrome stores extensions.settings in Default/Secure Preferences or
+// Default/Preferences depending on the version, so both are read.
+//
+// clearExtensionDisable drops disable_reasons and a non-enabled legacy state
+// from this extension's entry only (matched by its manifest-key id or its load
+// path); other extensions are never touched. A file is rewritten atomically and
+// only when it changes; a missing or unreadable file is left alone. Chrome must
+// not be running on the profile: it rewrites its prefs from memory on exit. The
+// Secure Preferences MAC is left stale; Chrome accepts the edited entry.
+//
+// CLI: profile-extension-state.cjs --profile <dir> --extension-dir <dist>
+// Clears and prints one line when it did. Exit 0 — cleared or nothing to clear;
+// non-zero — bad args or an unwritable prefs file.
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { extensionIdFromExtensionDir } = require('@farmslot/adapter-web/extension-id');
+
+const PREFS_FILES = ['Secure Preferences', 'Preferences'];
+
+// Names from Chromium extensions/browser/disable_reason.h (Chrome 147).
+const DISABLE_REASONS = {
+  [1 << 0]: 'DISABLE_USER_ACTION',
+  [1 << 1]: 'DISABLE_PERMISSIONS_INCREASE',
+  [1 << 2]: 'DISABLE_RELOAD',
+  [1 << 3]: 'DISABLE_UNSUPPORTED_REQUIREMENT',
+  [1 << 4]: 'DISABLE_SIDELOAD_WIPEOUT',
+  [1 << 5]: 'DEPRECATED_DISABLE_UNKNOWN_FROM_SYNC',
+  [1 << 8]: 'DISABLE_NOT_VERIFIED',
+  [1 << 9]: 'DISABLE_GREYLIST',
+  [1 << 10]: 'DISABLE_CORRUPTED',
+  [1 << 11]: 'DISABLE_REMOTE_INSTALL',
+  [1 << 13]: 'DISABLE_EXTERNAL_EXTENSION',
+  [1 << 14]: 'DISABLE_UPDATE_REQUIRED_BY_POLICY',
+  [1 << 15]: 'DISABLE_CUSTODIAN_APPROVAL_REQUIRED',
+  [1 << 16]: 'DISABLE_BLOCKED_BY_POLICY',
+  [1 << 19]: 'DISABLE_REINSTALL',
+  [1 << 20]: 'DISABLE_NOT_ALLOWLISTED',
+  [1 << 21]: 'DEPRECATED_DISABLE_NOT_ASH_KEEPLISTED',
+  [1 << 22]: 'DISABLE_PUBLISHED_IN_STORE_REQUIRED_BY_POLICY',
+  [1 << 23]: 'DISABLE_UNSUPPORTED_MANIFEST_VERSION',
+  [1 << 24]: 'DISABLE_UNSUPPORTED_DEVELOPER_EXTENSION',
+  [1 << 25]: 'DISABLE_UNKNOWN',
+  [1 << 26]: 'DISABLE_BLOCKED_BY_CLOUD_POLICY_CHECK',
+};
+
+// Chrome 147 stores a list of single-bit reasons; older builds one bitmask.
+function disableReasonNames(value) {
+  const names = [];
+  for (const reason of Array.isArray(value) ? value : [value]) {
+    if (!Number.isInteger(reason)) continue;
+    for (let bit = 0; bit < 31; bit += 1) {
+      const flag = 1 << bit;
+      if (reason & flag) names.push(DISABLE_REASONS[flag] || `DISABLE_REASON_${flag}`);
+    }
+  }
+  return names;
+}
+
+// Why this entry is disabled; empty when it is not.
+function entryDisableNames(entry) {
+  const names = disableReasonNames(entry.disable_reasons);
+  if (entry.state !== undefined && entry.state !== 1) names.push(`state=${JSON.stringify(entry.state)}`);
+  return names;
+}
+
+function readPrefs(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// This extension's entries in one prefs document, with why each is disabled.
+function ownDisabledEntries(prefs, extensionDir) {
+  const settings = prefs?.extensions?.settings;
+  if (!settings || typeof settings !== 'object') return [];
+  const extensionId = extensionIdFromExtensionDir(extensionDir);
+  const loadPath = path.resolve(extensionDir);
+  return Object.entries(settings)
+    .filter(([id, entry]) =>
+      entry &&
+      typeof entry === 'object' &&
+      ((extensionId && id === extensionId) ||
+        (typeof entry.path === 'string' && path.isAbsolute(entry.path) && path.resolve(entry.path) === loadPath)))
+    .map(([id, entry]) => ({ id, entry, names: entryDisableNames(entry) }))
+    .filter(({ names }) => names.length > 0);
+}
+
+function prefsFiles(profile) {
+  return PREFS_FILES.map((name) => path.join(profile, 'Default', name));
+}
+
+/** Why the profile keeps this extension disabled; empty when it does not. */
+function extensionDisableReasons(profile, extensionDir) {
+  const names = prefsFiles(profile).flatMap((file) =>
+    ownDisabledEntries(readPrefs(file), extensionDir).flatMap(({ names: entryNames }) => entryNames));
+  return [...new Set(names)];
+}
+
+/** Re-enable this extension in a stopped profile; returns the reasons cleared. */
+function clearExtensionDisable(profile, extensionDir, log = (line) => process.stderr.write(`${line}\n`)) {
+  const cleared = new Set();
+  const ids = new Set();
+  for (const file of prefsFiles(profile)) {
+    const prefs = readPrefs(file);
+    const disabled = ownDisabledEntries(prefs, extensionDir);
+    if (disabled.length === 0) continue;
+    for (const { id, entry, names } of disabled) {
+      delete entry.disable_reasons;
+      if (entry.state !== 1) delete entry.state;
+      ids.add(id);
+      for (const name of names) cleared.add(name);
+    }
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(prefs), { mode: fs.statSync(file).mode & 0o777 });
+    fs.renameSync(tmp, file);
+  }
+  if (cleared.size > 0) {
+    log(`[profile] Re-enabled MetaMask (${[...ids].join(', ')}) in ${profile}; cleared: ${[...cleared].join(', ')}`);
+  }
+  return [...cleared];
+}
+
+module.exports = { clearExtensionDisable, disableReasonNames, extensionDisableReasons };
+
+if (require.main === module) {
+  const usage = 'Usage: profile-extension-state.cjs --profile <dir> --extension-dir <dist>';
+  if (process.argv.includes('--help') || process.argv.includes('-h')) {
+    console.log(usage);
+    process.exit(0);
+  }
+  const args = {};
+  const argv = process.argv.slice(2);
+  for (let i = 0; i < argv.length; i += 2) {
+    if (!['--profile', '--extension-dir'].includes(argv[i]) || i + 1 >= argv.length) {
+      console.error(usage);
+      process.exit(2);
+    }
+    args[argv[i].slice(2)] = argv[i + 1];
+  }
+  if (!args.profile || !args['extension-dir']) {
+    console.error(usage);
+    process.exit(2);
+  }
+  clearExtensionDisable(args.profile, args['extension-dir'], (line) => console.log(line));
+}

package/adapters/extension/readiness.mjs

@@ -366,13 +366,32 @@ function findPageTarget(targets, selectedExtensionId, preferredPagePath = '') {
   return extensionPages.reduce((best, current) => (score(current) > score(best) ? current : best), extensionPages[0]);
 }
 
+// A disable reason the slot profile kept on MetaMask blocks every extension
+// page (ERR_BLOCKED_BY_CLIENT); name it instead of the symptom. The profile is
+// the one the launch recorded for this browser.
+function blockedExtensionMessage(target, symptom) {
+  let reasons = [];
+  try {
+    const record = JSON.parse(fs.readFileSync(path.join(target, recipeRuntimeDir(), 'browser-resolution.json'), 'utf8'));
+    const profile = record?.launch?.profile;
+    if (typeof profile === 'string' && profile) {
+      const { extensionDisableReasons } = require('./profile-extension-state.cjs');
+      reasons = extensionDisableReasons(profile, extensionBuildRoot(target));
+    }
+  } catch {
+    return symptom;
+  }
+  if (reasons.length === 0) return symptom;
+  return `MetaMask is disabled in the slot profile: ${reasons.join(', ')}. Next: mm-harness launch --adapter extension --build`;
+}
+
 async function inspectCdp(target, cdpPort, expectedExtensionId, expectedServiceWorker, extensionPagePath) {
   const version = await httpJson(`http://127.0.0.1:${cdpPort}/json/version`);
   let targets = await httpJson(`http://127.0.0.1:${cdpPort}/json/list`);
   if (!Array.isArray(targets)) throw new Error('/json/list did not return an array');
   let { extensionIds, selectedExtensionId } = chooseExtensionId(targets, expectedExtensionId, expectedServiceWorker);
   if (!selectedExtensionId) {
-    throw new Error('CDP is reachable but no chrome-extension:// targets are present');
+    throw new Error(blockedExtensionMessage(target, 'CDP is reachable but no chrome-extension:// targets are present'));
   }
   let pageTarget = findPageTarget(targets, selectedExtensionId, extensionPagePath);
   let openedPage = false;
@@ -422,7 +441,7 @@ async function inspectCdp(target, cdpPort, expectedExtensionId, expectedServiceW
         ui.hasStartupError ||
         ui.hasErrorBoundary
       ) {
-        throw Object.assign(new Error('MetaMask extension page loaded Chrome error UI'), {
+        throw Object.assign(new Error(blockedExtensionMessage(target, 'MetaMask extension page loaded Chrome error UI')), {
           report: { cdp: { browser: version.Browser || 'unknown', selectedExtensionId, ui } },
         });
       }

package/adapters/manifest.json

@@ -250,6 +250,14 @@
       "inputs": "--cdp-port --chrome-bin --profile --extension-dir --chrome-log --chrome-pid [--browser-resolution] [--start-url] [--stop-only 1] [--reset-profile 1]",
       "outputs": "pid file + append-log + <runtime>/browser-resolution.json; exit 0 / non-zero"
     },
+    {
+      "id": "extension/profile-extension-state",
+      "entry": "adapters/extension/profile-extension-state.cjs",
+      "kind": "node",
+      "purpose": "Clear a stale Chrome disable mark (disable_reasons / non-enabled state) on the harness extension only, in a stopped slot profile's Preferences and Secure Preferences; decode the reasons for readiness errors.",
+      "inputs": "--profile --extension-dir",
+      "outputs": "rewrites <profile>/Default/{Preferences,Secure Preferences} only when the extension was disabled; one line naming the cleared reasons; exit 0 / non-zero"
+    },
     {
       "id": "extension/refresh-build",
       "entry": "adapters/extension/refresh-build.sh",

package/adapters/mobile/wait-for-bridge.cjs

@@ -14,6 +14,7 @@ const {
   describeRequested,
   describeTargets,
   hasMatchingRoute,
+  manufacturerNameMatches,
 } = require('@farmslot/adapter-rn/bridge-runtime/lib/match-bridge-target.cjs');
 const {
   rankRuntimeCandidates,
@@ -179,9 +180,14 @@ function snapshotMatchesRequest(snapshot, platform, env) {
     if (snapshot.platform && snapshot.platform !== 'android') return false;
     const androidName =
       env.ANDROID_TARGET_DEVICE_NAME || env.ANDROID_DEVICE || '';
-    return androidName
-      ? deviceName === androidName || deviceName.startsWith(`${androidName} -`)
-      : snapshot.platform === 'android';
+    const adbSerial = env.ADB_SERIAL || env.ANDROID_SERIAL || '';
+    if (!androidName) return snapshot.platform === 'android';
+    if (deviceName === androidName || deviceName.startsWith(`${androidName} -`)) {
+      return true;
+    }
+    // Metro names the target "Pixel 6a - 17 - API 37", but the bridge snapshot
+    // of a physical device carries the manufacturer: "Google Pixel 6a".
+    return manufacturerNameMatches(deviceName, androidName, adbSerial);
   }
   return !platform;
 }

package/dist/adapters/extension/actions.js

@@ -20,7 +20,8 @@ const extensionActions = {
     "metamask.perps.update_position_tpsl",
     "metamask.perps.assert_visible_consistency",
     "metamask.settings.set_basic_functionality",
-    "metamask.perps.read_snapshot"
+    "metamask.perps.read_snapshot",
+    "metamask.perps.set_network"
   ],
   liveNeedsCdpPort: true,
   cdpTarget: { transport: "chrome-extension-cdp", probePath: "json/version" },

package/dist/adapters/extension/run.js

@@ -45,6 +45,12 @@ const extensionRun = {
     return async () => refuseLockedSession(json, options) ?? ensureExtensionProofRuntime(target, heal, state, json, { onRecovery });
   },
   launchedBrowser: (target, artifactsDir, cdpPort) => launchedBrowser(target, artifactsDir, cdpPort),
+  // Cancel the mainnet limit orders the run opened and switch Perps back to
+  // testnet after a start_state network=mainnet; a failure fails the run.
+  async teardown(projectRoot, env) {
+    const { cancelRunMainnetOrders } = await import("../perps-mainnet-cleanup.js");
+    await cancelRunMainnetOrders(projectRoot, env, "teardown");
+  },
   browserProvenance: (browser) => ({
     browser: browser.browser,
     browser_version: browser.version,

package/dist/adapters/mobile/android-screenrecord.js

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { createAndroidVideoRecorder } from "@farmslot/adapter-rn";
 import { optionalVideoTiming } from "@farmslot/recipe-runner";
-import { interruptedRecorder, recordingFailure } from "./recording-outcome.js";
+import { recordingFailure } from "./recording-outcome.js";
 const SEGMENT_SECONDS = 180;
 const START_TIMEOUT_MS = 5e3;
 const STOP_TIMEOUT_MS = 1e4;
@@ -196,11 +196,15 @@ async function startRecording(serial, request, adb, options) {
         return {
           ...timing.timing ? { timing: { ...timing.timing, clock: { ...timing.timing.clock, latestZeroUnixMs: latestVideoZero(timing.timing, placed) } } } : timing,
           timingEvidencePath,
-          recorder: interruption ? interruptedRecorder(
-            recorder,
-            interruption,
-            timing.timing ? { coveredMs: [0, timing.timing.framesMs.at(-1)] } : { coverageUnavailableReason: timing.timingUnavailableReason ?? "video timing unavailable" }
-          ) : recorder
+          recorder,
+          // The runner keeps the files finished before the failure and fails the run as CAPTURE_INTERRUPTED.
+          ...interruption ? {
+            interruption: {
+              frames: timing.timing?.framesMs.length ?? 0,
+              mediaTimeMs: timing.timing?.framesMs.at(-1) ?? 0,
+              cause: interruption
+            }
+          } : {}
         };
       } finally {
         abandon();

package/dist/adapters/mobile/recording-outcome.js

@@ -1,34 +1,8 @@
-import fs from "node:fs";
-import path from "node:path";
-import { errorMessage, manifestTarget, readCaptureHelperTiming, RecipeExecutionError } from "@farmslot/recipe-runner";
+import { errorMessage, RecipeExecutionError } from "@farmslot/recipe-runner";
 function recordingFailure(code, cause) {
   const reason = cause.trim().replace(/[\s.:]+$/u, "");
   return new RecipeExecutionError("environment", `${code}: ${reason}. The run has no video.`, { code, details: { cause: reason } });
 }
-function interruptedRecorder(recorder, cause, coverage) {
-  const kept = "coveredMs" in coverage ? `${(coverage.coveredMs[0] / 1e3).toFixed(1)}-${(coverage.coveredMs[1] / 1e3).toFixed(1)} s` : `coverage unknown: ${coverage.coverageUnavailableReason}`;
-  process.stderr.write(`WARN: RECORDER_INTERRUPTED (${cause}): kept the partial video, ${kept}.
-`);
-  const entry = { ...recorder, interrupted: { code: "RECORDER_INTERRUPTED", cause, ...coverage } };
-  return entry;
-}
-function streamInterruption(text) {
-  for (const line of text.split("\n")) {
-    if (!line.includes("stream_interrupted")) continue;
-    try {
-      const event = JSON.parse(line.slice(line.indexOf("{"), line.lastIndexOf("}") + 1));
-      if (event.type !== "error" || event.code !== "stream_interrupted") continue;
-      const mediaTimeMs = typeof event.media_time_ms === "number" && event.media_time_ms >= 0 ? event.media_time_ms : void 0;
-      return {
-        cause: `stream_interrupted: ${typeof event.cause === "string" ? event.cause : "capture stream stopped"}`,
-        ...mediaTimeMs !== void 0 ? { mediaTimeMs } : {}
-      };
-    } catch {
-      continue;
-    }
-  }
-  return void 0;
-}
 function withRecordingOutcomes(recorder) {
   return {
     name: recorder.name,
@@ -64,21 +38,7 @@ function withRecordingOutcomes(recorder) {
           try {
             return await active.stop();
           } catch (error) {
-            const known = coded(error);
-            if (known) throw known;
-            const interruption = streamInterruption(errorMessage(error));
-            if (!interruption) throw recordingFailure("RECORDING_FAILED", errorMessage(error));
-            if (!hasBytes(request.outputPath)) throw recordingFailure("RECORDER_INTERRUPTED", interruption.cause);
-            const timing = await readCaptureHelperTiming(request.outputPath);
-            return {
-              ...timing,
-              ...timing.timing ? { timingEvidencePath: `${path.basename(request.outputPath)}.timing.json` } : {},
-              recorder: interruptedRecorder(
-                { name: "capture-helper", platform: recorder.platform, target: manifestTarget(request.target) },
-                interruption.cause,
-                interruption.mediaTimeMs !== void 0 ? { coveredMs: [0, interruption.mediaTimeMs] } : { coverageUnavailableReason: "capture-helper reported no media time" }
-              )
-            };
+            throw coded(error) ?? recordingFailure("RECORDING_FAILED", errorMessage(error));
           }
         }
       };
@@ -88,16 +48,7 @@ function withRecordingOutcomes(recorder) {
 function coded(error) {
   return error instanceof RecipeExecutionError && typeof error.code === "string" ? error : void 0;
 }
-function hasBytes(file) {
-  try {
-    return fs.statSync(file).size > 0;
-  } catch {
-    return false;
-  }
-}
 export {
-  interruptedRecorder,
   recordingFailure,
-  streamInterruption,
   withRecordingOutcomes
 };

package/dist/adapters/mobile/run.js

@@ -61,11 +61,17 @@ const mobileRun = {
   // An installed release artifact is opaque: it has no dev bridge and no
   // AgentStepHud, so there is nothing to draw the HUD with.
   autoHud: () => process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME !== "1",
-  // Always clear a HUD step the engine left on-device (a failed run strands
-  // the FAIL banner). Best-effort — never masks the run's real outcome.
+  // Cancel the mainnet limit orders the run opened (a failure fails the run),
+  // and always clear a HUD step the engine left on-device (a failed run strands
+  // the FAIL banner; best-effort, never masks the run's real outcome).
   async teardown(projectRoot, env) {
-    const { hideMobileHudOnTeardown } = await import("./ui.js");
-    await hideMobileHudOnTeardown(projectRoot, env);
+    try {
+      const { cancelRunMainnetOrders } = await import("../perps-mainnet-cleanup.js");
+      await cancelRunMainnetOrders(projectRoot, env, "teardown");
+    } finally {
+      const { hideMobileHudOnTeardown } = await import("./ui.js");
+      await hideMobileHudOnTeardown(projectRoot, env);
+    }
   },
   // A release artifact is checked before the overlay install; the loaded
   // source only matters for a development build the caller did not restart.