@deeeed/metamask-harness 0.79.0 → 0.81.0

package/dist/console-classifier.js

@@ -0,0 +1,19 @@
+import {
+  allowlistMatch,
+  classifyConsoleRecord,
+  consoleRecords,
+  libraryRootsFromEnv,
+  loadConsoleAllowlist,
+  messageSignature
+} from "../library/actions/shared/console-findings.mjs";
+const consoleClassifier = {
+  records: (text) => consoleRecords(text),
+  classify: (record) => classifyConsoleRecord(record),
+  signature: (message) => messageSignature(message),
+  loadAllowlist: (libraryRoots) => loadConsoleAllowlist([...libraryRoots]),
+  match: (event, allowlist) => allowlistMatch(event, allowlist),
+  libraryRoots: () => libraryRootsFromEnv()
+};
+export {
+  consoleClassifier
+};

package/dist/doctor.js

@@ -1,11 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { color } from "./cli-color.js";
+import { color, harnessExecutable, recipeHarnessRoot, recipeRuntimeDir, readRuntimeContextField, resolveRuntimeContextPath } from "@farmslot/recipe-cli/harness";
 import { normalizeFeatureFlagRecord } from "./feature-flags.js";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { readRuntimeContextField, resolveRuntimeContextPath } from "./harness.js";
 import { isPin } from "./harness-pin.js";
-import { harnessExecutable, readJson, recipeHarnessRoot, recipeRuntimeDir, runnerDir } from "./paths.js";
+import { readJson, runnerDir } from "./paths.js";
 function requiredDoctorCheckSummary(checks) {
   const required = checks.filter((check) => check.required);
   const failed = required.filter((check) => check.status === "fail").map((check) => check.id);

package/dist/engine.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { resolveAdapter } from "@farmslot/recipe-cli/harness";
+import { getAdapterSurface } from "./adapters/surface.js";
+import { consoleClassifier } from "./console-classifier.js";
+import {
+  authorizeTrustedMutationPlan,
+  fixturePolicyMutationBase,
+  fundingOptionsFromCli,
+  isFixturePolicyBase,
+  loadTrustedMutationBase
+} from "./funding-execution-context.js";
+import { resolveActionManifest, validateManifest } from "./manifest.js";
+import { LIBRARY_ACTION_NAMESPACE, runnerDir } from "./paths.js";
+import { metaMaskActionExecutionCapabilities } from "./recipe-security.js";
+const metaMaskEngine = {
+  bundledLibrary: {
+    name: "metamask",
+    root: path.resolve(runnerDir, "library"),
+    actionNamespace: LIBRARY_ACTION_NAMESPACE
+  },
+  resolveActionManifest,
+  validateManifest,
+  actionCapabilities: metaMaskActionExecutionCapabilities,
+  createRunner: async (adapter, manifest, { trustedMutation, ...options }) => {
+    const { createMetaMaskRunner } = await import("./runner.js");
+    return trustedMutation === NO_PLAN_MUTATION ? createMetaMaskRunner(adapter, manifest, { ...options, suppressLibraryResolutionLogs: true }) : createMetaMaskRunner(adapter, manifest, { ...options, trustedMutation });
+  },
+  // Funding files from the run's command line, bound to the run's plan. Without
+  // them, a platform whose actions take a trusted mutation (the Extension) runs a
+  // plan with external mutations in the fixture-policy lane, where each action
+  // applies the shared order policy; any other plan runs without one.
+  trustedMutation: {
+    load: async ({ cli, ...run }) => await loadTrustedMutationBase({ ...fundingOptionsFromCli(cli), ...run }) ?? (takesTrustedMutation(cli) ? fixturePolicyMutationBase({ artifactsDir: run.artifactsDir, rootRecipe: run.rootRecipe }) : void 0),
+    authorize: async (base, plan) => {
+      if (!base || base === NO_PLAN_MUTATION) return void 0;
+      if (isFixturePolicyBase(base) && !plan.nodes.some((node) => node.capabilities.includes("external-mutation"))) {
+        return NO_PLAN_MUTATION;
+      }
+      return authorizeTrustedMutationPlan(base, plan);
+    }
+  },
+  console: consoleClassifier,
+  runnerIncludes: ["src", "adapters", "library", "bin", "dist", "package.json"]
+};
+const NO_PLAN_MUTATION = /* @__PURE__ */ Symbol("no plan mutation");
+function takesTrustedMutation(cli) {
+  let adapter;
+  try {
+    ({ adapter } = resolveAdapter(cli));
+  } catch {
+    return false;
+  }
+  return getAdapterSurface(adapter).actions.trustedMutation === true;
+}
+export {
+  metaMaskEngine
+};

package/dist/funding-execution-context.js

@@ -1,10 +1,10 @@
+import { optionString, recipeRuntimeDir } from "@farmslot/recipe-cli/harness";
 import { createHash } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { chmod, lstat, mkdir, open, readFile, readdir, realpath } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { digestRecipeDocument } from "@farmslot/protocol";
-import { recipeRuntimeDir } from "./paths.js";
 const SHA256 = /^[a-f0-9]{64}$/u;
 const INTEGER = /^(0|[1-9][0-9]{0,39})$/u;
 const IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
@@ -35,6 +35,7 @@ const CLAIM_DIFF_FIELDS = [
   "operationCounts"
 ];
 const trustedActionContexts = /* @__PURE__ */ new WeakSet();
+const fixturePolicySources = /* @__PURE__ */ new WeakMap();
 const fundingSources = /* @__PURE__ */ new WeakMap();
 const CURRENT_FUNDING_REGISTRY_SHA256 = "d4416e0e8a812a0e2f1798ae6f901a5820f7ee0b9783cfa5d515d0c7863ea80e";
 const PREVIOUS_FUNDING_REGISTRY_SHA256 = "7e79ee2a5f7bdde0a5548208cb2eab55881575cc7d826ee5f7acdbf15d49609c";
@@ -141,7 +142,70 @@ async function loadTrustedMutationBase(options) {
   });
   return trusted;
 }
+const FIXTURE_POLICY_LANE = "fixture-policy";
+const fixturePolicyMarker = (field) => sha256(`${FIXTURE_POLICY_LANE}:${field}`);
+function fixturePolicyMutationBase(options) {
+  if (!path.isAbsolute(options.artifactsDir)) {
+    throw new Error("Runner artifactsDir must be absolute before a mutation context is created.");
+  }
+  const rootRecipeSha256 = normalizeRecipeDigest(digestRecipeDocument(options.rootRecipe));
+  const base = deepFreeze({
+    runId: sha256(canonical({ lane: FIXTURE_POLICY_LANE, artifactsDir: options.artifactsDir, rootRecipeSha256 })),
+    rootRecipeSha256,
+    requestSha256: fixturePolicyMarker("request"),
+    preflightSha256: fixturePolicyMarker("preflight"),
+    releaseProofSha256: fixturePolicyMarker("release-proof"),
+    balanceProofSha256: fixturePolicyMarker("balance-proof"),
+    fundingRequirementsSha256: fixturePolicyMarker("requirements"),
+    runtimeArtifactSha256: fixturePolicyMarker("runtime-artifact"),
+    runtimeTreeSha256: fixturePolicyMarker("runtime-tree"),
+    registrySha256: fixturePolicyMarker("registry"),
+    profileId: FIXTURE_POLICY_LANE,
+    domain: "perps",
+    client: "extension",
+    proofLane: FIXTURE_POLICY_LANE,
+    targetId: FIXTURE_POLICY_LANE,
+    subjectDigest: fixturePolicyMarker("subject"),
+    selectedIdentitySha256: "",
+    runtimeSessionId: "",
+    cdpPort: 0,
+    cdpTargetId: "",
+    extensionOrigin: "",
+    operations: [],
+    budgets: [],
+    requirements: []
+  });
+  fixturePolicySources.set(base, { artifactsDir: options.artifactsDir });
+  return base;
+}
+function isFixturePolicyBase(base) {
+  return base?.proofLane === FIXTURE_POLICY_LANE;
+}
+async function authorizeFixturePolicyPlan(base, plan) {
+  const source = fixturePolicySources.get(base);
+  if (!source) throw new Error("Fixture-policy plan authorization requires the runner-created context.");
+  const executionPlanSha256 = normalizeRecipeDigest(plan.digest);
+  await mkdir(source.artifactsDir, { recursive: true, mode: 448 });
+  const artifactsDir = await realpath(source.artifactsDir);
+  const artifactsIdentitySha256 = await directoryIdentity(artifactsDir);
+  const executionLedgerRoot = path.join(artifactsDir, "mutation-ledger");
+  await ensurePrivateDirectory(artifactsDir, executionLedgerRoot);
+  const runId = sha256(canonical({
+    lane: FIXTURE_POLICY_LANE,
+    rootRecipeSha256: base.rootRecipeSha256,
+    executionPlanSha256,
+    artifactsIdentitySha256
+  }));
+  const authorized = deepFreeze({ ...base, runId, executionPlanSha256, artifactsIdentitySha256 });
+  fixturePolicySources.set(authorized, {
+    ...source,
+    executionLedgerRoot,
+    executionClaimSha256: sha256(canonical({ kind: "fixture-policy-execution-claim", runId, executionPlanSha256 }))
+  });
+  return authorized;
+}
 async function authorizeTrustedMutationPlan(base, plan, testIo = {}) {
+  if (isFixturePolicyBase(base)) return authorizeFixturePolicyPlan(base, plan);
   const source = fundingSources.get(base);
   if (!source) throw new Error("Funding plan authorization requires the original runner-verified context.");
   const executionPlanSha256 = normalizeRecipeDigest(plan.digest);
@@ -228,6 +292,20 @@ async function authorizeTrustedMutationPlan(base, plan, testIo = {}) {
   return authorized;
 }
 async function trustedMutationForAction(base, recipe, selectedIdentitySha256) {
+  if (isFixturePolicyBase(base)) {
+    const source2 = fixturePolicySources.get(base);
+    if (!source2?.executionLedgerRoot || !source2.executionClaimSha256) {
+      throw new Error("External mutation requires an authorized run-owned execution ledger.");
+    }
+    const trusted2 = deepFreeze({
+      ...base,
+      recipeSha256: normalizeRecipeDigest(digestRecipeDocument(recipe)),
+      executionLedgerRoot: source2.executionLedgerRoot,
+      executionClaimSha256: source2.executionClaimSha256
+    });
+    trustedActionContexts.add(trusted2);
+    return trusted2;
+  }
   if (!selectedIdentitySha256 || !SHA256.test(selectedIdentitySha256)) {
     throw new Error(
       "External mutation requires a successful same-run metamask.wallet.import selected identity proof. Next: run metamask.wallet.import before the mutation node."
@@ -255,6 +333,18 @@ async function trustedMutationForAction(base, recipe, selectedIdentitySha256) {
   trustedActionContexts.add(trusted);
   return trusted;
 }
+function fundingOptionsFromCli(options) {
+  return {
+    fundingRequest: optionString(options, "fundingRequest"),
+    fundingPreflight: optionString(options, "fundingPreflight"),
+    fundingReleaseProof: optionString(options, "fundingReleaseProof"),
+    fundingBalanceProof: optionString(options, "fundingBalanceProof")
+  };
+}
+function trustedMutationContextExtras(context) {
+  const trusted = context.trustedMutation;
+  return trusted ? { trustedMutation: serializeTrustedMutationContext(trusted) } : void 0;
+}
 function serializeTrustedMutationContext(value) {
   if (!isRecord(value) || !trustedActionContexts.has(value)) {
     throw new Error("Live adapter refused an untrusted mutation context.");
@@ -1430,9 +1520,14 @@ function deepFreeze(value) {
   return value;
 }
 export {
+  FIXTURE_POLICY_LANE,
   authorizeTrustedMutationPlan,
+  fixturePolicyMutationBase,
+  fundingOptionsFromCli,
+  isFixturePolicyBase,
   loadTrustedMutationBase,
   selectedIdentityFromWalletImport,
   serializeTrustedMutationContext,
+  trustedMutationContextExtras,
   trustedMutationForAction
 };

package/dist/host.js

@@ -0,0 +1,32 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { configureHarnessAdapters, configureHarnessHost } from "@farmslot/recipe-cli/harness";
+import { adapterRegistry } from "./adapters/registry.js";
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+configureHarnessHost({
+  name: "mm-harness",
+  product: "MetaMask",
+  envPrefix: "MM_HARNESS",
+  recipeEnvPrefix: "METAMASK_RECIPE",
+  packageName: "@deeeed/metamask-harness",
+  packageRoot,
+  bin: "bin/mm-harness",
+  journaledCommands: [
+    "prepare",
+    "call",
+    "check",
+    "checklist",
+    "cleanup",
+    "doctor",
+    "fixtures",
+    "install",
+    "launch",
+    "runtime-launch",
+    "provision",
+    "recipe-quality",
+    "run",
+    "stop",
+    "verify"
+  ]
+});
+configureHarnessAdapters(adapterRegistry);

package/dist/index.js

@@ -1,3 +1,4 @@
+import "./host.js";
 import { createDoctorReport } from "./doctor.js";
 import { loadActionManifest, validateManifest } from "./manifest.js";
 import { createMetaMaskExtensionRunner, createMetaMaskMobileRunner, createMetaMaskRunner } from "./runner.js";
@@ -5,13 +6,9 @@ import {
   extensionIdPath,
   importRecipeHarnessRuntimeBrowserExtension,
   importRecipeHarnessRuntimeCdp,
-  recipeHarnessPath,
   walletFixturePath
 } from "./paths.js";
-import { captureActiveRecipeRecordingSnapshot } from "./run-recording.js";
-import { validateRuntimeProof } from "./runtime-proof.js";
 export {
-  captureActiveRecipeRecordingSnapshot,
   createDoctorReport,
   createMetaMaskExtensionRunner,
   createMetaMaskMobileRunner,
@@ -20,8 +17,6 @@ export {
   importRecipeHarnessRuntimeBrowserExtension,
   importRecipeHarnessRuntimeCdp,
   loadActionManifest,
-  recipeHarnessPath,
   validateManifest,
-  validateRuntimeProof,
   walletFixturePath
 };

package/dist/live-tsx.js

@@ -0,0 +1,49 @@
+import { accessSync, constants, existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+const requireFromHarness = createRequire(import.meta.url);
+function harnessTsxBin() {
+  try {
+    const manifest = requireFromHarness.resolve("tsx/package.json");
+    const { bin } = JSON.parse(readFileSync(manifest, "utf8"));
+    const relative = typeof bin === "string" ? bin : bin?.tsx;
+    return relative ? path.join(path.dirname(manifest), relative) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function liveTsxCandidates() {
+  const bin = harnessTsxBin();
+  return bin ? [bin] : [];
+}
+function isExecutable(file) {
+  try {
+    accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveOverride(override, projectRoot) {
+  if (!override.includes("/")) {
+    return (process.env.PATH ?? "").split(path.delimiter).map((dir) => path.join(path.resolve(projectRoot, dir || "."), override)).find(isExecutable);
+  }
+  const bin = path.resolve(projectRoot, override);
+  return isExecutable(bin) ? bin : void 0;
+}
+function resolveLiveTsx(projectRoot) {
+  const override = process.env.TSX_BIN;
+  if (override) {
+    const bin = resolveOverride(override, path.resolve(projectRoot));
+    return bin ? { bin, source: "TSX_BIN" } : null;
+  }
+  const target = path.join(path.resolve(projectRoot), "node_modules/.bin/tsx");
+  if (existsSync(target)) return { bin: target, source: "target" };
+  const harness = harnessTsxBin();
+  return harness && existsSync(harness) ? { bin: harness, source: "harness" } : null;
+}
+export {
+  harnessTsxBin,
+  liveTsxCandidates,
+  resolveLiveTsx
+};

package/dist/mm-harness-cli.js

@@ -1,19 +1,17 @@
+import "./host.js";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
-import { color } from "./cli-color.js";
-import { withCommandJournal } from "./command-journal.js";
-import { JsonStreamWriter } from "./json-stream.js";
+import { color, withCommandJournal, JsonStreamWriter, detectAdapter, handleCallHelp } from "@farmslot/recipe-cli/harness";
 import { handleUpdate, maybeNudge } from "./commands/update.js";
 import { handlePin } from "./commands/pin.js";
-import { handleCallHelp } from "./commands/call.js";
+import { metaMaskEngine } from "./engine.js";
 import { handleHelp } from "./commands/help.js";
 import { handleTutorial } from "./commands/tutorial.js";
 import { handleSetupBase } from "./commands/setup-base.js";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { detectAdapter } from "./harness.js";
 import { configPath, hydrateLibraryPathEnv, readConfig } from "./review/knowledge.js";
 import {
   PUBLIC_COMMAND_CONTRACTS,
@@ -1233,6 +1231,6 @@ if (hasPassthroughHelp(rawArgv)) {
 }
 if (isCallActionHelp(rawArgv)) {
   const callHelp = REAL.find((command) => command.name === "call")?.helpText ?? "";
-  process.exit(await handleCallHelp(rawArgv.slice(1), callHelp));
+  process.exit(await handleCallHelp(rawArgv.slice(1), callHelp, { catalog: metaMaskEngine }));
 }
 await program.parseAsync(process.argv);

package/dist/paths.js

@@ -1,43 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { recipeRuntimeDir, recipeRuntimePath } from "@farmslot/recipe-cli/harness";
 import { adapterRegistry } from "./adapters/registry.js";
 const runnerDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const pathDefaults = readPathDefaults();
-const DEFAULT_RECIPE_RUNTIME_DIR = pathDefaults.recipeRuntimeDir;
-const DEFAULT_RECIPE_HARNESS_ROOT = pathDefaults.recipeHarnessRoot;
 const PREPARE_PROGRESS_ARTIFACT = "prepare/progress.json";
-function recipeRuntimeDir() {
-  return validateRelativeRecipePath("RECIPE_RUNTIME_DIR", process.env.RECIPE_RUNTIME_DIR || DEFAULT_RECIPE_RUNTIME_DIR);
-}
-function recipeHarnessRoot() {
-  return validateRelativeRecipePath("RECIPE_HARNESS_ROOT", process.env.RECIPE_HARNESS_ROOT || DEFAULT_RECIPE_HARNESS_ROOT);
-}
-function harnessExecutable() {
-  return path.resolve(process.env.MM_HARNESS_EXECUTABLE ?? path.join(runnerDir, "bin/mm-harness"));
-}
-function readPathDefaults() {
-  const defaultsPath = path.join(runnerDir, "adapters/shared/path-defaults.json");
-  const parsed = JSON.parse(fs.readFileSync(defaultsPath, "utf8"));
-  return {
-    recipeRuntimeDir: validateRelativeRecipePath("recipeRuntimeDir", parsed.recipeRuntimeDir || ""),
-    recipeHarnessRoot: validateRelativeRecipePath("recipeHarnessRoot", parsed.recipeHarnessRoot || "")
-  };
-}
-function validateRelativeRecipePath(name, value) {
-  if (!value || path.isAbsolute(value)) throw new Error(`${name} must be a non-empty relative path: ${value}`);
-  if (!/^[A-Za-z0-9._/-]+$/u.test(value)) throw new Error(`${name} contains unsupported characters: ${value}`);
-  for (const part of value.split("/")) {
-    if (!part || part === "." || part === "..") throw new Error(`${name} contains unsafe path component: ${value}`);
-  }
-  return value;
-}
-function recipeRuntimePath(projectRoot, ...segments) {
-  return path.join(projectRoot, recipeRuntimeDir(), ...segments);
-}
-function recipeHarnessPath(projectRoot, ...segments) {
-  return path.join(projectRoot, recipeHarnessRoot(), ...segments);
-}
 function walletFixturePath(projectRoot) {
   return recipeRuntimePath(projectRoot, "wallet-fixture.json");
 }
@@ -51,42 +18,51 @@ function recipeWatchLogCandidates() {
   ];
 }
 function resolveLocalProtocolRoot() {
-  const candidates = [
-    process.env.METAMASK_RUNNER_PROTOCOL_ROOT,
-    readConfiguredProtocolRoot(),
-    findProtocolRoot(runnerDir),
-    findProtocolRoot(process.cwd())
-  ].filter(Boolean);
-  const root = candidates[0];
+  const root = process.env.METAMASK_RUNNER_PROTOCOL_ROOT || readConfiguredProtocolRoot();
   return root ? path.resolve(root) : void 0;
 }
-function resolveRequiredLocalProtocolRoot(reason) {
-  const root = resolveLocalProtocolRoot();
-  if (!root) {
-    throw new Error(
-      `${reason} requires a local protocol/runtime checkout. Set METAMASK_RUNNER_PROTOCOL_ROOT or create .farmslot-root for this dev-only path.`
-    );
+function resolveFarmslotPoolDir(starts = [runnerDir, process.cwd()]) {
+  const configured = resolveLocalProtocolRoot();
+  if (configured) return path.join(configured, "pool");
+  for (const start of starts) {
+    const pool = findPoolDir(start);
+    if (pool) return pool;
   }
-  return root;
+  return void 0;
 }
+const LIBRARY_ACTION_NAMESPACE = "metamask";
 function readConfiguredProtocolRoot() {
   const configPath = path.join(runnerDir, ".farmslot-root");
   if (!fs.existsSync(configPath)) return void 0;
   const value = fs.readFileSync(configPath, "utf8").trim();
   return value || void 0;
 }
-function findProtocolRoot(start) {
+function findPoolDir(start) {
   let dir = path.resolve(start);
   while (dir !== path.dirname(dir)) {
-    if (isProtocolRoot(dir)) return dir;
-    const sibling = path.join(dir, "farmslot");
-    if (isProtocolRoot(sibling)) return sibling;
+    for (const root of [dir, path.join(dir, "farmslot")]) {
+      const pool = path.join(root, "pool");
+      if (holdsSlotPool(pool)) return pool;
+    }
     dir = path.dirname(dir);
   }
   return void 0;
 }
-function isProtocolRoot(candidate) {
-  return fs.existsSync(path.join(candidate, "packages/recipe-runner/package.json")) && fs.existsSync(path.join(candidate, "packages/protocol/package.json"));
+function holdsSlotPool(candidate) {
+  let names;
+  try {
+    names = fs.readdirSync(candidate);
+  } catch {
+    return false;
+  }
+  return names.some((name) => {
+    if (!name.endsWith(".json") || name.includes(".bak")) return false;
+    try {
+      return Array.isArray(JSON.parse(fs.readFileSync(path.join(candidate, name), "utf8"))?.slots);
+    } catch {
+      return false;
+    }
+  });
 }
 function assertAdapter(adapter) {
   const ids = adapterRegistry.list();
@@ -140,8 +116,8 @@ async function importRecipeHarnessRuntimeReactNativeBridge() {
 }
 async function importMetaMaskNativeUiProvider() {
   return importProtocolPackage(
-    "@farmslot/expo-recipe",
-    "packages/expo-recipe/src/index.ts"
+    "@farmslot/adapter-rn",
+    "packages/adapter-rn/src/index.ts"
   );
 }
 async function importRecipeRunnerCli() {
@@ -176,12 +152,10 @@ function isMissingPackageError(error, packageName) {
   return (code === "ERR_MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED") && error.message.includes(packageName);
 }
 export {
-  DEFAULT_RECIPE_HARNESS_ROOT,
-  DEFAULT_RECIPE_RUNTIME_DIR,
+  LIBRARY_ACTION_NAMESPACE,
   PREPARE_PROGRESS_ARTIFACT,
   assertAdapter,
   extensionIdPath,
-  harnessExecutable,
   importMetaMaskNativeUiProvider,
   importRecipeHarness,
   importRecipeHarnessAppLifecycle,
@@ -192,14 +166,10 @@ export {
   importRecipeRunnerCli,
   manifestPath,
   readJson,
-  recipeHarnessPath,
-  recipeHarnessRoot,
   recipePath,
-  recipeRuntimeDir,
-  recipeRuntimePath,
   recipeWatchLogCandidates,
+  resolveFarmslotPoolDir,
   resolveLocalProtocolRoot,
-  resolveRequiredLocalProtocolRoot,
   runnerDir,
   walletFixturePath
 };

package/dist/performance-observation.js

@@ -4,20 +4,18 @@ import { gzip } from "node:zlib";
 import { getAdapterSurface } from "./adapters/surface.js";
 import { createExtensionPerformanceBackend } from "./adapters/extension/performance-observer.js";
 import { TRACE_KINDS } from "./adapters/performance/cdp-trace.js";
-import { summarizeFrames } from "./adapters/mobile/frame-metrics.js";
+import { summarizeFrames } from "@farmslot/adapter-rn";
 import { summarizeJavaScriptTasks } from "./adapters/performance/js-task-metrics.js";
 import {
   indexArtifactManifest,
   readContainedJsonArtifact,
   writeContainedArtifact
-} from "./artifact-files.js";
+} from "@farmslot/recipe-cli/harness";
 const sessions = /* @__PURE__ */ new Map();
 const DEFAULT_MAX_DURATION_MS = 5 * 60 * 1e3;
 const MAX_DURATION_MS = 60 * 60 * 1e3;
 const gzipAsync = promisify(gzip);
-function startRunPerformanceObservation(adapter, target, artifactsDir, env, ports = {}) {
-  const observer = getAdapterSurface(adapter).observation?.performance;
-  if (!observer) return void 0;
+function startRunPerformanceObservation(observer, { target, artifactsDir, env, ports }) {
   const key = path.resolve(artifactsDir);
   const session = {
     observer,

package/dist/progress.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { parseArgs } from "node:util";
-import { color } from "./cli-color.js";
+import { color } from "@farmslot/recipe-cli/harness";
 function shouldEmitJson(explicit) {
   if (explicit) return true;
   const env = process.env.RECIPE_PROGRESS_JSON;

package/dist/recipe-assistance-context.js

@@ -1,13 +1,10 @@
 import fs from "node:fs";
 import { createHash } from "node:crypto";
 import { loadRecipeLibraries, resolveRecipeDependencies, rootResolutionRef } from "@farmslot/recipe-runner";
-import { isSensitiveKey } from "./command-journal.js";
+import { isSensitiveKey, CliError, describeManifestActions, isRecord, optionStrings, EXIT, resolveLibrarySources, validateRunRecipeStatic } from "@farmslot/recipe-cli/harness";
 import { resolveActionManifest } from "./manifest.js";
-import { describeManifestActions } from "./commands/manifest.js";
 import { recipeComposition } from "@farmslot/recipe-cli";
-import { resolveMetaMaskLibrarySources, validateRunRecipeStatic } from "./commands/run-engine.js";
-import { CliError, isRecord, optionStrings } from "./commands/parse-args.js";
-import { EXIT } from "./commands/shared.js";
+import { metaMaskEngine } from "./engine.js";
 import { MAX_ADVICE_STATE_BYTES } from "./recipe-assistance-rubric.js";
 function digest(value) {
   return createHash("sha256").update(value).digest("hex");
@@ -48,7 +45,7 @@ async function buildAdviceContext(input) {
   const task = readInput(input.task);
   if (!input.recipe) throw new CliError("Advice requires a recipe. Next: use recipe-quality plan before authoring.", EXIT.usage);
   readInput(input.recipe);
-  const validated = await validateRunRecipeStatic(input.recipe, input.adapter, input.options ?? {}, input.params);
+  const validated = await validateRunRecipeStatic(metaMaskEngine, input.recipe, input.adapter, input.options ?? {}, input.params);
   if (validated.usageError || !validated.schemaValid || !isRecord(validated.recipe)) {
     const detail = validated.usageError?.message ?? validated.findings.map((finding) => finding.message).join("; ");
     throw new CliError(`Recipe is not statically valid: ${detail}. Next: run mm-harness run ${input.recipe} --plan --adapter ${input.adapter}.`, EXIT.validation);
@@ -58,7 +55,7 @@ async function buildAdviceContext(input) {
   const dependencies = resolveRecipeDependencies({ rootRef: rootResolutionRef(rootDigest), root: validated.recipe, rootSource: { kind: "recipe-file", trust: "unknown", digest: rootDigest }, recipes: library.recipes });
   const composition = recipeComposition(validated.recipe, dependencies.recipes);
   const { manifest, actionSources } = await resolveActionManifest(input.adapter, void 0, validated.librarySources);
-  const catalog = describeManifestActions(manifest, actionSources);
+  const catalog = describeManifestActions(metaMaskEngine, manifest, actionSources);
   const used = new Set(composition.actions);
   const actions = catalog.filter((action) => used.has(action.name)).map(({ name, description, schema, capabilities }) => ({ name, description, schema, capabilities }));
   const domains = new Set(composition.actions.map((name) => name.split(".").slice(0, -1).join(".")));
@@ -110,12 +107,12 @@ async function buildPlanningContext(input) {
     throw new CliError("Planning requires 1\u201320 non-empty acceptanceCriteria strings. Next: supply a focused JSON task.", EXIT.validation);
   }
   const criteria = task.acceptanceCriteria;
-  const sources = await resolveMetaMaskLibrarySources(optionStrings(input.options ?? {}, "library"));
+  const sources = await resolveLibrarySources(metaMaskEngine, optionStrings(input.options ?? {}, "library"));
   const library = await loadRecipeLibraries(sources ?? [], { adapter: input.adapter });
   const { manifest, actionSources } = await resolveActionManifest(input.adapter, void 0, sources);
   const candidates = [
     ...[...library.recipes.values()].map((recipe) => ({ id: `recipe:${recipe.ref}`, kind: "recipe", ref: recipe.ref, description: typeof recipe.document.description === "string" ? recipe.document.description : "", parameters: recipe.document.paramsSchema, source: recipe.source, provenance: recipe.provenance, shadows: recipe.shadows })),
-    ...describeManifestActions(manifest, actionSources).map((action) => ({ id: `action:${action.name}`, kind: "action", ref: action.name, description: action.description, parameters: action.schema, capabilities: action.capabilities, source: action.source, sourceTier: action.sourceTier, shadows: action.shadows }))
+    ...describeManifestActions(metaMaskEngine, manifest, actionSources).map((action) => ({ id: `action:${action.name}`, kind: "action", ref: action.name, description: action.description, parameters: action.schema, capabilities: action.capabilities, source: action.source, sourceTier: action.sourceTier, shadows: action.shadows }))
   ];
   const terms = new Set(criteria.join(" ").toLowerCase().match(/[a-z][a-z_]{3,}/gu) ?? []);
   const score = (candidate) => [...new Set(`${candidate.ref} ${candidate.description}`.toLowerCase().match(/[a-z][a-z_]{3,}/gu) ?? [])].filter((word) => terms.has(word)).length;