@deeeed/metamask-harness 0.55.0 → 0.56.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 0.56.0 - 2026-09-18
+
+### Changed
+
+- `prepare` says what it is doing while it does it. It now opens with the whole chain — `doctor`, `status`, `launch`, `fixtures`, `verify`, or just `doctor`, `status`, `verify` on Core — one line each, so the wait is bounded before the first step runs. The running step counts up in place (`… launch: running 1:23`), each finished one keeps how long it took (`✓ launch: pass (0:47)`), and the slow steps carry a dim note saying what they are waiting on: `can take minutes on Mobile: Metro bundle and app start` for `launch`, `under a minute` for `fixtures`. Where the checkout has a previous `sandbox.json`, each step also shows what it cost last time (`last run 6:52`) — the only honest estimate the harness has. Before this, a Mobile prepare printed `✓ status: pass` and then nothing for the minutes the launch step ran, which reads as a hang. The clock on screen is the wall clock: one timestamp taken at the spawn feeds both the ticker and the `durationMs` in the record, and the repaint holds the event loop awake so a step that stays quiet for minutes — `verify` waiting on its bridge probe — cannot leave the count frozen behind the wall. Piped output is a plain log — the list, then each step as it lands, then the finished list. `--json` is untouched: stdout stays a single document.
+- `sandbox.json` records `durationMs` on every readiness step (`0` for a skipped one), so a run that felt slow can be read back step by step instead of retimed by hand.
+
+## 0.55.1 - 2026-09-18
+
+### Fixed
+
+- `doctor` probes the registry when the running build is newer than the cached latest, instead of reporting "ahead of registry" for up to an hour after a publish.
+
 ## 0.55.0 - 2026-09-18
 
 ### Added

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

@@ -193,6 +193,7 @@ function writeDepsNote(resolved) {
   stream.write(
     `
 ${color("warn", "mm-harness note (deps):", { stream })} ${color("dim", body, { stream })}
+
 `
   );
 }

package/dist/commands/prepare.js

@@ -1,14 +1,16 @@
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import {
   READINESS_RECORD
 } from "@farmslot/protocol";
+import { color, stripAnsi } from "../cli-color.js";
 import { runnerProvenance } from "../doctor.js";
 import { detectAdapter } from "../harness.js";
 import { harnessExecutable, manifestPath, recipeRuntimeDir } from "../paths.js";
 import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
 import { EXIT } from "./shared.js";
+import { formatDuration } from "./status-watch.js";
 const USAGE = "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]";
 const REPORT_DIR = "prepare";
 const SKIPPED_AFTER_FAILURE = "previous step failed";
@@ -26,31 +28,175 @@ function reportedError(stdout) {
   return typeof message === "string" && message ? message : void 0;
 }
 function skippedStep(id, command, reason) {
-  return { id, command, status: "skipped", exitCode: 0, reason };
+  return { id, command, status: "skipped", exitCode: 0, reason, durationMs: 0 };
 }
-const STEP_MARK = { pass: "\u2713", fail: "\u2717", skipped: "\u2013" };
-function stepLine(step) {
-  return `${STEP_MARK[step.status]} ${step.id}: ${step.status}${step.reason ? ` \u2014 ${step.reason}` : ""}`;
+const STEP_MARK = {
+  pending: "\xB7",
+  running: "\u2026",
+  pass: "\u2713",
+  fail: "\u2717",
+  skipped: "\u2013"
+};
+const STEP_STYLE = {
+  pending: "dim",
+  running: "accent",
+  pass: "ok",
+  fail: "err",
+  skipped: "dim"
+};
+const STEP_HINT = {
+  launch: "can take minutes on Mobile: Metro bundle and app start",
+  fixtures: "under a minute"
+};
+function stepChain(platform) {
+  return platform === "core" ? ["doctor", "status", "verify"] : ["doctor", "status", "launch", "fixtures", "verify"];
 }
-function runStep(executable, target, artifactsDir, id, args, { json }) {
-  const command = [executable, ...args].join(" ");
-  const result = spawnSync(executable, [...args], {
-    cwd: target,
-    encoding: "utf8",
-    // The update nudge is an interactive courtesy; it has no place in the
-    // stream a recorded readiness step captures.
-    env: { ...process.env, MM_HARNESS_NO_UPDATE_CHECK: "1" }
+function lastRunDurations(recordPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(recordPath, "utf8"));
+  } catch {
+    return {};
+  }
+  const steps = parsed?.steps;
+  if (!Array.isArray(steps)) return {};
+  const durations = {};
+  for (const step of steps) {
+    if (typeof step?.id === "string" && typeof step.durationMs === "number" && step.durationMs > 0) {
+      durations[step.id] = step.durationMs;
+    }
+  }
+  return durations;
+}
+function stepHints(chain, lastRun) {
+  const hints = {};
+  for (const id of chain) {
+    const previous = lastRun[id];
+    const parts = [];
+    if (STEP_HINT[id]) parts.push(STEP_HINT[id]);
+    if (previous !== void 0) parts.push(`last run ${formatDuration(previous)}`);
+    if (parts.length > 0) hints[id] = parts.join(", ");
+  }
+  return hints;
+}
+function stepRowLine(row, width) {
+  const out = (style, text) => color(style, text, { stream: process.stdout });
+  const running = row.state === "pending" || row.state === "running";
+  const elapsed = row.state === "running" && row.startedAt !== void 0 ? ` ${out("dim", formatDuration(Date.now() - row.startedAt))}` : "";
+  const note = running ? row.hint : row.durationMs ? formatDuration(row.durationMs) : void 0;
+  const mark = out(STEP_STYLE[row.state], STEP_MARK[row.state]);
+  return `${mark} ${out(running ? "bold" : "dim", row.id.padEnd(width))}: ${out(STEP_STYLE[row.state], row.state)}${elapsed}${row.reason ? ` \u2014 ${row.reason}` : ""}${note ? ` ${out("dim", `(${note})`)}` : ""}`;
+}
+function createStepView(chain, hints) {
+  const rows = new Map(
+    chain.map((id) => [id, { id, state: "pending", hint: hints[id] }])
+  );
+  const width = Math.max(...chain.map((id) => id.length));
+  const tty = Boolean(process.stdout.isTTY);
+  const block = () => {
+    const terminalColumns = process.stdout.columns;
+    const columns = tty && typeof terminalColumns === "number" && terminalColumns > 0 ? terminalColumns : Number.POSITIVE_INFINITY;
+    return [...rows.values()].map((row) => {
+      const line = stepRowLine(row, width);
+      return stripAnsi(line).length <= columns ? line : stripAnsi(line).slice(0, columns);
+    });
+  };
+  let painted = 0;
+  let lastFrame = "";
+  let ended = false;
+  let timer;
+  const repaint = () => {
+    const lines = block();
+    const frame = lines.join("\n");
+    if (frame === lastFrame) return;
+    lastFrame = frame;
+    const up = painted > 0 ? `\x1B[${painted}A` : "";
+    painted = lines.length;
+    process.stdout.write(`${up}${lines.map((line) => `\x1B[2K${line}`).join("\n")}
+`);
+  };
+  const writeBlock = () => {
+    process.stdout.write(`${block().join("\n")}
+`);
+  };
+  return {
+    begin() {
+      if (tty) repaint();
+      else writeBlock();
+    },
+    start(id, startedAt) {
+      const row = rows.get(id);
+      if (!row) return;
+      row.state = "running";
+      row.startedAt = startedAt;
+      if (!tty) return;
+      repaint();
+      timer = setInterval(repaint, 250);
+    },
+    finish(step) {
+      clearInterval(timer);
+      timer = void 0;
+      const row = rows.get(step.id);
+      if (!row) return;
+      row.state = step.status;
+      row.startedAt = void 0;
+      row.reason = step.reason;
+      row.durationMs = step.durationMs;
+      if (tty) repaint();
+      else process.stdout.write(`${stepRowLine(row, width)}
+`);
+    },
+    // Idempotent: the caller ends the view where the final block belongs in the
+    // output, and a `finally` ends it again on the paths that never got there.
+    // The ticker holds the event loop awake, so this must run either way.
+    end() {
+      if (ended) return;
+      ended = true;
+      clearInterval(timer);
+      timer = void 0;
+      if (!tty) writeBlock();
+    }
+  };
+}
+function spawnStep(executable, args, target) {
+  return new Promise((resolve) => {
+    const child = spawn(executable, [...args], {
+      cwd: target,
+      stdio: ["ignore", "pipe", "pipe"],
+      // The update nudge is an interactive courtesy; it has no place in the
+      // stream a recorded readiness step captures.
+      env: { ...process.env, MM_HARNESS_NO_UPDATE_CHECK: "1" }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => resolve({ error, status: null, stdout, stderr }));
+    child.on("close", (status) => resolve({ status, stdout, stderr }));
   });
+}
+async function runStep(executable, target, artifactsDir, id, args, { json, onSpawn }) {
+  const command = [executable, ...args].join(" ");
+  const startedAt = Date.now();
+  onSpawn?.(startedAt);
+  const result = await spawnStep(executable, args, target);
+  const durationMs = Date.now() - startedAt;
   if (result.error) {
-    return { id, command, status: "fail", exitCode: 1, reason: result.error.message };
+    return { id, command, status: "fail", exitCode: 1, reason: result.error.message, durationMs };
   }
   const report = reportPathFor(id);
   const file = path.join(artifactsDir, report);
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, result.stdout ?? "");
+  fs.writeFileSync(file, result.stdout);
   const exitCode = result.status ?? 1;
   if (exitCode === 0) {
-    return { id, command, status: "pass", exitCode, reportPath: report };
+    return { id, command, status: "pass", exitCode, reportPath: report, durationMs };
   }
   if (!json && result.stderr) process.stderr.write(result.stderr);
   return {
@@ -59,7 +205,8 @@ function runStep(executable, target, artifactsDir, id, args, { json }) {
     status: "fail",
     exitCode,
     reportPath: report,
-    reason: reportedError(result.stdout) ?? `exited ${exitCode}`
+    reason: reportedError(result.stdout) ?? `exited ${exitCode}`,
+    durationMs
   };
 }
 function readDevices(artifactsDir) {
@@ -172,41 +319,56 @@ async function handlePrepare(argv) {
   Next: ${USAGE}`);
   }
   let mobilePlatform = mobilePlatformOption(optionString(options, "mobilePlatform"));
+  const recordPath = path.join(artifactsDir, READINESS_RECORD);
+  const chain = stepChain(platform);
+  const view = json ? void 0 : createStepView(chain, stepHints(chain, lastRunDurations(recordPath)));
+  view?.begin();
   const steps = [];
   const failed = () => steps.some((step) => step.status === "fail");
   const addStep = (step) => {
     steps.push(step);
-    if (!json) console.log(stepLine(step));
+    view?.finish(step);
     return step;
   };
-  const run = (id, args) => addStep(
-    failed() ? skippedStep(id, [executable, ...args].join(" "), SKIPPED_AFTER_FAILURE) : runStep(executable, target, artifactsDir, id, args, { json })
-  );
-  run("doctor", ["doctor", "--fix", "--json", "--adapter", platform, ...targetArgs]);
-  run("status", ["status", "--json", ...targetArgs]);
-  if (platform === "mobile" && !mobilePlatform && !failed()) {
-    mobilePlatform = mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(readDevices(artifactsDir));
-    if (!mobilePlatform) return ambiguousMobileTarget(json);
-  }
-  if (platform === "core") {
-    const reason = "core is headless: no app surface to launch or seed";
-    addStep(skippedStep("launch", `${executable} launch`, reason));
-    addStep(skippedStep("fixtures", `${executable} fixtures set`, reason));
-  } else if (platform === "mobile") {
-    const device = mobilePlatform ? [mobilePlatform] : [];
-    run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], "--verify", "--json", ...targetArgs]);
-    run("fixtures", [
-      "fixtures",
-      "set",
-      ...mobilePlatform ? ["--platform", mobilePlatform] : [],
-      "--json",
-      ...targetArgs
-    ]);
-  } else {
-    run("launch", ["launch", "--verify", "--json", ...targetArgs]);
-    run("fixtures", ["fixtures", "set", "--json", ...targetArgs]);
+  const run = async (id, args) => {
+    if (failed()) {
+      return addStep(skippedStep(id, [executable, ...args].join(" "), SKIPPED_AFTER_FAILURE));
+    }
+    const step = await runStep(executable, target, artifactsDir, id, args, {
+      json,
+      onSpawn: (startedAt) => view?.start(id, startedAt)
+    });
+    return addStep(step);
+  };
+  try {
+    await run("doctor", ["doctor", "--fix", "--json", "--adapter", platform, ...targetArgs]);
+    await run("status", ["status", "--json", ...targetArgs]);
+    if (platform === "mobile" && !mobilePlatform && !failed()) {
+      mobilePlatform = mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(readDevices(artifactsDir));
+      if (!mobilePlatform) return ambiguousMobileTarget(json);
+    }
+    if (platform === "core") {
+      const reason = "core is headless: no app surface to launch or seed";
+      addStep(skippedStep("launch", `${executable} launch`, reason));
+      addStep(skippedStep("fixtures", `${executable} fixtures set`, reason));
+    } else if (platform === "mobile") {
+      const device = mobilePlatform ? [mobilePlatform] : [];
+      await run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], "--verify", "--json", ...targetArgs]);
+      await run("fixtures", [
+        "fixtures",
+        "set",
+        ...mobilePlatform ? ["--platform", mobilePlatform] : [],
+        "--json",
+        ...targetArgs
+      ]);
+    } else {
+      await run("launch", ["launch", "--verify", "--json", ...targetArgs]);
+      await run("fixtures", ["fixtures", "set", "--json", ...targetArgs]);
+    }
+    await run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
+  } finally {
+    view?.end();
   }
-  run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
   const provenance = runnerProvenance(manifestPath(platform));
   const record = {
     schemaVersion: 1,
@@ -222,7 +384,6 @@ async function handlePrepare(argv) {
     ready: steps.every((step) => step.status !== "fail"),
     recordedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const recordPath = path.join(artifactsDir, READINESS_RECORD);
   fs.mkdirSync(artifactsDir, { recursive: true });
   fs.writeFileSync(recordPath, `${JSON.stringify(record, null, 2)}
 `);

package/dist/commands/update.js

@@ -206,7 +206,7 @@ function updateStatus(now = Date.now()) {
   if (nudgeDisabled()) return { current, checked: false };
   const file = cacheFile();
   const cache = readCache(file);
-  const latest = cache?.latest && now - cache.lastCheck < DOCTOR_CACHE_FRESH_MS ? cache.latest : probeLatest(file, now);
+  const latest = cache?.latest && now - cache.lastCheck < DOCTOR_CACHE_FRESH_MS && !isNewer(current, cache.latest) ? cache.latest : probeLatest(file, now);
   if (!latest) return { current, checked: false };
   return { current, checked: true, latest, updateAvailable: isNewer(latest, current) };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"