@deeeed/metamask-harness 0.72.0 → 0.74.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 0.74.0 - 2026-10-03
+
+### Changed
+
+- Adapters register in an `AdapterRegistry` (`src/adapters/registry.ts`) instead of a compiled-in union: the adapter id is a string, the four built-in surfaces register themselves, and `--adapter` resolves through the registry. `launch` moves behind a new `AdapterSurface.launch` member, so the command keeps only the shared grammar and no longer branches on the adapter name (39 such branches in `commands/launch/index.ts`, now 0). A test-only `example` adapter registers and launches with no shared-file edit. Flags, output, and the CLI goldens are unchanged.
+
+## 0.73.0 - 2026-10-03
+
+### Changed
+
+- Recipe discovery runs on `@farmslot/recipe-cli`: `run --list` and recipe completion candidates use its readiness rule, and `run --describe` and recipe assistance use its call-graph composition. mm-harness still supplies the view and the policy: only the requested adapter's libraries are loaded, and readiness is judged against the MetaMask manifest `run` executes, so a broken recipe for another platform no longer matters and team manifests follow the same rules as `run --plan`. Flags and output are unchanged; the discovery goldens prove it.
+- Move to the Farmslot release that ships `@farmslot/recipe-cli`: `@farmslot/protocol` 0.34.0, `@farmslot/recipe-harness` 0.22.1, `@farmslot/recipe-cli` 0.1.1, `@farmslot/agent-runtime` 0.16.0 and `@farmslot/expo-recipe` 0.13.1, all on one protocol and one recipe-harness copy. With recipe-harness 0.22, a library's `recipes/terminal/` folder counts as the terminal variant of its plain ids, so `run --list --adapter terminal` with the terminal library also lists `perps.manage-position` and its siblings; the `terminal.perps.*` ids are unchanged.
+
 ## 0.72.0 - 2026-10-03
 
 ### Added

package/dist/adapters/core/surface.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { depsCheck } from "@farmslot/recipe-harness/runtime/deps-readiness";
 import { shellQuote } from "../../commands/parse-args.js";
+import { adapterRegistry } from "../registry.js";
 const coreSurface = {
   adapter: "core",
   headless: true,
@@ -53,8 +54,10 @@ const coreSurface = {
     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")
 };
+adapterRegistry.register(coreSurface);
 export {
   coreSurface
 };

package/dist/adapters/extension/surface.js

@@ -9,6 +9,7 @@ import {
 } from "../slot-ports.js";
 import { decideExtensionReadiness } from "./runtime-decision.js";
 import { extensionProductConfigBlock } from "./product-config.js";
+import { adapterRegistry } from "../registry.js";
 function watcherStatus(buildLog) {
   if (buildLog === "ok") return "up";
   if (buildLog === "no-watch") return "down";
@@ -98,8 +99,16 @@ const extensionSurface = {
     launch: "mm-harness launch",
     relaunch: "mm-harness launch --build",
     runtimeProbeRecovery: (target) => `mm-harness launch --adapter extension --target ${shellQuote(path.resolve(target))}`
+  },
+  launch: async (context) => {
+    const [{ runDeviceLaunch }, { extensionLaunchProfile }] = await Promise.all([
+      import("../../commands/launch/device.js"),
+      import("../../commands/launch/extension.js")
+    ]);
+    return runDeviceLaunch(context, extensionLaunchProfile);
   }
 };
+adapterRegistry.register(extensionSurface);
 export {
   extensionRuntimeNextAction,
   extensionSurface

package/dist/adapters/mobile/surface.js

@@ -5,6 +5,7 @@ import { shellQuote } from "../../commands/parse-args.js";
 import { resolveMobileSlotPorts } from "../slot-ports.js";
 import { mobileRuntimeStatus } from "./prepare.js";
 import { hasRunwayProvisionBaseline, provisionRunwayMobile } from "./provision.js";
+import { adapterRegistry } from "../registry.js";
 function mobileRuntimeNextAction(reasonCode, target, platform) {
   const resolved = shellQuote(path.resolve(target));
   return reasonCode === "deps-missing" || reasonCode === "deps-partial" || reasonCode === "deps-stale" ? `cd ${resolved} && yarn setup` : `mm-harness launch ${platform} --adapter mobile --target ${resolved}`;
@@ -59,8 +60,16 @@ const mobileSurface = {
     launch: "mm-harness launch ios",
     relaunch: "mm-harness launch ios",
     runtimeProbeRecovery: (target) => `mm-harness status --target ${shellQuote(path.resolve(target))} --json`
+  },
+  launch: async (context) => {
+    const [{ runDeviceLaunch }, { mobileLaunchProfile }] = await Promise.all([
+      import("../../commands/launch/device.js"),
+      import("../../commands/launch/mobile.js")
+    ]);
+    return runDeviceLaunch(context, mobileLaunchProfile);
   }
 };
+adapterRegistry.register(mobileSurface);
 export {
   mobileRuntimeNextAction,
   mobileSurface

package/dist/adapters/registry.js

@@ -0,0 +1,17 @@
+const surfaces = /* @__PURE__ */ new Map();
+const adapterRegistry = {
+  register(surface) {
+    if (surfaces.has(surface.adapter)) throw new Error(`adapter '${surface.adapter}' is already registered`);
+    surfaces.set(surface.adapter, surface);
+  },
+  get(id) {
+    const surface = surfaces.get(id);
+    if (!surface) throw new Error(`unknown adapter '${id}' (registered: ${[...surfaces.keys()].join(", ")})`);
+    return surface;
+  },
+  has: (id) => surfaces.has(id),
+  list: () => [...surfaces.keys()]
+};
+export {
+  adapterRegistry
+};

package/dist/adapters/surface.js

@@ -1,15 +1,10 @@
-import { coreSurface } from "./core/surface.js";
-import { extensionSurface } from "./extension/surface.js";
-import { mobileSurface } from "./mobile/surface.js";
-import { terminalSurface } from "./terminal/surface.js";
-const SURFACES = {
-  mobile: mobileSurface,
-  extension: extensionSurface,
-  core: coreSurface,
-  terminal: terminalSurface
-};
+import { adapterRegistry } from "./registry.js";
+import "./mobile/surface.js";
+import "./extension/surface.js";
+import "./core/surface.js";
+import "./terminal/surface.js";
 function getAdapterSurface(adapter) {
-  return SURFACES[adapter];
+  return adapterRegistry.get(adapter);
 }
 export {
   getAdapterSurface

package/dist/adapters/terminal/launch.js

@@ -0,0 +1,85 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { flag, str } from "../../commands/shared.js";
+import { runnerDir } from "../../paths.js";
+const TERMINAL_ONLY_LAUNCH_OPTIONS = Object.freeze({
+  signer: "--signer",
+  account: "--account",
+  freshProfile: "--fresh-profile",
+  headless: "--headless",
+  headful: "--headful",
+  slowMo: "--slow-mo",
+  network: "--network",
+  mainnetConfirmation: "--mainnet-confirmation"
+});
+function terminalOnlyLaunchFlags(options) {
+  return Object.entries(TERMINAL_ONLY_LAUNCH_OPTIONS).filter(([key]) => options[key] !== void 0 && options[key] !== false).map(([, name]) => name);
+}
+function parseTerminalLauncherOutput(output) {
+  const text = output.trim();
+  if (!text) return { status: "fail", error: "the terminal launcher printed no summary" };
+  try {
+    return JSON.parse(text);
+  } catch {
+    const last = text.split("\n").filter((line) => line.trim()).pop() ?? "";
+    try {
+      return JSON.parse(last);
+    } catch {
+      return { status: "fail", error: `the terminal launcher printed no JSON summary: ${last.slice(0, 200)}` };
+    }
+  }
+}
+async function launchTerminal({ options, target, jsonOutput, stream, usage }) {
+  const cdpPort = str(options, "cdpPort") ?? process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
+  const appPort = str(options, "watcherPort") ?? process.env.TERMINAL_APP_PORT ?? process.env.RECIPE_WATCHER_PORT ?? process.env.WATCHER_PORT;
+  if (!cdpPort || !appPort) {
+    return usage(
+      "terminal launch needs the slot browser CDP port and the slot dev-server port.",
+      "mm-harness launch --adapter terminal --cdp-port <port> --watcher-port <app port>"
+    );
+  }
+  const args = [
+    path.join(runnerDir, "adapters", "terminal", "launch.mjs"),
+    "--target",
+    target,
+    "--cdp-port",
+    cdpPort,
+    "--app-port",
+    appPort,
+    "--signer",
+    str(options, "signer") ?? process.env.TERMINAL_SIGNER ?? "extension",
+    "--account",
+    str(options, "account") ?? process.env.TERMINAL_ACCOUNT ?? "dev1",
+    "--json"
+  ];
+  if (flag(options, "freshProfile")) args.push("--fresh-profile");
+  if (flag(options, "headless")) args.push("--headless");
+  if (flag(options, "headful")) args.push("--headful");
+  const slowMo = str(options, "slowMo");
+  if (slowMo) args.push("--slow-mo", slowMo);
+  const network = str(options, "network");
+  if (network) args.push("--network", network);
+  const mainnetConfirmation = str(options, "mainnetConfirmation");
+  if (mainnetConfirmation) args.push("--mainnet-confirmation", mainnetConfirmation);
+  stream.phase("launch", { adapter: "terminal", cdpPort, appPort });
+  let output = "";
+  let status = 0;
+  try {
+    output = execFileSync(process.execPath, args, { encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] });
+  } catch (error) {
+    status = 1;
+    output = String(error.stdout ?? "");
+  }
+  const result = parseTerminalLauncherOutput(output);
+  if (jsonOutput) console.log(JSON.stringify({ schemaVersion: 1, command: "launch", adapter: "terminal", target, ...result }, null, 2));
+  else if (result.status === "pass") console.log(`\u2713 terminal browser ${result.reused ? "reused" : "started"} on CDP ${result.cdpPort} (${result.signer}, ${result.account?.name})`);
+  else console.error(`\u2717 terminal launch failed: ${result.error ?? "unknown error"}`);
+  stream.complete(result.status === "pass" ? "pass" : "fail", status);
+  return result.status === "pass" ? 0 : 1;
+}
+export {
+  TERMINAL_ONLY_LAUNCH_OPTIONS,
+  launchTerminal,
+  parseTerminalLauncherOutput,
+  terminalOnlyLaunchFlags
+};

package/dist/adapters/terminal/surface.js

@@ -3,6 +3,7 @@ import { shellQuote } from "../../commands/parse-args.js";
 import fs from "node:fs";
 import { TERMINAL_CONSOLE_FILES, terminalRuntimeFile } from "./console-capture.js";
 import { stopTerminalBrowserSync } from "./stop.js";
+import { adapterRegistry } from "../registry.js";
 function portFromEnv(...names) {
   for (const name of names) {
     const raw = process.env[name];
@@ -95,8 +96,10 @@ const terminalSurface = {
     launch: "mm-harness launch --adapter terminal --cdp-port <port> --watcher-port <app port>",
     relaunch: "mm-harness launch --adapter terminal --fresh-profile",
     runtimeProbeRecovery: (target) => `mm-harness doctor --adapter terminal --target ${shellQuote(path.resolve(target))}`
-  }
+  },
+  launch: async (context) => (await import("./launch.js")).launchTerminal(context)
 };
+adapterRegistry.register(terminalSurface);
 export {
   terminalAppPort,
   terminalCdpPort,

package/dist/commands/launch/device.js

@@ -0,0 +1,346 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import { color, colorHumanMessage } from "../../cli-color.js";
+import { handleHarness } from "../../harness.js";
+import { recipeRuntimePath, walletFixturePath } from "../../paths.js";
+import { getAdapterSurface } from "../../adapters/surface.js";
+import { EXIT, flag, str } from "../shared.js";
+import {
+  checkHealBounds,
+  ensureOverlay,
+  newHealState
+} from "../../heal-bounds.js";
+import {
+  FeatureFlagSpecError,
+  fixtureFeatureFlags,
+  parseRemoteFlagSpec,
+  remoteFlagRequestFor
+} from "../../feature-flags.js";
+import { terminalOnlyLaunchFlags } from "../../adapters/terminal/launch.js";
+async function runDeviceLaunch(context, profile) {
+  const { adapter, options, target, heal, jsonOutput, machine, stream, usage } = context;
+  const terminalOnly = terminalOnlyLaunchFlags(options);
+  if (terminalOnly.length > 0) {
+    return usage(
+      `${terminalOnly.join(", ")} apply only to --adapter terminal; ${adapter} does not read them.`,
+      "drop the terminal flags, or pass --adapter terminal"
+    );
+  }
+  const wantBuild = flag(options, "build");
+  const wantVerify = flag(options, "verify");
+  const wantWatch = flag(options, "watch");
+  const wantRunway = flag(options, "runway");
+  const wantClearMetro = flag(options, "clearMetro");
+  const requestedSurface = str(options, "surface");
+  const legacySidepanel = flag(options, "sidepanel");
+  const legacyFullscreen = flag(options, "fullscreen");
+  const remoteFlagSpec = str(options, "remoteFlag");
+  const refused = profile.refuseFlags(context, { watch: wantWatch, runway: wantRunway, clearMetro: wantClearMetro, remoteFlagSpec });
+  if (refused) return usage(refused.message, refused.userAction);
+  if (requestedSurface !== void 0 && requestedSurface !== "fullscreen" && requestedSurface !== "sidepanel") {
+    return usage(
+      `--surface must be fullscreen or sidepanel (got: ${requestedSurface}).`,
+      "pass --surface fullscreen or --surface sidepanel"
+    );
+  }
+  if (legacySidepanel && legacyFullscreen) {
+    return usage("--sidepanel and --fullscreen conflict.", "pass exactly one Extension surface");
+  }
+  const legacySurface = legacySidepanel ? "sidepanel" : legacyFullscreen ? "fullscreen" : void 0;
+  if (requestedSurface && legacySurface && requestedSurface !== legacySurface) {
+    return usage(
+      `--surface ${requestedSurface} conflicts with --${legacySurface}.`,
+      "pass one consistent Extension surface"
+    );
+  }
+  const displayMode = requestedSurface ?? legacySurface ?? "fullscreen";
+  let remoteFlagRequest;
+  try {
+    remoteFlagRequest = remoteFlagRequestFor({
+      ...fixtureFeatureFlags(walletFixturePath(target)),
+      ...remoteFlagSpec === void 0 ? {} : parseRemoteFlagSpec(remoteFlagSpec)
+    });
+  } catch (error) {
+    if (!(error instanceof FeatureFlagSpecError)) throw error;
+    return usage(error.message, error.userAction);
+  }
+  for (const portFlag of ["cdpPort", "watcherPort"]) {
+    const value = str(options, portFlag);
+    if (value !== void 0 && !/^\d+$/u.test(value)) {
+      return usage(
+        `--${portFlag === "cdpPort" ? "cdp-port" : "watcher-port"} must be numeric (got: ${value}).`,
+        `pass a numeric port, e.g. --${portFlag === "cdpPort" ? "cdp-port 6663" : "watcher-port 8081"}`
+      );
+    }
+  }
+  getAdapterSurface(adapter).resolveSlotPorts(target);
+  const envError = profile.applyEnv?.(context);
+  if (envError) return usage(envError.message, envError.userAction);
+  const cdpPort = str(options, "cdpPort");
+  if (cdpPort) {
+    process.env.CDP_PORT = cdpPort;
+    process.env.RECIPE_CDP_PORT = cdpPort;
+  }
+  const watcherPort = str(options, "watcherPort");
+  if (watcherPort) {
+    process.env.WATCHER_PORT = watcherPort;
+    process.env.RECIPE_WATCHER_PORT = watcherPort;
+    process.env.METRO_PORT = watcherPort;
+  }
+  const launch = {
+    ...context,
+    tier: wantBuild ? "build" : "quick",
+    wantWatch,
+    wantVerify,
+    wantClearMetro,
+    displayMode,
+    remoteFlagRequest,
+    compose: (tier2, restartApp = false, clearMetro = false) => profile.compose(launch, tier2, restartApp, clearMetro),
+    settle: (state2, provenFlags, sidepanelRecoveryAllowed = true) => settleLaunch(launch, profile, state2, sidepanelRecoveryAllowed, provenFlags),
+    fail: (state2, failure) => launchFail(launch, profile, state2, failure)
+  };
+  const { tier } = launch;
+  profile.start(launch);
+  const state = newHealState();
+  if (tier === "quick" && nativeInputsChanged(target, profile.nativeInputs)) {
+    return usage("native build inputs changed since last build.", profile.rebuildCommand(launch));
+  }
+  stream.phase("install");
+  const ensured = await ensureOverlay(adapter, target, heal, state, machine);
+  if (!ensured.ok) {
+    return launch.fail(state, {
+      code: "OVERLAY_INSTALL_FAILED",
+      message: ensured.error ?? "overlay install failed",
+      recoverable: false,
+      exitCode: EXIT.infra
+    });
+  }
+  stream.phase("healthcheck");
+  const blocked = await profile.healthcheck?.(launch, state);
+  if (blocked !== void 0) return blocked;
+  stream.phase("launch");
+  let attempt = await launch.compose(tier, false, wantClearMetro);
+  if (attempt.status === 0) {
+    return await launch.settle(state, attempt.remoteFeatureFlags);
+  }
+  const readinessFailure = readinessBlockFailure(attempt);
+  if (readinessFailure) return launch.fail(state, readinessFailure);
+  const classified = profile.classify(launch, attempt.output);
+  if (classified) return launch.fail(state, classified);
+  if (heal === "off") {
+    return launch.fail(state, {
+      code: "LAUNCH_FAILED",
+      message: `launch ${adapter}${launch.mobileTarget ? ` ${launch.mobileTarget}` : ""} failed (healing off)`,
+      recoverable: false,
+      exitCode: EXIT.infra
+    });
+  }
+  const handled = await profile.beforeHeal?.(launch, attempt, state);
+  if (handled !== void 0) return handled;
+  const bound = checkHealBounds(target, attempt.output, state);
+  if (bound !== null) {
+    return launch.fail(state, {
+      code: bound.code,
+      message: bound.message,
+      recoverable: false,
+      userAction: bound.userAction,
+      exitCode: bound.exitCode,
+      originalError: bound.originalError
+    });
+  }
+  const recovery = profile.recovery(launch, attempt.output);
+  state.attemptedRecoveries.push(recovery.code);
+  stream.phase("recover");
+  const recoveryTier = recovery.restartApp && tier === "build" ? "quick" : tier;
+  if (!jsonOutput) {
+    process.stderr.write(`launch: recovering (${recovery.code}) with the ${recoveryTier} tier
+`);
+  }
+  attempt = await launch.compose(recoveryTier, recovery.restartApp, false);
+  if (attempt.status === 0) {
+    state.recovered.push(recovery.code);
+    return await launch.settle(state, attempt.remoteFeatureFlags);
+  }
+  const retryReadinessFailure = readinessBlockFailure(attempt);
+  if (retryReadinessFailure) return launch.fail(state, retryReadinessFailure);
+  return launch.fail(state, {
+    code: "SAME_RECOVERY_TWICE",
+    message: `launch ${adapter}${launch.mobileTarget ? ` ${launch.mobileTarget}` : ""} failed again after ${recovery.code} recovery \u2014 refusing to loop.`,
+    recoverable: false,
+    exitCode: EXIT.bounded,
+    originalError: attempt.output.trim() || void 0
+  });
+}
+function readinessBlockFailure(result) {
+  const block = result.readinessBlock;
+  if (!block) return void 0;
+  return {
+    code: block.reasonCode === "deps-not-ready" ? "MOBILE_DEPENDENCIES_NOT_READY" : "MOBILE_READINESS_BLOCKED",
+    message: block.message,
+    userAction: block.userAction,
+    recoverable: false,
+    exitCode: result.status
+  };
+}
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:@%+=,-]+$/u.test(value)) return value;
+  return `'${value.replace(/'/gu, `'"'"'`)}'`;
+}
+function nativeInputsChanged(target, paths) {
+  const baselineFile = recipeRuntimePath(target, ".last-build-ref");
+  let baseline;
+  try {
+    baseline = fs.readFileSync(baselineFile, "utf8").trim();
+  } catch {
+    return false;
+  }
+  if (!baseline) return false;
+  try {
+    const diff = execFileSync("git", ["-C", target, "diff", "--name-only", baseline, "--", ...paths], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return diff.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function settleLaunch(launch, profile, state, sidepanelRecoveryAllowed, provenFlags) {
+  const proven = profile.provenFlags(launch, launch.remoteFlagRequest?.flags ?? {}, provenFlags);
+  if (!("flags" in proven)) return launch.fail(state, proven);
+  const stopped = await profile.finish?.(launch, state, sidepanelRecoveryAllowed);
+  if (stopped !== void 0) return stopped;
+  const { adapter, target, stream, tier } = launch;
+  if (launch.wantVerify) {
+    stream.phase("verify");
+    const verifyArgs = ["verify", "--adapter", adapter, "--target", target, ...profile.verifyArgs(launch)];
+    if (launch.machine) verifyArgs.push("--json");
+    const exitCode = await handleHarness(verifyArgs);
+    if (stream.enabled) {
+      for (const mutation of state.mutations) stream.mutation(mutation);
+      for (const recovery of state.recovered) stream.recovery(recovery);
+      stream.complete(exitCode === EXIT.ok ? "pass" : "fail", exitCode, {
+        adapter,
+        platform: profile.platformLabel(launch),
+        tier,
+        recovered: state.recovered,
+        mutations: state.mutations,
+        metro: profile.evidence?.(target),
+        remoteFeatureFlags: proven.flags
+      });
+    }
+    return exitCode;
+  }
+  return launchPass(launch, profile, state, proven.flags);
+}
+function launchPass(launch, profile, state, remoteFlags) {
+  const { adapter, mobileTarget, target, stream, tier } = launch;
+  if (stream.enabled) {
+    for (const mutation of state.mutations) stream.mutation(mutation);
+    for (const recovery of state.recovered) stream.recovery(recovery);
+    stream.complete("pass", EXIT.ok, {
+      adapter,
+      platform: profile.platformLabel(launch),
+      tier,
+      recovered: state.recovered,
+      mutations: state.mutations,
+      metro: profile.evidence?.(target),
+      remoteFeatureFlags: remoteFlags
+    });
+  } else if (launch.jsonOutput) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: "launch",
+          adapter,
+          platform: profile.platformLabel(launch),
+          tier,
+          status: "pass",
+          phase: "launch",
+          recovered: state.recovered,
+          mutations: state.mutations,
+          metro: profile.evidence?.(target),
+          remoteFeatureFlags: remoteFlags,
+          exitCode: EXIT.ok
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    const tierNote = tier === "quick" ? "quick relaunch, no native build" : tier;
+    const devNote = process.env.MM_HARNESS_BIN ? ` ${color("dim", "[dev: MM_HARNESS_BIN]")}` : "";
+    console.error(
+      `${color("ok", "\u2713")} launch ${adapter}${mobileTarget ? ` ${mobileTarget}` : ""} \u2014 ${color("ok", profile.deviceLabel(launch))} \xB7 ${tierNote} \xB7 app + bridge ready${devNote}`
+    );
+  }
+  return EXIT.ok;
+}
+function launchFail(launch, profile, state, failure) {
+  const { adapter, mobileTarget, target, stream, tier } = launch;
+  const userAction = failure.userAction ?? `mm-harness doctor --fix --adapter ${adapter} --target ${shellQuote(target)} --json`;
+  if (stream.enabled) {
+    for (const mutation of state.mutations) stream.mutation(mutation);
+    for (const recovery of state.recovered) stream.recovery(recovery);
+    stream.error({
+      code: failure.code,
+      message: failure.message,
+      retryable: failure.recoverable,
+      userAction,
+      originalError: failure.originalError ?? null
+    });
+    stream.complete("fail", failure.exitCode, {
+      adapter,
+      platform: mobileTarget ?? null,
+      tier,
+      recovered: state.recovered,
+      mutations: state.mutations,
+      recoverable: failure.recoverable,
+      attemptedRecoveries: state.attemptedRecoveries,
+      metro: profile.evidence?.(target)
+    });
+  } else if (launch.jsonOutput) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: "launch",
+          adapter,
+          platform: mobileTarget ?? null,
+          tier,
+          status: "fail",
+          phase: state.attemptedRecoveries.length ? "recover" : "launch",
+          recovered: state.recovered,
+          mutations: state.mutations,
+          recoverable: failure.recoverable,
+          attemptedRecoveries: state.attemptedRecoveries,
+          metro: profile.evidence?.(target),
+          exitCode: failure.exitCode,
+          error: {
+            code: failure.code,
+            message: failure.message,
+            retryable: failure.recoverable,
+            userAction,
+            originalError: failure.originalError ?? null
+          }
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    console.error(colorHumanMessage(
+      `\u2717 launch ${adapter}${mobileTarget ? ` ${mobileTarget}` : ""} failed
+  ${failure.message}` + (failure.originalError ? `
+  --- original failure ---
+${failure.originalError}` : "") + `
+  Next: ${userAction}`
+    ));
+  }
+  return failure.exitCode;
+}
+export {
+  runDeviceLaunch,
+  shellQuote
+};