@deeeed/metamask-harness 0.82.1 → 0.84.0

package/dist/adapters/core/readiness.js

@@ -1,11 +1,140 @@
+import { spawn } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { coreDependencyBlock } from "../../commands/core-readiness.js";
+import { shellQuote } from "@farmslot/recipe-cli/harness";
 import { resolveLiveTsx } from "../../live-tsx.js";
+import { runnerDir } from "../../paths.js";
 const coreReadiness = {
   compatibilityMode: (target) => fs.existsSync(path.join(target, "packages/perps-controller/src/index.ts")) ? "headless controller (no bridge)" : "unsupported/no bridge",
-  checks: (target) => [coreControllerActionsCheck(target)]
+  checks: (target) => [coreControllerActionsCheck(target)],
+  // Installed dependencies and a tsx are not enough: a partial workspace build
+  // can still leave the controller unimportable. Import it the way the actions
+  // do, once the cheaper gate passes. runtimeStatus asks the same question, so
+  // --print-ready, --expect-live and verify agree.
+  liveChecks: async (target) => coreDependencyBlock(target) ? [] : [coreControllerImportCheck(await coreControllerImport(target))],
+  // doctor --fix cannot build the workspace: an unimportable controller stays failed.
+  runtimeBlock: (_target, runtime) => runtime?.reasonCode === "CORE_CONTROLLER_IMPORT_FAILED" ? { id: "core-controller-import", userAction: runtime.nextAction } : void 0
 };
+const CONTROLLER_IMPORT_TIMEOUT_MS = 6e4;
+const PARENT_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+function isProbeReport(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const report = value;
+  const optionalString = (field) => field === void 0 || field === null || typeof field === "string";
+  return typeof report.ok === "boolean" && optionalString(report.code) && optionalString(report.url) && (report.message === void 0 || typeof report.message === "string");
+}
+function coreRebuildAction(target) {
+  return `cd ${shellQuote(path.resolve(target))} && yarn build`;
+}
+const controllerImports = /* @__PURE__ */ new Map();
+function coreControllerImport(target) {
+  const key = path.resolve(target);
+  let result = controllerImports.get(key);
+  if (!result) {
+    result = probeControllerImport(key);
+    controllerImports.set(key, result);
+  }
+  return result;
+}
+async function probeControllerImport(target) {
+  const runner = resolveLiveTsx(target);
+  if (!runner) return { ok: false, reason: "no tsx runtime found" };
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "mm-harness-core-probe-"));
+  let cancelledBy;
+  try {
+    const { coreSurface } = await import("./surface.js");
+    const env = { ...process.env, ...await coreSurface.actions.tsxLiveScripts?.env(target, tempDir) };
+    const probe = path.join(runnerDir, "adapters/core/controller-import-probe.mjs");
+    const run = await runBounded(runner.bin, [probe, target], target, env);
+    cancelledBy = run.cancelledBy;
+    if (run.spawnError) {
+      return { ok: false, reason: `tsx (${runner.source}) ${runner.bin} could not start: ${run.spawnError.code ?? run.spawnError.message}`, code: run.spawnError.code };
+    }
+    if (run.timedOut) {
+      return {
+        ok: false,
+        reason: `importing the Perps controller took over ${CONTROLLER_IMPORT_TIMEOUT_MS / 1e3}s`,
+        userAction: coreRebuildAction(target)
+      };
+    }
+    const line = run.stdout.trim().split("\n").at(-1) ?? "";
+    let parsed;
+    if (line.startsWith("{")) {
+      try {
+        parsed = JSON.parse(line);
+      } catch (error) {
+        if (!(error instanceof SyntaxError)) throw error;
+      }
+    }
+    const report = isProbeReport(parsed) ? parsed : void 0;
+    if (!report || run.exitCode !== 0) {
+      return { ok: false, reason: `tsx (${runner.source}) ${runner.bin} did not run the controller import probe (exit ${run.exitCode ?? "signal"})` };
+    }
+    if (report.ok) return { ok: true };
+    const missingModule = report.code === "ERR_MODULE_NOT_FOUND" || report.code === "MODULE_NOT_FOUND";
+    const detail = report.url ?? report.message?.split("\n")[0];
+    return {
+      ok: false,
+      reason: missingModule ? `a module is missing (${detail})` : String(detail),
+      code: report.code ?? void 0,
+      userAction: coreRebuildAction(target)
+    };
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    if (cancelledBy) process.kill(process.pid, cancelledBy);
+  }
+}
+function coreControllerImportCheck(result) {
+  const id = "core-controller-import";
+  if (result.ok) {
+    return { id, status: "pass", required: true, message: "the Perps controller imports under the action runtime." };
+  }
+  return {
+    id,
+    status: "fail",
+    required: true,
+    message: `metamask.perps.* actions cannot import the Perps controller: ${result.reason}.`,
+    ...result.code ? { detail: result.code } : {},
+    ...result.userAction ? { userAction: result.userAction } : {}
+  };
+}
+function runBounded(bin, args, cwd, env) {
+  return new Promise((resolve) => {
+    const child = spawn(bin, args, { cwd, env, stdio: ["ignore", "pipe", "ignore"], detached: true });
+    let stdout = "";
+    let timedOut = false;
+    let cancelledBy;
+    const killGroup = () => {
+      if (child.pid === void 0) return;
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch (error) {
+        if (error.code !== "ESRCH") throw error;
+      }
+    };
+    const onSignal = (signal) => {
+      cancelledBy ??= signal;
+      killGroup();
+    };
+    for (const signal of PARENT_SIGNALS) process.on(signal, onSignal);
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killGroup();
+    }, CONTROLLER_IMPORT_TIMEOUT_MS);
+    const settle = (run) => {
+      clearTimeout(timer);
+      for (const signal of PARENT_SIGNALS) process.off(signal, onSignal);
+      resolve({ ...run, ...cancelledBy ? { cancelledBy } : {} });
+    };
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.on("error", (error) => settle({ stdout, exitCode: null, timedOut: false, spawnError: error }));
+    child.on("close", (code) => settle({ stdout, exitCode: code, timedOut }));
+  });
+}
 function coreControllerActionsCheck(target) {
   const block = coreDependencyBlock(target);
   if (block) {
@@ -31,5 +160,7 @@ function coreControllerActionsCheck(target) {
   };
 }
 export {
-  coreReadiness
+  coreControllerImport,
+  coreReadiness,
+  coreRebuildAction
 };

package/dist/adapters/core/surface.js

@@ -1,20 +1,50 @@
-import { shellQuote } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
-import { depsCheck } from "@farmslot/recipe-runner/runtime/deps-readiness";
+import { checkoutWorkspacePackages, createNodeAdapter } from "@farmslot/adapter-node";
 import { defineAdapter } from "@farmslot/adapter-sdk";
+import { shellQuote } from "@farmslot/recipe-cli/harness";
+import { depsCheck } from "@farmslot/recipe-runner/runtime/deps-readiness";
+import { coreDependencyBlock } from "../../commands/core-readiness.js";
+import { checkoutHas, checkoutHasDir } from "../checkout-files.js";
 import { adapterRegistry } from "../registry.js";
 import { coreActions } from "./actions.js";
-import { coreHarness, corePrepare, coreRuntimeContext } from "./overlay.js";
-import { coreReadiness } from "./readiness.js";
+import { coreHarness, corePrepare } from "./overlay.js";
+import { coreControllerImport, coreReadiness, coreRebuildAction } from "./readiness.js";
 import { coreRun } from "./run.js";
-import { coreDependencyBlock } from "../../commands/core-readiness.js";
-import { checkoutHas, checkoutHasDir } from "../checkout-files.js";
 const coreSurface = defineAdapter({
-  id: "core",
-  sdkVersion: 1,
-  headless: true,
-  resolveSlotPorts() {
+  ...createNodeAdapter({
+    id: "core",
+    detect: {
+      files: (target) => checkoutHasDir(target, "packages/perps-controller") && checkoutHas(target, "yarn.lock")
+    },
+    hints: {
+      launch: "mm-harness run <recipe>   # run recipes against the headless core",
+      relaunch: "mm-harness verify",
+      runtimeProbeRecovery: (target) => `mm-harness verify --adapter core --target ${shellQuote(path.resolve(target))}`
+    },
+    wording: {
+      devServerStop: {
+        message: "core is headless \u2014 no dev server runs for a core checkout",
+        userAction: "use mm-harness verify (readiness) or mm-harness run (execute a recipe)"
+      }
+    },
+    // Live scripts import the checkout's workspace packages from source: an
+    // unbuilt or stale checkout has no usable dist/ for them.
+    workspacePackages: checkoutWorkspacePackages,
+    actions: coreActions,
+    harness: coreHarness,
+    // coreRun's dependencyBlock (the Core gate) replaces adapter-node's check.
+    run: coreRun
+  }),
+  // Core's live adapter marks a module the checkout cannot resolve (a partial
+  // workspace build) on its own line: the environment, not app logic.
+  failurePatterns: {
+    environment: {
+      pattern: /\[core\/perps\] environment: cannot resolve /u,
+      message: "the Core checkout cannot resolve a module the action imports (a partial workspace build).",
+      userAction: "run yarn build in the Core checkout, then retry"
+    }
   },
+  // The Core gate decides readiness too, so doctor, verify, run and call agree.
   async runtimeStatus(target) {
     const deps = depsCheck(path.resolve(target));
     const block = deps.status === "current" ? coreDependencyBlock(target) : null;
@@ -27,6 +57,18 @@ const coreSurface = defineAdapter({
         deps: deps.status
       };
     }
+    if (deps.status === "current") {
+      const imported = await coreControllerImport(target);
+      if (!imported.ok) {
+        return {
+          decision: "blocked",
+          reasonCode: "CORE_CONTROLLER_IMPORT_FAILED",
+          reasons: [`Core is headless; controller actions cannot import the Perps controller: ${imported.reason}`],
+          nextAction: imported.userAction ?? coreRebuildAction(target),
+          deps: deps.status
+        };
+      }
+    }
     const ready = deps.status === "current";
     return {
       decision: ready ? "ready" : "install",
@@ -51,39 +93,9 @@ const coreSurface = defineAdapter({
       };
     }
   },
-  devServer: {
-    label: "dev-server",
-    describe: () => "no dev server (headless)",
-    stop() {
-      return {
-        kind: "headless",
-        message: "core is headless \u2014 no dev server runs for a core checkout",
-        userAction: "use mm-harness verify (readiness) or mm-harness run (execute a recipe)"
-      };
-    }
-  },
-  logSources() {
-    return [];
-  },
-  appLogSource() {
-    return null;
-  },
-  detect: {
-    files: (target) => checkoutHasDir(target, "packages/perps-controller") && checkoutHas(target, "yarn.lock")
-  },
-  hints: {
-    launch: "mm-harness run <recipe>   # run recipes against the headless core",
-    relaunch: "mm-harness verify",
-    runtimeProbeRecovery: (target) => `mm-harness verify --adapter core --target ${shellQuote(path.resolve(target))}`
-  },
-  launch: async ({ usage }) => usage("core is headless; there is nothing to launch.", "mm-harness verify"),
-  actions: coreActions,
-  harness: coreHarness,
-  runtimeContext: coreRuntimeContext,
   readiness: coreReadiness,
   fixtures: { operations: ["init", "sync", "set"] },
-  prepare: corePrepare,
-  run: coreRun
+  prepare: corePrepare
 });
 adapterRegistry.register(coreSurface);
 export {

package/dist/adapters/extension/extension-id.js

@@ -77,5 +77,6 @@ async function resolveExtensionId(target, options = {}) {
 }
 export {
   extensionIdFromKey,
+  idFromManifest,
   resolveExtensionId
 };

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

@@ -9,6 +9,7 @@ import {
   verifyExtensionConsoleControl
 } from "./console-capture.js";
 import { emitProofFailure } from "../proof-failure.js";
+import { refuseLockedSession } from "../session-lock.js";
 import { launchedBrowser } from "./launched-browser.js";
 const AUTOLAUNCH_ENV = "METAMASK_RECIPE_EXTENSION_AUTOLAUNCH";
 const extensionRun = {
@@ -39,8 +40,9 @@ const extensionRun = {
     });
   },
   // The proof runtime is checked on the run's own ports (the engine's scope).
-  runtimeCheck({ target, heal, state, json, onRecovery }) {
-    return () => ensureExtensionProofRuntime(target, heal, state, json, { onRecovery });
+  // The Extension browser is always headful: a locked session refuses first.
+  runtimeCheck({ target, options, heal, state, json, onRecovery }) {
+    return async () => refuseLockedSession(json, options) ?? ensureExtensionProofRuntime(target, heal, state, json, { onRecovery });
   },
   launchedBrowser: (target, artifactsDir, cdpPort) => launchedBrowser(target, artifactsDir, cdpPort),
   browserProvenance: (browser) => ({
@@ -181,7 +183,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: {