@deeeed/metamask-harness 0.92.22 → 0.92.23

package/dist/commands/prepare.js

@@ -1,433 +0,0 @@
-import { acquireCheckoutLock, trackCheckoutChild, recordCommandStage, color, stripAnsi, harnessExecutable, recipeRuntimeDir, contextAdapter, optionFlag, optionString, parseArgs, targetPath, usageError, EXIT } from "@farmslot/recipe-cli/harness";
-import { spawn } from "node:child_process";
-import { OperationOutputTail } from "@farmslot/recipe-runner/runtime/operation";
-import fs from "node:fs";
-import path from "node:path";
-import {
-  READINESS_RECORD
-} from "@farmslot/protocol";
-import { runnerProvenance } from "../doctor.js";
-import { adapterRegistry } from "../adapters/registry.js";
-import { getAdapterSurface } from "../adapters/surface.js";
-import { PREPARE_PROGRESS_ARTIFACT } from "../paths.js";
-import { formatDuration } from "./status-watch.js";
-import { FeatureFlagSpecError, parseRemoteFlagSpec } from "../feature-flags.js";
-const USAGE = "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]";
-const REPORT_DIR = "prepare";
-const SKIPPED_AFTER_FAILURE = "previous step failed";
-function reportPathFor(id) {
-  return path.join(REPORT_DIR, `${id}.json`);
-}
-function reportedError(stdout) {
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout ?? "");
-  } catch {
-    return void 0;
-  }
-  const message = parsed?.error?.message;
-  return typeof message === "string" && message ? message : void 0;
-}
-function skippedStep(id, command, reason) {
-  return { id, command, status: "skipped", exitCode: 0, reason, durationMs: 0 };
-}
-const STEP_MARK = {
-  pending: "\xB7",
-  running: "\u2026",
-  pass: "\u2713",
-  fail: "\u2717",
-  skipped: "\u2013"
-};
-const STEP_STYLE = {
-  pending: "dim",
-  running: "accent",
-  pass: "ok",
-  fail: "err",
-  skipped: "dim"
-};
-const STEP_HINT = {
-  launch: "can take minutes on Mobile: Metro bundle and app start",
-  fixtures: "under a minute"
-};
-function stepChain(surface) {
-  return surface.headless ? ["doctor", "status", "verify"] : ["doctor", "status", "launch", "fixtures", "verify"];
-}
-function lastRunDurations(recordPath) {
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(recordPath, "utf8"));
-  } catch {
-    return {};
-  }
-  const steps = parsed?.steps;
-  if (!Array.isArray(steps)) return {};
-  const durations = {};
-  for (const step of steps) {
-    if (typeof step?.id === "string" && typeof step.durationMs === "number" && step.durationMs > 0) {
-      durations[step.id] = step.durationMs;
-    }
-  }
-  return durations;
-}
-function stepHints(chain, lastRun) {
-  const hints = {};
-  for (const id of chain) {
-    const previous = lastRun[id];
-    const parts = [];
-    if (STEP_HINT[id]) parts.push(STEP_HINT[id]);
-    if (previous !== void 0) parts.push(`last run ${formatDuration(previous)}`);
-    if (parts.length > 0) hints[id] = parts.join(", ");
-  }
-  return hints;
-}
-function stepRowLine(row, width) {
-  const out = (style, text) => color(style, text, { stream: process.stdout });
-  const running = row.state === "pending" || row.state === "running";
-  const elapsed = row.state === "running" && row.startedAt !== void 0 ? ` ${out("dim", formatDuration(Date.now() - row.startedAt))}` : "";
-  const note = running ? row.hint : row.durationMs ? formatDuration(row.durationMs) : void 0;
-  const mark = out(STEP_STYLE[row.state], STEP_MARK[row.state]);
-  return `${mark} ${out(running ? "bold" : "dim", row.id.padEnd(width))}: ${out(STEP_STYLE[row.state], row.state)}${elapsed}${row.reason ? ` \u2014 ${row.reason}` : ""}${note ? ` ${out("dim", `(${note})`)}` : ""}`;
-}
-function createStepView(chain, hints) {
-  const rows = new Map(
-    chain.map((id) => [id, { id, state: "pending", hint: hints[id] }])
-  );
-  const width = Math.max(...chain.map((id) => id.length));
-  const tty = Boolean(process.stdout.isTTY);
-  const block = () => {
-    const terminalColumns = process.stdout.columns;
-    const columns = tty && typeof terminalColumns === "number" && terminalColumns > 0 ? terminalColumns : Number.POSITIVE_INFINITY;
-    return [...rows.values()].map((row) => {
-      const line = stepRowLine(row, width);
-      return stripAnsi(line).length <= columns ? line : stripAnsi(line).slice(0, columns);
-    });
-  };
-  let painted = 0;
-  let lastFrame = "";
-  let ended = false;
-  let timer;
-  const repaint = () => {
-    const lines = block();
-    const frame = lines.join("\n");
-    if (frame === lastFrame) return;
-    lastFrame = frame;
-    const up = painted > 0 ? `\x1B[${painted}A` : "";
-    painted = lines.length;
-    process.stdout.write(`${up}${lines.map((line) => `\x1B[2K${line}`).join("\n")}
-`);
-  };
-  const writeBlock = () => {
-    process.stdout.write(`${block().join("\n")}
-`);
-  };
-  return {
-    begin() {
-      if (tty) repaint();
-      else writeBlock();
-    },
-    start(id, startedAt) {
-      const row = rows.get(id);
-      if (!row) return;
-      row.state = "running";
-      row.startedAt = startedAt;
-      if (!tty) return;
-      repaint();
-      timer = setInterval(repaint, 250);
-    },
-    finish(step) {
-      clearInterval(timer);
-      timer = void 0;
-      const row = rows.get(step.id);
-      if (!row) return;
-      row.state = step.status;
-      row.startedAt = void 0;
-      row.reason = step.reason;
-      row.durationMs = step.durationMs;
-      if (tty) repaint();
-      else process.stdout.write(`${stepRowLine(row, width)}
-`);
-    },
-    // Idempotent: the caller ends the view where the final block belongs in the
-    // output, and a `finally` ends it again on the paths that never got there.
-    // The ticker holds the event loop awake, so this must run either way.
-    end() {
-      if (ended) return;
-      ended = true;
-      clearInterval(timer);
-      timer = void 0;
-      if (!tty) writeBlock();
-    }
-  };
-}
-function spawnStep(executable, args, target) {
-  return new Promise((resolve) => {
-    const child = spawn(executable, [...args], {
-      cwd: target,
-      stdio: ["ignore", "pipe", "pipe"],
-      // The update nudge is an interactive courtesy; it has no place in the
-      // stream a recorded readiness step captures.
-      env: { ...process.env, MM_HARNESS_NO_UPDATE_CHECK: "1" }
-    });
-    if (child.pid) trackCheckoutChild(target, child.pid);
-    let stdout = "";
-    const stderr = new OperationOutputTail();
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr.append(chunk);
-    });
-    child.on("error", (error) => resolve({ error, status: null, stdout, stderr: stderr.toString() }));
-    child.on("close", (status) => resolve({ status, stdout, stderr: stderr.toString() }));
-  });
-}
-async function runStep(executable, target, artifactsDir, id, args, { json, onSpawn }) {
-  const command = [executable, ...args].join(" ");
-  const startedAt = Date.now();
-  onSpawn?.(startedAt);
-  const result = await spawnStep(executable, args, target);
-  const durationMs = Date.now() - startedAt;
-  if (result.error) {
-    return { id, command, status: "fail", exitCode: 1, reason: result.error.message, durationMs };
-  }
-  const report = reportPathFor(id);
-  const file = path.join(artifactsDir, report);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, result.stdout);
-  const exitCode = result.status ?? 1;
-  if (exitCode === 0) {
-    return { id, command, status: "pass", exitCode, reportPath: report, durationMs };
-  }
-  if (!json && result.stderr) process.stderr.write(result.stderr);
-  return {
-    id,
-    command,
-    status: "fail",
-    exitCode,
-    reportPath: report,
-    reason: reportedError(result.stdout) ?? `exited ${exitCode}`,
-    durationMs
-  };
-}
-function readDevices(artifactsDir) {
-  const file = path.join(artifactsDir, reportPathFor("status"));
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return [];
-  }
-  const devices = parsed?.devices;
-  return Array.isArray(devices) ? devices : [];
-}
-function mobileTargetAmbiguityError() {
-  const choices = [
-    "1. iOS     mm-harness prepare --platform mobile --mobile-platform ios",
-    "2. Android mm-harness prepare --platform mobile --mobile-platform android"
-  ];
-  return {
-    code: "PREPARE_MOBILE_TARGET_AMBIGUOUS",
-    message: "could not infer the mobile target from the connected devices",
-    userAction: `choose the mobile target, then rerun this command:
-${choices.join("\n")}`
-  };
-}
-function ambiguousMobileTarget(json) {
-  const { code, message, userAction } = mobileTargetAmbiguityError();
-  if (json) {
-    console.log(
-      JSON.stringify(
-        {
-          schemaVersion: 1,
-          command: "prepare",
-          status: "fail",
-          exitCode: EXIT.runtime,
-          error: { code, message, userAction }
-        },
-        null,
-        2
-      )
-    );
-  } else {
-    console.error(`\u2717 mm-harness prepare: ${message}`);
-    console.error(`  Next: ${userAction}`);
-  }
-  return EXIT.runtime;
-}
-function mobilePlatformOption(value) {
-  if (value === void 0) return void 0;
-  if (value === "ios") return "ios";
-  if (value === "android") return "android";
-  throw usageError(
-    `--mobile-platform must be ios or android; received '${value}'
-  Next: ${USAGE}`
-  );
-}
-function resolvePlatform(target) {
-  const platform = contextAdapter(target);
-  const surface = platform && adapterRegistry.has(platform) ? getAdapterSurface(platform) : void 0;
-  if (surface?.prepare) {
-    return surface;
-  }
-  throw usageError(
-    `could not detect the platform of ${target}
-  Next: ${USAGE}`
-  );
-}
-async function handlePrepare(argv) {
-  const { options } = parseArgs(argv);
-  const target = targetPath(options);
-  if (!fs.existsSync(target)) return handlePrepareLocked(argv);
-  const lock = acquireCheckoutLock(target, "prepare");
-  if ("message" in lock) {
-    if (optionFlag(options, "json")) console.log(JSON.stringify({ status: "fail", error: { code: "SANDBOX_BUSY", message: lock.message }, exitCode: EXIT.runtime }));
-    else console.error(`${lock.message} Next: inspect the owning operation with mm-harness status --watch`);
-    return EXIT.runtime;
-  }
-  try {
-    return await handlePrepareLocked(argv);
-  } finally {
-    lock.release();
-  }
-}
-async function handlePrepareLocked(argv) {
-  const { options } = parseArgs(argv);
-  const json = optionFlag(options, "json");
-  const target = targetPath(options);
-  const surface = resolvePlatform(target);
-  const platform = surface.id;
-  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 && !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 (surface.headless) {
-      throw usageError(`--remote-flag needs an app runtime; this checkout is ${platform}
-  Next: ${USAGE}`);
-    }
-    try {
-      parseRemoteFlagSpec(remoteFlag);
-    } catch (error) {
-      if (!(error instanceof FeatureFlagSpecError)) throw error;
-      throw usageError(`${error.message}
-  Next: ${error.userAction}`);
-    }
-  }
-  const remoteFlagArgs = remoteFlag === void 0 ? [] : ["--remote-flag", remoteFlag];
-  let mobilePlatform = mobilePlatformOption(optionString(options, "mobilePlatform"));
-  const recordPath = path.join(artifactsDir, READINESS_RECORD);
-  const progressPath = path.join(artifactsDir, PREPARE_PROGRESS_ARTIFACT);
-  const chain = stepChain(surface);
-  const view = json ? void 0 : createStepView(chain, stepHints(chain, lastRunDurations(recordPath)));
-  view?.begin();
-  const steps = [];
-  let activeStep;
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const writeProgress = () => {
-    fs.mkdirSync(path.dirname(progressPath), { recursive: true });
-    const temporaryPath = `${progressPath}.${process.pid}.tmp`;
-    fs.writeFileSync(temporaryPath, `${JSON.stringify({
-      schemaVersion: 1,
-      startedAt,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      total: chain.length,
-      steps: steps.filter(({ id }) => chain.includes(id)).map(({ id, status, durationMs }) => ({ id, status, durationMs })),
-      ...activeStep ? { active: activeStep } : {}
-    })}
-`);
-    fs.renameSync(temporaryPath, progressPath);
-  };
-  const failed = () => steps.some((step) => step.status === "fail");
-  const addStep = (step) => {
-    steps.push(step);
-    activeStep = void 0;
-    writeProgress();
-    view?.finish(step);
-    return step;
-  };
-  const run = async (id, args) => {
-    if (failed()) {
-      return addStep(skippedStep(id, [executable, ...args].join(" "), SKIPPED_AFTER_FAILURE));
-    }
-    const step = await runStep(executable, target, artifactsDir, id, args, {
-      json,
-      onSpawn: (stepStartedAt) => {
-        recordCommandStage(id);
-        activeStep = { id, startedAt: new Date(stepStartedAt).toISOString() };
-        writeProgress();
-        view?.start(id, stepStartedAt);
-      }
-    });
-    return addStep(step);
-  };
-  const heartbeat = setInterval(() => {
-    if (activeStep) writeProgress();
-  }, 1e4);
-  try {
-    await run("doctor", ["doctor", "--fix", "--json", "--adapter", platform, ...targetArgs]);
-    await run("status", ["status", "--json", ...targetArgs]);
-    const { devicePlatform } = surface.prepare;
-    if (devicePlatform && !mobilePlatform && !failed()) {
-      mobilePlatform = devicePlatform(target, readDevices(artifactsDir));
-      if (!mobilePlatform) return ambiguousMobileTarget(json);
-    }
-    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 {
-      const device = devicePlatform && mobilePlatform ? [mobilePlatform] : [];
-      await run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], ...remoteFlagArgs, "--verify", "--json", ...targetArgs]);
-      await run("fixtures", [
-        "fixtures",
-        "set",
-        ...device.flatMap((platformName) => ["--platform", platformName]),
-        ...remoteFlagArgs,
-        "--json",
-        ...targetArgs
-      ]);
-    }
-    await run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
-  } finally {
-    clearInterval(heartbeat);
-    view?.end();
-  }
-  const provenance = runnerProvenance(surface.actions.manifestPath());
-  const record = {
-    schemaVersion: 1,
-    harness: {
-      name: provenance.packageName,
-      version: provenance.version,
-      source: `${provenance.installKind}/${provenance.packageSource}`,
-      executable: provenance.executablePath
-    },
-    platform,
-    ...mobilePlatform ? { mobilePlatform } : {},
-    steps,
-    ready: steps.every((step) => step.status !== "fail"),
-    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  fs.mkdirSync(artifactsDir, { recursive: true });
-  fs.writeFileSync(recordPath, `${JSON.stringify(record, null, 2)}
-`);
-  fs.rmSync(progressPath, { force: true });
-  if (json) {
-    console.log(JSON.stringify(record, null, 2));
-  } else {
-    console.log(`readiness record: ${recordPath}`);
-  }
-  return record.ready ? EXIT.ok : EXIT.runtime;
-}
-export {
-  handlePrepare,
-  mobileTargetAmbiguityError
-};

package/dist/commands/recipe-quality.js

@@ -1,103 +0,0 @@
-import { EXIT, usageOut, optionFlag, optionString, parseArgs } from "@farmslot/recipe-cli/harness";
-import fs from "node:fs";
-import path from "node:path";
-import {
-  buildRecipeQualityArtifact
-} from "@farmslot/agent-runtime";
-const BUILD_USAGE = "mm-harness recipe-quality build --input <compact.json> --output <path> [--json]";
-const SHORTHAND_USAGE = "mm-harness recipe-quality build --input <compact.json> --output <path> [--json]\n  Shorthand: mm-harness recipe-quality --input <compact.json> --output <path> [--json]\n  Note: apply the quality bar from mm-harness help, then build its compact verdict here.";
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function invalidOut(json, message, source) {
-  const userAction = `fix ${source} (${message}), then re-run: ${BUILD_USAGE}`;
-  if (json) {
-    console.log(
-      JSON.stringify(
-        {
-          schemaVersion: 1,
-          command: "recipe-quality",
-          action: "build",
-          status: "fail",
-          exitCode: EXIT.validation,
-          error: { code: "RECIPE_QUALITY_INVALID", message, userAction }
-        },
-        null,
-        2
-      )
-    );
-  } else {
-    console.error(`\u2717 mm-harness recipe-quality: ${message}
-  Next: ${userAction}`);
-  }
-  return EXIT.validation;
-}
-async function handleRecipeQuality(argv) {
-  const { positional, options } = parseArgs(argv);
-  const json = optionFlag(options, "json");
-  const action = positional[0];
-  if (action === "advise" || action === "plan" || action === "advisor-status") {
-    const { handleRecipeAdvice } = await import("./recipe-advice.js");
-    return handleRecipeAdvice(options, action === "advisor-status" ? "status" : action === "plan" ? "plan" : "review");
-  }
-  if (["advisor", "advisorModel", "advisorStages", "recipe", "task", "evidence", "adapter", "library", "params"].some((key) => options[key] !== void 0)) {
-    return usageOut(json, "recipe-quality", "advice options require the advise subcommand", "mm-harness recipe-quality advise --recipe <recipe.json> --task <TASK.md> --adapter <adapter> --advisor <provider>");
-  }
-  if (!action && (optionString(options, "input") || optionString(options, "output"))) {
-    return buildArtifact(options, json);
-  }
-  if (action !== "build") {
-    const message = action ? `unknown action '${action}'` : "missing action: use build, plan, or advise";
-    return usageOut(json, "recipe-quality", message, SHORTHAND_USAGE);
-  }
-  return buildArtifact(options, json);
-}
-function buildArtifact(options, json) {
-  const input = optionString(options, "input");
-  const output = optionString(options, "output");
-  if (!input) return usageOut(json, "recipe-quality", "missing --input <compact.json>", BUILD_USAGE);
-  if (!output) return usageOut(json, "recipe-quality", "missing --output <path>", BUILD_USAGE);
-  const inputPath = path.resolve(input);
-  let raw;
-  try {
-    raw = fs.readFileSync(inputPath, "utf8");
-  } catch (error) {
-    return usageOut(
-      json,
-      "recipe-quality",
-      `cannot read --input ${input}: ${errorMessage(error)}`,
-      `write the compact recipe-quality JSON to that path, then: ${BUILD_USAGE}`
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    return invalidOut(json, `--input ${input} is not valid JSON: ${errorMessage(error)}`, `--input ${input}`);
-  }
-  let artifact;
-  try {
-    artifact = buildRecipeQualityArtifact(parsed);
-  } catch (error) {
-    return invalidOut(json, errorMessage(error), `--input ${input}`);
-  }
-  const outputPath = path.resolve(output);
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-  fs.writeFileSync(outputPath, `${JSON.stringify(artifact, null, 2)}
-`);
-  if (json) {
-    console.log(
-      JSON.stringify(
-        { schemaVersion: 1, command: "recipe-quality", action: "build", status: "ok", outputPath: output, artifact },
-        null,
-        2
-      )
-    );
-  } else {
-    console.log(`\u2713 recipe-quality build \u2192 ${output} (verdict: ${artifact.verdict})`);
-  }
-  return EXIT.ok;
-}
-export {
-  handleRecipeQuality
-};