@deeeed/metamask-harness 0.78.0 → 0.80.0

package/dist/commands/last.js

@@ -1,60 +0,0 @@
-import { readCommandJournal } from "../command-journal.js";
-import { EXIT } from "./shared.js";
-import {
-  optionFlag,
-  optionString,
-  shellQuote,
-  targetPath
-} from "./parse-args.js";
-async function handleLast({ options }) {
-  const target = targetPath(options);
-  const { file, record } = readCommandJournal(target, optionString(options, "runtimeDir"));
-  const json = optionFlag(options, "json");
-  if (!record) {
-    const message = `no resumability journal exists for ${target}`;
-    const userAction = "run a proof or runtime command in this checkout, then re-run mm-harness last --json";
-    if (json) {
-      console.log(JSON.stringify({
-        schemaVersion: 1,
-        command: "last",
-        target,
-        journalPath: file,
-        status: "fail",
-        exitCode: EXIT.runtime,
-        error: { code: "LAST_NOT_FOUND", message, userAction }
-      }, null, 2));
-    } else {
-      console.error(`\u2717 mm-harness last: ${message}
-  Next: ${userAction}`);
-    }
-    return EXIT.runtime;
-  }
-  if (json) {
-    console.log(JSON.stringify({
-      schemaVersion: 1,
-      command: "last",
-      target,
-      journalPath: file,
-      status: "pass",
-      exitCode: EXIT.ok,
-      last: record
-    }, null, 2));
-  } else {
-    const end = record.finishedAt ?? "still running or interrupted";
-    console.log(`${record.verdict.toUpperCase()} ${record.command} (exit ${record.exitCode ?? "pending"})`);
-    console.log(`command: mm-harness ${record.command}${record.args.length > 0 ? ` ${record.args.map(shellQuote).join(" ")}` : ""}`);
-    console.log(`started: ${record.startedAt}`);
-    console.log(`finished: ${end}`);
-    if (record.evidencePaths.length > 0) {
-      console.log("evidence:");
-      for (const evidence of record.evidencePaths) console.log(`  ${evidence}`);
-    } else {
-      console.log("evidence: none recorded");
-    }
-    console.log(`journal: ${file}`);
-  }
-  return EXIT.ok;
-}
-export {
-  handleLast
-};

package/dist/commands/launch/index.js

@@ -1,109 +0,0 @@
-import fs from "node:fs";
-import { getAdapterSurface } from "../../adapters/surface.js";
-import {
-  ADAPTER_DETECT_NEXT,
-  checkoutBusyOut,
-  EXIT,
-  flag,
-  parseFlags,
-  resolveAdapter,
-  str,
-  targetOf,
-  usageOut
-} from "../shared.js";
-import { parseHeal } from "../../heal-bounds.js";
-import { acquireCheckoutLock } from "../../checkout-lock.js";
-import { JsonStreamWriter } from "../../json-stream.js";
-import { shellQuote } from "./quote.js";
-const LAUNCH_BOOLEANS = /* @__PURE__ */ new Set([
-  "build",
-  "watch",
-  "verify",
-  "sidepanel",
-  "fullscreen",
-  "runway",
-  "clearMetro",
-  "json",
-  "jsonStream",
-  "freshProfile",
-  "headless",
-  "headful"
-]);
-async function handleLaunch(argv) {
-  const { options } = parseFlags(argv, LAUNCH_BOOLEANS);
-  const json = flag(options, "json");
-  const stream = new JsonStreamWriter("launch", flag(options, "jsonStream"));
-  const jsonOutput = json && !stream.enabled;
-  const restoreStdout = stream.isolateStdout();
-  const target = targetOf(options);
-  try {
-    let exitCode;
-    if (!fs.existsSync(target)) {
-      exitCode = await handleLaunchLocked(argv, stream);
-    } else {
-      const lock = acquireCheckoutLock(target, "launch");
-      if ("message" in lock) {
-        const userAction = `wait for the current owner, or inspect ${lock.path} if its process has exited`;
-        stream.error({ code: "SANDBOX_BUSY", message: lock.message, userAction });
-        exitCode = checkoutBusyOut(jsonOutput, "launch", lock.message, lock.path);
-      } else {
-        try {
-          exitCode = await handleLaunchLocked(argv, stream);
-        } finally {
-          lock.release();
-        }
-      }
-    }
-    stream.complete(exitCode === EXIT.ok ? "pass" : "fail", exitCode);
-    return exitCode;
-  } catch (error) {
-    const exitCode = error !== null && typeof error === "object" && "exitCode" in error && typeof error.exitCode === "number" ? error.exitCode : EXIT.runtime;
-    stream.error({
-      code: exitCode === EXIT.usage ? "CLI_USAGE_ERROR" : "LAUNCH_FAILED",
-      message: error instanceof Error ? error.message : String(error),
-      userAction: `mm-harness doctor --target ${shellQuote(target)} --json`
-    });
-    stream.complete("fail", exitCode);
-    throw error;
-  } finally {
-    restoreStdout();
-  }
-}
-async function handleLaunchLocked(argv, stream) {
-  const { positional, options } = parseFlags(argv, LAUNCH_BOOLEANS);
-  const json = flag(options, "json");
-  const jsonOutput = json && !stream.enabled;
-  const machine = json || stream.enabled;
-  const target = targetOf(options);
-  const heal = parseHeal(options, "auto");
-  if (typeof heal !== "string") return launchUsage(jsonOutput, stream, heal.error, "use --heal off|infra-only|auto");
-  const posToken = positional[0];
-  const mobileTargetToken = posToken === "ios" || posToken === "android" ? posToken : void 0;
-  const platformFlag = str(options, "platform");
-  const platformMobileToken = platformFlag === "ios" || platformFlag === "android" ? platformFlag : void 0;
-  const mobileTarget = mobileTargetToken ?? platformMobileToken;
-  const adapterHint = mobileTarget ? "mobile" : void 0;
-  const adapter = resolveAdapter(options, target, adapterHint);
-  if (!adapter) {
-    return launchUsage(jsonOutput, stream, `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
-  }
-  stream.phase("resolve", { target, adapter, platform: mobileTarget ?? null });
-  return getAdapterSurface(adapter).launch({
-    adapter,
-    target,
-    options,
-    mobileTarget,
-    heal,
-    jsonOutput,
-    machine,
-    stream,
-    usage: (message, userAction) => launchUsage(jsonOutput, stream, message, userAction)
-  });
-}
-function launchUsage(json, stream, message, userAction) {
-  stream.error({ code: "USAGE", message, userAction });
-  return usageOut(json, "launch", message, userAction);
-}
-export {
-  handleLaunch
-};

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
-};