@git.zone/cli 6.7.3 → 6.9.0

package/ts/mod_release/index.ts

@@ -49,8 +49,14 @@ import {
   normalizeNpmRegistryUrl,
   packNpmArtifact,
   verifyStoredNpmArtifact,
+  type IPnpmReleaseCapability,
 } from "./helpers.npmartifact.js";
 import { executeReleasePublication } from "./helpers.releasepublication.js";
+import {
+  assertPackageReleaseRecovery,
+  assertRecoveryUnpublished,
+  withReleasePreparationRecovery,
+} from "./helpers.releasepreparation.js";
 import {
   TsdockerReleaseClient,
   canonicalReleaseJson,
@@ -87,6 +93,10 @@ const runInternal = async (argvArg: any): Promise<void> => {
     await runReleaseResume(argvArg, mode);
     return;
   }
+  if (subcommand === "recover") {
+    await runReleaseRecover(argvArg, mode);
+    return;
+  }
   if (subcommand !== undefined) {
     throw new Error(`Unknown release subcommand: ${subcommand}`);
   }
@@ -134,7 +144,7 @@ const runInternal = async (argvArg: any): Promise<void> => {
   const preflightTsdocker = workflow.targets.includes("docker")
     ? new TsdockerReleaseClient(smartshellInstance, branchContext.sourceCwd)
     : undefined;
-  await assertFreshReleaseCapabilities(
+  const pnpmCapability = await assertFreshReleaseCapabilities(
     smartshellInstance,
     workflow,
     branchContext.sourceCwd,
@@ -284,6 +294,7 @@ const runInternal = async (argvArg: any): Promise<void> => {
       )
     : undefined;
   const journalContext = await createReleaseJournal({
+    pnpmCapability,
     smartshell: smartshellInstance,
     workflow,
     releaseCwd,
@@ -296,6 +307,7 @@ const runInternal = async (argvArg: any): Promise<void> => {
     ensurePublicationState,
   });
   const finalJournal = await executeReleasePublication({
+    pnpmCapability,
     smartshell: smartshellInstance,
     cwd: releaseCwd,
     store: journalContext.store,
@@ -313,7 +325,7 @@ const assertFreshReleaseCapabilities = async (
   cwdArg: string,
   pushUrlArg?: string,
   tsdockerArg?: ITsdockerReleaseClient,
-): Promise<void> => {
+): Promise<IPnpmReleaseCapability | undefined> => {
   if (workflowArg.targets.includes("docker")) {
     if (!tsdockerArg) {
       throw new Error("Docker release target requires project-local tSDocker.");
@@ -332,7 +344,7 @@ const assertFreshReleaseCapabilities = async (
     await assertNoLegacyNpmPublisher(cwdArg);
   }
   if (workflowArg.targets.includes("npm")) {
-    await assertPnpmReleaseCapability(smartshellArg, cwdArg);
+    return assertPnpmReleaseCapability(smartshellArg, cwdArg);
   }
 };
 
@@ -399,9 +411,12 @@ const assertReleaseConfiguration = (
 };
 
 interface ICreateReleaseJournalOptions {
+  pnpmCapability?: IPnpmReleaseCapability;
   smartshell: plugins.smartshell.Smartshell;
   workflow: IResolvedReleaseWorkflow;
   releaseCwd: string;
+  /** Exact detached checkout used only while recovering pre-journal packaging. */
+  npmSourceCwd?: string;
   releasePushUrl?: string;
   expectedRemoteMainOid?: string;
   version: string;
@@ -447,6 +462,7 @@ export const planReleasePackages = async (
 export const createReleaseJournal = async (
   optionsArg: ICreateReleaseJournalOptions,
 ): Promise<{ store: ReleaseJournalStore; journal: TReleaseJournal }> => {
+  const npmSourceCwd = optionsArg.npmSourceCwd ?? optionsArg.releaseCwd;
   const gitCommonDirectory = await resolveGitCommonDirectory(
     optionsArg.smartshell,
     optionsArg.releaseCwd,
@@ -474,7 +490,7 @@ export const createReleaseJournal = async (
     const packages: IReleasePackage[] = [];
     if (optionsArg.workflow.targets.includes("npm")) {
       if (optionsArg.workflow.npmPackageSource === "tspublish") {
-        const plan = await planReleasePackages(optionsArg.releaseCwd);
+        const plan = await planReleasePackages(npmSourceCwd);
         if (plan.version !== optionsArg.version)
           throw new Error("tspublish plan version differs from the release.");
         const outputDirectory = plugins.path.join(
@@ -482,7 +498,7 @@ export const createReleaseJournal = async (
           "prepared",
         );
         const prepared = await new plugins.tspublish.TsPublish().prepare(
-          optionsArg.releaseCwd,
+          npmSourceCwd,
           outputDirectory,
         );
         if (
@@ -497,6 +513,7 @@ export const createReleaseJournal = async (
             module.directory,
             temporaryDirectory,
             optionsArg.version,
+            optionsArg.pnpmCapability,
             releasePackageArtifactFile(module.name),
           );
           if (packed.packageName !== module.name)
@@ -509,14 +526,15 @@ export const createReleaseJournal = async (
       } else {
         artifact = await packNpmArtifact(
           optionsArg.smartshell,
-          optionsArg.releaseCwd,
+          npmSourceCwd,
           temporaryDirectory,
           optionsArg.version,
+          optionsArg.pnpmCapability,
         );
       }
       await verifyCleanTree(
         optionsArg.smartshell,
-        optionsArg.releaseCwd,
+        npmSourceCwd,
         "npm pack lifecycle scripts changed the release worktree. Aborting release.",
       );
       await optionsArg.ensurePublicationState();
@@ -650,6 +668,155 @@ const runReleaseInspect = async (
   }
 };
 
+const runReleaseRecover = async (
+  argvArg: any,
+  mode: ICliMode,
+): Promise<void> => {
+  const allowed = new Set([
+    "_",
+    "$0",
+    "y",
+    "yes",
+    "plan",
+    "h",
+    "help",
+    "plain",
+    "quiet",
+    "agent",
+    "interactive",
+    "check-updates",
+    "checkUpdates",
+  ]);
+  if (
+    argvArg._?.length !== 3 ||
+    Object.keys(argvArg).some((key) => !allowed.has(key)) ||
+    (argvArg.plan !== undefined && typeof argvArg.plan !== "boolean")
+  ) {
+    throw new Error(
+      "Usage: gitzone release recover <version> [-y|--plan]. Target, version, build and test overrides are not allowed.",
+    );
+  }
+  const version = normalizeReleaseVersion(argvArg._[2]);
+  const shell = new plugins.smartshell.Smartshell({
+    executor: "bash",
+    sourceFilePaths: [],
+  });
+  const store = new ReleaseJournalStore(
+    await resolveGitCommonDirectory(shell, paths.cwd),
+  );
+  const existing = await plugins.fs
+    .lstat(store.getReleaseDirectory(version))
+    .then(() => true)
+    .catch((error: NodeJS.ErrnoException) => {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    });
+  if (existing) {
+    if (argvArg.plan) {
+      printReleaseJournalSummary(await store.read(version));
+      return;
+    }
+    await runReleaseResume(
+      { _: ["release", "resume", version], yes: mode.yes },
+      mode,
+    );
+    return;
+  }
+  const workflow = await resolveReleaseWorkflow({ yes: true });
+  assertReleaseConfiguration(workflow, false);
+  let branch = await inspectReleaseBranch({
+    smartshell: shell,
+    cwd: paths.cwd,
+    gitRemote: workflow.gitRemote,
+    gitTargetActive: true,
+    pushBranch: workflow.pushBranch,
+    pushTags: workflow.pushTags,
+    mergeRequested: false,
+    planMode: argvArg.plan === true,
+  });
+  const refs = await captureReleaseRefs(
+    shell,
+    paths.cwd,
+    version,
+    branch.sourceOid,
+  );
+  const options = { smartshell: shell, workflow, branch, refs, version, store };
+  const packageName = await assertPackageReleaseRecovery(options);
+  if (!branch.planAncestryVerified) {
+    console.log(
+      "Remote ancestry is deferred until execution fetches the missing commit.",
+    );
+  }
+  console.log(
+    `Recover existing ${packageName}@${version}\ncommit: ${refs.mainOid}\ntag object: ${refs.tagOid}\nGit destination: ${branch.gitRemote}\nnpm registries: ${workflow.npmRegistries.join(", ")}\nBuild and pack an isolated checkout, install its journal, then publish configured targets.`,
+  );
+  if (argvArg.plan) return;
+  const pnpmCapability = await assertFreshReleaseCapabilities(
+    shell,
+    workflow,
+    paths.cwd,
+    branch.pushUrl,
+  );
+  if (!mode.yes) {
+    if (!mode.interactive)
+      throw new Error(
+        "Release recovery requires an interactive terminal or -y.",
+      );
+    if (
+      !(await plugins.smartinteract.SmartInteract.getCliConfirmation(
+        `Recover and publish existing v${version}?`,
+        false,
+      ))
+    )
+      return;
+  }
+  branch = await prepareReleaseIntegration(shell, branch);
+  options.branch = branch;
+  const ensureState = async (remote = branch.remoteMainOid) => {
+    await verifyReleaseRefs(shell, paths.cwd, version, refs);
+    await revalidateReleasePublicationState(
+      shell,
+      branch,
+      refs.mainOid,
+      remote,
+    );
+  };
+  const ensureUnpublished = async () => {
+    await ensureState();
+    await assertRecoveryUnpublished(options, packageName);
+  };
+  const context = await withReleasePreparationRecovery(
+    options,
+    ensureUnpublished,
+    async (checkout, ensureCheckout) =>
+      createReleaseJournal({
+        pnpmCapability,
+        smartshell: shell,
+        workflow,
+        releaseCwd: paths.cwd,
+        npmSourceCwd: checkout,
+        releasePushUrl: branch.pushUrl,
+        expectedRemoteMainOid: branch.remoteMainOid,
+        version,
+        refs,
+        ensurePublicationState: async () => {
+          await ensureCheckout();
+          await ensureUnpublished();
+        },
+      }),
+  );
+  const result = await executeReleasePublication({
+    pnpmCapability,
+    smartshell: shell,
+    cwd: paths.cwd,
+    store: context.store,
+    journal: context.journal,
+    pushUrl: branch.pushUrl,
+    ensurePublicationState: ensureState,
+  });
+  printReleaseJournalSummary(result);
+};
+
 const assertResumeArguments = (argvArg: any): void => {
   const forbiddenKeys = [
     "allow-empty",
@@ -754,8 +921,12 @@ const runReleaseResume = async (
     await tsdocker.assertCapabilities();
     await tsdocker.validate(journal.docker.request);
   }
+  let pnpmCapability: IPnpmReleaseCapability | undefined;
   if (getReleaseArtifacts(journal).length) {
-    await assertPnpmReleaseCapability(smartshellInstance, paths.cwd);
+    pnpmCapability = await assertPnpmReleaseCapability(
+      smartshellInstance,
+      paths.cwd,
+    );
     await assertNoLegacyNpmPublisher(paths.cwd);
     for (const artifact of getReleaseArtifacts(journal)) {
       await verifyStoredNpmArtifact(
@@ -825,6 +996,7 @@ const runReleaseResume = async (
     );
   };
   const finalJournal = await executeReleasePublication({
+    pnpmCapability,
     smartshell: smartshellInstance,
     cwd: paths.cwd,
     store,
@@ -1284,7 +1456,8 @@ export function showHelp(mode?: ICliMode): void {
   if (mode?.json) {
     printJson({
       command: "release",
-      usage: "gitzone release [inspect [version]|resume <version>] [options]",
+      usage:
+        "gitzone release [inspect [version]|resume <version>|recover <version>] [options]",
       description:
         "Creates a versioned release from pending changelog entries and publishes configured artifacts.",
       flags: [
@@ -1338,6 +1511,11 @@ export function showHelp(mode?: ICliMode): void {
           description:
             "Resume exact journaled publication without rebuilding or repacking npm artifacts",
         },
+        {
+          flag: "recover <version>",
+          description:
+            "Recover a local root npm release tag after build or pack failure before journal creation",
+        },
         {
           flag: "--recover-attempt <id>",
           description:
@@ -1350,7 +1528,7 @@ export function showHelp(mode?: ICliMode): void {
 
   console.log("");
   console.log(
-    "Usage: gitzone release [inspect [version]|resume <version>] [options]",
+    "Usage: gitzone release [inspect [version]|resume <version>|recover <version>] [options]",
   );
   console.log("");
   console.log("Creates a versioned release from changelog Pending entries.");
@@ -1386,6 +1564,9 @@ export function showHelp(mode?: ICliMode): void {
   console.log(
     "  resume <version>    Resume exact journaled publication without rebuilding or repacking npm artifacts",
   );
+  console.log(
+    "  recover <version>   Recover an unpublished root npm release from its existing local tag",
+  );
   console.log(
     "  --recover-attempt   Recover one exact 32-character hexadecimal attempt ID after proving its publisher stopped",
   );