@deeeed/metamask-harness 0.14.7 → 0.15.0

package/dist/adapters/extension/runtime-decision.js

@@ -7,7 +7,7 @@ import {
   INSTALL_MARKERS,
   recordDepsBaseline
 } from "@farmslot/recipe-harness/runtime/deps-readiness";
-import { recipeHarnessPath, recipeWatchLogCandidates } from "../../paths.js";
+import { recipeHarnessPath, recipeRuntimeDir, recipeWatchLogCandidates } from "../../paths.js";
 const WEBPACK_DIRECT_INPUTS = ["package.json", "yarn.lock", ".yarnrc.yml", ".tool-versions"];
 const WEBPACK_RECURSIVE_INPUTS = ["development/webpack"];
 const WEBPACK_CACHE_DIR = "node_modules/.cache/webpack";
@@ -152,6 +152,80 @@ function latestDistMtime(target) {
   walk2(distDir);
   return latest;
 }
+function runtimeDistCheck(target) {
+  const dist = path.join(target, "dist/chrome");
+  const runtimeDist = path.join(
+    target,
+    recipeRuntimeDir(),
+    process.env.RECIPE_RUNTIME_DIST_DIR || "runtime-dist"
+  );
+  if (!fs.existsSync(path.join(runtimeDist, "manifest.json"))) return { status: "missing" };
+  let output;
+  try {
+    output = execFileSync("rsync", [
+      "-rni",
+      "--exclude",
+      "_metadata",
+      "--out-format=%n",
+      `${dist}${path.sep}`,
+      `${runtimeDist}${path.sep}`
+    ], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      try {
+        const modified2 = filesystemSnapshotDiff(dist, runtimeDist).slice(0, 10);
+        return modified2.length > 0 ? { status: "stale", comparison: "filesystem-quick", modified: modified2 } : { status: "fresh", comparison: "filesystem-quick" };
+      } catch (fallbackError) {
+        return {
+          status: "unknown",
+          error: `snapshot comparison failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`
+        };
+      }
+    }
+    const status = error.status;
+    return {
+      status: "unknown",
+      error: `rsync snapshot comparison failed${typeof status === "number" ? ` with exit ${status}` : ""}`
+    };
+  }
+  const modified = output.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, 10);
+  return modified.length > 0 ? { status: "stale", comparison: "rsync-quick", modified } : { status: "fresh", comparison: "rsync-quick" };
+}
+function filesystemSnapshotDiff(source, snapshot) {
+  const sourceEntries = snapshotEntries(source);
+  const snapshotEntriesByPath = snapshotEntries(snapshot);
+  const paths = [.../* @__PURE__ */ new Set([...sourceEntries.keys(), ...snapshotEntriesByPath.keys()])].sort();
+  return paths.filter((relative) => {
+    const left = sourceEntries.get(relative);
+    const right = snapshotEntriesByPath.get(relative);
+    return left === void 0 || right === void 0 || JSON.stringify(left) !== JSON.stringify(right);
+  });
+}
+function snapshotEntries(root) {
+  const entries = /* @__PURE__ */ new Map();
+  const walk2 = (directory) => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (entry.name === "_metadata") continue;
+      const absolute = path.join(directory, entry.name);
+      const relative = path.relative(root, absolute);
+      const stat = fs.lstatSync(absolute);
+      if (entry.isDirectory()) {
+        entries.set(relative, { type: "directory" });
+        walk2(absolute);
+      } else if (entry.isSymbolicLink()) {
+        entries.set(relative, { type: "symlink", link: fs.readlinkSync(absolute) });
+      } else if (entry.isFile()) {
+        entries.set(relative, {
+          type: "file",
+          size: stat.size,
+          mtimeSeconds: Math.floor(stat.mtimeMs / 1e3)
+        });
+      }
+    }
+  };
+  walk2(root);
+  return entries;
+}
 function distCheck(target) {
   const manifestPath = path.join(target, "dist/chrome/manifest.json");
   if (!fs.existsSync(manifestPath)) return { status: "no-build" };
@@ -206,8 +280,9 @@ async function decideExtensionReadiness(target, options = {}) {
   const webpackCache = webpackCacheCheck(resolved);
   const buildLog = buildLogCheck(resolved, options.watchLog);
   const dist = distCheck(resolved);
+  const runtimeDist = runtimeDistCheck(resolved);
   const cdp = await cdpCheck(resolved, options.cdpPort, options.pageMode);
-  const checks = { deps, webpackCache, buildLog, dist, cdp };
+  const checks = { deps, webpackCache, buildLog, dist, runtimeDist, cdp };
   const install = [{ id: "yarn-install", argv: ["yarn", "install", "--immutable"], cwd: resolved }];
   const relaunch = [{ id: "relaunch-browser" }];
   const cacheStale = buildLog.reason === "stale-cache";
@@ -259,6 +334,20 @@ async function decideExtensionReadiness(target, options = {}) {
       reasons: [dist.reason === "uncommitted-source" ? `Uncommitted source since the build (${dist.modified?.length ?? 0} file(s)); rebuild.` : `dist git id ${dist.distGitId} != HEAD ${dist.head}; rebuild.`],
       actions: buildAction(resolved, false)
     },
+    {
+      when: runtimeDist.status === "unknown",
+      decision: "blocked",
+      reasonCode: "runtime-dist-check-failed",
+      reasons: [runtimeDist.error ?? "The loaded runtime snapshot could not be compared with dist/chrome."],
+      actions: []
+    },
+    {
+      when: runtimeDist.status !== "fresh",
+      decision: "relaunch",
+      reasonCode: runtimeDist.status === "missing" ? "runtime-dist-missing" : "runtime-dist-stale",
+      reasons: [runtimeDist.status === "missing" ? "The loaded runtime snapshot is missing; launch before proving behavior." : `The loaded runtime snapshot differs from dist/chrome (${runtimeDist.modified?.length ?? 0} file(s)); reload before proving behavior.`],
+      actions: relaunch
+    },
     {
       when: cdp.status === "pass",
       decision: "ready",
@@ -305,5 +394,6 @@ function buildAction(target, clean) {
 export {
   decideExtensionReadiness,
   isExtensionDistStale,
-  recordReadinessBaseline
+  recordReadinessBaseline,
+  runtimeDistCheck
 };

package/dist/adapters/extension/surface.js

@@ -1,7 +1,11 @@
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { recipeRuntimePath, runnerDir } from "../../paths.js";
-import { resolveExtensionSlotPorts, stopExtensionWatcher } from "../slot-ports.js";
+import {
+  isExtensionWatcherLive,
+  resolveExtensionSlotPorts,
+  stopExtensionRuntime
+} from "../slot-ports.js";
 import { decideExtensionReadiness } from "./runtime-decision.js";
 function watcherStatus(buildLog) {
   if (buildLog === "ok") return "up";
@@ -17,12 +21,16 @@ const extensionSurface = {
   async runtimeStatus(target) {
     const cdpPort = process.env.CDP_PORT ? parseInt(process.env.CDP_PORT, 10) : void 0;
     const report = await decideExtensionReadiness(target, { cdpPort, pageMode: "home-or-sidepanel" });
+    const watcherLive = isExtensionWatcherLive(target);
     return {
       decision: report.decision,
       reasonCode: report.reasonCode,
       reasons: report.reasons,
       deps: report.checks.deps.status,
-      devServer: { label: "webpack", status: watcherStatus(report.checks.buildLog.status) }
+      devServer: {
+        label: "webpack",
+        status: watcherLive ? watcherStatus(report.checks.buildLog.status) : "down"
+      }
     };
   },
   runwayProvision: {
@@ -44,13 +52,13 @@ const extensionSurface = {
   },
   devServer: {
     label: "webpack",
-    describe: () => "webpack watcher",
+    describe: () => "Extension runtime",
     stop(target) {
-      const signalled = stopExtensionWatcher(target);
+      const stopped = stopExtensionRuntime(target);
       const stopViewers = path.join(runnerDir, "adapters/extension/stop-viewers.sh");
       spawnSync("bash", [stopViewers, "--target", target], { stdio: "ignore", timeout: 5e3 });
-      const summary = signalled > 0 ? `stopped webpack watcher (${signalled} process${signalled === 1 ? "" : "es"}) for ${target}` : `webpack watcher not running for ${target} \u2014 nothing to stop`;
-      return { kind: "stopped", status: 0, summary, signalled };
+      const summary = stopped.signalled > 0 || stopped.removedMarkers > 0 ? `stopped Extension runtime (${stopped.signalled} process${stopped.signalled === 1 ? "" : "es"}, ${stopped.removedMarkers} stale marker${stopped.removedMarkers === 1 ? "" : "s"}) for ${target}` : `Extension runtime not running for ${target} \u2014 nothing to stop`;
+      return { kind: "stopped", status: 0, summary, signalled: stopped.signalled };
     }
   },
   logSources(target) {
@@ -60,6 +68,9 @@ const extensionSurface = {
       { label: "rebuild", path: recipeRuntimePath(target, "rebuild.log") }
     ];
   },
+  appLogSource(target) {
+    return { label: "app", path: recipeRuntimePath(target, "extension-console.log") };
+  },
   hints: {
     launch: "mm-harness launch",
     relaunch: "mm-harness launch --build"

package/dist/adapters/mobile/metro-env.js

@@ -0,0 +1,67 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { recipeRuntimePath } from "../../paths.js";
+const ENV_INPUTS = [".js.env", ".env", ".env.local"];
+const BASELINE_FILE = "metro-env-baseline.json";
+function mobileMetroEnvFingerprint(target) {
+  const hash = createHash("sha256");
+  for (const relative of ENV_INPUTS) {
+    const absolute = path.join(target, relative);
+    hash.update(`${relative}\0`);
+    if (fs.existsSync(absolute)) hash.update(fs.readFileSync(absolute));
+    else hash.update("<absent>");
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+function mobileMetroEnvCheck(target) {
+  const fingerprint = mobileMetroEnvFingerprint(target);
+  const marker = readBaseline(target);
+  return {
+    fingerprint,
+    status: marker === null ? "missing" : marker.fingerprint === fingerprint ? "current" : "changed"
+  };
+}
+function applyMobileMetroEnvPolicy(target, actions) {
+  if (mobileMetroEnvCheck(target).status === "current") return actions;
+  return actions.map((action) => action.id === "start-metro" && !action.argv?.includes("--clear") ? { ...action, argv: [...action.argv ?? [], "--clear"] } : action);
+}
+function recordMobileMetroEnvBaseline(target, expectedFingerprint) {
+  if (mobileMetroEnvFingerprint(target) !== expectedFingerprint) return false;
+  const marker = recipeRuntimePath(target, BASELINE_FILE);
+  const temporary = `${marker}.${process.pid}.${Date.now()}.tmp`;
+  const baseline = {
+    schemaVersion: 1,
+    fingerprint: expectedFingerprint,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs.mkdirSync(path.dirname(marker), { recursive: true });
+  try {
+    fs.writeFileSync(temporary, `${JSON.stringify(baseline, null, 2)}
+`, { mode: 384 });
+    if (mobileMetroEnvFingerprint(target) !== expectedFingerprint) return false;
+    fs.renameSync(temporary, marker);
+    if (mobileMetroEnvFingerprint(target) !== expectedFingerprint) {
+      if (readBaseline(target)?.fingerprint === expectedFingerprint) fs.rmSync(marker, { force: true });
+      return false;
+    }
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+  return true;
+}
+function readBaseline(target) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(recipeRuntimePath(target, BASELINE_FILE), "utf8"));
+    return parsed.schemaVersion === 1 && typeof parsed.fingerprint === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  applyMobileMetroEnvPolicy,
+  mobileMetroEnvCheck,
+  mobileMetroEnvFingerprint,
+  recordMobileMetroEnvBaseline
+};

package/dist/adapters/mobile/perps-env.js

@@ -0,0 +1,101 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+const DEFAULTS = {
+  MM_PERPS_ENABLED: "true",
+  OVERRIDE_REMOTE_FEATURE_FLAGS: "true"
+};
+function mobilePerpsEnvironment(target) {
+  const file = path.join(target, ".js.env");
+  const fileExists = fs.existsSync(file);
+  const source = fileExists ? fs.readFileSync(file, "utf8") : "";
+  const perpsEnabled = readSetting(source, "MM_PERPS_ENABLED");
+  const remoteFeatureFlagOverride = readSetting(source, "OVERRIDE_REMOTE_FEATURE_FLAGS");
+  return {
+    file: ".js.env",
+    fileExists,
+    status: perpsEnabled.status === "missing" || remoteFeatureFlagOverride.status === "missing" ? "incomplete" : "ready",
+    perpsEnabled,
+    remoteFeatureFlagOverride
+  };
+}
+function ensureMobilePerpsEnvironment(target) {
+  const current = mobilePerpsEnvironment(target);
+  const missing = Object.keys(DEFAULTS).filter(
+    (key) => settingForKey(current, key).status === "missing"
+  );
+  if (missing.length === 0) return [];
+  const file = path.join(fs.realpathSync(target), current.file);
+  const snapshot = readEnvironmentSnapshot(file);
+  const before = snapshot?.text ?? "";
+  const separator = before.length > 0 && !before.endsWith("\n") ? "\n" : "";
+  const additions = missing.map((key) => `export ${key}="${DEFAULTS[key]}"`).join("\n");
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  let descriptor = null;
+  try {
+    descriptor = fs.openSync(
+      temporary,
+      fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL,
+      snapshot?.mode ?? 384
+    );
+    fs.writeFileSync(descriptor, `${before}${separator}${additions}
+`);
+    if (snapshot) fs.fchmodSync(descriptor, snapshot.mode);
+    fs.closeSync(descriptor);
+    descriptor = null;
+    fs.renameSync(temporary, file);
+  } finally {
+    if (descriptor !== null) fs.closeSync(descriptor);
+    fs.rmSync(temporary, { force: true });
+  }
+  return missing;
+}
+function readEnvironmentSnapshot(file) {
+  let descriptor;
+  try {
+    descriptor = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") return null;
+    if (code === "ELOOP") {
+      throw new Error(`.js.env must not be a symbolic link. Next: replace ${file} with a regular file.`);
+    }
+    throw error;
+  }
+  try {
+    const stat = fs.fstatSync(descriptor);
+    if (!stat.isFile()) {
+      throw new Error(`.js.env must be a regular file. Next: replace ${file} with a regular file.`);
+    }
+    return { text: fs.readFileSync(descriptor, "utf8"), mode: stat.mode & 511 };
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+function readSetting(source, key) {
+  const assignment = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=(.*)$`, "u");
+  let value = null;
+  for (const line of source.split("\n")) {
+    const match = assignment.exec(line);
+    if (match) value = normalizeValue(match[1]);
+  }
+  if (value === null) return { status: "missing", value };
+  if (value === "true") return { status: "enabled", value };
+  if (value === "false") return { status: "disabled", value };
+  return { status: "configured", value };
+}
+function settingForKey(environment, key) {
+  return key === "MM_PERPS_ENABLED" ? environment.perpsEnabled : environment.remoteFeatureFlagOverride;
+}
+function normalizeValue(raw) {
+  const value = raw.trim();
+  if (value.length >= 2) {
+    const first = value[0];
+    if ((first === '"' || first === "'") && value.at(-1) === first) return value.slice(1, -1);
+  }
+  return value;
+}
+export {
+  ensureMobilePerpsEnvironment,
+  mobilePerpsEnvironment
+};

package/dist/adapters/mobile/prepare.js

@@ -6,6 +6,11 @@ import {
   decideMobileReadiness,
   launchActions
 } from "./runtime-decision.js";
+import {
+  applyMobileMetroEnvPolicy,
+  mobileMetroEnvCheck,
+  recordMobileMetroEnvBaseline
+} from "./metro-env.js";
 const READY_BRIDGE_CONFIRM_POLLS = 3;
 const POD_PROBE_ENV = {
   FORCE_COLOR: "0",
@@ -58,11 +63,7 @@ async function prepareMobile(target, opts = {}) {
 `
       );
     }
-    for (const action of launchActions(path.resolve(target))) {
-      const result = await dispatchAction(action, target, platform, json, preflightMode);
-      if (result.status !== 0) return result;
-    }
-    return { status: 0, output: "" };
+    return dispatchActionSequence(launchActions(path.resolve(target)), target, platform, json, preflightMode);
   }
   if (report.decision === "unknown") {
     const msg = "mobile prepare: runtime state unknown\n  Next: run mm-harness verify --adapter mobile --target <checkout>";
@@ -73,11 +74,8 @@ async function prepareMobile(target, opts = {}) {
   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));
-  }
+  const actionResult = await dispatchActionSequence(actions, target, platform, json, preflightMode);
+  if (actionResult.status !== 0) return actionResult;
   if (report.decision === "install" && !process.env["RECIPE_UP_INSTALL_ATTEMPTED"]) {
     process.env["RECIPE_UP_INSTALL_ATTEMPTED"] = "1";
     const postInstall = await decideMobileReadiness(target, {
@@ -100,10 +98,8 @@ async function prepareMobile(target, opts = {}) {
         break;
       }
       case "launch": {
-        for (const action of postInstall.actions) {
-          const result = await dispatchAction(action, target, platform, json, preflightMode);
-          if (result.status !== 0) return result;
-        }
+        const result = await dispatchActionSequence(postInstall.actions, target, platform, json, preflightMode);
+        if (result.status !== 0) return result;
         break;
       }
       default: {
@@ -117,6 +113,28 @@ async function prepareMobile(target, opts = {}) {
   }
   return { status: 0, output: "" };
 }
+async function dispatchActionSequence(requestedActions, target, platform, json, preflightMode) {
+  const resolved = path.resolve(target);
+  const actions = applyMobileMetroEnvPolicy(resolved, requestedActions);
+  let pendingMetroEnvFingerprint;
+  for (const action of actions) {
+    if (action.id === "start-metro") {
+      pendingMetroEnvFingerprint = mobileMetroEnvCheck(resolved).fingerprint;
+    }
+    const result = await dispatchAction(action, target, platform, json, preflightMode);
+    if (result.status !== 0) return result;
+    if (action.id === "yarn-setup") recordDepsBaseline(resolved);
+    if (action.id === "prewarm-bundle" && pendingMetroEnvFingerprint) {
+      if (!recordMobileMetroEnvBaseline(resolved, pendingMetroEnvFingerprint)) {
+        const message = "Mobile environment changed while Metro was starting; the stale bundle baseline was not recorded.\n  Next: re-run mm-harness launch.";
+        if (!json) process.stderr.write(`${message}
+`);
+        return { status: EXIT.runtime, output: message };
+      }
+    }
+  }
+  return { status: 0, output: "" };
+}
 async function dispatchAction(action, target, platform, json, preflightMode = "fast") {
   const cwd = action.cwd ?? target;
   switch (action.id) {

package/dist/adapters/mobile/runtime-decision.js

@@ -14,6 +14,7 @@ import {
 import { probeMetroPackager } from "@farmslot/recipe-harness/runtime/metro-probe";
 import { recipeRuntimePath } from "../../paths.js";
 import { mobileProductMarkers } from "./deps-markers.js";
+import { applyMobileMetroEnvPolicy, mobileMetroEnvCheck } from "./metro-env.js";
 const BUNDLE_ERR = /Bundling failed|Unable to resolve /u;
 const BUNDLE_OK = /Bundled \d+ms|iOS Bundled|Android Bundled|Finished bundling/u;
 const NATIVE_MODULE_STALE = /\[runtime not ready\].*HybridObject "([^"]+)" - It has not yet been registered in the Nitro Modules HybridObjectRegistry/u;
@@ -113,11 +114,29 @@ async function decideMobileReadiness(target, options = {}) {
         "Fast preflight found dependencies not ready and does not install them (the orchestrator deps phase owns installation).",
         ...report.reasons
       ],
-      userAction: `run the slot deps/prepare phase; standalone: ${standalone} in the checkout, then re-run \`mm-harness launch <platform>\``,
+      userAction: `1. Standalone checkout \u2014 run ${standalone} in the checkout.
+  2. Orchestrated slot \u2014 run its deps/prepare phase.
+  After the selected action succeeds, re-run \`mm-harness launch <platform>\`.`,
       actions: []
     };
   }
-  return report;
+  const env = mobileMetroEnvCheck(resolved);
+  if (env.status === "current" || report.decision !== "launch" && report.decision !== "ready") {
+    return report;
+  }
+  return {
+    ...report,
+    decision: "launch",
+    reasonCode: report.decision === "ready" ? env.status === "missing" ? "metro-env-baseline-missing" : "metro-env-changed" : report.reasonCode,
+    reasons: [
+      env.status === "missing" ? "Metro environment has no successful bundle baseline; restart once with a cleared transform cache." : "Metro environment inputs changed since the successful bundle baseline; restart once with a cleared transform cache.",
+      ...report.reasons
+    ],
+    actions: applyMobileMetroEnvPolicy(
+      resolved,
+      report.decision === "ready" ? launchActions(resolved) : report.actions
+    )
+  };
 }
 async function computeMobileReadiness(resolved, options, fast) {
   const rawDeps = depsCheck(resolved, {

package/dist/adapters/mobile/source-freshness.js

@@ -0,0 +1,116 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { recipeRuntimePath } from "../../paths.js";
+const SOURCE_PATHS = [
+  "app",
+  "locales",
+  "index.js",
+  "shim.js",
+  "shimPerf.js",
+  "ReactotronConfig.js",
+  "wdyr.js",
+  "app.config.js",
+  "babel.config.js",
+  "metro.config.js",
+  "metro.transform.js",
+  "package.json"
+];
+const ENV_INPUTS = [".js.env", ".env", ".env.local"];
+const BASELINE_FILE = "mobile-source-baseline.json";
+function mobileSourceFingerprint(target) {
+  try {
+    const hash = createHash("sha256");
+    hash.update(git(target, ["rev-parse", "HEAD"]));
+    hash.update(git(target, ["diff", "--no-ext-diff", "--binary", "HEAD", "--", ...SOURCE_PATHS]));
+    const untracked = git(target, [
+      "ls-files",
+      "--others",
+      "--exclude-standard",
+      "-z",
+      "--",
+      ...SOURCE_PATHS
+    ]).toString("utf8").split("\0").filter(Boolean).sort();
+    for (const relative of untracked) {
+      hash.update(`untracked\0${relative}\0`);
+      hash.update(fs.readFileSync(path.join(target, relative)));
+      hash.update("\0");
+    }
+    for (const relative of ENV_INPUTS) {
+      const absolute = path.join(target, relative);
+      hash.update(`env\0${relative}\0`);
+      hash.update(fs.existsSync(absolute) ? fs.readFileSync(absolute) : "<absent>");
+      hash.update("\0");
+    }
+    return { status: "ok", fingerprint: hash.digest("hex") };
+  } catch {
+    const resolved = path.resolve(target);
+    return {
+      fingerprint: null,
+      status: "unavailable",
+      error: {
+        code: "MOBILE_SOURCE_UNAVAILABLE",
+        message: `Mobile source fingerprint requires a readable Git checkout and source inputs: ${resolved}`,
+        userAction: "mm-harness doctor --adapter mobile --target <metamask-mobile-checkout>"
+      }
+    };
+  }
+}
+function mobileSourceCheck(target) {
+  const result = mobileSourceFingerprint(target);
+  if (result.status === "unavailable") return result;
+  const { fingerprint } = result;
+  const baseline = readBaseline(target);
+  return {
+    fingerprint,
+    status: baseline === null ? "missing" : baseline.fingerprint === fingerprint ? "current" : "changed"
+  };
+}
+function recordMobileSourceBaseline(target, expectedFingerprint) {
+  if (mobileSourceFingerprint(target).fingerprint !== expectedFingerprint) return false;
+  const marker = recipeRuntimePath(target, BASELINE_FILE);
+  const temporary = `${marker}.${process.pid}.${Date.now()}.tmp`;
+  const baseline = {
+    schemaVersion: 1,
+    fingerprint: expectedFingerprint,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs.mkdirSync(path.dirname(marker), { recursive: true });
+  try {
+    fs.writeFileSync(temporary, `${JSON.stringify(baseline, null, 2)}
+`, { mode: 384 });
+    if (mobileSourceFingerprint(target).fingerprint !== expectedFingerprint) return false;
+    fs.renameSync(temporary, marker);
+    if (mobileSourceFingerprint(target).fingerprint !== expectedFingerprint) {
+      if (readBaseline(target)?.fingerprint === expectedFingerprint) fs.rmSync(marker, { force: true });
+      return false;
+    }
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+  return true;
+}
+function git(target, args) {
+  return execFileSync("git", args, {
+    cwd: target,
+    encoding: "buffer",
+    maxBuffer: 128 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+}
+function readBaseline(target) {
+  try {
+    const parsed = JSON.parse(
+      fs.readFileSync(recipeRuntimePath(target, BASELINE_FILE), "utf8")
+    );
+    return parsed.schemaVersion === 1 && typeof parsed.fingerprint === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  mobileSourceCheck,
+  mobileSourceFingerprint,
+  recordMobileSourceBaseline
+};

package/dist/adapters/mobile/surface.js

@@ -46,6 +46,9 @@ const mobileSurface = {
   logSources(target) {
     return [{ label: "metro", path: recipeRuntimePath(target, "metro.log") }];
   },
+  appLogSource(target) {
+    return { label: "app", path: recipeRuntimePath(target, "metro.log") };
+  },
   hints: {
     launch: "mm-harness launch ios",
     relaunch: "mm-harness launch ios"

package/dist/adapters/resolve-slot-ports.js

@@ -1,8 +1,10 @@
 import {
   formatKvLines,
+  formatExtensionSlotPorts,
   inferSlotSuffix,
   realRepoPath,
   resolveDefaultExtensionPorts,
+  resolveExtensionRuntimeContext,
   resolveExtensionRuntimePorts,
   resolveSlotPortsByRepo,
   resolveFarmslotPortsByRepo,
@@ -11,10 +13,12 @@ import {
   resolveMobileSlotDefaults
 } from "../../adapters/shared/resolve-slot-ports-core.mjs";
 export {
+  formatExtensionSlotPorts,
   formatKvLines,
   inferSlotSuffix,
   realRepoPath,
   resolveDefaultExtensionPorts,
+  resolveExtensionRuntimeContext,
   resolveExtensionRuntimePorts,
   resolveFarmslotPortsByRepo,
   resolveMobileRuntimeContext,