@deeeed/metamask-harness 0.79.0 → 0.81.0

package/dist/commands/parse-args.js

@@ -1,279 +0,0 @@
-import path from "node:path";
-import { detectAdapter } from "../harness.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";
-class CliError extends Error {
-  exitCode;
-  constructor(message, exitCode) {
-    super(message);
-    this.name = "CliError";
-    this.exitCode = exitCode;
-  }
-}
-function usageError(message) {
-  return new CliError(message, EXIT.usage);
-}
-function parseArgs(argv, command) {
-  const positional = [];
-  const options = {};
-  const booleanOptions = /* @__PURE__ */ new Set([
-    "json",
-    "jsonStream",
-    "launchExistingDist",
-    "startWatch",
-    "buildLavamoat",
-    "resetProfile",
-    "preserveProfile",
-    "record",
-    "plan",
-    "proof",
-    "list",
-    "describe",
-    "raw",
-    "matrix",
-    "categories",
-    "fix",
-    "force",
-    "clearMetro",
-    "resolveOnly",
-    "expectLive",
-    "printReady",
-    "fast",
-    "allDevices",
-    "watch",
-    "help",
-    "noOpen"
-  ]);
-  const repeatableOptions = /* @__PURE__ */ new Set(["library"]);
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (!arg.startsWith("--")) {
-      positional.push(arg);
-      continue;
-    }
-    const body = arg.slice(2);
-    const equalsIndex = body.indexOf("=");
-    const rawKey = equalsIndex === -1 ? body : body.slice(0, equalsIndex);
-    const inlineValue = equalsIndex === -1 ? void 0 : body.slice(equalsIndex + 1);
-    const key = normalizeOptionKey(rawKey);
-    if (key === "recordVideo") {
-      options.recordVideo = parseRecordVideoMode(inlineValue);
-      continue;
-    }
-    if (key === "recordBaseline") {
-      options.record = true;
-      continue;
-    }
-    if (key === "record") {
-      if (command === "runtime-decision") {
-        options.record = true;
-        continue;
-      }
-      options.recordVideo = "full-run";
-      continue;
-    }
-    if (booleanOptions.has(key)) {
-      options[key] = true;
-      continue;
-    }
-    if (inlineValue !== void 0) {
-      assignOption(options, key, inlineValue, repeatableOptions);
-      continue;
-    }
-    if (i + 1 >= argv.length) throw usageError(`Missing value for ${arg}`);
-    assignOption(options, key, argv[i + 1], repeatableOptions);
-    i += 1;
-  }
-  return { positional, options, rawArgv: [...argv] };
-}
-function assignOption(options, key, value, repeatableOptions) {
-  if (!repeatableOptions.has(key)) {
-    options[key] = value;
-    return;
-  }
-  const existing = options[key];
-  if (existing === void 0) {
-    options[key] = [value];
-    return;
-  }
-  if (!Array.isArray(existing)) throw usageError(`--${key} has conflicting values.`);
-  options[key] = [...existing, value];
-}
-function parseRecipeParamAssignments(values) {
-  const params = {};
-  for (const assignment of values) {
-    const separator = assignment.indexOf("=");
-    if (separator <= 0) {
-      throw usageError(`recipe parameter ${JSON.stringify(assignment)} must use key=value.`);
-    }
-    const key = assignment.slice(0, separator).trim();
-    if (!key) throw usageError(`recipe parameter ${JSON.stringify(assignment)} has an empty key.`);
-    if (Object.hasOwn(params, key)) {
-      throw usageError(`recipe parameter ${JSON.stringify(key)} was provided more than once.`);
-    }
-    const raw = assignment.slice(separator + 1);
-    let value;
-    try {
-      value = JSON.parse(raw);
-    } catch {
-      value = raw;
-    }
-    Object.defineProperty(params, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  }
-  return params;
-}
-function parseRecordVideoMode(value) {
-  if (value === void 0 || value === "" || value === "true") return "full-run";
-  if (value === "off" || value === "false") return false;
-  if (value === "proof-window" || value === "proof_window") {
-    throw usageError(
-      "--record-video=proof-window is not supported yet; use --record-video=full-run."
-    );
-  }
-  if (value !== "full-run") {
-    throw usageError("--record-video must be full-run or off.");
-  }
-  return "full-run";
-}
-function normalizeOptionKey(key) {
-  return key.replace(/-([a-z])/gu, (_, character) => character.toUpperCase());
-}
-function optionString(options, key) {
-  const value = options[key];
-  if (value === void 0) return void 0;
-  if (typeof value !== "string") throw usageError(`--${key} requires a value.`);
-  return value;
-}
-function optionStrings(options, key) {
-  const value = options[key];
-  if (value === void 0) return void 0;
-  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
-    throw usageError(`--${key} requires a value.`);
-  }
-  return value;
-}
-function optionFlag(options, key) {
-  const value = options[key];
-  return value === true;
-}
-function applyRuntimeDirOption(options) {
-  const runtimeDir = optionString(options, "runtimeDir");
-  if (runtimeDir) process.env.RECIPE_RUNTIME_DIR = runtimeDir;
-}
-function applyWatcherPortOption(options) {
-  const watcherPort = optionString(options, "watcherPort");
-  if (!watcherPort) return;
-  process.env.WATCHER_PORT = watcherPort;
-  process.env.RECIPE_WATCHER_PORT = watcherPort;
-  process.env.METRO_PORT = watcherPort;
-}
-function requiredOption(options, key, message) {
-  const value = optionString(options, key);
-  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 adapterUsageError(error);
-  }
-  return adapter;
-}
-function targetPath(options) {
-  return path.resolve(optionString(options, "target") ?? process.cwd());
-}
-function actionManifestPathOption(options, adapter) {
-  const configured = optionString(options, "actionManifest");
-  return configured ? path.resolve(configured) : adapterRegistry.get(adapter).actions.manifestPath();
-}
-function parsePort(value, errorMessage) {
-  const port = Number(value);
-  if (!Number.isInteger(port) || port <= 0) throw usageError(errorMessage);
-  return port;
-}
-function runtimeOptionsFromCli(options) {
-  const recordVideo = options.recordVideo;
-  const hud = optionString(options, "hud");
-  const trust = explicitRecipeTrustOptions({
-    sourceTrust: optionString(options, "sourceTrust"),
-    sourceKind: optionString(options, "sourceKind"),
-    sourceName: optionString(options, "sourceName"),
-    sourceDigest: optionString(options, "sourceDigest"),
-    approvalDigest: optionString(options, "approvePlan")
-  });
-  return {
-    cdpPort: optionString(options, "cdpPort"),
-    watcherPort: optionString(options, "watcherPort") ?? optionString(options, "metroPort"),
-    launchExistingDist: optionFlag(options, "launchExistingDist"),
-    slot: optionString(options, "slot"),
-    validationRuntimeDir: optionString(options, "validationRuntimeDir"),
-    recordVideo: recordVideo === "full-run" ? "full-run" : false,
-    autoHud: hud === "show" ? true : hud === "hide" ? false : void 0,
-    fundingRequest: optionString(options, "fundingRequest"),
-    fundingPreflight: optionString(options, "fundingPreflight"),
-    fundingReleaseProof: optionString(options, "fundingReleaseProof"),
-    fundingBalanceProof: optionString(options, "fundingBalanceProof"),
-    ...trust
-  };
-}
-function resolveAdapter(options) {
-  const target = targetPath(options);
-  const adapterOptionValue = optionString(options, "adapter");
-  const platformOptionValue = optionString(options, "platform");
-  const explicit = adapterOptionValue ?? (platformOptionValue === "ios" || platformOptionValue === "android" ? "mobile" : platformOptionValue);
-  const adapter = explicit ?? detectAdapter(target);
-  if (!adapter) {
-    throw usageError(`could not detect the MetaMask repo type for ${target}
-  Next: ${ADAPTER_DETECT_NEXT}`);
-  }
-  try {
-    assertAdapter(adapter);
-  } catch (error) {
-    throw adapterUsageError(error);
-  }
-  return { adapter, target };
-}
-function shellQuote(value) {
-  return `'${value.replace(/'/gu, `'\\''`)}'`;
-}
-function shellQuoteArg(value) {
-  return /^[A-Za-z0-9_./:=@+-]+$/u.test(value) ? value : shellQuote(value);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export {
-  CliError,
-  actionManifestPathOption,
-  adapterOption,
-  applyRuntimeDirOption,
-  applyWatcherPortOption,
-  isRecord,
-  optionFlag,
-  optionString,
-  optionStrings,
-  parseArgs,
-  parsePort,
-  parseRecipeParamAssignments,
-  requiredOption,
-  resolveAdapter,
-  runtimeOptionsFromCli,
-  shellQuote,
-  shellQuoteArg,
-  targetPath,
-  usageError
-};

package/dist/commands/reload.js

@@ -1,41 +0,0 @@
-import { getAdapterSurface } from "../adapters/surface.js";
-import {
-  ADAPTER_DETECT_NEXT,
-  flag,
-  parseFlags,
-  resolveAdapter,
-  targetOf,
-  usageOut
-} from "./shared.js";
-const RELOAD_BOOLEANS = /* @__PURE__ */ new Set(["json"]);
-async function handleReload(argv) {
-  const { options } = parseFlags(argv, RELOAD_BOOLEANS);
-  const json = flag(options, "json");
-  const target = targetOf(options);
-  const adapter = resolveAdapter(options, target);
-  if (!adapter) {
-    return usageOut(
-      json,
-      "reload",
-      `could not detect the MetaMask repo type for ${target}`,
-      ADAPTER_DETECT_NEXT
-    );
-  }
-  const surface = getAdapterSurface(adapter);
-  if (surface.headless) {
-    return usageOut(
-      json,
-      "reload",
-      `${adapter} is headless; there is no app runtime to reload.`,
-      `mm-harness run <${adapter}-recipe>`
-    );
-  }
-  if (!surface.reload) {
-    return usageOut(json, "reload", `reload does not support the ${adapter} adapter.`, surface.hints.launch);
-  }
-  surface.resolveSlotPorts(target);
-  return surface.reload(target, json);
-}
-export {
-  handleReload
-};