@deeeed/metamask-harness 0.5.0 → 0.6.0

package/dist/commands/run.js

@@ -0,0 +1,217 @@
+import fs from "node:fs";
+import path from "node:path";
+import { walletFixturePath } from "../paths.js";
+import { EXIT } from "./shared.js";
+import {
+  adapterOption,
+  optionFlag,
+  optionString,
+  requiredOption,
+  resolveAdapter,
+  runtimeOptionsFromCli,
+  targetPath,
+  usageError
+} from "./parse-args.js";
+import {
+  countRecipeNodes,
+  emitHealViolation,
+  executeWithHealBounds,
+  prepareHeal,
+  resolveMetaMaskLibrarySources,
+  runRecipe,
+  validateRunRecipeStatic
+} from "./run-engine.js";
+async function handleRun({ positional, options }) {
+  const targetRecipe = positional[0];
+  if (!targetRecipe) throw usageError("run requires <recipe.json>.");
+  if (optionFlag(options, "plan")) return handleRunPlan(targetRecipe, options);
+  const adapter = adapterOption(options);
+  const json = optionFlag(options, "json");
+  const target = targetPath(options);
+  const artifactsDir = requiredOption(options, "artifactsDir", "run requires --artifacts-dir <dir>.");
+  const prepared = await prepareHeal(adapter, target, options, json);
+  if (typeof prepared === "number") return prepared;
+  const { state, heal } = prepared;
+  const validated = await validateRunRecipeStatic(targetRecipe, adapter, options);
+  if (validated.usageError) {
+    return emitRunUsageError(json, adapter, validated.recipeFile, validated.usageError.code, validated.usageError.message);
+  }
+  if (validated.errorCount > 0) {
+    return emitRunValidationError(json, adapter, validated.recipeFile, validated.findings, validated.errorCount);
+  }
+  const librarySources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+  const runtimeOptions = {
+    ...runtimeOptionsFromCli(options),
+    ...librarySources ? { librarySources } : {},
+    stdoutIsMachineContract: json
+  };
+  const { result, violation } = await executeWithHealBounds(
+    () => runRecipe(adapter, targetRecipe, artifactsDir, target, optionString(options, "actionManifest"), runtimeOptions),
+    adapter,
+    target,
+    heal,
+    state
+  );
+  if (violation !== null) return emitHealViolation(json, "run", result, violation, state, adapter);
+  const exitCode = result.status === "pass" ? EXIT.ok : EXIT.runtime;
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: "run",
+          adapter,
+          status: result.status,
+          exitCode,
+          recovered: state.recovered,
+          mutations: state.mutations,
+          result
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    console.log(`MetaMask recipe run: ${result.status}
+Artifacts: ${result.artifactManifestPath}`);
+  }
+  return exitCode;
+}
+async function handleRunPlan(recipeArg, options) {
+  const json = optionFlag(options, "json");
+  const { adapter, target } = resolveAdapter(options);
+  const validated = await validateRunRecipeStatic(recipeArg, adapter, options);
+  if (validated.usageError) {
+    return emitPlanUsageError(json, adapter, validated.recipeFile, validated.usageError.code, validated.usageError.message);
+  }
+  const { recipe, recipeFile, findings, errorCount, manifestOk, schemaValid } = validated;
+  const status = errorCount === 0 ? "pass" : "fail";
+  const nodeCount = countRecipeNodes(recipe);
+  const artifactsDir = optionString(options, "artifactsDir");
+  const plan = [
+    { step: "resolve.recipe", confidence: "static", status: "ok", detail: recipeFile },
+    { step: "resolve.adapter", confidence: "static", status: "ok", detail: adapter },
+    {
+      step: "resolve.artifactsDir",
+      confidence: "static",
+      status: "ok",
+      detail: artifactsDir ? path.resolve(artifactsDir) : "(resolved to the slot artifacts dir at run time)"
+    },
+    {
+      step: "validate.manifest",
+      confidence: "static",
+      status: manifestOk ? "ok" : "error",
+      detail: manifestOk ? "action manifest is well-formed" : "action manifest failed validation"
+    },
+    {
+      step: "validate.schema",
+      confidence: "static",
+      status: manifestOk && schemaValid ? "ok" : "error",
+      detail: "recipe document schema + action existence/platform vs the adapter manifest"
+    },
+    {
+      step: "fixture.file",
+      confidence: "static",
+      status: "ok",
+      detail: fs.existsSync(walletFixturePath(target)) ? `present: ${walletFixturePath(target)}` : `absent: ${walletFixturePath(target)} (fixtures set to seed)`
+    },
+    {
+      step: "overlay.ensure",
+      confidence: "conditional",
+      status: "planned",
+      detail: "would auto-ensure the runtime overlay if missing (install phase)"
+    },
+    ...adapter === "core" ? [] : [
+      {
+        step: "launch.app",
+        confidence: "conditional",
+        status: "planned",
+        detail: "would launch/attach the app + heal transport (Metro/Chrome/CDP) before executing"
+      }
+    ],
+    {
+      step: "execute.nodes",
+      confidence: "conditional",
+      status: "planned",
+      detail: nodeCount === void 0 ? "would execute the recipe nodes" : `would execute ${nodeCount} recipe node(s)`
+    }
+  ];
+  if (json) {
+    const payload = { schemaVersion: 1, command: "run", mode: "plan", status, adapter, recipe: recipeFile, findings, plan };
+    if (status === "fail") payload.error = { code: "RECIPE_VALIDATION_FAILED", message: `recipe validation found ${errorCount} error(s)` };
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(`plan ${status} \u2014 ${adapter} \u2014 ${recipeFile}`);
+    for (const item of plan) {
+      const mark = item.status === "error" ? "\u2717" : item.status === "ok" ? "\u2713" : "\xB7";
+      console.log(`  ${mark} [${item.confidence}] ${item.step}: ${item.detail}`);
+    }
+    if (findings.length) {
+      console.log("findings:");
+      for (const finding of findings) {
+        console.log(`  ${finding.severity === "error" ? "\u2717" : "\u26A0"} ${finding.code} ${finding.path} \u2014 ${finding.message}`);
+      }
+    }
+  }
+  return status === "pass" ? EXIT.ok : EXIT.validation;
+}
+function emitPlanUsageError(json, adapter, recipeFile, code, message) {
+  if (json) {
+    console.log(
+      JSON.stringify(
+        { schemaVersion: 1, command: "run", mode: "plan", status: "fail", adapter, recipe: recipeFile, error: { code, message } },
+        null,
+        2
+      )
+    );
+  } else {
+    console.error(`\u2717 run --plan: ${message}`);
+  }
+  return EXIT.usage;
+}
+function emitRunUsageError(json, adapter, recipeFile, code, message) {
+  if (json) {
+    console.log(
+      JSON.stringify(
+        { schemaVersion: 1, command: "run", adapter, status: "fail", exitCode: EXIT.usage, recipe: recipeFile, error: { code, message } },
+        null,
+        2
+      )
+    );
+  } else {
+    console.error(`\u2717 run: ${message}`);
+  }
+  return EXIT.usage;
+}
+function emitRunValidationError(json, adapter, recipeFile, findings, errorCount) {
+  const message = `recipe validation found ${errorCount} error(s)`;
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: "run",
+          adapter,
+          status: "fail",
+          exitCode: EXIT.validation,
+          recovered: [],
+          mutations: [],
+          recipe: recipeFile,
+          findings,
+          error: { code: "RECIPE_VALIDATION_FAILED", message }
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    console.error(`\u2717 run: ${message}`);
+    for (const finding of findings) {
+      if (finding.severity === "error") console.error(`  ${finding.code} ${finding.path} \u2014 ${finding.message}`);
+    }
+  }
+  return EXIT.validation;
+}
+export {
+  handleRun
+};

package/dist/commands/runtime-decision.js

@@ -0,0 +1,58 @@
+import { decideExtensionReadiness } from "../adapters/extension/runtime-decision.js";
+import { decideMobileReadiness } from "../adapters/mobile/runtime-decision.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 report2 = {
+      schemaVersion: 1,
+      adapter,
+      target,
+      decision: "unknown",
+      clean: false,
+      reasonCode: "adapter-unsupported",
+      reasons: [`runtime-decision applies to extension and mobile adapters, not ${adapter}.`],
+      checks: {},
+      actions: []
+    };
+    if (optionFlag(options, "json")) console.log(JSON.stringify(report2, null, 2));
+    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")
+  });
+  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] ?? ""}`);
+  return 0;
+}
+export {
+  handleRuntimeDecision
+};

package/dist/commands/runtime-health.js

@@ -0,0 +1,25 @@
+import {
+  adapterOption,
+  optionFlag,
+  optionString,
+  parsePort,
+  targetPath
+} from "./parse-args.js";
+async function handleRuntimeHealth({ options }) {
+  const adapter = adapterOption(options);
+  if (adapter !== "extension") throw new Error("runtime-health currently applies to the extension adapter.");
+  const target = targetPath(options);
+  const cdpPort = parsePort(
+    optionString(options, "cdpPort") ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT,
+    "runtime-health requires --cdp-port <port>."
+  );
+  const { checkExtensionRuntimeHealth, formatHealthFailure } = await import("../adapters/extension/runtime.js");
+  const report = await checkExtensionRuntimeHealth(target, cdpPort);
+  if (optionFlag(options, "json")) console.log(JSON.stringify(report, null, 2));
+  else if (report.status === "PASS") console.log(`PASS extension runtime cdp=${cdpPort} target=${report.targetUrl}`);
+  else console.error(formatHealthFailure(report, target));
+  return report.status === "PASS" ? 0 : 1;
+}
+export {
+  handleRuntimeHealth
+};

package/dist/commands/runtime-launch.js

@@ -0,0 +1,139 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { recipeHarnessPath } from "../paths.js";
+import {
+  adapterOption,
+  isRecord,
+  optionFlag,
+  optionString,
+  parsePort,
+  shellQuote,
+  targetPath
+} from "./parse-args.js";
+async function handleRuntimeLaunch({ options }) {
+  const adapter = adapterOption(options);
+  const target = targetPath(options);
+  if (adapter !== "extension") throw new Error("runtime-launch currently applies to the extension adapter.");
+  const cdpPort = parsePort(
+    optionString(options, "cdpPort") ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT,
+    "runtime-launch requires --cdp-port <port>."
+  );
+  const chromeUserDataDir = optionString(options, "chromeUserDataDir");
+  const artifactsDir = path.resolve(
+    optionString(options, "artifactsDir") ?? recipeHarnessPath(target, "extension", "runtime-launch", (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/gu, ""))
+  );
+  const startWatch = optionFlag(options, "startWatch");
+  const liveScript = recipeHarnessPath(target, "extension", "scripts", "live.sh");
+  const command = [
+    "bash",
+    liveScript,
+    "--target",
+    target,
+    "--cdp-port",
+    String(cdpPort),
+    startWatch ? "--start-watch" : "--launch-existing-dist",
+    "--artifacts-dir",
+    artifactsDir
+  ];
+  if (chromeUserDataDir) command.push("--chrome-user-data-dir", chromeUserDataDir);
+  const remoteFlag = optionString(options, "remoteFlag");
+  if (remoteFlag) command.push("--remote-flag", remoteFlag);
+  if (!fs.existsSync(liveScript)) {
+    const report2 = runtimeLaunchReport("fail", {
+      adapter,
+      target,
+      cdpPort,
+      artifactsDir,
+      reason: "harness_live_script_missing",
+      fix: `Run mm-harness install --adapter extension --target ${shellQuote(target)}, then rerun: ${runtimeLaunchCommand(target, cdpPort, chromeUserDataDir)}`,
+      command
+    });
+    printRuntimeLaunchReport(report2, optionFlag(options, "json"));
+    return 1;
+  }
+  fs.mkdirSync(artifactsDir, { recursive: true });
+  const jsonMode = optionFlag(options, "json");
+  if (!jsonMode) {
+    console.error(`recipe: runtime-launch starting (cdp=${cdpPort}${startWatch ? ", clean webpack build" : ", existing dist"})`);
+  } else {
+    console.error(JSON.stringify({
+      schemaVersion: 1,
+      type: "progress",
+      command: "rebuild",
+      phase: "runtime-launch",
+      message: startWatch ? "clean webpack build starting" : "launching existing dist",
+      cdpPort
+    }));
+  }
+  const result = spawnSync(command[0], command.slice(1), {
+    cwd: target,
+    encoding: "utf8",
+    maxBuffer: 5 * 1024 * 1024,
+    stdio: jsonMode ? ["ignore", "pipe", "pipe"] : "inherit"
+  });
+  const summaryPath = path.join(artifactsDir, "summary.json");
+  const summary = readJsonIfExists(summaryPath);
+  if (result.status === 0 && isRecord(summary) && summary.status === "pass") {
+    const report2 = runtimeLaunchReport("pass", {
+      adapter,
+      target,
+      cdpPort,
+      artifactsDir,
+      summaryPath,
+      reason: "runtime_ready",
+      fix: "",
+      command
+    });
+    printRuntimeLaunchReport(report2, optionFlag(options, "json"));
+    return 0;
+  }
+  const launchLogPath = path.join(artifactsDir, "launch", "logs", "launch.log");
+  const report = runtimeLaunchReport("fail", {
+    adapter,
+    target,
+    cdpPort,
+    artifactsDir,
+    summaryPath: fs.existsSync(summaryPath) ? summaryPath : void 0,
+    launchLogPath: fs.existsSync(launchLogPath) ? launchLogPath : void 0,
+    reason: "runtime_launch_failed",
+    fix: `Read ${fs.existsSync(launchLogPath) ? launchLogPath : summaryPath}, fix the first error, then rerun: ${runtimeLaunchCommand(target, cdpPort, chromeUserDataDir, startWatch)}`,
+    command,
+    exitCode: result.status ?? 1
+  });
+  printRuntimeLaunchReport(report, optionFlag(options, "json"));
+  return 1;
+}
+function runtimeLaunchCommand(target, cdpPort, chromeUserDataDir, startWatch = false) {
+  const base = `mm-harness runtime-launch --adapter extension --target ${shellQuote(target)} --cdp-port ${cdpPort}`;
+  const withMode = startWatch ? `${base} --start-watch` : base;
+  return chromeUserDataDir ? `${withMode} --chrome-user-data-dir ${shellQuote(chromeUserDataDir)}` : withMode;
+}
+function runtimeLaunchReport(status, fields) {
+  return {
+    schemaVersion: 1,
+    status,
+    ...fields
+  };
+}
+function printRuntimeLaunchReport(report, json) {
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  const status = String(report.status).toUpperCase();
+  console.log(`${status} runtime-launch ${report.reason}`);
+  if (report.status === "fail") console.log(`Fix: ${report.fix}`);
+  console.log(`Artifacts: ${report.artifactsDir}`);
+}
+function readJsonIfExists(file) {
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+export {
+  handleRuntimeLaunch
+};

package/dist/commands/self-test.js

@@ -0,0 +1,52 @@
+import { mkdtemp } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { loadActionManifest, validateManifest } from "../manifest.js";
+import { recipePath, runnerDir } from "../paths.js";
+import {
+  optionFlag,
+  optionString,
+  requiredOption
+} from "./parse-args.js";
+import { runRecipe } from "./run-engine.js";
+async function handleSelfTest({ options }) {
+  const result = await runSelfTest(options);
+  if (optionFlag(options, "json")) console.log(JSON.stringify(result, null, 2));
+  else console.log(`MetaMask runner self-test: ${result.status}
+Artifacts: ${result.artifactsDir}`);
+  return result.status === "pass" ? 0 : 1;
+}
+async function runSelfTest(options) {
+  const root = optionString(options, "artifactsDir") ? path.resolve(requiredOption(options, "artifactsDir", "self-test artifacts dir missing.")) : await mkdtemp(path.join(os.tmpdir(), "mm-harness-runner-"));
+  const previousAutoHud = process.env.METAMASK_RECIPE_AUTO_HUD;
+  const runs = [];
+  try {
+    process.env.METAMASK_RECIPE_AUTO_HUD = "0";
+    for (const adapter of ["mobile", "extension"]) {
+      const manifest = loadActionManifest(adapter);
+      const manifestValidation = await validateManifest(manifest);
+      const smokeRecipe = recipePath(
+        adapter === "mobile" ? "smoke.mobile.recipe.json" : "smoke.extension.recipe.json"
+      );
+      const artifactsDir = path.join(root, adapter);
+      const result = await runRecipe(adapter, smokeRecipe, artifactsDir, runnerDir, void 0, {
+        skipExtensionRuntimePrepare: true
+      });
+      runs.push({ adapter, manifestValidation: manifestValidation.summary, artifactsDir, result });
+    }
+  } finally {
+    restoreEnv("METAMASK_RECIPE_AUTO_HUD", previousAutoHud);
+  }
+  return {
+    status: runs.every((run) => run.result.status === "pass") ? "pass" : "fail",
+    artifactsDir: root,
+    runs
+  };
+}
+function restoreEnv(key, value) {
+  if (value === void 0) delete process.env[key];
+  else process.env[key] = value;
+}
+export {
+  handleSelfTest
+};

package/dist/commands/stop.js

@@ -0,0 +1,52 @@
+import { color } from "../cli-color.js";
+import { getAdapterSurface } from "../adapters/surface.js";
+import { usageOut } from "./shared.js";
+import {
+  parseArgs,
+  optionFlag,
+  optionString,
+  resolveAdapter
+} from "./parse-args.js";
+async function handleStop(argv) {
+  const { options } = parseArgs(argv, "stop");
+  const json = optionFlag(options, "json");
+  const { adapter, target } = resolveAdapter(options);
+  const surface = getAdapterSurface(adapter);
+  const explicitPort = optionString(options, "port") ?? optionString(options, "watcherPort");
+  if (explicitPort) {
+    process.env.WATCHER_PORT = explicitPort;
+    process.env.METRO_PORT = explicitPort;
+  } else {
+    surface.resolveSlotPorts(target);
+  }
+  const stop = surface.devServer.stop(target);
+  if (stop.kind === "headless") {
+    return usageOut(json, "stop", stop.message, stop.userAction);
+  }
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: "stop",
+          adapter,
+          target,
+          status: stop.status === 0 ? "pass" : "fail",
+          ...stop.signalled !== void 0 ? { signalled: stop.signalled } : {},
+          exitCode: stop.status,
+          ...stop.output ? { output: stop.output } : {}
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    if (stop.output) process.stderr.write(`${stop.output}
+`);
+    console.error(`${color(stop.status === 0 ? "ok" : "err", stop.status === 0 ? "\u2713" : "\u2717")} ${stop.summary}`);
+  }
+  return stop.status;
+}
+export {
+  handleStop
+};

package/dist/harness.js

@@ -4,10 +4,10 @@ import path from "node:path";
 import { resolveLeafInvoke, shellLeafMissing, missingShellLeafMessage } from "./leaf-invoke.js";
 import { recipeHarnessPath, recipeRuntimeDir, runnerDir } from "./paths.js";
 import { prepareMobile } from "./adapters/mobile/prepare.js";
-const HARNESS_ACTIONS = ["install", "provision", "verify", "cleanup", "live"];
+const HARNESS_ACTIONS = ["install", "verify", "cleanup", "live"];
 const ADAPTERS = ["mobile", "extension", "core"];
 function isValidAdapterAction(adapter, action) {
-  if (adapter === "core") return action === "install" || action === "provision" || action === "verify" || action === "cleanup";
+  if (adapter === "core") return action === "install" || action === "verify" || action === "cleanup";
   return true;
 }
 function harnessUsage() {
@@ -19,8 +19,6 @@ is auto-detected from the repo. Pass --platform only to override.
 Commands (one copy-pasteable example each):
   install   Install the recipe harness runtime overlay into the checkout.
               mm-harness install
-  provision Install the cached Runway mobile dev client (same path as install --runway).
-              mm-harness provision runway ios --adapter mobile
   verify    Check the harness/runtime is present and healthy (no app launch).
               mm-harness verify
   cleanup   Remove the installed harness overlay and restore the checkout.
@@ -404,11 +402,8 @@ async function handleHarness(argv) {
   }
   const autoDetected = parsedAdapter === void 0;
   let forwardArgs = hasArg(forward, "--target") ? [...forward] : ["--target", target, ...forward];
-  if (harnessAction === "provision") {
-    return handleRunwayInstall(adapter, target, provisionRunwayForward(forward), json, "provision");
-  }
   if (harnessAction === "install" && hasArg(forward, "--runway")) {
-    return handleRunwayInstall(adapter, target, forward, json, "install");
+    return handleRunwayInstall(adapter, target, forward, json);
   }
   if (adapter === "extension" && (harnessAction === "live" || harnessAction === "verify")) {
     forwardArgs = applyExtensionRuntimeEnv(target, harnessAction, forwardArgs);
@@ -501,9 +496,9 @@ async function handleHarness(argv) {
   }
   return exitCode;
 }
-async function handleRunwayInstall(adapter, target, forward, json, action) {
+async function handleRunwayInstall(adapter, target, forward, json) {
   const { getAdapterSurface } = await import("./adapters/surface.js");
-  const rerunCommand = action === "provision" ? runwayProvisionRerunCommand(adapter, target, forward, json) : runwayInstallRerunCommand(adapter, target, forward, json);
+  const rerunCommand = runwayInstallRerunCommand(adapter, target, forward, json);
   const surface = getAdapterSurface(adapter);
   const runtimeDir = argValue(forward, "--runtime-dir");
   const watcherPort = argValue(forward, "--watcher-port");
@@ -533,26 +528,15 @@ async function handleRunwayInstall(adapter, target, forward, json, action) {
     if (result.resolveOnly) {
       console.error(`\u2713 resolved Runway app for ${adapter} ${result.platform ?? ""} run=${artifact?.runId ?? "unknown"} revision=${artifact?.revision ?? "unknown"} artifact=${artifact?.artifactName ?? "unknown"}`);
     } else {
-      const action2 = result.skipped ? "already provisioned" : "installed Runway app";
-      console.error(`\u2713 ${action2} for ${adapter} ${result.platform ?? ""} simulator=${simulator?.name ?? "unknown"} cache=${cache?.status ?? "skip"}`);
+      const action = result.skipped ? "already provisioned" : "installed Runway app";
+      console.error(`\u2713 ${action} for ${adapter} ${result.platform ?? ""} simulator=${simulator?.name ?? "unknown"} cache=${cache?.status ?? "skip"}`);
     }
   } else {
-    const label = action === "provision" ? "provision" : "install --runway";
-    console.error(`\u2717 mm-harness ${label}: ${result.error?.message ?? "runway install failed"}
+    console.error(`\u2717 mm-harness install --runway: ${result.error?.message ?? "runway install failed"}
   Next: ${result.error?.userAction ?? rerunCommand}`);
   }
   return result.exitCode;
 }
-function provisionRunwayForward(forward) {
-  const normalized = [];
-  let index = 0;
-  if (forward[index] === "runway") index += 1;
-  if (forward[index] && !forward[index].startsWith("-")) {
-    if (!hasArg(forward, "--platform")) normalized.push("--platform", forward[index]);
-    index += 1;
-  }
-  return [...normalized, ...forward.slice(index)];
-}
 function runwayInstallRerunCommand(adapter, target, forward, json) {
   const parts = ["mm-harness", "install", "--runway", "--adapter", adapter, "--target", shellQuote(target)];
   const valueFlags = [
@@ -578,30 +562,6 @@ function runwayInstallRerunCommand(adapter, target, forward, json) {
   if (json) parts.push("--json");
   return parts.join(" ");
 }
-function runwayProvisionRerunCommand(adapter, target, forward, json) {
-  const parts = ["mm-harness", "provision", "runway", shellQuote(argValue(forward, "--platform") ?? "ios"), "--adapter", adapter, "--target", shellQuote(target)];
-  const valueFlags = [
-    "--branch",
-    "--default-branch",
-    "--run",
-    "--cache-root",
-    "--simulator",
-    "--device",
-    "--slot",
-    "--watcher-port",
-    "--runtime-dir",
-    "--runtime",
-    "--device-type"
-  ];
-  for (const flag of valueFlags) {
-    const value = argValue(forward, flag);
-    if (value) parts.push(flag, shellQuote(value));
-  }
-  if (hasArg(forward, "--force")) parts.push("--force");
-  if (hasArg(forward, "--resolve-only")) parts.push("--resolve-only");
-  if (json) parts.push("--json");
-  return parts.join(" ");
-}
 function harnessSummary(action, adapter, target, status, exitCode, autoDetected, error) {
   return JSON.stringify({
     schemaVersion: 1,