@deeeed/metamask-harness 0.81.0 → 0.82.0

package/dist/adapters/{terminal → web-dapp}/launch.js

@@ -2,7 +2,8 @@ import { flag, str } from "@farmslot/recipe-cli/harness";
 import { execFileSync } from "node:child_process";
 import path from "node:path";
 import { runnerDir } from "../../paths.js";
-const TERMINAL_ONLY_LAUNCH_OPTIONS = Object.freeze({
+import { webDappAdapterId } from "../../../adapters/web-dapp/lib/policy.mjs";
+const WEB_DAPP_ONLY_LAUNCH_OPTIONS = Object.freeze({
   signer: "--signer",
   account: "--account",
   freshProfile: "--fresh-profile",
@@ -12,12 +13,12 @@ const TERMINAL_ONLY_LAUNCH_OPTIONS = Object.freeze({
   network: "--network",
   mainnetConfirmation: "--mainnet-confirmation"
 });
-function terminalOnlyLaunchFlags(options) {
-  return Object.entries(TERMINAL_ONLY_LAUNCH_OPTIONS).filter(([key]) => options[key] !== void 0 && options[key] !== false).map(([, name]) => name);
+function webDappOnlyLaunchFlags(options) {
+  return Object.entries(WEB_DAPP_ONLY_LAUNCH_OPTIONS).filter(([key]) => options[key] !== void 0 && options[key] !== false).map(([, name]) => name);
 }
-function parseTerminalLauncherOutput(output) {
+function parseWebDappLauncherOutput(output) {
   const text = output.trim();
-  if (!text) return { status: "fail", error: "the terminal launcher printed no summary" };
+  if (!text) return { status: "fail", error: `the ${webDappAdapterId()} launcher printed no summary` };
   try {
     return JSON.parse(text);
   } catch {
@@ -25,30 +26,28 @@ function parseTerminalLauncherOutput(output) {
     try {
       return JSON.parse(last);
     } catch {
-      return { status: "fail", error: `the terminal launcher printed no JSON summary: ${last.slice(0, 200)}` };
+      return { status: "fail", error: `the ${webDappAdapterId()} launcher printed no JSON summary: ${last.slice(0, 200)}` };
     }
   }
 }
-async function launchTerminal({ options, target, jsonOutput, stream, usage }) {
+async function launchWebDapp({ options, target, jsonOutput, stream, usage }) {
+  const id = webDappAdapterId();
   const cdpPort = str(options, "cdpPort") ?? process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
   const appPort = str(options, "watcherPort") ?? process.env.TERMINAL_APP_PORT ?? process.env.RECIPE_WATCHER_PORT ?? process.env.WATCHER_PORT;
   if (!cdpPort || !appPort) {
     return usage(
-      "terminal launch needs the slot browser CDP port and the slot dev-server port.",
-      "mm-harness launch --adapter terminal --cdp-port <port> --watcher-port <app port>"
+      `${id} launch needs the slot browser CDP port and the slot dev-server port.`,
+      `mm-harness launch --adapter ${id} --cdp-port <port> --watcher-port <app port>`
     );
   }
   const args = [
-    path.join(runnerDir, "adapters", "terminal", "launch.mjs"),
+    path.join(runnerDir, "adapters", "web-dapp", "launch.mjs"),
     "--target",
     target,
     "--cdp-port",
     cdpPort,
     "--app-port",
     appPort,
-    // The Terminal's venue policy (Hyperliquid hosts, refusal, start page).
-    "--policy-module",
-    path.join(runnerDir, "adapters", "terminal", "policy.mjs"),
     "--signer",
     str(options, "signer") ?? process.env.TERMINAL_SIGNER ?? "extension",
     "--account",
@@ -64,7 +63,7 @@ async function launchTerminal({ options, target, jsonOutput, stream, usage }) {
   if (network) args.push("--network", network);
   const mainnetConfirmation = str(options, "mainnetConfirmation");
   if (mainnetConfirmation) args.push("--mainnet-confirmation", mainnetConfirmation);
-  stream.phase("launch", { adapter: "terminal", cdpPort, appPort });
+  stream.phase("launch", { adapter: id, cdpPort, appPort });
   let output = "";
   let status = 0;
   try {
@@ -73,16 +72,16 @@ async function launchTerminal({ options, target, jsonOutput, stream, usage }) {
     status = 1;
     output = String(error.stdout ?? "");
   }
-  const result = parseTerminalLauncherOutput(output);
-  if (jsonOutput) console.log(JSON.stringify({ schemaVersion: 1, command: "launch", adapter: "terminal", target, ...result }, null, 2));
-  else if (result.status === "pass") console.log(`\u2713 terminal browser ${result.reused ? "reused" : "started"} on CDP ${result.cdpPort} (${result.signer}, ${result.account?.name})`);
-  else console.error(`\u2717 terminal launch failed: ${result.error ?? "unknown error"}`);
+  const result = parseWebDappLauncherOutput(output);
+  if (jsonOutput) console.log(JSON.stringify({ schemaVersion: 1, command: "launch", adapter: id, target, ...result }, null, 2));
+  else if (result.status === "pass") console.log(`\u2713 ${id} browser ${result.reused ? "reused" : "started"} on CDP ${result.cdpPort} (${result.signer}, ${result.account?.name})`);
+  else console.error(`\u2717 ${id} launch failed: ${result.error ?? "unknown error"}`);
   stream.complete(result.status === "pass" ? "pass" : "fail", status);
   return result.status === "pass" ? 0 : 1;
 }
 export {
-  TERMINAL_ONLY_LAUNCH_OPTIONS,
-  launchTerminal,
-  parseTerminalLauncherOutput,
-  terminalOnlyLaunchFlags
+  WEB_DAPP_ONLY_LAUNCH_OPTIONS,
+  launchWebDapp,
+  parseWebDappLauncherOutput,
+  webDappOnlyLaunchFlags
 };

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

@@ -0,0 +1,21 @@
+import path from "node:path";
+import { runnerDir } from "../../paths.js";
+const webDappHarness = {
+  install: { entry: "adapters/web-dapp/inject.mjs", fallback: "adapters/web-dapp/inject.mjs", node: true },
+  cleanup: { entry: "adapters/web-dapp/cleanup.mjs", fallback: "adapters/web-dapp/cleanup.mjs", node: true },
+  verify: () => ({
+    command: process.execPath,
+    prefixArgs: [path.join(runnerDir, "adapters", "web-dapp", "verify.mjs")]
+  }),
+  restart: "mm-harness launch"
+};
+const webDappRuntimeContext = {
+  forbiddenFields: ["metroPort", "simulator", "simulatorUdid", "adbSerial", "extensionId"],
+  resources: ({ existing, defaults, envPort }) => ({
+    cdpPort: envPort("RECIPE_CDP_PORT", "CDP_PORT") ?? existing.cdpPort ?? defaults.cdpPort
+  })
+};
+export {
+  webDappHarness,
+  webDappRuntimeContext
+};

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

@@ -0,0 +1,10 @@
+import { POLICY_ENV, webDappPolicy } from "../../../adapters/web-dapp/lib/policy.mjs";
+const webDappReadiness = {
+  compatibilityMode: (target) => process.env[POLICY_ENV] && webDappPolicy().checkout.matches(target) ? "slot browser over CDP (website; no product bridge)" : "unsupported/no bridge",
+  liveChecks: async (target) => (await import("./doctor-checks.js")).webDappDoctorChecks(target),
+  // Screenshots come from the slot browser over CDP.
+  captureProviders: ["cdp"]
+};
+export {
+  webDappReadiness
+};

package/dist/adapters/{terminal → web-dapp}/run.js

@@ -2,21 +2,21 @@ import { isRecord } from "@farmslot/recipe-cli/harness";
 import { verifyOwnedCollectorControl } from "../console-capture.js";
 import { devicePlatformFromEnv } from "../performance/device-platform.js";
 import {
-  ensureTerminalConsoleCapture,
-  terminalCaptureFiles,
-  terminalCdpPort,
-  terminalRuntimeFile,
-  verifyTerminalConsoleControl
+  ensureWebDappConsoleCapture,
+  webDappCaptureFiles,
+  webDappCdpPort,
+  webDappRuntimeFile,
+  verifyWebDappConsoleControl
 } from "./console-capture.js";
-const terminalDiagnostics = {
+const webDappDiagnostics = {
   console: {
-    start: (projectRoot) => ensureTerminalConsoleCapture(projectRoot),
-    files: (projectRoot) => terminalCaptureFiles(projectRoot),
-    cdpPort: () => terminalCdpPort(),
-    verifyControl: (capture) => verifyOwnedCollectorControl(capture, () => verifyTerminalConsoleControl(capture))
+    start: (projectRoot) => ensureWebDappConsoleCapture(projectRoot),
+    files: (projectRoot) => webDappCaptureFiles(projectRoot),
+    cdpPort: () => webDappCdpPort(),
+    verifyControl: (capture) => verifyOwnedCollectorControl(capture, () => verifyWebDappConsoleControl(capture))
   },
   requestLog: {
-    path: (projectRoot) => terminalRuntimeFile(projectRoot, "wallet-requests.jsonl"),
+    path: (projectRoot) => webDappRuntimeFile(projectRoot, "wallet-requests.jsonl"),
     findings: (lines) => walletRequestFindings(lines)
   }
 };
@@ -38,7 +38,7 @@ function walletRequestFindings(lines) {
   }
   return findings;
 }
-const terminalObservation = {
+const webDappObservation = {
   network: {
     backend: async (_target, env, artifactsDir) => (await import("../extension/network-observer.js")).createExtensionNetworkBackend(env, artifactsDir)
   },
@@ -46,13 +46,13 @@ const terminalObservation = {
     start: async (context) => {
       const observation = await import("../../performance-observation.js");
       return observation.startRunPerformanceObservation({
-        backend: (target, env, ports) => observation.createExtensionPerformanceObserver(target, env, ports),
+        backend: (target, env) => observation.createExtensionPerformanceObserver(target, env),
         platform: (env) => devicePlatformFromEnv(env)
       }, context);
     }
   }
 };
 export {
-  terminalDiagnostics,
-  terminalObservation
+  webDappDiagnostics,
+  webDappObservation
 };

package/dist/adapters/{terminal → web-dapp}/stop.js

@@ -1,8 +1,9 @@
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { runnerDir } from "../../paths.js";
-function stopTerminalBrowserSync(target) {
-  const args = [path.join(runnerDir, "adapters", "terminal", "stop.mjs"), "--target", path.resolve(target)];
+import { webDappAdapterId } from "../../../adapters/web-dapp/lib/policy.mjs";
+function stopWebDappBrowserSync(target) {
+  const args = [path.join(runnerDir, "adapters", "web-dapp", "stop.mjs"), "--target", path.resolve(target)];
   const cdpPort = process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
   if (cdpPort) args.push("--cdp-port", cdpPort);
   const result = spawnSync(process.execPath, args, { encoding: "utf8" });
@@ -10,10 +11,10 @@ function stopTerminalBrowserSync(target) {
   const status = result.status ?? 1;
   return {
     status,
-    summary: status === 0 ? "terminal browser and wallet host stopped" : "terminal browser stop failed",
+    summary: status === 0 ? `${webDappAdapterId()} browser and wallet host stopped` : `${webDappAdapterId()} browser stop failed`,
     output
   };
 }
 export {
-  stopTerminalBrowserSync
+  stopWebDappBrowserSync
 };

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

@@ -0,0 +1,149 @@
+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 { 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";
+}
+function bindWebDappPolicy(adapter) {
+  if (adapter.extends === "web-dapp" && typeof adapter.policy?.module === "string") {
+    process.env[POLICY_ENV] = adapter.policy.module;
+  }
+  return adapter;
+}
+const webDappSurface = defineAdapter({
+  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"
+      }
+    };
+  },
+  runwayProvision: {
+    async run(target, options) {
+      return {
+        schemaVersion: 1,
+        command: "provision",
+        adapter: webDappAdapterId(),
+        target: path.resolve(target),
+        status: "fail",
+        exitCode: 2,
+        error: {
+          code: "UNSUPPORTED_ADAPTER",
+          message: `the ${process.env[POLICY_ENV] ? webDappPolicy().checkout.name : "web dapp"} is a website; there is no simulator or build to provision.`,
+          userAction: options.rerunCommand || `mm-harness launch --adapter ${webDappAdapterId()}`
+        }
+      };
+    }
+  },
+  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"
+  },
+  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 }) => [
+      ...process.env.WATCHER_PORT ? ["--port", process.env.WATCHER_PORT] : [],
+      "--action",
+      devMenu ? "dev-menu" : "debug"
+    ]
+  },
+  diagnostics: webDappDiagnostics,
+  observation: webDappObservation
+});
+adapterRegistry.register(webDappSurface);
+export {
+  bindWebDappPolicy,
+  webDappAppPort,
+  webDappCdpPort,
+  webDappSurface
+};

package/dist/cli.js

@@ -15,6 +15,7 @@ import {
   targetPath
 } from "@farmslot/recipe-cli/harness";
 import { stopProjectCollector } from "../library/actions/shared/analytics/collector.mjs";
+import { loadSelectedAdapter } from "./adapters/plugin-surface.js";
 import { adapterRegistry } from "./adapters/registry.js";
 import { applyDeviceTargeting } from "./commands/device-target.js";
 import { metaMaskEngine } from "./engine.js";
@@ -135,6 +136,8 @@ async function main(argv) {
     usage();
     return command ? 0 : 2;
   }
+  const refused = await loadSelectedAdapter(command, argv.slice(1));
+  if (refused !== void 0) return refused;
   if (command === "status" || command === "health" || command === "home") {
     return handleStatus(parseArgs(argv.slice(1)));
   }

package/dist/command-contract.js

@@ -1,4 +1,5 @@
-import { closest } from "@farmslot/recipe-cli/harness";
+import { adapterChoices, closest } from "@farmslot/recipe-cli/harness";
+import { configuredLibrarySources, operatorLibraryEnv } from "./adapters/plugin-surface.js";
 const bool = () => ({ kind: "boolean" });
 const value = (choices) => ({ kind: "value", ...choices ? { choices } : {} });
 const optionalValue = (choices) => ({ kind: "optional-value", ...choices ? { choices } : {} });
@@ -8,9 +9,18 @@ const JSON = { "--json": bool() };
 const NO_OPEN = { "--no-open": bool() };
 const JSON_STREAM = { "--json-stream": bool() };
 const TARGET = { "--target": value() };
-const ADAPTER = { "--adapter": value(["mobile", "extension", "core", "terminal"]) };
+const adapterIds = (tokens) => adapterChoices(optionValues(tokens, "--library"), {
+  configured: configuredLibrarySources(),
+  env: operatorLibraryEnv()
+});
+const ADAPTER = { "--adapter": { kind: "value", choices: adapterIds } };
 const MOBILE_PLATFORM = { "--platform": value(["ios", "android"]) };
-const ADAPTER_OR_MOBILE_PLATFORM = { "--platform": value(["mobile", "extension", "core", "terminal", "ios", "android"]) };
+const ADAPTER_OR_MOBILE_PLATFORM = {
+  "--platform": {
+    kind: "value",
+    choices: (tokens) => [...adapterIds(tokens), "ios", "android"]
+  }
+};
 const DEVICE = { "--device": value() };
 const RUNTIME_PORTS = {
   "--cdp-port": value(),
@@ -152,7 +162,7 @@ const PUBLIC_COMMAND_CONTRACTS = {
   prepare: {
     usage: "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]",
     options: options(HELP, JSON, TARGET, {
-      "--platform": value(["mobile", "extension", "core", "terminal"]),
+      "--platform": { kind: "value", choices: adapterIds },
       "--mobile-platform": value(["ios", "android"]),
       "--clear-metro": bool(),
       "--artifacts-dir": value(),
@@ -420,6 +430,16 @@ const PUBLIC_COMMAND_CONTRACTS = {
     minimumPositionals: 0
   }
 };
+function optionValues(args, name) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--") break;
+    if (arg === name && args[index + 1] !== void 0) values.push(args[index += 1]);
+    else if (arg.startsWith(`${name}=`)) values.push(arg.slice(name.length + 1));
+  }
+  return values;
+}
 function validatePublicInvocation(argv, examples = {}) {
   const token = argv[0];
   if (!token || token === "--help" || token === "-h" || token === "--version" || token === "-v") return null;
@@ -487,12 +507,13 @@ function validatePublicInvocation(argv, examples = {}) {
       return usageFailure("CLI_MISSING_OPTION_VALUE", name, `${optionName} requires a value.`, contract, examples);
     }
     if (inlineValue === void 0) index += 1;
-    if (spec.choices && !spec.choices.includes(optionValue)) {
-      const suggestion = closest(optionValue, spec.choices);
+    const choices = typeof spec.choices === "function" ? spec.choices(tokens) : spec.choices;
+    if (choices && !choices.includes(optionValue)) {
+      const suggestion = closest(optionValue, choices);
       return {
         code: "CLI_INVALID_OPTION_VALUE",
         command: name,
-        message: `${optionName} must be ${formatChoiceList(spec.choices)}; received '${optionValue}'.`,
+        message: `${optionName} must be ${formatChoiceList(choices)}; received '${optionValue}'.`,
         userAction: actionFor(optionValue, suggestion, exampleFor(name, examples))
       };
     }
@@ -701,6 +722,7 @@ function exampleFor(command, examples) {
 }
 export {
   PUBLIC_COMMAND_CONTRACTS,
+  optionValues,
   publicCommandNames,
   publicCommandTokens,
   validatePublicInvocation

package/dist/commands/check.js

@@ -3,7 +3,7 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import "../adapters/surface.js";
-const USAGE = "mm-harness check diff [--fix] [--target <repo>] [--adapter mobile|extension|core] [--base <ref>] [--profile fast|full] [--artifacts-dir <dir>] [--json]";
+const USAGE = "mm-harness check diff [--fix] [--target <repo>] [--adapter <adapter>] [--base <ref>] [--profile fast|full] [--artifacts-dir <dir>] [--json]";
 const JS_TS_EXT_RE = /\.(?:c|m)?jsx?$|\.tsx?$/u;
 const FORMAT_EXT_RE = /\.(?:c|m)?jsx?$|\.tsx?$|\.json$|\.md$|\.css$|\.scss$|\.ya?ml$/u;
 const TEST_FILE_RE = /(?:^|[./_-])(?:test|spec)\.(?:c|m)?jsx?$|(?:^|[./_-])(?:test|spec)\.tsx?$/u;
@@ -21,7 +21,7 @@ async function handleCheck(argv) {
   const target = path.resolve(optionString(options, "target") ?? process.cwd());
   const explicitAdapter = optionString(options, "adapter") ?? optionString(options, "platform");
   const detected = explicitAdapter ?? detectAdapter(target);
-  if (detected && !["mobile", "extension", "core", "terminal"].includes(detected)) {
+  if (detected === "ios" || detected === "android") {
     return usageOut(json, "check", `unsupported adapter '${detected}'`, USAGE);
   }
   const adapter = detected;

package/dist/commands/doctor.js

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { featureFlagReport } from "../feature-flags.js";
-import { color, acquireCheckoutLock, detectAdapter, resolveRuntimeContextPath, ensureOverlay, newHealState, recipeRunning, adapterDetectNext, checkoutBusyOut, EXIT, usageOut, actionManifestPathOption, applyRuntimeDirOption, optionFlag, optionString, shellQuote, targetPath } from "@farmslot/recipe-cli/harness";
+import { adapterPluginChecks, color, acquireCheckoutLock, detectAdapter, resolveRuntimeContextPath, ensureOverlay, newHealState, recipeRunning, adapterDetectNext, checkoutBusyOut, EXIT, usageOut, actionManifestPathOption, applyRuntimeDirOption, optionFlag, optionString, shellQuote, targetPath } from "@farmslot/recipe-cli/harness";
 import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
 import { createDoctorReport, fixtureSummary, requiredDoctorCheckSummary } from "../doctor.js";
 import { assertAdapter, runnerDir } from "../paths.js";
@@ -158,7 +158,10 @@ async function handleDoctor({ options }) {
   const checks = [
     ...result.checks,
     runtimeCheck,
-    ...await readiness.liveChecks?.(target) ?? []
+    ...await readiness.liveChecks?.(target) ?? [],
+    ...await platformDoctorChecks(adapter, target),
+    // Which library plugin code this process loaded: library, module and digest.
+    ...adapterPluginChecks()
   ];
   const requiredChecks = requiredDoctorCheckSummary(checks);
   const doctorResult = {
@@ -244,6 +247,20 @@ async function handleDoctor({ options }) {
   }
   return doctorResult.status === "pass" ? 0 : 1;
 }
+async function platformDoctorChecks(adapter, target) {
+  try {
+    return await getAdapterSurface(adapter).doctor?.(target) ?? [];
+  } catch (error) {
+    return [{
+      id: `adapter-plugin:${adapter}:doctor`,
+      status: "fail",
+      required: true,
+      message: `${adapter}'s doctor checks failed to run.`,
+      detail: error instanceof Error ? error.message : String(error),
+      userAction: `fix the doctor() of the ${adapter} adapter, then rerun mm-harness doctor --adapter ${adapter}`
+    }];
+  }
+}
 function doctorRuntimeCheck(runtime, error, expectLive) {
   if (error) {
     return {

package/dist/commands/farmslot-ready.js

@@ -11,6 +11,7 @@ function farmslotReadyIndicator(adapter, devices) {
       return "OK";
     case "core":
       return "ready";
+    case "web-dapp":
     case "terminal":
       return "OK";
     case "mobile": {

package/dist/commands/help.js

@@ -5,7 +5,7 @@ import { handleHelpReview } from "./review.js";
 import "../adapters/surface.js";
 const UNSCOPED_NEXT = "cd into a MetaMask checkout or pass --adapter <mobile|extension|core|terminal>";
 function validHelpLine(value) {
-  return typeof value === "string" || Boolean(value && typeof value.text === "string" && Array.isArray(value.adapters) && value.adapters.length > 0 && value.adapters.every((adapter) => ["mobile", "extension", "core", "terminal"].includes(adapter)));
+  return typeof value === "string" || Boolean(value && typeof value.text === "string" && Array.isArray(value.adapters) && value.adapters.length > 0 && value.adapters.every((adapter) => ["mobile", "extension", "core", "web-dapp"].includes(adapter)));
 }
 function scopedSections(topic, adapter) {
   const select = (lines) => lines.flatMap((line) => typeof line === "string" ? [line] : line.adapters.includes(adapter) ? [line.text] : []);

package/dist/commands/launch/device.js

@@ -9,15 +9,15 @@ import {
   parseRemoteFlagSpec,
   remoteFlagRequestFor
 } from "../../feature-flags.js";
-import { terminalOnlyLaunchFlags } from "../../adapters/terminal/launch.js";
+import { webDappOnlyLaunchFlags } from "../../adapters/web-dapp/launch.js";
 import { shellQuote } from "./quote.js";
 async function runDeviceLaunch(context, profile) {
   const { adapter, options, target, heal, jsonOutput, machine, stream, usage } = context;
-  const terminalOnly = terminalOnlyLaunchFlags(options);
-  if (terminalOnly.length > 0) {
+  const webDappOnly = webDappOnlyLaunchFlags(options);
+  if (webDappOnly.length > 0) {
     return usage(
-      `${terminalOnly.join(", ")} apply only to --adapter terminal; ${adapter} does not read them.`,
-      "drop the terminal flags, or pass --adapter terminal"
+      `${webDappOnly.join(", ")} apply only to adapters that extend web-dapp (e.g. --adapter terminal); ${adapter} does not read them.`,
+      "drop those flags, or pass --adapter terminal"
     );
   }
   const wantBuild = flag(options, "build");

package/dist/commands/self-test.js

@@ -1,4 +1,4 @@
-import { optionFlag, optionString, requiredOption, runRecipe } from "@farmslot/recipe-cli/harness";
+import { activateRecipeRuntimeEnvironment, optionFlag, optionString, requiredOption, runRecipe } from "@farmslot/recipe-cli/harness";
 import { mkdtemp } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -23,10 +23,14 @@ async function runSelfTest(options) {
       const manifestValidation = await validateManifest(manifest);
       const smokeRecipe = recipePath(`${adapter}/runner/smoke.recipe.json`);
       const artifactsDir = path.join(root, adapter);
-      const result = await runRecipe(metaMaskEngine, adapter, smokeRecipe, artifactsDir, runnerDir, void 0, {
-        cli: { adapter },
-        platform: { skipExtensionRuntimePrepare: true }
-      });
+      const runtimeOptions = { platform: { skipExtensionRuntimePrepare: true } };
+      const restoreRuntimeEnvironment = activateRecipeRuntimeEnvironment(adapter, runnerDir, runtimeOptions);
+      let result;
+      try {
+        result = await runRecipe(metaMaskEngine, adapter, smokeRecipe, artifactsDir, runnerDir, void 0, runtimeOptions);
+      } finally {
+        restoreRuntimeEnvironment();
+      }
       runs.push({ adapter, manifestValidation: manifestValidation.summary, artifactsDir, result });
     }
   } finally {

package/dist/engine.js

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { resolveAdapter } from "@farmslot/recipe-cli/harness";
 import { getAdapterSurface } from "./adapters/surface.js";
 import { consoleClassifier } from "./console-classifier.js";
 import {
@@ -21,20 +20,21 @@ const metaMaskEngine = {
   resolveActionManifest,
   validateManifest,
   actionCapabilities: metaMaskActionExecutionCapabilities,
-  createRunner: async (adapter, manifest, { trustedMutation, ...options }) => {
+  createRunner: async (adapter, manifest, options) => {
     const { createMetaMaskRunner } = await import("./runner.js");
-    return trustedMutation === NO_PLAN_MUTATION ? createMetaMaskRunner(adapter, manifest, { ...options, suppressLibraryResolutionLogs: true }) : createMetaMaskRunner(adapter, manifest, { ...options, trustedMutation });
+    return createMetaMaskRunner(adapter, manifest, options);
   },
   // Funding files from the run's command line, bound to the run's plan. Without
   // them, a platform whose actions take a trusted mutation (the Extension) runs a
   // plan with external mutations in the fixture-policy lane, where each action
   // applies the shared order policy; any other plan runs without one.
   trustedMutation: {
-    load: async ({ cli, ...run }) => await loadTrustedMutationBase({ ...fundingOptionsFromCli(cli), ...run }) ?? (takesTrustedMutation(cli) ? fixturePolicyMutationBase({ artifactsDir: run.artifactsDir, rootRecipe: run.rootRecipe }) : void 0),
+    load: async ({ cli, adapter, ...run }) => await loadTrustedMutationBase({ ...fundingOptionsFromCli(cli), ...run }) ?? (getAdapterSurface(adapter).actions.trustedMutation === true ? fixturePolicyMutationBase({ artifactsDir: run.artifactsDir, rootRecipe: run.rootRecipe }) : void 0),
+    // Nothing to bind (undefined): recipe-cli keeps the runner it planned with.
     authorize: async (base, plan) => {
-      if (!base || base === NO_PLAN_MUTATION) return void 0;
+      if (!base) return void 0;
       if (isFixturePolicyBase(base) && !plan.nodes.some((node) => node.capabilities.includes("external-mutation"))) {
-        return NO_PLAN_MUTATION;
+        return void 0;
       }
       return authorizeTrustedMutationPlan(base, plan);
     }
@@ -42,16 +42,6 @@ const metaMaskEngine = {
   console: consoleClassifier,
   runnerIncludes: ["src", "adapters", "library", "bin", "dist", "package.json"]
 };
-const NO_PLAN_MUTATION = /* @__PURE__ */ Symbol("no plan mutation");
-function takesTrustedMutation(cli) {
-  let adapter;
-  try {
-    ({ adapter } = resolveAdapter(cli));
-  } catch {
-    return false;
-  }
-  return getAdapterSurface(adapter).actions.trustedMutation === true;
-}
 export {
   metaMaskEngine
 };