@deeeed/metamask-harness 0.36.0 → 0.37.0

package/dist/adapters/mobile/release-artifact.js

@@ -0,0 +1,295 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+async function installAndroidReleaseArtifact(options, deps = defaultDeps) {
+  validateInputs(options);
+  const sourcePath = path.resolve(options.file);
+  const stagingDirectory = await fsp.mkdtemp(path.join(os.tmpdir(), "mm-harness-android-artifact-"));
+  try {
+    const stagedPath = path.join(stagingDirectory, "release.apk");
+    const { sha256, bytes } = await stageRegularFile(sourcePath, stagedPath);
+    if (sha256 !== options.expectedSha256) {
+      throw new Error(`Android artifact SHA-256 ${sha256} does not match expected ${options.expectedSha256}.`);
+    }
+    const { packageId, versionName, versionCode } = readAndroidPackageIdentity(deps, stagedPath);
+    if (packageId !== options.packageId) {
+      throw new Error(`Android artifact package ${packageId || "missing"} does not match expected ${options.packageId}.`);
+    }
+    if (versionName !== options.expectedVersion) {
+      throw new Error(`Android artifact version ${versionName || "missing"} does not match expected ${options.expectedVersion}.`);
+    }
+    if (versionCode !== options.expectedBuildId) {
+      throw new Error(`Android artifact build ${versionCode || "missing"} does not match expected ${options.expectedBuildId}.`);
+    }
+    const adb = resolveAdb(deps);
+    const state = runChecked(deps, adb, ["-s", options.deviceSerial, "get-state"]).trim();
+    if (state !== "device") {
+      throw new Error(`Android device ${options.deviceSerial} is not ready.`);
+    }
+    runChecked(deps, adb, ["-s", options.deviceSerial, "install", "-r", "-d", stagedPath]);
+    assertInstalledAndroidReleaseArtifact({
+      packageId,
+      versionName,
+      versionCode,
+      sha256,
+      deviceSerial: options.deviceSerial
+    }, deps, adb);
+    runChecked(deps, adb, [
+      "-s",
+      options.deviceSerial,
+      "shell",
+      "monkey",
+      "-p",
+      packageId,
+      "-c",
+      "android.intent.category.LAUNCHER",
+      "1"
+    ]);
+    let pid = "";
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      const result = deps.run(adb, ["-s", options.deviceSerial, "shell", "pidof", packageId]);
+      if (result.status === 0 && result.stdout.trim()) {
+        pid = result.stdout.trim();
+        break;
+      }
+      await deps.sleep(250);
+    }
+    if (!pid) throw new Error(`Android package ${packageId} did not start on ${options.deviceSerial}.`);
+    return {
+      schemaVersion: 1,
+      status: "pass",
+      adapter: "mobile",
+      platform: "android",
+      source: { kind: "local", path: sourcePath },
+      sha256,
+      bytes,
+      packageId,
+      versionName,
+      versionCode,
+      deviceSerial: options.deviceSerial,
+      installed: true,
+      launched: true
+    };
+  } finally {
+    await fsp.rm(stagingDirectory, { recursive: true, force: true });
+  }
+}
+function assertAndroidReleaseArtifactRuntime(identity, deps = defaultDeps) {
+  validateInputs({
+    file: "runtime.apk",
+    expectedVersion: identity.versionName,
+    expectedBuildId: identity.versionCode,
+    expectedSha256: identity.sha256,
+    packageId: identity.packageId,
+    deviceSerial: identity.deviceSerial
+  });
+  const adb = resolveAdb(deps);
+  assertInstalledAndroidReleaseArtifact(identity, deps, adb);
+}
+async function relaunchAndroidReleaseArtifactRuntime(identity, deps = defaultDeps) {
+  assertAndroidReleaseArtifactRuntime(identity, deps);
+  const adb = resolveAdb(deps);
+  runChecked(deps, adb, [
+    "-s",
+    identity.deviceSerial,
+    "shell",
+    "monkey",
+    "-p",
+    identity.packageId,
+    "-c",
+    "android.intent.category.LAUNCHER",
+    "1"
+  ]);
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const result = deps.run(adb, ["-s", identity.deviceSerial, "shell", "pidof", identity.packageId]);
+    if (result.status === 0 && result.stdout.trim()) return;
+    await deps.sleep(250);
+  }
+  throw new Error(`Android package ${identity.packageId} did not start on ${identity.deviceSerial}.`);
+}
+function validateInputs(options) {
+  if (!/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9._-]+)?$/u.test(options.expectedVersion)) {
+    throw new Error("--artifact-version must be an Android version name such as X.Y.Z.");
+  }
+  if (!/^\d+$/u.test(options.expectedBuildId)) {
+    throw new Error("--artifact-build-id must be the numeric Android version code.");
+  }
+  if (!/^[a-f0-9]{64}$/u.test(options.expectedSha256)) {
+    throw new Error("--artifact-sha256 must be 64 lowercase hexadecimal characters.");
+  }
+  if (!/^[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)+$/u.test(options.packageId)) {
+    throw new Error("--artifact-package-id must be an Android application ID.");
+  }
+  if (!/^[A-Za-z0-9._:-]+$/u.test(options.deviceSerial)) {
+    throw new Error("Android artifact launch requires an explicit device serial.");
+  }
+}
+function assertInstalledAndroidReleaseArtifact(identity, deps, adb) {
+  const state = runChecked(deps, adb, ["-s", identity.deviceSerial, "get-state"]).trim();
+  if (state !== "device") throw new Error(`Android device ${identity.deviceSerial} is not ready.`);
+  const paths = runChecked(deps, adb, [
+    "-s",
+    identity.deviceSerial,
+    "shell",
+    "pm",
+    "path",
+    identity.packageId
+  ]).split(/\r?\n/u).filter(Boolean);
+  if (paths.length !== 1 || !paths[0].startsWith("package:/") || !paths[0].endsWith("/base.apk")) {
+    throw new Error(`Android package ${identity.packageId} is not a single installed APK on ${identity.deviceSerial}.`);
+  }
+  const installedPath = paths[0].slice("package:".length);
+  if (!/^\/data\/app\/[A-Za-z0-9._~+=/-]+\/base\.apk$/u.test(installedPath)) {
+    throw new Error(`Android package ${identity.packageId} returned an unsafe installed path.`);
+  }
+  const installedSha256 = runChecked(deps, adb, [
+    "-s",
+    identity.deviceSerial,
+    "shell",
+    "sha256sum",
+    installedPath
+  ]).trim().split(/\s+/u)[0];
+  if (installedSha256 !== identity.sha256) {
+    throw new Error(`Android package ${identity.packageId} no longer matches the trusted release artifact SHA-256.`);
+  }
+  const installed = runChecked(deps, adb, [
+    "-s",
+    identity.deviceSerial,
+    "shell",
+    "dumpsys",
+    "package",
+    identity.packageId
+  ]);
+  if (!new RegExp(`^\\s*versionName=${escapeRegExp(identity.versionName)}\\s*$`, "mu").test(installed) || !new RegExp(`^\\s*versionCode=${escapeRegExp(identity.versionCode)}(?:\\s|$)`, "mu").test(installed)) {
+    throw new Error(`Android package ${identity.packageId} installed with an unexpected version on ${identity.deviceSerial}.`);
+  }
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+async function stageRegularFile(file, destination) {
+  const descriptor = await fsp.open(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  const output = await fsp.open(destination, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
+  try {
+    const stat = await descriptor.stat();
+    if (!stat.isFile() || stat.size <= 0 || stat.size > 2 * 1024 * 1024 * 1024) {
+      throw new Error(`Android artifact must be a non-empty regular file smaller than 2 GiB: ${file}`);
+    }
+    const digest = createHash("sha256");
+    const stream = descriptor.createReadStream({ autoClose: false });
+    for await (const chunk of stream) {
+      digest.update(chunk);
+      await output.writeFile(chunk);
+    }
+    await output.sync();
+    return { sha256: digest.digest("hex"), bytes: stat.size };
+  } finally {
+    await output.close();
+    await descriptor.close();
+  }
+}
+function resolveAdb(deps) {
+  const configured = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+  const candidates = [
+    configured ? path.join(configured, "platform-tools", "adb") : "",
+    path.join(os.homedir(), "Library", "Android", "sdk", "platform-tools", "adb"),
+    "adb"
+  ].filter(Boolean);
+  return firstRunnable(deps, candidates, ["version"], "adb");
+}
+function readAndroidPackageIdentity(deps, file) {
+  const analyzer = resolveApkAnalyzer(deps);
+  if (analyzer) {
+    const packageId2 = deps.run(analyzer, ["manifest", "application-id", file]);
+    const versionName2 = deps.run(analyzer, ["manifest", "version-name", file]);
+    const versionCode2 = deps.run(analyzer, ["manifest", "version-code", file]);
+    if (packageId2.status === 0 && packageId2.stdout.trim() && versionName2.status === 0 && versionName2.stdout.trim() && versionCode2.status === 0 && versionCode2.stdout.trim()) {
+      return {
+        packageId: packageId2.stdout.trim(),
+        versionName: versionName2.stdout.trim(),
+        versionCode: versionCode2.stdout.trim()
+      };
+    }
+  }
+  const aapt2 = resolveAapt2(deps);
+  const badging = runChecked(deps, aapt2, ["dump", "badging", file]);
+  const line = badging.split(/\r?\n/u).find((entry) => entry.startsWith("package: ")) ?? "";
+  const packageId = /\bname='([^']+)'/u.exec(line)?.[1] ?? "";
+  const versionCode = /\bversionCode='([^']+)'/u.exec(line)?.[1] ?? "";
+  const versionName = /\bversionName='([^']+)'/u.exec(line)?.[1] ?? "";
+  if (!packageId || !versionCode || !versionName) {
+    throw new Error("aapt2 could not read the Android artifact package identity.");
+  }
+  return { packageId, versionName, versionCode };
+}
+function resolveApkAnalyzer(deps) {
+  const configured = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+  const candidates = [
+    configured ? path.join(configured, "cmdline-tools", "latest", "bin", "apkanalyzer") : "",
+    path.join(os.homedir(), "Library", "Android", "sdk", "cmdline-tools", "latest", "bin", "apkanalyzer")
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      if (fs.statSync(candidate).isFile()) return candidate;
+    } catch {
+      continue;
+    }
+  }
+  const probe = deps.run("apkanalyzer", []);
+  if (`${probe.stdout}
+${probe.stderr}`.includes("manifest application-id")) return "apkanalyzer";
+  return null;
+}
+function resolveAapt2(deps) {
+  const configured = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+  const buildToolsRoot = configured ? path.join(configured, "build-tools") : path.join(os.homedir(), "Library", "Android", "sdk", "build-tools");
+  let candidates = [];
+  try {
+    candidates = fs.readdirSync(buildToolsRoot).sort((left, right) => right.localeCompare(left, void 0, { numeric: true })).map((version) => path.join(buildToolsRoot, version, "aapt2"));
+  } catch {
+    candidates = [];
+  }
+  candidates.push("aapt2");
+  return firstRunnable(deps, candidates, ["version"], "apkanalyzer or aapt2");
+}
+function firstRunnable(deps, candidates, args, label) {
+  for (const candidate of candidates) {
+    if (deps.run(candidate, args).status === 0) return candidate;
+  }
+  throw new Error(`${label} is required to validate and install an Android release artifact.`);
+}
+function runChecked(deps, command, args) {
+  const result = deps.run(command, args);
+  if (result.status !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`;
+    throw new Error(`${path.basename(command)} failed: ${detail}`);
+  }
+  return result.stdout;
+}
+const defaultDeps = {
+  run(command, args) {
+    const result = spawnSync(command, args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 12e4,
+      maxBuffer: 4 * 1024 * 1024
+    });
+    return {
+      status: result.status ?? 1,
+      stdout: result.stdout || "",
+      stderr: result.stderr || result.error?.message || ""
+    };
+  },
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+export {
+  assertAndroidReleaseArtifactRuntime,
+  installAndroidReleaseArtifact,
+  relaunchAndroidReleaseArtifactRuntime
+};

package/dist/adapters.js

@@ -12,10 +12,15 @@ import { resolveMobileToolPath } from "../library/actions/mobile/platform/tool-p
 import { resolveWalletImportCredentials, validateWalletImportOptions } from "../library/actions/shared/wallet/import-source.mjs";
 const execFileAsync = promisify(execFile);
 const NATIVE_PROVIDER_UI_ACTIONS = /* @__PURE__ */ new Set([
+  "ui.press",
+  "ui.set_input",
+  "ui.scroll",
   "ui.swipe",
   "ui.pan",
   "ui.drag",
   "ui.long_press",
+  "ui.wait_for",
+  "ui.screenshot",
   "ui.capture_surface"
 ]);
 function sleep(ms) {
@@ -30,6 +35,7 @@ function simpleAdapter(action, executor) {
   };
 }
 const LIVE_ONLY_PERPS_ACTIONS = /* @__PURE__ */ new Set([
+  "metamask.perps.read_snapshot",
   "metamask.perps.read_positions",
   "metamask.perps.ensure_positions",
   "metamask.perps.assert_positions",
@@ -47,8 +53,7 @@ const LIVE_ONLY_PERPS_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.perps.capture_performance"
 ]);
 const CORE_ONLY_PERPS_ACTIONS = /* @__PURE__ */ new Set([
-  "metamask.perps.read_account",
-  "metamask.perps.read_snapshot"
+  "metamask.perps.read_account"
 ]);
 const LIVE_ONLY_WALLET_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.wallet.setup",
@@ -221,13 +226,14 @@ function createMetaMaskSemanticAdapters(platform, declaredCustomActions = [], pr
     "metamask.perps.start_state",
     "metamask.perps.teardown_state",
     "metamask.perps.capture_performance",
+    ...platform === "extension" || platform === "core" ? ["metamask.perps.read_snapshot"] : [],
     ...platform === "mobile" ? [
       "metamask.perps.clear_performance_caches",
       "metamask.perps.measure_homepage_visible",
       "metamask.perps.prepare_local_snapshot_endpoint"
     ] : [],
     // read_account is core-only: only the headless core adapter implements it.
-    ...platform === "core" ? ["metamask.perps.read_account", "metamask.perps.read_snapshot"] : []
+    ...platform === "core" ? ["metamask.perps.read_account"] : []
   ];
   const bundled = new Set(bundledActions);
   const actions = [.../* @__PURE__ */ new Set([...bundledActions, ...declaredCustomActions])];
@@ -662,6 +668,7 @@ async function handleMobileHud(payload, context) {
   }
 }
 async function hideMobileHudOnTeardown(projectRoot, env = {}) {
+  if (env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === "1" || process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === "1") return;
   if (process.env.METAMASK_RECIPE_AUTO_HUD === "0" || process.env.METAMASK_RECIPE_AUTO_HUD === "false") return;
   const input = {
     node: { bridge_timeout_ms: 8e3, cdp_timeout_ms: 5e3 },
@@ -803,7 +810,7 @@ function createMetaMaskUiTransport(platform, harness, preparedLiveAdapters) {
         if (live) return live.output;
         throw new Error(`ui.navigate requires library/actions/${platform}/ui/navigate.mjs.`);
       }
-      if (platform === "mobile" && NATIVE_PROVIDER_UI_ACTIONS.has(action)) {
+      if (platform === "mobile" && NATIVE_PROVIDER_UI_ACTIONS.has(action) && (context.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === "1" || process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === "1" || ["ui.swipe", "ui.pan", "ui.drag", "ui.long_press", "ui.capture_surface"].includes(action))) {
         return executeNativeProviderAction(action, node, context, harness.createNativeUiTransport);
       }
       return base.execute(action, action === "ui.wait_for" ? normalizeUiWaitNode(node) : node, context);

package/dist/command-contract.js

@@ -239,6 +239,22 @@ const PUBLIC_COMMAND_CONTRACTS = {
     }),
     positionals: [{ label: "platform", choices: ["ios", "android"] }]
   },
+  "runtime-launch": {
+    options: options(HELP, JSON, TARGET, ADAPTER, DEVICE, MOBILE_PLATFORM, {
+      "--cdp-port": value(),
+      "--chrome-user-data-dir": value(),
+      "--artifacts-dir": value(),
+      "--start-watch": bool(),
+      "--build-lavamoat": bool(),
+      "--remote-flag": value(),
+      "--artifact-file": value(),
+      "--artifact-version": value(),
+      "--artifact-build-id": value(),
+      "--artifact-package-id": value(),
+      "--artifact-sha256": value(),
+      "--artifact-cache": value()
+    })
+  },
   logs: {
     options: options(HELP, JSON, TARGET, ADAPTER, ADAPTER_OR_MOBILE_PLATFORM, {
       "--full": bool(),

package/dist/commands/call.js

@@ -40,6 +40,7 @@ import {
   synthesizeOneNodeRecipe,
   validateRecipeAdapterAware
 } from "./run-engine.js";
+import { readMobileReleaseArtifactState } from "../adapters/mobile/release-artifact-state.js";
 import { acquireCheckoutLock } from "../checkout-lock.js";
 import { formatRunDiagnosticsForHuman, readRunDiagnosticsDocument } from "../run-diagnostics.js";
 import { recipeTrustFailure } from "../recipe-security.js";
@@ -267,7 +268,7 @@ async function handleCall(argv) {
   }
   try {
     const prepared = await prepareHeal(adapter, target, options, json, {
-      skipMobileSourceFreshness: adapter === "mobile" && resolvedAction === "app.lifecycle"
+      skipMobileSourceFreshness: adapter === "mobile" && (resolvedAction === "app.lifecycle" || readMobileReleaseArtifactState(target) !== null)
     });
     if (typeof prepared === "number") return prepared;
     const { state, heal } = prepared;

package/dist/commands/launch/extension.js

@@ -21,7 +21,11 @@ import {
   extensionProductConfigBlock,
   extensionProductConfigFingerprint
 } from "../../adapters/extension/product-config.js";
-import { isExtensionDistStale } from "../../adapters/extension/runtime-decision.js";
+import {
+  isExtensionDistStale,
+  releaseArtifactState,
+  runtimeDistCheck
+} from "../../adapters/extension/runtime-decision.js";
 import { checkExtensionRuntimeHealth } from "../../adapters/extension/runtime.js";
 import { ensureHarnessFresh } from "../../adapters/harness-freshness.js";
 import { isExtensionWatcherLive, stopExtensionWatcher } from "../../adapters/slot-ports.js";
@@ -55,7 +59,18 @@ async function launchExtension(target, tier, wantWatch, displayMode = "fullscree
   if (process.env.CHROME_USER_DATA_DIR) {
     process.env.CHROME_USER_DATA_DIR = path.resolve(process.env.CHROME_USER_DATA_DIR);
   }
-  const reusable = !wantWatch && tier !== "build" && await extensionRuntimeReusable(target);
+  const artifact = releaseArtifactState(target);
+  const artifactSnapshot = runtimeDistCheck(target, artifact);
+  const artifactLaunchable = !wantWatch && tier !== "build" && artifact.status === "valid" && artifactSnapshot.status === "fresh";
+  const reusable = !wantWatch && tier !== "build" && await extensionRuntimeReusable(target, artifact);
+  if (artifact.status !== "none" && !reusable && !artifactLaunchable) {
+    const detail = artifact.status === "invalid" ? `identity is invalid: ${artifact.reason ?? "unknown reason"}` : "runtime is not healthy and reusable";
+    return {
+      status: EXIT.infra,
+      output: `RELEASE_ARTIFACT_NOT_REUSABLE: The loaded release artifact ${detail}.
+Next: rerun runtime-launch with the same artifact source.`
+    };
+  }
   if (!reusable) {
     const block = extensionProductConfigBlock(target);
     if (block) {
@@ -80,14 +95,23 @@ Next: ${block.userAction}`
   if (reusable) {
     return extensionReattach(target, displayMode);
   }
+  if (artifactLaunchable) {
+    return extensionLaunchReleaseArtifact(target, artifact);
+  }
   return extensionLaunchDevelopment(target);
 }
-async function extensionRuntimeReusable(target) {
+async function extensionRuntimeReusable(target, artifact = releaseArtifactState(target)) {
   const cdpPort = process.env.CDP_PORT;
   if (!cdpPort) return false;
-  if (isExtensionDistStale(target)) return false;
-  if (isExtensionWatcherLive(target) && !harnessWatcherMatchesProductConfig(target)) return false;
-  if (!extensionCompiledScriptsMatchProductConfig(target, expectedRuntimeDist(target))) return false;
+  const runtimeSnapshot = runtimeDistCheck(target, artifact);
+  const releaseArtifact = runtimeSnapshot.source === "release-artifact";
+  if (releaseArtifact) {
+    if (runtimeSnapshot.status !== "fresh") return false;
+  } else {
+    if (isExtensionDistStale(target)) return false;
+    if (isExtensionWatcherLive(target) && !harnessWatcherMatchesProductConfig(target)) return false;
+    if (!extensionCompiledScriptsMatchProductConfig(target, expectedRuntimeDist(target))) return false;
+  }
   for (let attempt = 0; attempt < 3; attempt += 1) {
     const reachable = await cdpVersionReachable(cdpPort);
     const nonceOwned = reachable && await cdpOwnedByRuntimeNonce(cdpPort, target);
@@ -344,6 +368,31 @@ async function extensionLaunchDevelopment(target) {
   ));
   return spawnScriptStreaming(liveScript, liveArgs, target);
 }
+async function extensionLaunchReleaseArtifact(target, artifact) {
+  if (!artifact.sourceDir || !artifact.provenancePath) {
+    return {
+      status: EXIT.infra,
+      output: "RELEASE_ARTIFACT_NOT_REUSABLE: The loaded release artifact identity is incomplete.\nNext: rerun runtime-launch with the same artifact source."
+    };
+  }
+  const liveScript = recipeHarnessPath(target, "extension", "scripts", "live.sh");
+  const liveArgs = [
+    "--target",
+    target,
+    "--external-artifact",
+    "--dist-dir",
+    artifact.sourceDir,
+    "--artifact-provenance",
+    artifact.provenancePath,
+    "--preserve-profile"
+  ];
+  if (process.env.CDP_PORT) liveArgs.push("--cdp-port", process.env.CDP_PORT);
+  if (process.env.EXTENSION_START_URL) liveArgs.push("--start-url", process.env.EXTENSION_START_URL);
+  console.error(colorHumanMessage(
+    `\u2192 extension release relaunch \u2014 verified artifact ${artifact.manifestVersion ?? artifact.expectedVersion ?? ""} \xB7 CDP :${process.env.CDP_PORT ?? "default"}`
+  ));
+  return spawnScriptStreaming(liveScript, liveArgs, target);
+}
 function harnessWatcherMatchesProductConfig(target) {
   const runtimeDir = path.join(target, recipeRuntimeDir());
   const harnessPidFile = path.join(runtimeDir, "recipe-harness-webpack.pid");

package/dist/commands/launch/mobile.js

@@ -4,8 +4,10 @@ import {
   recordMobileSourceBaseline
 } from "../../adapters/mobile/source-freshness.js";
 import { ensureHarnessFresh } from "../../adapters/harness-freshness.js";
+import { clearMobileReleaseArtifactState } from "../../adapters/mobile/release-artifact-state.js";
 import { EXIT } from "../shared.js";
 async function launchMobile(target, mobileTarget, tier, json, restartApp = false, clearMetro = false) {
+  clearMobileReleaseArtifactState(target);
   await ensureHarnessFresh(target, "mobile");
   const platform = mobileTarget ?? "ios";
   const watcherPort = process.env.WATCHER_PORT ? parseInt(process.env.WATCHER_PORT, 10) : void 0;

package/dist/commands/provision.js

@@ -1,6 +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 {
   applyWatcherPortOption,
@@ -28,6 +29,7 @@ async function handleProvision({ positional, options, rawArgv }) {
   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);
   }
   const result = await surface.runwayProvision.run(target, {
     json,