@deeeed/metamask-harness 0.17.5 → 0.19.0

package/dist/command-journal.js

@@ -0,0 +1,263 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { recipeRuntimeDir } from "./paths.js";
+const COMMAND_JOURNAL_FILE = "last-command.json";
+const JOURNALED_COMMANDS = /* @__PURE__ */ new Set([
+  "call",
+  "check",
+  "checklist",
+  "cleanup",
+  "doctor",
+  "fixtures",
+  "install",
+  "launch",
+  "provision",
+  "recipe-quality",
+  "run",
+  "stop",
+  "verify"
+]);
+const SENSITIVE_KEY = /(?:api[-_]?key|auth|credential|mnemonic|pass(?:word)?|private[-_]?key|secret|seed|srp|token|vault)/iu;
+const EVIDENCE_OPTIONS = /* @__PURE__ */ new Set(["--artifacts-dir", "--out", "--output"]);
+let activeCommandJournal;
+async function withCommandJournal(command, argv, execute) {
+  if (!JOURNALED_COMMANDS.has(command)) return execute();
+  const handle = tryBeginCommandJournal(command, argv);
+  const previous = activeCommandJournal;
+  activeCommandJournal = handle;
+  try {
+    const exitCode = await execute();
+    tryFinishCommandJournal(handle, exitCode);
+    return exitCode;
+  } catch (error) {
+    tryFinishCommandJournal(handle, 1);
+    throw error;
+  } finally {
+    activeCommandJournal = previous;
+  }
+}
+function recordCommandEvidence(...evidence) {
+  const handle = activeCommandJournal;
+  if (!handle || evidence.length === 0) return;
+  try {
+    const paths = new Set(handle.record.evidencePaths);
+    for (const entry of evidence) paths.add(path.resolve(entry));
+    handle.record = { ...handle.record, evidencePaths: [...paths] };
+    writeAtomic(handle.file, handle.record);
+  } catch (error) {
+    process.stderr.write(
+      `mm-harness: resumability journal could not record evidence: ${errorMessage(error)}
+`
+    );
+  }
+}
+function commandJournalPath(target, runtimeDir) {
+  const relative = runtimeDir ?? recipeRuntimeDir();
+  assertRelativeRuntimeDir(relative);
+  return path.join(path.resolve(target), relative, COMMAND_JOURNAL_FILE);
+}
+function readCommandJournal(target, runtimeDir) {
+  const file = commandJournalPath(target, runtimeDir);
+  let descriptor;
+  try {
+    const noFollow = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+    descriptor = fs.openSync(file, fs.constants.O_RDONLY | noFollow);
+    const descriptorStat = fs.fstatSync(descriptor, { bigint: true });
+    const pathStat = fs.lstatSync(file, { bigint: true });
+    if (!descriptorStat.isFile() || !pathStat.isFile() || pathStat.isSymbolicLink() || pathStat.dev === 0n && pathStat.ino === 0n || descriptorStat.dev !== pathStat.dev || descriptorStat.ino !== pathStat.ino) {
+      return { file, record: null };
+    }
+    const parsed = JSON.parse(
+      fs.readFileSync(descriptor, "utf8")
+    );
+    return isCommandJournalRecord(parsed) ? { file, record: parsed } : { file, record: null };
+  } catch {
+    return { file, record: null };
+  } finally {
+    if (descriptor !== void 0) fs.closeSync(descriptor);
+  }
+}
+function redactCommandArgs(argv) {
+  const redacted = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    const equals = token.indexOf("=");
+    if (token.startsWith("--") && equals !== -1) {
+      const option = token.slice(0, equals);
+      const value = token.slice(equals + 1);
+      redacted.push(
+        `${option}=${option === "--arg" ? redactAssignment(value) : SENSITIVE_KEY.test(option) ? "<redacted>" : redactUrl(value)}`
+      );
+      continue;
+    }
+    if (token.startsWith("--") && SENSITIVE_KEY.test(token)) {
+      redacted.push(token);
+      const value = argv[index + 1];
+      if (value !== void 0 && !value.startsWith("--")) {
+        redacted.push("<redacted>");
+        index += 1;
+      }
+      continue;
+    }
+    if (token === "--arg") {
+      redacted.push(token);
+      const value = argv[index + 1];
+      if (value !== void 0) {
+        redacted.push(redactAssignment(value));
+        index += 1;
+      }
+      continue;
+    }
+    redacted.push(redactAssignment(redactUrl(token)));
+  }
+  return redacted;
+}
+function tryBeginCommandJournal(command, argv) {
+  try {
+    const target = invocationTarget(argv);
+    if (!fs.existsSync(target)) return void 0;
+    const runtimeDir = optionValue(argv, "--runtime-dir");
+    const file = commandJournalPath(target, runtimeDir);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      schemaVersion: 1,
+      command,
+      args: redactCommandArgs(argv.slice(1)),
+      target,
+      verdict: "running",
+      exitCode: null,
+      evidencePaths: evidencePaths(argv),
+      startedAt: now,
+      finishedAt: null
+    };
+    writeAtomic(file, record);
+    return { file, record };
+  } catch (error) {
+    process.stderr.write(
+      `mm-harness: resumability journal unavailable: ${errorMessage(error)}
+`
+    );
+    return void 0;
+  }
+}
+function tryFinishCommandJournal(handle, exitCode) {
+  if (!handle) return;
+  try {
+    writeAtomic(handle.file, {
+      ...handle.record,
+      verdict: exitCode === 0 ? "pass" : "fail",
+      exitCode,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    process.stderr.write(
+      `mm-harness: resumability journal could not finalize: ${errorMessage(error)}
+`
+    );
+  }
+}
+function writeAtomic(file, record) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  let descriptor;
+  try {
+    descriptor = fs.openSync(temporary, "wx", 384);
+    fs.writeFileSync(descriptor, `${JSON.stringify(record, null, 2)}
+`);
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+    descriptor = void 0;
+    fs.renameSync(temporary, file);
+  } finally {
+    if (descriptor !== void 0) fs.closeSync(descriptor);
+    fs.rmSync(temporary, { force: true });
+  }
+}
+function invocationTarget(argv) {
+  return path.resolve(
+    optionValue(argv, "--target") ?? process.cwd()
+  );
+}
+function evidencePaths(argv) {
+  const values = /* @__PURE__ */ new Set();
+  for (const option of EVIDENCE_OPTIONS) {
+    const value = optionValue(argv, option);
+    if (value) values.add(path.resolve(value));
+  }
+  return [...values];
+}
+function optionValue(argv, option) {
+  const divider = argv.indexOf("--");
+  const end = divider === -1 ? argv.length : divider;
+  for (let index = 1; index < end; index += 1) {
+    const token = argv[index] ?? "";
+    if (token === option) {
+      const value = argv[index + 1];
+      return value && !value.startsWith("--") ? value : void 0;
+    }
+    if (token.startsWith(`${option}=`)) return token.slice(option.length + 1);
+  }
+  return void 0;
+}
+function redactAssignment(token) {
+  const equals = token.indexOf("=");
+  if (equals <= 0) return redactValue(token);
+  const key = token.slice(0, equals);
+  const value = token.slice(equals + 1);
+  return `${key}=${SENSITIVE_KEY.test(key) ? "<redacted>" : redactValue(value)}`;
+}
+function redactUrl(token) {
+  return token.replace(/(\w+:\/\/)[^/@\s:]+:[^/@\s]+@/gu, "$1<redacted>@");
+}
+function redactValue(value) {
+  try {
+    return JSON.stringify(redactStructuredValue(JSON.parse(value)));
+  } catch {
+    return value.replace(
+      /((?:api[-_]?key|auth|credential|mnemonic|pass(?:word)?|private[-_]?key|secret|seed|srp|token|vault)=)[^\s]+/giu,
+      "$1<redacted>"
+    );
+  }
+}
+function isSensitiveKey(key) {
+  return SENSITIVE_KEY.test(key);
+}
+function redactStructuredValue(value) {
+  if (Array.isArray(value)) return value.map(redactStructuredValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      isSensitiveKey(key) ? "<redacted>" : redactStructuredValue(entry)
+    ])
+  );
+}
+function assertRelativeRuntimeDir(value) {
+  if (!value || path.isAbsolute(value) || !/^[A-Za-z0-9._/-]+$/u.test(value)) {
+    throw new Error(`--runtime-dir must be a safe relative path: ${value}`);
+  }
+  if (value.split("/").some((part) => !part || part === "." || part === "..")) {
+    throw new Error(
+      `--runtime-dir contains an unsafe path component: ${value}`
+    );
+  }
+}
+function isCommandJournalRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.schemaVersion === 1 && typeof record.command === "string" && Array.isArray(record.args) && record.args.every((entry) => typeof entry === "string") && typeof record.target === "string" && (record.verdict === "running" || record.verdict === "pass" || record.verdict === "fail") && (record.exitCode === null || typeof record.exitCode === "number") && Array.isArray(record.evidencePaths) && record.evidencePaths.every((entry) => typeof entry === "string") && typeof record.startedAt === "string" && (record.finishedAt === null || typeof record.finishedAt === "string");
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  COMMAND_JOURNAL_FILE,
+  commandJournalPath,
+  isSensitiveKey,
+  readCommandJournal,
+  recordCommandEvidence,
+  redactCommandArgs,
+  redactStructuredValue,
+  withCommandJournal
+};