@deeeed/metamask-harness 0.83.0 → 0.85.0

package/dist/adapters/mobile/verify.js

@@ -4,7 +4,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { runnerDir } from "../../paths.js";
-const USAGE = "Usage: mm-harness verify --adapter mobile -- [--target <metamask-mobile>] [--artifacts-dir <dir>] [--static-only] [--platform ios|android] [--preflight-mode fast|auto|default|rebuild-native|clean] [--no-auto-start]";
+const USAGE = "Usage: mm-harness verify --adapter mobile -- [--target <metamask-mobile>] [--artifacts-dir <dir>] [--static-only] [--platform ios|android] [--watcher-port <port>] [--preflight-mode fast|auto|default|rebuild-native|clean] [--no-auto-start]";
 const ENV_FILES = [".js.env", ".env", ".env.local"];
 const PREFLIGHT_MODES = ["fast", "auto", "default", "rebuild-native", "clean"];
 const AUTO_START_TRUE = ["1", "true", "TRUE", "True", "yes", "YES", "Yes", "on", "ON", "On"];
@@ -36,6 +36,7 @@ function parseMobileVerifyArgs(argv, env = process.env) {
   let platform = env.RECIPE_HARNESS_PLATFORM || env.PLATFORM || "ios";
   let preflightMode = env.RECIPE_HARNESS_MOBILE_PREFLIGHT_MODE || "fast";
   let autoStart = env.RECIPE_HARNESS_MOBILE_AUTO_START ?? "false";
+  let watcherPort;
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     const needsValue = () => {
@@ -65,6 +66,12 @@ function parseMobileVerifyArgs(argv, env = process.env) {
         platform = value;
         break;
       }
+      case "--watcher-port": {
+        const value = needsValue();
+        if (value === void 0) return { kind: "error", message: "Missing value for --watcher-port", exitCode: 2 };
+        watcherPort = value;
+        break;
+      }
       case "--preflight-mode": {
         const value = needsValue();
         if (value === void 0) return { kind: "error", message: "Missing value for --preflight-mode", exitCode: 2 };
@@ -101,7 +108,8 @@ function parseMobileVerifyArgs(argv, env = process.env) {
       staticOnly,
       platform,
       preflightMode,
-      autoStart: AUTO_START_TRUE.includes(autoStart)
+      autoStart: AUTO_START_TRUE.includes(autoStart),
+      ...watcherPort === void 0 ? {} : { watcherPort }
     }
   };
 }
@@ -141,8 +149,8 @@ function buildMobileVerifySummary(input) {
     generatedAt: input.generatedAt
   };
 }
-function resolveWatcherPort(target, env = process.env) {
-  const explicit = env.WATCHER_PORT || "";
+function resolveWatcherPort(target, env = process.env, flag) {
+  const explicit = flag || env.RECIPE_WATCHER_PORT || env.WATCHER_PORT || "";
   if (explicit) return explicit;
   for (const file of ENV_FILES) {
     const full = path.join(target, file);
@@ -299,7 +307,7 @@ async function runMobileVerify(argv, io = defaultIo) {
     io.err(parsed.message);
     return parsed.exitCode;
   }
-  const { staticOnly, platform, preflightMode, autoStart } = parsed.options;
+  const { staticOnly, platform, preflightMode, autoStart, watcherPort } = parsed.options;
   const target = path.resolve(parsed.options.target);
   if (!fs.existsSync(target)) {
     io.err(`Refusing mobile verify: target checkout does not exist: ${target}`);
@@ -344,9 +352,9 @@ async function runMobileVerify(argv, io = defaultIo) {
   let fixtureStatus = null;
   let portHolder = null;
   if (!staticOnly) {
-    const port = resolveWatcherPort(target);
+    const port = resolveWatcherPort(target, process.env, watcherPort);
     if (!isNumericWatcherPort(port)) {
-      io.err(`Refusing mobile verify: resolved watcher port is not numeric: '${port}' (check WATCHER_PORT)`);
+      io.err(`Refusing mobile verify: resolved watcher port is not numeric: '${port}' (check --watcher-port, RECIPE_WATCHER_PORT or WATCHER_PORT)`);
       return 2;
     }
     let deviceTarget = mobileDeviceTarget(target, platform, process.env);

package/dist/adapters/plugin-surface.js

@@ -1,16 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import {
-  adapterPlugin,
-  adapterSelectionFailureOut,
-  ensureAdapterLoaded,
-  selectedAdapterId
-} from "@farmslot/recipe-cli/harness";
+import { fencePolicy, POLICY_DIGEST_ENV, POLICY_ENV, PolicyFenceError } from "@farmslot/adapter-web/web-dapp";
+import { adapterPlugin, AdapterPluginError } from "@farmslot/recipe-cli/harness";
 import { libraryAdapterFiles } from "@farmslot/recipe-runner";
-import { POLICY_ENV } from "../../adapters/web-dapp/lib/policy.mjs";
-import { POLICY_DIGEST_ENV, PolicyFenceError, fencePolicy } from "../../adapters/web-dapp/lib/policy-fence.mjs";
 import { configPath, declaredLibraryPathEnv, readConfig } from "../review/knowledge.js";
-import { adapterRegistry } from "./registry.js";
 import { bindWebDappPolicy } from "./web-dapp/surface.js";
 function configuredLibrarySources() {
   let libraries;
@@ -29,38 +22,6 @@ function operatorLibraryEnv() {
   else env.RECIPE_LIBRARY_PATH = declared.value;
   return env;
 }
-async function loadSelectedAdapter(command, args) {
-  const passthrough = args.indexOf("--");
-  const own = passthrough < 0 ? args : args.slice(0, passthrough);
-  const libraries = [];
-  own.forEach((arg, index) => {
-    if (arg === "--library" && own[index + 1] !== void 0) libraries.push(own[index + 1]);
-    else if (arg.startsWith("--library=")) libraries.push(arg.slice("--library=".length));
-  });
-  const selected = selectedAdapterId(args);
-  const builtin = selected !== void 0 && adapterRegistry.has(selected);
-  try {
-    await ensureAdapterLoaded(selected, {
-      libraries,
-      configured: configuredLibrarySources(),
-      env: operatorLibraryEnv(),
-      adopt: adoptPluginAdapter
-    });
-    await fenceBoundPolicy();
-    return void 0;
-  } catch (error) {
-    const refusal = error;
-    if (typeof refusal.code !== "string" || typeof refusal.userAction !== "string") throw error;
-    if (builtin && refusal.code !== "ADAPTER_ID_CONFLICT") {
-      return void 0;
-    }
-    return adapterSelectionFailureOut(own.includes("--json"), command, {
-      code: refusal.code,
-      message: String(refusal.message),
-      userAction: refusal.userAction
-    });
-  }
-}
 const ADAPTER_PLUGIN_ENV = "METAMASK_RECIPE_ADAPTER_PLUGIN";
 let boundPolicy;
 async function fenceBoundPolicy() {
@@ -80,6 +41,16 @@ async function fenceBoundPolicy() {
     throw error;
   }
 }
+async function afterAdapterLoad() {
+  try {
+    await fenceBoundPolicy();
+  } catch (error) {
+    if (error instanceof PolicyFenceError) {
+      throw new AdapterPluginError("ADAPTER_PLUGIN_INVALID", error.message, error.userAction);
+    }
+    throw error;
+  }
+}
 function adoptPluginAdapter(adapter) {
   const surface = bindWebDappPolicy(adapter);
   const policy = adapter;
@@ -120,7 +91,8 @@ function adoptPluginAdapter(adapter) {
 export {
   ADAPTER_PLUGIN_ENV,
   adoptPluginAdapter,
+  afterAdapterLoad,
   configuredLibrarySources,
-  loadSelectedAdapter,
+  fenceBoundPolicy,
   operatorLibraryEnv
 };

package/dist/adapters/session-lock.js

@@ -0,0 +1,23 @@
+import { Writable } from "node:stream";
+import { EXIT, optionFlag } from "@farmslot/recipe-cli/harness";
+import {
+  macosSessionLocked,
+  SESSION_LOCKED_MESSAGE,
+  SESSION_LOCKED_USER_ACTION
+} from "../../adapters/shared/session-lock.mjs";
+import { emitProofFailure } from "./proof-failure.js";
+function refuseLockedSession(json, options = {}) {
+  if (macosSessionLocked() !== true) return null;
+  const error = { code: "SESSION_LOCKED", message: SESSION_LOCKED_MESSAGE, userAction: SESSION_LOCKED_USER_ACTION };
+  if (optionFlag(options, "jsonStream")) emitRunStreamError(error);
+  emitProofFailure(json, { recoverable: false, error });
+  return EXIT.infra;
+}
+function emitRunStreamError(error) {
+  const line = JSON.stringify({ schemaVersion: 1, command: "run", event: "error", error, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  Writable.prototype.write.call(process.stdout, `${line}
+`);
+}
+export {
+  refuseLockedSession
+};

package/dist/adapters/web-dapp/actions.js

@@ -9,7 +9,7 @@ const webDappActions = {
     "app.performance_assert"
   ],
   cdpTarget: { transport: "chrome-cdp", probePath: "json/version" },
-  ui: (harness, { hudPolicy }) => ({
+  ui: (harness) => ({
     base: harness.createCdpWebUiTransport({
       async withPage(input, callback) {
         const { withAppPage } = await import("../../../library/actions/web-dapp/platform/page.mjs");
@@ -30,14 +30,16 @@ const webDappActions = {
     async execute(action, node, context, standard) {
       if (action === "app.hud") {
         const { showAppHud } = await import("../../../library/actions/web-dapp/platform/hud.mjs");
-        return showAppHud(
-          { action, node, context: { nodeId: context.nodeId, projectRoot: context.projectRoot } },
-          { hudPolicy }
-        );
+        return showAppHud({ action, node, context: { nodeId: context.nodeId, projectRoot: context.projectRoot } });
       }
       return standard();
     }
   }),
+  // Deletes hud.json (the wallet host redraws from it) and the HUD on the app tabs.
+  async clearHud(projectRoot) {
+    const { showAppHud } = await import("../../../library/actions/web-dapp/platform/hud.mjs");
+    await showAppHud({ node: { clear: true }, context: { nodeId: "hud-clear", projectRoot } });
+  },
   // ensure_positions and ensure_orders with an open or present state place an order.
   inputFindings: (nodeId, node) => perpsOrderInputFindings(nodeId, node, { ensureChecksOnly: false })
 };

package/dist/adapters/web-dapp/console-capture.js

@@ -1,23 +1,7 @@
 import fs from "node:fs";
-import path from "node:path";
-import { recipeRuntimePath } from "@farmslot/recipe-cli/harness";
+import { WEB_DAPP_CONSOLE_FILES, webDappAdapterId, webDappRuntimeFile } from "@farmslot/adapter-web/web-dapp";
 import { verifyCapture } from "../../../library/actions/shared/console-collector.mjs";
 import { ensureConsoleCollector } from "../console-capture.js";
-import { webDappAdapterId } from "../../../adapters/web-dapp/lib/policy.mjs";
-const WEB_DAPP_CONSOLE_FILES = Object.freeze({
-  app: "app-console.log",
-  extension: "extension-console.log",
-  collectorLog: "console-tail.log",
-  pidFile: "console-tail.pid"
-});
-function webDappRuntimeFile(target, name) {
-  let root = path.resolve(target);
-  try {
-    root = fs.realpathSync(root);
-  } catch {
-  }
-  return recipeRuntimePath(root, webDappAdapterId(), name);
-}
 function webDappCaptureFiles(target) {
   return {
     extensionLog: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.extension),
@@ -54,10 +38,8 @@ async function verifyWebDappConsoleControl(capture) {
   return verifyCapture({ cdpPort: capture.cdpPort, log: capture.pageLog, target: "page", appOrigin: browser.appOrigin });
 }
 export {
-  WEB_DAPP_CONSOLE_FILES,
   ensureWebDappConsoleCapture,
   verifyWebDappConsoleControl,
   webDappCaptureFiles,
-  webDappCdpPort,
-  webDappRuntimeFile
+  webDappCdpPort
 };

package/dist/adapters/web-dapp/run.js

@@ -1,44 +1,43 @@
+import fs from "node:fs";
 import path from "node:path";
+import { ownsProcess, webDappRuntimeFile } from "@farmslot/adapter-web/web-dapp";
 import { isRecord } from "@farmslot/recipe-cli/harness";
 import { verifyOwnedCollectorControl } from "../console-capture.js";
+import { refuseLockedSession } from "../session-lock.js";
 import { devicePlatformFromEnv } from "../performance/device-platform.js";
 import {
   ensureWebDappConsoleCapture,
   webDappCaptureFiles,
   webDappCdpPort,
-  webDappRuntimeFile,
   verifyWebDappConsoleControl
 } from "./console-capture.js";
+async function webDappRunHeadless(target) {
+  const stateFile = webDappRuntimeFile(target, "browser.json");
+  try {
+    const state = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+    if (isRecord(state) && isRecord(state.browser) && typeof state.browser.headless === "boolean") {
+      if (ownsProcess("browser", state.browserPid, path.dirname(stateFile))) return state.browser.headless;
+    }
+  } catch {
+  }
+  try {
+    const { resolveHeadless } = await import("../../../library/actions/web-dapp/platform/adapter-web-lib.mjs");
+    return resolveHeadless();
+  } catch {
+    return null;
+  }
+}
+const webDappRun = {
+  runtimeCheck: ({ target, options, json }) => async () => await webDappRunHeadless(target) === false ? refuseLockedSession(json, options) : null
+};
 const webDappDiagnostics = {
   console: {
     start: (projectRoot) => ensureWebDappConsoleCapture(projectRoot),
     files: (projectRoot) => webDappCaptureFiles(projectRoot),
     cdpPort: () => webDappCdpPort(),
     verifyControl: (capture) => verifyOwnedCollectorControl(capture, () => verifyWebDappConsoleControl(capture))
-  },
-  requestLog: {
-    path: (projectRoot) => webDappRuntimeFile(projectRoot, "wallet-requests.jsonl"),
-    findings: (lines) => walletRequestFindings(lines)
   }
 };
-function walletRequestFindings(lines) {
-  const findings = [];
-  for (const line of lines) {
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (!isRecord(entry)) continue;
-    let text = null;
-    if (entry.kind === "blocked-mainnet" && entry.probe !== true) text = `blocked-mainnet: ${String(entry.transport ?? "request")} to ${String(entry.url ?? "?")}`;
-    else if (entry.kind === "refused-mainnet") text = `refused-mainnet: ${String(entry.method ?? "?")} (${String(entry.reason ?? "?")})`;
-    else if (entry.kind === "unattributed") text = `unattributed wallet ${entry.binding === "request" ? "request" : "log entry"}${typeof entry.method === "string" ? ` (${entry.method})` : ""}`;
-    if (text) findings.push({ level: "error", source: "wallet", text });
-  }
-  return findings;
-}
 const webDappObservation = {
   network: {
     backend: async (target, env, artifactsDir) => (await import("../extension/network-observer.js")).createLoadedExtensionNetworkBackend(
@@ -59,5 +58,7 @@ const webDappObservation = {
 };
 export {
   webDappDiagnostics,
-  webDappObservation
+  webDappObservation,
+  webDappRun,
+  webDappRunHeadless
 };

package/dist/adapters/web-dapp/surface.js

@@ -1,82 +1,38 @@
-import { shellQuote } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
 import { defineAdapter } from "@farmslot/adapter-sdk";
-import fs from "node:fs";
-import { POLICY_ENV, webDappAdapterId, webDappPolicy } from "../../../adapters/web-dapp/lib/policy.mjs";
-import { WEB_DAPP_CONSOLE_FILES, webDappRuntimeFile } from "./console-capture.js";
-import { stopWebDappBrowserSync } from "./stop.js";
+import {
+  bindWebDappPolicy as bindPolicy,
+  createWebDappAdapter,
+  POLICY_ENV,
+  SIGNER_MODULE_ENV,
+  webDappAdapterId,
+  webDappPolicy
+} from "@farmslot/adapter-web/web-dapp";
+import { runnerDir } from "../../paths.js";
 import { adapterRegistry } from "../registry.js";
 import { webDappActions } from "./actions.js";
-import { webDappHarness, webDappRuntimeContext } from "./overlay.js";
-import { webDappReadiness } from "./readiness.js";
-import { webDappDiagnostics, webDappObservation } from "./run.js";
-function portFromEnv(...names) {
-  for (const name of names) {
-    const raw = process.env[name];
-    if (raw && /^\d+$/u.test(raw)) return Number(raw);
-  }
-  return void 0;
-}
-function webDappAppPort() {
-  return portFromEnv("TERMINAL_APP_PORT", "RECIPE_WATCHER_PORT", "WATCHER_PORT");
-}
-function webDappCdpPort() {
-  return portFromEnv("RECIPE_CDP_PORT", "CDP_PORT");
-}
-function webDappSignerFor(target) {
-  try {
-    const state = JSON.parse(fs.readFileSync(webDappRuntimeFile(target, "browser.json"), "utf8"));
-    if (typeof state.signer === "string") return state.signer;
-  } catch {
-  }
-  return process.env.TERMINAL_SIGNER || "extension";
-}
+import { webDappDiagnostics, webDappObservation, webDappRun } from "./run.js";
+const METAMASK_SIGNER_MODULE = path.join(runnerDir, "adapters", "web-dapp", "metamask-signer.mjs");
 function bindWebDappPolicy(adapter) {
+  bindPolicy(adapter);
   if (adapter.extends === "web-dapp" && typeof adapter.policy?.module === "string") {
-    process.env[POLICY_ENV] = adapter.policy.module;
+    process.env[SIGNER_MODULE_ENV] = METAMASK_SIGNER_MODULE;
   }
   return adapter;
 }
-const webDappSurface = defineAdapter({
+const generic = createWebDappAdapter({
   id: "web-dapp",
-  sdkVersion: 1,
-  headless: false,
-  resolveSlotPorts() {
-  },
-  async runtimeStatus(target) {
-    if (!process.env[POLICY_ENV]) {
-      return {
-        decision: "blocked",
-        reasonCode: "web-dapp-venue-policy",
-        reasons: ["web-dapp needs a venue policy: select an adapter that extends it"],
-        nextAction: "pass --adapter <the adapter that extends web-dapp>, e.g. --adapter terminal, with its recipe library on RECIPE_LIBRARY_PATH",
-        deps: "missing",
-        devServer: { label: "next", status: "down" }
-      };
-    }
-    const policy = webDappPolicy();
-    const { webDappReadiness: webDappReadiness2 } = await import("../../../adapters/web-dapp/lib/readiness.mjs");
-    const report = await webDappReadiness2({
-      policy,
-      target: path.resolve(target),
-      appPort: webDappAppPort(),
-      cdpPort: webDappCdpPort(),
-      signer: process.env.TERMINAL_SIGNER || "extension"
-    });
-    const blocking = report.checks.filter((check) => check.required && check.status === "fail");
-    const devServer = report.checks.find((check) => check.id === "app-dev-server");
-    return {
-      decision: blocking.length === 0 ? "ready" : "blocked",
-      reasonCode: blocking[0]?.id,
-      reasons: (blocking.length ? blocking : report.checks).map((check) => `${check.id}: ${check.detail}`),
-      nextAction: blocking.length === 0 ? void 0 : blocking[0].id === "app-dev-server" || blocking[0].id === "testnet-forced" ? "start the slot dev server with testnet forced (Farmslot preflight), then retry" : `mm-harness doctor --adapter ${policy.adapterId} --target ${shellQuote(path.resolve(target))} --json`,
-      deps: report.checks.find((check) => check.id === "dependencies")?.status === "pass" ? "current" : "missing",
-      devServer: {
-        label: "next",
-        status: devServer?.status === "pass" ? "up" : "down"
-      }
-    };
-  },
+  signerModule: METAMASK_SIGNER_MODULE,
+  cli: "mm-harness",
+  hooks: {
+    actions: webDappActions,
+    run: webDappRun,
+    diagnostics: webDappDiagnostics,
+    observation: webDappObservation
+  }
+});
+const webDappSurface = defineAdapter({
+  ...generic,
   runwayProvision: {
     async run(target, options) {
       return {
@@ -94,41 +50,12 @@ const webDappSurface = defineAdapter({
       };
     }
   },
-  devServer: {
-    label: "browser",
-    describe: () => `${webDappAdapterId()} slot browser and wallet host (the Next.js dev server belongs to the slot)`,
-    stop(target) {
-      const result = stopWebDappBrowserSync(target);
-      return { kind: "stopped", status: result.status, summary: result.summary, output: result.output };
-    }
-  },
-  logSources(target) {
-    return [
-      { label: "app-console", path: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.app) },
-      ...webDappSignerFor(target) === "extension" ? [{ label: "extension-console", path: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.extension) }] : [],
-      { label: "wallet-requests", path: webDappRuntimeFile(target, "wallet-requests.jsonl") },
-      { label: "wallet-host", path: webDappRuntimeFile(target, "wallet-host.log") },
-      { label: "browser", path: webDappRuntimeFile(target, "browser.log") },
-      { label: "next", path: path.join(target, "temp/farmslot/next-dev.log") }
-    ];
-  },
-  // The app page's console and uncaught exceptions, as the Extension's
-  // diagnostics read the extension console: errors make a run REVIEW.
-  appLogSource(target) {
-    return { label: "app-console", path: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.app) };
-  },
-  flags: { launch: ["freshProfile", "headless", "headful"] },
-  hints: {
-    // Bare web-dapp has no venue: every hint names the adapter that extends it.
-    launch: "pass --adapter <the adapter that extends web-dapp>, e.g. --adapter terminal, with its recipe library on RECIPE_LIBRARY_PATH",
-    relaunch: "pass --adapter <the adapter that extends web-dapp>, e.g. --adapter terminal, with --fresh-profile",
-    runtimeProbeRecovery: () => "pass --adapter <the adapter that extends web-dapp>, e.g. --adapter terminal, with its recipe library on RECIPE_LIBRARY_PATH"
+  // adapter-web's slot readiness (with MetaMask's own checks) and capture providers.
+  readiness: {
+    liveChecks: generic.readiness.liveChecks,
+    captureProviders: generic.readiness.captureProviders,
+    compatibilityMode: (target) => process.env[POLICY_ENV] && webDappPolicy().checkout.matches(target) ? "slot browser over CDP (website; no product bridge)" : "unsupported/no bridge"
   },
-  launch: async (context) => (await import("./launch.js")).launchWebDapp(context),
-  actions: webDappActions,
-  harness: webDappHarness,
-  runtimeContext: webDappRuntimeContext,
-  readiness: webDappReadiness,
   fixtures: { operations: ["init", "sync", "set"] },
   debug: {
     args: ({ devMenu }) => [
@@ -136,14 +63,11 @@ const webDappSurface = defineAdapter({
       "--action",
       devMenu ? "dev-menu" : "debug"
     ]
-  },
-  diagnostics: webDappDiagnostics,
-  observation: webDappObservation
+  }
 });
 adapterRegistry.register(webDappSurface);
 export {
+  METAMASK_SIGNER_MODULE,
   bindWebDappPolicy,
-  webDappAppPort,
-  webDappCdpPort,
   webDappSurface
 };

package/dist/adapters.js

@@ -90,7 +90,9 @@ const LIVE_ONLY_APP_ACTIONS = /* @__PURE__ */ new Set([
   "app.network_capture",
   "app.network_assert",
   "app.performance_capture",
-  "app.performance_assert"
+  "app.performance_assert",
+  // Proves a capture of the running app; a static result would pass on no evidence.
+  "metamask.app.assert_no_console_errors"
 ]);
 function requiresLiveAdapter(platform, action) {
   return LIVE_ONLY_ACTIONS.has(action) || Boolean(getAdapterSurface(platform).actions.liveOnly?.includes(action)) || LIVE_ONLY_WALLET_ACTIONS.has(action) || LIVE_ONLY_FEATURE_FLAG_ACTIONS.has(action) || LIVE_ONLY_APP_ACTIONS.has(action);
@@ -290,7 +292,7 @@ function createMetaMaskSemanticAdapters(platform, declaredCustomActions = [], pr
     )
   );
 }
-function createMetaMaskUiTransport(platform, harness, preparedLiveAdapters, { hudPolicy = "auto" } = {}) {
+function createMetaMaskUiTransport(platform, harness, preparedLiveAdapters) {
   const ui = getAdapterSurface(platform).actions.ui;
   if (!ui) {
     return {
@@ -301,7 +303,7 @@ function createMetaMaskUiTransport(platform, harness, preparedLiveAdapters, { hu
       }
     };
   }
-  const { base, execute } = ui(harness, { hudPolicy });
+  const { base, execute } = ui(harness, { hudPolicy: "show" });
   async function standard(action, node, context) {
     if (action === "ui.navigate") {
       const live = await runLiveFirst(