@deeeed/metamask-harness 0.75.0 → 0.77.0

package/dist/commands/manifest.js

@@ -17,6 +17,15 @@ import {
 } from "@farmslot/protocol";
 import { metaMaskActionExecutionCapabilities } from "../recipe-security.js";
 import { closest } from "../command-contract.js";
+import {
+  actionCapabilityMatrix,
+  actionCategory,
+  findRelatedActions,
+  fuzzyResolveActions,
+  resolveActionCapabilityRefusal,
+  searchActions,
+  summarizeActionCategories
+} from "@farmslot/recipe-cli";
 const OFFICIAL_ACTIONS = new Set(OFFICIAL_RECIPE_ACTIONS);
 const ACTION_MATRIX_ADAPTERS = ["mobile", "extension", "core", "terminal"];
 function actionLibraryContextArgs(librarySources) {
@@ -178,51 +187,7 @@ async function resolveActionCapabilityMatrix(librarySources) {
       return { adapter, actions: describeManifestActions(manifest, actionSources) };
     })
   );
-  const actions = /* @__PURE__ */ new Map();
-  for (const catalog of catalogs) {
-    for (const action of catalog.actions) {
-      const entry = actions.get(action.name) ?? { entries: [], adapters: /* @__PURE__ */ new Set() };
-      entry.entries.push(action);
-      entry.adapters.add(catalog.adapter);
-      actions.set(action.name, entry);
-    }
-  }
-  return [...actions.entries()].map(([name, entry]) => {
-    const representative = entry.entries[0];
-    const satisfyingAdapters = ACTION_MATRIX_ADAPTERS.filter(
-      (adapter) => entry.adapters.has(adapter)
-    );
-    return {
-      name,
-      category: representative.category,
-      description: entry.entries.map((action) => action.description).find(Boolean) ?? "",
-      fields: [...new Set(entry.entries.flatMap((action) => action.fields))].sort(),
-      support: Object.fromEntries(
-        ACTION_MATRIX_ADAPTERS.map((adapter) => [
-          adapter,
-          entry.adapters.has(adapter) ? "available" : "unavailable"
-        ])
-      ),
-      satisfyingAdapters
-    };
-  }).sort((left, right) => left.name.localeCompare(right.name));
-}
-function resolveActionCapabilityRefusal(action, adapter, matrix) {
-  const matches = fuzzyResolveActions(matrix, action);
-  if (matches.length !== 1 || matches[0].satisfyingAdapters.includes(adapter)) {
-    return void 0;
-  }
-  return {
-    capability: matches[0].name,
-    satisfyingAdapters: matches[0].satisfyingAdapters
-  };
-}
-function missingActionCapabilities(adapter, actionNames, matrix) {
-  return [...new Set(actionNames)].flatMap((action) => {
-    const row = matrix.find((entry) => entry.name === action);
-    if (!row || row.satisfyingAdapters.includes(adapter)) return [];
-    return [{ capability: row.name, satisfyingAdapters: row.satisfyingAdapters }];
-  });
+  return actionCapabilityMatrix(catalogs);
 }
 function handleActionMatrixError(json, code, message, userAction, details = {}) {
   if (json) {
@@ -315,32 +280,6 @@ function renderHumanActionMatrix(actions) {
     )
   ].join("\n");
 }
-function fuzzyResolveActions(entries, query) {
-  const exactFull = entries.filter((e) => e.name === query);
-  if (exactFull.length > 0) return exactFull;
-  const finalSegment2 = (name) => name.split(".").pop() ?? name;
-  const exactSegment = entries.filter((e) => finalSegment2(e.name) === query);
-  if (exactSegment.length > 0) return exactSegment;
-  return entries.filter((e) => finalSegment2(e.name).includes(query));
-}
-function searchActions(entries, query) {
-  const terms = searchTerms(query);
-  if (terms.length === 0) return [];
-  return entries.map((entry) => {
-    const scores = terms.map((term) => actionSearchScore(entry, term));
-    return { entry, scores, score: scores.reduce((total, value) => total + value, 0) };
-  }).filter(({ score, scores }) => score > 0 && scores.every((value) => value > 0)).sort((left, right) => right.score - left.score || left.entry.name.localeCompare(right.entry.name)).map(({ entry }) => entry);
-}
-function findRelatedActions(entries, selected, limit = 5) {
-  const selectedNameTerms = searchTerms(finalSegment(selected.name).replaceAll("_", " "));
-  return entries.filter((entry) => entry.name !== selected.name).map((entry) => {
-    const nameTerms = new Set(searchTerms(finalSegment(entry.name).replaceAll("_", " ")));
-    const sharedScore = selectedNameTerms.filter((term) => nameTerms.has(term)).reduce((score2, term) => score2 + (GENERIC_OPERATION_TERMS.has(term) ? 5 : 30), 0);
-    const score = (entry.category === selected.category ? 100 : 0) + sharedScore;
-    return { name: entry.name, score };
-  }).filter(({ score }) => score > 0).sort((left, right) => right.score - left.score || left.name.localeCompare(right.name)).slice(0, limit).map(({ name }) => name);
-}
-const GENERIC_OPERATION_TERMS = /* @__PURE__ */ new Set(["assert", "call", "close", "ensure", "place", "read", "start", "teardown"]);
 function summarizeDescribedAction(entry) {
   const { schema: _schema, examples: _examples, ...summary } = entry;
   return summary;
@@ -496,11 +435,6 @@ function actionDomainGroup(entry) {
   const match = /^metamask[.]([^.]+)[.]/u.exec(entry.name);
   return match ? `metamask \xB7 ${match[1]}` : "custom";
 }
-function summarizeActionCategories(actions) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const action of actions) counts.set(action.category, (counts.get(action.category) ?? 0) + 1);
-  return [...counts.entries()].map(([name, count]) => ({ name, count })).sort((left, right) => left.name.localeCompare(right.name));
-}
 function describeManifestActions(manifest, actionSources = /* @__PURE__ */ new Map()) {
   const manifestRecord = isRecord(manifest) ? manifest : {};
   const actions = isRecord(manifestRecord.actions) ? manifestRecord.actions : {};
@@ -521,7 +455,7 @@ function describeManifestAction(name, kind, metadata, source) {
   return {
     name,
     kind,
-    category: actionCategory(name),
+    category: actionCategory(name, ["metamask"]),
     description: typeof record.description === "string" ? record.description : "",
     fields: properties,
     schema,
@@ -539,72 +473,16 @@ function describeManifestAction(name, kind, metadata, source) {
     ])]
   };
 }
-function actionCategory(name) {
-  const segments = name.split(".");
-  if (segments[0] === "metamask" && segments.length > 2) return segments[1] ?? "metamask";
-  if (segments[0] === "app" || segments[0] === "cdp") return "runtime";
-  if (segments[0] === "ui") return "ui";
-  if (name.startsWith("assert_")) return "assertion";
-  if (name === "watch_logs" || name === "index_artifacts") return "evidence";
-  if (name === "command" || name === "wait" || name === "call" || name === "end") return "control";
-  return segments.length > 1 ? segments[0] || "utility" : "utility";
-}
-function actionSearchScore(entry, term) {
-  const name = entry.name.toLowerCase();
-  const segment = finalSegment(name);
-  const nameTerms = searchTerms(name.replaceAll(".", " ").replaceAll("_", " "));
-  const fields = entry.fields.map((field) => field.toLowerCase());
-  const description = entry.description.toLowerCase();
-  if (name === term) return 120;
-  if (segment === term) return 110;
-  if (entry.category === term) return 100;
-  if (fields.includes(term)) return 90;
-  if (nameTerms.includes(term)) return 80;
-  if (name.includes(term)) return 70;
-  if (fields.some((field) => field.includes(term))) return 60;
-  if (description.includes(term)) return 50;
-  if ([...nameTerms, ...fields].some((candidate) => fuzzyTermMatch(term, candidate))) return 40;
-  return 0;
-}
-function fuzzyTermMatch(term, candidate) {
-  if (term.length < 4 || candidate.length < 4) return false;
-  const threshold = Math.max(1, Math.floor(Math.max(term.length, candidate.length) / 4));
-  return levenshtein(term, candidate) <= threshold;
-}
-function searchTerms(value) {
-  return value.toLowerCase().match(/[a-z0-9]+/gu) ?? [];
-}
-function finalSegment(name) {
-  return name.split(".").pop() ?? name;
-}
-function levenshtein(left, right) {
-  const 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] ?? 0) + (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1);
-      current[rightIndex] = Math.min((current[rightIndex - 1] ?? 0) + 1, (prior[rightIndex] ?? 0) + 1, substitution);
-    }
-    for (let index = 0; index < current.length; index += 1) prior[index] = current[index] ?? 0;
-  }
-  return prior[right.length] ?? right.length;
-}
 export {
   ACTION_MATRIX_ADAPTERS,
   actionDomain,
   actionExampleCommand,
   actionLibraryContextArgs,
   describeManifestActions,
-  findRelatedActions,
-  fuzzyResolveActions,
   handleActions,
-  missingActionCapabilities,
   renderHumanActionCatalog,
   renderHumanActionExample,
   renderHumanActionMatrix,
   resolveActionCapabilityMatrix,
-  resolveActionCapabilityRefusal,
-  searchActions,
-  summarizeActionCategories,
   summarizeDescribedAction
 };

package/dist/commands/parse-args.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { detectAdapter } from "../harness.js";
-import { assertAdapter, manifestPath } from "../paths.js";
+import { adapterRegistry } from "../adapters/registry.js";
+import { assertAdapter } from "../paths.js";
 import { explicitRecipeTrustOptions } from "../recipe-security.js";
 import { ADAPTER_DETECT_NEXT } from "./shared.js";
 import { EXIT } from "./shared.js";
@@ -179,12 +180,16 @@ function requiredOption(options, key, message) {
   if (!value) throw usageError(message);
   return value;
 }
+function adapterUsageError(error) {
+  if (error instanceof Error && error.message.startsWith("internal:")) return error;
+  return usageError(error instanceof Error ? error.message : String(error));
+}
 function adapterOption(options) {
   const adapter = optionString(options, "adapter");
   try {
     assertAdapter(adapter);
   } catch (error) {
-    throw usageError(error instanceof Error ? error.message : String(error));
+    throw adapterUsageError(error);
   }
   return adapter;
 }
@@ -193,7 +198,7 @@ function targetPath(options) {
 }
 function actionManifestPathOption(options, adapter) {
   const configured = optionString(options, "actionManifest");
-  return configured ? path.resolve(configured) : manifestPath(adapter);
+  return configured ? path.resolve(configured) : adapterRegistry.get(adapter).actions.manifestPath();
 }
 function parsePort(value, errorMessage) {
   const port = Number(value);
@@ -238,7 +243,7 @@ function resolveAdapter(options) {
   try {
     assertAdapter(adapter);
   } catch (error) {
-    throw usageError(error instanceof Error ? error.message : String(error));
+    throw adapterUsageError(error);
   }
   return { adapter, target };
 }

package/dist/commands/prepare.js

@@ -10,7 +10,9 @@ import {
 import { color, stripAnsi } from "../cli-color.js";
 import { runnerProvenance } from "../doctor.js";
 import { detectAdapter } from "../harness.js";
-import { harnessExecutable, manifestPath, PREPARE_PROGRESS_ARTIFACT, recipeRuntimeDir } from "../paths.js";
+import { adapterRegistry } from "../adapters/registry.js";
+import { getAdapterSurface } from "../adapters/surface.js";
+import { harnessExecutable, PREPARE_PROGRESS_ARTIFACT, recipeRuntimeDir } from "../paths.js";
 import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
 import { EXIT } from "./shared.js";
 import { formatDuration } from "./status-watch.js";
@@ -52,8 +54,8 @@ const STEP_HINT = {
   launch: "can take minutes on Mobile: Metro bundle and app start",
   fixtures: "under a minute"
 };
-function stepChain(platform) {
-  return platform === "core" ? ["doctor", "status", "verify"] : ["doctor", "status", "launch", "fixtures", "verify"];
+function stepChain(surface) {
+  return surface.headless ? ["doctor", "status", "verify"] : ["doctor", "status", "launch", "fixtures", "verify"];
 }
 function lastRunDurations(recordPath) {
   let parsed;
@@ -225,36 +227,6 @@ function readDevices(artifactsDir) {
   const devices = parsed?.devices;
   return Array.isArray(devices) ? devices : [];
 }
-function readRuntimeContextTarget(target) {
-  const file = path.join(target, recipeRuntimeDir(), "agentic-runtime.json");
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return {};
-  }
-  const record = parsed ?? {};
-  const str = (key) => typeof record[key] === "string" ? record[key] : void 0;
-  return { simulator: str("simulator"), simulatorUdid: str("simulatorUdid"), adbSerial: str("adbSerial") };
-}
-function mobilePlatformFromConfiguredTarget(env, context) {
-  const ios = Boolean(env.IOS_SIMULATOR || env.SIM_UDID || context.simulator || context.simulatorUdid);
-  const android = Boolean(
-    env.ADB_SERIAL || env.ANDROID_SERIAL || env.ANDROID_TARGET_DEVICE_NAME || env.ANDROID_DEVICE || context.adbSerial
-  );
-  if (ios === android) return void 0;
-  return ios ? "ios" : "android";
-}
-function mobilePlatformFromDevices(devices) {
-  const selected = devices.filter((device) => device?.selected === true);
-  const candidates = selected.length > 0 ? selected : devices;
-  const platforms = [
-    ...new Set(
-      candidates.map((device) => device?.platform).filter((value) => value === "ios" || value === "android")
-    )
-  ];
-  return platforms.length === 1 ? platforms[0] : void 0;
-}
 function mobileTargetAmbiguityError() {
   const choices = [
     "1. iOS     mm-harness prepare --platform mobile --mobile-platform ios",
@@ -300,8 +272,9 @@ function mobilePlatformOption(value) {
 }
 function resolvePlatform(requested, target) {
   const platform = requested ?? detectAdapter(target);
-  if (platform === "mobile" || platform === "extension" || platform === "core") {
-    return platform;
+  const surface = platform && adapterRegistry.has(platform) ? getAdapterSurface(platform) : void 0;
+  if (surface?.prepare) {
+    return surface;
   }
   throw usageError(
     `could not detect the platform of ${target}
@@ -328,21 +301,22 @@ async function handlePrepareLocked(argv) {
   const { options } = parseArgs(argv, "prepare");
   const json = optionFlag(options, "json");
   const target = targetPath(options);
-  const platform = resolvePlatform(optionString(options, "platform"), target);
+  const surface = resolvePlatform(optionString(options, "platform"), target);
+  const platform = surface.adapter;
   const artifactsDir = path.resolve(
     optionString(options, "artifactsDir") ?? path.join(target, recipeRuntimeDir())
   );
   const executable = harnessExecutable();
   const targetArgs = ["--target", target];
   const clearMetro = optionFlag(options, "clearMetro");
-  if (clearMetro && platform !== "mobile") {
+  if (clearMetro && !surface.prepare.clearMetro) {
     throw usageError(`--clear-metro is mobile only; this checkout is ${platform}
   Next: ${USAGE}`);
   }
   const remoteFlag = optionString(options, "remoteFlag");
   if (remoteFlag !== void 0) {
-    if (platform === "core") {
-      throw usageError(`--remote-flag needs an app runtime; this checkout is core
+    if (surface.headless) {
+      throw usageError(`--remote-flag needs an app runtime; this checkout is ${platform}
   Next: ${USAGE}`);
     }
     try {
@@ -357,7 +331,7 @@ async function handlePrepareLocked(argv) {
   let mobilePlatform = mobilePlatformOption(optionString(options, "mobilePlatform"));
   const recordPath = path.join(artifactsDir, READINESS_RECORD);
   const progressPath = path.join(artifactsDir, PREPARE_PROGRESS_ARTIFACT);
-  const chain = stepChain(platform);
+  const chain = stepChain(surface);
   const view = json ? void 0 : createStepView(chain, stepHints(chain, lastRunDurations(recordPath)));
   view?.begin();
   const steps = [];
@@ -406,35 +380,33 @@ async function handlePrepareLocked(argv) {
   try {
     await run("doctor", ["doctor", "--fix", "--json", "--adapter", platform, ...targetArgs]);
     await run("status", ["status", "--json", ...targetArgs]);
-    if (platform === "mobile" && !mobilePlatform && !failed()) {
-      mobilePlatform = mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(readDevices(artifactsDir));
+    const { devicePlatform } = surface.prepare;
+    if (devicePlatform && !mobilePlatform && !failed()) {
+      mobilePlatform = devicePlatform(target, readDevices(artifactsDir));
       if (!mobilePlatform) return ambiguousMobileTarget(json);
     }
-    if (platform === "core") {
-      const reason = "core is headless: no app surface to launch or seed";
+    if (surface.headless) {
+      const reason = `${platform} is headless: no app surface to launch or seed`;
       addStep(skippedStep("launch", `${executable} launch`, reason));
       addStep(skippedStep("fixtures", `${executable} fixtures set`, reason));
-    } else if (platform === "mobile") {
-      const device = mobilePlatform ? [mobilePlatform] : [];
+    } else {
+      const device = devicePlatform && mobilePlatform ? [mobilePlatform] : [];
       await run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], ...remoteFlagArgs, "--verify", "--json", ...targetArgs]);
       await run("fixtures", [
         "fixtures",
         "set",
-        ...mobilePlatform ? ["--platform", mobilePlatform] : [],
+        ...device.flatMap((platformName) => ["--platform", platformName]),
         ...remoteFlagArgs,
         "--json",
         ...targetArgs
       ]);
-    } else {
-      await run("launch", ["launch", ...remoteFlagArgs, "--verify", "--json", ...targetArgs]);
-      await run("fixtures", ["fixtures", "set", ...remoteFlagArgs, "--json", ...targetArgs]);
     }
     await run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
   } finally {
     clearInterval(heartbeat);
     view?.end();
   }
-  const provenance = runnerProvenance(manifestPath(platform));
+  const provenance = runnerProvenance(surface.actions.manifestPath());
   const record = {
     schemaVersion: 1,
     harness: {
@@ -462,7 +434,5 @@ async function handlePrepareLocked(argv) {
 }
 export {
   handlePrepare,
-  mobilePlatformFromConfiguredTarget,
-  mobilePlatformFromDevices,
   mobileTargetAmbiguityError
 };

package/dist/commands/provision.js

@@ -1,8 +1,7 @@
 import { detectAdapter } from "../harness.js";
 import { assertAdapter } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
-import { clearMobileReleaseArtifactState } from "../adapters/mobile/release-artifact-state.js";
-import { ADAPTER_DETECT_NEXT, usageOut, writeInteractiveProgress } from "./shared.js";
+import { ADAPTER_DETECT_NEXT, usageOut } from "./shared.js";
 import {
   applyWatcherPortOption,
   optionFlag,
@@ -27,10 +26,7 @@ async function handleProvision({ positional, options, rawArgv }) {
   const surface = getAdapterSurface(adapter);
   const rerunCommand = provisionRerunCommand(rawArgv, options, adapter, target);
   const platform = optionString(options, "platform") ?? optionString(options, "devicePlatform") ?? (positional[0] === "runway" ? positional[1] : positional[0]) ?? "ios";
-  if (adapter === "mobile") {
-    writeInteractiveProgress(json, `\u2192 provision mobile ${platform} \u2014 resolving simulator and Runway artifact`);
-    if (!optionFlag(options, "resolveOnly")) clearMobileReleaseArtifactState(target);
-  }
+  surface.runwayProvision.before?.(target, { json, platform, resolveOnly: optionFlag(options, "resolveOnly") });
   const result = await surface.runwayProvision.run(target, {
     json,
     platform,
@@ -50,7 +46,7 @@ async function handleProvision({ positional, options, rawArgv }) {
   });
   const provisionedSimulator = typeof result.simulator === "object" && result.simulator ? result.simulator : void 0;
   const provisionedDevice = typeof provisionedSimulator?.udid === "string" ? provisionedSimulator.udid : typeof provisionedSimulator?.name === "string" ? provisionedSimulator.name : void 0;
-  const next = result.status === "pass" && adapter === "mobile" && result.resolveOnly !== true ? `mm-harness launch ${String(result.platform ?? platform)} --adapter mobile --target ${shellQuote(target)}` + (provisionedDevice ? ` --device ${shellQuoteArg(provisionedDevice)}` : "") : void 0;
+  const next = result.status === "pass" && surface.runwayProvision.launchNext && result.resolveOnly !== true ? `mm-harness launch ${String(result.platform ?? platform)} --adapter ${adapter} --target ${shellQuote(target)}` + (provisionedDevice ? ` --device ${shellQuoteArg(provisionedDevice)}` : "") : void 0;
   const output = next ? { ...result, next } : result;
   if (json) {
     console.log(JSON.stringify(output, null, 2));

package/dist/commands/reload.js

@@ -1,13 +1,9 @@
-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";
@@ -25,55 +21,20 @@ async function handleReload(argv) {
       ADAPTER_DETECT_NEXT
     );
   }
-  if (adapter === "core") {
+  const surface = getAdapterSurface(adapter);
+  if (surface.headless) {
     return usageOut(
       json,
       "reload",
-      "core is headless; there is no app runtime to reload.",
-      "mm-harness run <core-recipe>"
+      `${adapter} is headless; there is no app runtime to reload.`,
+      `mm-harness run <${adapter}-recipe>`
     );
   }
-  getAdapterSurface(adapter).resolveSlotPorts(target);
-  if (adapter === "extension") {
-    if (!process.env.CDP_PORT) {
-      return usageOut(
-        json,
-        "reload",
-        "the Extension CDP port could not be resolved.",
-        "mm-harness launch"
-      );
-    }
-    const script2 = path.join(runnerDir, "adapters/extension/reattach.sh");
-    const args2 = ["--target", target, "--cdp-port", process.env.CDP_PORT];
-    if (process.env.WATCHER_PORT) {
-      args2.push("--watcher-port", process.env.WATCHER_PORT);
-    }
-    const result2 = spawnScript(script2, args2, target, json);
-    if (json) {
-      console.log(
-        JSON.stringify(
-          {
-            ok: result2.status === 0,
-            adapter,
-            method: "cdp-reattach",
-            command: "reload",
-            cdpPort: Number(process.env.CDP_PORT),
-            ...result2.status === 0 ? {} : { error: result2.output.slice(-4e3) || "Extension reload failed." }
-          },
-          null,
-          2
-        )
-      );
-    }
-    return result2.status === 0 ? EXIT.ok : EXIT.runtime;
+  if (!surface.reload) {
+    return usageOut(json, "reload", `reload does not support the ${adapter} adapter.`, surface.hints.launch);
   }
-  const script = path.join(runnerDir, "adapters/mobile/reload-app.mjs");
-  const args = [];
-  if (process.env.WATCHER_PORT) args.push("--port", process.env.WATCHER_PORT);
-  if (json) args.push("--json");
-  const result = spawnScript(process.execPath, [script, ...args], target, json);
-  if (json) process.stdout.write(result.output);
-  return result.status === 0 ? EXIT.ok : EXIT.runtime;
+  surface.resolveSlotPorts(target);
+  return surface.reload(target, json);
 }
 export {
   handleReload

package/dist/commands/run.js

@@ -38,11 +38,8 @@ import { formatRunDiagnosticsForHuman, readRunDiagnosticsDocument } from "../run
 import { recipeTrustFailure } from "../recipe-security.js";
 import { ProvenanceDriftError } from "../execution-provenance.js";
 import { recordCommandEvidence } from "../command-journal.js";
-import {
-  actionLibraryContextArgs,
-  missingActionCapabilities,
-  resolveActionCapabilityMatrix
-} from "./manifest.js";
+import { actionLibraryContextArgs, resolveActionCapabilityMatrix } from "./manifest.js";
+import { missingActionCapabilities } from "@farmslot/recipe-cli";
 import {
   startRunNetworkObservation
 } from "../network-observation.js";

package/dist/commands/runtime-decision.js

@@ -1,32 +1,16 @@
-import { decideExtensionReadiness } from "../adapters/extension/runtime-decision.js";
-import { decideMobileReadiness } from "../adapters/mobile/runtime-decision.js";
+import { getAdapterSurface } from "../adapters/surface.js";
 import {
   adapterOption,
   applyRuntimeDirOption,
   optionFlag,
-  optionString,
-  parsePort,
   targetPath
 } from "./parse-args.js";
 async function handleRuntimeDecision({ options }) {
   applyRuntimeDirOption(options);
   const adapter = adapterOption(options);
   const target = targetPath(options);
-  if (adapter === "mobile") {
-    const watcherPortRaw = optionString(options, "watcherPort") ?? process.env.WATCHER_PORT ?? process.env.METRO_PORT;
-    const watcherPort = watcherPortRaw === void 0 ? void 0 : parsePort(watcherPortRaw, "runtime-decision --watcher-port must be a port.");
-    const report2 = await decideMobileReadiness(target, {
-      watcherPort,
-      metroLog: optionString(options, "metroLog"),
-      platform: optionString(options, "platform") ?? process.env.PLATFORM ?? process.env.RECIPE_HARNESS_PLATFORM,
-      record: optionFlag(options, "record"),
-      preflightMode: optionString(options, "preflightMode")
-    });
-    if (optionFlag(options, "json")) console.log(JSON.stringify(report2, null, 2));
-    else console.log(`${report2.decision} ${report2.reasonCode} \u2014 ${report2.reasons[0] ?? ""}`);
-    return 0;
-  }
-  if (adapter !== "extension") {
+  const decide = getAdapterSurface(adapter).runtimeDecision;
+  if (!decide) {
     const report2 = {
       schemaVersion: 1,
       adapter,
@@ -42,15 +26,9 @@ async function handleRuntimeDecision({ options }) {
     else console.log(`unknown adapter-unsupported \u2014 ${report2.reasons[0]}`);
     return 0;
   }
-  const cdpPortRaw = optionString(options, "cdpPort") ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT;
-  const cdpPort = cdpPortRaw === void 0 ? void 0 : parsePort(cdpPortRaw, "runtime-decision --cdp-port must be a port.");
-  const report = await decideExtensionReadiness(target, {
-    cdpPort,
-    watchLog: optionString(options, "watchLog"),
-    record: optionFlag(options, "record")
-  });
+  const { report, line } = await decide(target, options);
   if (optionFlag(options, "json")) console.log(JSON.stringify(report, null, 2));
-  else console.log(`${report.decision}${report.clean ? " (clean)" : ""} ${report.reasonCode} \u2014 ${report.reasons[0] ?? ""}`);
+  else console.log(line);
   return 0;
 }
 export {

package/dist/commands/self-test.js

@@ -25,9 +25,7 @@ async function runSelfTest(options) {
     for (const adapter of ["mobile", "extension"]) {
       const manifest = loadActionManifest(adapter);
       const manifestValidation = await validateManifest(manifest);
-      const smokeRecipe = recipePath(
-        adapter === "mobile" ? "mobile/runner/smoke.recipe.json" : "extension/runner/smoke.recipe.json"
-      );
+      const smokeRecipe = recipePath(`${adapter}/runner/smoke.recipe.json`);
       const artifactsDir = path.join(root, adapter);
       const result = await runRecipe(adapter, smokeRecipe, artifactsDir, runnerDir, void 0, {
         skipExtensionRuntimePrepare: true