@deeeed/metamask-harness 0.17.4 → 0.17.5

package/dist/commands/run.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { walletFixturePath } from "../paths.js";
 import { color } from "../cli-color.js";
 import { recipeRunning } from "../heal-bounds.js";
-import { checkoutBusyOut, EXIT, usageOut, writeInteractiveProgress } from "./shared.js";
+import { EXIT } from "./shared.js";
 import {
   optionFlag,
   optionString,
@@ -11,8 +11,6 @@ import {
   resolveAdapter,
   runtimeOptionsFromCli,
   isRecord,
-  shellQuote,
-  targetPath,
   usageError
 } from "./parse-args.js";
 import {
@@ -30,119 +28,46 @@ import { getAdapterSurface } from "../adapters/surface.js";
 import { coreDependencyBlock } from "./core-readiness.js";
 import { writeRunReport } from "./run-report.js";
 import { acquireCheckoutLock } from "../checkout-lock.js";
-import { JsonStreamWriter } from "../json-stream.js";
-import { formatRunDiagnosticsForHuman, readRunDiagnosticsDocument } from "../run-diagnostics.js";
-async function handleRun(parsed) {
-  const stream = new JsonStreamWriter("run", optionFlag(parsed.options, "jsonStream"));
-  const restoreStdout = stream.isolateStdout();
-  const target = targetPath(parsed.options);
-  try {
-    const exitCode = await handleRunInner(parsed, stream);
-    stream.complete(exitCode === EXIT.ok ? "pass" : "fail", exitCode);
-    return exitCode;
-  } catch (error) {
-    const exitCode = error !== null && typeof error === "object" && "exitCode" in error && typeof error.exitCode === "number" ? error.exitCode : EXIT.runtime;
-    stream.error({
-      code: exitCode === EXIT.usage ? "CLI_USAGE_ERROR" : "RUN_FAILED",
-      message: error instanceof Error ? error.message : String(error),
-      userAction: `mm-harness doctor --target ${shellQuote(target)} --json`
-    });
-    stream.complete("fail", exitCode);
-    throw error;
-  } finally {
-    restoreStdout();
-  }
-}
-async function handleRunInner({ positional, options }, stream) {
-  if (optionFlag(options, "list")) {
-    if (stream.enabled) {
-      const message = "--json-stream is for recipe execution; use run --list --json for discovery.";
-      stream.error({ code: "JSON_STREAM_UNSUPPORTED_MODE", message, userAction: "mm-harness run --list --json" });
-      return EXIT.usage;
-    }
-    return handleListExecutables("run", options);
-  }
+async function handleRun({ positional, options }) {
+  if (optionFlag(options, "list")) return handleListExecutables("run", options);
   const targetRecipe = positional[0];
   if (!targetRecipe) throw usageError("run requires <recipe.json>.");
-  if (optionFlag(options, "plan")) return handleRunPlan(targetRecipe, options, stream);
+  if (optionFlag(options, "plan")) return handleRunPlan(targetRecipe, options);
   const { adapter, target } = resolveAdapter(options);
   const json = optionFlag(options, "json");
-  const jsonOutput = json && !stream.enabled;
-  const machine = json || stream.enabled;
-  stream.phase("resolve", { adapter, target, recipe: targetRecipe });
-  if (!fs.existsSync(target)) {
-    const message = `target does not exist: ${target}`;
-    const userAction = "pass --target <metamask-checkout> pointing to an existing checkout";
-    if (stream.enabled) {
-      stream.error({ code: "TARGET_NOT_FOUND", message, userAction });
-      return EXIT.usage;
-    }
-    return usageOut(jsonOutput, "run", message, userAction);
-  }
-  writeInteractiveProgress(machine, `\u2192 recipe run \u2014 validating ${targetRecipe} \xB7 ${adapter}`);
   getAdapterSurface(adapter).resolveSlotPorts(target);
   const dtResult = applyDeviceTargeting("run", adapter, options, { gate: true, rerun: "" });
   if ("code" in dtResult) {
-    return emitRunUsageError(jsonOutput, stream, adapter, targetRecipe, dtResult.code, dtResult.message, dtResult.userAction);
+    return emitRunUsageError(json, adapter, targetRecipe, dtResult.code, dtResult.message);
   }
-  if (recipeRunning(target)) return emitRunRecipeRunning(jsonOutput, stream, target);
+  if (recipeRunning(target)) return emitRunRecipeRunning(json);
   if (optionString(options, "artifactsDir") === void 0 && runArgLooksLikeRecipeFile(targetRecipe)) {
     requiredOption(options, "artifactsDir", "run requires --artifacts-dir <dir>.");
   }
-  stream.phase("validate");
   const validated = await validateRunRecipeStatic(targetRecipe, adapter, options);
   if (validated.usageError) {
-    const userAction = runUsageRecovery(
-      validated.usageError.code,
-      validated.usageError.message,
-      adapter,
-      validated.recipeFile
-    );
-    return emitRunUsageError(
-      jsonOutput,
-      stream,
-      adapter,
-      validated.recipeFile,
-      validated.usageError.code,
-      validated.usageError.message,
-      userAction
-    );
+    return emitRunUsageError(json, adapter, validated.recipeFile, validated.usageError.code, validated.usageError.message);
   }
   if (validated.errorCount > 0) {
-    return emitRunValidationError(jsonOutput, stream, adapter, validated.recipeFile, validated.findings, validated.errorCount);
+    return emitRunValidationError(json, adapter, validated.recipeFile, validated.findings, validated.errorCount);
   }
   const depsBlock = adapter === "core" && recipeUsesCoreController(validated.recipe, validated.librarySources) ? coreDependencyBlock(target) : null;
   if (depsBlock) {
-    return emitRunUsageError(jsonOutput, stream, adapter, validated.recipeFile, depsBlock.code, depsBlock.message, depsBlock.userAction);
+    return emitRunUsageError(json, adapter, validated.recipeFile, depsBlock.code, depsBlock.message, depsBlock.userAction);
   }
   const artifactsDir = requiredOption(options, "artifactsDir", "run requires --artifacts-dir <dir>.");
   const lock = acquireCheckoutLock(target, "run");
-  if ("message" in lock) {
-    const userAction = `wait for the current owner, or inspect ${lock.path} if its process has exited`;
-    stream.error({ code: "SANDBOX_BUSY", message: lock.message, userAction });
-    return checkoutBusyOut(jsonOutput, "run", lock.message, lock.path);
-  }
+  if ("message" in lock) return emitRunRecipeRunning(json, lock.message);
   try {
-    const prepared = await prepareHeal(adapter, target, options, machine, {
-      onPhase: (phase, fields) => stream.phase(phase, fields)
-    });
-    if (typeof prepared === "number") {
-      stream.error({
-        code: "RUN_PREPARE_FAILED",
-        message: "runtime preparation failed; inspect stderr for the exact probe",
-        userAction: `mm-harness doctor --fix --adapter ${adapter} --target ${shellQuote(target)} --json`
-      });
-      return prepared;
-    }
+    const prepared = await prepareHeal(adapter, target, options, json);
+    if (typeof prepared === "number") return prepared;
     const { state, heal } = prepared;
     const librarySources = validated.librarySources;
     const runtimeOptions = {
       ...runtimeOptionsFromCli(options),
       ...librarySources ? { librarySources } : {},
-      stdoutIsMachineContract: machine,
-      onActionEvent: ({ nodeId, action, status }) => stream.node(nodeId, action, status)
+      stdoutIsMachineContract: json
     };
-    stream.phase("execute");
     const { result, violation } = await executeWithHealBounds(
       // validated.recipeFile, not the raw arg: the arg may be a library recipe NAME
       // that only the resolver knows how to turn into a file.
@@ -151,42 +76,12 @@ async function handleRunInner({ positional, options }, stream) {
       target,
       heal,
       state,
-      () => recoverRunInfra(adapter, target, machine),
-      (code) => stream.phase("recover", { code })
+      () => recoverRunInfra(adapter, target, json)
     );
-    for (const mutation of state.mutations) stream.mutation(mutation);
-    for (const recovery of state.recovered) stream.recovery(recovery);
-    if (violation !== null) {
-      const userAction = violation.userAction ?? `inspect ${shellQuote(result.summaryPath)} and ${shellQuote(result.tracePath)}; fix the application or recipe failure before retrying`;
-      stream.error({
-        code: violation.code,
-        message: violation.message,
-        userAction,
-        originalError: violation.originalError ?? null
-      });
-      return emitHealViolation(jsonOutput, "run", result, violation, state, adapter);
-    }
+    if (violation !== null) return emitHealViolation(json, "run", result, violation, state, adapter);
     const report = writeRunReport(result);
     const exitCode = result.status === "pass" ? EXIT.ok : EXIT.runtime;
-    const failureUserAction = `mm-harness last --target ${shellQuote(target)} --json`;
-    if (stream.enabled) {
-      if (result.status === "fail") {
-        stream.error({
-          code: "RECIPE_EXECUTION_FAILED",
-          message: "recipe execution failed; inspect the persisted result and evidence paths",
-          userAction: failureUserAction
-        });
-      }
-      stream.complete(result.status === "pass" ? "pass" : "fail", exitCode, {
-        adapter,
-        reportPath: report.path,
-        summaryPath: result.summaryPath,
-        tracePath: result.tracePath,
-        artifactManifestPath: result.artifactManifestPath,
-        recovered: state.recovered,
-        mutations: state.mutations
-      });
-    } else if (json) {
+    if (json) {
       console.log(
         JSON.stringify(
           {
@@ -198,8 +93,7 @@ async function handleRunInner({ positional, options }, stream) {
             recovered: state.recovered,
             mutations: state.mutations,
             reportPath: report.path,
-            result,
-            ...result.status === "fail" ? { error: { code: "RECIPE_EXECUTION_FAILED", message: "recipe execution failed; inspect the persisted result and evidence paths", userAction: failureUserAction } } : {}
+            result
           },
           null,
           2
@@ -212,61 +106,14 @@ async function handleRunInner({ positional, options }, stream) {
         console.log(out("label", "summary:"));
         for (const line of report.preview) console.log(`  ${formatPreviewLine(line, out)}`);
       }
-      const artifacts = runArtifactInventory(result.artifactManifestPath);
-      console.log(out("label", `artifacts (${artifacts.length}):`));
-      for (const artifact of artifacts) {
-        console.log(`  ${out("dim", `${artifact.label}:`)} ${out("path", artifact.absolutePath)}`);
-      }
-      if (result.status === "fail") {
-        console.error(`  Next: ${failureUserAction}`);
-      }
-      console.log(out("label", "diagnostics:"));
-      const diagnostics = readRunDiagnosticsDocument(result.diagnosticsPath);
-      for (const line of formatRunDiagnosticsForHuman(diagnostics, adapter)) {
-        console.log(`  ${formatDiagnosticLine(line, out)}`);
-      }
+      console.log(`${out("label", "report:")} ${out("path", report.path)}`);
+      console.log(`${out("label", "artifacts:")} ${out("path", result.artifactManifestPath)}`);
     }
     return exitCode;
   } finally {
     lock.release();
   }
 }
-function formatDiagnosticLine(line, out) {
-  const match = /^(CLEAN|REVIEW|UNAVAILABLE|N\/A|WARNING|ERROR|EXCEPTION)(.*)$/u.exec(line);
-  if (!match) return line;
-  const status = match[1];
-  const style = status === "CLEAN" ? "ok" : status === "ERROR" || status === "EXCEPTION" ? "err" : "warn";
-  return `${out(style, status)}${match[2]}`;
-}
-function runArtifactInventory(manifestPathValue) {
-  const manifestPath = path.resolve(String(manifestPathValue));
-  const root = path.dirname(manifestPath);
-  let manifest;
-  try {
-    manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-  } catch {
-    return [{ absolutePath: manifestPath, basename: path.basename(manifestPath), label: "Artifact manifest" }];
-  }
-  const entries = isRecord(manifest) && Array.isArray(manifest.artifacts) ? manifest.artifacts : [];
-  const artifacts = [];
-  for (const entry of entries) {
-    if (!isRecord(entry) || typeof entry.path !== "string" || entry.path.length === 0) continue;
-    const absolutePath = path.resolve(root, entry.path);
-    const basename = path.basename(absolutePath);
-    const label = typeof entry.label === "string" && entry.label.length > 0 ? entry.label : basename;
-    artifacts.push({ absolutePath, basename, label });
-  }
-  artifacts.push({ absolutePath: manifestPath, basename: path.basename(manifestPath), label: "Artifact manifest" });
-  const priority = /* @__PURE__ */ new Map([
-    ["diagnostics.json", 0],
-    ["report.md", 1],
-    ["summary.json", 2],
-    ["trace.json", 3],
-    ["recipe.json", 4],
-    ["artifact-manifest.json", 100]
-  ]);
-  return artifacts.filter((artifact, index, all) => all.findIndex((candidate) => candidate.absolutePath === artifact.absolutePath) === index).sort((left, right) => (priority.get(left.basename) ?? 50) - (priority.get(right.basename) ?? 50));
-}
 function formatPreviewLine(line, out) {
   const match = /^(PASS|FAIL)\s+(.+)$/u.exec(line);
   if (!match) return line;
@@ -338,29 +185,12 @@ function loadFlowCatalogs(librarySources) {
 function actionUsesCoreController(action) {
   return typeof action === "string" && action.startsWith("metamask.perps.");
 }
-async function handleRunPlan(recipeArg, options, stream) {
+async function handleRunPlan(recipeArg, options) {
   const json = optionFlag(options, "json");
-  const jsonOutput = json && !stream.enabled;
   const { adapter, target } = resolveAdapter(options);
-  stream.phase("resolve", { adapter, target, recipe: recipeArg });
-  stream.phase("validate");
   const validated = await validateRunRecipeStatic(recipeArg, adapter, options);
   if (validated.usageError) {
-    const userAction = runUsageRecovery(
-      validated.usageError.code,
-      validated.usageError.message,
-      adapter,
-      validated.recipeFile
-    );
-    return emitPlanUsageError(
-      jsonOutput,
-      stream,
-      adapter,
-      validated.recipeFile,
-      validated.usageError.code,
-      validated.usageError.message,
-      userAction
-    );
+    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";
@@ -414,27 +244,9 @@ async function handleRunPlan(recipeArg, options, stream) {
       detail: nodeCount === void 0 ? "would execute the recipe nodes" : `would execute ${nodeCount} recipe node(s)`
     }
   ];
-  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)`,
-      userAction: runPlanProbe(adapter, recipeFile)
-    };
-  }
-  if (stream.enabled) {
-    if (status === "fail") stream.error(payload.error);
-    stream.complete(status, status === "pass" ? EXIT.ok : EXIT.validation, { mode: "plan", adapter, recipe: recipeFile, findings, plan });
-  } else if (json) {
+  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}`);
@@ -448,61 +260,52 @@ async function handleRunPlan(recipeArg, options, stream) {
         console.log(`  ${finding.severity === "error" ? "\u2717" : "\u26A0"} ${finding.code} ${finding.path} \u2014 ${finding.message}`);
       }
     }
-    if (status === "fail") console.error(`  Next: ${runPlanProbe(adapter, recipeFile)}`);
   }
   return status === "pass" ? EXIT.ok : EXIT.validation;
 }
-function emitPlanUsageError(json, stream, adapter, recipeFile, code, message, userAction) {
-  stream.error({ code, message, userAction, mode: "plan", adapter, recipe: recipeFile });
+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, userAction } },
+        { schemaVersion: 1, command: "run", mode: "plan", status: "fail", adapter, recipe: recipeFile, error: { code, message } },
         null,
         2
       )
     );
   } else {
-    console.error(`\u2717 run --plan: ${message}
-  Next: ${userAction}`);
+    console.error(`\u2717 run --plan: ${message}`);
   }
   return EXIT.usage;
 }
 function runArgLooksLikeRecipeFile(value) {
   return path.isAbsolute(value) || value.includes("/") || value.includes(path.sep) || value.endsWith(".json") || fs.existsSync(path.resolve(value));
 }
-function emitRunRecipeRunning(json, stream, target, detail) {
+function emitRunRecipeRunning(json, detail) {
   const message = detail ?? "a recipe is currently running \u2014 refusing to start while another recipe executes.";
-  const userAction = `inspect the checkout state with: mm-harness status --target ${shellQuote(target)} --json; retry after the active recipe finishes`;
-  stream.error({ code: "RECIPE_RUNNING", message, userAction, recoverable: false });
   if (json) {
-    console.log(JSON.stringify({ schemaVersion: 1, status: "fail", recoverable: false, error: { code: "RECIPE_RUNNING", message, userAction } }, null, 2));
+    console.log(JSON.stringify({ schemaVersion: 1, status: "fail", recoverable: false, error: { code: "RECIPE_RUNNING", message } }, null, 2));
   } else {
-    console.error(`\u2717 mm-harness: ${message}
-  Next: ${userAction}`);
+    console.error(`\u2717 mm-harness: ${message}`);
   }
   return EXIT.bounded;
 }
-function emitRunUsageError(json, stream, adapter, recipeFile, code, message, userAction) {
-  stream.error({ code, message, userAction });
+function emitRunUsageError(json, adapter, recipeFile, code, message, userAction) {
   if (json) {
     console.log(
       JSON.stringify(
-        { schemaVersion: 1, command: "run", adapter, status: "fail", exitCode: EXIT.usage, recipe: recipeFile, error: { code, message, userAction } },
+        { schemaVersion: 1, command: "run", adapter, status: "fail", exitCode: EXIT.usage, recipe: recipeFile, error: { code, message, ...userAction ? { userAction } : {} } },
         null,
         2
       )
     );
   } else {
     console.error(`\u2717 run: ${message}`);
-    console.error(`  Next: ${userAction}`);
+    if (userAction) console.error(`  Next: ${userAction}`);
   }
   return EXIT.usage;
 }
-function emitRunValidationError(json, stream, adapter, recipeFile, findings, errorCount) {
+function emitRunValidationError(json, adapter, recipeFile, findings, errorCount) {
   const message = `recipe validation found ${errorCount} error(s)`;
-  const userAction = runPlanProbe(adapter, recipeFile);
-  stream.error({ code: "RECIPE_VALIDATION_FAILED", message, userAction, findings });
   if (json) {
     console.log(
       JSON.stringify(
@@ -516,7 +319,7 @@ function emitRunValidationError(json, stream, adapter, recipeFile, findings, err
           mutations: [],
           recipe: recipeFile,
           findings,
-          error: { code: "RECIPE_VALIDATION_FAILED", message, userAction }
+          error: { code: "RECIPE_VALIDATION_FAILED", message }
         },
         null,
         2
@@ -527,22 +330,9 @@ function emitRunValidationError(json, stream, adapter, recipeFile, findings, err
     for (const finding of findings) {
       if (finding.severity === "error") console.error(`  ${finding.code} ${finding.path} \u2014 ${finding.message}`);
     }
-    console.error(`  Next: ${userAction}`);
   }
   return EXIT.validation;
 }
-function runPlanProbe(adapter, recipeFile) {
-  return `mm-harness run --plan ${shellQuote(recipeFile)} --adapter ${adapter} --json`;
-}
-function runUsageRecovery(code, message, adapter, recipeFile) {
-  const actionCommand = /This is an action, not a recipe\. Use: (mm-harness call .+)\.$/u.exec(message)?.[1];
-  if (actionCommand) return actionCommand;
-  if (code === "RECIPE_NOT_FOUND") return `mm-harness run --list --adapter ${adapter} --json`;
-  if (code === "RECIPE_UNPARSEABLE") {
-    return `fix the JSON syntax in ${shellQuote(recipeFile)}, then retry: ${runPlanProbe(adapter, recipeFile)}`;
-  }
-  return runPlanProbe(adapter, recipeFile);
-}
 export {
   handleRun
 };

package/dist/commands/shared.js

@@ -3,15 +3,6 @@ import path from "node:path";
 import { detectAdapter } from "../harness.js";
 import { resolveLeafInvoke, shellLeafMissing } from "../leaf-invoke.js";
 const EXIT = { ok: 0, runtime: 1, usage: 2, infra: 3, bounded: 4, validation: 5 };
-function writeInteractiveProgress(json, message, {
-  stdoutIsTTY = Boolean(process.stdout.isTTY),
-  stream = process.stderr
-} = {}) {
-  if (json || !stdoutIsTTY) return false;
-  stream.write(`${message}
-`);
-  return true;
-}
 function parseFlags(argv, booleans) {
   const positional = [];
   const options = {};
@@ -147,16 +138,11 @@ function spawnScriptStreaming(script, args, cwd, options) {
     let settled = false;
     let didTimeout = false;
     let escalation;
-    const parentSignals = ["SIGINT", "SIGTERM"];
-    const removeParentSignalHandlers = () => {
-      for (const signal of parentSignals) process.removeListener(signal, parentSignalHandlers[signal]);
-    };
     const finish = (result) => {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
-      if (escalation) clearTimeout(escalation);
-      removeParentSignalHandlers();
+      if (escalation && !didTimeout) clearTimeout(escalation);
       resolve(result);
     };
     const signalChildTree = (signal) => {
@@ -166,14 +152,6 @@ function spawnScriptStreaming(script, args, cwd, options) {
       } catch {
       }
     };
-    const parentSignalHandlers = Object.fromEntries(parentSignals.map((signal) => [signal, () => {
-      signalChildTree(signal);
-      removeParentSignalHandlers();
-      process.kill(process.pid, signal);
-    }]));
-    if (ownsProcessGroup) {
-      for (const signal of parentSignals) process.once(signal, parentSignalHandlers[signal]);
-    }
     const timeoutMs = spawnOptions.timeoutMs;
     const timer = Number.isFinite(timeoutMs) && Number(timeoutMs) > 0 ? setTimeout(() => {
       didTimeout = true;
@@ -204,13 +182,8 @@ function spawnScriptStreaming(script, args, cwd, options) {
 `);
       finish({ status: 1, output: message });
     });
-    child.on("exit", () => {
-      if (!didTimeout) return;
-      signalChildTree("SIGKILL");
-      finish({ status: 1, output, timedOut: true, timeoutMs: Number(timeoutMs) });
-    });
     child.on("close", (status) => {
-      if (didTimeout) signalChildTree("SIGKILL");
+      if (didTimeout && escalation) return;
       finish({
         status: didTimeout ? 1 : status ?? 1,
         output,
@@ -235,33 +208,9 @@ function usageOut(json, command, message, userAction) {
   }
   return EXIT.usage;
 }
-function checkoutBusyOut(json, command, message, lockPath) {
-  const userAction = `wait for the current owner, or inspect ${lockPath} if its process has exited`;
-  if (json) {
-    console.log(
-      JSON.stringify(
-        {
-          schemaVersion: 1,
-          command,
-          status: "fail",
-          exitCode: EXIT.bounded,
-          recoverable: false,
-          error: { code: "SANDBOX_BUSY", message, userAction }
-        },
-        null,
-        2
-      )
-    );
-  } else {
-    console.error(`\u2717 mm-harness ${command}: ${message}
-  Next: ${userAction}`);
-  }
-  return EXIT.bounded;
-}
 export {
   ADAPTER_DETECT_NEXT,
   EXIT,
-  checkoutBusyOut,
   flag,
   parseFlags,
   resolveAdapter,
@@ -271,6 +220,5 @@ export {
   spawnScriptStreaming,
   str,
   targetOf,
-  usageOut,
-  writeInteractiveProgress
+  usageOut
 };

package/dist/commands/status-probe.js

@@ -34,7 +34,7 @@ function parseBridgeEntries(raw) {
     deviceName: typeof e.deviceName === "string" ? e.deviceName : "",
     platform: typeof e.platform === "string" ? e.platform : "",
     // agenticPresent is only set when the bridge explicitly sends it (false = absent).
-    // An omitted value remains unknown.
+    // Omitted by older bridge versions → leave undefined so caller treats as present.
     ...typeof e.agenticPresent === "boolean" ? { agenticPresent: e.agenticPresent } : {}
   }));
 }

package/dist/commands/status.js

@@ -31,7 +31,7 @@ async function handleStatus({ options }) {
   if (adapter === "mobile") {
     const dtResult = applyDeviceTargeting("status", adapter, options, { gate: false, rerun: "" });
     if ("code" in dtResult) {
-      return usageOut(json, "status", dtResult.message, dtResult.userAction);
+      return usageOut(json, "status", dtResult.message, "mm-harness status --device <id> or --all-devices");
     }
   }
   const next = surface.hints.relaunch;

package/dist/commands/stop.js

@@ -5,8 +5,7 @@ import {
   parseArgs,
   optionFlag,
   optionString,
-  resolveAdapter,
-  shellQuote
+  resolveAdapter
 } from "./parse-args.js";
 async function handleStop(argv) {
   const { options } = parseArgs(argv, "stop");
@@ -23,8 +22,6 @@ async function handleStop(argv) {
   if (stop.kind === "headless") {
     return usageOut(json, "stop", stop.message, stop.userAction);
   }
-  const next = adapter === "extension" ? `${surface.hints.launch} --target ${shellQuote(target)}` : void 0;
-  const userAction = `mm-harness status --target ${shellQuote(target)} --json`;
   if (json) {
     console.log(
       JSON.stringify(
@@ -36,8 +33,7 @@ async function handleStop(argv) {
           status: stop.status === 0 ? "pass" : "fail",
           ...stop.signalled !== void 0 ? { signalled: stop.signalled } : {},
           exitCode: stop.status,
-          ...stop.output ? { output: stop.output } : {},
-          ...stop.status === 0 ? next ? { next } : {} : { error: { code: "DEV_SERVER_STOP_FAILED", message: stop.summary, userAction } }
+          ...stop.output ? { output: stop.output } : {}
         },
         null,
         2
@@ -47,7 +43,6 @@ async function handleStop(argv) {
     if (stop.output) process.stderr.write(`${stop.output}
 `);
     console.error(`${color(stop.status === 0 ? "ok" : "err", stop.status === 0 ? "\u2713" : "\u2717")} ${stop.summary}`);
-    if (stop.status !== 0 || next) console.error(`  Next: ${stop.status === 0 ? next : userAction}`);
   }
   return stop.status;
 }

package/dist/commands/update.js

@@ -1,4 +1,4 @@
-import { spawn, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -6,8 +6,7 @@ import { runnerDir } from "../paths.js";
 import { EXIT, flag, parseFlags } from "./shared.js";
 const PACKAGE_NAME = "@deeeed/metamask-harness";
 const NUDGE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-const NUDGE_FETCH_TIMEOUT_MS = 2e3;
-const REGISTRY_DIST_TAGS_ENDPOINT = `https://registry.npmjs.org/-/package/${encodeURIComponent(PACKAGE_NAME)}/dist-tags`;
+const NUDGE_FETCH_TIMEOUT_MS = 300;
 function currentVersion() {
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(runnerDir, "package.json"), "utf8"));
@@ -57,6 +56,24 @@ function fetchLatest(timeoutMs) {
   if (!latest) return { error: { kind: "unreachable", message: "npm returned no dist-tag for latest" } };
   return { latest };
 }
+async function fetchLatestAsync(timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const url = `https://registry.npmjs.org/-/package/${encodeURIComponent(PACKAGE_NAME)}/dist-tags`;
+    const res = await fetch(url, { signal: controller.signal });
+    if (!res.ok) return { error: { kind: "unreachable", message: `registry returned HTTP ${res.status}` } };
+    const data = await res.json();
+    const latest = data["latest"];
+    if (!latest) return { error: { kind: "unreachable", message: "npm registry returned no latest dist-tag" } };
+    return { latest };
+  } catch (err) {
+    const msg = err.name === "AbortError" ? `registry fetch timed out after ${timeoutMs}ms` : err.message;
+    return { error: { kind: "unreachable", message: msg } };
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function teachFailure(json, current, code, message, userAction) {
   if (json) {
     console.log(
@@ -194,28 +211,23 @@ function nudgeDisabled() {
 function nudgeLine(current, latest) {
   return isNewer(latest, current) ? `mm-harness ${current} \u2192 ${latest} available \xB7 run: mm-harness update` : null;
 }
-function maybeNudge(now = Date.now()) {
+async function maybeNudge(now = Date.now()) {
   if (nudgeDisabled()) return;
   const file = cacheFile();
   const cache = readCache(file);
   const current = currentVersion();
+  let latest = cache?.latest ?? "";
   process.once("exit", () => {
-    const line = nudgeLine(current, cache?.latest ?? "");
+    const line = nudgeLine(current, latest);
     if (line) process.stderr.write(`${line}
 `);
   });
   if (!cache || now - cache.lastCheck >= NUDGE_INTERVAL_MS) {
-    writeCache(file, { lastCheck: now, latest: cache?.latest ?? "" });
-    const worker = path.join(runnerDir, "adapters", "shared", "update-check-worker.mjs");
-    if (!fs.existsSync(worker)) return;
-    try {
-      const child = spawn(
-        process.execPath,
-        [worker, file, String(NUDGE_FETCH_TIMEOUT_MS), REGISTRY_DIST_TAGS_ENDPOINT],
-        { detached: true, stdio: "ignore" }
-      );
-      child.unref();
-    } catch {
+    writeCache(file, { lastCheck: now, latest });
+    const fetched = await fetchLatestAsync(NUDGE_FETCH_TIMEOUT_MS);
+    if (fetched.latest) {
+      latest = fetched.latest;
+      writeCache(file, { lastCheck: now, latest });
     }
   }
 }