@deeeed/metamask-harness 0.17.4 → 0.18.0

package/dist/manifest.js

@@ -1,5 +1,10 @@
+import fs from "node:fs";
 import path from "node:path";
 import { manifestPath, readJson, importRecipeProtocol } from "./paths.js";
+import {
+  actionSourceIntegrity,
+  metaMaskActionExecutionCapabilities
+} from "./recipe-security.js";
 function loadMetaMaskMobileActionManifest() {
   return asActionManifest(readJson(manifestPath("mobile")));
 }
@@ -15,6 +20,130 @@ function loadActionManifest(adapter, overridePath) {
   if (adapter === "core") return loadMetaMaskCoreActionManifest();
   return loadMetaMaskExtensionActionManifest();
 }
+async function resolveActionManifest(adapter, overridePath, librarySources, taskActionRoot) {
+  if (overridePath) {
+    const manifestPath2 = path.resolve(overridePath);
+    const implementationRoot = path.resolve(
+      taskActionRoot ?? defaultImplementationRoot(manifestPath2)
+    );
+    const manifest = withMetaMaskExecutionCapabilities(loadActionManifest(adapter, manifestPath2));
+    await validateManifest(manifest);
+    const integrity = await actionSourceIntegrity(manifestPath2, "task", implementationRoot);
+    return {
+      manifest,
+      actionSources: describeManifestSources(manifest, {
+        name: "task",
+        tier: "task",
+        manifestPath: manifestPath2,
+        implementationRoot,
+        trust: "unknown",
+        ...integrity
+      })
+    };
+  }
+  const canonicalPath = manifestPath(adapter);
+  const sources = librarySources?.length ? librarySources : [{ name: "metamask", root: path.dirname(path.dirname(canonicalPath)) }];
+  const manifests = [];
+  for (const source of sources) {
+    const file = path.join(source.root, "manifests", `${adapter}.action-manifest.json`);
+    if (!fs.existsSync(file)) continue;
+    const manifest = asActionManifest(readJson(file));
+    await validateManifest(manifest);
+    manifests.push({ source, file, manifest });
+  }
+  if (!manifests.some((entry) => path.resolve(entry.file) === path.resolve(canonicalPath))) {
+    const manifest = loadActionManifest(adapter);
+    await validateManifest(manifest);
+    manifests.push({ source: { name: "metamask", root: path.dirname(path.dirname(canonicalPath)) }, file: canonicalPath, manifest });
+  }
+  const canonical = manifests.find((entry) => entry.source.name === "metamask") ?? manifests.at(-1);
+  if (!canonical) throw new Error(`No ${adapter} action manifest could be resolved.`);
+  const base = cloneManifest(canonical.manifest);
+  const official = new Set(stringArray(recordOf(base).supported_official_actions));
+  const custom = /* @__PURE__ */ new Map();
+  const customMetadata = /* @__PURE__ */ new Map();
+  const bindings = /* @__PURE__ */ new Map();
+  const canonicalImplementationRoot = path.join(canonical.source.root, "actions");
+  const canonicalIntegrity = await actionSourceIntegrity(
+    canonical.file,
+    "canonical",
+    canonicalImplementationRoot
+  );
+  const actionSources = describeManifestSources(base, {
+    name: "metamask",
+    tier: "canonical",
+    manifestPath: canonical.file,
+    implementationRoot: canonicalImplementationRoot,
+    trust: "trusted",
+    ...canonicalIntegrity
+  });
+  for (const entry of manifests) {
+    const sourceName = entry.source.name ?? path.basename(entry.source.root);
+    const tier = sourceName === "metamask" ? "canonical" : sourceName === "personal" ? "personal" : "team";
+    const implementationRoot = path.join(entry.source.root, "actions");
+    const integrity = await actionSourceIntegrity(entry.file, tier, implementationRoot);
+    const sourceInfo = {
+      name: sourceName,
+      tier,
+      manifestPath: entry.file,
+      implementationRoot,
+      trust: entry.source.provenance?.trust ?? (tier === "canonical" ? "trusted" : "unknown"),
+      ...integrity
+    };
+    const manifestRecord = recordOf(entry.manifest);
+    const metadata = recordOf(manifestRecord.action_metadata);
+    for (const action of customActions(manifestRecord.custom_actions)) {
+      if (official.has(action.name)) {
+        throw new Error(`Library action ${action.name} from ${entry.file} conflicts with an official action.`);
+      }
+      if (custom.has(action.name)) {
+        const existing = actionSources.get(action.name);
+        if (existing && existing.name !== sourceName) {
+          existing.shadows = [...existing.shadows ?? [], sourceName];
+        }
+        continue;
+      }
+      custom.set(action.name, action.value);
+      customMetadata.set(action.name, metadata[action.name]);
+      actionSources.set(action.name, { ...sourceInfo });
+    }
+    for (const binding of objectArray(manifestRecord.native_bindings)) {
+      const action = typeof binding.action === "string" ? binding.action : void 0;
+      if (action && !bindings.has(action)) bindings.set(action, binding);
+    }
+  }
+  const baseRecord = recordOf(base);
+  baseRecord.custom_actions = [...custom.values()];
+  const baseMetadata = recordOf(baseRecord.action_metadata);
+  for (const [name, metadata] of customMetadata) {
+    if (metadata !== void 0) baseMetadata[name] = metadata;
+  }
+  baseRecord.action_metadata = baseMetadata;
+  baseRecord.native_bindings = [...bindings.values()];
+  return { manifest: withMetaMaskExecutionCapabilities(base), actionSources };
+}
+function defaultImplementationRoot(selectedManifestPath) {
+  const manifestDirectory = path.dirname(selectedManifestPath);
+  return path.basename(manifestDirectory) === "manifests" ? path.join(path.dirname(manifestDirectory), "actions") : path.join(manifestDirectory, "actions");
+}
+function withMetaMaskExecutionCapabilities(manifest) {
+  const result = cloneManifest(manifest);
+  const record = recordOf(result);
+  if (!Array.isArray(record.custom_actions)) return result;
+  record.custom_actions = record.custom_actions.map((entry) => {
+    const name = typeof entry === "string" ? entry : recordOf(entry).name;
+    if (typeof name !== "string") return entry;
+    const capabilities = metaMaskActionExecutionCapabilities(name);
+    if (capabilities.length === 0) return entry;
+    const declaredValue = typeof entry === "string" ? void 0 : recordOf(entry).execution_capabilities;
+    const declared = Array.isArray(declaredValue) ? declaredValue.filter(
+      (capability) => typeof capability === "string"
+    ) : [];
+    const executionCapabilities = [.../* @__PURE__ */ new Set([...declared, ...capabilities])];
+    return typeof entry === "string" ? { name, execution_capabilities: executionCapabilities } : { ...recordOf(entry), execution_capabilities: executionCapabilities };
+  });
+  return result;
+}
 async function validateManifest(manifest) {
   const { validateRecipeActionManifestDocument } = await importRecipeProtocol();
   const result = validateRecipeActionManifestDocument(manifest);
@@ -28,10 +157,41 @@ async function validateManifest(manifest) {
 function asActionManifest(value) {
   return value;
 }
+function cloneManifest(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function recordOf(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function objectArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)) : [];
+}
+function customActions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string") return [{ name: entry, value: entry }];
+    const record = recordOf(entry);
+    return typeof record.name === "string" ? [{ name: record.name, value: entry }] : [];
+  });
+}
+function describeManifestSources(manifest, customSource) {
+  const record = recordOf(manifest);
+  const sources = /* @__PURE__ */ new Map();
+  for (const name of stringArray(record.supported_official_actions)) {
+    sources.set(name, { name: "official", tier: "official", manifestPath: customSource.manifestPath });
+  }
+  for (const action of customActions(record.custom_actions)) sources.set(action.name, { ...customSource });
+  return sources;
+}
 export {
   loadActionManifest,
   loadMetaMaskCoreActionManifest,
   loadMetaMaskExtensionActionManifest,
   loadMetaMaskMobileActionManifest,
-  validateManifest
+  resolveActionManifest,
+  validateManifest,
+  withMetaMaskExecutionCapabilities
 };

package/dist/mm-harness-cli.js

@@ -134,7 +134,7 @@ Example:
   Actions differ per adapter \u2014 list this checkout's with:
   mm-harness actions.
 
-  --list                             List everything invocable for the adapter (actions + flows); no <action> needed
+  --list                             List actions accepted by call for this adapter; no <action> needed
   --arg k=v                          Action field value (repeatable; equivalent to key=value shorthand)
   --device <udid|serial|name>        Mobile only: target this device (env: IOS_SIMULATOR / ADB_SERIAL). Without it, >1 connected mobile device fails fast and lists them.
   --adapter <mobile|extension|core>  Target adapter (auto-detected inside a checkout)
@@ -154,7 +154,7 @@ Example (real actions; run mm-harness actions for this checkout's full set):
     name: "flows",
     summary: "Browse reusable parameterized action sequences.",
     example: "mm-harness flows",
-    helpText: `mm-harness flows [flags]
+    helpText: `mm-harness flows [list|describe <ref>|promote] [flags]
 
   Browse reusable parameterized action sequences. Flows resolve by precedence
   (personal > team > canonical); the highest-tier copy wins and shadows lower ones.
@@ -165,7 +165,9 @@ Example (real actions; run mm-harness actions for this checkout's full set):
   --json                             Machine-readable output
 
 Example:
-  mm-harness flows`
+  mm-harness flows
+  mm-harness flows describe perps.clean_market_testnet
+  mm-harness flows describe perps.clean_market_testnet --json`
   },
   {
     name: "run",
@@ -176,12 +178,15 @@ Example:
   Validate and execute a complete proof, then write summary, trace, diagnostics,
   and artifacts. A recipe may use actions directly or call reusable flows.
 
-  --list                             List everything invocable for the adapter (actions + flows); no <recipe> needed
+  --list                             List complete recipes accepted by run for this adapter; no <recipe> needed
+  --describe                         Show one recipe's metadata, declared inputs, composed actions/flows, and next command
   --plan                             Validate + print execution plan, touching nothing. Exit 5 if invalid.
   --device <udid|serial|name>        Mobile only: target this device (env: IOS_SIMULATOR / ADB_SERIAL). Without it, >1 connected mobile device fails fast and lists them.
+  --cdp-port <port>                  Extension CDP port (env: CDP_PORT / RECIPE_CDP_PORT)
+  --launch-existing-dist             Extension: reuse/launch the existing dist without rebuilding
   --adapter <mobile|extension|core>  Target adapter (auto-detected inside a checkout)
   --target <path>                    Checkout path (default: cwd)
-  --artifacts-dir <dir>              Where to write evidence (required unless --plan)
+  --artifacts-dir <dir>              Override evidence output (default: active task/artifacts, otherwise a checkout-local temp/recipe/runs/<run>)
   --action-manifest <path>           Override the action manifest
   --library <name=path>              Add/override a recipe-library source (repeatable)
   --heal <off|infra-only|auto>       Healing policy (default: infra-only); auto-ensures the overlay
@@ -190,8 +195,9 @@ Example:
   --record-video=full-run            Record a video of the run
 
 Example:
+  mm-harness run wallet.smoke --describe
   mm-harness run recipe.json --plan --adapter mobile
-  mm-harness run recipe.json --adapter extension --artifacts-dir ./out`
+  mm-harness run recipe.json --adapter extension`
   },
   {
     name: "last",
@@ -644,7 +650,7 @@ function groupedHelp() {
   lines.push("DEV/PROD \u2014 the global npm install is prod; set MM_HARNESS_BIN to a dev checkout to override:");
   lines.push("  MM_HARNESS_BIN=/path/to/checkout/bin/mm-harness   # unset = the installed/global bin");
   lines.push("");
-  lines.push("See README.md for the workflow and docs/CHEATSHEET.md for examples.");
+  lines.push("See README.md for the workflow and docs/RECIPES.md for proof authoring.");
   return `${lines.join("\n")}
 `;
 }

package/dist/recipe-security.js

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import path from "node:path";
+const READ_ONLY_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
+  "metamask.wallet.fixture_status",
+  "metamask.wallet.list_accounts",
+  "metamask.wallet.read_state",
+  "metamask.perps.read_positions",
+  "metamask.perps.read_orders",
+  "metamask.perps.read_account",
+  "metamask.perps.assert_positions",
+  "metamask.perps.assert_orders"
+]);
+const APP_MUTATION_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
+  "metamask.wallet.setup",
+  "metamask.wallet.ensure_unlocked",
+  "metamask.wallet.select_account",
+  "metamask.perps.close_positions",
+  "metamask.perps.close_orders",
+  "metamask.perps.place_order",
+  "metamask.perps.ensure_positions",
+  "metamask.perps.ensure_orders",
+  "metamask.perps.start_state",
+  "metamask.perps.teardown_state"
+]);
+const EXTERNAL_MUTATION_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
+  "metamask.perps.close_positions",
+  "metamask.perps.close_orders",
+  "metamask.perps.place_order",
+  "metamask.perps.ensure_positions",
+  "metamask.perps.ensure_orders",
+  "metamask.perps.start_state",
+  "metamask.perps.teardown_state"
+]);
+function metaMaskActionExecutionCapabilities(action) {
+  const capabilities = [];
+  if (READ_ONLY_CUSTOM_ACTIONS.has(action)) capabilities.push("host-read-export");
+  if (APP_MUTATION_CUSTOM_ACTIONS.has(action)) capabilities.push("app-mutation");
+  if (EXTERNAL_MUTATION_CUSTOM_ACTIONS.has(action)) capabilities.push("external-mutation");
+  return capabilities.length > 0 ? capabilities : ["arbitrary-code"];
+}
+async function actionSourceIntegrity(manifestPath, tier, implementationRoot) {
+  const manifestRoot = path.dirname(manifestPath);
+  const actionRoot = implementationRoot ?? (tier === "task" ? path.join(manifestRoot, "actions") : path.join(path.dirname(manifestRoot), "actions"));
+  const resolveDigest = () => digestSourceInputs([
+    { label: "manifest", root: manifestRoot, inputs: [path.basename(manifestPath)] },
+    { label: "implementation", root: actionRoot, inputs: ["."], optional: true }
+  ]);
+  return { digest: await resolveDigest(), resolveDigest };
+}
+async function digestSourceInputs(sources) {
+  const entries = [];
+  for (const source of sources) {
+    let rootReal;
+    try {
+      rootReal = await realpath(source.root);
+    } catch (error) {
+      if (source.optional && isMissing(error)) continue;
+      throw error;
+    }
+    const visitedDirectories = /* @__PURE__ */ new Set();
+    for (const relativeInput of source.inputs) {
+      await collectDigestEntries(
+        source.root,
+        rootReal,
+        relativeInput,
+        source.label,
+        entries,
+        visitedDirectories
+      );
+    }
+  }
+  entries.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  const hash = createHash("sha256");
+  for (const entry of entries) {
+    hash.update(`${entry.name}\0${entry.bytes.length}\0`);
+    hash.update(entry.bytes);
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+async function collectDigestEntries(root, rootReal, relativePath, label, entries, visitedDirectories) {
+  const lexicalPath = path.join(root, relativePath);
+  const info = await lstat(lexicalPath);
+  const resolvedPath = await realpath(lexicalPath);
+  if (!isPathWithin(rootReal, resolvedPath)) {
+    throw new Error(`Action source ${relativePath} resolves outside its selected source root.`);
+  }
+  const resolvedInfo = info.isSymbolicLink() ? await lstat(resolvedPath) : info;
+  if (resolvedInfo.isDirectory()) {
+    if (visitedDirectories.has(resolvedPath)) return;
+    visitedDirectories.add(resolvedPath);
+    for (const entry of await readdir(resolvedPath, { withFileTypes: true })) {
+      await collectDigestEntries(
+        root,
+        rootReal,
+        path.join(relativePath, entry.name),
+        label,
+        entries,
+        visitedDirectories
+      );
+    }
+    return;
+  }
+  if (!resolvedInfo.isFile()) return;
+  entries.push({
+    name: `${label}/${relativePath.split(path.sep).join("/")}`,
+    bytes: await readFile(resolvedPath)
+  });
+}
+function isPathWithin(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function isMissing(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+function explicitRecipeTrustOptions(values) {
+  const { sourceTrust, sourceKind, sourceName, sourceDigest, approvalDigest } = values;
+  const source = sourceTrust || sourceKind || sourceName || sourceDigest ? {
+    trust: sourceTrust ?? "unknown",
+    kind: sourceKind ?? "recipe-file",
+    ...sourceName ? { name: sourceName } : {},
+    ...sourceDigest ? { digest: sourceDigest } : {}
+  } : void 0;
+  return {
+    ...source ? { source } : {},
+    ...approvalDigest ? { approval: { planDigest: approvalDigest } } : {}
+  };
+}
+function recipeTrustFailure(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const value = error;
+  if (typeof value.code !== "string" || !value.code.startsWith("RECIPE_") || typeof value.message !== "string" || typeof value.userAction !== "string") return void 0;
+  const failure = value.failure && typeof value.failure === "object" ? value.failure : void 0;
+  const blocked = Array.isArray(failure?.blocked) ? failure.blocked.flatMap((entry) => {
+    if (!entry || typeof entry !== "object") return [];
+    const node = entry;
+    if (typeof node.nodeId !== "string" || typeof node.action !== "string" || !Array.isArray(node.capabilities)) return [];
+    const origin = node.origin && typeof node.origin === "object" ? node.origin : void 0;
+    const adapterOrigin = node.adapterOrigin && typeof node.adapterOrigin === "object" ? node.adapterOrigin : void 0;
+    const implementation = adapterOrigin ? {
+      ...typeof adapterOrigin.kind === "string" ? { kind: adapterOrigin.kind } : {},
+      ...typeof adapterOrigin.trust === "string" ? { trust: adapterOrigin.trust } : {},
+      ...typeof adapterOrigin.digest === "string" ? { digest: adapterOrigin.digest } : {}
+    } : void 0;
+    return [{
+      nodeId: node.nodeId,
+      action: node.action,
+      capabilities: node.capabilities.filter(
+        (item) => typeof item === "string"
+      ),
+      source: typeof origin?.kind === "string" ? origin.kind : "unknown",
+      ...implementation && Object.keys(implementation).length > 0 ? { implementation } : {}
+    }];
+  }) : void 0;
+  const recipeDigest = typeof failure?.recipeDigest === "string" ? failure.recipeDigest : void 0;
+  const userAction = recipeDigest && (value.code === "RECIPE_TRUST_REQUIRED" || value.code === "RECIPE_APPROVAL_MISMATCH") && !value.userAction.includes("execution environment") ? `${value.userAction}; rerun with the same project root, artifact directory, and execution environment` : value.userAction;
+  return {
+    code: value.code,
+    message: value.message,
+    userAction,
+    ...failure ? {
+      details: {
+        // Farmslot reports the approved execution plan digest as
+        // recipeDigest in failures; approval input names it planDigest.
+        ...recipeDigest ? { recipeDigest } : {},
+        ...typeof failure.trust === "string" ? { trust: failure.trust } : {},
+        ...blocked?.length ? { blocked } : {}
+      }
+    } : {}
+  };
+}
+export {
+  actionSourceIntegrity,
+  explicitRecipeTrustOptions,
+  metaMaskActionExecutionCapabilities,
+  recipeTrustFailure
+};

package/dist/runner.js

@@ -6,6 +6,9 @@ import {
 } from "./adapters/mobile/source-freshness.js";
 import { resolveMetaMaskMobileLifecycleTarget } from "./app-lifecycle.js";
 import { loadMetaMaskExtensionActionManifest, loadMetaMaskMobileActionManifest } from "./manifest.js";
+import {
+  prepareLiveAdapterScript
+} from "./live-adapter-contract.js";
 import { createMetaMaskRecordingTargetProvider } from "./recording-target.js";
 import { importRecipeHarness, importRecipeHarnessAppLifecycle, importRecipeHarnessRuntimeCdp, importRecipeHarnessRuntimeReactNativeBridge, runnerDir } from "./paths.js";
 async function createMetaMaskMobileRunner(options = {}) {
@@ -29,10 +32,17 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
   const { createCdpWebUiTransport } = await importRecipeHarnessRuntimeCdp();
   const { createReactNativeBridgeUiTransport } = await importRecipeHarnessRuntimeReactNativeBridge();
   const { createAppLifecycleAdapters } = await importRecipeHarnessAppLifecycle();
-  const actions = [
-    ...actionManifest.supported_official_actions,
-    ...(actionManifest.custom_actions ?? []).map((entry) => entry.name)
-  ];
+  const customActions = (actionManifest.custom_actions ?? []).map(
+    (entry) => typeof entry === "string" ? entry : entry.name
+  );
+  const actionSources = options.actionSources ? new Map([...options.actionSources].map(([action, source]) => [action, { ...source }])) : void 0;
+  const preparedLiveAdapters = await prepareLiveAdapterImplementations(
+    adapter,
+    customActions,
+    actionSources,
+    options.trustTaskActions
+  );
+  const actions = [...actionManifest.supported_official_actions, ...customActions];
   const declaredActions = new Set(actions);
   const core = createStandardCoreAdapters({ actions });
   const projectOwnedOfficialActions = /* @__PURE__ */ new Set(["app.status", "app.lifecycle"]);
@@ -41,7 +51,7 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     transport: createMetaMaskUiTransport(adapter, {
       createCdpWebUiTransport,
       createReactNativeBridgeUiTransport
-    })
+    }, preparedLiveAdapters)
   });
   const existing = new Set([...core, ...ui].map((entry) => entry.action));
   const lifecycle = mobileSourceAwareLifecycleAdapters(
@@ -51,19 +61,34 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
       targetProvider: { resolveTarget: resolveMetaMaskMobileLifecycleTarget }
     })
   );
-  const custom = createMetaMaskAdapters(adapter).filter(
+  const custom = createMetaMaskAdapters(
+    adapter,
+    customActions,
+    preparedLiveAdapters
+  ).filter(
     (entry) => declaredActions.has(entry.action) && !existing.has(entry.action) && !lifecycle.some((lifecycleEntry) => lifecycleEntry.action === entry.action)
   );
-  const autoHudDisabled = process.env.METAMASK_RECIPE_AUTO_HUD === "0" || process.env.METAMASK_RECIPE_AUTO_HUD === "false";
+  const autoHudDisabled = options.autoHud === false || process.env.METAMASK_RECIPE_AUTO_HUD === "0" || process.env.METAMASK_RECIPE_AUTO_HUD === "false";
   const logger = options.quietStdout ? new console.Console(process.stderr) : console;
   return createRecipeRunner({
     actionManifest,
-    adapters: withActionProgress([...core, ...ui, ...lifecycle, ...custom], options.onActionEvent),
+    adapters: withActionProgress(
+      [...core, ...ui, ...lifecycle, ...custom].map((entry) => ({
+        ...entry,
+        ...adapterSecurity(entry.action, actionSources, options.trustTaskActions)
+      })),
+      options.onActionEvent
+    ),
     logger,
     recording: {
       targetProvider: createMetaMaskRecordingTargetProvider(adapter)
     },
     runner: runnerProvenance(),
+    defaultSource: {
+      kind: "operator",
+      trust: "trusted",
+      name: "@deeeed/metamask-harness"
+    },
     hud: autoHudDisabled ? false : {
       enabled: true,
       display: {
@@ -76,6 +101,59 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     }
   });
 }
+async function prepareLiveAdapterImplementations(platform, actions, sources, trustTaskActions = false) {
+  const prepared = /* @__PURE__ */ new Map();
+  if (!sources) return prepared;
+  await Promise.all(actions.map(async (action) => {
+    const source = sources.get(action);
+    if (!source?.implementationRoot || source.tier === "official") return;
+    const executable = await prepareLiveAdapterScript({
+      platform,
+      action,
+      implementationRoot: source.implementationRoot,
+      allowRuntimeImports: source.tier === "canonical" || source.trust === "trusted" || source.tier === "task" && trustTaskActions
+    });
+    if (!executable) return;
+    prepared.set(action, executable);
+    source.digest = executable.sourceDigest;
+    source.resolveDigest = void 0;
+  }));
+  return prepared;
+}
+function adapterSecurity(action, sources, trustTaskActions = false) {
+  const source = sources?.get(action);
+  if (source?.tier === "task") {
+    return {
+      source: {
+        kind: "custom-adapter",
+        trust: trustTaskActions ? "trusted" : "untrusted",
+        name: source.name,
+        path: source.manifestPath,
+        ...source.digest ? { digest: source.digest } : {}
+      },
+      ...source.resolveDigest ? { resolveSourceDigest: source.resolveDigest } : {}
+    };
+  }
+  if (source && source.tier !== "official") {
+    return {
+      source: {
+        kind: source.tier === "canonical" ? "bundled" : "custom-adapter",
+        trust: source.trust ?? (source.tier === "canonical" ? "trusted" : "unknown"),
+        name: source.name,
+        path: source.manifestPath,
+        ...source.digest ? { digest: source.digest } : {}
+      },
+      ...source.resolveDigest ? { resolveSourceDigest: source.resolveDigest } : {}
+    };
+  }
+  return {
+    source: {
+      kind: "bundled",
+      trust: "trusted",
+      name: "@deeeed/metamask-harness"
+    }
+  };
+}
 function withActionProgress(adapters, onActionEvent) {
   if (!onActionEvent) return adapters;
   return adapters.map((entry) => ({
@@ -113,11 +191,7 @@ function mobileSourceAwareLifecycleAdapters(adapter, lifecycle) {
     async execute(node, context) {
       const command = node.command ?? node.event ?? node.state;
       const reloadsSource = command === "launch" || command === "foreground" || command === "restart";
-      const source = reloadsSource ? mobileSourceFingerprint(context.projectRoot) : void 0;
-      if (source?.status === "unavailable") {
-        throw new Error(`${source.error.message} Next: ${source.error.userAction}`);
-      }
-      const fingerprint = source?.fingerprint;
+      const fingerprint = reloadsSource ? mobileSourceFingerprint(context.projectRoot) : void 0;
       const result = await entry.execute(node, context);
       if (fingerprint !== void 0 && !recordMobileSourceBaseline(context.projectRoot, fingerprint)) {
         throw new Error(

package/dist/runtime-context.js

@@ -53,32 +53,6 @@ function readExistingContext(contextPath, repoRoot, runtimeDir, adapter) {
   return { context, existed: true };
 }
 function validExistingContext(context, repoRoot, runtimeDir, adapter) {
-  const allowedFields = /* @__PURE__ */ new Set([
-    "schemaVersion",
-    "repoRoot",
-    "project",
-    "slotId",
-    "machine",
-    "runtimeOwner",
-    "strict",
-    "platform",
-    "runtimeDir",
-    "gitDirty",
-    "simulator",
-    "adbSerial",
-    "distDir",
-    "extensionId",
-    "gitHead",
-    "gitBranch",
-    "gitCommit",
-    "createdAt",
-    "session",
-    "cdpPort",
-    "watcherPort",
-    "metroPort",
-    "devServerPort"
-  ]);
-  if (Object.keys(context).some((field) => !allowedFields.has(field))) return false;
   if (context.schemaVersion !== void 0 && context.schemaVersion !== 1) return false;
   if (context.repoRoot !== void 0 && (typeof context.repoRoot !== "string" || path.resolve(context.repoRoot) !== repoRoot)) return false;
   if (context.platform !== void 0 && context.platform !== adapter) return false;
@@ -108,6 +82,14 @@ function validExistingContext(context, repoRoot, runtimeDir, adapter) {
     const value = context[field];
     if (value !== void 0 && (!Number.isInteger(value) || Number(value) < 1 || Number(value) > 65535)) return false;
   }
+  if (context.runtimeStart !== void 0) {
+    if (!context.runtimeStart || typeof context.runtimeStart !== "object" || Array.isArray(context.runtimeStart)) return false;
+    const runtimeStart = context.runtimeStart;
+    if (runtimeStart.approved !== void 0 && typeof runtimeStart.approved !== "boolean") return false;
+    for (const field of ["command", "readyUrl"]) {
+      if (runtimeStart[field] !== void 0 && (typeof runtimeStart[field] !== "string" || runtimeStart[field].length === 0)) return false;
+    }
+  }
   const forbiddenResources = adapter === "core" ? ["cdpPort", "watcherPort", "metroPort", "devServerPort", "simulator", "adbSerial", "extensionId"] : adapter === "extension" ? ["metroPort", "simulator", "adbSerial"] : ["cdpPort", "extensionId"];
   if (forbiddenResources.some((field) => context[field] !== void 0)) return false;
   return true;