@deeeed/metamask-harness 0.41.1 → 0.42.0

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

@@ -0,0 +1,300 @@
+import path from "node:path";
+import { WebSocket } from "ws";
+import brokerModule from "../../../adapters/mobile/bridge-runtime/lib/cdp-broker.cjs";
+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 [version, targets] = await Promise.all([
+    fetchJson(`http://127.0.0.1:${cdpPort}/json/version`),
+    fetchJson(`http://127.0.0.1:${cdpPort}/json`)
+  ]);
+  const browserWebSocketUrl = String(
+    asRecord(version).webSocketDebuggerUrl ?? ""
+  );
+  const extensionId = extensionIdFromTargets(targets);
+  if (!browserWebSocketUrl || !extensionId) {
+    throw new Error(
+      "Extension CDP browser or loaded extension target is unavailable."
+    );
+  }
+  const socket = new WebSocket(browserWebSocketUrl);
+  await waitForOpen(socket);
+  let nextId = 0;
+  let closed = false;
+  const brokerRef = {};
+  const pending = /* @__PURE__ */ new Map();
+  const targetSessions = /* @__PURE__ */ new Map();
+  const attaching = /* @__PURE__ */ new Set();
+  const send = (method, params = {}, sessionId, timeoutMs = COMMAND_TIMEOUT_MS) => new Promise((resolve, reject) => {
+    const id = ++nextId;
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error(`Extension CDP command timed out: ${method}`));
+    }, timeoutMs);
+    pending.set(id, { resolve, reject, timer });
+    socket.send(
+      JSON.stringify({
+        id,
+        method,
+        params,
+        ...sessionId ? { sessionId } : {}
+      })
+    );
+  });
+  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);
+    }
+  };
+  socket.on("message", (data) => {
+    let message;
+    try {
+      message = JSON.parse(String(data));
+    } catch {
+      return;
+    }
+    if (message.id && pending.has(message.id)) {
+      const command = pending.get(message.id);
+      pending.delete(message.id);
+      if (!command) return;
+      clearTimeout(command.timer);
+      if (message.error) {
+        command.reject(
+          new Error(
+            String(message.error.message ?? "Extension CDP command failed")
+          )
+        );
+      } else {
+        command.resolve(message.result ?? {});
+      }
+      return;
+    }
+    if (message.method === "Target.targetCreated") {
+      const target = asTargetInfo(message.params?.targetInfo);
+      if (target) void attachTarget(target);
+      return;
+    }
+    if (message.method === "Target.attachedToTarget") {
+      const target = asTargetInfo(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 ?? {}
+      );
+    }
+  });
+  socket.on("close", () => {
+    if (!closed) brokerRef.current?.onSessionClose(DEVICE_ID);
+    for (const command of pending.values()) {
+      clearTimeout(command.timer);
+      command.reject(new Error("Extension browser CDP connection closed"));
+    }
+    pending.clear();
+  });
+  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(asTargetInfo).filter((target) => Boolean(target)).map(attachTarget)
+  );
+  if (targetSessions.size === 0) {
+    socket.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 = asTargetInfo(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();
+      socket.close();
+    }
+  };
+}
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok)
+    throw new Error(`Extension CDP returned HTTP ${response.status}.`);
+  return response.json();
+}
+function extensionIdFromTargets(targets) {
+  const values = Array.isArray(targets) ? targets : [];
+  for (const target of values) {
+    const info = asTargetInfo(target);
+    if (!info) continue;
+    try {
+      const url = new URL(info.url);
+      if (url.protocol !== "chrome-extension:") continue;
+      const extensionId = url.hostname;
+      if (extensionId) return extensionId;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asTargetInfo(value) {
+  const target = asRecord(value);
+  const targetId = String(target.targetId ?? target.id ?? "");
+  const type = String(target.type ?? "");
+  const url = String(target.url ?? "");
+  return targetId && type && url ? { targetId, type, url } : null;
+}
+function waitForOpen(socket) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      socket.close();
+      reject(new Error("Extension browser CDP connection timed out."));
+    }, COMMAND_TIMEOUT_MS);
+    socket.once("open", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    socket.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+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.");
+}
+export {
+  createExtensionNetworkObserver
+};

package/dist/adapters/mobile/metro-env.js

@@ -32,10 +32,6 @@ function mobileMetroEnvCheck(target) {
     status: marker === null ? "missing" : marker.fingerprint === fingerprint ? "current" : "changed"
   };
 }
-function applyMobileMetroEnvPolicy(target, actions) {
-  if (mobileMetroEnvCheck(target).status === "current") return actions;
-  return actions.map((action) => action.id === "start-metro" && !action.argv?.includes("--clear") ? { ...action, argv: [...action.argv ?? [], "--clear"] } : action);
-}
 function recordMobileMetroEnvBaseline(target, expectedFingerprint) {
   if (mobileMetroEnvFingerprint(target) !== expectedFingerprint) return false;
   const marker = recipeRuntimePath(target, BASELINE_FILE);
@@ -69,7 +65,6 @@ function readBaseline(target) {
   }
 }
 export {
-  applyMobileMetroEnvPolicy,
   mobileMetroEnvCheck,
   mobileMetroEnvFingerprint,
   recordMobileMetroEnvBaseline

package/dist/adapters/mobile/prepare.js

@@ -9,7 +9,6 @@ import {
   launchActions
 } from "./runtime-decision.js";
 import {
-  applyMobileMetroEnvPolicy,
   mobileMetroEnvCheck,
   recordMobileMetroEnvBaseline
 } from "./metro-env.js";
@@ -241,9 +240,8 @@ function withAppRestart(actions, restartApp) {
 }
 async function dispatchActionSequence(requestedActions, target, platform, json, preflightMode, watcherPort) {
   const resolved = path.resolve(target);
-  const actions = applyMobileMetroEnvPolicy(resolved, requestedActions);
   let pendingMetroEnvFingerprint;
-  for (const action of actions) {
+  for (const action of requestedActions) {
     if (action.id === "start-metro") {
       pendingMetroEnvFingerprint = mobileMetroEnvCheck(resolved).fingerprint;
     }

package/dist/adapters/mobile/runtime-decision.js

@@ -13,7 +13,7 @@ import { probeMetroPackager } from "@farmslot/recipe-harness/runtime/metro-probe
 import { recipeRuntimePath } from "../../paths.js";
 import { resolveMobileToolPath } from "../../../library/actions/mobile/platform/tool-paths.mjs";
 import { mobileProductMarkers } from "./deps-markers.js";
-import { applyMobileMetroEnvPolicy, mobileMetroEnvCheck } from "./metro-env.js";
+import { mobileMetroEnvCheck } from "./metro-env.js";
 const BUNDLE_ERR = /Bundling failed|Unable to resolve /u;
 const BUNDLE_OK = /Bundled \d+ms|iOS Bundled|Android Bundled|Finished bundling/u;
 const NATIVE_MODULE_STALE = /\[runtime not ready\].*HybridObject "([^"]+)" - It has not yet been registered in the Nitro Modules HybridObjectRegistry/u;
@@ -130,13 +130,10 @@ async function decideMobileReadiness(target, options = {}) {
     decision: "launch",
     reasonCode: report.decision === "ready" ? env.status === "missing" ? "metro-env-baseline-missing" : "metro-env-changed" : report.reasonCode,
     reasons: [
-      env.status === "missing" ? "Metro environment has no successful bundle baseline; restart once with a cleared transform cache." : "Metro environment inputs changed since the successful bundle baseline; restart once with a cleared transform cache.",
+      env.status === "missing" ? "Metro environment has no successful bundle baseline; restart Metro to load the current environment without clearing its transform cache." : "Metro environment inputs changed since the successful bundle baseline; restart Metro without clearing its transform cache. Pass --clear-metro only if stale transforms are observed.",
       ...report.reasons
     ],
-    actions: applyMobileMetroEnvPolicy(
-      resolved,
-      report.decision === "ready" ? launchActions(resolved) : report.actions
-    )
+    actions: report.decision === "ready" ? launchActions(resolved) : report.actions
   };
 }
 async function computeMobileReadiness(resolved, options, fast) {
@@ -216,7 +213,7 @@ async function computeMobileReadiness(resolved, options, fast) {
       checks,
       actions: [
         { id: "rebuild-native-dev-client" },
-        ...launchActions(resolved, true)
+        ...launchActions(resolved)
       ]
     };
   }
@@ -231,11 +228,11 @@ async function computeMobileReadiness(resolved, options, fast) {
         decision: "launch",
         reasonCode: metroLog.reason === "stale-bundle-error" ? "metro-stale-log" : "bundle-errors-recoverable",
         reasons: [
-          metroLog.reason === "stale-bundle-error" ? "Metro log shows prior bundle failures but cited modules are installed; restart Metro with a cleared cache." : "Metro bundle is failing with current deps; restart Metro (clear cache) before relaunching the dev client.",
+          metroLog.reason === "stale-bundle-error" ? "Metro log shows prior bundle failures but cited modules are installed; restart Metro without clearing the cache. Pass --clear-metro if the failure persists." : "Metro bundle is failing with current deps; restart Metro without clearing the cache. Pass --clear-metro if the failure persists.",
           ...excerpt ? [excerpt] : []
         ],
         checks,
-        actions: launchActions(resolved, true)
+        actions: launchActions(resolved)
       };
     }
     return {

package/dist/adapters.js

@@ -12,6 +12,7 @@ import { observeNativeUi } from "../library/actions/mobile/platform/observe-ui.m
 import { nativeAgentDeviceStateDir } from "../library/actions/mobile/platform/native-session-name.mjs";
 import { resolveMobileToolPath } from "../library/actions/mobile/platform/tool-paths.mjs";
 import { resolveWalletImportCredentials, validateWalletImportOptions } from "../library/actions/shared/wallet/import-source.mjs";
+import { handleRunNetworkAction } from "./network-observation.js";
 const execFileAsync = promisify(execFile);
 const NATIVE_PROVIDER_UI_ACTIONS = /* @__PURE__ */ new Set([
   "ui.press",
@@ -103,7 +104,11 @@ const LIVE_ONLY_WALLET_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.wallet.list_accounts",
   "metamask.wallet.read_state"
 ]);
-const LIVE_ONLY_APP_ACTIONS = /* @__PURE__ */ new Set(["ui.navigate"]);
+const LIVE_ONLY_APP_ACTIONS = /* @__PURE__ */ new Set([
+  "ui.navigate",
+  "app.network_capture",
+  "app.network_assert"
+]);
 function requiresLiveAdapter(platform, action) {
   return LIVE_ONLY_ACTIONS.has(action) || platform === "core" && CORE_ONLY_PERPS_ACTIONS.has(action) || LIVE_ONLY_WALLET_ACTIONS.has(action) || LIVE_ONLY_APP_ACTIONS.has(action);
 }
@@ -140,6 +145,13 @@ function liveAdapterPathHint(platform, action) {
   return `library/actions/${platform}/${action.replaceAll(".", "/")}.mjs`;
 }
 async function semanticResult(platform, action, node, context, forceLive = false, preparedLiveAdapters) {
+  const networkAction = await handleRunNetworkAction(
+    platform,
+    action,
+    node,
+    context
+  );
+  if (networkAction) return networkAction;
   const live = await runLiveFirst(
     platform,
     action,
@@ -253,6 +265,7 @@ function createMetaMaskSemanticAdapters(platform, declaredCustomActions = [], pr
   ];
   const bundledActions = [
     ...walletActions,
+    ...platform !== "core" ? ["app.network_capture", "app.network_assert"] : [],
     "metamask.assets.read_visible_state",
     "metamask.assets.open_details",
     "metamask.assets.read_details",

package/dist/cli-commands.js

@@ -15,6 +15,7 @@ const SPEC = {
     { name: "sync", desc: "Refresh harness + canonicalize wallet fixture", flags: ["--json"] },
     { name: "logs", aliases: ["tail"], desc: "Compact build events or full log", flags: ["--full", "-f", "--window", "--events", "--source", "--json"] },
     { name: "debug", aliases: ["devtools", "inspect"], desc: "Open DevTools UI", flags: ["--json", "--no-open"] },
+    { name: "reload", desc: "Reload the connected app runtime", flags: ["--json"] },
     { name: "fixtures", desc: "Manage the canonical wallet fixture (sync/set/reset/generate)", args: ["sync", "set", "reset", "generate"], flags: ["--fixture", "--out", "--adapter", "--target", "--device", "--json"] },
     { name: "actions", desc: "List runnable recipe actions", flags: ["--json", "--matrix", "--categories", "--category", "--action", "--library"] },
     { name: "doctor", desc: "Check harness/orchestration health", flags: ["--json", "--target", "--adapter", "--runtime-dir", "--expect-live", "--print-ready", "--cdp-port", "--device"] },
@@ -31,10 +32,11 @@ const SPEC = {
     { name: "ready", aliases: ["ensure-ready"], desc: "Ensure one healthy extension home tab" },
     { name: "watch", aliases: ["start-watch", "watcher"], desc: "Start/reuse webpack watcher", flags: ["--full", "-f"] },
     { name: "stop", aliases: ["stop-watch", "stop-watcher"], desc: "Stop this checkout watcher" },
-    { name: "rebuild", aliases: ["reset", "reopen", "reload", "browser", "launch", "full-launch", "runtime-launch", "build", "build:once", "build-once", "refresh-once"], desc: "Clean webpack + browser launch", flags: ["--json", "--dry-run", "--full"] },
+    { name: "rebuild", aliases: ["reset", "reopen", "browser", "launch", "full-launch", "runtime-launch", "build", "build:once", "build-once", "refresh-once"], desc: "Clean webpack + browser launch", flags: ["--json", "--dry-run", "--full"] },
     { name: "sidepanel", desc: "Side panel helper", args: ["cycle", "open", "close", "toggle", "status"] },
     { name: "prepare", flags: ["--target", "--cdp-port", "--runtime-dir", "--validate"] },
-    { name: "debug", args: ["page", "worker"], flags: ["--json", "--no-open"] }
+    { name: "debug", args: ["page", "worker"], flags: ["--json", "--no-open"] },
+    { name: "reload", desc: "Reload the live Extension UI over CDP", flags: ["--json"] }
   ],
   mobile: [
     { name: "ios", aliases: ["start"], desc: "Start Metro + launch iOS dev client" },
@@ -53,7 +55,8 @@ const SPEC = {
     { name: "screenshot", desc: "Capture simulator/device screenshot", args: ["path"] },
     { name: "dev-menu", aliases: ["devmenu"], desc: "Open RN developer menu", flags: ["--json", "--no-open"] },
     { name: "prepare", flags: ["--target", "--platform", "--preflight-mode", "--port", "--simulator", "--adb-serial", "--runtime-dir", "--wallet-setup", "--wallet-fixture"] },
-    { name: "debug", flags: ["--json", "--no-open", "--action"] }
+    { name: "debug", flags: ["--json", "--no-open", "--action"] },
+    { name: "reload", desc: "Reload the app without restarting Metro", flags: ["--json"] }
   ]
 };
 const GLOBAL_FLAGS = ["--json", "--dry-run", "--full", "-f", "--help", "-h", "--no-open", "--no-color"];

package/dist/cli.js

@@ -15,6 +15,7 @@ import { handleCompletionCandidates, invalidateCompletionCache } from "./command
 import { handleLaunch } from "./commands/launch/index.js";
 import { handleLogs } from "./commands/logs.js";
 import { handleDebug } from "./commands/debug.js";
+import { handleReload } from "./commands/reload.js";
 import { handleFixtures } from "./commands/fixtures.js";
 import { handleRecipeQuality } from "./commands/recipe-quality.js";
 import { handleStatus } from "./commands/status.js";
@@ -47,6 +48,8 @@ DAILY LOOP \u2014 what a teammate runs many times a day:
                mm-harness logs
   debug      Open the debug console (extension DevTools / mobile RN).
                mm-harness debug
+  reload     Reload the connected Mobile or Extension runtime.
+               mm-harness reload
   fixtures   Sync files, set/reset the wallet, generate fixture-state, or finalize labels over CDP.
                mm-harness fixtures sync                 # or: set | reset | generate --fixture <f> --out <o> | finalize \u2026
 
@@ -118,6 +121,7 @@ async function main(argv) {
   if (command === "stop") return handleStop(argv.slice(1));
   if (command === "logs") return handleLogs(argv.slice(1));
   if (command === "debug") return handleDebug(argv.slice(1));
+  if (command === "reload") return handleReload(argv.slice(1));
   if (command === "fixtures") return handleFixtures(argv.slice(1));
   if (command === "recipe-quality") return handleRecipeQuality(argv.slice(1));
   if (command === "check") return handleCheck(argv.slice(1));

package/dist/command-contract.js

@@ -278,6 +278,9 @@ const PUBLIC_COMMAND_CONTRACTS = {
       "--no-open": bool()
     })
   },
+  reload: {
+    options: options(HELP, JSON, TARGET, ADAPTER, ADAPTER_OR_MOBILE_PLATFORM)
+  },
   update: {
     options: options(HELP, JSON, { "--check": bool() })
   },

package/dist/commands/call.js

@@ -43,6 +43,9 @@ import {
 import { readMobileReleaseArtifactState } from "../adapters/mobile/release-artifact-state.js";
 import { acquireCheckoutLock } from "../checkout-lock.js";
 import { formatRunDiagnosticsForHuman, readRunDiagnosticsDocument } from "../run-diagnostics.js";
+import {
+  startRunNetworkObservation
+} from "../network-observation.js";
 import { recipeTrustFailure } from "../recipe-security.js";
 import { isSensitiveKey, recordCommandEvidence, redactStructuredValue } from "../command-journal.js";
 import { closest } from "../command-contract.js";
@@ -209,12 +212,14 @@ async function handleCall(argv) {
   recordCommandEvidence(artifactsDir);
   const requestedRuntimeOptions = runtimeOptionsFromCli(options);
   const inheritedSource = process.env.FARMSLOT_RECIPE_SOURCE_TRUST || process.env.FARMSLOT_RECIPE_SOURCE_KIND || process.env.FARMSLOT_RECIPE_SOURCE_NAME || process.env.FARMSLOT_RECIPE_SOURCE_DIGEST;
+  let networkObservation;
   const callRuntimeOptions = {
     ...requestedRuntimeOptions,
     ...librarySources ? { librarySources } : {},
     autoHud: false,
     suppressLibraryResolutionLogs: true,
     stdoutIsMachineContract: json,
+    onActionEvent: ({ nodeId, action, status }) => networkObservation?.onActionEvent({ nodeId, action, status }),
     ...requestedRuntimeOptions.source ? { source: requestedRuntimeOptions.source } : inheritedSource ? {} : {
       source: {
         kind: "operator",
@@ -275,29 +280,49 @@ async function handleCall(argv) {
     });
     if (typeof prepared === "number") return prepared;
     const { state, heal } = prepared;
-    const { result, violation } = await executeWithHealBounds(
-      () => {
-        const execution = preflightedExecution;
-        preflightedExecution = void 0;
-        return runRecipe(
-          adapter,
-          recipe,
-          artifactsDir,
-          target,
-          actionManifestOverride,
-          callRuntimeOptions,
-          execution
-        );
-      },
+    networkObservation = await startRunNetworkObservation(
       adapter,
       target,
-      heal,
-      state,
-      () => recoverRunInfra(adapter, target, json, {
-        cdpPort: optionString(options, "cdpPort"),
-        watcherPort: optionString(options, "watcherPort") ?? optionString(options, "metroPort")
-      })
+      artifactsDir,
+      process.env,
+      {
+        cdpPort: callRuntimeOptions.cdpPort,
+        watcherPort: callRuntimeOptions.watcherPort
+      }
     );
+    let executionResult;
+    try {
+      executionResult = await executeWithHealBounds(
+        () => {
+          const execution = preflightedExecution;
+          preflightedExecution = void 0;
+          return runRecipe(
+            adapter,
+            recipe,
+            artifactsDir,
+            target,
+            actionManifestOverride,
+            callRuntimeOptions,
+            execution
+          );
+        },
+        adapter,
+        target,
+        heal,
+        state,
+        () => recoverRunInfra(adapter, target, json, {
+          cdpPort: optionString(options, "cdpPort"),
+          watcherPort: optionString(options, "watcherPort") ?? optionString(options, "metroPort")
+        })
+      );
+    } catch (error) {
+      await networkObservation?.finalize();
+      networkObservation = void 0;
+      throw error;
+    }
+    const { result, violation } = executionResult;
+    await networkObservation?.finalize(result.artifactManifestPath);
+    networkObservation = void 0;
     if (violation !== null) {
       const conciseFailure = violation.originalError ? conciseFailureForHuman(violation.originalError) : "";
       const example = describedAction ? actionExampleCommand(

package/dist/commands/reload.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { runnerDir } from "../paths.js";
+import { getAdapterSurface } from "../adapters/surface.js";
+import {
+  ADAPTER_DETECT_NEXT,
+  EXIT,
+  flag,
+  parseFlags,
+  resolveAdapter,
+  spawnScript,
+  targetOf,
+  usageOut
+} from "./shared.js";
+const RELOAD_BOOLEANS = /* @__PURE__ */ new Set(["json"]);
+async function handleReload(argv) {
+  const { options } = parseFlags(argv, RELOAD_BOOLEANS);
+  const json = flag(options, "json");
+  const target = targetOf(options);
+  const adapter = resolveAdapter(options, target);
+  if (!adapter) {
+    return usageOut(
+      json,
+      "reload",
+      `could not detect the MetaMask repo type for ${target}`,
+      ADAPTER_DETECT_NEXT
+    );
+  }
+  if (adapter === "core") {
+    return usageOut(
+      json,
+      "reload",
+      "core is headless; there is no app runtime to reload.",
+      "mm-harness run <core-recipe>"
+    );
+  }
+  getAdapterSurface(adapter).resolveSlotPorts(target);
+  if (adapter === "extension") {
+    if (!process.env.CDP_PORT) {
+      return usageOut(
+        json,
+        "reload",
+        "the Extension CDP port could not be resolved.",
+        "mm-harness launch"
+      );
+    }
+    const script2 = path.join(runnerDir, "adapters/extension/reattach.sh");
+    const args2 = ["--target", target, "--cdp-port", process.env.CDP_PORT];
+    if (process.env.WATCHER_PORT) {
+      args2.push("--watcher-port", process.env.WATCHER_PORT);
+    }
+    const result2 = spawnScript(script2, args2, target, json);
+    if (json) {
+      console.log(
+        JSON.stringify(
+          {
+            ok: result2.status === 0,
+            adapter,
+            method: "cdp-reattach",
+            command: "reload",
+            cdpPort: Number(process.env.CDP_PORT),
+            ...result2.status === 0 ? {} : { error: result2.output.slice(-4e3) || "Extension reload failed." }
+          },
+          null,
+          2
+        )
+      );
+    }
+    return result2.status === 0 ? EXIT.ok : EXIT.runtime;
+  }
+  const script = path.join(runnerDir, "adapters/mobile/reload-app.mjs");
+  const args = [];
+  if (process.env.WATCHER_PORT) args.push("--port", process.env.WATCHER_PORT);
+  if (json) args.push("--json");
+  const result = spawnScript(process.execPath, [script, ...args], target, json);
+  if (json) process.stdout.write(result.output);
+  return result.status === 0 ? EXIT.ok : EXIT.runtime;
+}
+export {
+  handleReload
+};