@deeeed/metamask-harness 0.78.0 → 0.80.0

package/dist/run-diagnostics.js

@@ -1,364 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createHash } from "node:crypto";
-import { getAdapterSurface } from "./adapters/surface.js";
-import {
-  collectorOwnerMarker,
-  collectorStatus
-} from "../library/actions/shared/console-collector.mjs";
-import {
-  allowlistMatch,
-  classifyConsoleRecord,
-  consoleRecords,
-  libraryRootsFromEnv,
-  loadConsoleAllowlist,
-  messageSignature
-} from "../library/actions/shared/console-findings.mjs";
-const MAX_CAPTURE_BYTES = 512 * 1024;
-const MAX_FINDINGS = 20;
-const MAX_PREVIEW_CHARS = 320;
-const RAW_APP_LOG_ARTIFACT = "diagnostics-app-log.txt";
-function readRunDiagnosticsDocument(diagnosticsPath) {
-  if (typeof diagnosticsPath !== "string" || diagnosticsPath.length === 0) return null;
-  try {
-    const document = JSON.parse(fs.readFileSync(diagnosticsPath, "utf8"));
-    return isRunDiagnosticsDocument(document) ? document : null;
-  } catch {
-    return null;
-  }
-}
-function formatRunDiagnosticsForHuman(diagnostics, adapter) {
-  if (!diagnostics) {
-    return [getAdapterSurface(adapter).headless ? `N/A \u2014 ${adapter.charAt(0).toUpperCase()}${adapter.slice(1)} is headless and has no application log source.` : "UNAVAILABLE \u2014 application diagnostics could not be collected for this run."];
-  }
-  const status = diagnostics.status === "clean" ? "CLEAN" : diagnostics.status === "review" ? "REVIEW" : "UNAVAILABLE";
-  const lines = [`${status} \u2014 ${diagnostics.note}`];
-  for (const finding of diagnostics.findings) {
-    const count = finding.count > 1 ? ` \xD7${finding.count}` : "";
-    const source = finding.source ? ` [${finding.source}]` : "";
-    const allowed = finding.allowlisted ? ` (allowlisted: ${finding.allowlisted.reason})` : "";
-    lines.push(`${finding.level.toUpperCase()}${count}${source} \u2014 ${finding.preview}${allowed}`);
-  }
-  return lines;
-}
-async function beginRunDiagnostics(adapter, projectRoot) {
-  const surface = getAdapterSurface(adapter);
-  const source = surface.appLogSource(projectRoot);
-  if (!source) return null;
-  const diagnostics = surface.diagnostics;
-  const issueBuffer = diagnostics?.issueBuffer?.arm(projectRoot) ? { adapter, projectRoot } : void 0;
-  let capture;
-  if (diagnostics?.console) {
-    const collector = diagnostics.console;
-    const startError = await collector.start(projectRoot).then(() => void 0, (error) => error instanceof Error ? error.message : String(error));
-    const { extensionLog, pageLog, pidFile } = collector.files(projectRoot);
-    const cdpPort = collector.cdpPort();
-    capture = { adapter, projectRoot, extensionLog, pageLog, pidFile, ...cdpPort ? { cdpPort } : {}, ...startError ? { startError } : {} };
-  }
-  const walletLogPath = diagnostics?.walletLog?.(projectRoot) ?? null;
-  const walletStat = walletLogPath ? safeStat(walletLogPath) : null;
-  const stat = safeStat(source.path);
-  return {
-    source,
-    offset: stat?.size ?? 0,
-    ...stat ? { inode: stat.ino } : {},
-    ...issueBuffer ? { issueBuffer } : {},
-    ...capture ? { capture } : {},
-    ...walletLogPath ? { walletLog: { path: walletLogPath, offset: walletStat?.size ?? 0, ...walletStat ? { inode: walletStat.ino } : {} } } : {}
-  };
-}
-async function verifyConsoleCapture(capture) {
-  if (capture.startError) return { verified: false, detail: `the console collector did not start: ${capture.startError}` };
-  if (!capture.cdpPort) return { verified: false, detail: "no CDP port for the console collector" };
-  const status = collectorStatus({
-    pidFile: capture.pidFile,
-    extensionLog: capture.extensionLog,
-    marker: collectorOwnerMarker(path.dirname(capture.pidFile)),
-    cdpPort: capture.cdpPort
-  });
-  if (!status.ok) return { verified: false, detail: status.detail };
-  const control = await getAdapterSurface(capture.adapter).diagnostics.console.verifyControl({
-    projectRoot: capture.projectRoot,
-    cdpPort: capture.cdpPort,
-    extensionLog: capture.extensionLog,
-    pageLog: capture.pageLog,
-    pidFile: capture.pidFile
-  });
-  return { verified: control.ok, detail: control.ok ? `${status.detail}; ${control.detail}` : control.detail };
-}
-function isRunDiagnosticsDocument(value) {
-  if (!isRecord(value) || value.schemaVersion !== 1 || value.scope !== "recipe-run-application") return false;
-  if (value.status !== "clean" && value.status !== "review" && value.status !== "unavailable") return false;
-  return typeof value.note === "string" && Array.isArray(value.findings);
-}
-async function finishRunDiagnostics(baseline, result) {
-  if (!baseline) return result;
-  try {
-    const bufferedIssues = baseline.issueBuffer ? getAdapterSurface(baseline.issueBuffer.adapter).diagnostics?.issueBuffer?.collect(baseline.issueBuffer.projectRoot) : void 0;
-    const allowlist = loadConsoleAllowlist(recipeLibraryRoots(result.summaryPath));
-    const capture = baseline.capture ? await verifyConsoleCapture(baseline.capture) : void 0;
-    const { diagnostics, rawAppLog } = collectRunDiagnosticsCapture(baseline, bufferedIssues, allowlist, capture);
-    const artifactsDir = path.dirname(result.summaryPath);
-    const diagnosticsPath = path.join(artifactsDir, "diagnostics.json");
-    fs.writeFileSync(diagnosticsPath, `${JSON.stringify(diagnostics, null, 2)}
-`);
-    fs.writeFileSync(
-      path.join(artifactsDir, RAW_APP_LOG_ARTIFACT),
-      redactDiagnosticText(rawAppLog.toString("utf8"))
-    );
-    indexDiagnosticArtifact(result.artifactManifestPath);
-    indexDiagnosticSummary(result.summaryPath, diagnostics);
-    return {
-      ...result,
-      diagnosticsPath,
-      sideFindings: {
-        status: diagnostics.status,
-        note: diagnostics.note,
-        counts: diagnostics.counts
-      }
-    };
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`WARN: run diagnostics were unavailable: ${detail}`);
-    return {
-      ...result,
-      sideFindings: {
-        status: "unavailable",
-        note: "Run diagnostics could not be collected; the recipe result is unchanged.",
-        counts: { total: 0, warning: 0, error: 0, exception: 0 }
-      }
-    };
-  }
-}
-function collectRunDiagnostics(baseline, bufferedIssues, allowlist = null, capture) {
-  return collectRunDiagnosticsCapture(baseline, bufferedIssues, allowlist, capture).diagnostics;
-}
-function collectRunDiagnosticsCapture(baseline, bufferedIssues, allowlist = null, capture) {
-  const stat = safeStat(baseline.source.path);
-  const source = {
-    label: baseline.source.label,
-    path: baseline.source.path,
-    startOffset: baseline.offset,
-    endOffset: stat?.size ?? baseline.offset,
-    inode: void 0,
-    bytesRead: 0,
-    truncated: false,
-    inAppBuffer: bufferedIssues === void 0 ? "n/a" : bufferedIssues === null ? "unavailable" : "collected",
-    rawArtifact: RAW_APP_LOG_ARTIFACT,
-    redacted: true
-  };
-  let rawAppLog = Buffer.alloc(0);
-  if (stat) {
-    const sameFile = baseline.inode === void 0 || baseline.inode === stat.ino;
-    const startOffset = sameFile && stat.size >= baseline.offset ? baseline.offset : 0;
-    const available = Math.max(0, stat.size - startOffset);
-    const bytesToRead = Math.min(available, MAX_CAPTURE_BYTES);
-    source.startOffset = startOffset;
-    source.endOffset = stat.size;
-    source.inode = stat.ino;
-    source.bytesRead = bytesToRead;
-    source.truncated = available > MAX_CAPTURE_BYTES;
-    if (bytesToRead > 0) rawAppLog = readSlice(baseline.source.path, startOffset, bytesToRead);
-    if (source.truncated) rawAppLog = rawAppLog.subarray(0, rawAppLog.lastIndexOf(10) + 1);
-  }
-  const text = rawAppLog.toString("utf8");
-  const lineFindings = consoleRecords(text).map(classifyRecord).filter((finding) => finding !== null);
-  applyConsoleAllowlist(lineFindings, allowlist);
-  const allFindings = dedupeFindings(
-    [
-      ...lineFindings,
-      ...(bufferedIssues ?? []).map(classifyBufferedIssue).filter((finding) => finding !== null),
-      ...baseline.walletLog ? walletLogFindings(baseline.walletLog) : []
-    ]
-  );
-  const applied = allFindings.filter((finding) => finding.level === "info").length;
-  allFindings.sort((a, b) => Number(a.level === "info") - Number(b.level === "info"));
-  const findings = allFindings.slice(0, MAX_FINDINGS).map(stripInternal);
-  const counts = countFindings(allFindings);
-  const omittedFindingCount = Math.max(0, allFindings.length - findings.length);
-  const captureFailed = capture !== void 0 && !capture.verified;
-  const status = counts.total > 0 ? "review" : !captureFailed && !source.truncated && (stat || bufferedIssues !== void 0 && bufferedIssues !== null) ? "clean" : "unavailable";
-  const captureNote = (captureFailed ? ` Console capture was not verified: ${capture.detail}.` : "") + (source.truncated ? ` The run's log exceeded ${MAX_CAPTURE_BYTES} bytes; only its start was checked.` : "");
-  const note = (counts.total > 0 ? `Observed ${counts.total} distinct application warning/error event(s) during the recipe run; showing ${findings.length} preview(s) and omitting ${omittedFindingCount}. Relation to the task is not determined.` : status === "clean" ? "No application warnings or errors were emitted during the recipe run." : "Application diagnostics were unavailable for this run.") + captureNote;
-  return { diagnostics: {
-    schemaVersion: 1,
-    scope: "recipe-run-application",
-    status,
-    nonBlocking: true,
-    note,
-    source,
-    counts,
-    ...allowlist ? { allowlist: { entries: allowlist.entries.length, applied, problems: allowlist.problems } } : {},
-    ...capture ? { capture } : {},
-    displayedFindingCount: findings.length,
-    omittedFindingCount,
-    findings
-  }, rawAppLog };
-}
-function classifyRecord(record) {
-  const classified = classifyConsoleRecord(record);
-  if (!classified) return null;
-  const line = record.line;
-  const signature = messageSignature(redactDiagnosticText(classified.message));
-  return {
-    ...makeFinding(classified.level, line.trim(), `${classified.source}|${signature}`),
-    source: classified.source,
-    signature: redactPreview(signature),
-    firstFrame: classified.firstFrame ? redactPreview(classified.firstFrame) : null,
-    event: classified.key
-  };
-}
-function walletLogFindings(walletLog) {
-  const stat = safeStat(walletLog.path);
-  if (!stat) return [];
-  const sameFile = walletLog.inode === void 0 || walletLog.inode === stat.ino;
-  const start = sameFile && stat.size >= walletLog.offset ? walletLog.offset : 0;
-  const findings = [];
-  for (const line of readSlice(walletLog.path, start, stat.size - start).toString("utf8").split("\n")) {
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (!isRecord(entry)) continue;
-    let text = null;
-    if (entry.kind === "blocked-mainnet" && entry.probe !== true) text = `blocked-mainnet: ${String(entry.transport ?? "request")} to ${String(entry.url ?? "?")}`;
-    else if (entry.kind === "refused-mainnet") text = `refused-mainnet: ${String(entry.method ?? "?")} (${String(entry.reason ?? "?")})`;
-    else if (entry.kind === "unattributed") text = `unattributed wallet ${entry.binding === "request" ? "request" : "log entry"}${typeof entry.method === "string" ? ` (${entry.method})` : ""}`;
-    if (text) findings.push({ ...makeFinding("error", text, `wallet|${text}`), source: "wallet", signature: text, firstFrame: null });
-  }
-  return findings;
-}
-function classifyBufferedIssue(value) {
-  if (!isRecord(value) || typeof value.text !== "string") return null;
-  const rawLevel = String(value.level ?? "").toLowerCase();
-  const level = rawLevel === "warn" || rawLevel === "warning" ? "warning" : rawLevel === "error" ? "error" : rawLevel === "exception" ? "exception" : null;
-  return level ? makeFinding(level, value.text) : null;
-}
-function makeFinding(level, text, groupKey) {
-  const preview = redactPreview(text.trim());
-  const identity = groupKey ?? preview.replace(/\b\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?\b/gu, "[TIME]").replace(/\[(?:sw|page:[^\]]+|console:[^\]]+)\]/gu, "[APP]").replace(/^(?:(?:WARN(?:ING)?|ERROR|EXCEPTION|\[TIME\]|\[APP\])\s*)+/u, "");
-  return {
-    level,
-    fingerprint: createHash("sha256").update(`${level}|${identity}`).digest("hex").slice(0, 12),
-    preview
-  };
-}
-function applyConsoleAllowlist(findings, allowlist) {
-  if (!allowlist) return;
-  for (const finding of findings) {
-    if (!finding.event) continue;
-    const match = allowlistMatch({ source: finding.source, key: finding.event }, allowlist);
-    if (!match) continue;
-    finding.allowlisted = { reason: match.reason, entry: match.index, file: match.file, ...match.temporary ? { temporary: true } : {} };
-    finding.level = "info";
-    finding.fingerprint = createHash("sha256").update(`${finding.fingerprint}|info|${match.file}#${match.index}`).digest("hex").slice(0, 12);
-  }
-}
-function redactPreview(value) {
-  return redactDiagnosticText(value).slice(0, MAX_PREVIEW_CHARS);
-}
-function redactDiagnosticText(value) {
-  return value.replace(/\b(Bearer)\s+\S+/giu, "$1 [REDACTED]").replace(/(["'])(api[-_]?key|password|passphrase|mnemonic|seed(?:Phrase)?|privateKey|secret|token|authorization|vault)\1\s*:\s*(?:"[^"]*"|'[^']*'|[^,\s}\]]+)/giu, '$1$2$1:"[REDACTED]"').replace(/\b(api[-_]?key|password|passphrase|mnemonic|seed(?:Phrase)?|privateKey|secret|token|authorization|vault)\b\s*[:=]\s*(?:"[^"]*"|'[^']*'|\S+)/giu, "$1=[REDACTED]").replace(/\b(?:0x)?[a-f0-9]{64,}\b/giu, "[REDACTED_HEX]").replace(/(https?:\/\/[^\s?]+)\?\S+/giu, "$1?[REDACTED_QUERY]");
-}
-function dedupeFindings(findings) {
-  const byFingerprint = /* @__PURE__ */ new Map();
-  for (const finding of findings) {
-    const existing = byFingerprint.get(finding.fingerprint);
-    if (existing) existing.count += 1;
-    else byFingerprint.set(finding.fingerprint, { ...finding, count: 1 });
-  }
-  return [...byFingerprint.values()];
-}
-function countFindings(findings) {
-  const counts = { total: 0, warning: 0, error: 0, exception: 0, info: 0 };
-  for (const finding of findings) {
-    counts[finding.level] += 1;
-    if (finding.level !== "info") counts.total += 1;
-  }
-  return counts;
-}
-function stripInternal(finding) {
-  const { event: _event, ...rest } = finding;
-  return rest;
-}
-function readSlice(filePath, offset, length) {
-  const fd = fs.openSync(filePath, "r");
-  try {
-    const buffer = Buffer.alloc(length);
-    const bytesRead = fs.readSync(fd, buffer, 0, length, offset);
-    return buffer.subarray(0, bytesRead);
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-function safeStat(filePath) {
-  try {
-    return fs.statSync(filePath);
-  } catch {
-    return null;
-  }
-}
-function indexDiagnosticArtifact(manifestPath) {
-  const manifest = readJsonRecord(manifestPath);
-  if (!manifest) return;
-  const artifacts = Array.isArray(manifest.artifacts) ? manifest.artifacts : [];
-  manifest.artifacts = [
-    ...artifacts.filter((artifact) => !isRecord(artifact) || !["diagnostics.json", RAW_APP_LOG_ARTIFACT].includes(String(artifact.path))),
-    {
-      path: "diagnostics.json",
-      type: "json",
-      label: "Run-scoped application diagnostics",
-      category: "diagnostic"
-    },
-    {
-      path: RAW_APP_LOG_ARTIFACT,
-      type: "log",
-      label: "Redacted run-scoped application log slice",
-      category: "diagnostic"
-    }
-  ];
-  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`);
-}
-function indexDiagnosticSummary(summaryPath, diagnostics) {
-  const summary = readJsonRecord(summaryPath);
-  if (!summary) return;
-  summary.sideFindings = {
-    status: diagnostics.status,
-    nonBlocking: true,
-    counts: diagnostics.counts,
-    diagnosticsPath: "diagnostics.json",
-    appLogPath: RAW_APP_LOG_ARTIFACT,
-    appLogRedacted: true
-  };
-  fs.writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}
-`);
-}
-function recipeLibraryRoots(summaryPath) {
-  const summary = readJsonRecord(summaryPath);
-  const libraries = isRecord(summary?.recipeLibraries) ? summary.recipeLibraries : null;
-  const sources = Array.isArray(libraries?.sources) ? libraries.sources : [];
-  const roots = sources.map((source) => isRecord(source) && typeof source.root === "string" ? source.root : null).filter((root) => Boolean(root));
-  return roots.length ? roots : libraryRootsFromEnv();
-}
-function readJsonRecord(filePath) {
-  try {
-    const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    return isRecord(value) ? value : null;
-  } catch {
-    return null;
-  }
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export {
-  beginRunDiagnostics,
-  collectRunDiagnostics,
-  finishRunDiagnostics,
-  formatRunDiagnosticsForHuman,
-  readRunDiagnosticsDocument,
-  verifyConsoleCapture
-};