@deeeed/metamask-harness 0.78.0 → 0.80.0

package/dist/adapters/terminal/run.js

@@ -1,3 +1,5 @@
+import { isRecord } from "@farmslot/recipe-cli/harness";
+import { verifyOwnedCollectorControl } from "../console-capture.js";
 import { devicePlatformFromEnv } from "../performance/device-platform.js";
 import {
   ensureTerminalConsoleCapture,
@@ -11,10 +13,31 @@ const terminalDiagnostics = {
     start: (projectRoot) => ensureTerminalConsoleCapture(projectRoot),
     files: (projectRoot) => terminalCaptureFiles(projectRoot),
     cdpPort: () => terminalCdpPort(),
-    verifyControl: (capture) => verifyTerminalConsoleControl(capture)
+    verifyControl: (capture) => verifyOwnedCollectorControl(capture, () => verifyTerminalConsoleControl(capture))
   },
-  walletLog: (projectRoot) => terminalRuntimeFile(projectRoot, "wallet-requests.jsonl")
+  requestLog: {
+    path: (projectRoot) => terminalRuntimeFile(projectRoot, "wallet-requests.jsonl"),
+    findings: (lines) => walletRequestFindings(lines)
+  }
 };
+function walletRequestFindings(lines) {
+  const findings = [];
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isRecord(entry)) continue;
+    let text = null;
+    if (entry.kind === "blocked-mainnet" && entry.probe !== true) text = `blocked-mainnet: ${String(entry.transport ?? "request")} to ${String(entry.url ?? "?")}`;
+    else if (entry.kind === "refused-mainnet") text = `refused-mainnet: ${String(entry.method ?? "?")} (${String(entry.reason ?? "?")})`;
+    else if (entry.kind === "unattributed") text = `unattributed wallet ${entry.binding === "request" ? "request" : "log entry"}${typeof entry.method === "string" ? ` (${entry.method})` : ""}`;
+    if (text) findings.push({ level: "error", source: "wallet", text });
+  }
+  return findings;
+}
 const terminalObservation = {
   network: {
     backend: async (_target, env, artifactsDir) => (await import("../../network-observation.js")).createExtensionNetworkBackend(env, artifactsDir)

package/dist/adapters/terminal/surface.js

@@ -1,5 +1,6 @@
+import { shellQuote } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
-import { shellQuote } from "../../commands/parse-args.js";
+import { defineAdapter } from "@farmslot/adapter-sdk";
 import fs from "node:fs";
 import { TERMINAL_CONSOLE_FILES, terminalRuntimeFile } from "./console-capture.js";
 import { stopTerminalBrowserSync } from "./stop.js";
@@ -8,6 +9,7 @@ import { terminalActions } from "./actions.js";
 import { terminalHarness, terminalRuntimeContext } from "./overlay.js";
 import { terminalReadiness } from "./readiness.js";
 import { terminalDiagnostics, terminalObservation } from "./run.js";
+import { checkoutHas, checkoutHasDir } from "../checkout-files.js";
 function portFromEnv(...names) {
   for (const name of names) {
     const raw = process.env[name];
@@ -29,8 +31,9 @@ function terminalSignerFor(target) {
   }
   return process.env.TERMINAL_SIGNER || "extension";
 }
-const terminalSurface = {
-  adapter: "terminal",
+const terminalSurface = defineAdapter({
+  id: "terminal",
+  sdkVersion: 1,
   headless: false,
   resolveSlotPorts() {
   },
@@ -96,6 +99,11 @@ const terminalSurface = {
   appLogSource(target) {
     return { label: "app-console", path: terminalRuntimeFile(target, TERMINAL_CONSOLE_FILES.app) };
   },
+  detect: {
+    remote: (url) => url.includes("va-mmcx-terminal"),
+    files: (target) => checkoutHasDir(target, "src/features/perpetuals") && ["next.config.ts", "next.config.mjs", "next.config.js"].some((file) => checkoutHas(target, file))
+  },
+  flags: { launch: ["freshProfile", "headless", "headful"] },
   hints: {
     launch: "mm-harness launch --adapter terminal --cdp-port <port> --watcher-port <app port>",
     relaunch: "mm-harness launch --adapter terminal --fresh-profile",
@@ -116,7 +124,7 @@ const terminalSurface = {
   },
   diagnostics: terminalDiagnostics,
   observation: terminalObservation
-};
+});
 adapterRegistry.register(terminalSurface);
 export {
   terminalAppPort,

package/dist/adapters.js

@@ -1,9 +1,10 @@
 import http from "node:http";
 import { createHash } from "node:crypto";
 import { compatibilityMode, fixtureSummary, repoShape } from "./doctor.js";
-import {
-  runLiveAdapterScript
-} from "./live-adapter-contract.js";
+import { runLiveAdapterScript } from "@farmslot/recipe-cli/harness";
+import { trustedMutationContextExtras } from "./funding-execution-context.js";
+import { LIBRARY_ACTION_NAMESPACE } from "./paths.js";
+import { liveTsxCandidates } from "./live-tsx.js";
 import { resolveWalletImportCredentials, validateWalletImportOptions } from "../library/actions/shared/wallet/import-source.mjs";
 import { isRecord, traceText } from "./action-values.js";
 import { getAdapterSurface } from "./adapters/surface.js";
@@ -109,9 +110,12 @@ async function runLiveFirst(platform, action, node, context, forceLive = false,
   const live = await runLiveAdapterScript({
     platform,
     action,
+    namespace: LIBRARY_ACTION_NAMESPACE,
     node,
     context,
-    prepared: preparedLiveAdapters?.get(action)
+    prepared: preparedLiveAdapters?.get(action),
+    contextExtras: trustedMutationContextExtras(context),
+    tsxCandidates: liveTsxCandidates()
   });
   if (!live) return null;
   const liveResult = isRecord(live.result) ? live.result : { result: live.result };

package/dist/advisor-policy.js

@@ -1,5 +1,5 @@
+import { optionString, usageError } from "@farmslot/recipe-cli/harness";
 import { assessmentProvider } from "./assessment-providers.js";
-import { optionString, usageError } from "./commands/parse-args.js";
 import { configPath, parseAdvisorSettings, readConfig } from "./review/knowledge.js";
 function resolveAdvisorPolicy(options, env = process.env, config) {
   const saved = (config ?? readConfig(configPath(env))).advisor ?? {};

package/dist/checkout-view.js

@@ -1,8 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { color } from "./cli-color.js";
+import { color, recipeRuntimeDir } from "@farmslot/recipe-cli/harness";
 import { renderRuntimeContext, runtimeContextSummary } from "./doctor.js";
-import { recipeRuntimeDir } from "./paths.js";
 import {
   configPath,
   declaredLibraryPathEnv,

package/dist/cli.js

@@ -1,5 +1,17 @@
+import "./host.js";
+import "./adapters/surface.js";
+import {
+  detectAdapter,
+  handleHarness,
+  handleLast,
+  handleLaunch,
+  handleReload,
+  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 { handleDoctor } from "./commands/doctor.js";
 import { handleProvision } from "./commands/provision.js";
@@ -11,12 +23,9 @@ 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,12 +34,17 @@ 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 COMMANDS = {
   actions: handleActions,
   doctor: handleDoctor,
@@ -98,35 +112,34 @@ 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 === "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 +150,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/call.js

@@ -3,9 +3,7 @@ import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { resolveActionManifest } from "../manifest.js";
 import { importRecipeProtocol } from "../paths.js";
-import { conciseFailureForHuman, recipeRunning } from "../heal-bounds.js";
-import { color } from "../cli-color.js";
-import { checkoutBusyOut, EXIT, usageOut } from "./shared.js";
+import { color, acquireCheckoutLock, isSensitiveKey, recordCommandEvidence, redactStructuredValue, conciseFailureForHuman, recipeRunning, checkoutBusyOut, EXIT, usageOut, parseArgs, isRecord, optionFlag, optionString, optionStrings, resolveAdapter, shellQuote, usageError } from "@farmslot/recipe-cli/harness";
 import {
   actionLibraryContextArgs,
   actionExampleCommand,
@@ -13,17 +11,6 @@ import {
   resolveActionCapabilityMatrix
 } from "./manifest.js";
 import { fuzzyResolveActions, resolveActionCapabilityRefusal } from "@farmslot/recipe-cli";
-import {
-  parseArgs,
-  isRecord,
-  optionFlag,
-  optionString,
-  optionStrings,
-  resolveAdapter,
-  runtimeOptionsFromCli,
-  shellQuote,
-  usageError
-} from "./parse-args.js";
 import { getAdapterSurface } from "../adapters/surface.js";
 import { handleListExecutables } from "./list-executables.js";
 import { applyDeviceTargeting } from "./device-target.js";
@@ -38,21 +25,17 @@ import {
   synthesizeOneNodeRecipe,
   validateRecipeAdapterAware
 } from "./run-engine.js";
-import { acquireCheckoutLock } from "../checkout-lock.js";
-import { formatRunDiagnosticsForHuman, readRunDiagnosticsDocument } from "../run-diagnostics.js";
 import {
   startRunNetworkObservation
 } from "../network-observation.js";
 import {
   startRunPerformanceObservation
 } from "../performance-observation.js";
-import { recipeTrustFailure } from "../recipe-security.js";
-import { isSensitiveKey, recordCommandEvidence, redactStructuredValue } from "../command-journal.js";
-import { closest } from "../command-contract.js";
-import { ProvenanceDriftError } from "../execution-provenance.js";
+import { closest, formatRunDiagnosticsForHuman, ProvenanceDriftError, readRunDiagnosticsDocument, recipeRunOptionsFromCli, recipeTrustFailure } from "@farmslot/recipe-cli/harness";
+import { fundingOptionsFromCli } from "../funding-execution-context.js";
 async function handleCall(argv) {
   if (argv.includes("--list")) {
-    const { options: options2 } = parseArgs(argv, "call");
+    const { options: options2 } = parseArgs(argv);
     return handleListExecutables("call", options2);
   }
   if (argv.length > 0 && argv[0].startsWith("--")) {
@@ -61,7 +44,7 @@ async function handleCall(argv) {
     return EXIT.usage;
   }
   const { action: shortName, args, rest } = parseCallArgs(argv);
-  const { options } = parseArgs(rest, "call");
+  const { options } = parseArgs(rest);
   if (["domain", "source", "sort"].some((name) => optionString(options, name) !== void 0)) {
     throw usageError("--domain, --source, and --sort require call --list.");
   }
@@ -214,7 +197,10 @@ async function handleCall(argv) {
   }
   const artifactsDir = optionString(options, "artifactsDir") ?? defaultCallArtifactsDir(target, resolvedAction);
   recordCommandEvidence(artifactsDir);
-  const requestedRuntimeOptions = runtimeOptionsFromCli(options);
+  const requestedRuntimeOptions = {
+    ...recipeRunOptionsFromCli(adapter, options),
+    ...fundingOptionsFromCli(options)
+  };
   const inheritedSource = process.env.FARMSLOT_RECIPE_SOURCE_TRUST || process.env.FARMSLOT_RECIPE_SOURCE_KIND || process.env.FARMSLOT_RECIPE_SOURCE_NAME || process.env.FARMSLOT_RECIPE_SOURCE_DIGEST;
   let networkObservation;
   let performanceObservation;
@@ -509,7 +495,7 @@ function redactCallValue(value, key = "") {
 }
 async function handleCallHelp(argv, genericHelp) {
   const { action: shortName, rest } = parseCallArgs(argv.filter((arg) => arg !== "--help" && arg !== "-h"));
-  const { options } = parseArgs(rest, "call");
+  const { options } = parseArgs(rest);
   let adapter;
   let manifest;
   let actionSources = /* @__PURE__ */ new Map();

package/dist/commands/check.js

@@ -1,16 +1,15 @@
+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;
 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");

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, parseArgs, optionFlag, optionString, optionStrings, resolveAdapter, 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";
 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>.");

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.");