@deeeed/metamask-harness 0.75.0 → 0.77.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## Unreleased
 
+## 0.77.0 - 2026-10-04
+
+### Changed
+
+- The action catalog runs on `@farmslot/recipe-cli` 0.1.2: `actions` (lookup, search, related actions, categories, `--matrix`), `call` name lookup and `call --list` short names, and the missing-capability refusals in `call` and `run` use its catalog helpers instead of mm-harness's own copies. mm-harness still resolves the action manifest with its own policy, and flags and output are unchanged.
+
+## 0.76.0 - 2026-10-04
+
+### Changed
+
+- The lifecycle and readiness commands reach platform behavior through the adapter surface instead of branching on the adapter name. New `AdapterSurface` members:
+  - `harness`: the install/cleanup leaves, verify dispatch and environment, and the restart hint;
+  - `runtimeContext`: forbidden fields, local port bases and the resources `agentic-runtime.json` records;
+  - `readiness`: doctor's compatibility mode, platform checks, live checks, environment, orphaned dev servers, capture providers, `--fix` repairs, runtime block, pinned feature flags, the status runtime probe, and connected devices;
+  - `fixtures` (operations, apply), `prepare`, `debug`, `reload` and `runtimeDecision`;
+  - plus `devServer.afterStop` and `runwayProvision.before`/`launchNext`.
+- `harness.ts`, `prepare`, `runtime-context`, `status`, both doctor modules, `fixtures`, `debug`, `reload`, `runtime-decision`, `provision`, `stop`, `logs`, `self-test`, `device-target` and the CLI front door (`--adapter`/`--platform` validation now asks the registry) go from 90 adapter-name branches to 0; `src/` goes from 101 to 10 (one of the 101 was a comment, reworded).
+- Platform code moves to `src/adapters/<adapter>/` (`overlay.ts`, `readiness.ts`, `doctor-checks.ts`, `fixtures.ts`, `reload.ts`, Mobile `devices.ts` and `prepare-target.ts`).
+- The test-only `example` adapter now also installs, verifies, cleans up, records its runtime context, and is reached by doctor, fixtures, reload, runtime-decision, stop, provision and debug.
+- Flags, output and the CLI goldens are unchanged for Mobile, Extension and Core. Four Terminal paths that fell into another platform's branch now behave as Terminal:
+  - `doctor` reports `cdp` as the screenshot provider instead of `simctl`/`adb`;
+  - `logs --window` names the tail window `browser-<port>` instead of `webpack-<port>`;
+  - `reload` and `fixtures set`/`reset` report that Terminal has nothing to reload or apply, instead of running the Mobile reload script or failing with a status-less envelope.
+
+### Fixed
+
+- `doctor` finds leaked Metro bundlers by running `reap-checkout-metros.sh detect <checkout> [port]` with an argv instead of a `bash -c` string, so the checkout path and port are never shell text (code scanning alerts 41, 42 and 131).
+
 ## 0.75.0 - 2026-10-04
 
 ### Added

package/adapters/shared/reap-checkout-metros.sh

@@ -6,6 +6,8 @@
 #
 #   reap_checkout_metros  <checkout-abs-path> [keep-pid]
 #   detect_checkout_metros <checkout-abs-path> [live-port]
+# Sourced for the functions; run directly, `detect <checkout-abs-path> [live-port]`
+# prints the orphan pids (doctor calls it this way, with an argv and no shell string).
 # reap kills every bundler for the checkout (stop wants a clean slate), sparing
 # keep-pid. detect lists orphans for doctor and EXCLUDES the bundler serving
 # live-port (the currently-running valid Metro is not a leak).
@@ -73,3 +75,10 @@ detect_checkout_metros() {
 $(_checkout_metro_pids "$repo")
 LIST
 }
+
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+  case "${1:-}" in
+    detect) shift; detect_checkout_metros "$@" ;;
+    *) printf 'usage: %s detect <checkout-abs-path> [live-port]\n' "$0" >&2; exit 2 ;;
+  esac
+fi

package/dist/adapters/core/overlay.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import { recipeHarnessPath } from "../../paths.js";
+function isExecutable(file) {
+  try {
+    const stat = fs.statSync(file);
+    return stat.isFile() && (stat.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+const coreHarness = {
+  install: { entry: "adapters/core/inject.sh", fallback: "scripts/inject-core-harness.sh" },
+  cleanup: { entry: "adapters/core/cleanup.sh", fallback: "scripts/cleanup-core-harness.sh", fromInstalledRunner: true },
+  verify(target) {
+    const delegate = path.join(recipeHarnessPath(target, "core"), "runner", "bin", "mm-harness");
+    if (!isExecutable(delegate)) {
+      return {
+        error: `core recipe harness not installed: missing delegate ${delegate}.
+Next: mm-harness install --platform core --target ${target}`
+      };
+    }
+    return { command: delegate, prefixArgs: ["doctor", "--adapter", "core"] };
+  }
+};
+const coreRuntimeContext = {
+  forbiddenFields: ["cdpPort", "watcherPort", "metroPort", "devServerPort", "simulator", "simulatorUdid", "adbSerial", "extensionId"]
+};
+const corePrepare = {};
+export {
+  coreHarness,
+  corePrepare,
+  coreRuntimeContext
+};

package/dist/adapters/core/readiness.js

@@ -0,0 +1,8 @@
+import fs from "node:fs";
+import path from "node:path";
+const coreReadiness = {
+  compatibilityMode: (target) => fs.existsSync(path.join(target, "packages/perps-controller/src/index.ts")) ? "headless controller (no bridge)" : "unsupported/no bridge"
+};
+export {
+  coreReadiness
+};

package/dist/adapters/core/surface.js

@@ -3,6 +3,8 @@ import { depsCheck } from "@farmslot/recipe-harness/runtime/deps-readiness";
 import { shellQuote } from "../../commands/parse-args.js";
 import { adapterRegistry } from "../registry.js";
 import { coreActions } from "./actions.js";
+import { coreHarness, corePrepare, coreRuntimeContext } from "./overlay.js";
+import { coreReadiness } from "./readiness.js";
 import { coreRun } from "./run.js";
 const coreSurface = {
   adapter: "core",
@@ -59,6 +61,11 @@ const coreSurface = {
   },
   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
 };
 adapterRegistry.register(coreSurface);

package/dist/adapters/extension/doctor-checks.js

@@ -0,0 +1,135 @@
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { recipeRuntimeDir, runnerDir } from "../../paths.js";
+function extensionBrowserDoctorCheck(target) {
+  const requireFromTarget = createRequire(path.join(path.resolve(target), "package.json"));
+  for (const packageName of ["@playwright/test", "playwright"]) {
+    try {
+      const playwright = requireFromTarget(packageName);
+      const executable = playwright.chromium?.executablePath?.();
+      if (executable && fs.existsSync(executable)) {
+        return {
+          id: "playwright-chromium",
+          status: "pass",
+          required: true,
+          message: "Checkout-pinned Playwright Chromium is installed.",
+          detail: executable
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    id: "playwright-chromium",
+    status: "fail",
+    required: true,
+    message: "Checkout-pinned Playwright Chromium is not installed.",
+    userAction: "yarn playwright install chromium"
+  };
+}
+function extensionBrowserResolutionDoctorCheck(target) {
+  const resolver = path.join(runnerDir, "adapters/shared/browser-resolver.cjs");
+  const runtime = path.join(path.resolve(target), recipeRuntimeDir());
+  const record = path.join(runtime, "browser-resolution.json");
+  let profile = process.env.CHROME_USER_DATA_DIR || path.join(runtime, process.env.RECIPE_CHROME_PROFILE_NAME || "chrome-profile");
+  while (profile.length > 1 && profile.endsWith("/")) profile = profile.slice(0, -1);
+  const profileExists = fs.existsSync(path.join(profile, "Local State"));
+  const result = spawnSync(process.execPath, [
+    resolver,
+    "resolve",
+    "--target",
+    path.resolve(target),
+    "--launch-method",
+    "launch-services",
+    "--display",
+    "headful",
+    ...profileExists && fs.existsSync(record) ? ["--recorded", record] : [],
+    "--json"
+  ], {
+    cwd: path.resolve(target),
+    encoding: "utf8",
+    timeout: 135e3
+  });
+  if (result.status === 0) {
+    const resolution = JSON.parse(result.stdout);
+    const managed = resolution.managedChrome;
+    const managedNote = managed && !resolution.warning?.includes("managed by policy") ? ` Google Chrome is managed by policy (${managed.forcedExtensions.length} forced extension${managed.forcedExtensions.length === 1 ? "" : "s"}: ${managed.forcedExtensions.map(({ id, name }) => name ? `${id} (${name})` : id).join(", ")}${managed.signinForced ? "; browser sign-in forced" : ""}); slots use Chrome for Testing.` : "";
+    const probe = resolution.probe ? `; Chrome for Testing probe (${resolution.probe.launchMethod}, ${resolution.probe.display}${resolution.probe.cached ? ", cached" : ""}${resolution.probe.transient ? `, retried after ${resolution.probe.expiresAt}` : ""}): ${resolution.probe.reason}` : resolution.recordedFrom ? `; kept from the slot profile record ${resolution.recordedFrom}` : "";
+    return {
+      id: "extension-browser",
+      status: "pass",
+      required: false,
+      message: `Launch browser: ${resolution.browser} ${resolution.version ?? "(unknown version)"} via ${resolution.source} (${resolution.mode}); extension loading: ${resolution.extensionLoading}${probe}.${managedNote}${resolution.warning ? ` Warning: ${resolution.warning}` : ""}`,
+      detail: resolution.bin
+    };
+  }
+  const message = (result.stderr || result.error?.message || "browser resolution failed").trim();
+  return {
+    id: "extension-browser",
+    status: "fail",
+    required: message.includes("BROWSER_UNLAUNCHABLE:"),
+    message,
+    userAction: "install Google Chrome, or set RECIPE_HARNESS_BROWSER / RECIPE_HARNESS_CHROME_BIN to a browser that starts"
+  };
+}
+function ensureExtensionPerpsBuildFlag(target) {
+  const configPath = path.join(target, ".metamaskrc");
+  const templatePath = path.join(target, ".metamaskrc.dist");
+  const config = readTextSnapshot(configPath);
+  const template = config.kind === "file" ? null : readTextSnapshot(templatePath);
+  const source = config.kind === "file" ? config : template?.kind === "file" ? template : config.kind === "symlink" ? { kind: "file", text: "", mode: 438 } : null;
+  if (!source) return false;
+  const before = source.text;
+  if (/^\s*PERPS_ENABLED\s*=\s*(['"]?)true\1\s*$/mu.test(before)) return false;
+  const line = "PERPS_ENABLED='true'";
+  const after = /^\s*PERPS_ENABLED\s*=.*$/mu.test(before) ? before.replace(/^\s*PERPS_ENABLED\s*=.*$/mu, line) : `${before.replace(/\s*$/u, "")}
+${line}
+`;
+  const temporary = `${configPath}.${process.pid}.${randomUUID()}.tmp`;
+  let descriptor = null;
+  try {
+    const mode = config.kind === "file" ? config.mode : 438;
+    descriptor = fs.openSync(
+      temporary,
+      fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL,
+      mode
+    );
+    fs.writeFileSync(descriptor, after);
+    if (config.kind === "file") fs.fchmodSync(descriptor, config.mode);
+    fs.closeSync(descriptor);
+    descriptor = null;
+    fs.renameSync(temporary, configPath);
+  } finally {
+    if (descriptor !== null) fs.closeSync(descriptor);
+    fs.rmSync(temporary, { force: true });
+  }
+  return true;
+}
+function readTextSnapshot(file) {
+  let descriptor;
+  try {
+    descriptor = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") return { kind: "missing" };
+    if (code === "ELOOP") return { kind: "symlink" };
+    throw error;
+  }
+  try {
+    return {
+      kind: "file",
+      text: fs.readFileSync(descriptor, "utf8"),
+      mode: fs.fstatSync(descriptor).mode & 511
+    };
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+export {
+  ensureExtensionPerpsBuildFlag,
+  extensionBrowserDoctorCheck,
+  extensionBrowserResolutionDoctorCheck
+};

package/dist/adapters/extension/fixtures.js

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import { colorHumanMessage } from "../../cli-color.js";
+import { FIXTURE_STREAM_TIMEOUT_MS } from "../../commands/fixtures.js";
+import { EXIT, spawnScriptStreaming } from "../../commands/shared.js";
+import { sameFeatureFlags } from "../../feature-flags.js";
+import { runnerDir } from "../../paths.js";
+import { readExtensionPinnedFlags } from "./feature-flags.js";
+async function applyExtensionFixture({
+  target,
+  fixturePath,
+  canonicalFixture,
+  json,
+  sub: action,
+  fixtureFlags
+}) {
+  const distManifest = path.join(target, "dist/chrome/manifest.json");
+  const userAction = `mm-harness launch --build --verify --target ${JSON.stringify(target)}`;
+  if (!fs.existsSync(distManifest)) {
+    const message2 = `Extension fixture needs an existing dist/chrome build; no manifest was found at ${distManifest}.`;
+    if (json) {
+      console.log(JSON.stringify({
+        schemaVersion: 1,
+        command: "fixtures",
+        action,
+        adapter: "extension",
+        fixture: fixturePath,
+        canonicalFixture,
+        status: "fail",
+        exitCode: EXIT.runtime,
+        error: { code: "EXTENSION_FIXTURE_BUILD_REQUIRED", message: message2, userAction }
+      }, null, 2));
+    } else {
+      console.error(`\u2717 mm-harness fixtures ${action}: ${message2}
+  Next: ${userAction}`);
+    }
+    return EXIT.runtime;
+  }
+  process.stderr.write(`${colorHumanMessage(`\u2192 fixtures ${action} extension \u2014 resetting and seeding the slot-owned profile from the existing build\u2026`)}
+`);
+  const liveScript = path.join(runnerDir, "adapters/extension/live.sh");
+  const args = ["--target", target, "--launch-existing-dist", "--launch-only", "--reset-profile"];
+  const flagKeys = Object.keys(fixtureFlags);
+  if (flagKeys.length > 0) args.push("--remote-flags-json", JSON.stringify(fixtureFlags));
+  if (process.env.CDP_PORT) args.push("--cdp-port", process.env.CDP_PORT);
+  const result = await spawnScriptStreaming(liveScript, args, target, {
+    env: { RECIPE_WALLET_FIXTURE: fixturePath },
+    timeoutMs: FIXTURE_STREAM_TIMEOUT_MS
+  });
+  const pinned = readExtensionPinnedFlags(target);
+  const pinnedFlags = pinned.pinned ?? {};
+  const flagMismatch = result.status === 0 && !pinned.error && (pinned.pinned === null || !sameFeatureFlags(pinnedFlags, fixtureFlags)) ? [.../* @__PURE__ */ new Set([...flagKeys, ...Object.keys(pinnedFlags)])].filter(
+    (key) => JSON.stringify(pinnedFlags[key]) !== JSON.stringify(fixtureFlags[key])
+  ) : [];
+  if (result.status === 0 && (pinned.error || flagMismatch.length > 0)) {
+    const detail = pinned.error ? `the launched snapshot manifest could not be read (${pinned.sourcePath ?? "unknown path"}): ${pinned.error}` : `snapshot pin disagrees with the fixture for: ${flagMismatch.join(", ")}`;
+    const flagNext = `mm-harness launch --adapter extension --build --target ${JSON.stringify(target)}`;
+    if (json) {
+      console.log(JSON.stringify({
+        schemaVersion: 1,
+        command: "fixtures",
+        action,
+        adapter: "extension",
+        fixture: fixturePath,
+        canonicalFixture,
+        status: "fail",
+        exitCode: EXIT.runtime,
+        error: { code: "EXTENSION_FIXTURE_FLAGS_NOT_APPLIED", message: detail, userAction: flagNext }
+      }, null, 2));
+    } else {
+      console.error(`\u2717 mm-harness fixtures ${action}: ${detail}
+  Next: ${flagNext}`);
+    }
+    return EXIT.runtime;
+  }
+  const status = result.status === 0 ? "pass" : "fail";
+  const exitCode = status === "pass" ? EXIT.ok : EXIT.runtime;
+  const message = status === "pass" ? `Wallet fixture applied and validated. Want different accounts? Edit: ${canonicalFixture}` : "Extension wallet fixture could not be applied and validated.";
+  if (json) {
+    console.log(JSON.stringify({
+      schemaVersion: 1,
+      command: "fixtures",
+      action,
+      adapter: "extension",
+      fixture: fixturePath,
+      canonicalFixture,
+      status,
+      exitCode,
+      profileReset: status === "pass",
+      message,
+      error: status === "fail" ? { code: "EXTENSION_FIXTURE_APPLY_FAILED", message, userAction } : null
+    }, null, 2));
+  } else if (status === "pass") {
+    console.error(message);
+  } else {
+    console.error(`\u2717 mm-harness fixtures ${action}: ${message}
+  Next: ${userAction}`);
+  }
+  return exitCode;
+}
+export {
+  applyExtensionFixture
+};

package/dist/adapters/extension/overlay.js

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import { readRuntimeContextField, resolveRuntimeContextPath } from "../../harness.js";
+import { resolveExtensionSlotPorts } from "../slot-ports.js";
+function hasArg(args, needle) {
+  return args.some((arg) => arg === needle || arg.startsWith(`${needle}=`));
+}
+function applyExtensionRuntimeEnv(target, args) {
+  const contextPath = resolveRuntimeContextPath(target);
+  const contextExists = fs.existsSync(contextPath);
+  if (contextExists) {
+    process.env.RECIPE_RUNTIME_CONTEXT = contextPath;
+    if (!process.env.RECIPE_SLOT_ID) {
+      const slotId = readRuntimeContextField(contextPath, "slotId");
+      if (slotId) process.env.RECIPE_SLOT_ID = slotId;
+    }
+    if (!process.env.RECIPE_HARNESS_EXTENSION_ID) {
+      const extensionId = readRuntimeContextField(contextPath, "extensionId");
+      if (extensionId) process.env.RECIPE_HARNESS_EXTENSION_ID = extensionId;
+    }
+  } else {
+    delete process.env.RECIPE_RUNTIME_CONTEXT;
+  }
+  resolveExtensionSlotPorts(target);
+  let result = [...args];
+  if (!hasArg(result, "--cdp-port")) {
+    const cdpPort = process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
+    if (cdpPort) {
+      process.env.RECIPE_CDP_PORT = cdpPort;
+      process.env.CDP_PORT = cdpPort;
+      result = [...result, "--cdp-port", cdpPort];
+    }
+  }
+  return result;
+}
+const extensionHarness = {
+  install: { entry: "adapters/extension/inject.mjs", fallback: "scripts/inject-extension-harness.mjs", node: true },
+  cleanup: { entry: "adapters/extension/cleanup.mjs", fallback: "scripts/cleanup-extension-harness.mjs", node: true, fromInstalledRunner: true },
+  // Runner-owned typed code, not a shipped leaf: no installed overlay copy can shadow it.
+  verify: () => ({ inProcess: async () => (await import("./verify.js")).runExtensionVerify }),
+  verifyArgs: applyExtensionRuntimeEnv,
+  restart: "mm-harness launch"
+};
+const extensionRuntimeContext = {
+  forbiddenFields: ["metroPort", "simulator", "simulatorUdid", "adbSerial"],
+  localPorts: { cdp: 2e4, watcher: 3e4 },
+  resources: ({ existing, defaults, envPort }) => ({
+    cdpPort: envPort("RECIPE_CDP_PORT", "CDP_PORT") ?? existing.cdpPort ?? defaults.cdpPort
+  })
+};
+const extensionPrepare = {};
+export {
+  extensionHarness,
+  extensionPrepare,
+  extensionRuntimeContext
+};

package/dist/adapters/extension/readiness.js

@@ -0,0 +1,32 @@
+import { optionFlag, optionString, parsePort } from "../../commands/parse-args.js";
+import { ensureExtensionPerpsBuildFlag, extensionBrowserDoctorCheck, extensionBrowserResolutionDoctorCheck } from "./doctor-checks.js";
+import { readExtensionPinnedFlags } from "./feature-flags.js";
+import { extensionProductConfigBlock } from "./product-config.js";
+const extensionReadiness = {
+  compatibilityMode(_target, shape) {
+    if (!shape.extensionProject) return "unsupported/no bridge";
+    if (shape.extensionRuntime || shape.injectedHarness) return "bridge present";
+    return "bridge injectable";
+  },
+  checks: (target) => [extensionBrowserDoctorCheck(target), extensionBrowserResolutionDoctorCheck(target)],
+  captureProviders: ["cdp"],
+  fixes: [{ id: "extension-perps-build", apply: ensureExtensionPerpsBuildFlag }],
+  runtimeBlock: (target, runtime) => runtime?.reasonCode === "product-config-required" ? { id: "extension-product-config", userAction: extensionProductConfigBlock(target)?.userAction } : void 0,
+  pinnedFlags: readExtensionPinnedFlags,
+  statusRuntime: true
+};
+async function extensionRuntimeDecision(target, options) {
+  const cdpPortRaw = optionString(options, "cdpPort") ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT;
+  const cdpPort = cdpPortRaw === void 0 ? void 0 : parsePort(cdpPortRaw, "runtime-decision --cdp-port must be a port.");
+  const { decideExtensionReadiness } = await import("./runtime-decision.js");
+  const report = await decideExtensionReadiness(target, {
+    cdpPort,
+    watchLog: optionString(options, "watchLog"),
+    record: optionFlag(options, "record")
+  });
+  return { report, line: `${report.decision}${report.clean ? " (clean)" : ""} ${report.reasonCode} \u2014 ${report.reasons[0] ?? ""}` };
+}
+export {
+  extensionReadiness,
+  extensionRuntimeDecision
+};

package/dist/adapters/extension/reload.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+import { EXIT, spawnScript, usageOut } from "../../commands/shared.js";
+import { runnerDir } from "../../paths.js";
+function reloadExtension(target, json) {
+  const adapter = "extension";
+  if (!process.env.CDP_PORT) {
+    return usageOut(
+      json,
+      "reload",
+      "the Extension CDP port could not be resolved.",
+      "mm-harness launch"
+    );
+  }
+  const script = path.join(runnerDir, "adapters/extension/reattach.sh");
+  const args = ["--target", target, "--cdp-port", process.env.CDP_PORT];
+  if (process.env.WATCHER_PORT) {
+    args.push("--watcher-port", process.env.WATCHER_PORT);
+  }
+  const result = spawnScript(script, args, target, json);
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          ok: result.status === 0,
+          adapter,
+          method: "cdp-reattach",
+          command: "reload",
+          cdpPort: Number(process.env.CDP_PORT),
+          ...result.status === 0 ? {} : { error: result.output.slice(-4e3) || "Extension reload failed." }
+        },
+        null,
+        2
+      )
+    );
+  }
+  return result.status === 0 ? EXIT.ok : EXIT.runtime;
+}
+export {
+  reloadExtension
+};

package/dist/adapters/extension/surface.js

@@ -11,6 +11,8 @@ import { decideExtensionReadiness } from "./runtime-decision.js";
 import { extensionProductConfigBlock } from "./product-config.js";
 import { adapterRegistry } from "../registry.js";
 import { extensionActions } from "./actions.js";
+import { extensionHarness, extensionPrepare, extensionRuntimeContext } from "./overlay.js";
+import { extensionReadiness, extensionRuntimeDecision } from "./readiness.js";
 import { extensionDiagnostics, extensionObservation, extensionRecording, extensionRun } from "./run.js";
 function watcherStatus(buildLog) {
   if (buildLog === "ok") return "up";
@@ -84,7 +86,8 @@ const extensionSurface = {
       spawnSync("bash", [stopViewers, "--target", target], { stdio: "ignore", timeout: 5e3 });
       const summary = stopped.signalled > 0 || stopped.removedMarkers > 0 ? `stopped Extension runtime (${stopped.signalled} process${stopped.signalled === 1 ? "" : "es"}, ${stopped.removedMarkers} stale marker${stopped.removedMarkers === 1 ? "" : "s"}) for ${target}` : `Extension runtime not running for ${target} \u2014 nothing to stop`;
       return { kind: "stopped", status: 0, summary, signalled: stopped.signalled };
-    }
+    },
+    afterStop: (target) => `mm-harness launch --target ${shellQuote(target)}`
   },
   logSources(target) {
     return [
@@ -110,6 +113,24 @@ const extensionSurface = {
     return runDeviceLaunch(context, extensionLaunchProfile);
   },
   actions: extensionActions,
+  harness: extensionHarness,
+  runtimeContext: extensionRuntimeContext,
+  readiness: extensionReadiness,
+  fixtures: {
+    operations: ["init", "sync", "set", "reset", "generate", "finalize"],
+    apply: async (context) => (await import("./fixtures.js")).applyExtensionFixture(context)
+  },
+  prepare: extensionPrepare,
+  debug: {
+    refuse: ({ devMenu }) => devMenu ? { message: "--dev-menu is mobile-only (RN developer menu). Use --worker on the extension.", userAction: "mm-harness debug --worker" } : void 0,
+    args: ({ worker }) => [
+      ...process.env.CDP_PORT ? ["--cdp-port", process.env.CDP_PORT] : [],
+      "--target",
+      worker ? "worker" : "page"
+    ]
+  },
+  reload: async (target, json) => (await import("./reload.js")).reloadExtension(target, json),
+  runtimeDecision: extensionRuntimeDecision,
   run: extensionRun,
   recording: extensionRecording,
   diagnostics: extensionDiagnostics,

package/dist/adapters/harness-freshness.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { recipeHarnessPath, runnerDir } from "../paths.js";
+import { getAdapterSurface } from "./surface.js";
 async function ensureHarnessFresh(target, adapter) {
   if (!fs.existsSync(path.join(target, "package.json")) || !hasCheckoutHead(target)) return;
   let current;
@@ -17,9 +18,10 @@ async function ensureHarnessFresh(target, adapter) {
   const installed = readInstalledFingerprint(manifestPath);
   if (installed === current) return;
   const reason = installed === null ? "harness not installed" : "runner changed";
-  const injector = path.join(runnerDir, `adapters/${adapter}/inject.${adapter === "extension" ? "mjs" : "sh"}`);
+  const install = getAdapterSurface(adapter).harness.install;
+  const injector = path.resolve(runnerDir, install.entry);
   try {
-    execFileSync(adapter === "extension" ? process.execPath : "bash", [injector, "--target", target], {
+    execFileSync(install.node ? process.execPath : "bash", [injector, "--target", target], {
       stdio: ["ignore", "ignore", "inherit"]
     });
     console.error(`\u2192 refreshed ${adapter} harness overlay (${reason})`);

package/dist/adapters/mobile/devices.js

@@ -0,0 +1,21 @@
+import {
+  mobileDeviceLiveView,
+  mobileDeviceView,
+  nextForLive,
+  renderAdditionalReachableDevices,
+  renderAndroidPortHints,
+  renderMobileDeviceList,
+  renderMobileLiveBlock
+} from "../../commands/mobile-device-view.js";
+const mobileDevices = {
+  view: mobileDeviceView,
+  live: mobileDeviceLiveView,
+  renderList: renderMobileDeviceList,
+  renderAdditional: renderAdditionalReachableDevices,
+  renderLive: renderMobileLiveBlock,
+  renderPortHints: renderAndroidPortHints,
+  nextForLive
+};
+export {
+  mobileDevices
+};

package/dist/adapters/mobile/doctor-checks.js

@@ -0,0 +1,40 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import {
+  mobileToolRecovery,
+  resolveMobileToolPath
+} from "../../../library/actions/mobile/platform/tool-paths.mjs";
+import { runnerDir } from "../../paths.js";
+function mobileToolDoctorChecks(platform) {
+  const specs = platform === "android" ? [{ tool: "adb", platform: "Android" }] : platform === "ios" ? [{ tool: "idb", platform: "iOS" }] : [
+    { tool: "adb", platform: "Android" },
+    { tool: "idb", platform: "iOS" }
+  ];
+  return specs.map(({ tool, platform: platformName }) => {
+    const resolved = resolveMobileToolPath(tool);
+    return {
+      id: `device-tool-${tool}`,
+      status: resolved ? "pass" : "fail",
+      required: platform !== void 0,
+      message: resolved ? `${platformName} device tool ${tool} is ready.` : `${platformName} device tool ${tool} is unavailable.`,
+      ...resolved ? { detail: resolved } : {},
+      ...!resolved ? { userAction: mobileToolRecovery(tool) } : {}
+    };
+  });
+}
+function detectOrphanMetros(target, livePort) {
+  try {
+    const script = path.join(runnerDir, "adapters/shared/reap-checkout-metros.sh");
+    const out = execFileSync("bash", [script, "detect", target, livePort ?? ""], {
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    return out.split("\n").map((line) => line.trim()).filter((line) => /^\d+$/u.test(line));
+  } catch {
+    return [];
+  }
+}
+export {
+  detectOrphanMetros,
+  mobileToolDoctorChecks
+};