@deeeed/metamask-harness 0.79.0 → 0.81.0

package/dist/cli.js

@@ -1,6 +1,24 @@
+import "./host.js";
+import "./adapters/surface.js";
+import fs from "node:fs";
+import {
+  detectAdapter,
+  handleActions,
+  handleCall,
+  handleHarness,
+  handleLast,
+  handleLaunch,
+  handleReload,
+  handleRun,
+  handleStop,
+  parseArgs,
+  targetPath
+} from "@farmslot/recipe-cli/harness";
+import { stopProjectCollector } from "../library/actions/shared/analytics/collector.mjs";
 import { adapterRegistry } from "./adapters/registry.js";
-import { detectAdapter, handleHarness } from "./harness.js";
-import { handleActions } from "./commands/manifest.js";
+import { applyDeviceTargeting } from "./commands/device-target.js";
+import { metaMaskEngine } from "./engine.js";
+import { walletFixturePath } from "./paths.js";
 import { handleDoctor } from "./commands/doctor.js";
 import { handleProvision } from "./commands/provision.js";
 import { handleRuntimeHealth } from "./commands/runtime-health.js";
@@ -8,15 +26,10 @@ import { handleRuntimeLaunch } from "./commands/runtime-launch.js";
 import { handleRuntimeDecision } from "./commands/runtime-decision.js";
 import { handleResolveExtension } from "./commands/resolve-extension.js";
 import { handleEnsureReady } from "./commands/ensure-ready.js";
-import { handleRun } from "./commands/run.js";
 import { handleSelfTest } from "./commands/self-test.js";
-import { handleCall } from "./commands/call.js";
-import { handleStop } from "./commands/stop.js";
 import { handleCompletionCandidates, invalidateCompletionCache } from "./commands/completion-candidates.js";
-import { handleLaunch } from "./commands/launch/index.js";
 import { handleLogs } from "./commands/logs.js";
 import { handleDebug } from "./commands/debug.js";
-import { handleReload } from "./commands/reload.js";
 import { handleFixtures } from "./commands/fixtures.js";
 import { handleRecipeQuality } from "./commands/recipe-quality.js";
 import { handleStatus } from "./commands/status.js";
@@ -25,21 +38,46 @@ import { handleChecklist } from "./commands/checklist.js";
 import { handleExecutionTemplate } from "./commands/execution-template.js";
 import { handlePrepare } from "./commands/prepare.js";
 import { handleTaskInit } from "./commands/task-init.js";
-import { handleLast } from "./commands/last.js";
 import { handleReview } from "./commands/review.js";
 import { handleDomain } from "./commands/domain.js";
 import { handleConfig } from "./commands/config.js";
 import { handlePrBody } from "./commands/pr-body.js";
-import { parseArgs, targetPath } from "./commands/parse-args.js";
+import { overlayCommandOptions } from "./commands/overlay.js";
+const stopOptions = {
+  companions: async (target) => {
+    const collector = await stopProjectCollector(target);
+    return collector.stopped && collector.pid !== null ? [{ label: "analytics collector", pid: collector.pid }] : [];
+  }
+};
+const targetDevice = (command, adapter, options) => applyDeviceTargeting(command, adapter, options, { gate: true, rerun: "" });
+const runOptions = {
+  engine: metaMaskEngine,
+  targetDevice,
+  plan: {
+    // The wallet fixture `fixtures set` seeds.
+    steps: (target) => [{
+      step: "fixture.file",
+      confidence: "static",
+      status: "ok",
+      detail: fs.existsSync(walletFixturePath(target)) ? `present: ${walletFixturePath(target)}` : `absent: ${walletFixturePath(target)} (fixtures set to seed)`
+    }],
+    launchDetail: "would launch/attach the app + heal transport (Metro/Chrome/CDP) before executing"
+  }
+};
+const callOptions = {
+  engine: metaMaskEngine,
+  targetDevice,
+  // A wallet action makes the most useful first example.
+  exampleAction: (names) => names.find((name) => /wallet|unlock/u.test(name))
+};
 const COMMANDS = {
-  actions: handleActions,
+  actions: (parsed) => handleActions(parsed, { catalog: metaMaskEngine }),
   doctor: handleDoctor,
   "runtime-health": handleRuntimeHealth,
   "runtime-decision": handleRuntimeDecision,
   "runtime-launch": handleRuntimeLaunch,
   "resolve-extension": handleResolveExtension,
   "ensure-ready": handleEnsureReady,
-  run: handleRun,
   "self-test": handleSelfTest
 };
 const OVERLAY_COMMANDS = ["install", "verify", "cleanup"];
@@ -98,35 +136,35 @@ async function main(argv) {
     return command ? 0 : 2;
   }
   if (command === "status" || command === "health" || command === "home") {
-    return handleStatus(parseArgs(argv.slice(1), "status"));
+    return handleStatus(parseArgs(argv.slice(1)));
   }
-  if (command === "call") return handleCall(argv.slice(1));
+  if (command === "run") return handleRun(argv.slice(1), runOptions);
+  if (command === "call") return handleCall(argv.slice(1), callOptions);
   if (command === "completion-candidates") return handleCompletionCandidates(argv.slice(1));
-  if (command === "provision") return handleProvision(parseArgs(argv.slice(1), command));
+  if (command === "provision") return handleProvision(parseArgs(argv.slice(1)));
   if (OVERLAY_COMMANDS.includes(command)) {
     if (command === "verify" && process.env.MM_HARNESS_SKIP_OVERLAY_ENSURE !== "1") {
       try {
-        const { options } = parseArgs(argv.slice(1), command);
+        const { options } = parseArgs(argv.slice(1));
         const target = targetPath(options);
         const adapterRaw = (typeof options["adapter"] === "string" ? options["adapter"] : void 0) ?? (typeof options["platform"] === "string" ? options["platform"] : void 0) ?? detectAdapter(target);
-        await import("./adapters/surface.js");
         if (adapterRaw && adapterRegistry.has(adapterRaw)) {
           await handleHarness(["install", "--platform", adapterRaw, "--target", target, "--quiet"]);
         }
       } catch {
       }
     }
-    const code = await handleHarness(argv);
+    const code = await handleHarness(argv, overlayCommandOptions);
     if (code === 0 && command === "install") {
       try {
-        invalidateCompletionCache(targetPath(parseArgs(argv.slice(1), command).options));
+        invalidateCompletionCache(targetPath(parseArgs(argv.slice(1)).options));
       } catch {
       }
     }
     return code;
   }
   if (command === "launch") return handleLaunch(argv.slice(1));
-  if (command === "stop") return handleStop(argv.slice(1));
+  if (command === "stop") return handleStop(argv.slice(1), stopOptions);
   if (command === "logs") return handleLogs(argv.slice(1));
   if (command === "debug") return handleDebug(argv.slice(1));
   if (command === "reload") return handleReload(argv.slice(1));
@@ -137,14 +175,14 @@ async function main(argv) {
   if (command === "execution-template") return handleExecutionTemplate(argv.slice(1));
   if (command === "task") return handleTaskInit(argv.slice(1));
   if (command === "prepare") return handlePrepare(argv.slice(1));
-  if (command === "last") return handleLast(parseArgs(argv.slice(1), command));
+  if (command === "last") return handleLast(parseArgs(argv.slice(1)));
   if (command === "review") return handleReview(argv.slice(1));
   if (command === "domain") return handleDomain(argv.slice(1));
   if (command === "config") return handleConfig(argv.slice(1));
   if (command === "pr-body") return handlePrBody(argv.slice(1));
   const handler = COMMANDS[command];
   if (!handler) throw new Error(`Unknown command: ${command}`);
-  return handler(parseArgs(argv.slice(1), command));
+  return handler(parseArgs(argv.slice(1), command === "runtime-decision" ? { recordIsFlag: true } : {}));
 }
 if (!globalThis.__MM_HARNESS_WRAPPER__) {
   try {

package/dist/command-contract.js

@@ -1,3 +1,4 @@
+import { closest } from "@farmslot/recipe-cli/harness";
 const bool = () => ({ kind: "boolean" });
 const value = (choices) => ({ kind: "value", ...choices ? { choices } : {} });
 const optionalValue = (choices) => ({ kind: "optional-value", ...choices ? { choices } : {} });
@@ -698,34 +699,8 @@ function actionFor(received, suggestion, example) {
 function exampleFor(command, examples) {
   return command ? examples[command] ?? `mm-harness ${command} --help` : "mm-harness --help";
 }
-function closest(input, candidates) {
-  if (candidates.length === 0) return void 0;
-  const ranked = candidates.map((candidate) => ({ candidate, distance: levenshtein(input, candidate) })).sort((left, right) => left.distance - right.distance || left.candidate.localeCompare(right.candidate));
-  const best = ranked[0];
-  if (!best) return void 0;
-  const threshold = Math.max(2, Math.floor(Math.max(input.length, best.candidate.length) / 3));
-  return best.distance <= threshold ? best.candidate : void 0;
-}
-function levenshtein(left, right) {
-  let twoBack;
-  let prior = Array.from({ length: right.length + 1 }, (_, index) => index);
-  for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
-    const current = [leftIndex];
-    for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
-      const substitution = prior[rightIndex - 1] + (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1);
-      current[rightIndex] = Math.min((current[rightIndex - 1] ?? 0) + 1, (prior[rightIndex] ?? 0) + 1, substitution);
-      if (twoBack && leftIndex > 1 && rightIndex > 1 && left[leftIndex - 1] === right[rightIndex - 2] && left[leftIndex - 2] === right[rightIndex - 1]) {
-        current[rightIndex] = Math.min(current[rightIndex] ?? 0, (twoBack[rightIndex - 2] ?? 0) + 1);
-      }
-    }
-    twoBack = prior;
-    prior = current;
-  }
-  return prior[right.length] ?? right.length;
-}
 export {
   PUBLIC_COMMAND_CONTRACTS,
-  closest,
   publicCommandNames,
   publicCommandTokens,
   validatePublicInvocation

package/dist/commands/check.js

@@ -1,16 +1,16 @@
+import { detectAdapter, EXIT, usageOut, optionFlag, optionString, parseArgs, shellQuote } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { detectAdapter } from "../harness.js";
-import { EXIT, usageOut } from "./shared.js";
-import { optionFlag, optionString, parseArgs, shellQuote } from "./parse-args.js";
+import "../adapters/surface.js";
 const USAGE = "mm-harness check diff [--fix] [--target <repo>] [--adapter mobile|extension|core] [--base <ref>] [--profile fast|full] [--artifacts-dir <dir>] [--json]";
 const JS_TS_EXT_RE = /\.(?:c|m)?jsx?$|\.tsx?$/u;
 const FORMAT_EXT_RE = /\.(?:c|m)?jsx?$|\.tsx?$|\.json$|\.md$|\.css$|\.scss$|\.ya?ml$/u;
 const TEST_FILE_RE = /(?:^|[./_-])(?:test|spec)\.(?:c|m)?jsx?$|(?:^|[./_-])(?:test|spec)\.tsx?$/u;
 const ESLINT_SUPPRESSION_RE = /^\s*eslint-disable(?:-line|-next-line)?\b/u;
+const EXTENSION_LOCALE_RE = /^app\/_locales\//u;
 async function handleCheck(argv) {
-  const { positional, options } = parseArgs(argv, "check");
+  const { positional, options } = parseArgs(argv);
   const action = positional[0];
   const json = optionFlag(options, "json");
   const fix = optionFlag(options, "fix");
@@ -53,10 +53,12 @@ async function handleCheck(argv) {
   const mergeBase = resolveMergeBase(target, baseRef);
   const changedFiles = listChangedFiles(target, mergeBase, artifactsDir);
   const existingChangedFiles = changedFiles.filter((file) => fs.existsSync(path.join(target, file)));
+  const untracked = untrackedFiles(target);
   const suppressionCheck = checkNewEslintSuppressions({
     target,
     artifactsDir,
     mergeBase,
+    untracked,
     files: existingChangedFiles.filter((file) => JS_TS_EXT_RE.test(file))
   });
   const policyFailed = suppressionCheck.status === "fail";
@@ -98,6 +100,9 @@ async function handleCheck(argv) {
         files: existingChangedFiles.filter((file) => TEST_FILE_RE.test(file))
       })
     );
+    if (adapter === "extension") {
+      checks.push(...runExtensionDiffChecks({ target, artifactsDir, packageJson, files: changedFiles }));
+    }
     if (profile === "full") {
       checks.push(runTypecheck({ target, artifactsDir, packageJson }));
     } else {
@@ -188,10 +193,10 @@ function listChangedFiles(target, mergeBase, artifactsDir) {
     }
   };
   if (mergeBase) {
-    addLines(runCommand("git", ["diff", "--name-only", "--diff-filter=ACMR", `${mergeBase}...HEAD`], target).stdout);
+    addLines(runCommand("git", ["diff", "--name-only", "--no-renames", "--diff-filter=ACMRD", `${mergeBase}...HEAD`], target).stdout);
   }
-  addLines(runCommand("git", ["diff", "--name-only", "--diff-filter=ACMR", "HEAD"], target).stdout);
-  addLines(runCommand("git", ["diff", "--cached", "--name-only", "--diff-filter=ACMR"], target).stdout);
+  addLines(runCommand("git", ["diff", "--name-only", "--no-renames", "--diff-filter=ACMRD", "HEAD"], target).stdout);
+  addLines(runCommand("git", ["diff", "--cached", "--name-only", "--no-renames", "--diff-filter=ACMRD"], target).stdout);
   addLines(runCommand("git", ["ls-files", "--others", "--exclude-standard"], target).stdout);
   return [...files].filter((file) => !isUnderArtifactsDir(target, artifactsDir, file)).sort();
 }
@@ -210,9 +215,7 @@ function checkNewEslintSuppressions(input) {
   if (input.files.length === 0) {
     return { id, label, status: "skip", reason: "no changed JS/TS files" };
   }
-  const untracked = new Set(
-    runCommand("git", ["ls-files", "--others", "--exclude-standard"], input.target).stdout.split("\n").map((file) => normalizeRelativePath(file.trim())).filter(Boolean)
-  );
+  const { untracked } = input;
   const findings = [];
   const trackedFiles = input.files.filter((file) => !untracked.has(normalizeRelativePath(file)));
   if (trackedFiles.length > 0) {
@@ -241,6 +244,26 @@ function checkNewEslintSuppressions(input) {
     reason: `${findings.length} newly added eslint-disable directive(s)`
   } : { id, label, status: "pass", logPath };
 }
+function untrackedFiles(target) {
+  return new Set(
+    runCommand("git", ["ls-files", "--others", "--exclude-standard"], target).stdout.split("\n").map((file) => normalizeRelativePath(file.trim())).filter(Boolean)
+  );
+}
+function runExtensionDiffChecks(input) {
+  const scripts = input.packageJson?.scripts && typeof input.packageJson.scripts === "object" ? input.packageJson.scripts : {};
+  const results = [];
+  if (typeof scripts["verify-locales"] === "string") {
+    results.push(
+      input.files.some((file) => EXTENSION_LOCALE_RE.test(normalizeRelativePath(file))) ? runCheckCommand("verify-locales", "Locale strings", input.target, input.artifactsDir, "yarn", ["verify-locales", "--quiet"]) : { id: "verify-locales", label: "Locale strings", status: "skip", reason: "no app/_locales changes" }
+    );
+  }
+  if (typeof scripts["circular-deps:check"] === "string") {
+    results.push(
+      input.files.some((file) => JS_TS_EXT_RE.test(file)) ? runCheckCommand("circular-deps", "Circular dependencies", input.target, input.artifactsDir, "yarn", ["circular-deps:check"]) : { id: "circular-deps", label: "Circular dependencies", status: "skip", reason: "no JS/TS changes" }
+    );
+  }
+  return results;
+}
 function findAddedSuppressions(diff) {
   const findings = [];
   let file = "";

package/dist/commands/checklist.js

@@ -1,10 +1,10 @@
+import { EXIT } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { HANDOFF_INPUT } from "@farmslot/agent-runtime";
 import { enumerateChecklistCheckboxes, isTerminalWorkerSignalStatus } from "@farmslot/protocol";
-import { EXIT } from "./shared.js";
 const require2 = createRequire(import.meta.url);
 const MARK_SCRIPT = require2.resolve(
   "@farmslot/agent-runtime/scripts/mark-checklist-step.cjs"

package/dist/commands/completion-candidates.js

@@ -1,3 +1,4 @@
+import { EXIT, listRunnableRecipes, parseArgs, optionFlag, optionString, optionStrings, resolveAdapter, resolveLibrarySources, targetPath } from "@farmslot/recipe-cli/harness";
 import { resolveActionManifest } from "../manifest.js";
 import {
   invalidateCompletionCache,
@@ -5,19 +6,10 @@ import {
   writeCompletionCandidates
 } from "../completions-cache.js";
 import { importRecipeProtocol } from "../paths.js";
-import { EXIT } from "./shared.js";
-import {
-  parseArgs,
-  optionFlag,
-  optionString,
-  optionStrings,
-  resolveAdapter,
-  targetPath
-} from "./parse-args.js";
-import { listRunnableRecipes, resolveMetaMaskLibrarySources } from "./run-engine.js";
+import { metaMaskEngine } from "../engine.js";
 async function handleCompletionCandidates(argv) {
   const kind = argv[0];
-  const { options } = parseArgs(argv.slice(1), "completion-candidates");
+  const { options } = parseArgs(argv.slice(1));
   const json = optionFlag(options, "json");
   if (kind !== "actions" && kind !== "recipes") {
     console.error("completion-candidates requires <actions|recipes>.");
@@ -28,7 +20,7 @@ async function handleCompletionCandidates(argv) {
   let candidates;
   if (kind === "actions") {
     adapter = resolveAdapter(options).adapter;
-    const sources = await resolveMetaMaskLibrarySources(optionStrings(options, "library"));
+    const sources = await resolveLibrarySources(metaMaskEngine, optionStrings(options, "library"));
     const { manifest } = await resolveActionManifest(adapter, optionString(options, "actionManifest"), sources);
     const { getRecipeActionManifestActionNames } = await importRecipeProtocol();
     candidates = getRecipeActionManifestActionNames(manifest);
@@ -38,8 +30,8 @@ async function handleCompletionCandidates(argv) {
     const cacheKey = `recipes:${adapter}`;
     candidates = readFreshCandidates(target, cacheKey);
     if (!candidates) {
-      const sources = await resolveMetaMaskLibrarySources(optionStrings(options, "library")).catch(() => void 0);
-      candidates = sources ? (await listRunnableRecipes(adapter, sources)).map((recipe) => recipe.name) : [];
+      const sources = await resolveLibrarySources(metaMaskEngine, optionStrings(options, "library")).catch(() => void 0);
+      candidates = sources ? (await listRunnableRecipes(metaMaskEngine, adapter, sources)).map((recipe) => recipe.name) : [];
       writeCompletionCandidates(target, cacheKey, candidates);
     }
   }

package/dist/commands/config.js

@@ -1,3 +1,4 @@
+import { optionFlag, parseArgs, usageError } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
 import {
   configPath,
@@ -6,7 +7,6 @@ import {
   REVIEW_ADAPTERS,
   writeConfig
 } from "../review/knowledge.js";
-import { optionFlag, parseArgs, usageError } from "./parse-args.js";
 const USAGE = "Usage: mm-harness config <list|path|get <key>|set <key> <value>|unset <key>> [--json]\n  keys: libraries.<name>, references.<mobile|extension|core|terminal>, advisor.<enabled|provider|model|stages>";
 function parseKey(raw) {
   if (!raw) throw usageError(USAGE);
@@ -36,7 +36,7 @@ function setValue(config, key, value) {
   else config[key.section] = section;
 }
 async function handleConfig(argv) {
-  const parsed = parseArgs(argv, "config");
+  const parsed = parseArgs(argv);
   const json = optionFlag(parsed.options, "json");
   const [action, rawKey, rawValue] = parsed.positional;
   const expectedPositionals = { path: 1, list: 1, get: 2, set: 3, unset: 2 }[action ?? "list"];

package/dist/commands/core-readiness.js

@@ -1,12 +1,24 @@
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
+import { resolveLiveTsx } from "../live-tsx.js";
 const requireFromHarness = createRequire(import.meta.url);
 const CORE_RUNTIME_DEPS = ["immer"];
 function coreDependencyBlock(target) {
   const resolved = path.resolve(target);
   const nodeLinker = readYarnNodeLinker(resolved);
   const installAction = `cd ${shellQuote(resolved)} && yarn install --immutable`;
+  if (!resolveLiveTsx(resolved)) {
+    return process.env.TSX_BIN ? {
+      code: "CORE_TS_RUNNER_MISSING",
+      message: `TSX_BIN is ${process.env.TSX_BIN}, which is not an executable on PATH or relative to the checkout.`,
+      userAction: "unset TSX_BIN to use the tsx mm-harness ships, or point it at an existing tsx"
+    } : {
+      code: "CORE_TS_RUNNER_MISSING",
+      message: "no tsx runtime found for core actions (mm-harness ships one; this install is missing it).",
+      userAction: "reinstall mm-harness (npm install -g @deeeed/metamask-harness), or set TSX_BIN"
+    };
+  }
   if (nodeLinker === "pnp") {
     if (!fs.existsSync(path.join(resolved, ".pnp.cjs"))) {
       return {
@@ -24,13 +36,6 @@ function coreDependencyBlock(target) {
       userAction: installAction
     };
   }
-  if (!fs.existsSync(path.join(resolved, "node_modules/.bin/tsx"))) {
-    return {
-      code: "CORE_DEPS_INCOMPLETE",
-      message: "core dependencies are incomplete (node_modules/.bin/tsx is missing).",
-      userAction: installAction
-    };
-  }
   for (const dependency of CORE_RUNTIME_DEPS) {
     if (!canResolveFromTarget(dependency, resolved)) {
       return {

package/dist/commands/debug.js

@@ -1,14 +1,14 @@
+import { adapterDetectNext, EXIT, flag, parseFlags, resolveFlagsAdapter, spawnScript, targetOf, usageOut } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
 import { runnerDir } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
-import { ADAPTER_DETECT_NEXT, EXIT, flag, parseFlags, resolveAdapter, spawnScript, targetOf, usageOut } from "./shared.js";
 const DEBUG_BOOLEANS = /* @__PURE__ */ new Set(["worker", "devMenu", "json", "noOpen"]);
 async function handleDebug(argv) {
   const { options } = parseFlags(argv, DEBUG_BOOLEANS);
   const json = flag(options, "json");
   const target = targetOf(options);
-  const adapter = resolveAdapter(options, target);
-  if (!adapter) return usageOut(json, "debug", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
+  const adapter = resolveFlagsAdapter(options, target);
+  if (!adapter) return usageOut(json, "debug", `could not detect the MetaMask repo type for ${target}`, adapterDetectNext());
   const surface = getAdapterSurface(adapter);
   if (surface.headless) return usageOut(json, "debug", `${adapter} is headless; there is no debug console.`, surface.hints.relaunch);
   surface.resolveSlotPorts(target);

package/dist/commands/device-target.js

@@ -1,12 +1,12 @@
+import { optionString, shellQuoteArg, targetPath } from "@farmslot/recipe-cli/harness";
 import { execFileSync } from "node:child_process";
-import { resolveMobileToolPath } from "../../library/actions/mobile/platform/tool-paths.mjs";
+import { resolveMobileToolPath } from "@farmslot/adapter-rn";
 import {
   findAvailableIosSimulatorById,
   listConnectedDevices
-} from "../devices.js";
+} from "@farmslot/adapter-rn";
 import { getAdapterSurface } from "../adapters/surface.js";
 import { persistExplicitDevicePin } from "../runtime-context.js";
-import { optionString, shellQuoteArg, targetPath } from "./parse-args.js";
 const DEVICE_SELECT_HINT = "Pass --device <name|udid|serial> to select one target. Do not shut down other connected devices to force selection.";
 function normalizeDeviceName(value) {
   return value.replace(/_/gu, " ").trim();
@@ -27,7 +27,7 @@ function resolveAndroidModel(serial) {
 }
 function setAndroidDeviceEnv(id, fallbackName) {
   process.env.PLATFORM = "android";
-  process.env.MM_HARNESS_EXPLICIT_PLATFORM = "android";
+  process.env.RECIPE_RN_EXPLICIT_PLATFORM = "android";
   process.env.ADB_SERIAL = id;
   process.env.ANDROID_SERIAL = id;
   process.env.ANDROID_DEVICE = id;
@@ -39,7 +39,7 @@ function setAndroidDeviceEnv(id, fallbackName) {
 }
 function setIosDeviceEnv(id, fallbackName) {
   process.env.PLATFORM = "ios";
-  process.env.MM_HARNESS_EXPLICIT_PLATFORM = "ios";
+  process.env.RECIPE_RN_EXPLICIT_PLATFORM = "ios";
   process.env.IOS_SIMULATOR = fallbackName?.trim() || id;
   process.env.SIM_UDID = id;
   process.env.ADB_SERIAL = "";

package/dist/commands/doctor.js

@@ -2,28 +2,16 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { featureFlagReport } from "../feature-flags.js";
-import { color } from "../cli-color.js";
+import { color, acquireCheckoutLock, detectAdapter, resolveRuntimeContextPath, ensureOverlay, newHealState, recipeRunning, adapterDetectNext, checkoutBusyOut, EXIT, usageOut, actionManifestPathOption, applyRuntimeDirOption, optionFlag, optionString, shellQuote, targetPath } from "@farmslot/recipe-cli/harness";
 import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
 import { createDoctorReport, fixtureSummary, requiredDoctorCheckSummary } from "../doctor.js";
-import { detectAdapter, resolveRuntimeContextPath } from "../harness.js";
 import { assertAdapter, runnerDir } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
 import { loadActionManifest, validateManifest } from "../manifest.js";
-import { ensureOverlay, newHealState, recipeRunning } from "../heal-bounds.js";
 import { applyDeviceTargeting } from "./device-target.js";
 import { farmslotReadyIndicator } from "./farmslot-ready.js";
 import { updateStatus } from "./update.js";
 import { ensureRuntimeContext } from "../runtime-context.js";
-import { acquireCheckoutLock } from "../checkout-lock.js";
-import { ADAPTER_DETECT_NEXT, checkoutBusyOut, EXIT, usageOut } from "./shared.js";
-import {
-  actionManifestPathOption,
-  applyRuntimeDirOption,
-  optionFlag,
-  optionString,
-  shellQuote,
-  targetPath
-} from "./parse-args.js";
 function applyDoctorRuntimePorts(options) {
   const cdpPort = optionString(options, "cdpPort");
   if (cdpPort) {
@@ -48,7 +36,7 @@ async function handleDoctor({ options }) {
   const explicitAdapter = optionString(options, "adapter") ?? (platformOption === "ios" || platformOption === "android" ? "mobile" : platformOption);
   const adapter = explicitAdapter ?? detectAdapter(target);
   if (!adapter) {
-    return usageOut(json, "doctor", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
+    return usageOut(json, "doctor", `could not detect the MetaMask repo type for ${target}`, adapterDetectNext());
   }
   assertAdapter(adapter);
   const { readiness } = getAdapterSurface(adapter);

package/dist/commands/domain.js

@@ -1,3 +1,4 @@
+import { optionFlag, optionString, parseArgs, targetPath, usageError } from "@farmslot/recipe-cli/harness";
 import {
   changedFiles,
   classifyDomain,
@@ -5,10 +6,9 @@ import {
   discoverLibraries,
   readConfig
 } from "../review/knowledge.js";
-import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
 import { adapterFromOptions } from "./review.js";
 async function handleDomain(argv) {
-  const parsed = parseArgs(argv, "domain");
+  const parsed = parseArgs(argv);
   const target = targetPath(parsed.options);
   const json = optionFlag(parsed.options, "json");
   const declared = optionString(parsed.options, "domain") ?? process.env.MM_HARNESS_DOMAIN;

package/dist/commands/ensure-ready.js

@@ -1,11 +1,5 @@
+import { adapterOption, optionFlag, optionString, parsePort, targetPath } from "@farmslot/recipe-cli/harness";
 import { ensureExtensionReady } from "../adapters/extension/ensure-ready.js";
-import {
-  adapterOption,
-  optionFlag,
-  optionString,
-  parsePort,
-  targetPath
-} from "./parse-args.js";
 async function handleEnsureReady({ options }) {
   const adapter = adapterOption(options);
   if (adapter !== "extension") throw new Error("ensure-ready currently applies to the extension adapter.");

package/dist/commands/fixtures.js

@@ -4,9 +4,8 @@ import path from "node:path";
 import { runnerDir, walletFixturePath } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
 import { fixtureFileSummary, fixtureSummary } from "../doctor.js";
-import { acquireCheckoutLock } from "../checkout-lock.js";
+import { acquireCheckoutLock, adapterDetectNext, checkoutBusyOut, EXIT, flag, parseFlags, resolveFlagsAdapter, scriptOverride, spawnScript, spawnScriptStreaming, str, targetOf, usageOut } from "@farmslot/recipe-cli/harness";
 import { applyDeviceTargeting } from "./device-target.js";
-import { ADAPTER_DETECT_NEXT, checkoutBusyOut, EXIT, flag, parseFlags, resolveAdapter, scriptOverride, spawnScript, spawnScriptStreaming, str, targetOf, usageOut } from "./shared.js";
 import { FeatureFlagSpecError, fixtureFeatureFlags, parseRemoteFlagSpec } from "../feature-flags.js";
 const FIXTURES_BOOLEANS = /* @__PURE__ */ new Set(["dev", "force", "json"]);
 const FIXTURE_STREAM_TIMEOUT_MS = 12e4;
@@ -39,9 +38,9 @@ function fixturesStatus(options) {
     );
   }
   const target = targetOf(options);
-  const adapter = resolveAdapter(options, target);
+  const adapter = resolveFlagsAdapter(options, target);
   if (!adapter) {
-    return usageOut(json, "fixtures", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
+    return usageOut(json, "fixtures", `could not detect the MetaMask repo type for ${target}`, adapterDetectNext());
   }
   const canonical = walletFixturePath(target);
   const summary = fixtureSummary(target, adapter);
@@ -115,9 +114,9 @@ async function handleFixturesLocked(argv) {
     );
   }
   const target = targetOf(options);
-  const adapter = resolveAdapter(options, target);
+  const adapter = resolveFlagsAdapter(options, target);
   if (!adapter) {
-    return usageOut(json, "fixtures", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
+    return usageOut(json, "fixtures", `could not detect the MetaMask repo type for ${target}`, adapterDetectNext());
   }
   const surface = getAdapterSurface(adapter);
   surface.resolveSlotPorts(target);

package/dist/commands/help.js

@@ -1,9 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { color } from "../cli-color.js";
-import { detectAdapter } from "../harness.js";
-import { optionString, parseArgs, targetPath } from "./parse-args.js";
+import { color, detectAdapter, optionString, parseArgs, targetPath } from "@farmslot/recipe-cli/harness";
 import { handleHelpReview } from "./review.js";
+import "../adapters/surface.js";
 const UNSCOPED_NEXT = "cd into a MetaMask checkout or pass --adapter <mobile|extension|core|terminal>";
 function validHelpLine(value) {
   return typeof value === "string" || Boolean(value && typeof value.text === "string" && Array.isArray(value.adapters) && value.adapters.length > 0 && value.adapters.every((adapter) => ["mobile", "extension", "core", "terminal"].includes(adapter)));
@@ -70,7 +69,7 @@ function renderRecipeHelp(topic, harnessVersion, adapter) {
 `;
 }
 function handleHelp(argv, context) {
-  const parsed = parseArgs(argv, "help");
+  const parsed = parseArgs(argv);
   if (parsed.positional[0] === "review") return handleHelpReview(argv, context.harnessVersion);
   const target = targetPath(parsed.options);
   const adapter = optionString(parsed.options, "adapter") ?? detectAdapter(target) ?? "unscoped";