@kungfu-tech/buildchain 4.0.2-alpha.0 → 4.0.2-alpha.4

package/scripts/release-candidate-resolver.mjs

@@ -110,13 +110,13 @@ function digestFileSync(filePath, algorithm, encoding) {
   return hash.digest(encoding);
 }
 
-export function selectMergedChannelPullRequest({ pullRequests = [], targetRef, repository }) {
+export function selectMergedChannelPullRequest({ pullRequests = [], targetRef, targetSha = "", repository }) {
   const normalizedTarget = normalizeBranch(targetRef);
   const candidates = pullRequests.filter((pr) => {
-    const baseRef = normalizeBranch(pr.base?.ref || pr.baseRefName || "");
-    const merged = Boolean(pr.merged_at || pr.mergedAt || pr.state === "closed");
-    const sameRepo = !repository || !pr.head?.repo?.full_name || pr.head.repo.full_name === repository;
-    return merged && sameRepo && baseRef === normalizedTarget;
+    const baseRepo = pr.base?.repo?.full_name || pr.baseRepository?.nameWithOwner;
+    const merged = Boolean(pr.merged_at || pr.mergedAt || pr.merged === true);
+    const rooted = !repository || (baseRepo || pr.head?.repo?.full_name) === repository;
+    return merged && rooted && (!targetSha || (pr.merge_commit_sha || pr.mergeCommit?.oid) === targetSha) && normalizeBranch(pr.base?.ref || pr.baseRefName || "") === normalizedTarget;
   });
   candidates.sort((left, right) => {
     const leftTime = Date.parse(left.merged_at || left.updated_at || left.closed_at || "");
@@ -513,11 +513,11 @@ export async function resolveReleaseCandidateArtifacts({
   });
   const channelPullRequest = selectMergedChannelPullRequest({
     pullRequests: Array.isArray(pulls) ? pulls : [],
-    targetRef: normalizedTarget,
+    targetRef: normalizedTarget, targetSha: sha,
     repository: repoInfo.fullName,
   });
   if (!channelPullRequest) {
-    throw new Error(`no same-repository merged channel PR found for ${sha} into ${normalizedTarget}`);
+    throw new Error(`no exact merged channel PR rooted in ${repoInfo.fullName} found for ${sha} into ${normalizedTarget}`);
   }
   let pullRequest = channelPullRequest;
   if (majorGateTarget) {
@@ -725,16 +725,6 @@ export async function resolveReleaseCandidateArtifacts({
     const noun = publishArtifactKind === "npm" ? "npm package tarballs" : "platform manifests";
     throw new Error(`expected at least ${minimumPayloadCount} downloaded ${noun}, found ${downloadedRequiredArtifactCount}`);
   }
-  const manifests = platformManifestPaths.map((manifestPath) => JSON.parse(fs.readFileSync(manifestPath, "utf8")));
-  const generatedRequiredArtifacts = generatePublishRequiredArtifacts({
-    manifests,
-    version: passport.target?.version || "",
-    kind: publishArtifactKind,
-    tarballPaths: npmTarballPaths,
-    mainPackage: publishPackageMain,
-  });
-  const requiredArtifactsPath = path.join(resolvedOutput, "publish-required-artifacts.json");
-  fs.writeFileSync(requiredArtifactsPath, `${JSON.stringify(generatedRequiredArtifacts, null, 2)}\n`);
   const sealedBundle = publishArtifactKind === "npm"
     ? createResolvedPublicationSealedBundle({
         bundleRoot: payloadDir,
@@ -750,6 +740,16 @@ export async function resolveReleaseCandidateArtifacts({
         releaseAssetPaths,
       })
     : undefined;
+  const manifests = platformManifestPaths.map((manifestPath) => JSON.parse(fs.readFileSync(manifestPath, "utf8")));
+  const generatedRequiredArtifacts = generatePublishRequiredArtifacts({
+    manifests,
+    version: [sealedBundle?.manifest?.npm?.version, passport.target?.version, ""].find(Boolean),
+    kind: publishArtifactKind,
+    tarballPaths: npmTarballPaths,
+    mainPackage: publishPackageMain,
+  });
+  const requiredArtifactsPath = path.join(resolvedOutput, "publish-required-artifacts.json");
+  fs.writeFileSync(requiredArtifactsPath, `${JSON.stringify(generatedRequiredArtifacts, null, 2)}\n`);
   const sealedBundleManifestPath = sealedBundle
     ? path.join(resolvedOutput, "sealed-bundle.json")
     : "";

package/scripts/resume-from-candidate-run.mjs

@@ -785,14 +785,13 @@ async function recoverCandidateEvidence({
   for (const artifact of [selected.passport, selected.summary]) initialDownloads.push(await downloadArtifact({ artifact, repoInfo, apiUrl, token, archiveDir, bundleRoot, fetchImpl }));
   const passport = readOnlyJson(initialDownloads[0].files.filter((file) => path.basename(file.path) === "release-candidate-passport.json"), "release-candidate-passport.json");
   const buildSummary = readOnlyJson(initialDownloads[1].files.filter((file) => path.basename(file.path) === "build-summary.json"), "build-summary.json");
-  const sidecarFiles = initialDownloads[0].files.filter(
-    (file) =>
-      path.basename(file.path) === "release-candidate-stage-capsules.json",
-  );
-  const stageCapsuleSidecar =
-    sidecarFiles.length === 1
-      ? readOnlyJson(sidecarFiles, "release-candidate-stage-capsules.json")
-      : undefined;
+  const [stageCapsuleFile, publicationQualificationFile] = [
+    "release-candidate-stage-capsules.json",
+    "release-candidate-publication-qualification.json",
+  ].map((name) => initialDownloads[0].files.find((file) => path.basename(file.path) === name));
+  const stageCapsuleSidecar = stageCapsuleFile
+    ? readOnlyJson([stageCapsuleFile], "release-candidate-stage-capsules.json")
+    : undefined;
   const { names: requiredNames, publicationNames } = candidateArtifactNames({ passport, selected, artifacts, artifactPatterns });
   const chosen = artifacts.filter((artifact) => requiredNames.has(artifact.name));
   if (chosen.length !== requiredNames.size) {
@@ -804,7 +803,7 @@ async function recoverCandidateEvidence({
   for (const artifact of chosen.filter((entry) => ![selected.passport.id, selected.summary.id].includes(entry.id))) downloads.push(await downloadArtifact({ artifact, repoInfo, apiUrl, token, archiveDir, bundleRoot, fetchImpl }));
   return {
     run, workflow, selected, resolvedOutput, bundleRoot, initialDownloads,
-    passport, buildSummary, stageCapsuleSidecar, chosen, downloads, publicationNames,
+    passport, buildSummary, stageCapsuleSidecar, stageCapsuleFile, publicationQualificationFile, chosen, downloads, publicationNames,
   };
 }
 
@@ -878,7 +877,7 @@ export async function resumeFromCandidateRun({
   try {
     const {
       run, workflow, selected, resolvedOutput, bundleRoot, initialDownloads,
-      passport, buildSummary, stageCapsuleSidecar, chosen, downloads, publicationNames,
+      passport, buildSummary, stageCapsuleSidecar, stageCapsuleFile, publicationQualificationFile, chosen, downloads, publicationNames,
     } = await recoverCandidateEvidence({
       repoInfo, runId, artifactName, artifactPatterns, requiredArtifactCount,
       outputDir, apiUrl, token, fetchImpl, archiveDir,
@@ -1023,9 +1022,9 @@ export async function resumeFromCandidateRun({
         sealedBundleRoot: publication.manifest ? outputPath(bundleRoot) : "",
         sealedBundleManifest: publication.manifest ? outputPath(sealedManifestPath) : "",
         recoveryReceipt: outputPath(recoveryReceiptPath),
-        runtimeResumeEvidence: runtimeResumeEvidencePath
-          ? outputPath(runtimeResumeEvidencePath)
-          : "",
+        stageCapsules: stageCapsuleFile ? outputPath(stageCapsuleFile.absolutePath) : "",
+        publicationQualification: publicationQualificationFile ? outputPath(publicationQualificationFile.absolutePath) : "",
+        runtimeResumeEvidence: runtimeResumeEvidencePath ? outputPath(runtimeResumeEvidencePath) : "",
       },
     };
   } finally {
@@ -1077,10 +1076,10 @@ export async function resumeFromCandidateRunCli() {
       "release-candidate-run-url": result.run.url,
       "release-candidate-recovery-receipt-path": result.paths.recoveryReceipt,
       "release-candidate-recovery-root": result.receipt.root,
+      "release-candidate-stage-capsules-path": result.paths.stageCapsules,
+      "release-candidate-publication-qualification-path": result.paths.publicationQualification,
       "v4-runtime-resume-evidence-path": result.paths.runtimeResumeEvidence,
-      "v4-runtime-resume-finalize-command": result.paths.runtimeResumeEvidence
-        ? "node .buildchain/runtime/promotion-shell/scripts/resume-from-candidate-run.mjs finalize"
-        : "",
+      "v4-runtime-resume-finalize-command": result.paths.runtimeResumeEvidence ? "node .buildchain/runtime/promotion-shell/scripts/resume-from-candidate-run.mjs finalize" : "",
       "release-candidate-root": result.candidateRoot,
       "release-candidate-artifact-root": result.artifactRoot,
       "publish-sealed-bundle-root": result.paths.sealedBundleRoot,

package/scripts/v3-v4-capability-catalog.mjs

@@ -23,6 +23,9 @@ const PLATFORM_MARKERS = Object.freeze({
   "self-hosted": /\bself-hosted\b/iu,
   windows: /\bwindows\b/iu,
 });
+const LIVE_V4_PROTECTED_BRANCH = "refs/heads/dev/v4/v4.0";
+const LIVE_V4_PROTECTED_LINEAGE_REF = "refs/remotes/origin/dev/v4/v4.0";
+const PROTECTED_LINEAGE_DEPTH = 256;
 
 export function sha256(value) {
   return `sha256:${crypto.createHash("sha256").update(value).digest("hex")}`;
@@ -47,6 +50,110 @@ export function git(root, args, { trim = true } = {}) {
   return trim ? output.trim() : output;
 }
 
+export function assertCapabilityCutAncestor({
+  root = process.cwd(),
+  revision,
+  descendant = "HEAD",
+  label = "capability cut",
+} = {}) {
+  try {
+    execFileSync("git", ["merge-base", "--is-ancestor", revision, descendant], {
+      cwd: root,
+      stdio: "ignore",
+    });
+  } catch {
+    throw new Error(
+      `${label} ${revision} must be an ancestor of ${descendant}; regenerate the cut after rebasing instead of relying on a retained local object`,
+    );
+  }
+}
+
+export function ensureCapabilityCutAncestor({
+  root = process.cwd(),
+  revision,
+  descendant = "HEAD",
+  label = "capability cut",
+} = {}) {
+  try {
+    assertCapabilityCutAncestor({ root, revision, descendant, label });
+    return;
+  } catch (error) {
+    if (git(root, ["rev-parse", "--is-shallow-repository"]) !== "true")
+      throw error;
+  }
+  const descendantCommit = git(root, ["rev-parse", `${descendant}^{commit}`]);
+  try {
+    execFileSync(
+      "git",
+      ["fetch", "--no-tags", "--depth=128", "origin", descendantCommit],
+      { cwd: root, stdio: "ignore" },
+    );
+  } catch {
+    throw new Error(
+      `${label} ${revision} ancestry could not be hydrated from ${descendantCommit} through a bounded origin fetch`,
+    );
+  }
+  assertCapabilityCutAncestor({ root, revision, descendant, label });
+}
+
+function protectedV4TreeWitness(root, descendant) {
+  try {
+    execFileSync(
+      "git",
+      [
+        "fetch",
+        "--no-tags",
+        `--depth=${PROTECTED_LINEAGE_DEPTH}`,
+        "origin",
+        `${LIVE_V4_PROTECTED_BRANCH}:${LIVE_V4_PROTECTED_LINEAGE_REF}`,
+      ],
+      { cwd: root, stdio: "ignore" },
+    );
+  } catch {
+    throw new Error(
+      `protected v4 lineage ${LIVE_V4_PROTECTED_BRANCH} could not be hydrated through a bounded origin fetch`,
+    );
+  }
+  const tree = git(root, ["rev-parse", `${descendant}^{tree}`]);
+  return (
+    git(root, [
+      "log",
+      `--max-count=${PROTECTED_LINEAGE_DEPTH}`,
+      "--format=%H %T",
+      LIVE_V4_PROTECTED_LINEAGE_REF,
+    ])
+      .split("\n")
+      .map((row) => row.split(" "))
+      .find(([, candidateTree]) => candidateTree === tree)?.[0] || ""
+  );
+}
+
+export function ensureCapabilityCutLineage({
+  root = process.cwd(),
+  revision,
+  descendant = "HEAD",
+  label = "capability cut",
+} = {}) {
+  try {
+    ensureCapabilityCutAncestor({ root, revision, descendant, label });
+    return { mode: "direct-ancestry", witness: descendant };
+  } catch (directError) {
+    const witness = protectedV4TreeWitness(root, descendant);
+    if (!witness)
+      throw new Error(
+        `${label} ${revision} is not an ancestor of ${descendant}, and ${descendant} has no tree-equivalent commit in the bounded protected v4 lineage`,
+        { cause: directError },
+      );
+    ensureCapabilityCutAncestor({
+      root,
+      revision,
+      descendant: witness,
+      label: `${label} protected-lineage witness`,
+    });
+    return { mode: "protected-tree-equivalent", witness };
+  }
+}
+
 function gitJson(root, revision, relPath) {
   return JSON.parse(
     git(root, ["show", `${revision}:${relPath}`], { trim: false }),

package/scripts/v4-declarative-promotion-admission.mjs

@@ -8,7 +8,10 @@ export function admitV4DeclarativePromotion({
   runtimeRef,
   declarative,
 }) {
-  if (!/^v4(?:$|[-./])/u.test(String(runtimeRef || ""))) {
+  if (
+    declarative !== true &&
+    !/^v4(?:$|[-./])/u.test(String(runtimeRef || ""))
+  ) {
     return Object.freeze({ mode: "legacy", admitted: true });
   }
   if (declarative !== true) {

package/scripts/v4-release-candidate-adapter.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+export function resolveV4ReleaseCandidateAdapter({
+  resumeCandidateRunId = "",
+} = {}) {
+  const mode = String(resumeCandidateRunId || "").trim() ? "recovery" : "fresh";
+  return Object.freeze({
+    mode,
+    script:
+      mode === "recovery"
+        ? "scripts/resume-from-candidate-run.mjs"
+        : "scripts/release-candidate-resolver.mjs",
+  });
+}
+
+export function runV4ReleaseCandidateAdapter({
+  env = process.env,
+  exec = execFileSync,
+} = {}) {
+  const route = resolveV4ReleaseCandidateAdapter({
+    resumeCandidateRunId: env.BUILDCHAIN_RESUME_CANDIDATE_RUN_ID,
+  });
+  exec(process.execPath, [path.join(root, route.script)], {
+    env,
+    stdio: "inherit",
+  });
+  return route;
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  runV4ReleaseCandidateAdapter();
+}

package/scripts/capture-package-release-propagation.mjs

@@ -1,263 +0,0 @@
-#!/usr/bin/env node
-
-import crypto from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import {
-  createPackageReleasePropagationCapture,
-  normalizePackageReleasePropagationConfig,
-} from "../packages/core/release-propagation-capture.js";
-import { stableJson } from "../packages/core/release-propagation-common.js";
-
-function parseArgs(argv) {
-  const args = {};
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index];
-    if (!token.startsWith("--")) throw new Error(`unexpected argument: ${token}`);
-    const key = token.slice(2);
-    const value = argv[index + 1];
-    if (!value || value.startsWith("--")) throw new Error(`${token} requires a value`);
-    args[key] = value;
-    index += 1;
-  }
-  return args;
-}
-
-function required(args, key) {
-  const value = String(args[key] || "").trim();
-  if (!value) throw new Error(`--${key} is required`);
-  return value;
-}
-
-function sha256(bytes) {
-  return crypto.createHash("sha256").update(bytes).digest("hex");
-}
-
-function commandJson(command, args, options = {}) {
-  const text = execFileSync(command, args, { encoding: "utf8", ...options });
-  return JSON.parse(text);
-}
-
-function assertSourcePath(value) {
-  const sourcePath = String(value || "").trim();
-  if (!sourcePath || path.isAbsolute(sourcePath) || sourcePath.split("/").includes("..") || /[\r\n]/.test(sourcePath)) {
-    throw new Error("release propagation config path must be a safe repository-relative path");
-  }
-  return sourcePath;
-}
-
-function hasCommit(sourceSha, cwd) {
-  try {
-    execFileSync("git", ["cat-file", "-e", `${sourceSha}^{commit}`], {
-      cwd,
-      stdio: "ignore",
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function readConfigAtSource(sourceSha, configPath, cwd) {
-  if (!hasCommit(sourceSha, cwd)) {
-    try {
-      execFileSync("git", ["fetch", "--no-tags", "--depth=1", "origin", sourceSha], {
-        cwd,
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-    } catch (error) {
-      const detail = String(error.stderr || error.message || "unknown git fetch failure").trim();
-      throw new Error(`exact release source ${sourceSha} is unavailable from origin: ${detail}`);
-    }
-  }
-  const bytes = execFileSync("git", ["show", `${sourceSha}:${configPath}`], {
-    cwd,
-    encoding: "utf8",
-  });
-  const parsed = JSON.parse(bytes);
-  return { bytes, parsed, normalized: normalizePackageReleasePropagationConfig(parsed) };
-}
-
-function resolveTagTarget(repository, tag) {
-  let object = commandJson("gh", ["api", `repos/${repository}/git/ref/tags/${tag}`]).object;
-  for (let depth = 0; depth < 8 && object?.type === "tag"; depth += 1) {
-    object = commandJson("gh", ["api", `repos/${repository}/git/tags/${object.sha}`]).object;
-  }
-  if (object?.type !== "commit" || !/^[0-9a-f]{40}$/i.test(object.sha || "")) {
-    throw new Error(`release tag ${tag} does not resolve to one exact commit`);
-  }
-  return object.sha.toLowerCase();
-}
-
-function resolvePackageFact(packageName, version) {
-  const fact = commandJson("npm", [
-    "view",
-    `${packageName}@${version}`,
-    "version",
-    "dist.integrity",
-    "gitHead",
-    "--json",
-    "--registry=https://registry.npmjs.org/",
-  ]);
-  return {
-    name: packageName,
-    version: String(fact.version || ""),
-    integrity: String(fact.dist?.integrity || fact["dist.integrity"] || ""),
-    gitHead: String(fact.gitHead || "").toLowerCase(),
-  };
-}
-
-function verifyPublicReleasePassport({ repository, tag, localPath }) {
-  const temporary = fs.mkdtempSync(path.join(os.tmpdir(), "buildchain-release-passport-"));
-  try {
-    execFileSync("gh", [
-      "release", "download", tag,
-      "--repo", repository,
-      "--pattern", "buildchain.release.json",
-      "--dir", temporary,
-    ], { stdio: ["ignore", "pipe", "pipe"] });
-    const localBytes = fs.readFileSync(localPath);
-    const remotePath = path.join(temporary, "buildchain.release.json");
-    const remoteBytes = fs.readFileSync(remotePath);
-    const localDigest = sha256(localBytes);
-    const remoteDigest = sha256(remoteBytes);
-    if (localDigest !== remoteDigest) {
-      throw new Error("public release passport bytes disagree with finalized local passport");
-    }
-    return {
-      url: `https://github.com/${repository}/releases/download/${tag}/buildchain.release.json`,
-      sha256: remoteDigest,
-    };
-  } finally {
-    fs.rmSync(temporary, { recursive: true, force: true });
-  }
-}
-
-function resolveBaseShas(config) {
-  return Object.fromEntries(config.targets.map((targetId) => {
-    const node = config.graph.nodes.find((entry) => entry.id === targetId);
-    if (!node?.baseRef) throw new Error(`configured propagation target ${targetId} has no baseRef`);
-    const response = commandJson("gh", ["api", `repos/${node.repository}/commits/${node.baseRef}`]);
-    const sha = String(response.sha || "").toLowerCase();
-    if (!/^[0-9a-f]{40}$/.test(sha)) {
-      throw new Error(`configured propagation target ${targetId} baseRef did not resolve exactly`);
-    }
-    return [targetId, sha];
-  }));
-}
-
-function writeOutput(name, value) {
-  if (!process.env.GITHUB_OUTPUT) return;
-  fs.appendFileSync(process.env.GITHUB_OUTPUT, `${name}=${value}\n`);
-}
-
-export function capturePackageReleasePropagation({
-  config,
-  upstreamRelease,
-  expectedBaseShas,
-  outputDir,
-  configBytes = "",
-} = {}) {
-  const captured = createPackageReleasePropagationCapture({
-    config,
-    upstreamRelease,
-    expectedBaseShas,
-  });
-  fs.mkdirSync(outputDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(outputDir, "config.json"),
-    configBytes || stableJson(captured.config),
-  );
-  fs.writeFileSync(path.join(outputDir, "upstream-release.json"), stableJson(captured.upstreamRelease));
-  fs.writeFileSync(path.join(outputDir, "plan.json"), stableJson(captured.plan));
-  for (const item of captured.works) {
-    const targetDir = path.join(outputDir, "work", item.propagationKey);
-    fs.mkdirSync(targetDir, { recursive: true });
-    fs.writeFileSync(path.join(targetDir, "work.json"), stableJson(item.work));
-    fs.writeFileSync(path.join(targetDir, "status.json"), stableJson(item.status));
-  }
-  return captured;
-}
-
-export function main(argv = process.argv.slice(2)) {
-  const args = parseArgs(argv);
-  const repository = required(args, "repository");
-  const channel = required(args, "channel");
-  const sourceSha = required(args, "source-sha").toLowerCase();
-  const tag = required(args, "tag");
-  const configPath = assertSourcePath(required(args, "config-path"));
-  const releasePassportPath = path.resolve(required(args, "release-passport-path"));
-  const outputDir = path.resolve(required(args, "output-dir"));
-  if (!/^[0-9a-f]{40}$/.test(sourceSha)) throw new Error("--source-sha must be an exact commit SHA");
-  if (tag !== `v${tag.replace(/^v/, "")}`) throw new Error("--tag must be an exact v-prefixed release tag");
-  const version = tag.slice(1);
-  const configSource = readConfigAtSource(sourceSha, configPath, process.cwd());
-  const sourceNode = configSource.normalized.graph.nodes.find(
-    (node) => node.id === configSource.normalized.sourceNode,
-  );
-  const packageFact = resolvePackageFact(sourceNode.package, version);
-  const tagTargetSha = resolveTagTarget(repository, tag);
-  const releasePassport = verifyPublicReleasePassport({
-    repository,
-    tag,
-    localPath: releasePassportPath,
-  });
-  const upstreamRelease = {
-    repository,
-    channel,
-    tag,
-    sourceSha,
-    tagTargetSha,
-    package: packageFact,
-    releasePassport,
-  };
-  const expectedBaseShas = resolveBaseShas(configSource.normalized);
-  const captured = capturePackageReleasePropagation({
-    config: configSource.parsed,
-    configBytes: configSource.bytes,
-    upstreamRelease,
-    expectedBaseShas,
-    outputDir,
-  });
-  const artifactName = `package-propagation-work-${version}-${sourceSha}`;
-  const workRoots = captured.works.map((item) => item.work.contentRoot);
-  writeOutput("configured", "true");
-  writeOutput("artifact-name", artifactName);
-  writeOutput("work-roots-json", JSON.stringify(workRoots));
-  process.stdout.write(stableJson({
-    schemaVersion: 1,
-    contract: "kungfu-buildchain-package-release-propagation-capture-result",
-    artifactName,
-    release: {
-      repository,
-      channel,
-      tag,
-      sourceSha,
-      tagTargetSha,
-      package: packageFact,
-      releasePassport,
-    },
-    workCount: captured.works.length,
-    works: captured.works.map((item) => ({
-      target: item.target,
-      repository: item.repository,
-      propagationKey: item.propagationKey,
-      workId: item.work.workId,
-      workRoot: item.work.contentRoot,
-      nextAction: item.status.nextAction,
-    })),
-  }));
-}
-
-const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
-if (isMain) {
-  try {
-    main();
-  } catch (error) {
-    console.error(error.message);
-    process.exitCode = 1;
-  }
-}