@deeeed/metamask-harness 0.82.0 → 0.83.0

package/dist/adapters/extension/fixtures.js

@@ -1,10 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
-import { colorHumanMessage, EXIT, spawnScriptStreaming } from "@farmslot/recipe-cli/harness";
+import { colorHumanMessage, EXIT, shellQuote, spawnScriptStreaming } from "@farmslot/recipe-cli/harness";
 import { FIXTURE_STREAM_TIMEOUT_MS } from "../../commands/fixtures.js";
 import { sameFeatureFlags } from "../../feature-flags.js";
 import { runnerDir } from "../../paths.js";
 import { readExtensionPinnedFlags } from "./feature-flags.js";
+import { releaseArtifactState } from "./runtime-decision.js";
 async function applyExtensionFixture({
   target,
   fixturePath,
@@ -13,6 +14,64 @@ async function applyExtensionFixture({
   sub: action,
   fixtureFlags
 }) {
+  const artifact = releaseArtifactState(target);
+  if (artifact.status !== "none") {
+    const targetArg = `--target ${shellQuote(target)}`;
+    const cdpArg = process.env.CDP_PORT ? ` --cdp-port ${shellQuote(process.env.CDP_PORT)}` : "";
+    const canonical = path.resolve(fixturePath) === path.resolve(canonicalFixture);
+    const fixtureArg = canonical ? "" : ` --fixture ${shellQuote(fixturePath)}`;
+    const checkoutAction = `mm-harness runtime-launch --adapter extension ${targetArg}${cdpArg} && mm-harness fixtures ${action} --adapter extension ${targetArg}${fixtureArg}`;
+    let message2;
+    let artifactAction;
+    let alternatives = [];
+    if (artifact.status === "invalid") {
+      message2 = `The selected release artifact is no longer valid (${artifact.reason ?? "unknown reason"}) and fixtures will not replace it with the checkout build; re-select it with runtime-launch and the same artifact source, or seed the checkout build instead.`;
+      artifactAction = checkoutAction;
+    } else {
+      let archive;
+      try {
+        const provenance = JSON.parse(fs.readFileSync(artifact.provenancePath, "utf8"));
+        if (typeof provenance.source?.path === "string") archive = provenance.source.path;
+      } catch {
+        archive = void 0;
+      }
+      const archivePresent = archive !== void 0 && fs.existsSync(archive);
+      const reselect = [
+        `mm-harness runtime-launch --adapter extension ${targetArg}${cdpArg}`,
+        `--artifact-file ${archivePresent ? shellQuote(archive) : "<path-to-the-artifact-zip>"}`,
+        `--artifact-version ${shellQuote(artifact.expectedVersion)}`,
+        `--artifact-sha256 ${shellQuote(artifact.sha256)}`,
+        `--artifact-cache ${shellQuote(path.dirname(path.dirname(path.dirname(artifact.provenancePath))))}`,
+        `--chrome-user-data-dir ${shellQuote(artifact.chromeUserDataDir)}`,
+        "--reset-profile"
+      ].join(" ");
+      const publish = canonical ? "" : `mm-harness fixtures init --from ${shellQuote(fixturePath)} --force ${targetArg} && `;
+      const importWallet = `mm-harness run wallet.import method=ui credential_source=fixture --adapter extension ${targetArg}`;
+      artifactAction = `${publish}${reselect} && ${importWallet}`;
+      alternatives = [checkoutAction];
+      const archiveNote = archivePresent ? "" : `, supplying its archive with --artifact-file (${archive ? `${archive} no longer exists` : "its provenance names no archive"})`;
+      const fixtureNote = canonical ? "" : `, after the selected fixture replaces this slot's canonical fixture ${canonicalFixture}, the only one wallet.import reads`;
+      message2 = `Release artifact ${artifact.manifestVersion} is selected and fixtures can only seed the checkout build; re-select it with a clean profile and import the fixture wallet${archiveNote}${fixtureNote}, or seed the checkout build instead.`;
+    }
+    if (json) {
+      console.log(JSON.stringify({
+        schemaVersion: 1,
+        command: "fixtures",
+        action,
+        adapter: "extension",
+        fixture: fixturePath,
+        canonicalFixture,
+        status: "fail",
+        exitCode: EXIT.runtime,
+        error: { code: "FIXTURES_ARTIFACT_ACTIVE", message: message2, userAction: artifactAction, alternatives }
+      }, null, 2));
+    } else {
+      console.error(`\u2717 mm-harness fixtures ${action}: ${message2}
+  Next: ${artifactAction}${alternatives.map((alternative) => `
+  Or: ${alternative}`).join("")}`);
+    }
+    return EXIT.runtime;
+  }
   const distManifest = path.join(target, "dist/chrome/manifest.json");
   const userAction = `mm-harness launch --build --verify --target ${JSON.stringify(target)}`;
   if (!fs.existsSync(distManifest)) {

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

@@ -1,211 +1,24 @@
+import { createRequire } from "node:module";
 import path from "node:path";
-import brokerModule from "@farmslot/recipe-runner/cdp-broker";
-import {
-  asBrowserCdpTarget,
-  createBrowserCdpClient,
-  extensionIdFromCdpTargets,
-  fetchCdpJson
-} from "./browser-cdp.js";
-const DEVICE_ID = "extension";
-const COMMAND_TIMEOUT_MS = 1e4;
-const EXTENSION_TARGET_TYPES = /* @__PURE__ */ new Set([
-  "background_page",
-  "other",
-  "page",
-  "service_worker"
-]);
-const { brokerSocketPath, createBrokerClient, createCdpBroker } = brokerModule;
-async function createExtensionNetworkObserver(cdpPort, runtimeDir) {
-  if (!Number.isInteger(cdpPort) || cdpPort <= 0) {
-    throw new Error("Extension network observation requires a valid CDP port.");
-  }
-  const targets = await fetchCdpJson(cdpPort);
-  const extensionId = extensionIdFromCdpTargets(targets);
-  if (!extensionId) {
-    throw new Error(
-      "Extension CDP browser or loaded extension target is unavailable."
-    );
-  }
-  const connection = await createBrowserCdpClient(cdpPort);
-  let closed = false;
-  const brokerRef = {};
-  const targetSessions = /* @__PURE__ */ new Map();
-  const attaching = /* @__PURE__ */ new Set();
-  const send = (method, params = {}, sessionId, timeoutMs = COMMAND_TIMEOUT_MS) => connection.send(method, params, sessionId, timeoutMs);
-  const relevantTarget = (target) => {
-    if (!EXTENSION_TARGET_TYPES.has(String(target.type))) return false;
-    try {
-      return new URL(String(target.url)).hostname === extensionId;
-    } catch {
-      return false;
-    }
-  };
-  const refreshBrokerSession = () => {
-    if (!brokerRef.current) return;
-    brokerRef.current.onSessionClose(DEVICE_ID);
-    brokerRef.current.onSessionOpen(DEVICE_ID);
-  };
-  const attachTarget = async (target) => {
-    if (closed || !relevantTarget(target) || targetSessions.has(target.targetId) || attaching.has(target.targetId)) {
-      return;
-    }
-    attaching.add(target.targetId);
-    try {
-      const result = asRecord(
-        await send("Target.attachToTarget", {
-          targetId: target.targetId,
-          flatten: true
-        })
-      );
-      const sessionId = String(result.sessionId ?? "");
-      if (sessionId) {
-        targetSessions.set(target.targetId, sessionId);
-        refreshBrokerSession();
-      }
-    } catch (error) {
-      if (!/already attached/iu.test(String(error))) {
-        brokerRef.current?.onSessionClose(DEVICE_ID);
-      }
-    } finally {
-      attaching.delete(target.targetId);
-    }
-  };
-  connection.onMessage((message) => {
-    if (message.method === "Target.targetCreated") {
-      const target = asBrowserCdpTarget(message.params?.targetInfo);
-      if (target) void attachTarget(target);
-      return;
-    }
-    if (message.method === "Target.attachedToTarget") {
-      const target = asBrowserCdpTarget(message.params?.targetInfo);
-      const sessionId = String(message.params?.sessionId ?? "");
-      if (target && sessionId && relevantTarget(target)) {
-        targetSessions.set(target.targetId, sessionId);
-        refreshBrokerSession();
-      }
-      return;
-    }
-    if (message.method === "Target.detachedFromTarget") {
-      const sessionId = String(message.params?.sessionId ?? "");
-      for (const [targetId, activeSessionId] of targetSessions) {
-        if (activeSessionId !== sessionId) continue;
-        targetSessions.delete(targetId);
-        refreshBrokerSession();
-      }
-      return;
-    }
-    if (message.sessionId && message.method?.startsWith("Network.")) {
-      brokerRef.current?.onCdpEvent(
-        DEVICE_ID,
-        message.method,
-        message.params ?? {}
-      );
-    }
-  });
-  connection.onClose(() => {
-    if (!closed) brokerRef.current?.onSessionClose(DEVICE_ID);
-  });
-  await send("Target.setDiscoverTargets", { discover: true });
-  const targetResult = asRecord(await send("Target.getTargets"));
-  const targetInfos = Array.isArray(targetResult.targetInfos) ? targetResult.targetInfos : [];
-  await Promise.all(
-    targetInfos.map(asBrowserCdpTarget).filter((target) => Boolean(target)).map(attachTarget)
-  );
-  if (targetSessions.size === 0) {
-    connection.close();
-    throw new Error("Extension CDP exposes no attachable extension targets.");
-  }
-  const sessions = /* @__PURE__ */ new Map([[DEVICE_ID, { brokerReady: true }]]);
-  const socketPath = brokerSocketPath(
-    path.join(runtimeDir, "extension-network")
-  );
-  brokerRef.current = createCdpBroker({
-    socketPath,
-    sessions,
-    async sendCommand(_session, method, params, timeoutMs) {
-      const sessionIds = [...new Set(targetSessions.values())];
-      if (sessionIds.length === 0) {
-        throw new Error(
-          "Extension CDP has no active extension target sessions."
-        );
-      }
-      const results = await Promise.allSettled(
-        sessionIds.map(
-          (sessionId) => send(method, params, sessionId, timeoutMs)
-        )
-      );
-      const successes = results.filter(
-        (result) => result.status === "fulfilled"
-      );
-      if (successes.length === 0) {
-        const firstFailure = results.find(
-          (result) => result.status === "rejected"
-        );
-        throw new Error(
-          `Extension CDP command failed on every target: ${String(firstFailure?.reason ?? method)}`
-        );
-      }
-      if (successes.length !== results.length) {
-        results.forEach((result, index) => {
-          if (result.status === "fulfilled") return;
-          const failedSession = sessionIds[index];
-          for (const [targetId, sessionId] of targetSessions) {
-            if (sessionId === failedSession) targetSessions.delete(targetId);
-          }
-        });
-        brokerRef.current?.onSessionClose(DEVICE_ID);
-      }
-      return successes[0].value;
-    },
-    requestDiscovery() {
-      void send("Target.getTargets").then((result) => {
-        const infos = asRecord(result).targetInfos;
-        if (!Array.isArray(infos)) return;
-        for (const value of infos) {
-          const target = asBrowserCdpTarget(value);
-          if (target) void attachTarget(target);
-        }
-      }).catch(() => brokerRef.current?.onSessionClose(DEVICE_ID));
-    }
-  });
-  brokerRef.current.onSessionOpen(DEVICE_ID);
-  await waitForSocket(socketPath);
-  const client = await createBrokerClient(
-    socketPath,
-    DEVICE_ID,
-    COMMAND_TIMEOUT_MS
-  );
-  return {
-    start(params) {
-      return client.control("capture-start", params, COMMAND_TIMEOUT_MS);
-    },
-    async end(id) {
-      return asRecord(
-        await client.control("capture-end", { id }, COMMAND_TIMEOUT_MS)
-      );
-    },
-    async close() {
-      closed = true;
-      client.close();
-      brokerRef.current?.close();
-      connection.close();
-    }
-  };
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+import { idFromManifest, resolveExtensionId } from "./extension-id.js";
+async function createExtensionNetworkBackend(target, env, artifactsDir) {
+  const cdpPort = extensionCdpPort(env);
+  const { extensionId } = await resolveExtensionId(target, { cdpPort });
+  return observeExtensionNetwork(cdpPort, artifactsDir, extensionId);
 }
-async function waitForSocket(socketPath) {
-  const { existsSync } = await import("node:fs");
-  const deadline = Date.now() + COMMAND_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (existsSync(socketPath)) return;
-    await new Promise((resolve) => setTimeout(resolve, 25));
-  }
-  throw new Error("Extension network observer broker did not start.");
+async function createLoadedExtensionNetworkBackend(extensionDir, env, artifactsDir) {
+  const extensionId = idFromManifest(path.join(extensionDir, "manifest.json"));
+  return observeExtensionNetwork(extensionCdpPort(env), artifactsDir, extensionId);
 }
-async function createExtensionNetworkBackend(env, artifactsDir) {
-  return createExtensionNetworkObserver(extensionCdpPort(env), artifactsDir);
+function observeExtensionNetwork(cdpPort, artifactsDir, extensionId) {
+  const { createExtensionNetworkObserver } = createRequire(import.meta.url)(
+    "@farmslot/adapter-web/network-observer"
+  );
+  return createExtensionNetworkObserver({
+    cdpPort,
+    runtimeDir: artifactsDir,
+    ...extensionId ? { extensionId } : {}
+  });
 }
 function extensionCdpPort(env) {
   const port = Number(
@@ -218,5 +31,5 @@ function extensionCdpPort(env) {
 }
 export {
   createExtensionNetworkBackend,
-  createExtensionNetworkObserver
+  createLoadedExtensionNetworkBackend
 };

package/dist/adapters/extension/run.js

@@ -181,7 +181,7 @@ const extensionDiagnostics = {
 };
 const extensionObservation = {
   network: {
-    backend: async (_target, env, artifactsDir) => (await import("./network-observer.js")).createExtensionNetworkBackend(env, artifactsDir),
+    backend: async (target, env, artifactsDir) => (await import("./network-observer.js")).createExtensionNetworkBackend(target, env, artifactsDir),
     actions: true
   },
   performance: {

package/dist/adapters/extension/runtime.js

@@ -40,22 +40,39 @@ async function prepareExtensionRuntime(options) {
     projectRoot,
     cdpPort,
     timeoutMs: options.healthTimeoutMs,
-    pageMode: options.pageMode
+    pageMode: options.pageMode,
+    // The validation launch seeds the copied wallet fixture into a fresh
+    // profile; attaching to an existing runtime may legitimately be onboarding.
+    seededLaunchDir: seededLaunchDir(projectRoot, launch)
   });
   return { launch, health };
 }
+function seededLaunchDir(projectRoot, launch) {
+  return launch?.runtimeDir ? path.join(projectRoot, launch.runtimeDir, "live") : void 0;
+}
+const FIXTURE_SEED_RECHECK_MS = 5e3;
 async function assertHealthyExtensionRuntime(options) {
   const timeoutMs = options.timeoutMs ?? 3e4;
   const deadline = Date.now() + timeoutMs;
   let lastReport = null;
+  let onboardingSince;
   while (Date.now() <= deadline) {
     lastReport = await checkExtensionRuntimeHealth(options.projectRoot, options.cdpPort, {
-      pageMode: options.pageMode
+      pageMode: options.pageMode,
+      seededLaunchDir: options.seededLaunchDir
     });
     if (lastReport.status === "PASS") return lastReport;
     if (lastReport.errorCode === "UI_COMPOSITOR_SUSPENDED" || lastReport.errorCode === "EXTENSION_BACKGROUND_UNRESPONSIVE") {
       throw new Error(formatHealthFailure(lastReport, options.projectRoot));
     }
+    if (lastReport.errorCode === "FIXTURE_SEED_NOT_APPLIED") {
+      onboardingSince ??= Date.now();
+      if (Date.now() - onboardingSince >= FIXTURE_SEED_RECHECK_MS) {
+        throw new Error(formatHealthFailure(lastReport, options.projectRoot));
+      }
+    } else {
+      onboardingSince = void 0;
+    }
     await sleep(500);
   }
   const report = lastReport ?? failReport(options.cdpPort, ["CDP runtime was not probed."], {});
@@ -102,6 +119,24 @@ async function checkExtensionRuntimeHealth(projectRoot, cdpPort, options = {}) {
   if (String(target.url ?? "").startsWith("chrome-error://")) {
     findings.push(`Extension target resolved to chrome-error page: ${target.url}`);
   }
+  if (options.seededLaunchDir && String(target.url ?? "").includes("/onboarding/")) {
+    return {
+      status: "FAIL",
+      errorCode: "FIXTURE_SEED_NOT_APPLIED",
+      userAction: `Read logs/fixture-source.json and logs/fixture-account-parity.json in the newest run under ${shellQuote(options.seededLaunchDir)}, fix the slot's wallet fixture (${shellQuote(path.join(projectRoot, recipeRuntimeDir(), "wallet-fixture.json"))}), then rerun with --launch-existing-dist.`,
+      cdpPort,
+      targetUrl: target.url,
+      extensionId: safeExtensionId(target),
+      extensionPageTargets: extensionTargets.length,
+      findings: [
+        "FIXTURE_SEED_NOT_APPLIED: MetaMask is still on onboarding after launch: the wallet fixture was not applied."
+      ],
+      details: {
+        projectRoot,
+        targetUrls: targets.map((entry) => entry.url).filter(Boolean)
+      }
+    };
+  }
   let session;
   try {
     session = await CdpSession.connect(target.webSocketDebuggerUrl, {
@@ -653,6 +688,9 @@ async function launchLockedValidationBrowser(options) {
     "--cdp-port",
     String(options.cdpPort),
     "--launch-existing-dist",
+    // The profile is a fresh mkdtemp dir; live.sh resolves and seeds the copied
+    // wallet fixture only on a reset launch.
+    "--reset-profile",
     "--chrome-user-data-dir",
     validationProfilePath,
     "--artifacts-dir",
@@ -1001,5 +1039,6 @@ export {
   evmRpcRecoveryAction,
   extensionBackgroundProbeTimeoutMs,
   formatHealthFailure,
-  prepareExtensionRuntime
+  prepareExtensionRuntime,
+  seededLaunchDir
 };

package/dist/adapters/mobile/android-gfxinfo-performance.js

@@ -1,6 +1,8 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { summarizeFrames } from "@farmslot/adapter-rn";
+import {
+  summarizeFrames
+} from "@farmslot/recipe-runner/runtime/cdp-trace";
 const execFileAsync = promisify(execFile);
 const POLL_INTERVAL_MS = 750;
 const MAX_FRAMES = 1e5;

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

@@ -1,6 +1,7 @@
 import {
   createCdpTraceCollector
-} from "../performance/cdp-trace.js";
+} from "@farmslot/recipe-runner/runtime/cdp-trace";
+import { TRACE_KINDS, TRACE_MARKER_PREFIX } from "../performance/trace-kinds.js";
 import { connectMobileBroker } from "./network-observer.js";
 import { createAndroidGfxinfoPerformanceBackend } from "./android-gfxinfo-performance.js";
 async function createMobilePerformanceBackend(target, env) {
@@ -8,10 +9,12 @@ async function createMobilePerformanceBackend(target, env) {
     return createAndroidGfxinfoPerformanceBackend(env);
   }
   const { client } = await connectMobileBroker(target, env);
-  return createCdpTraceCollector(
-    client,
-    resolvePlatform(env),
-    async (name) => {
+  const platform = resolvePlatform(env);
+  return createCdpTraceCollector(client, {
+    kind: TRACE_KINDS[platform],
+    platform,
+    markerPrefix: TRACE_MARKER_PREFIX,
+    async marker(name) {
       const before = Date.now();
       await markRuntime(client, name);
       const after = Date.now();
@@ -20,7 +23,7 @@ async function createMobilePerformanceBackend(target, env) {
         uncertaintyMs: (after - before) / 2
       };
     }
-  );
+  });
 }
 async function markRuntime(client, name) {
   await client.send(

package/dist/adapters/performance/trace-kinds.js

@@ -0,0 +1,36 @@
+const TRACE_MARKER_PREFIX = "mmh-clock-";
+const MOBILE_TRACE_CATEGORIES = [
+  "blink.user_timing",
+  "disabled-by-default-devtools.timeline.frame"
+];
+const EXTENSION_TRACE_CATEGORIES = [
+  "blink.user_timing",
+  "devtools.timeline",
+  "disabled-by-default-devtools.timeline",
+  "disabled-by-default-devtools.timeline.frame",
+  "v8.execute"
+];
+const ANDROID_TRACE_KIND = {
+  categories: MOBILE_TRACE_CATEGORIES,
+  rendererScoped: false,
+  scope: "mobile-host",
+  nativeSource: "react-native-cdp-frame-timings",
+  javascriptTasks: false,
+  frameTiming: "draw"
+};
+const TRACE_KINDS = {
+  extension: {
+    categories: EXTENSION_TRACE_CATEGORIES,
+    rendererScoped: true,
+    scope: "extension-renderer",
+    nativeSource: "chromium-cdp-frame-timings",
+    javascriptTasks: true,
+    frameTiming: "draw"
+  },
+  ios: { ...ANDROID_TRACE_KIND, frameTiming: "cadence" },
+  android: ANDROID_TRACE_KIND
+};
+export {
+  TRACE_KINDS,
+  TRACE_MARKER_PREFIX
+};

package/dist/adapters/plugin-surface.js

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import {
   adapterPlugin,
@@ -5,6 +6,9 @@ import {
   ensureAdapterLoaded,
   selectedAdapterId
 } 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";
@@ -34,6 +38,7 @@ async function loadSelectedAdapter(command, args) {
     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,
@@ -41,11 +46,12 @@ async function loadSelectedAdapter(command, args) {
       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 (selected !== void 0 && adapterRegistry.has(selected) && refusal.code !== "ADAPTER_ID_CONFLICT") {
+    if (builtin && refusal.code !== "ADAPTER_ID_CONFLICT") {
       return void 0;
     }
     return adapterSelectionFailureOut(own.includes("--json"), command, {
@@ -56,8 +62,30 @@ async function loadSelectedAdapter(command, args) {
   }
 }
 const ADAPTER_PLUGIN_ENV = "METAMASK_RECIPE_ADAPTER_PLUGIN";
+let boundPolicy;
+async function fenceBoundPolicy() {
+  const bound = boundPolicy;
+  boundPolicy = void 0;
+  if (!bound || process.env[POLICY_ENV] !== bound.file) return;
+  const plugin = adapterPlugin(bound.adapterId);
+  try {
+    if (!plugin) throw new PolicyFenceError(`no plugin record for adapter '${bound.adapterId}'`);
+    const files = await libraryAdapterFiles(plugin.root, { module: plugin.module });
+    const covered = new Set(files.map((file) => fs.realpathSync(path.join(plugin.root, file))));
+    const scope = `${path.posix.dirname(plugin.module.replace(/^\.\//u, ""))}/ and actions/ in ${plugin.root}`;
+    process.env[POLICY_DIGEST_ENV] = fencePolicy({ file: bound.file, covered, scope });
+  } catch (error) {
+    delete process.env[POLICY_ENV];
+    delete process.env[POLICY_DIGEST_ENV];
+    throw error;
+  }
+}
 function adoptPluginAdapter(adapter) {
   const surface = bindWebDappPolicy(adapter);
+  const policy = adapter;
+  if (policy.extends === "web-dapp" && typeof policy.policy?.module === "string") {
+    boundPolicy = { adapterId: adapter.id, file: policy.policy.module };
+  }
   return {
     ...surface,
     run: {

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

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { isRecord } from "@farmslot/recipe-cli/harness";
 import { verifyOwnedCollectorControl } from "../console-capture.js";
 import { devicePlatformFromEnv } from "../performance/device-platform.js";
@@ -40,7 +41,11 @@ function walletRequestFindings(lines) {
 }
 const webDappObservation = {
   network: {
-    backend: async (_target, env, artifactsDir) => (await import("../extension/network-observer.js")).createExtensionNetworkBackend(env, artifactsDir)
+    backend: async (target, env, artifactsDir) => (await import("../extension/network-observer.js")).createLoadedExtensionNetworkBackend(
+      path.resolve(env.TERMINAL_EXTENSION_DIR || path.join(target, "temp/metamask-extension/chrome")),
+      env,
+      artifactsDir
+    )
   },
   performance: {
     start: async (context) => {

package/dist/command-contract.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import { adapterChoices, closest } from "@farmslot/recipe-cli/harness";
 import { configuredLibrarySources, operatorLibraryEnv } from "./adapters/plugin-surface.js";
 const bool = () => ({ kind: "boolean" });
@@ -440,6 +442,36 @@ function optionValues(args, name) {
   }
   return values;
 }
+const LIBRARY_ADAPTERS = {
+  terminal: { title: "MetaMask Web Terminal", repository: "MetaMask/experimental-metamask-recipe-terminal" }
+};
+const quoteArg = (value2) => /^[A-Za-z0-9_./:=@%+-]+$/u.test(value2) ? value2 : `'${value2.replaceAll("'", `'\\''`)}'`;
+function missingAdapterLibrary(command, optionName, id, tokens) {
+  const library = LIBRARY_ADAPTERS[id];
+  if (!library || optionName !== "--adapter" && optionName !== "--platform") return void 0;
+  const current = operatorLibraryEnv().RECIPE_LIBRARY_PATH;
+  const rerun = (libraryPath) => `RECIPE_LIBRARY_PATH=${quoteArg(libraryPath)} mm-harness ${[command, ...tokens].map(quoteArg).join(" ")}`;
+  const revision = `a revision whose recipe-library.json declares adapters.${id}`;
+  const older = (current ?? "").split(":").filter(Boolean).map((entry) => {
+    const separator = entry.indexOf("=");
+    return separator > 0 && !entry.slice(0, separator).includes("/") ? { name: entry.slice(0, separator), root: entry.slice(separator + 1) } : { name: void 0, root: entry };
+  }).find((entry) => entry.name === id || fs.existsSync(path.join(entry.root, "recipes", id)));
+  if (older) {
+    return {
+      code: "CLI_ADAPTER_LIBRARY_MISSING",
+      command,
+      message: `${optionName} ${id} is the ${library.title} adapter, a plugin of the ${library.repository} recipe library. The library on RECIPE_LIBRARY_PATH at ${older.root} does not declare it: an older checkout, or a recipe-library.json that does not parse.`,
+      userAction: `Update that checkout to ${revision} (e.g. git -C ${quoteArg(older.root)} pull), then rerun: ${rerun(current)}`
+    };
+  }
+  const checkout = `<${library.repository.split("/")[1]} checkout>`;
+  return {
+    code: "CLI_ADAPTER_LIBRARY_MISSING",
+    command,
+    message: `${optionName} ${id} is the ${library.title} adapter, a plugin of the ${library.repository} recipe library, and no library on RECIPE_LIBRARY_PATH, --library or the config declares it.`,
+    userAction: `Keep ${optionName} ${id} and put that library, at ${revision}, on RECIPE_LIBRARY_PATH (git clone https://github.com/${library.repository}.git ${checkout}): ${rerun(current ? `${id}=${checkout}:${current}` : `${id}=${checkout}`)}`
+  };
+}
 function validatePublicInvocation(argv, examples = {}) {
   const token = argv[0];
   if (!token || token === "--help" || token === "-h" || token === "--version" || token === "-v") return null;
@@ -509,6 +541,8 @@ function validatePublicInvocation(argv, examples = {}) {
     if (inlineValue === void 0) index += 1;
     const choices = typeof spec.choices === "function" ? spec.choices(tokens) : spec.choices;
     if (choices && !choices.includes(optionValue)) {
+      const missing = missingAdapterLibrary(name, optionName, optionValue, tokens);
+      if (missing) return missing;
       const suggestion = closest(optionValue, choices);
       return {
         code: "CLI_INVALID_OPTION_VALUE",

package/dist/commands/check.js

@@ -7,6 +7,7 @@ const USAGE = "mm-harness check diff [--fix] [--target <repo>] [--adapter <adapt
 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;
+const OXFMT_TARGET_ARGS = ["--no-error-on-unmatched-pattern"];
 const ESLINT_SUPPRESSION_RE = /^\s*eslint-disable(?:-line|-next-line)?\b/u;
 const EXTENSION_LOCALE_RE = /^app\/_locales\//u;
 async function handleCheck(argv) {
@@ -427,7 +428,7 @@ function runFormatterCheck(input) {
       label: "Changed-file oxfmt",
       ...input,
       command: oxfmt,
-      args: ["--config", oxfmtConfig, "--check"]
+      args: ["--config", oxfmtConfig, "--check", ...OXFMT_TARGET_ARGS]
     });
   }
   return runToolCheck({
@@ -447,7 +448,7 @@ function runFormatterFix(input) {
       label: "Changed-file oxfmt fix",
       ...input,
       command: oxfmt,
-      args: ["--config", oxfmtConfig, "--write"]
+      args: ["--config", oxfmtConfig, "--write", ...OXFMT_TARGET_ARGS]
     });
   }
   return runToolCheck({