@deeeed/metamask-harness 0.4.0 → 0.5.1

package/dist/adapters/mobile/deps-markers.js

@@ -0,0 +1,22 @@
+const MOBILE_PRODUCT_MARKERS = [
+  "node_modules/.yarn-state.yml",
+  "app/core/InpageBridgeWeb3.js",
+  "docs/assets/termsOfUse.html",
+  "app/util/termsOfUse/termsOfUseContent.ts",
+  "node_modules/.bin/anvil"
+];
+const MOBILE_IOS_NATIVE_MARKERS = ["ios/Podfile.lock"];
+const MOBILE_ANDROID_NATIVE_MARKERS = ["android/gradle.properties"];
+function mobileProductMarkers(platform) {
+  const markers = [...MOBILE_PRODUCT_MARKERS];
+  const resolved = (platform ?? process.env.PLATFORM ?? process.env.RECIPE_HARNESS_PLATFORM ?? "").trim().toLowerCase();
+  if (resolved === "ios") markers.push(...MOBILE_IOS_NATIVE_MARKERS);
+  else if (resolved === "android") markers.push(...MOBILE_ANDROID_NATIVE_MARKERS);
+  return markers;
+}
+export {
+  MOBILE_ANDROID_NATIVE_MARKERS,
+  MOBILE_IOS_NATIVE_MARKERS,
+  MOBILE_PRODUCT_MARKERS,
+  mobileProductMarkers
+};

package/dist/adapters/mobile/prepare.js

@@ -0,0 +1,146 @@
+import path from "node:path";
+import { recordDepsBaseline } from "@farmslot/recipe-harness/runtime/deps-readiness";
+import { EXIT, spawnScriptStreaming } from "../../commands/shared.js";
+import { runnerDir } from "../../paths.js";
+import {
+  decideMobileReadiness
+} from "./runtime-decision.js";
+const POD_PROBE_ENV = {
+  FORCE_COLOR: "0",
+  NO_COLOR: "1",
+  LANG: process.env.LANG?.includes("UTF-8") ? process.env.LANG : "en_US.UTF-8",
+  LC_ALL: process.env.LC_ALL?.includes("UTF-8") ? process.env.LC_ALL : "en_US.UTF-8"
+};
+async function mobileRuntimeStatus(target, opts = {}) {
+  return decideMobileReadiness(target, {
+    watcherPort: opts.watcherPort,
+    metroLog: opts.metroLog,
+    platform: opts.platform,
+    record: opts.record,
+    preflightMode: opts.preflightMode
+  });
+}
+async function prepareMobile(target, opts = {}) {
+  const json = opts.json ?? false;
+  const platform = opts.platform ?? "ios";
+  const preflightMode = opts.preflightMode ?? "fast";
+  const clearMetro = opts.clearMetro ?? false;
+  const report = await decideMobileReadiness(target, {
+    watcherPort: opts.watcherPort,
+    metroLog: opts.metroLog,
+    platform,
+    record: opts.record,
+    preflightMode
+  });
+  if (report.decision === "blocked") {
+    const reasons = report.reasons.join(" ");
+    const next = report.userAction ?? "fix the bundle error in app code before retrying recipe up.";
+    const msg = `mobile prepare blocked: ${reasons}
+  Next: ${next}`;
+    if (!json) process.stderr.write(`${msg}
+`);
+    return { status: EXIT.runtime, output: msg };
+  }
+  if (report.decision === "ready") {
+    return { status: 0, output: "" };
+  }
+  if (report.decision === "unknown") {
+    const msg = "mobile prepare: runtime state unknown\n  Next: run mm-harness verify --adapter mobile --target <checkout>";
+    if (!json) process.stderr.write(`${msg}
+`);
+    return { status: EXIT.runtime, output: msg };
+  }
+  const actions = clearMetro ? report.actions.map(
+    (a) => a.id === "start-metro" && !a.argv?.includes("--clear") ? { ...a, argv: [...a.argv ?? [], "--clear"] } : a
+  ) : report.actions;
+  for (const action of actions) {
+    const result = await dispatchAction(action, target, platform, json, preflightMode);
+    if (result.status !== 0) return result;
+    if (action.id === "yarn-setup") recordDepsBaseline(path.resolve(target));
+  }
+  if (report.decision === "install" && !process.env["RECIPE_UP_INSTALL_ATTEMPTED"]) {
+    process.env["RECIPE_UP_INSTALL_ATTEMPTED"] = "1";
+    const postInstall = await decideMobileReadiness(target, {
+      watcherPort: opts.watcherPort,
+      metroLog: opts.metroLog,
+      platform,
+      preflightMode
+    });
+    switch (postInstall.decision) {
+      case "install": {
+        const msg = `mobile prepare: dependencies installed but runtime is still unresolved (${postInstall.reasons.join("; ")})
+  Next: inspect the checkout \u2014 node_modules may be incomplete or yarn.lock drifted.`;
+        if (!json) process.stderr.write(`${msg}
+`);
+        return { status: EXIT.runtime, output: msg };
+      }
+      case "ready": {
+        const bridge = await dispatchAction({ id: "wait-for-bridge", cwd: target }, target, platform, json, preflightMode);
+        if (bridge.status !== 0) return bridge;
+        break;
+      }
+      case "launch": {
+        for (const action of postInstall.actions) {
+          const result = await dispatchAction(action, target, platform, json, preflightMode);
+          if (result.status !== 0) return result;
+        }
+        break;
+      }
+      default: {
+        const msg = `mobile prepare: post-install state is ${postInstall.decision}: ${postInstall.reasons.join("; ")}
+  Next: run mm-harness verify --adapter mobile --target <checkout>`;
+        if (!json) process.stderr.write(`${msg}
+`);
+        return { status: EXIT.runtime, output: msg };
+      }
+    }
+  }
+  return { status: 0, output: "" };
+}
+async function dispatchAction(action, target, platform, json, preflightMode = "fast") {
+  const cwd = action.cwd ?? target;
+  switch (action.id) {
+    case "yarn-setup": {
+      const leaf = path.join(runnerDir, "adapters/mobile/yarn-setup.sh");
+      return spawnScriptStreaming(leaf, ["--target", cwd], target, POD_PROBE_ENV);
+    }
+    case "start-metro": {
+      const leaf = path.join(runnerDir, "adapters/mobile/start-metro.sh");
+      const extra = action.argv ?? [];
+      return spawnScriptStreaming(leaf, ["--target", cwd, ...extra], target);
+    }
+    case "prewarm-bundle": {
+      const leaf = path.join(runnerDir, "adapters/mobile/prewarm-bundle.sh");
+      return spawnScriptStreaming(leaf, ["--platform", platform, "--target", cwd], target);
+    }
+    case "wait-for-bridge": {
+      const leaf = path.join(runnerDir, "adapters/mobile/wait-for-bridge.sh");
+      return spawnScriptStreaming(leaf, ["--target", cwd], target);
+    }
+    case "clear-metro-cache": {
+      const leaf = path.join(runnerDir, "adapters/mobile/start-metro.sh");
+      return spawnScriptStreaming(leaf, ["--target", cwd, "--clear"], target);
+    }
+    case "launch-mobile-runtime": {
+      const leaf = path.join(runnerDir, "adapters/mobile/open-device.sh");
+      return spawnScriptStreaming(
+        leaf,
+        ["--platform", platform, "--target", cwd, "--preflight-mode", preflightMode],
+        target,
+        POD_PROBE_ENV
+      );
+    }
+    case "rebuild-native-dev-client": {
+      const msg = "rebuild-native-dev-client required: native module mismatch detected.\n  Next: yarn start:ios or yarn start:android to rebuild the native dev client, then re-run mm-harness launch.";
+      if (!json) process.stderr.write(`${msg}
+`);
+      return { status: EXIT.runtime, output: msg };
+    }
+    default:
+      return { status: 0, output: "" };
+  }
+}
+export {
+  mobileRuntimeStatus,
+  prepareMobile
+};

package/dist/adapters/mobile/provision.js

@@ -0,0 +1,465 @@
+import { execFileSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { recipeRuntimeDir } from "../../paths.js";
+const RUNWAY_IOS_METADATA = {
+  artifactName: "ios-app-main-dev-expo",
+  workflow: "expo-dev-build.yml",
+  bundleId: "io.metamask.MetaMask",
+  appDirName: "MetaMask.app",
+  fallbackRepo: "MetaMask/metamask-mobile"
+};
+async function provisionRunwayMobile(target, options) {
+  const resolvedTarget = path.resolve(target);
+  const platform = options.platform ?? "ios";
+  const slot = readSlotContext(resolvedTarget, options.runtimeDir);
+  if (options.slot) slot.slotId = options.slot;
+  if (options.watcherPort) slot.watcherPort = options.watcherPort;
+  const command = options.rerunCommand;
+  if (platform !== "ios") {
+    return fail(resolvedTarget, platform, "UNSUPPORTED_PLATFORM", "runway provisioning currently installs the iOS .app artifact only.", command, slot);
+  }
+  const simulator = options.simulator ?? slot.simulator ?? process.env.IOS_SIMULATOR;
+  if (!simulator && !options.resolveOnly) {
+    return fail(resolvedTarget, platform, "SIMULATOR_MISSING", "no simulator was resolved from agentic-runtime.json, --simulator, or IOS_SIMULATOR.", command, slot);
+  }
+  const runtime = options.runtime ?? slot.runtime ?? process.env.IOS_RUNTIME;
+  const deviceType = options.deviceType ?? slot.deviceType ?? process.env.IOS_DEVICE_TYPE;
+  const repo = githubRepo(resolvedTarget);
+  const defaultBranch = options.defaultBranch ?? slot.defaultBranch ?? "main";
+  const branch = options.branch ?? slot.gitBranch ?? gitBranch(resolvedTarget) ?? defaultBranch;
+  try {
+    if (options.resolveOnly) {
+      log(options, `runway: resolving Runway artifact for ${branch} (default ${defaultBranch})`);
+      const resolved2 = resolveArtifactRun(repo, branch, defaultBranch, options.run);
+      return {
+        schemaVersion: 1,
+        command: "provision",
+        adapter: "mobile",
+        target: resolvedTarget,
+        platform,
+        status: "pass",
+        exitCode: 0,
+        slot,
+        resolveOnly: true,
+        artifact: resolved2,
+        installed: false,
+        skipped: true
+      };
+    }
+    const sim = ensureSimulator(simulator, runtime, deviceType);
+    if (!options.force && appInstalled(sim.udid ?? sim.name)) {
+      const baselinePath2 = writeRunwayBaseline(resolvedTarget, slot, platform, void 0, void 0, sim, true, options.runtimeDir);
+      return {
+        schemaVersion: 1,
+        command: "provision",
+        adapter: "mobile",
+        target: resolvedTarget,
+        platform,
+        status: "pass",
+        exitCode: 0,
+        slot,
+        simulator: sim,
+        skipped: true,
+        installed: false,
+        baselinePath: baselinePath2
+      };
+    }
+    log(options, `runway: resolving Runway artifact for ${branch} (default ${defaultBranch})`);
+    const resolved = resolveArtifactRun(repo, branch, defaultBranch, options.run);
+    const cacheRoot = options.cacheRoot ?? defaultRunwayCacheRoot();
+    const cache = ensureCachedArtifact(repo, resolved.branch, resolved.runId, cacheRoot, options);
+    log(options, `runway: installing ${cache.artifact.appPath} on ${sim.name}`);
+    execFileSync("xcrun", ["simctl", "install", sim.udid ?? sim.name, cache.artifact.appPath], { stdio: ["ignore", "ignore", "pipe"] });
+    const baselinePath = writeRunwayBaseline(resolvedTarget, slot, platform, resolved, cache.artifact, sim, false, options.runtimeDir);
+    return {
+      schemaVersion: 1,
+      command: "provision",
+      adapter: "mobile",
+      target: resolvedTarget,
+      platform,
+      status: "pass",
+      exitCode: 0,
+      slot,
+      artifact: cache.artifact,
+      cache: { status: cache.status, path: cache.artifact.appPath, root: cacheRoot },
+      simulator: sim,
+      installed: true,
+      skipped: false,
+      baselinePath
+    };
+  } catch (error) {
+    return fail(resolvedTarget, platform, "PROVISION_FAILED", errorMessage(error), command, slot);
+  }
+}
+function runwayBaselinePath(target, runtimeDir) {
+  return path.join(target, resolveRuntimeDir(runtimeDir), "runway-provision.json");
+}
+function hasRunwayProvisionBaseline(target) {
+  try {
+    const data = JSON.parse(fs.readFileSync(runwayBaselinePath(target), "utf8"));
+    if (data.appInstalled !== true) return false;
+    const simulators = baselineSimulatorCandidates(data, readSlotContext(path.resolve(target)));
+    return simulators.some((simulator) => appInstalled(simulator));
+  } catch {
+    return false;
+  }
+}
+function fail(target, platform, code, message, rerunCommand, slot) {
+  return {
+    schemaVersion: 1,
+    command: "provision",
+    adapter: "mobile",
+    target,
+    platform,
+    status: "fail",
+    exitCode: 1,
+    slot,
+    error: { code, message, userAction: rerunCommand }
+  };
+}
+function readSlotContext(target, runtimeDir) {
+  const candidates = [
+    process.env.RECIPE_RUNTIME_CONTEXT,
+    runtimeContextPath(target, runtimeDir),
+    path.join(target, recipeRuntimeDir(), "agentic-runtime.json"),
+    path.join(target, "temp/recipe/runtime/agentic-runtime.json"),
+    path.join(target, "temp/agentic/recipe-harness/agentic-runtime.json")
+  ].filter((value) => Boolean(value));
+  for (const candidate of [...new Set(candidates)]) {
+    try {
+      const data = JSON.parse(fs.readFileSync(candidate, "utf8"));
+      return {
+        path: candidate,
+        slotId: stringField(data, "slotId"),
+        platform: stringField(data, "platform"),
+        simulator: stringField(data, "simulator") ?? stringField(data, "iosSimulator"),
+        runtime: stringField(data, "runtime") ?? stringField(data, "iosRuntime"),
+        deviceType: stringField(data, "deviceType") ?? stringField(data, "iosDeviceType"),
+        watcherPort: stringField(data, "watcherPort") ?? stringField(data, "metroPort") ?? stringField(data, "devServerPort"),
+        gitBranch: stringField(data, "gitBranch") ?? stringField(data, "prepareRef"),
+        defaultBranch: stringField(data, "defaultBranch") ?? stringField(data, "prepareDefaultRef")
+      };
+    } catch {
+    }
+  }
+  return {};
+}
+function runtimeContextPath(target, runtimeDir) {
+  if (!runtimeDir) return void 0;
+  try {
+    return path.join(target, resolveRuntimeDir(runtimeDir), "agentic-runtime.json");
+  } catch {
+    return void 0;
+  }
+}
+function stringField(data, key) {
+  const value = data[key];
+  return typeof value === "string" && value ? value : void 0;
+}
+function githubRepo(target) {
+  try {
+    const remote = execFileSync("git", ["-C", target, "config", "--get", "remote.origin.url"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const match = /github\.com[:/]([^/]+\/[^/.]+)(?:\.git)?$/u.exec(remote);
+    if (match) return match[1];
+  } catch {
+  }
+  return RUNWAY_IOS_METADATA.fallbackRepo;
+}
+function gitBranch(target) {
+  try {
+    return execFileSync("git", ["-C", target, "branch", "--show-current"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveArtifactRun(repo, branch, defaultBranch, runOverride) {
+  if (runOverride) {
+    assertValidRunId(runOverride);
+    const artifact = findRunArtifact(repo, runOverride, RUNWAY_IOS_METADATA.artifactName);
+    if (!artifact) throw new Error(`Runway run ${runOverride} does not contain ${RUNWAY_IOS_METADATA.artifactName}.`);
+    const revision = runRevision(repo, runOverride) ?? runOverride;
+    return resolvedArtifact(repo, branch, runOverride, revision, artifact);
+  }
+  const tried = [.../* @__PURE__ */ new Set([branch, defaultBranch])];
+  for (const candidate of tried) {
+    const run = latestRunWithArtifact(repo, candidate, RUNWAY_IOS_METADATA.artifactName);
+    if (run) return resolvedArtifact(repo, candidate, run.runId, run.revision, run.artifact);
+  }
+  throw new Error(`no Runway artifact found for ${RUNWAY_IOS_METADATA.artifactName} on ${tried.join(", ")}.`);
+}
+function latestRunWithArtifact(repo, branch, artifactName) {
+  let runs;
+  try {
+    runs = execJson("gh", [
+      "run",
+      "list",
+      "--repo",
+      repo,
+      `--workflow=${RUNWAY_IOS_METADATA.workflow}`,
+      `--branch=${branch}`,
+      "--status=success",
+      "--limit=30",
+      "--json",
+      "databaseId,headSha"
+    ]);
+  } catch {
+    return void 0;
+  }
+  for (const run of runs) {
+    const runId = run.databaseId ? String(run.databaseId) : "";
+    if (!runId) continue;
+    const artifact = findRunArtifact(repo, runId, artifactName);
+    if (artifact) return { runId, revision: run.headSha || runId, artifact };
+  }
+  return void 0;
+}
+function assertValidRunId(runId) {
+  if (!/^\d+$/u.test(runId)) throw new Error(`invalid Runway run id: ${runId}.`);
+}
+function findRunArtifact(repo, runId, artifactName) {
+  assertValidRunId(runId);
+  try {
+    const data = execJson("gh", [
+      "api",
+      `repos/${repo}/actions/runs/${runId}/artifacts`,
+      "--paginate"
+    ]);
+    return data.artifacts?.find((artifact) => artifact.expired === false && artifact.name === artifactName);
+  } catch {
+    return void 0;
+  }
+}
+function runRevision(repo, runId) {
+  try {
+    const data = execJson("gh", ["run", "view", runId, "--repo", repo, "--json", "headSha"]);
+    return data.headSha;
+  } catch {
+    return void 0;
+  }
+}
+function resolvedArtifact(repo, branch, runId, revision, artifact) {
+  return {
+    repo,
+    branch,
+    runId,
+    artifactName: RUNWAY_IOS_METADATA.artifactName,
+    revision,
+    archiveSizeBytes: artifact.size_in_bytes,
+    archiveDownloadUrl: artifact.archive_download_url,
+    createdAt: artifact.created_at,
+    updatedAt: artifact.updated_at
+  };
+}
+function ensureCachedArtifact(repo, branch, runId, cacheRoot, options) {
+  const dir = path.join(cacheRoot, runId);
+  const appPath = path.join(dir, RUNWAY_IOS_METADATA.appDirName);
+  const metaPath = path.join(dir, "metadata.json");
+  const valid = validateCache(appPath, metaPath, RUNWAY_IOS_METADATA.artifactName, runId);
+  if (valid) {
+    return { status: "hit", artifact: { repo, branch, runId, artifactName: RUNWAY_IOS_METADATA.artifactName, revision: runId, appPath, sizeBytes: valid.sizeBytes, sha256: valid.sha256 } };
+  }
+  const redownload = fs.existsSync(dir);
+  if (redownload) {
+    const corruptDir = path.join(cacheRoot, `${runId}.corrupt-${Date.now()}`);
+    fs.renameSync(dir, corruptDir);
+  }
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "mm-runway-artifact-"));
+  try {
+    log(options, `runway: cache ${redownload ? "corrupt" : "miss"} for run ${runId}; downloading once`);
+    execFileSync("gh", ["run", "download", runId, "--repo", repo, "--name", RUNWAY_IOS_METADATA.artifactName, "--dir", tmp], { stdio: ["ignore", "ignore", "pipe"] });
+    const downloaded = findAppOrExtractArchive(tmp);
+    if (!downloaded) throw new Error("downloaded artifact did not contain an iOS .app bundle.");
+    movePath(downloaded, appPath);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+  const digest = hashPath(appPath);
+  const meta = { artifactName: RUNWAY_IOS_METADATA.artifactName, runId, sizeBytes: digest.sizeBytes, sha256: digest.sha256 };
+  fs.writeFileSync(metaPath, `${JSON.stringify(meta, null, 2)}
+`);
+  return { status: redownload ? "redownload" : "miss", artifact: { repo, branch, runId, artifactName: RUNWAY_IOS_METADATA.artifactName, revision: runId, appPath, ...digest } };
+}
+function validateCache(appPath, metaPath, artifactName, runId) {
+  if (!fs.existsSync(appPath) || !fs.existsSync(metaPath)) return null;
+  try {
+    const meta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
+    if (meta.artifactName !== artifactName || meta.runId !== runId) return null;
+    const digest = hashPath(appPath);
+    return digest.sizeBytes === meta.sizeBytes && digest.sha256 === meta.sha256 ? digest : null;
+  } catch {
+    return null;
+  }
+}
+function findApp(root) {
+  const entries = fs.readdirSync(root, { withFileTypes: true });
+  let app;
+  for (const entry of entries) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory() && entry.name === RUNWAY_IOS_METADATA.appDirName) return full;
+    if (entry.isDirectory() && entry.name.endsWith(".app")) {
+      app ??= full;
+      continue;
+    }
+    if (entry.isDirectory()) {
+      const nested = findApp(full);
+      if (nested) return nested;
+    }
+  }
+  return app;
+}
+function findAppOrExtractArchive(root) {
+  return findAppOrExtractArchiveInner(root, /* @__PURE__ */ new Set(), 0);
+}
+function findAppOrExtractArchiveInner(root, extracted, depth) {
+  const app = findApp(root);
+  if (app) return app;
+  if (depth >= 3) return void 0;
+  for (const archive of findZipArchives(root)) {
+    const realArchive = fs.realpathSync(archive);
+    if (extracted.has(realArchive)) continue;
+    extracted.add(realArchive);
+    const extractDir = fs.mkdtempSync(path.join(root, ".mm-runway-unzip-"));
+    execFileSync("unzip", ["-q", archive, "-d", extractDir], { stdio: ["ignore", "ignore", "pipe"] });
+    const nested = findAppOrExtractArchiveInner(extractDir, extracted, depth + 1);
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function findZipArchives(root) {
+  const archives = [];
+  const visit = (dir) => {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.endsWith(".app")) visit(full);
+        continue;
+      }
+      if (entry.isFile() && entry.name.toLowerCase().endsWith(".zip")) archives.push(full);
+    }
+  };
+  visit(root);
+  return archives.sort();
+}
+function movePath(source, destination) {
+  try {
+    fs.renameSync(source, destination);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EXDEV") {
+      fs.cpSync(source, destination, { recursive: true });
+      fs.rmSync(source, { recursive: true, force: true });
+      return;
+    }
+    throw error;
+  }
+}
+function hashPath(root) {
+  const hash = crypto.createHash("sha256");
+  let sizeBytes = 0;
+  const visitDirectory = (dir, relative = "") => {
+    const entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      const rel = path.join(relative, entry.name);
+      if (entry.isDirectory()) {
+        visitDirectory(full, rel);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      hash.update(rel);
+      const data = fs.readFileSync(full);
+      sizeBytes += data.length;
+      hash.update(data);
+    }
+  };
+  visitDirectory(root);
+  return { sizeBytes, sha256: hash.digest("hex") };
+}
+function ensureSimulator(name, runtime, deviceType) {
+  const existing = findSimulator(name);
+  if (existing) return { name, udid: existing, created: false, runtime, deviceType };
+  if (!runtime || !deviceType) {
+    throw new Error(`simulator ${name} is missing and runtime/device type could not be resolved. Pass --runtime and --device-type, or write them to agentic-runtime.json.`);
+  }
+  const udid = execFileSync("xcrun", ["simctl", "create", name, deviceType, runtime], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  return { name, udid: udid || name, created: true, runtime, deviceType };
+}
+function findSimulator(name) {
+  const data = execJson("xcrun", ["simctl", "list", "devices", "--json"]);
+  for (const devices of Object.values(data.devices ?? {})) {
+    const found = devices.find((device) => device.name === name || device.udid === name);
+    if (found?.udid) return found.udid;
+  }
+  return void 0;
+}
+function baselineSimulatorCandidates(data, current) {
+  const candidates = [];
+  if (current.simulator) candidates.push(current.simulator);
+  const simulator = data.simulator;
+  if (simulator && typeof simulator === "object" && !Array.isArray(simulator)) {
+    const record = simulator;
+    for (const key of ["udid", "name"]) {
+      const value = record[key];
+      if (typeof value === "string" && value) candidates.push(value);
+    }
+  }
+  return [...new Set(candidates)];
+}
+function appInstalled(device) {
+  try {
+    execFileSync("xcrun", ["simctl", "get_app_container", device, RUNWAY_IOS_METADATA.bundleId, "app"], { stdio: ["ignore", "ignore", "ignore"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeRunwayBaseline(target, slot, platform, resolved, artifact, simulator, alreadyInstalled, runtimeDir) {
+  const file = runwayBaselinePath(target, runtimeDir);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({
+    schemaVersion: 1,
+    appInstalled: true,
+    deps: "pending",
+    platform,
+    slotId: slot.slotId ?? null,
+    watcherPort: slot.watcherPort ?? null,
+    simulator,
+    artifact: resolved && artifact ? { ...resolved, path: artifact.appPath, sizeBytes: artifact.sizeBytes, sha256: artifact.sha256 } : null,
+    alreadyInstalled,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2)}
+`);
+  return file;
+}
+function resolveRuntimeDir(runtimeDir) {
+  if (runtimeDir === void 0) return recipeRuntimeDir();
+  if (!runtimeDir || path.isAbsolute(runtimeDir)) throw new Error(`--runtime-dir must be a non-empty relative path: ${runtimeDir}`);
+  if (!/^[A-Za-z0-9._/-]+$/u.test(runtimeDir)) throw new Error(`--runtime-dir contains unsupported characters: ${runtimeDir}`);
+  for (const part of runtimeDir.split("/")) {
+    if (!part || part === "." || part === "..") throw new Error(`--runtime-dir contains unsafe path component: ${runtimeDir}`);
+  }
+  return runtimeDir;
+}
+function defaultRunwayCacheRoot() {
+  return path.join(process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache"), "metamask-harness", "runway");
+}
+function execJson(bin, args) {
+  const out = execFileSync(bin, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return JSON.parse(out);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function log(options, message) {
+  if (!options.json) process.stderr.write(`${message}
+`);
+}
+export {
+  hasRunwayProvisionBaseline,
+  provisionRunwayMobile,
+  runwayBaselinePath
+};