@deeeed/metamask-harness 0.80.0 → 0.82.0

package/dist/adapters/mobile/actions.js

@@ -1,4 +1,5 @@
 import { manifestPath } from "../../paths.js";
+import { perpsOrderInputFindings } from "../perps-order-inputs.js";
 const NATIVE_PROVIDER_UI_ACTIONS = /* @__PURE__ */ new Set([
   "ui.press",
   "ui.key_press",
@@ -47,7 +48,9 @@ const mobileActions = {
     }
   }),
   wrap: async (adapters) => (await import("./runtime-identity.js")).withMobileNativeRuntimeIdentity(adapters),
-  lifecycle: async (adapters) => (await import("./lifecycle.js")).mobileSourceAwareLifecycleAdapters(adapters)
+  lifecycle: async (adapters) => (await import("./lifecycle.js")).mobileSourceAwareLifecycleAdapters(adapters),
+  // ensure_positions and ensure_orders with an open or present state place an order.
+  inputFindings: (nodeId, node) => perpsOrderInputFindings(nodeId, node, { ensureChecksOnly: false })
 };
 export {
   mobileActions

package/dist/adapters/mobile/network-observer.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import brokerModule from "@farmslot/recipe-runner/cdp-broker";
+import configModule from "@farmslot/adapter-rn/bridge-runtime/lib/config.cjs";
+const { brokerSocketPath, createBrokerClient } = brokerModule;
+const { resolvePort } = configModule;
+async function createMobileNetworkBackend(target, env) {
+  const { client } = await connectMobileBroker(target, env);
+  return {
+    start(params) {
+      return client.control("capture-start", params, 1e4);
+    },
+    async end(id) {
+      return asRecord(await client.control("capture-end", { id }, 1e4));
+    },
+    async close() {
+      client.close();
+    }
+  };
+}
+async function connectMobileBroker(target, env) {
+  const runtimeDir = env.RECIPE_RUNTIME_DIR ? path.resolve(target, env.RECIPE_RUNTIME_DIR) : path.join(target, "temp", "recipe", "runtime");
+  const socketPath = brokerSocketPath(
+    runtimeDir,
+    resolvePort(env, target)
+  );
+  const discoveryClient = await createBrokerClient(socketPath, "", 1e4);
+  let targets;
+  try {
+    targets = await discoveryClient.control(
+      "resolve-targets",
+      { nameIncludes: mobileTargetPin(env) },
+      1e4
+    );
+  } finally {
+    discoveryClient.close();
+  }
+  const deviceId = selectMobileBrokerTarget(targets, env);
+  const client = await createBrokerClient(socketPath, deviceId, 1e4);
+  return { client, deviceId };
+}
+function selectMobileBrokerTarget(value, env) {
+  const targets = Array.isArray(value) ? value.map(asRecord).filter((target) => target.deviceId) : [];
+  const pin = mobileTargetPin(env);
+  const candidates = pin ? targets.filter(
+    (target) => String(target.name ?? "").toLowerCase().includes(pin.toLowerCase())
+  ) : targets;
+  if (candidates.length !== 1) {
+    throw new Error(
+      `Mobile network observation requires one broker target; found ${candidates.length}.`
+    );
+  }
+  return String(candidates[0].deviceId);
+}
+function mobileTargetPin(env) {
+  const platform = String(
+    env.RECIPE_RN_EXPLICIT_PLATFORM ?? env.RECIPE_HARNESS_PLATFORM ?? ""
+  ).toLowerCase();
+  return String(
+    platform === "android" ? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? "" : platform === "ios" ? env.IOS_SIMULATOR ?? "" : env.IOS_SIMULATOR ?? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? ""
+  ).trim();
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export {
+  connectMobileBroker,
+  createMobileNetworkBackend
+};

package/dist/adapters/mobile/performance-observer.js

@@ -1,9 +1,7 @@
 import {
   createCdpTraceCollector
 } from "../performance/cdp-trace.js";
-import {
-  connectMobileBroker
-} from "../../network-observation.js";
+import { connectMobileBroker } from "./network-observer.js";
 import { createAndroidGfxinfoPerformanceBackend } from "./android-gfxinfo-performance.js";
 async function createMobilePerformanceBackend(target, env) {
   if (resolvePlatform(env) === "android") {

package/dist/adapters/mobile/run.js

@@ -1,4 +1,4 @@
-import { isRecord } from "@farmslot/recipe-cli/harness";
+import { EXIT, isRecord } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { IOS_SIMULATOR_RECORDING_TARGET_PREFIX } from "@farmslot/adapter-rn";
@@ -8,6 +8,7 @@ import {
   resolveAndroidDeviceSerial,
   resolveMobileIosSimulatorName
 } from "./recording-target.js";
+import { emitProofFailure } from "../proof-failure.js";
 import { mobileAppIdentityEnv } from "./app-identity.js";
 import { requireCurrentMobileReleaseArtifactState } from "./release-artifact-state.js";
 const EXPLICIT_DEVICE_KEYS = [
@@ -51,7 +52,10 @@ const mobileRun = {
     ADB_SERIAL: process.env.ADB_SERIAL,
     ANDROID_SERIAL: process.env.ANDROID_SERIAL,
     ...mobileAppIdentityEnv(),
-    METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME: process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME
+    METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME: process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME,
+    // The platform `--platform`/`--device` pinned; the React Native bridge
+    // matches its target against it.
+    RECIPE_RN_EXPLICIT_PLATFORM: process.env.RECIPE_RN_EXPLICIT_PLATFORM
   }),
   // An installed release artifact is opaque: no harness HUD inside it.
   autoHud: () => process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME !== "1",
@@ -65,12 +69,28 @@ const mobileRun = {
   // source only matters for a development build the caller did not restart.
   runtimeCheck({ target, heal, state, json, appRestartAuthored }) {
     if (requireCurrentMobileReleaseArtifactState(target) !== null || appRestartAuthored) return void 0;
-    return async () => {
-      const { ensureMobileProofRuntime } = await import("../../commands/run-engine.js");
-      return ensureMobileProofRuntime(target, heal, state, json);
-    };
+    return () => ensureMobileProofRuntime(target, heal, state, json);
   }
 };
+async function ensureMobileProofRuntime(target, _heal, state, json, deps = {}) {
+  const source = await import("./source-freshness.js");
+  const check = deps.check ?? (() => source.mobileSourceCheck(target));
+  const initial = check();
+  if (initial.status === "unavailable") {
+    emitProofFailure(json, { recoverable: false, error: initial.error });
+    return EXIT.usage;
+  }
+  if (initial.status === "current") return null;
+  const targetArg = JSON.stringify(path.resolve(target));
+  const userAction = `mm-harness call app.lifecycle --arg command=restart --adapter mobile --target ${targetArg}`;
+  const message = `Mobile loaded source is not current (${initial.status}).`;
+  emitProofFailure(json, {
+    recoverable: true,
+    mutations: state.mutations,
+    error: { code: "MOBILE_SOURCE_NOT_LOADED", message, userAction }
+  });
+  return EXIT.infra;
+}
 const mobileRecording = {
   target: (context) => resolveMobileRecordingTarget(context),
   // An Android device records through the mirror, with screenrecord as the
@@ -127,11 +147,13 @@ const mobileDiagnostics = {
 };
 const mobileObservation = {
   network: {
-    backend: async (target, env) => (await import("../../network-observation.js")).createMobileNetworkBackend(target, env)
+    backend: async (target, env) => (await import("./network-observer.js")).createMobileNetworkBackend(target, env)
   },
   performance: {
-    backend: async (target, env) => (await import("./performance-observer.js")).createMobilePerformanceBackend(target, env),
-    platform: (env) => devicePlatformFromEnv(env)
+    start: async (context) => (await import("../../performance-observation.js")).startRunPerformanceObservation({
+      backend: async (target, env) => (await import("./performance-observer.js")).createMobilePerformanceBackend(target, env),
+      platform: (env) => devicePlatformFromEnv(env)
+    }, context)
   }
 };
 function runMobileIssueCommand(projectRoot, command) {
@@ -150,6 +172,7 @@ function runMobileIssueCommand(projectRoot, command) {
   }
 }
 export {
+  ensureMobileProofRuntime,
   mobileDiagnostics,
   mobileObservation,
   mobileRecording,

package/dist/adapters/perps-order-inputs.js

@@ -0,0 +1,36 @@
+function perpsOrderInputFindings(nodeId, node, { ensureChecksOnly }) {
+  const action = node.action;
+  const state = typeof node.state === "string" ? node.state.toLowerCase() : void 0;
+  const createsOrder = action === "metamask.perps.place_order" || !ensureChecksOnly && (action === "metamask.perps.ensure_positions" || action === "metamask.perps.ensure_orders") && (state === "open" || state === "present");
+  if (!createsOrder) return [];
+  const findings = [];
+  const requireOneOf = (names, message) => {
+    const present = names.some((name) => {
+      const value = node[name];
+      return value !== void 0 && value !== null && value !== "";
+    });
+    if (present) return;
+    findings.push({
+      severity: "error",
+      code: "recipe.missing_param",
+      path: `workflow.nodes.${nodeId}.${names[0]}`,
+      message
+    });
+  };
+  requireOneOf(
+    ["market", "symbol"],
+    `${action} requires market=<symbol> (or symbol=<symbol>) before it may create an order`
+  );
+  requireOneOf(
+    ["side"],
+    `${action} requires side=long or side=short before it may create an order`
+  );
+  requireOneOf(
+    ["amount", "notional"],
+    `${action} requires amount=<usd> or notional=<usd> before it may create an order`
+  );
+  return findings;
+}
+export {
+  perpsOrderInputFindings
+};

package/dist/adapters/plugin-surface.js

@@ -0,0 +1,98 @@
+import path from "node:path";
+import {
+  adapterPlugin,
+  adapterSelectionFailureOut,
+  ensureAdapterLoaded,
+  selectedAdapterId
+} from "@farmslot/recipe-cli/harness";
+import { configPath, declaredLibraryPathEnv, readConfig } from "../review/knowledge.js";
+import { adapterRegistry } from "./registry.js";
+import { bindWebDappPolicy } from "./web-dapp/surface.js";
+function configuredLibrarySources() {
+  let libraries;
+  try {
+    libraries = readConfig(configPath()).libraries;
+  } catch {
+    return [];
+  }
+  return Object.entries(libraries ?? {}).map(([name, root]) => ({ name, root: path.resolve(root) }));
+}
+function operatorLibraryEnv() {
+  const declared = declaredLibraryPathEnv();
+  if (!declared) return process.env;
+  const env = { ...process.env };
+  if (declared.value === void 0) delete env.RECIPE_LIBRARY_PATH;
+  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);
+  try {
+    await ensureAdapterLoaded(selected, {
+      libraries,
+      configured: configuredLibrarySources(),
+      env: operatorLibraryEnv(),
+      adopt: adoptPluginAdapter
+    });
+    return void 0;
+  } catch (error) {
+    const refusal = error;
+    if (typeof refusal.code !== "string" || typeof refusal.userAction !== "string") throw error;
+    if (selected !== void 0 && adapterRegistry.has(selected) && 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";
+function adoptPluginAdapter(adapter) {
+  const surface = bindWebDappPolicy(adapter);
+  return {
+    ...surface,
+    run: {
+      ...surface.run,
+      envKeys: [...surface.run?.envKeys ?? [], ADAPTER_PLUGIN_ENV],
+      activateEnv(projectRoot, options) {
+        surface.run?.activateEnv?.(projectRoot, options);
+        process.env[ADAPTER_PLUGIN_ENV] = `${adapter.id} ${adapterPlugin(adapter.id)?.digest ?? "unknown"}`;
+      }
+    },
+    runwayProvision: surface.runwayProvision ?? {
+      async run(target) {
+        return {
+          schemaVersion: 1,
+          command: "provision",
+          adapter: adapter.id,
+          target: path.resolve(target),
+          status: "fail",
+          exitCode: 2,
+          error: {
+            code: "UNSUPPORTED_ADAPTER",
+            message: `${adapter.id} has no mobile simulator to provision.`,
+            userAction: `mm-harness run <recipe> --adapter ${adapter.id}`
+          }
+        };
+      }
+    },
+    readiness: surface.readiness ?? { compatibilityMode: () => "unsupported/no bridge" },
+    fixtures: surface.fixtures ?? { operations: [] }
+  };
+}
+export {
+  ADAPTER_PLUGIN_ENV,
+  adoptPluginAdapter,
+  configuredLibrarySources,
+  loadSelectedAdapter,
+  operatorLibraryEnv
+};

package/dist/adapters/proof-failure.js

@@ -0,0 +1,11 @@
+function emitProofFailure(json, failure) {
+  if (json) {
+    console.log(JSON.stringify({ schemaVersion: 1, status: "fail", ...failure }, null, 2));
+    return;
+  }
+  console.error(`\u2717 ${failure.error.message}`);
+  console.error(`  Next: ${failure.error.userAction}`);
+}
+export {
+  emitProofFailure
+};

package/dist/adapters/surface.js

@@ -3,7 +3,7 @@ import { adapterRegistry } from "./registry.js";
 import "./mobile/surface.js";
 import "./extension/surface.js";
 import "./core/surface.js";
-import "./terminal/surface.js";
+import "./web-dapp/surface.js";
 function getAdapterSurface(adapter) {
   return adapterRegistry.get(adapter);
 }

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

@@ -1,6 +1,7 @@
 import { manifestPath } from "../../paths.js";
-const terminalActions = {
-  manifestPath: () => manifestPath("terminal"),
+import { perpsOrderInputFindings } from "../perps-order-inputs.js";
+const webDappActions = {
+  manifestPath: () => manifestPath("web-dapp"),
   semantic: [
     "app.network_capture",
     "app.network_assert",
@@ -11,8 +12,8 @@ const terminalActions = {
   ui: (harness, { hudPolicy }) => ({
     base: harness.createCdpWebUiTransport({
       async withPage(input, callback) {
-        const { withTerminalPage } = await import("../../../library/actions/terminal/platform/page.mjs");
-        return withTerminalPage(
+        const { withAppPage } = await import("../../../library/actions/web-dapp/platform/page.mjs");
+        return withAppPage(
           {
             action: input.action,
             node: input.node,
@@ -28,16 +29,18 @@ const terminalActions = {
     }),
     async execute(action, node, context, standard) {
       if (action === "app.hud") {
-        const { showTerminalHud } = await import("../../../library/actions/terminal/platform/hud.mjs");
-        return showTerminalHud(
+        const { showAppHud } = await import("../../../library/actions/web-dapp/platform/hud.mjs");
+        return showAppHud(
           { action, node, context: { nodeId: context.nodeId, projectRoot: context.projectRoot } },
           { hudPolicy }
         );
       }
       return standard();
     }
-  })
+  }),
+  // ensure_positions and ensure_orders with an open or present state place an order.
+  inputFindings: (nodeId, node) => perpsOrderInputFindings(nodeId, node, { ensureChecksOnly: false })
 };
 export {
-  terminalActions
+  webDappActions
 };

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

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import { recipeRuntimePath } from "@farmslot/recipe-cli/harness";
+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),
+    pageLog: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.app),
+    collectorLog: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.collectorLog),
+    pidFile: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.pidFile)
+  };
+}
+function webDappCdpPort() {
+  return process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
+}
+async function ensureWebDappConsoleCapture(target) {
+  const cdpPort = webDappCdpPort();
+  if (!cdpPort) {
+    const id = webDappAdapterId();
+    throw new Error(`${id.charAt(0).toUpperCase()}${id.slice(1)} console capture requires the slot CDP port.`);
+  }
+  await ensureConsoleCollector({
+    cdpPort,
+    ...webDappCaptureFiles(target),
+    waitForAttachment: false,
+    cwd: target
+  });
+}
+async function verifyWebDappConsoleControl(capture) {
+  let browser = null;
+  try {
+    const value = JSON.parse(fs.readFileSync(webDappRuntimeFile(capture.projectRoot, "browser.json"), "utf8"));
+    browser = typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    browser = null;
+  }
+  if (typeof browser?.appOrigin !== "string") return { ok: false, detail: "no slot browser state (browser.json) to verify the page console capture against" };
+  return verifyCapture({ cdpPort: capture.cdpPort, log: capture.pageLog, target: "page", appOrigin: browser.appOrigin });
+}
+export {
+  WEB_DAPP_CONSOLE_FILES,
+  ensureWebDappConsoleCapture,
+  verifyWebDappConsoleControl,
+  webDappCaptureFiles,
+  webDappCdpPort,
+  webDappRuntimeFile
+};

package/dist/adapters/web-dapp/doctor-checks.js

@@ -0,0 +1,33 @@
+import { POLICY_ENV, webDappPolicy } from "../../../adapters/web-dapp/lib/policy.mjs";
+import { webDappAppPort, webDappCdpPort } from "./surface.js";
+async function webDappDoctorChecks(target) {
+  if (!process.env[POLICY_ENV]) {
+    return [{
+      id: "web-dapp-venue-policy",
+      status: "fail",
+      required: true,
+      message: "web-dapp needs a venue policy: select an adapter that extends it (e.g. --adapter terminal with its recipe library on RECIPE_LIBRARY_PATH)."
+    }];
+  }
+  const policy = webDappPolicy();
+  const { webDappReadiness } = await import("../../../adapters/web-dapp/lib/readiness.mjs");
+  const { resolveBrowser } = await import("../../../adapters/web-dapp/launch.mjs");
+  const report = await webDappReadiness({
+    policy,
+    target,
+    appPort: webDappAppPort(),
+    cdpPort: webDappCdpPort(),
+    signer: process.env.TERMINAL_SIGNER || "extension",
+    account: process.env.TERMINAL_ACCOUNT || "dev1",
+    probeBrowser: resolveBrowser
+  });
+  return report.checks.map((check) => ({
+    id: `${policy.adapterId}-${check.id}`,
+    status: check.status === "pass" ? "pass" : "fail",
+    required: check.required,
+    message: check.detail
+  }));
+}
+export {
+  webDappDoctorChecks
+};

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,21 +26,22 @@ 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",
@@ -61,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 {
@@ -70,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,16 +38,21 @@ function walletRequestFindings(lines) {
   }
   return findings;
 }
-const terminalObservation = {
+const webDappObservation = {
   network: {
-    backend: async (_target, env, artifactsDir) => (await import("../../network-observation.js")).createExtensionNetworkBackend(env, artifactsDir)
+    backend: async (_target, env, artifactsDir) => (await import("../extension/network-observer.js")).createExtensionNetworkBackend(env, artifactsDir)
   },
   performance: {
-    backend: async (target, env, ports) => (await import("../../performance-observation.js")).createExtensionPerformanceObserver(target, env, ports),
-    platform: (env) => devicePlatformFromEnv(env)
+    start: async (context) => {
+      const observation = await import("../../performance-observation.js");
+      return observation.startRunPerformanceObservation({
+        backend: (target, env) => observation.createExtensionPerformanceObserver(target, env),
+        platform: (env) => devicePlatformFromEnv(env)
+      }, context);
+    }
   }
 };
 export {
-  terminalDiagnostics,
-  terminalObservation
+  webDappDiagnostics,
+  webDappObservation
 };