@deeeed/metamask-harness 0.82.1 → 0.84.0

package/dist/adapters/extension/runtime.js

@@ -5,6 +5,7 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { importRecipeHarnessRuntimeBrowserExtension, importRecipeHarnessRuntimeCdp, resolveFarmslotPoolDir, runnerDir } from "../../paths.js";
 import { poolFilesForHost } from "../resolve-slot-ports.js";
+import { macosSessionLocked, SESSION_LOCKED_MESSAGE, SESSION_LOCKED_USER_ACTION } from "../../../adapters/shared/session-lock.mjs";
 import { profileProcessPids } from "./validation-process-ownership.js";
 const require2 = createRequire(import.meta.url);
 const { RUNTIME_NONCE_PREFIX, detachedLaunchUnprovenPath, hasDetachedLaunchUnproven, shellQuote } = require2(
@@ -40,22 +41,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") {
+    if (lastReport.errorCode === "SESSION_LOCKED" || 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 +120,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, {
@@ -114,18 +150,17 @@ async function checkExtensionRuntimeHealth(projectRoot, cdpPort, options = {}) {
       Math.min(1e3, cdpCallTimeoutMs)
     );
     if (compositor.status === "suspended") {
-      const userAction = compositorRecoveryAction(projectRoot);
+      const suspended = `UI_COMPOSITOR_SUSPENDED: the Extension page is reachable over CDP but its render compositor is not advancing (${compositor.reason ?? "unknown reason"}).`;
+      const locked = macosSessionLocked() === true;
       return {
         status: "FAIL",
-        errorCode: "UI_COMPOSITOR_SUSPENDED",
-        userAction,
+        errorCode: locked ? "SESSION_LOCKED" : "UI_COMPOSITOR_SUSPENDED",
+        userAction: locked ? SESSION_LOCKED_USER_ACTION : compositorRecoveryAction(projectRoot),
         cdpPort,
         targetUrl: target.url,
         extensionId: safeExtensionId(target),
         extensionPageTargets: extensionTargets.length,
-        findings: [
-          `UI_COMPOSITOR_SUSPENDED: the Extension page is reachable over CDP but its render compositor is not advancing (${compositor.reason ?? "unknown reason"}).`
-        ],
+        findings: locked ? [`SESSION_LOCKED: ${SESSION_LOCKED_MESSAGE}`, suspended] : [suspended],
         details: {
           projectRoot,
           targetUrls: targets.map((entry) => entry.url).filter(Boolean),
@@ -634,7 +669,7 @@ async function launchLockedValidationBrowser(options) {
   await stopOwnedCdpListener(options.cdpPort, [
     validationRuntimePath,
     path.join(options.projectRoot, recipeRuntimeDir())
-  ]);
+  ], path.join(options.projectRoot, recipeRuntimeDir()));
   assertNoLiveValidationProfileOwners(validationProfileRoot);
   pruneValidationRuns(validationProfileRoot, 0);
   pruneValidationRuns(validationArtifactsRoot, 4);
@@ -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",
@@ -895,16 +933,32 @@ function runProcess(command, args, options) {
     });
   });
 }
-async function stopOwnedCdpListener(cdpPort, runtimePaths) {
+async function stopOwnedCdpListener(cdpPort, runtimePaths, checkoutRuntimeRoot) {
   if (process.platform !== "darwin" && process.platform !== "linux") return;
   let listenerPids = await inspectCdpListenerPids(cdpPort);
   if (listenerPids.length === 0) return;
   const identity = runtimePaths.map((runtimePath) => readValidationRuntimeIdentity(runtimePath, cdpPort)).find((candidate) => candidate?.pid === listenerPids[0]);
-  if (!identity || listenerPids.length !== 1 || listenerPids[0] !== identity.pid || !await browserEchoesRuntimeNonce(cdpPort, identity.nonce)) {
-    throw new Error(`Extension validation will not stop an unowned CDP listener on port ${cdpPort}.`);
+  let pid;
+  if (identity && listenerPids.length === 1 && listenerPids[0] === identity.pid && await browserEchoesRuntimeNonce(cdpPort, identity.nonce)) {
+    pid = identity.pid;
+  }
+  if (pid === void 0) {
+    const listeners = await listenerCommands(listenerPids);
+    const listener = listenerPids.length === 1 ? listeners.get(listenerPids[0]) : void 0;
+    if (listener?.chrome && !listener.ambiguous && pathInsideReal(checkoutRuntimeRoot, listener.profile) && (await listenerCommands(listenerPids)).get(listenerPids[0])?.command === listener.command) {
+      pid = listenerPids[0];
+    } else {
+      const seen = listenerPids.map((candidate) => {
+        const profile = listeners.get(candidate)?.profile;
+        return profile ? `pid ${candidate} --user-data-dir=${profile}` : `pid ${candidate}`;
+      }).join("; ");
+      throw new Error(
+        `Extension validation will not stop an unowned CDP listener on port ${cdpPort} (${seen}). Next: if that is this slot's browser, stop it (kill ${listenerPids.join(" ")}); otherwise free port ${cdpPort}. Then rerun.`
+      );
+    }
   }
   try {
-    process.kill(identity.pid, "SIGTERM");
+    process.kill(pid, "SIGTERM");
   } catch (error) {
     if (error.code !== "ESRCH") throw error;
   }
@@ -912,10 +966,10 @@ async function stopOwnedCdpListener(cdpPort, runtimePaths) {
   do {
     await sleep(50);
     listenerPids = await inspectCdpListenerPids(cdpPort);
-  } while ((listenerPids.length > 0 || processExists(identity.pid)) && Date.now() < termDeadline);
-  if (listenerPids.length > 0 || processExists(identity.pid)) {
+  } while ((listenerPids.length > 0 || processExists(pid)) && Date.now() < termDeadline);
+  if (listenerPids.length > 0 || processExists(pid)) {
     try {
-      process.kill(identity.pid, "SIGKILL");
+      process.kill(pid, "SIGKILL");
     } catch (error) {
       if (error.code !== "ESRCH") throw error;
     }
@@ -923,12 +977,48 @@ async function stopOwnedCdpListener(cdpPort, runtimePaths) {
     do {
       await sleep(50);
       listenerPids = await inspectCdpListenerPids(cdpPort);
-    } while ((listenerPids.length > 0 || processExists(identity.pid)) && Date.now() < killDeadline);
+    } while ((listenerPids.length > 0 || processExists(pid)) && Date.now() < killDeadline);
   }
-  if (listenerPids.length > 0 || processExists(identity.pid)) {
+  if (listenerPids.length > 0 || processExists(pid)) {
     throw new Error(`Extension validation could not stop its CDP listener on port ${cdpPort}.`);
   }
 }
+async function listenerCommands(pids) {
+  const listeners = /* @__PURE__ */ new Map();
+  const result = await runProcess("ps", ["-ww", "-o", "pid=,command=", "-p", pids.join(",")], {
+    cwd: runnerDir,
+    env: process.env,
+    timeoutMs: 5e3
+  });
+  if (result.timedOut) return listeners;
+  for (const line of result.stdout.split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(.*)$/u);
+    if (!match) continue;
+    const command = match[2];
+    const flags = [...command.matchAll(/(?:^|\s)--user-data-dir=/gu)];
+    const last = flags.at(-1);
+    if (!last) continue;
+    const value = command.slice(last.index + last[0].length);
+    const ends = [...value.matchAll(/\s--/gu)].map((end) => end.index);
+    const profile = value.slice(0, ends[0] ?? value.length);
+    const longerReadings = [...ends.slice(1), value.length].map((end) => value.slice(0, end));
+    listeners.set(Number(match[1]), {
+      command,
+      profile,
+      chrome: /chrom/iu.test(path.basename(command.split(/\s-/u)[0])),
+      ambiguous: flags.length > 1 || !path.isAbsolute(profile) || ends.length > 0 && longerReadings.some((reading) => fs.existsSync(reading))
+    });
+  }
+  return listeners;
+}
+function pathInsideReal(root, candidate) {
+  try {
+    const relative = path.relative(fs.realpathSync(root), fs.realpathSync(candidate));
+    return Boolean(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  } catch {
+    return false;
+  }
+}
 async function inspectCdpListenerPids(cdpPort) {
   const result = await runProcess("lsof", ["-ti", `tcp:${cdpPort}`, "-sTCP:LISTEN"], {
     cwd: runnerDir,
@@ -1001,5 +1091,7 @@ export {
   evmRpcRecoveryAction,
   extensionBackgroundProbeTimeoutMs,
   formatHealthFailure,
-  prepareExtensionRuntime
+  prepareExtensionRuntime,
+  seededLaunchDir,
+  stopOwnedCdpListener
 };

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/devices.js

@@ -9,7 +9,11 @@ import {
 } from "../../commands/mobile-device-view.js";
 const mobileDevices = {
   view: mobileDeviceView,
-  live: mobileDeviceLiveView,
+  // adapter-sdk's live view names the app's feature-flag overrides `featureFlags`.
+  async live(target, view) {
+    const live = await mobileDeviceLiveView(target, view);
+    return { ...live, featureFlags: live.featureFlagOverrides };
+  },
   renderList: renderMobileDeviceList,
   renderAdditional: renderAdditionalReachableDevices,
   renderLive: renderMobileLiveBlock,

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/mobile/run.js

@@ -82,7 +82,7 @@ async function ensureMobileProofRuntime(target, _heal, state, json, deps = {}) {
   }
   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 userAction = `mm-harness call app.lifecycle command=restart --adapter mobile --target ${targetArg}`;
   const message = `Mobile loaded source is not current (${initial.status}).`;
   emitProofFailure(json, {
     recoverable: true,

package/dist/adapters/mobile/surface.js

@@ -53,9 +53,8 @@ const mobileSurface = defineAdapter({
   devServer: {
     label: "metro",
     describe: () => "Metro dev server",
-    // Metro's leaves read the port as METRO_PORT; run and call take it as --metro-port.
+    // Metro's leaves read the port as METRO_PORT.
     portEnv: ["METRO_PORT"],
-    portFlags: ["metroPort"],
     stop(target) {
       const leaf = path.join(runnerDir, "adapters", "mobile", "stop-metro.sh");
       const args = ["--target", target];

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,12 +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 { configPath, declaredLibraryPathEnv, readConfig } from "../review/knowledge.js";
-import { adapterRegistry } from "./registry.js";
 import { bindWebDappPolicy } from "./web-dapp/surface.js";
 function configuredLibrarySources() {
   let libraries;
@@ -25,39 +22,41 @@ 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 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 {
-    await ensureAdapterLoaded(selected, {
-      libraries,
-      configured: configuredLibrarySources(),
-      env: operatorLibraryEnv(),
-      adopt: adoptPluginAdapter
-    });
-    return void 0;
+    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) {
-    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;
+    delete process.env[POLICY_ENV];
+    delete process.env[POLICY_DIGEST_ENV];
+    throw error;
+  }
+}
+async function afterAdapterLoad() {
+  try {
+    await fenceBoundPolicy();
+  } catch (error) {
+    if (error instanceof PolicyFenceError) {
+      throw new AdapterPluginError("ADAPTER_PLUGIN_INVALID", error.message, error.userAction);
     }
-    return adapterSelectionFailureOut(own.includes("--json"), command, {
-      code: refusal.code,
-      message: String(refusal.message),
-      userAction: refusal.userAction
-    });
+    throw error;
   }
 }
-const ADAPTER_PLUGIN_ENV = "METAMASK_RECIPE_ADAPTER_PLUGIN";
 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: {
@@ -92,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/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,46 +1,50 @@
+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")).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) => {
@@ -54,5 +58,7 @@ const webDappObservation = {
 };
 export {
   webDappDiagnostics,
-  webDappObservation
+  webDappObservation,
+  webDappRun,
+  webDappRunHeadless
 };