@deeeed/metamask-harness 0.5.0 → 0.6.0

package/dist/commands/call.js

@@ -0,0 +1,183 @@
+import fs from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { loadActionManifest } from "../manifest.js";
+import { importRecipeProtocol } from "../paths.js";
+import { recipeRunning } from "../heal-bounds.js";
+import { EXIT } from "./shared.js";
+import {
+  parseArgs,
+  optionFlag,
+  optionString,
+  resolveAdapter,
+  runtimeOptionsFromCli,
+  usageError
+} from "./parse-args.js";
+import {
+  emitHealViolation,
+  executeWithHealBounds,
+  prepareHeal,
+  resolveMetaMaskLibrarySources,
+  runRecipe,
+  synthesizeOneNodeRecipe,
+  validateRecipeAdapterAware
+} from "./run-engine.js";
+async function handleCall(argv) {
+  if (argv.length > 0 && argv[0].startsWith("--")) {
+    const message = "call requires <action> first: mm-harness call <action> [--arg k=v ...] [flags]";
+    console.error(message);
+    return EXIT.usage;
+  }
+  const { action: shortName, args, rest } = parseCallArgs(argv);
+  const { options } = parseArgs(rest, "call");
+  const json = optionFlag(options, "json");
+  if (!shortName) {
+    let example = "mm-harness call <action>";
+    let discovery = "mm-harness actions";
+    try {
+      const { adapter: adapter2 } = resolveAdapter(options);
+      const manifest2 = loadActionManifest(adapter2, optionString(options, "actionManifest"));
+      const { getRecipeActionManifestActionNames: getRecipeActionManifestActionNames2 } = await importRecipeProtocol();
+      const exampleAction = pickCallExampleAction(getRecipeActionManifestActionNames2(manifest2));
+      example = `mm-harness call ${exampleAction} --adapter ${adapter2}`;
+      discovery = `mm-harness actions --adapter ${adapter2}`;
+    } catch {
+    }
+    const message = `call requires <action>. Example: ${example}`;
+    const userAction = `${example}   # see the vocabulary: ${discovery}`;
+    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "call", error: { code: "USAGE", message, userAction } }, null, 2));
+    else console.error(`${message}
+  See the vocabulary: ${discovery}`);
+    return EXIT.usage;
+  }
+  const { adapter, target } = resolveAdapter(options);
+  if (recipeRunning(target)) {
+    const msg = "a recipe is currently running \u2014 refusing to start while another recipe executes.";
+    if (json) {
+      console.log(JSON.stringify({ schemaVersion: 1, command: "call", status: "fail", recoverable: false, error: { code: "RECIPE_RUNNING", message: msg } }, null, 2));
+    } else {
+      console.error(`\u2717 mm-harness call: ${msg}`);
+    }
+    return EXIT.bounded;
+  }
+  const actionManifestOverride = optionString(options, "actionManifest");
+  const manifest = loadActionManifest(adapter, actionManifestOverride);
+  const { getRecipeActionManifestActionNames } = await importRecipeProtocol();
+  const names = getRecipeActionManifestActionNames(manifest);
+  const resolution = resolveActionName(shortName, names);
+  if (resolution.status === "unknown") {
+    const message = `\u2717 call: unknown action "${shortName}" for the ${adapter} adapter.
+  See the vocabulary: mm-harness actions --adapter ${adapter} --json`;
+    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "call", adapter, action: shortName, error: { code: "ACTION_UNKNOWN", message } }, null, 2));
+    else console.error(message);
+    return EXIT.usage;
+  }
+  if (resolution.status === "ambiguous") {
+    const message = `\u2717 call: "${shortName}" is ambiguous: ${resolution.candidates.join(", ")} \u2014 use the full name.`;
+    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "call", adapter, action: shortName, error: { code: "ACTION_AMBIGUOUS", message, candidates: resolution.candidates } }, null, 2));
+    else console.error(message);
+    return EXIT.usage;
+  }
+  const resolvedAction = resolution.resolved;
+  const recipe = synthesizeOneNodeRecipe(resolvedAction, args);
+  const validation = await validateRecipeAdapterAware(recipe, manifest);
+  if (validation.status === "invalid") {
+    const message = `\u2717 call ${resolvedAction}: recipe validation failed`;
+    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "call", adapter, action: shortName, resolvedAction, args, findings: validation.findings, error: { code: "RECIPE_VALIDATION_FAILED", message } }, null, 2));
+    else {
+      console.error(message);
+      for (const finding of validation.findings) console.error(`  ${finding.code} ${finding.path} \u2014 ${finding.message}`);
+    }
+    return EXIT.validation;
+  }
+  const prepared = await prepareHeal(adapter, target, options, json);
+  if (typeof prepared === "number") return prepared;
+  const { state, heal } = prepared;
+  const scratch = await mkdtemp(path.join(os.tmpdir(), "mm-harness-call-"));
+  const recipeFile = path.join(scratch, "call.recipe.json");
+  fs.writeFileSync(recipeFile, `${JSON.stringify(recipe, null, 2)}
+`);
+  const artifactsDir = optionString(options, "artifactsDir") ?? path.join(scratch, "artifacts");
+  const librarySources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+  const callRuntimeOptions = {
+    ...runtimeOptionsFromCli(options),
+    ...librarySources ? { librarySources } : {},
+    stdoutIsMachineContract: json
+  };
+  const { result, violation } = await executeWithHealBounds(
+    () => runRecipe(adapter, recipeFile, artifactsDir, target, actionManifestOverride, callRuntimeOptions),
+    adapter,
+    target,
+    heal,
+    state
+  );
+  if (violation !== null) return emitHealViolation(json, "call", result, violation, state, adapter);
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: "call",
+          adapter,
+          action: shortName,
+          resolvedAction,
+          args,
+          status: result.status,
+          summaryPath: result.summaryPath,
+          tracePath: result.tracePath,
+          artifactManifestPath: result.artifactManifestPath,
+          recovered: state.recovered,
+          mutations: state.mutations,
+          exitCode: result.status === "pass" ? EXIT.ok : EXIT.runtime
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    console.log(`call ${resolvedAction}: ${result.status}
+Artifacts: ${result.artifactManifestPath}`);
+  }
+  return result.status === "pass" ? EXIT.ok : EXIT.runtime;
+}
+function parseCallArgs(argv) {
+  const args = {};
+  const rest = [];
+  let action;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--arg" || arg.startsWith("--arg=")) {
+      const pair = arg === "--arg" ? argv[i += 1] : arg.slice("--arg=".length);
+      if (pair === void 0) throw usageError("--arg requires k=v.");
+      const eq = pair.indexOf("=");
+      if (eq === -1) throw usageError(`--arg must be k=v: ${pair}`);
+      args[pair.slice(0, eq)] = pair.slice(eq + 1);
+      continue;
+    }
+    if (!arg.startsWith("--") && action === void 0) {
+      action = arg;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { action, args, rest };
+}
+function resolveActionName(shortName, names) {
+  if (names.includes(shortName)) return { status: "ok", resolved: shortName, candidates: [shortName] };
+  const finalSegment = (name) => name.split(".").pop() ?? name;
+  const exactSegment = names.filter((name) => finalSegment(name) === shortName);
+  const tier = exactSegment.length > 0 ? exactSegment : names.filter((name) => finalSegment(name).includes(shortName));
+  if (tier.length === 1) return { status: "ok", resolved: tier[0], candidates: tier };
+  if (tier.length > 1) return { status: "ambiguous", resolved: "", candidates: tier };
+  return { status: "unknown", resolved: "", candidates: [] };
+}
+function pickCallExampleAction(names) {
+  const walletish = names.find((name) => /wallet|unlock/u.test(name));
+  if (walletish) return walletish;
+  if (names.includes("command")) return "command";
+  return names[0] ?? "command";
+}
+export {
+  handleCall
+};

package/dist/commands/completion-candidates.js

@@ -0,0 +1,58 @@
+import { loadActionManifest } from "../manifest.js";
+import {
+  invalidateCompletionCache,
+  readFreshCandidates,
+  writeCompletionCandidates
+} from "../completions-cache.js";
+import { importRecipeHarness, importRecipeProtocol } from "../paths.js";
+import { EXIT } from "./shared.js";
+import {
+  parseArgs,
+  optionFlag,
+  optionString,
+  resolveAdapter,
+  targetPath
+} from "./parse-args.js";
+import { resolveMetaMaskLibrarySources } from "./run-engine.js";
+async function handleCompletionCandidates(argv) {
+  const kind = argv[0];
+  const { options } = parseArgs(argv.slice(1), "completion-candidates");
+  const json = optionFlag(options, "json");
+  if (kind !== "actions" && kind !== "flows") {
+    console.error("completion-candidates requires <actions|flows>.");
+    return EXIT.usage;
+  }
+  const target = targetPath(options);
+  let adapter;
+  let candidates;
+  if (kind === "actions") {
+    adapter = resolveAdapter(options).adapter;
+    candidates = readFreshCandidates(target, "actions");
+    if (!candidates) {
+      const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
+      const { getRecipeActionManifestActionNames } = await importRecipeProtocol();
+      candidates = getRecipeActionManifestActionNames(manifest);
+      writeCompletionCandidates(target, "actions", candidates);
+    }
+  } else {
+    candidates = readFreshCandidates(target, "flows");
+    if (!candidates) {
+      const sources = await resolveMetaMaskLibrarySources(void 0).catch(() => void 0);
+      if (!sources) {
+        candidates = [];
+      } else {
+        const harness = await importRecipeHarness();
+        const resolution = await harness.loadRecipeLibraries(sources);
+        candidates = [...resolution.flows.keys()].sort();
+        writeCompletionCandidates(target, "flows", candidates);
+      }
+    }
+  }
+  if (json) console.log(JSON.stringify({ schemaVersion: 1, kind, adapter, candidates }, null, 2));
+  else for (const candidate of candidates) console.log(candidate);
+  return EXIT.ok;
+}
+export {
+  handleCompletionCandidates,
+  invalidateCompletionCache
+};

package/dist/commands/doctor.js

@@ -0,0 +1,101 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { color } from "../cli-color.js";
+import { createDoctorReport, renderRuntimeContext } from "../doctor.js";
+import { detectAdapter } 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 { ADAPTER_DETECT_NEXT, usageOut } from "./shared.js";
+import {
+  actionManifestPathOption,
+  applyRuntimeDirOption,
+  optionFlag,
+  optionString,
+  targetPath
+} from "./parse-args.js";
+async function handleDoctor({ options }) {
+  applyRuntimeDirOption(options);
+  const target = targetPath(options);
+  const json = optionFlag(options, "json");
+  const explicitAdapter = optionString(options, "adapter") ?? optionString(options, "platform");
+  const adapter = explicitAdapter ?? detectAdapter(target);
+  if (!adapter) {
+    return usageOut(json, "doctor", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
+  }
+  assertAdapter(adapter);
+  const actionManifestPath = actionManifestPathOption(options, adapter);
+  const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
+  const manifestValidation = await validateManifest(manifest);
+  if (optionFlag(options, "fix")) {
+    const { fixed, failed } = await runDoctorFix(adapter, target, manifestValidation, json);
+    const result2 = createDoctorReport(adapter, target, manifestValidation, actionManifestPath);
+    if (json) console.log(JSON.stringify({ ...result2, fixed, failed }, null, 2));
+    else console.log(`${result2.status} ${adapter} ${result2.compatibilityMode} manifest=${actionManifestPath} fixed=[${fixed.join(",")}] failed=[${failed.join(",")}]`);
+    return failed.length === 0 ? 0 : 1;
+  }
+  const result = createDoctorReport(adapter, target, manifestValidation, actionManifestPath);
+  let runtime;
+  try {
+    const surface = getAdapterSurface(adapter);
+    surface.resolveSlotPorts(target);
+    runtime = await surface.runtimeStatus(target);
+  } catch {
+  }
+  const orphanMetros = adapter === "mobile" ? detectOrphanMetros(target) : [];
+  if (json) console.log(JSON.stringify({ ...result, runtime, orphanMetros }, null, 2));
+  else {
+    const out = (style, text) => color(style, text, { stream: process.stdout });
+    const stateStyle = (value, good) => value === good ? "ok" : "warn";
+    console.log(`${out(result.status === "pass" ? "ok" : "err", result.status)} ${out("bold", adapter)} ${result.compatibilityMode} ${out("dim", `manifest=${actionManifestPath}`)}`);
+    if (runtime) {
+      const provisionedDepsPending = runtime.reasonCode === "app-installed-deps-pending";
+      const decisionStyle = provisionedDepsPending ? "info" : runtime.decision === "ready" ? "ok" : runtime.decision === "blocked" ? "err" : "warn";
+      const depsStyle = provisionedDepsPending ? "info" : stateStyle(runtime.deps, "current");
+      const devServerStyle = provisionedDepsPending ? "info" : void 0;
+      const devServer = runtime.devServer ? ` ${runtime.devServer.label}=${out(devServerStyle ?? stateStyle(runtime.devServer.status, "up"), runtime.devServer.status)}` : "";
+      console.log(
+        `${out("label", "runtime:")} decision=${out(decisionStyle, runtime.decision)}${runtime.reasonCode ? ` ${out("dim", `(${runtime.reasonCode})`)}` : ""} deps=${out(depsStyle, runtime.deps ?? "unknown")}${devServer}`
+      );
+      for (const reason of runtime.reasons) console.log(`  ${out("dim", reason)}`);
+    }
+    console.log(renderRuntimeContext(result.runtimeContext));
+    if (orphanMetros.length > 0) {
+      console.log(
+        `${out("warn", "orphan Metro:")} ${orphanMetros.length} leaked bundler(s) for this checkout (pids ${orphanMetros.join(", ")})`
+      );
+      console.log(`  ${out("dim", "Next: mm-harness stop   # reaps every bundler this checkout leaked")}`);
+    }
+  }
+  return result.status === "pass" ? 0 : 1;
+}
+function detectOrphanMetros(target) {
+  try {
+    const script = path.join(runnerDir, "adapters/shared/reap-checkout-metros.sh");
+    const out = execFileSync("bash", ["-c", `. "$1"; detect_checkout_metros "$2"`, "mm-harness-doctor", script, target], {
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    return out.split("\n").map((line) => line.trim()).filter((line) => /^\d+$/u.test(line));
+  } catch {
+    return [];
+  }
+}
+async function runDoctorFix(adapter, target, manifestValidation, json) {
+  const fixed = [];
+  const failed = [];
+  if (recipeRunning(target)) {
+    failed.push("recipe-running");
+    return { fixed, failed };
+  }
+  if (Number(manifestValidation.summary?.errors ?? 0) > 0) failed.push("manifest");
+  const state = newHealState();
+  const ensured = await ensureOverlay(adapter, target, "infra-only", state, json);
+  if (!ensured.ok) failed.push("overlay");
+  else if (state.mutations.length > 0) fixed.push("overlay");
+  return { fixed, failed };
+}
+export {
+  handleDoctor
+};

package/dist/commands/ensure-ready.js

@@ -0,0 +1,24 @@
+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.");
+  const target = targetPath(options);
+  const cdpPort = parsePort(
+    optionString(options, "cdpPort") ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT,
+    "ensure-ready requires --cdp-port <port>."
+  );
+  const result = await ensureExtensionReady(target, { cdpPort });
+  if (optionFlag(options, "json")) console.log(JSON.stringify(result, null, 2));
+  else console.log(`${result.ready ? "READY" : "NOT-READY"} ${result.reasonCode} \u2014 id=${result.extensionId} homeTabs ${result.homeTabs.before}\u2192${result.homeTabs.after} (closed ${result.homeTabs.closed})`);
+  return result.ready ? 0 : 1;
+}
+export {
+  handleEnsureReady
+};

package/dist/commands/flows.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { color } from "../cli-color.js";
+import { importRecipeHarnessCli } from "../paths.js";
+import { EXIT } from "./shared.js";
+import { usageError } from "./parse-args.js";
+import { resolveMetaMaskLibrarySources } from "./run-engine.js";
+const FLOWS_SUBCOMMANDS = ["list", "promote"];
+function stripTargetFlag(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--target") {
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--target=")) continue;
+    out.push(arg);
+  }
+  return out;
+}
+function serializeLibrarySources(sources) {
+  return sources.map((source) => source.name ? `${source.name}=${source.root}` : source.root).join(":");
+}
+function flowSourceTier(source, index, total) {
+  if (index === total - 1 && source.name === "metamask") return "canonical";
+  if (source.name === "personal") return "personal";
+  return "team";
+}
+function restoreEnv(key, value) {
+  if (value === void 0) delete process.env[key];
+  else process.env[key] = value;
+}
+async function handleFlows(argv) {
+  const sources = await resolveMetaMaskLibrarySources(void 0);
+  if (!sources) {
+    throw usageError(
+      "flows requires @farmslot/recipe-harness >= 0.3.3 (recipe-library support; flows resolve personal > team > canonical). Next: update the dependency and run yarn install."
+    );
+  }
+  const forwarded = stripTargetFlag(argv);
+  const jsonMode = forwarded.includes("--json");
+  if (!jsonMode) {
+    console.error(color("label", "flows resolve by precedence (highest wins; local shadows canonical):"));
+    sources.forEach((source, index) => {
+      const name = source.name ?? path.basename(source.root);
+      console.error(`  ${index + 1}. ${color("cmd", name)} ${color("dim", `[${flowSourceTier(source, index, sources.length)}]`)}`);
+    });
+  }
+  const withSubcommand = FLOWS_SUBCOMMANDS.includes(forwarded[0]) ? forwarded : ["list", ...forwarded];
+  const { runRecipeHarnessCli } = await importRecipeHarnessCli();
+  const previousLibraryPath = process.env.RECIPE_LIBRARY_PATH;
+  process.env.RECIPE_LIBRARY_PATH = serializeLibrarySources(sources);
+  try {
+    await runRecipeHarnessCli(["flows", ...withSubcommand]);
+  } finally {
+    restoreEnv("RECIPE_LIBRARY_PATH", previousLibraryPath);
+  }
+  return EXIT.ok;
+}
+export {
+  handleFlows
+};

package/dist/commands/launch/extension.js

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import path from "node:path";
+import { recipeHarnessPath, recipeRuntimeDir, runnerDir } from "../../paths.js";
+import { stopExtensionWatcher } from "../../adapters/slot-ports.js";
+import { spawnScriptStreaming } from "../shared.js";
+async function launchExtension(target, tier, wantWatch) {
+  if (!wantWatch && tier === "quick") {
+    return extensionRebuild(target);
+  }
+  const startWatchSh = path.join(runnerDir, "adapters/extension/start-watch.sh");
+  const watchArgs = ["--target", target];
+  if (process.env.WATCHER_PORT) watchArgs.push("--watcher-port", process.env.WATCHER_PORT);
+  console.error(`\u2192 extension ${wantWatch ? "watch" : "build"} \u2014 webpack :${process.env.WATCHER_PORT ?? "default"} (output streams below)`);
+  return spawnScriptStreaming(startWatchSh, watchArgs, target);
+}
+async function extensionRebuild(target) {
+  const runtimeDirRel = recipeRuntimeDir();
+  const runtimeAbs = path.join(target, runtimeDirRel);
+  const rebuildLog = path.join(runtimeAbs, "rebuild.log");
+  stopExtensionWatcher(target);
+  fs.mkdirSync(path.dirname(rebuildLog), { recursive: true });
+  fs.writeFileSync(rebuildLog, "");
+  const liveScript = recipeHarnessPath(target, "extension", "scripts", "live.sh");
+  const liveArgs = ["--target", target, "--start-watch"];
+  if (process.env.CDP_PORT) liveArgs.push("--cdp-port", process.env.CDP_PORT);
+  if (process.env.EXTENSION_START_URL) liveArgs.push("--start-url", process.env.EXTENSION_START_URL);
+  console.error(`\u2192 extension quick relaunch \u2014 webpack :${process.env.WATCHER_PORT ?? "default"} \xB7 CDP :${process.env.CDP_PORT ?? "default"} (output streams below)`);
+  const result = await spawnScriptStreaming(liveScript, liveArgs, target);
+  if (result.output) {
+    try {
+      fs.appendFileSync(rebuildLog, result.output);
+    } catch {
+    }
+  }
+  return result;
+}
+export {
+  extensionRebuild,
+  launchExtension
+};

package/dist/commands/{launch.js → launch/index.js}

@@ -1,12 +1,10 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { color } from "../cli-color.js";
-import { handleHarness } from "../harness.js";
-import { recipeHarnessPath, recipeRuntimeDir, recipeRuntimePath, runnerDir } from "../paths.js";
-import { prepareMobile } from "../adapters/mobile/prepare.js";
-import { getAdapterSurface } from "../adapters/surface.js";
-import { stopExtensionWatcher } from "../adapters/slot-ports.js";
+import { color } from "../../cli-color.js";
+import { handleHarness } from "../../harness.js";
+import { recipeRuntimePath, runnerDir } from "../../paths.js";
+import { getAdapterSurface } from "../../adapters/surface.js";
 import {
   ADAPTER_DETECT_NEXT,
   EXIT,
@@ -14,18 +12,19 @@ import {
   parseFlags,
   resolveAdapter,
   spawnScript,
-  spawnScriptStreaming,
   str,
   targetOf,
   usageOut
-} from "./shared.js";
+} from "../shared.js";
 import {
   RECOVERY_CODE,
   checkHealBounds,
   ensureOverlay,
   newHealState,
   parseHeal
-} from "../heal-bounds.js";
+} from "../../heal-bounds.js";
+import { launchExtension } from "./extension.js";
+import { launchMobile } from "./mobile.js";
 const LAUNCH_BOOLEANS = /* @__PURE__ */ new Set([
   "build",
   "watch",
@@ -84,6 +83,9 @@ async function handleLaunch(argv) {
     }
   }
   applyLaunchEnvOverrides(options, adapter, mobileTarget, target);
+  if (adapter === "extension" && typeof options["url"] === "string" && options["url"]) {
+    process.env.EXTENSION_START_URL = options["url"];
+  }
   const tier = wantVerify ? "verify" : wantBuild ? "build" : "quick";
   const state = newHealState();
   if (tier === "quick" && nativeInputsChanged(target, adapter)) {
@@ -107,8 +109,7 @@ async function handleLaunch(argv) {
     const liveArgs = ["live", "--adapter", adapter, "--target", target];
     if (adapter === "mobile" && mobileTarget) liveArgs.push("--platform", mobileTarget);
     if (json) liveArgs.push("--json");
-    const code = await handleHarness(liveArgs);
-    return code;
+    return handleHarness(liveArgs);
   }
   let attempt = await executeComposition(adapter, mobileTarget, tier, wantWatch, target, json);
   if (attempt.status === 0) {
@@ -194,47 +195,16 @@ function nativeInputsChanged(target, adapter) {
 }
 async function executeComposition(adapter, mobileTarget, tier, wantWatch, target, json) {
   if (adapter === "mobile") {
-    const platform = mobileTarget ?? "ios";
-    const watcherPort = process.env.WATCHER_PORT ? parseInt(process.env.WATCHER_PORT, 10) : void 0;
-    const preflightMode = tier === "build" ? "auto" : "fast";
-    return prepareMobile(target, { platform, json, watcherPort, preflightMode });
-  }
-  if (!wantWatch && tier === "quick") {
-    return extensionRebuild(target, json);
-  }
-  const startWatchSh = path.join(runnerDir, "adapters/extension/start-watch.sh");
-  const watchArgs = ["--target", target];
-  if (process.env.WATCHER_PORT) watchArgs.push("--watcher-port", process.env.WATCHER_PORT);
-  console.error(`\u2192 extension ${wantWatch ? "watch" : "build"} \u2014 webpack :${process.env.WATCHER_PORT ?? "default"} (output streams below)`);
-  return spawnScriptStreaming(startWatchSh, watchArgs, target);
-}
-async function extensionRebuild(target, json) {
-  const runtimeDirRel = recipeRuntimeDir();
-  const runtimeAbs = path.join(target, runtimeDirRel);
-  const rebuildLog = path.join(runtimeAbs, "rebuild.log");
-  stopExtensionWatcher(target);
-  fs.mkdirSync(path.dirname(rebuildLog), { recursive: true });
-  fs.writeFileSync(rebuildLog, "");
-  const liveScript = recipeHarnessPath(target, "extension", "scripts", "live.sh");
-  const liveArgs = ["--target", target, "--start-watch"];
-  if (process.env.CDP_PORT) liveArgs.push("--cdp-port", process.env.CDP_PORT);
-  if (process.env.WATCHER_PORT) liveArgs.push("--watcher-port", process.env.WATCHER_PORT);
-  console.error(`\u2192 extension quick relaunch \u2014 webpack :${process.env.WATCHER_PORT ?? "default"} \xB7 CDP :${process.env.CDP_PORT ?? "default"} (output streams below)`);
-  const result = await spawnScriptStreaming(liveScript, liveArgs, target);
-  if (result.output) {
-    try {
-      fs.appendFileSync(rebuildLog, result.output);
-    } catch {
-    }
+    return launchMobile(target, mobileTarget, tier, json);
   }
-  return result;
+  return launchExtension(target, tier, wantWatch);
 }
 function finishLaunch(json, adapter, mobileTarget, tier, displayMode, target, state) {
   if (adapter === "extension" && displayMode === "sidepanel") {
     const sidepanelSh = path.join(runnerDir, "adapters/extension/sidepanel-toggle.sh");
     const sidepanelArgs = ["open"];
     if (process.env.CDP_PORT) sidepanelArgs.push("--cdp-port", process.env.CDP_PORT);
-    const sidepanel = spawnScript(sidepanelSh, sidepanelArgs, target, json);
+    const sidepanel = spawnScript(sidepanelSh, sidepanelArgs, target, json, { REPO: target });
     if (sidepanel.status !== 0) {
       return launchFail(json, adapter, mobileTarget, tier, state, {
         code: "SIDEPANEL_OPEN_FAILED",
@@ -300,8 +270,6 @@ function launchFail(json, adapter, mobileTarget, tier, state, failure) {
             message: failure.message,
             retryable: failure.recoverable,
             userAction: failure.userAction ?? null,
-            // The classification note is in `message`; the REAL failure text lives
-            // here verbatim so it is never lost.
             originalError: failure.originalError ?? null
           }
         },

package/dist/commands/launch/mobile.js

@@ -0,0 +1,10 @@
+import { prepareMobile } from "../../adapters/mobile/prepare.js";
+async function launchMobile(target, mobileTarget, tier, json) {
+  const platform = mobileTarget ?? "ios";
+  const watcherPort = process.env.WATCHER_PORT ? parseInt(process.env.WATCHER_PORT, 10) : void 0;
+  const preflightMode = tier === "build" ? "auto" : "fast";
+  return prepareMobile(target, { platform, json, watcherPort, preflightMode });
+}
+export {
+  launchMobile
+};

package/dist/commands/manifest.js

@@ -0,0 +1,72 @@
+import { loadActionManifest, validateManifest } from "../manifest.js";
+import {
+  actionManifestPathOption,
+  isRecord,
+  optionFlag,
+  optionString,
+  resolveAdapter
+} from "./parse-args.js";
+async function handleManifest({ options }) {
+  const { adapter } = resolveAdapter(options);
+  const actionManifestPath = actionManifestPathOption(options, adapter);
+  const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
+  await validateManifest(manifest);
+  if (optionFlag(options, "json")) console.log(JSON.stringify(manifest, null, 2));
+  else console.log(actionManifestPath);
+  return 0;
+}
+async function handleActions({ options }) {
+  const { adapter } = resolveAdapter(options);
+  const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
+  await validateManifest(manifest);
+  const action = optionString(options, "action");
+  const actions = describeManifestActions(manifest, action);
+  if (optionFlag(options, "json")) {
+    console.log(JSON.stringify({ adapter, actions }, null, 2));
+  } else {
+    for (const entry of actions) {
+      const fields = entry.fields.length ? ` fields=${entry.fields.join(",")}` : "";
+      console.log(`${entry.name} (${entry.kind})${fields}${entry.description ? ` \u2014 ${entry.description}` : ""}`);
+    }
+  }
+  return 0;
+}
+function describeManifestActions(manifest, filterAction) {
+  const manifestRecord = isRecord(manifest) ? manifest : {};
+  const metadata = isRecord(manifestRecord.action_metadata) ? manifestRecord.action_metadata : {};
+  const official = Array.isArray(manifestRecord.supported_official_actions) ? manifestRecord.supported_official_actions.filter((value) => typeof value === "string") : [];
+  const custom = Array.isArray(manifestRecord.custom_actions) ? manifestRecord.custom_actions.flatMap((entry) => {
+    if (typeof entry === "string") return [{ name: entry, metadata: metadata[entry] }];
+    if (isRecord(entry) && typeof entry.name === "string") {
+      const entryMetadata = { ...entry };
+      const metadataOverride = metadata[entry.name];
+      if (isRecord(metadataOverride)) Object.assign(entryMetadata, metadataOverride);
+      return [{ name: entry.name, metadata: entryMetadata }];
+    }
+    return [];
+  }) : [];
+  const entries = [
+    ...official.map((name) => describeManifestAction(name, "official", metadata[name])),
+    ...custom.map((entry) => describeManifestAction(entry.name, "custom", entry.metadata))
+  ].filter((entry) => !filterAction || entry.name === filterAction);
+  if (filterAction && entries.length === 0) throw new Error(`Action not found in manifest: ${filterAction}`);
+  return entries;
+}
+function describeManifestAction(name, kind, metadata) {
+  const record = isRecord(metadata) ? metadata : {};
+  const schema = record.schema;
+  const schemaRecord = isRecord(schema) ? schema : {};
+  const properties = isRecord(schemaRecord.properties) ? Object.keys(schemaRecord.properties).sort() : [];
+  return {
+    name,
+    kind,
+    description: typeof record.description === "string" ? record.description : "",
+    fields: properties,
+    schema,
+    examples: record.examples
+  };
+}
+export {
+  handleActions,
+  handleManifest
+};