@outerlayer/cli 0.34.0-next.20261024180339 → 0.34.0-next.20261024231715

package/dist/work-proofs-record-HTWSMEDG.js

@@ -1,402 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from 'node:module';
-import { runWorkComment } from './chunk-GWF3ZRUX.js';
-import { recipeKeyFor, ownPullRequest, otherPullRequestHeads, PROOFS_DIR, SETUP_FILE, proofsCommentId, planEntries, checkEmitPath, insideRoot, kindProblem, proofsCommentBody } from './chunk-RT6VNM3S.js';
-import { resolveProofsItem, classifyProofsAt, runWorkProofs } from './chunk-3KT2IWV3.js';
-import { runEmitDemo } from './chunk-BTHH5H5H.js';
-import { readNewestDemo } from './chunk-ER6KQCVJ.js';
-import { runEmitArtifact } from './chunk-MHGIN2X6.js';
-import { runSync } from './chunk-HBVHRC3A.js';
-import './chunk-5XZ6BUPH.js';
-import './chunk-ESVW4MJY.js';
-import './chunk-TBT347UY.js';
-import './chunk-2PGI6RDE.js';
-import './chunk-ES4ULBAL.js';
-import { WorkCommandError, resolveCredentials, getJson } from './chunk-HIGP4WOC.js';
-import './chunk-IP7BIBXJ.js';
-import './chunk-OHJDH5GV.js';
-import './chunk-NVDPSH72.js';
-import './chunk-MECW77XP.js';
-import { resolveRepoIdentity } from './chunk-6ZFY2L2T.js';
-import './chunk-TIRHZC2M.js';
-import './chunk-Y5YCX6AL.js';
-import './chunk-G2JWZDFA.js';
-import './chunk-ANPNT6PM.js';
-import { defaultFetch } from './chunk-6RKD7YZ6.js';
-import './chunk-PJDQPF5N.js';
-import './chunk-SOI6K5DY.js';
-import './chunk-PA6CK6WQ.js';
-import './chunk-BALIE3BA.js';
-import './chunk-SHIGGHZO.js';
-import './chunk-ZJSNLVCE.js';
-import './chunk-2O5KA67H.js';
-import './chunk-BKO6JEZI.js';
-import './chunk-HCVLP7XA.js';
-import './chunk-BJ3KTMDH.js';
-import './chunk-ZGB4ZJ5E.js';
-import './chunk-5BHIBJDA.js';
-import './chunk-CDDED64E.js';
-import './chunk-RA3O54FC.js';
-import './chunk-T2Q7ISPE.js';
-import './chunk-WZBHBH3J.js';
-import './chunk-CRB3POP4.js';
-import './chunk-URIZRCRY.js';
-import './chunk-TUSYOL2O.js';
-import { parseProofRecipe, parseProofSetup } from './chunk-CQRPR4WZ.js';
-import { ARTIFACT_MAX_CAPTION_LENGTH } from './chunk-EOTMDIYC.js';
-import './chunk-VNVZDWO3.js';
-import './chunk-HACGUL52.js';
-import './chunk-MESOOLF4.js';
-import './chunk-Z5GEFMRW.js';
-import { spawnSync, spawn } from 'child_process';
-import { mkdtempSync, rmSync, statSync, openSync, closeSync, readdirSync, readFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-
-createRequire(import.meta.url);
-var runShell = (command, params) => {
-  const logPath = join(params.logDir, `${params.groups.length}-${Date.now()}.log`);
-  const fd = openSync(logPath, "w");
-  return new Promise((resolve) => {
-    const child = spawn("sh", ["-c", command], { cwd: params.cwd, env: params.env, detached: true, stdio: ["ignore", fd, fd] });
-    closeSync(fd);
-    if (child.pid !== void 0) params.groups.push(child.pid);
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      try {
-        process.kill(-child.pid, "SIGKILL");
-      } catch {
-      }
-    }, params.timeoutMs);
-    const finish = (status) => {
-      clearTimeout(timer);
-      let text = "";
-      try {
-        text = readFileSync(logPath, "utf8");
-      } catch {
-      }
-      resolve({ status, timedOut, tail: text.trimEnd().split("\n").slice(-8).join("\n") });
-    };
-    child.on("error", () => finish(null));
-    child.on("exit", (status) => finish(status));
-  });
-};
-
-// src/work-proofs-record.ts
-var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
-var MTIME_SLOP_MS = 2e3;
-function showAtHead(root, path) {
-  const shown = spawnSync("git", ["show", `HEAD:${path}`], { cwd: root, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
-  return shown.status === 0 ? shown.stdout : void 0;
-}
-function findManifests(folder) {
-  const found = [];
-  for (const entry of readdirSync(folder, { withFileTypes: true })) {
-    const path = join(folder, entry.name);
-    if (entry.isDirectory()) found.push(...findManifests(path));
-    else if (entry.name === "manifest.json" && folder.split("/").pop() === "demo") found.push(path);
-  }
-  return found;
-}
-function unstoredUploads(result, spooled) {
-  if (typeof result !== "object" || result === null) return [];
-  const { artifactsDropped, artifactsHeld, rejected, uploadedArtifacts } = result;
-  if (Array.isArray(uploadedArtifacts)) {
-    const stored = new Set(uploadedArtifacts.map((a) => a?.artifactId));
-    return spooled.filter((id) => !stored.has(id));
-  }
-  const lost = typeof artifactsDropped === "number" && artifactsDropped > 0 || typeof artifactsHeld === "number" && artifactsHeld > 0 || Array.isArray(rejected) && rejected.length > 0;
-  return lost ? "all" : [];
-}
-function shortSha(sha) {
-  return sha.slice(0, 7);
-}
-function oneLine(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-async function runWorkProofsRecord(opts) {
-  const env = opts.env ?? process.env;
-  const item = resolveProofsItem({ item: opts.item, env });
-  const cwd = opts.cwd ?? process.cwd();
-  const identity = resolveRepoIdentity(cwd);
-  if (identity.repoRoot === void 0 || identity.commitSha === void 0) {
-    throw new WorkCommandError("this is not a git checkout with a commit. Run this inside the repository, after the recipe is committed.");
-  }
-  const { repoRoot: root, commitSha: head } = identity;
-  const fetchImpl = opts.fetchImpl ?? defaultFetch;
-  const creds = resolveCredentials({ ...opts, env });
-  const home = opts.home;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const lines = [];
-  const say = (line) => void lines.push(line);
-  const { data } = await getJson(creds.url, `/v1/work-items/${item}`, creds.apiKey, creds.appId, fetchImpl);
-  const body = data;
-  const key = recipeKeyFor(body.trackerKey ?? "");
-  if (key === void 0) {
-    throw new WorkCommandError(`the item's tracker key "${body.trackerKey ?? ""}" cannot name a recipe file.`);
-  }
-  const own = ownPullRequest(body.pullRequests ?? [], opts.pr, identity.gitRepo);
-  if ("ambiguous" in own) {
-    throw new WorkCommandError(`the item links several open pull requests (${own.ambiguous.map((n) => `#${n}`).join(", ")}). Pass --pr <number> to name this checkout's.`);
-  }
-  const ownPr = own.pr;
-  const heads = /* @__PURE__ */ new Set([head.toLowerCase(), ...otherPullRequestHeads(body.pullRequests ?? [], ownPr, identity.gitRepo)]);
-  const states = classifyProofsAt(body, heads);
-  const postGeneral = async (text, clientCommentId) => {
-    try {
-      await runWorkComment({ ...creds, item, body: text, clientCommentId, cwd, home, env, fetchImpl, quiet: true });
-    } catch (err) {
-      if (!(err instanceof WorkCommandError && err.code === "comment_conflict")) {
-        say(`The comment on the item's thread was not posted: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-      }
-    }
-  };
-  const recipePath = `${PROOFS_DIR}/${key}.yaml`;
-  const setupPath = `${PROOFS_DIR}/${SETUP_FILE}`;
-  const recipeText = showAtHead(root, recipePath);
-  const setupText = showAtHead(root, setupPath);
-  const recipeParsed = recipeText === void 0 ? { ok: true, value: { run: [], manual: [] } } : parseProofRecipe(recipeText);
-  const setupParsed = setupText === void 0 ? { ok: true, value: { setup: [] } } : parseProofSetup(setupText);
-  for (const [file, parsed] of [
-    [recipePath, recipeParsed],
-    [setupPath, setupParsed]
-  ]) {
-    if (parsed.ok) continue;
-    const problem = `${file} cannot be read: ${parsed.problems.join("; ")}`;
-    if (opts.comment) {
-      const text = `The proof recipe cannot be read at ${shortSha(head)}, so no proof was recorded. ${problem}`.slice(0, 2e3);
-      await postGeneral(text, proofsCommentId(item, head, [{ id: file, proof: "recipe", reason: problem }]));
-    }
-    throw new WorkCommandError(problem);
-  }
-  const recipe = recipeParsed.value;
-  const setup = setupParsed.value;
-  if (recipeText === void 0) say(`No recipe at ${recipePath} in the HEAD commit, so no entry runs.`);
-  const dirty = spawnSync("git", ["diff", "--quiet", "HEAD", "--", PROOFS_DIR], { cwd: root });
-  if (dirty.status === 1) say(`The working copy of ${PROOFS_DIR} differs from HEAD. Only the committed files run. Commit the change, then record again.`);
-  const declared = new Map((body.criteria?.items ?? []).map((criterion) => [criterion.id, criterion]));
-  const reasons = /* @__PURE__ */ new Map();
-  const emitted = /* @__PURE__ */ new Map();
-  const manual = new Map(recipe.manual.map((entry) => [entry.criterion, entry]));
-  const plan = planEntries(recipe, states);
-  const toRun = [];
-  for (const planned of plan) {
-    if (planned.skip !== null) continue;
-    const label = planned.entry.emit === "demo" ? "the demo entry" : `the entry for ${planned.entry.for}`;
-    const refuse = (reason) => {
-      say(`Skipped ${label}: ${reason}`);
-      for (const id of planned.criteria) reasons.set(id, reason);
-    };
-    if (planned.entry.command.trim() === "") {
-      refuse("it has no command. Fill in the recipe.");
-      continue;
-    }
-    if (planned.entry.emit !== "demo") {
-      const checked = checkEmitPath(root, planned.entry.emit);
-      if (!checked.ok) {
-        refuse(checked.reason);
-        continue;
-      }
-    }
-    toRun.push(planned);
-  }
-  const logDir = mkdtempSync(join(tmpdir(), "outerlayer-proofs-"));
-  const groups = [];
-  const runCommand = opts.runCommand ?? runShell;
-  const baseEnv = { ...process.env, ...env };
-  let spooledCount = 0;
-  const spooledCriteria = /* @__PURE__ */ new Set();
-  const emitArtifact = async (emitOpts) => {
-    const result = await (opts.emitArtifact ?? runEmitArtifact)(emitOpts);
-    if (result.spooled) spooledCount += 1;
-    return result;
-  };
-  const common = { url: creds.url, apiKey: creds.apiKey, appId: creds.appId, cwd: root, home, env, fetchImpl, quiet: true };
-  let setupStarted = false;
-  let setupFailed;
-  const stopGroups = () => {
-    for (const pid of groups) {
-      try {
-        process.kill(-pid, "SIGTERM");
-      } catch {
-      }
-    }
-  };
-  const onSignal = (signal) => {
-    stopGroups();
-    rmSync(logDir, { recursive: true, force: true });
-    process.exit(signal === "SIGINT" ? 130 : 143);
-  };
-  const onInterrupt = () => onSignal("SIGINT");
-  const onTerminate = () => onSignal("SIGTERM");
-  process.once("SIGINT", onInterrupt);
-  process.once("SIGTERM", onTerminate);
-  try {
-    if (toRun.length > 0) {
-      setupStarted = true;
-      for (const command of setup.setup) {
-        const result = await runCommand(command, { cwd: root, env: baseEnv, timeoutMs, logDir, groups });
-        if (result.status !== 0) {
-          setupFailed = `setup failed: "${oneLine(command)}" ${result.timedOut ? `timed out after ${Math.round(timeoutMs / 1e3)} s` : `exited with status ${result.status}`}`;
-          say(setupFailed);
-          if (result.tail !== "") say(result.tail);
-          break;
-        }
-      }
-    }
-    for (const planned of toRun) {
-      if (setupFailed !== void 0) {
-        for (const id of planned.criteria) reasons.set(id, setupFailed);
-        continue;
-      }
-      const { entry } = planned;
-      const proofOut = mkdtempSync(join(tmpdir(), "outerlayer-proof-out-"));
-      const startedAt = Date.now();
-      try {
-        const result = await runCommand(entry.command, { cwd: root, env: { ...baseEnv, OUTERLAYER_PROOF_OUT: proofOut }, timeoutMs, logDir, groups });
-        const failure = result.timedOut ? `the command timed out after ${Math.round(timeoutMs / 1e3)} s` : result.status === 0 ? void 0 : `the command exited ${result.status}`;
-        if (entry.emit === "demo") {
-          await recordDemo({ planned, proofOut, failure, tail: result.tail });
-        } else {
-          await recordFile({ planned, failure, tail: result.tail, startedAt });
-        }
-      } finally {
-        rmSync(proofOut, { recursive: true, force: true });
-      }
-    }
-  } finally {
-    if (setupStarted) {
-      for (const command of setup.teardown ?? []) {
-        const result = await runCommand(command, { cwd: root, env: baseEnv, timeoutMs, logDir, groups });
-        if (result.status !== 0) say(`teardown failed: "${oneLine(command)}" ${result.timedOut ? "timed out" : `exited with status ${result.status}`}`);
-      }
-    }
-    process.off("SIGINT", onInterrupt);
-    process.off("SIGTERM", onTerminate);
-    stopGroups();
-    rmSync(logDir, { recursive: true, force: true });
-  }
-  async function recordFile(params) {
-    const { entry } = params.planned;
-    const id = entry.for;
-    const fail = (reason) => {
-      reasons.set(id, reason);
-      say(`Not recorded, ${id}: ${reason}`);
-      if (params.tail !== "" && params.failure !== void 0) say(params.tail);
-    };
-    if (params.failure !== void 0) return fail(params.failure);
-    const checked = checkEmitPath(root, entry.emit);
-    if (!checked.ok) return fail(checked.reason);
-    let modified;
-    try {
-      const stat = statSync(checked.path);
-      if (!stat.isFile()) return fail(`${entry.emit} is not a file`);
-      modified = stat.mtimeMs;
-    } catch {
-      return fail(`the command did not write ${entry.emit}`);
-    }
-    if (!insideRoot(root, checked.path)) return fail(`${entry.emit} is outside the repository: it links out of it`);
-    if (modified < params.startedAt - MTIME_SLOP_MS) return fail(`the command did not write ${entry.emit}: the file is older than this run`);
-    const problem = kindProblem(declared.get(id)?.proof ?? null, checked.path);
-    if (problem !== void 0) return fail(problem);
-    try {
-      const caption = (declared.get(id)?.text ?? `Proof for ${id}`).slice(0, ARTIFACT_MAX_CAPTION_LENGTH);
-      const before = spooledCount;
-      const result = await emitArtifact({ ...common, file: checked.path, caption, criterionId: id, ...ownPr === void 0 ? {} : { pr: ownPr } });
-      const artifactId = result.record?.artifactId ?? result.data?.clientArtifactId;
-      if (artifactId === void 0) return fail("the upload returned no artifact id");
-      emitted.set(id, artifactId);
-      if (spooledCount > before) spooledCriteria.add(id);
-      say(`Recorded ${id} from ${entry.emit}.`);
-    } catch (err) {
-      fail(`the upload failed: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-    }
-  }
-  async function recordDemo(params) {
-    const fail = (reason) => {
-      for (const id of params.planned.criteria) reasons.set(id, reason);
-      say(`Not recorded, the demo: ${reason}`);
-      if (params.tail !== "" && params.failure !== void 0) say(params.tail);
-    };
-    const manifests = findManifests(params.proofOut);
-    if (manifests.length !== 1) {
-      const status = params.failure === void 0 ? "" : ` (${params.failure})`;
-      return fail(manifests.length === 0 ? `the command left no demo manifest${status}` : `the command left ${manifests.length} demo manifests, so it is unclear which to store`);
-    }
-    let replaces;
-    try {
-      replaces = (await readNewestDemo({ url: creds.url, apiKey: creds.apiKey, appId: creds.appId, item, fetchImpl }))?.artifactId;
-    } catch (err) {
-      replaces = void 0;
-      say(`The previous demo could not be read, so the new demo does not replace it: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-    }
-    const before = spooledCount;
-    let result;
-    try {
-      result = await (opts.emitDemo ?? runEmitDemo)({
-        ...common,
-        manifest: manifests[0],
-        item,
-        ...ownPr === void 0 ? {} : { pr: ownPr },
-        ...replaces === void 0 ? {} : { replaces },
-        emitArtifact
-      });
-    } catch (err) {
-      return fail(`the demo was not stored: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-    }
-    for (const id of params.planned.criteria) {
-      const proof = declared.get(id)?.proof;
-      const artifactId = proof === "screenshot" ? result.screenshots.find((shot) => shot.criterionId === id && shot.artifactId !== void 0)?.artifactId : result.clips.find((clip) => clip.criterionId === id && clip.bound)?.clipArtifactId;
-      if (artifactId !== void 0) {
-        emitted.set(id, artifactId);
-        if (spooledCount > before) spooledCriteria.add(id);
-      } else reasons.set(id, result.failures.length > 0 ? `the demo failed a check: ${oneLine(result.failures[0])}` : "the demo has no passing chapter for it");
-    }
-    say(`Recorded the demo: ${params.planned.criteria.filter((id) => emitted.has(id)).length} of ${params.planned.criteria.length} proofs.`);
-    for (const failure of result.failures) say(`Demo check failed: ${oneLine(failure)}`);
-  }
-  if (spooledCount > 0) {
-    try {
-      const synced = await (opts.sync ?? (() => runSync({ ...common })))();
-      const unstored = unstoredUploads(
-        synced,
-        [...spooledCriteria].map((id) => emitted.get(id))
-      );
-      const lostIds = unstored === "all" ? [...spooledCriteria] : [...spooledCriteria].filter((id) => unstored.includes(emitted.get(id)));
-      for (const id of lostIds) {
-        emitted.delete(id);
-        reasons.set(id, "the sync did not store the upload, so the proof is stored only in the session record");
-      }
-      if (lostIds.length > 0) say("The sync did not store an upload. The proofs that went through the session record are not stored.");
-    } catch (err) {
-      for (const id of spooledCriteria) {
-        emitted.delete(id);
-        reasons.set(id, "the sync failed, so the proof is stored only in the session record");
-      }
-      say(`The sync failed, so the new proofs are stored only in the session record: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-    }
-  }
-  let finalStates = states;
-  try {
-    const { data: fresh } = await getJson(creds.url, `/v1/work-items/${item}`, creds.apiKey, creds.appId, fetchImpl);
-    finalStates = classifyProofsAt(fresh, heads);
-  } catch {
-  }
-  const notCurrent = finalStates.filter((state) => state.state !== "current" && !emitted.has(state.id)).map((state) => ({ id: state.id, proof: state.proof, reason: reasons.get(state.id) ?? manual.get(state.id)?.reason ?? "no entry in the recipe" }));
-  if (opts.comment && notCurrent.length > 0) {
-    await postGeneral(proofsCommentBody(head, notCurrent), proofsCommentId(item, head, notCurrent));
-  }
-  for (const proof of notCurrent) say(`Not current, ${proof.id} (${proof.proof}): ${proof.reason}`);
-  const closing = await runWorkProofs({ ...opts, item, env, quiet: true, checkoutHead: head, fetchImpl });
-  const output = [...lines, closing.output].join("\n");
-  if (!opts.quiet) process.stdout.write(output + "\n");
-  return {
-    exitCode: closing.exitCode,
-    output,
-    emitted: [...emitted].map(([criterion, artifactId]) => ({ criterion, artifactId })),
-    notCurrent
-  };
-}
-
-export { runWorkProofsRecord };