@deeeed/metamask-harness 0.75.0 → 0.76.0

package/dist/commands/prepare.js

@@ -10,7 +10,9 @@ import {
 import { color, stripAnsi } from "../cli-color.js";
 import { runnerProvenance } from "../doctor.js";
 import { detectAdapter } from "../harness.js";
-import { harnessExecutable, manifestPath, PREPARE_PROGRESS_ARTIFACT, recipeRuntimeDir } from "../paths.js";
+import { adapterRegistry } from "../adapters/registry.js";
+import { getAdapterSurface } from "../adapters/surface.js";
+import { harnessExecutable, PREPARE_PROGRESS_ARTIFACT, recipeRuntimeDir } from "../paths.js";
 import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
 import { EXIT } from "./shared.js";
 import { formatDuration } from "./status-watch.js";
@@ -52,8 +54,8 @@ const STEP_HINT = {
   launch: "can take minutes on Mobile: Metro bundle and app start",
   fixtures: "under a minute"
 };
-function stepChain(platform) {
-  return platform === "core" ? ["doctor", "status", "verify"] : ["doctor", "status", "launch", "fixtures", "verify"];
+function stepChain(surface) {
+  return surface.headless ? ["doctor", "status", "verify"] : ["doctor", "status", "launch", "fixtures", "verify"];
 }
 function lastRunDurations(recordPath) {
   let parsed;
@@ -225,36 +227,6 @@ function readDevices(artifactsDir) {
   const devices = parsed?.devices;
   return Array.isArray(devices) ? devices : [];
 }
-function readRuntimeContextTarget(target) {
-  const file = path.join(target, recipeRuntimeDir(), "agentic-runtime.json");
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return {};
-  }
-  const record = parsed ?? {};
-  const str = (key) => typeof record[key] === "string" ? record[key] : void 0;
-  return { simulator: str("simulator"), simulatorUdid: str("simulatorUdid"), adbSerial: str("adbSerial") };
-}
-function mobilePlatformFromConfiguredTarget(env, context) {
-  const ios = Boolean(env.IOS_SIMULATOR || env.SIM_UDID || context.simulator || context.simulatorUdid);
-  const android = Boolean(
-    env.ADB_SERIAL || env.ANDROID_SERIAL || env.ANDROID_TARGET_DEVICE_NAME || env.ANDROID_DEVICE || context.adbSerial
-  );
-  if (ios === android) return void 0;
-  return ios ? "ios" : "android";
-}
-function mobilePlatformFromDevices(devices) {
-  const selected = devices.filter((device) => device?.selected === true);
-  const candidates = selected.length > 0 ? selected : devices;
-  const platforms = [
-    ...new Set(
-      candidates.map((device) => device?.platform).filter((value) => value === "ios" || value === "android")
-    )
-  ];
-  return platforms.length === 1 ? platforms[0] : void 0;
-}
 function mobileTargetAmbiguityError() {
   const choices = [
     "1. iOS     mm-harness prepare --platform mobile --mobile-platform ios",
@@ -300,8 +272,9 @@ function mobilePlatformOption(value) {
 }
 function resolvePlatform(requested, target) {
   const platform = requested ?? detectAdapter(target);
-  if (platform === "mobile" || platform === "extension" || platform === "core") {
-    return platform;
+  const surface = platform && adapterRegistry.has(platform) ? getAdapterSurface(platform) : void 0;
+  if (surface?.prepare) {
+    return surface;
   }
   throw usageError(
     `could not detect the platform of ${target}
@@ -328,21 +301,22 @@ async function handlePrepareLocked(argv) {
   const { options } = parseArgs(argv, "prepare");
   const json = optionFlag(options, "json");
   const target = targetPath(options);
-  const platform = resolvePlatform(optionString(options, "platform"), target);
+  const surface = resolvePlatform(optionString(options, "platform"), target);
+  const platform = surface.adapter;
   const artifactsDir = path.resolve(
     optionString(options, "artifactsDir") ?? path.join(target, recipeRuntimeDir())
   );
   const executable = harnessExecutable();
   const targetArgs = ["--target", target];
   const clearMetro = optionFlag(options, "clearMetro");
-  if (clearMetro && platform !== "mobile") {
+  if (clearMetro && !surface.prepare.clearMetro) {
     throw usageError(`--clear-metro is mobile only; this checkout is ${platform}
   Next: ${USAGE}`);
   }
   const remoteFlag = optionString(options, "remoteFlag");
   if (remoteFlag !== void 0) {
-    if (platform === "core") {
-      throw usageError(`--remote-flag needs an app runtime; this checkout is core
+    if (surface.headless) {
+      throw usageError(`--remote-flag needs an app runtime; this checkout is ${platform}
   Next: ${USAGE}`);
     }
     try {
@@ -357,7 +331,7 @@ async function handlePrepareLocked(argv) {
   let mobilePlatform = mobilePlatformOption(optionString(options, "mobilePlatform"));
   const recordPath = path.join(artifactsDir, READINESS_RECORD);
   const progressPath = path.join(artifactsDir, PREPARE_PROGRESS_ARTIFACT);
-  const chain = stepChain(platform);
+  const chain = stepChain(surface);
   const view = json ? void 0 : createStepView(chain, stepHints(chain, lastRunDurations(recordPath)));
   view?.begin();
   const steps = [];
@@ -406,35 +380,33 @@ async function handlePrepareLocked(argv) {
   try {
     await run("doctor", ["doctor", "--fix", "--json", "--adapter", platform, ...targetArgs]);
     await run("status", ["status", "--json", ...targetArgs]);
-    if (platform === "mobile" && !mobilePlatform && !failed()) {
-      mobilePlatform = mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(readDevices(artifactsDir));
+    const { devicePlatform } = surface.prepare;
+    if (devicePlatform && !mobilePlatform && !failed()) {
+      mobilePlatform = devicePlatform(target, readDevices(artifactsDir));
       if (!mobilePlatform) return ambiguousMobileTarget(json);
     }
-    if (platform === "core") {
-      const reason = "core is headless: no app surface to launch or seed";
+    if (surface.headless) {
+      const reason = `${platform} is headless: no app surface to launch or seed`;
       addStep(skippedStep("launch", `${executable} launch`, reason));
       addStep(skippedStep("fixtures", `${executable} fixtures set`, reason));
-    } else if (platform === "mobile") {
-      const device = mobilePlatform ? [mobilePlatform] : [];
+    } else {
+      const device = devicePlatform && mobilePlatform ? [mobilePlatform] : [];
       await run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], ...remoteFlagArgs, "--verify", "--json", ...targetArgs]);
       await run("fixtures", [
         "fixtures",
         "set",
-        ...mobilePlatform ? ["--platform", mobilePlatform] : [],
+        ...device.flatMap((platformName) => ["--platform", platformName]),
         ...remoteFlagArgs,
         "--json",
         ...targetArgs
       ]);
-    } else {
-      await run("launch", ["launch", ...remoteFlagArgs, "--verify", "--json", ...targetArgs]);
-      await run("fixtures", ["fixtures", "set", ...remoteFlagArgs, "--json", ...targetArgs]);
     }
     await run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
   } finally {
     clearInterval(heartbeat);
     view?.end();
   }
-  const provenance = runnerProvenance(manifestPath(platform));
+  const provenance = runnerProvenance(surface.actions.manifestPath());
   const record = {
     schemaVersion: 1,
     harness: {
@@ -462,7 +434,5 @@ async function handlePrepareLocked(argv) {
 }
 export {
   handlePrepare,
-  mobilePlatformFromConfiguredTarget,
-  mobilePlatformFromDevices,
   mobileTargetAmbiguityError
 };

package/dist/commands/provision.js

@@ -1,8 +1,7 @@
 import { detectAdapter } from "../harness.js";
 import { assertAdapter } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
-import { clearMobileReleaseArtifactState } from "../adapters/mobile/release-artifact-state.js";
-import { ADAPTER_DETECT_NEXT, usageOut, writeInteractiveProgress } from "./shared.js";
+import { ADAPTER_DETECT_NEXT, usageOut } from "./shared.js";
 import {
   applyWatcherPortOption,
   optionFlag,
@@ -27,10 +26,7 @@ async function handleProvision({ positional, options, rawArgv }) {
   const surface = getAdapterSurface(adapter);
   const rerunCommand = provisionRerunCommand(rawArgv, options, adapter, target);
   const platform = optionString(options, "platform") ?? optionString(options, "devicePlatform") ?? (positional[0] === "runway" ? positional[1] : positional[0]) ?? "ios";
-  if (adapter === "mobile") {
-    writeInteractiveProgress(json, `\u2192 provision mobile ${platform} \u2014 resolving simulator and Runway artifact`);
-    if (!optionFlag(options, "resolveOnly")) clearMobileReleaseArtifactState(target);
-  }
+  surface.runwayProvision.before?.(target, { json, platform, resolveOnly: optionFlag(options, "resolveOnly") });
   const result = await surface.runwayProvision.run(target, {
     json,
     platform,
@@ -50,7 +46,7 @@ async function handleProvision({ positional, options, rawArgv }) {
   });
   const provisionedSimulator = typeof result.simulator === "object" && result.simulator ? result.simulator : void 0;
   const provisionedDevice = typeof provisionedSimulator?.udid === "string" ? provisionedSimulator.udid : typeof provisionedSimulator?.name === "string" ? provisionedSimulator.name : void 0;
-  const next = result.status === "pass" && adapter === "mobile" && result.resolveOnly !== true ? `mm-harness launch ${String(result.platform ?? platform)} --adapter mobile --target ${shellQuote(target)}` + (provisionedDevice ? ` --device ${shellQuoteArg(provisionedDevice)}` : "") : void 0;
+  const next = result.status === "pass" && surface.runwayProvision.launchNext && result.resolveOnly !== true ? `mm-harness launch ${String(result.platform ?? platform)} --adapter ${adapter} --target ${shellQuote(target)}` + (provisionedDevice ? ` --device ${shellQuoteArg(provisionedDevice)}` : "") : void 0;
   const output = next ? { ...result, next } : result;
   if (json) {
     console.log(JSON.stringify(output, null, 2));

package/dist/commands/reload.js

@@ -1,13 +1,9 @@
-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";
@@ -25,55 +21,20 @@ async function handleReload(argv) {
       ADAPTER_DETECT_NEXT
     );
   }
-  if (adapter === "core") {
+  const surface = getAdapterSurface(adapter);
+  if (surface.headless) {
     return usageOut(
       json,
       "reload",
-      "core is headless; there is no app runtime to reload.",
-      "mm-harness run <core-recipe>"
+      `${adapter} is headless; there is no app runtime to reload.`,
+      `mm-harness run <${adapter}-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;
+  if (!surface.reload) {
+    return usageOut(json, "reload", `reload does not support the ${adapter} adapter.`, surface.hints.launch);
   }
-  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;
+  surface.resolveSlotPorts(target);
+  return surface.reload(target, json);
 }
 export {
   handleReload

package/dist/commands/runtime-decision.js

@@ -1,32 +1,16 @@
-import { decideExtensionReadiness } from "../adapters/extension/runtime-decision.js";
-import { decideMobileReadiness } from "../adapters/mobile/runtime-decision.js";
+import { getAdapterSurface } from "../adapters/surface.js";
 import {
   adapterOption,
   applyRuntimeDirOption,
   optionFlag,
-  optionString,
-  parsePort,
   targetPath
 } from "./parse-args.js";
 async function handleRuntimeDecision({ options }) {
   applyRuntimeDirOption(options);
   const adapter = adapterOption(options);
   const target = targetPath(options);
-  if (adapter === "mobile") {
-    const watcherPortRaw = optionString(options, "watcherPort") ?? process.env.WATCHER_PORT ?? process.env.METRO_PORT;
-    const watcherPort = watcherPortRaw === void 0 ? void 0 : parsePort(watcherPortRaw, "runtime-decision --watcher-port must be a port.");
-    const report2 = await decideMobileReadiness(target, {
-      watcherPort,
-      metroLog: optionString(options, "metroLog"),
-      platform: optionString(options, "platform") ?? process.env.PLATFORM ?? process.env.RECIPE_HARNESS_PLATFORM,
-      record: optionFlag(options, "record"),
-      preflightMode: optionString(options, "preflightMode")
-    });
-    if (optionFlag(options, "json")) console.log(JSON.stringify(report2, null, 2));
-    else console.log(`${report2.decision} ${report2.reasonCode} \u2014 ${report2.reasons[0] ?? ""}`);
-    return 0;
-  }
-  if (adapter !== "extension") {
+  const decide = getAdapterSurface(adapter).runtimeDecision;
+  if (!decide) {
     const report2 = {
       schemaVersion: 1,
       adapter,
@@ -42,15 +26,9 @@ async function handleRuntimeDecision({ options }) {
     else console.log(`unknown adapter-unsupported \u2014 ${report2.reasons[0]}`);
     return 0;
   }
-  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 report = await decideExtensionReadiness(target, {
-    cdpPort,
-    watchLog: optionString(options, "watchLog"),
-    record: optionFlag(options, "record")
-  });
+  const { report, line } = await decide(target, options);
   if (optionFlag(options, "json")) console.log(JSON.stringify(report, null, 2));
-  else console.log(`${report.decision}${report.clean ? " (clean)" : ""} ${report.reasonCode} \u2014 ${report.reasons[0] ?? ""}`);
+  else console.log(line);
   return 0;
 }
 export {

package/dist/commands/self-test.js

@@ -25,9 +25,7 @@ async function runSelfTest(options) {
     for (const adapter of ["mobile", "extension"]) {
       const manifest = loadActionManifest(adapter);
       const manifestValidation = await validateManifest(manifest);
-      const smokeRecipe = recipePath(
-        adapter === "mobile" ? "mobile/runner/smoke.recipe.json" : "extension/runner/smoke.recipe.json"
-      );
+      const smokeRecipe = recipePath(`${adapter}/runner/smoke.recipe.json`);
       const artifactsDir = path.join(root, adapter);
       const result = await runRecipe(adapter, smokeRecipe, artifactsDir, runnerDir, void 0, {
         skipExtensionRuntimePrepare: true

package/dist/commands/status.js

@@ -1,6 +1,5 @@
 import fs from "node:fs";
 import path from "node:path";
-import { readExtensionPinnedFlags } from "../adapters/extension/feature-flags.js";
 import { featureFlagReport } from "../feature-flags.js";
 import { color } from "../cli-color.js";
 import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
@@ -10,15 +9,6 @@ import { getAdapterSurface } from "../adapters/surface.js";
 import {
   applyDeviceTargeting
 } from "./device-target.js";
-import {
-  mobileDeviceView,
-  mobileDeviceLiveView,
-  nextForLive,
-  renderAndroidPortHints,
-  renderMobileDeviceList,
-  renderAdditionalReachableDevices,
-  renderMobileLiveBlock
-} from "./mobile-device-view.js";
 import { ADAPTER_DETECT_NEXT, EXIT, usageOut } from "./shared.js";
 import { handleStatusTaskView, renderAcceptanceLines } from "./status-watch.js";
 import { collectTaskView, findTaskDir } from "../task-view.js";
@@ -45,23 +35,25 @@ async function handleStatus({ options }) {
   const view = collectCheckoutView(target, adapter);
   const surface = getAdapterSurface(adapter);
   surface.resolveSlotPorts(target);
-  if (adapter === "mobile") {
+  const { readiness } = surface;
+  const deviceSource = await readiness.devices?.();
+  if (deviceSource) {
     const dtResult = applyDeviceTargeting("status", adapter, options, { gate: false, rerun: "" });
     if ("code" in dtResult) {
       return usageOut(json, "status", dtResult.message, dtResult.userAction);
     }
   }
   const next = surface.hints.relaunch;
-  const extensionFlags = adapter === "extension" ? readExtensionPinnedFlags(target) : null;
-  const staticFeatureFlags = extensionFlags ? featureFlagReport(extensionFlags.overrides, extensionFlags) : featureFlagReport(null);
-  const deviceView = adapter === "mobile" ? mobileDeviceView(allDevices) : null;
+  const pinnedFlags = readiness.pinnedFlags?.(target) ?? null;
+  const staticFeatureFlags = pinnedFlags ? featureFlagReport(pinnedFlags.overrides, pinnedFlags) : featureFlagReport(null);
+  const deviceView = deviceSource ? deviceSource.view(allDevices) : null;
   const devices = deviceView?.devices ?? [];
   const discovery = deviceView?.deviceDiscoveryErrors.length ? { deviceDiscoveryErrors: deviceView.deviceDiscoveryErrors } : {};
   const discoveryNext = discovery.deviceDiscoveryErrors?.[0]?.userAction;
   if (json) {
-    const doProbe = !fast && adapter === "mobile" && deviceView !== null && deviceView.allConnectedDevices.length > 0;
+    const doProbe = !fast && deviceSource && deviceView !== null && deviceView.allConnectedDevices.length > 0;
     if (doProbe) {
-      const liveView = await mobileDeviceLiveView(target, deviceView);
+      const liveView = await deviceSource.live(target, deviceView);
       console.log(
         JSON.stringify(
           {
@@ -75,14 +67,14 @@ async function handleStatus({ options }) {
             ...discovery,
             ...liveView.additionalReachableDevices.length > 0 ? { additionalReachableDevices: liveView.additionalReachableDevices } : {},
             ...liveView.androidPortHints.length > 0 ? { androidPortHints: liveView.androidPortHints } : {},
-            next: discoveryNext ?? nextForLive(next, liveView.liveMap)
+            next: discoveryNext ?? deviceSource.nextForLive(next, liveView.liveMap)
           },
           null,
           2
         )
       );
     } else {
-      const runtime = !fast && adapter === "extension" ? await surface.runtimeStatus(target) : void 0;
+      const runtime = !fast && readiness.statusRuntime ? await surface.runtimeStatus(target) : void 0;
       console.log(
         JSON.stringify(
           {
@@ -113,21 +105,21 @@ async function handleStatus({ options }) {
       console.log(renderAcceptanceLines(taskView).join("\n"));
     }
   }
-  if (adapter !== "mobile") renderFeatureFlagLine(staticFeatureFlags, out);
-  if (deviceView) renderMobileDeviceList(deviceView, out);
-  if (!fast && adapter === "mobile" && deviceView !== null && deviceView.allConnectedDevices.length > 0) {
-    const liveView = await mobileDeviceLiveView(target, deviceView);
-    if (liveView.additionalReachableDevices.length > 0) renderAdditionalReachableDevices(liveView.additionalReachableDevices, out);
+  if (!deviceSource) renderFeatureFlagLine(staticFeatureFlags, out);
+  if (deviceSource && deviceView) deviceSource.renderList(deviceView, out);
+  if (!fast && deviceSource && deviceView !== null && deviceView.allConnectedDevices.length > 0) {
+    const liveView = await deviceSource.live(target, deviceView);
+    if (liveView.additionalReachableDevices.length > 0) deviceSource.renderAdditional(liveView.additionalReachableDevices, out);
     renderFeatureFlagLine(featureFlagReport(liveView.featureFlagOverrides), out);
-    renderMobileLiveBlock(devices, liveView.liveMap, out);
-    renderAndroidPortHints(liveView.androidPortHints, out);
-    console.log(`${out("label", "Next:")} ${out("cmd", discoveryNext ?? nextForLive(next, liveView.liveMap))}`);
-  } else if (!fast && adapter === "extension") {
+    deviceSource.renderLive(devices, liveView.liveMap, out);
+    deviceSource.renderPortHints(liveView.androidPortHints, out);
+    console.log(`${out("label", "Next:")} ${out("cmd", discoveryNext ?? deviceSource.nextForLive(next, liveView.liveMap))}`);
+  } else if (!fast && readiness.statusRuntime) {
     const runtime = await surface.runtimeStatus(target);
     renderRuntimeStatus(runtime, out);
     console.log(`${out("label", "Next:")} ${out("cmd", nextForRuntime(surface.hints.launch, surface.hints.relaunch, runtime))}`);
   } else {
-    if (adapter === "mobile") renderFeatureFlagLine(featureFlagReport(null), out);
+    if (deviceSource) renderFeatureFlagLine(featureFlagReport(null), out);
     console.log(`${out("label", "Next:")} ${out("cmd", discoveryNext ?? next)}`);
   }
   return EXIT.ok;

package/dist/commands/stop.js

@@ -27,7 +27,7 @@ async function handleStop(argv) {
   const collector = await stopProjectCollector(target);
   const signalled = (stop.signalled ?? 0) + (collector.stopped ? 1 : 0);
   const summary = collector.stopped ? `${stop.summary}; stopped analytics collector ${collector.pid}` : stop.summary;
-  const next = adapter === "extension" ? `${surface.hints.launch} --target ${shellQuote(target)}` : void 0;
+  const next = surface.devServer.afterStop?.(target);
   const userAction = `mm-harness status --target ${shellQuote(target)} --json`;
   if (json) {
     console.log(

package/dist/doctor.js

@@ -1,17 +1,11 @@
-import { spawnSync } from "node:child_process";
 import fs from "node:fs";
-import { createRequire } from "node:module";
 import path from "node:path";
 import { color } from "./cli-color.js";
 import { normalizeFeatureFlagRecord } from "./feature-flags.js";
-import {
-  mobileToolRecovery,
-  resolveMobileToolPath
-} from "../library/actions/mobile/platform/tool-paths.mjs";
-import { mobilePerpsEnvironment } from "./adapters/mobile/perps-env.js";
+import { getAdapterSurface } from "./adapters/surface.js";
 import { readRuntimeContextField, resolveRuntimeContextPath } from "./harness.js";
 import { isPin } from "./harness-pin.js";
-import { harnessExecutable, manifestPath, readJson, recipeHarnessRoot, recipeRuntimeDir, runnerDir } from "./paths.js";
+import { harnessExecutable, readJson, recipeHarnessRoot, recipeRuntimeDir, runnerDir } from "./paths.js";
 function requiredDoctorCheckSummary(checks) {
   const required = checks.filter((check) => check.required);
   const failed = required.filter((check) => check.status === "fail").map((check) => check.id);
@@ -42,21 +36,7 @@ function repoShape(target) {
   };
 }
 function compatibilityMode(adapter, target) {
-  const shape = repoShape(target);
-  if (adapter === "core") {
-    return fs.existsSync(path.join(target, "packages/perps-controller/src/index.ts")) ? "headless controller (no bridge)" : "unsupported/no bridge";
-  }
-  if (adapter === "terminal") {
-    return fs.existsSync(path.join(target, "src/features/perpetuals")) ? "slot browser over CDP (website; no product bridge)" : "unsupported/no bridge";
-  }
-  if (adapter === "mobile") {
-    if (shape.injectedHarness && shape.agenticService) return "runner bridge with injected app bridge";
-    if (shape.agenticService) return "runner bridge with app bridge";
-    return "runner bridge available; app bridge not installed";
-  }
-  if (!shape.extensionProject) return "unsupported/no bridge";
-  if (shape.extensionRuntime || shape.injectedHarness) return "bridge present";
-  return "bridge injectable";
+  return getAdapterSurface(adapter).readiness.compatibilityMode(target, repoShape(target));
 }
 function readPackageInfo(target) {
   const packageJsonPath = path.join(target, "package.json");
@@ -97,7 +77,8 @@ function fixtureFileSummary(file, adapter, reportedPath = file) {
     );
     const flagKeys = Object.keys(remoteFeatureFlags);
     return {
-      status: hasAccounts && (adapter === "core" || hasPassword) ? "ready" : "incomplete",
+      // A headless platform signs with the accounts alone; nothing unlocks a UI.
+      status: hasAccounts && (adapter !== void 0 && getAdapterSurface(adapter).headless || hasPassword) ? "ready" : "incomplete",
       path: reportedPath,
       accountCount: Array.isArray(data.accounts) ? data.accounts.length : 0,
       hasPassword,
@@ -155,7 +136,8 @@ function renderRuntimeContext(runtimeContext) {
   }
   return lines.join("\n");
 }
-function createDoctorReport(adapter, target, manifestValidation, actionManifestPath = manifestPath(adapter), mobilePlatform) {
+function createDoctorReport(adapter, target, manifestValidation, actionManifestPath = getAdapterSurface(adapter).actions.manifestPath(), platform) {
+  const readiness = getAdapterSurface(adapter).readiness;
   const mode = compatibilityMode(adapter, target);
   const manifestErrors = Number(manifestValidation.summary?.errors ?? 0);
   const checks = [
@@ -171,8 +153,7 @@ function createDoctorReport(adapter, target, manifestValidation, actionManifestP
       required: false,
       message: mode === "unsupported/no bridge" ? `No ${adapter} bridge is available for this checkout.` : `${adapter} compatibility mode: ${mode}.`
     },
-    ...adapter === "mobile" ? mobileToolDoctorChecks(mobilePlatform) : [],
-    ...adapter === "extension" ? [extensionBrowserDoctorCheck(target), extensionBrowserResolutionDoctorCheck(target)] : []
+    ...readiness.checks?.(target, platform) ?? []
   ];
   const requiredChecks = requiredDoctorCheckSummary(checks);
   return {
@@ -188,99 +169,11 @@ function createDoctorReport(adapter, target, manifestValidation, actionManifestP
     compatibilityMode: mode,
     shape: repoShape(target),
     fixture: fixtureSummary(target, adapter),
-    environment: adapter === "mobile" ? { mobilePerps: mobilePerpsEnvironment(target) } : {},
+    environment: readiness.environment?.(target) ?? {},
     runtimeContext: runtimeContextSummary(target, adapter),
     manifestValidation: manifestValidation.summary
   };
 }
-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 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 runnerInstallKind(runnerRoot, invokedPath, executablePath) {
   if (isPin(runnerRoot)) return "pinned-install";
   const normalizedRoot = path.normalize(runnerRoot);
@@ -344,11 +237,8 @@ function readJsonObject(file) {
 export {
   compatibilityMode,
   createDoctorReport,
-  extensionBrowserDoctorCheck,
-  extensionBrowserResolutionDoctorCheck,
   fixtureFileSummary,
   fixtureSummary,
-  mobileToolDoctorChecks,
   renderRuntimeContext,
   repoShape,
   requiredDoctorCheckSummary,