@deeeed/metamask-harness 0.4.0 → 0.5.1

package/dist/cli-commands.js

@@ -0,0 +1,224 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const SPEC = {
+  shim: [
+    { name: "sync", desc: "Copy fixture, write slot context, install harness", flags: ["--dry-run", "--no-install"] },
+    { name: "help", aliases: ["-h", "--help"], desc: "Show usage" }
+  ],
+  shared: [
+    { name: "status", aliases: ["health", "home"], desc: "Home status + next commands", flags: ["--json"] },
+    { name: "ports", desc: "Slot ports and runtime paths", flags: ["--json"] },
+    { name: "up", desc: "Decide + run minimum work to reach ready", flags: ["--json", "--dry-run"] },
+    { name: "sync", desc: "Refresh harness + canonicalize wallet fixture", flags: ["--json"] },
+    { name: "logs", aliases: ["tail"], desc: "Compact build events or full log", flags: ["--full", "-f"] },
+    { name: "debug", aliases: ["devtools", "inspect"], desc: "Open DevTools UI", flags: ["--json", "--no-open"] },
+    { name: "actions", desc: "List runnable recipe actions", flags: ["--json"] },
+    { name: "doctor", desc: "Check harness/orchestration health", flags: ["--json", "--target", "--adapter", "--runtime-dir"] },
+    { name: "run", desc: "Execute a proof recipe", args: ["recipe.json"] },
+    { name: "interactive", aliases: ["menu"], desc: "Interactive command menu" },
+    { name: "prepare", desc: "Install harness (+ optional validate)", flags: ["--target", "--runtime-dir", "--json"] },
+    { name: "runtime-status", desc: "Structured runtime status JSON", flags: ["--json", "--target", "--cdp-port", "--runtime-dir"] }
+  ],
+  extension: [
+    { name: "decision", aliases: ["decide"], desc: "Runtime decision (what next?)" },
+    { name: "update", aliases: ["sync-runtime"], desc: "Perform recommended runtime action" },
+    { name: "ready", aliases: ["ensure-ready"], desc: "Ensure one healthy extension home tab" },
+    { name: "watch", aliases: ["start-watch", "watcher"], desc: "Start/reuse webpack watcher", flags: ["--full", "-f"] },
+    { name: "stop", aliases: ["stop-watch", "stop-watcher"], desc: "Stop this checkout watcher" },
+    { name: "rebuild", aliases: ["reset", "reopen", "reload", "browser", "launch", "full-launch", "runtime-launch", "build", "build:once", "build-once", "refresh-once"], desc: "Clean webpack + browser launch", flags: ["--json", "--dry-run", "--full"] },
+    { name: "sidepanel", desc: "Side panel helper", args: ["cycle", "open", "close", "toggle", "status"] },
+    { name: "prepare", flags: ["--target", "--cdp-port", "--runtime-dir", "--validate"] },
+    { name: "debug", args: ["page", "worker"], flags: ["--json", "--no-open"] }
+  ],
+  mobile: [
+    { name: "ios", aliases: ["start"], desc: "Start Metro + launch iOS dev client" },
+    { name: "android", desc: "Start Metro + launch Android dev client" },
+    { name: "setup:ios", desc: "iOS launch + wallet fixture setup" },
+    { name: "setup:android", desc: "Android launch + wallet fixture setup" },
+    { name: "stop", desc: "Stop Metro for this slot" },
+    { name: "app-status", aliases: ["bridge-status"], desc: "Bridge/runtime status" },
+    { name: "route", aliases: ["get-route"], desc: "Current navigation route" },
+    { name: "navigate", desc: "Navigate by route name", args: ["RouteName"] },
+    { name: "back", aliases: ["go-back"], desc: "Navigate back" },
+    { name: "unlock", desc: "Unlock with fixture password", args: ["password"] },
+    { name: "setup-wallet", aliases: ["wallet-setup"], desc: "Apply wallet fixture", args: ["fixture.json"] },
+    { name: "accounts", aliases: ["list-accounts"], desc: "List accounts" },
+    { name: "select-account", aliases: ["switch-account"], desc: "Switch account", args: ["address"] },
+    { name: "screenshot", desc: "Capture simulator/device screenshot", args: ["path"] },
+    { name: "dev-menu", aliases: ["devmenu"], desc: "Open RN developer menu", flags: ["--json", "--no-open"] },
+    { name: "prepare", flags: ["--target", "--platform", "--preflight-mode", "--port", "--simulator", "--adb-serial", "--runtime-dir", "--wallet-setup", "--wallet-fixture"] },
+    { name: "debug", flags: ["--json", "--no-open", "--action"] }
+  ]
+};
+const GLOBAL_FLAGS = ["--json", "--dry-run", "--full", "-f", "--help", "-h", "--no-open", "--no-color"];
+function mergeCommands(adapter) {
+  const byName = /* @__PURE__ */ new Map();
+  const add = (cmd) => {
+    const existing = byName.get(cmd.name);
+    if (!existing) {
+      byName.set(cmd.name, {
+        ...cmd,
+        aliases: [...cmd.aliases || []],
+        flags: [...cmd.flags || []],
+        args: [...cmd.args || []]
+      });
+      return;
+    }
+    existing.aliases = [.../* @__PURE__ */ new Set([...existing.aliases || [], ...cmd.aliases || []])];
+    existing.flags = [.../* @__PURE__ */ new Set([...existing.flags || [], ...cmd.flags || []])];
+    existing.args = [.../* @__PURE__ */ new Set([...existing.args || [], ...cmd.args || []])];
+    if (!existing.desc && cmd.desc) existing.desc = cmd.desc;
+  };
+  for (const cmd of SPEC.shared) add(cmd);
+  for (const cmd of SPEC[adapter] || []) add(cmd);
+  return [...byName.values()];
+}
+function commandTokens(adapter, { includeAliases = true } = {}) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const cmd of mergeCommands(adapter)) {
+    tokens.add(cmd.name);
+    if (includeAliases) for (const alias of cmd.aliases || []) tokens.add(alias);
+  }
+  return [...tokens].sort();
+}
+function shimCommandTokens() {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const cmd of SPEC.shim) {
+    tokens.add(cmd.name);
+    for (const alias of cmd.aliases || []) tokens.add(alias);
+  }
+  return [...tokens].sort();
+}
+function lookupCommand(adapter, token) {
+  for (const cmd of mergeCommands(adapter)) {
+    if (cmd.name === token) return cmd;
+    if ((cmd.aliases || []).includes(token)) return cmd;
+  }
+  for (const cmd of SPEC.shim) {
+    if (cmd.name === token) return cmd;
+    if ((cmd.aliases || []).includes(token)) return cmd;
+  }
+  return null;
+}
+function flagsForPosition(adapter, commandToken) {
+  const cmd = lookupCommand(adapter, commandToken);
+  const flags = new Set(GLOBAL_FLAGS);
+  if (cmd) for (const flag of cmd.flags || []) flags.add(flag);
+  return [...flags].sort();
+}
+function argsForPosition(adapter, commandToken, argIndex) {
+  const cmd = lookupCommand(adapter, commandToken);
+  if (!cmd?.args?.length) return [];
+  const value = cmd.args[Math.max(0, argIndex)];
+  return value ? [value] : cmd.args;
+}
+const RUN_RECIPE_DIRS = [
+  (adapter, root) => path.join(root, "temp/recipe/harness", adapter, "runner/recipes"),
+  (adapter, root) => path.join(root, "temp/agentic/recipe-harness", adapter, "runner/recipes")
+];
+function listRunRecipes(adapter, root, cwd = process.cwd()) {
+  const byBase = /* @__PURE__ */ new Map();
+  for (const resolveDir of RUN_RECIPE_DIRS) {
+    const dir = resolveDir(adapter, root);
+    if (!fs.existsSync(dir)) continue;
+    for (const name of fs.readdirSync(dir)) {
+      if (!name.endsWith(".recipe.json") || byBase.has(name)) continue;
+      byBase.set(name, path.join(dir, name));
+    }
+  }
+  return [...byBase.values()].map((abs) => path.relative(cwd, abs)).sort();
+}
+function usage() {
+  process.stderr.write(`Usage:
+  cli-commands dump --adapter extension|mobile|shim [--aliases]
+  cli-commands describe --adapter extension|mobile|shim
+  cli-commands flags --adapter <adapter> --command <name>
+  cli-commands args --adapter <adapter> --command <name> [--index <n>]
+  cli-commands run-recipes --adapter extension|mobile --root <repo> [--cwd <dir>]
+  cli-commands global-flags
+`);
+}
+async function main() {
+  const { parseArgs: parseArgsUtil } = await import("node:util");
+  const { values, positionals } = parseArgsUtil({
+    allowPositionals: true,
+    args: process.argv.slice(2),
+    options: {
+      adapter: { type: "string" },
+      command: { type: "string" },
+      aliases: { type: "boolean", default: true },
+      index: { type: "string", default: "0" },
+      root: { type: "string" },
+      cwd: { type: "string" }
+    }
+  });
+  const command = positionals[0];
+  if (!command || command === "--help" || command === "-h") {
+    usage();
+    process.exit(command ? 0 : 2);
+  }
+  if (command === "global-flags") {
+    process.stdout.write(`${GLOBAL_FLAGS.join("\n")}
+`);
+    return;
+  }
+  const adapter = values.adapter;
+  if (!adapter && command !== "global-flags") {
+    usage();
+    process.exit(2);
+  }
+  if (command === "dump") {
+    process.stdout.write(`${commandTokens(adapter, { includeAliases: values.aliases }).join("\n")}
+`);
+    return;
+  }
+  if (command === "describe") {
+    const rows = adapter === "shim" ? SPEC.shim : mergeCommands(adapter);
+    for (const cmd of rows) {
+      const aliases = (cmd.aliases || []).join("|");
+      const label = aliases ? `${cmd.name}|${aliases}` : cmd.name;
+      process.stdout.write(`${label}	${cmd.desc || cmd.name}
+`);
+    }
+    return;
+  }
+  if (command === "flags") {
+    process.stdout.write(`${flagsForPosition(adapter, values.command || "").join("\n")}
+`);
+    return;
+  }
+  if (command === "args") {
+    const index = Number.parseInt(values.index, 10) || 0;
+    process.stdout.write(`${argsForPosition(adapter, values.command || "", index).join("\n")}
+`);
+    return;
+  }
+  if (command === "run-recipes") {
+    const root = values.root ? path.resolve(values.root) : process.cwd();
+    const cwd = values.cwd ? path.resolve(values.cwd) : process.cwd();
+    process.stdout.write(`${listRunRecipes(adapter, root, cwd).join("\n")}
+`);
+    return;
+  }
+  usage();
+  process.exit(2);
+}
+const _filename = fileURLToPath(import.meta.url);
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === _filename;
+if (isMain) {
+  main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  SPEC,
+  argsForPosition,
+  commandTokens,
+  flagsForPosition,
+  listRunRecipes,
+  lookupCommand,
+  shimCommandTokens
+};

package/dist/cli-version.js

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { parseArgs } from "node:util";
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readPackageVersion(dir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+    return pkg.version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function gitHead(dir) {
+  const result = spawnSync("git", ["-C", dir, "rev-parse", "HEAD"], { encoding: "utf8" });
+  return result.status === 0 ? result.stdout.trim() : "unknown";
+}
+function checkHarness({ runnerRoot, manifestPath }) {
+  const manifest = readJson(manifestPath);
+  const reasons = [];
+  if (!manifest) {
+    return { stale: false, reasons: ["no harness manifest"] };
+  }
+  const currentRevision = gitHead(runnerRoot);
+  const currentVersion = readPackageVersion(runnerRoot);
+  const manifestRecord = manifest;
+  const source = manifestRecord.source;
+  const installedRevision = source?.runnerRevision || null;
+  const installedVersion = manifestRecord.runnerPackageVersion || null;
+  if (installedRevision && installedRevision !== "unknown" && installedRevision !== currentRevision) {
+    reasons.push(`runner revision ${installedRevision.slice(0, 8)} != ${currentRevision.slice(0, 8)}`);
+  }
+  if (installedVersion && installedVersion !== currentVersion) {
+    reasons.push(`runner package ${installedVersion} != ${currentVersion}`);
+  }
+  return {
+    stale: reasons.length > 0,
+    reasons,
+    installedRevision,
+    currentRevision,
+    installedVersion,
+    currentVersion
+  };
+}
+function usage() {
+  console.error(`Usage:
+  cli-version check --runner-root <dir> --manifest <path> [--installed-sha <path>] [--json]`);
+}
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  const { values } = parseArgs({
+    args: rest,
+    allowPositionals: false,
+    options: {
+      "runner-root": { type: "string" },
+      manifest: { type: "string" },
+      "installed-sha": { type: "string" },
+      json: { type: "boolean", default: false }
+    }
+  });
+  if (!command || command === "--help" || command === "-h") {
+    usage();
+    process.exit(command ? 0 : 2);
+  }
+  if (command !== "check") {
+    usage();
+    process.exit(2);
+  }
+  const runnerRoot = values["runner-root"];
+  const manifestPath = values.manifest;
+  if (!runnerRoot || !manifestPath) {
+    usage();
+    process.exit(2);
+  }
+  const payload = {
+    ...checkHarness({
+      runnerRoot,
+      manifestPath,
+      installedShaPath: values["installed-sha"]
+    }),
+    manifest: manifestPath
+  };
+  if (values.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return;
+  }
+  if (payload.stale) {
+    process.stderr.write(`recipe: harness stale (${payload.reasons.join("; ")})
+`);
+    process.stderr.write("recipe: run: recipe sync\n");
+    process.exit(1);
+  }
+  process.stdout.write("harness up to date\n");
+}
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(import.meta.filename ?? "");
+if (isMain) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+export {
+  checkHarness
+};