@kb-labs/release-manager-core 2.83.0 → 2.86.0

package/dist/index.d.ts

@@ -15,6 +15,8 @@ interface ReleaseContext {
 interface PackageVersion {
     name: string;
     path: string;
+    /** Absolute path to the git repository root for this package. Populated during planning. */
+    gitRoot: string;
     currentVersion: string;
     nextVersion: string;
     bump: VersionBump;
@@ -408,6 +410,14 @@ declare function commitAndTagRelease(options: {
     dryRun?: boolean;
     /** Pass --no-verify to git push and pushTags. Default: false — hooks run normally. */
     noVerify?: boolean;
+    /** repoRoot for checkpoint updates. If omitted, checkpoint updates are skipped. */
+    repoRoot?: string;
+    /** Per-root state from checkpoint — skip roots already fully pushed. */
+    checkpointGitRoots?: Record<string, {
+        committed: boolean;
+        tagged: string[];
+        pushed: boolean;
+    }>;
 }): Promise<{
     committed: boolean;
     tagged: string[];

package/dist/index.js

@@ -1,10 +1,10 @@
 import { readFile, writeFile, mkdir, rm, rename, cp } from 'fs/promises';
-import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, rmSync, statSync } from 'fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, rmSync, statSync, unlinkSync } from 'fs';
 import { join, relative, resolve, dirname } from 'path';
 import simpleGit from 'simple-git';
 import semver2 from 'semver';
 import globby from 'globby';
-import { discoverSubRepoPaths } from '@kb-labs/sdk';
+import { discoverSubRepoPaths, useEnv } from '@kb-labs/sdk';
 import { execa } from 'execa';
 import { spawn, execSync } from 'child_process';
 import { tmpdir } from 'os';
@@ -104,6 +104,16 @@ function mergeConfigWithFlow(config, flowName) {
     ...flow.checks !== void 0 && { checks: flow.checks }
   };
 }
+async function isVersionPublished(name, version, registry) {
+  try {
+    const encoded = name.startsWith("@") ? `@${encodeURIComponent(name.slice(1))}` : name;
+    const url = `${registry.replace(/\/$/, "")}/${encoded}/${version}`;
+    const res = await fetch(url, { method: "HEAD", signal: AbortSignal.timeout(5e3) });
+    return res.status === 200;
+  } catch {
+    return false;
+  }
+}
 async function planRelease(options) {
   const { cwd, scope, bumpOverride } = options;
   const config = options.flow ? mergeConfigWithFlow(options.config, options.flow) : options.config;
@@ -140,11 +150,38 @@ async function planRelease(options) {
     const git = simpleGit(cwd, { timeout: { block: 6e4 } });
     modifiedPackages = await detectModifiedPackages(git, packages, cwd);
   }
+  const registry = config.registry ?? "https://registry.npmjs.org";
   let planPackages = [];
   for (const pkg of modifiedPackages) {
     const bump = bumpOverride || config.bump || "auto";
     const gitCwd = isWorkspaceRoot ? pkg.path : cwd;
     const git = simpleGit(gitCwd, { timeout: { block: 6e4 } });
+    let gitRoot = pkg.gitRoot;
+    if (!gitRoot) {
+      gitRoot = await git.revparse(["--show-toplevel"]).catch(() => pkg.path);
+    }
+    const pkgRelPath = relative(gitRoot, join(pkg.path, "package.json"));
+    const headPkgRaw = await git.raw(["show", `HEAD:${pkgRelPath}`]).catch(() => null);
+    const headVersion = headPkgRaw ? (() => {
+      try {
+        return JSON.parse(headPkgRaw).version ?? null;
+      } catch {
+        return null;
+      }
+    })() : null;
+    if (headVersion && headVersion !== pkg.currentVersion) {
+      const alreadyPublished = await isVersionPublished(pkg.name, pkg.currentVersion, registry);
+      if (alreadyPublished) {
+        planPackages.push({
+          ...pkg,
+          gitRoot,
+          nextVersion: pkg.currentVersion,
+          bump: detectBumpType(headVersion, pkg.currentVersion),
+          isPublished: true
+        });
+        continue;
+      }
+    }
     const nextVersion = await computeNextVersion(
       pkg.path,
       pkg.currentVersion,
@@ -155,6 +192,7 @@ async function planRelease(options) {
     );
     planPackages.push({
       ...pkg,
+      gitRoot,
       nextVersion,
       bump: bump === "auto" ? detectBumpType(pkg.currentVersion, nextVersion) : bump
     });
@@ -232,6 +270,7 @@ async function discoverPackages(cwd, config) {
     packages.push({
       name: packageJson.name,
       path: packagePath,
+      gitRoot: "",
       currentVersion: packageJson.version,
       nextVersion: packageJson.version,
       bump: "auto",
@@ -317,6 +356,7 @@ async function discoverSubRepoPackages(workspaceRoot, config) {
       packages.push({
         name: pkgJson.name,
         path: subRepoPath,
+        gitRoot: subRepoPath,
         currentVersion: pkgJson.version || "0.0.0",
         nextVersion: pkgJson.version || "0.0.0",
         bump: "auto",
@@ -425,6 +465,104 @@ function createExecaShellAdapter() {
     }
   };
 }
+function rewriteLinkDep(deps, depName, val, pkgPath, versionMap) {
+  const pinned = versionMap.get(depName);
+  if (pinned) {
+    deps[depName] = `^${pinned}`;
+    return;
+  }
+  try {
+    const linkPath = val.slice("link:".length);
+    const linked = JSON.parse(readFileSync(join(pkgPath, linkPath, "package.json"), "utf-8"));
+    deps[depName] = `^${linked.version ?? "*"}`;
+  } catch {
+    deps[depName] = "*";
+  }
+}
+function rewriteWorkspaceDep(deps, depName, val, versionMap) {
+  const pinned = versionMap.get(depName);
+  if (!pinned) {
+    return false;
+  }
+  deps[depName] = val === "workspace:*" ? `^${pinned}` : val.replace("workspace:", "");
+  return true;
+}
+function rewriteDepsSection(deps, pkgPath, versionMap, packageManager) {
+  let modified = false;
+  for (const depName of Object.keys(deps)) {
+    const val = deps[depName];
+    if (typeof val !== "string") {
+      continue;
+    }
+    if (val.startsWith("link:")) {
+      rewriteLinkDep(deps, depName, val, pkgPath, versionMap);
+      modified = true;
+    } else if (val.startsWith("workspace:") && packageManager !== "pnpm" && rewriteWorkspaceDep(deps, depName, val, versionMap)) {
+      modified = true;
+    }
+  }
+  return modified;
+}
+function rewriteWorkspaceDeps(pkgPath, versionMap, packageManager) {
+  const pkgJsonPath = join(pkgPath, "package.json");
+  const original = readFileSync(pkgJsonPath, "utf-8");
+  const pkgJson = JSON.parse(original);
+  let modified = false;
+  for (const section of ["dependencies", "peerDependencies"]) {
+    const deps = pkgJson[section];
+    if (!deps) {
+      continue;
+    }
+    if (rewriteDepsSection(deps, pkgPath, versionMap, packageManager)) {
+      modified = true;
+    }
+  }
+  if (modified) {
+    writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+  }
+  return () => writeFileSync(pkgJsonPath, original);
+}
+function checkpointPath(repoRoot) {
+  return join(repoRoot, ".kb", "release", "checkpoint.json");
+}
+function loadCheckpoint(repoRoot) {
+  const path = checkpointPath(repoRoot);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCheckpoint(repoRoot, checkpoint) {
+  mkdirSync(join(repoRoot, ".kb", "release"), { recursive: true });
+  const data = { ...checkpoint, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync(checkpointPath(repoRoot), JSON.stringify(data, null, 2));
+}
+function updateCheckpointGitRoot(repoRoot, gitRoot, state) {
+  const checkpoint = loadCheckpoint(repoRoot);
+  if (!checkpoint) return;
+  checkpoint.gitRoots[gitRoot] = state;
+  writeFileSync(checkpointPath(repoRoot), JSON.stringify(checkpoint, null, 2));
+}
+function markCheckpointComplete(repoRoot) {
+  const checkpoint = loadCheckpoint(repoRoot);
+  if (!checkpoint) return;
+  checkpoint.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(checkpointPath(repoRoot), JSON.stringify(checkpoint, null, 2));
+}
+function deleteCheckpoint(repoRoot) {
+  try {
+    unlinkSync(checkpointPath(repoRoot));
+  } catch {
+  }
+}
+function isCheckpointResumable(checkpoint, flow, version) {
+  if (checkpoint.completedAt) return false;
+  if (checkpoint.flow !== flow) return false;
+  if (checkpoint.version !== version && version !== "independent") return false;
+  return checkpoint.publishedPackages.length > 0 && Object.values(checkpoint.gitRoots).some((s) => !s.pushed);
+}
 
 // src/publisher.ts
 async function publishPackages(options) {
@@ -448,6 +586,8 @@ async function publishPackages(options) {
     }
     return result;
   }
+  const pm = options.config?.publish?.packageManager ?? "pnpm";
+  const versionMap = new Map(plan.packages.map((p) => [p.name, p.nextVersion]));
   for (const pkg of plan.packages) {
     try {
       const registry = plan.registry || "https://registry.npmjs.org";
@@ -470,16 +610,18 @@ async function publishPackages(options) {
         });
         continue;
       }
-      const pm = options.config?.publish?.packageManager ?? "pnpm";
+      const restoreDeps = rewriteWorkspaceDeps(pkg.path, versionMap, pm);
       const access = options.config?.publish?.access ?? "public";
-      const publishResult = await shellApi.exec(
-        pm,
-        ["publish", "--access", access, "--registry", registry],
-        {
-          cwd: pkg.path,
-          timeout: 6e4
-        }
-      );
+      let publishResult;
+      try {
+        publishResult = await shellApi.exec(
+          pm,
+          ["publish", "--access", access, "--registry", registry],
+          { cwd: pkg.path, timeout: 6e4 }
+        );
+      } finally {
+        restoreDeps();
+      }
       if (publishResult.ok) {
         result.published.push(`${pkg.name}@${pkg.nextVersion}`);
       } else {
@@ -639,7 +781,7 @@ function createPackageChangelog(pkg, changelog) {
   return changelog.substring(startIdx, endIdx).trim();
 }
 async function commitAndTagRelease(options) {
-  const { cwd, plan, dryRun, noVerify = false } = options;
+  const { cwd, plan, dryRun, noVerify = false, repoRoot, checkpointGitRoots } = options;
   const simpleGit2 = (await import('simple-git')).default;
   const result = {
     committed: false,
@@ -653,12 +795,7 @@ async function commitAndTagRelease(options) {
     const commitMessage = createCommitMessage(plan);
     const pkgToRoot = /* @__PURE__ */ new Map();
     for (const pkg of plan.packages) {
-      try {
-        const root = (await simpleGit2(pkg.path).revparse(["--show-toplevel"])).trim();
-        pkgToRoot.set(pkg.path, root);
-      } catch {
-        pkgToRoot.set(pkg.path, pkg.path);
-      }
+      pkgToRoot.set(pkg.path, pkg.gitRoot || pkg.path);
     }
     const rootToPkgs = /* @__PURE__ */ new Map();
     for (const pkg of plan.packages) {
@@ -667,55 +804,77 @@ async function commitAndTagRelease(options) {
       list.push(pkg);
       rootToPkgs.set(root, list);
     }
+    const uniqueVersions = new Set(plan.packages.map((p) => p.nextVersion));
+    const isLockstep = plan.packages.length > 1 && uniqueVersions.size === 1;
+    const pushFlags = noVerify ? ["--no-verify"] : [];
+    const pushTagsOptions = noVerify ? ["--no-verify"] : void 0;
     for (const [root, pkgs] of rootToPkgs) {
+      const prior = checkpointGitRoots?.[root];
+      if (prior?.pushed) {
+        result.committed = result.committed || prior.committed;
+        result.tagged.push(...prior.tagged.filter((t) => !result.tagged.includes(t)));
+        result.pushed = true;
+        continue;
+      }
       const rootGit = simpleGit2(root);
-      const filesToStage = [];
-      for (const pkg of pkgs) {
-        const rel = (p) => p.startsWith(root + "/") ? p.slice(root.length + 1) : p;
-        filesToStage.push(rel(join(pkg.path, "package.json")));
-        const changelogPath = join(pkg.path, "CHANGELOG.md");
-        if (existsSync(changelogPath)) {
-          filesToStage.push(rel(changelogPath));
+      let rootCommitted = prior?.committed ?? false;
+      let rootTagged = prior?.tagged ?? [];
+      if (!rootCommitted) {
+        const filesToStage = [];
+        for (const pkg of pkgs) {
+          const rel = (p) => p.startsWith(root + "/") ? p.slice(root.length + 1) : p;
+          filesToStage.push(rel(join(pkg.path, "package.json")));
+          const changelogPath = join(pkg.path, "CHANGELOG.md");
+          if (existsSync(changelogPath)) {
+            filesToStage.push(rel(changelogPath));
+          }
         }
-      }
-      await rootGit.add(filesToStage);
-      try {
-        await rootGit.commit(commitMessage);
-        result.committed = true;
-      } catch (commitError) {
-        const msg = commitError instanceof Error ? commitError.message : String(commitError);
-        if (!msg.includes("nothing to commit") && !msg.includes("nothing added to commit")) {
-          throw commitError;
+        await rootGit.add(filesToStage);
+        try {
+          await rootGit.commit(commitMessage);
+          rootCommitted = true;
+          result.committed = true;
+        } catch (commitError) {
+          const msg = commitError instanceof Error ? commitError.message : String(commitError);
+          if (!msg.includes("nothing to commit") && !msg.includes("nothing added to commit")) {
+            throw commitError;
+          }
         }
+      } else {
+        result.committed = true;
       }
-    }
-    const uniqueVersions = new Set(plan.packages.map((p) => p.nextVersion));
-    const isLockstep = plan.packages.length > 1 && uniqueVersions.size === 1;
-    if (isLockstep) {
-      const version = plan.packages[0].nextVersion;
-      const tagName = `v${version}`;
-      for (const root of rootToPkgs.keys()) {
-        await simpleGit2(root).addTag(tagName);
-      }
-      result.tagged.push(tagName);
-    } else {
-      for (const pkg of plan.packages) {
-        const root = pkgToRoot.get(pkg.path);
-        const tagName = `${pkg.name}@${pkg.nextVersion}`;
-        await simpleGit2(root).addTag(tagName);
-        result.tagged.push(tagName);
+      if (rootTagged.length === 0) {
+        if (isLockstep) {
+          const tagName = `v${plan.packages[0].nextVersion}`;
+          await rootGit.addTag(tagName);
+          rootTagged = [tagName];
+        } else {
+          for (const pkg of pkgs) {
+            const tagName = `${pkg.name}@${pkg.nextVersion}`;
+            await rootGit.addTag(tagName);
+            rootTagged.push(tagName);
+          }
+        }
+        result.tagged.push(...rootTagged);
+      } else {
+        result.tagged.push(...rootTagged.filter((t) => !result.tagged.includes(t)));
       }
-    }
-    const pushFlags = noVerify ? ["--no-verify"] : [];
-    const pushTagsOptions = noVerify ? ["--no-verify"] : void 0;
-    for (const root of rootToPkgs.keys()) {
-      const rootGit = simpleGit2(root);
-      if (result.committed) {
+      if (rootCommitted) {
         await rootGit.push(pushFlags);
       }
       await rootGit.pushTags(pushTagsOptions);
+      if (repoRoot) {
+        updateCheckpointGitRoot(repoRoot, root, {
+          committed: rootCommitted,
+          tagged: rootTagged,
+          pushed: true
+        });
+      }
     }
     result.pushed = true;
+    if (repoRoot) {
+      markCheckpointComplete(repoRoot);
+    }
   } catch (error) {
     console.error(`Git operations failed: ${error instanceof Error ? error.message : String(error)}`);
     throw error;
@@ -1329,6 +1488,38 @@ function findFiles(dir, predicate) {
   walk(dir);
   return results;
 }
+function lockPath(repoRoot) {
+  return join(repoRoot, ".kb", "release", "release.lock");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireLock(repoRoot, flow) {
+  const path = lockPath(repoRoot);
+  try {
+    const existing = JSON.parse(readFileSync(path, "utf-8"));
+    if (isProcessAlive(existing.pid)) {
+      throw new Error(
+        `Another release is already running (PID ${existing.pid}, started ${existing.startedAt}, flow: ${existing.flow ?? "unknown"}). If this is stale, delete: ${path}`
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Another release")) throw err;
+  }
+  mkdirSync(join(repoRoot, ".kb", "release"), { recursive: true });
+  writeFileSync(path, JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), flow }));
+  return () => {
+    try {
+      unlinkSync(path);
+    } catch {
+    }
+  };
+}
 
 // src/pipeline.ts
 async function runReleasePipeline(options) {
@@ -1355,6 +1546,65 @@ async function runReleasePipeline(options) {
     logger?.info?.(msg);
     onProgress?.(stage, msg);
   };
+  const releaseLock = acquireLock(repoRoot, flow);
+  try {
+    return await _runPipeline({
+      repoRoot,
+      scopeCwd,
+      scope,
+      flow,
+      config,
+      dryRun,
+      skipChecks,
+      skipBuild,
+      skipVerify,
+      noVerify,
+      checkConfigs,
+      publisher,
+      changelogGen,
+      logger,
+      startTime,
+      progress,
+      options
+    });
+  } finally {
+    releaseLock();
+  }
+}
+async function _runPipeline(ctx) {
+  const {
+    repoRoot,
+    scopeCwd,
+    scope,
+    flow,
+    config,
+    dryRun,
+    skipChecks,
+    skipBuild,
+    skipVerify,
+    noVerify,
+    checkConfigs,
+    publisher,
+    changelogGen,
+    logger,
+    startTime,
+    progress
+  } = ctx;
+  if (!dryRun) {
+    const registry = config.registry ?? "https://registry.npmjs.org";
+    const authError = await verifyNpmAuth(registry);
+    if (authError) {
+      return {
+        success: false,
+        plan: { packages: [], strategy: "semver", registry, rollbackEnabled: false },
+        report: buildReport("planning", { packages: [], strategy: "semver", registry, rollbackEnabled: false }, repoRoot, dryRun, startTime, {
+          ok: false,
+          errors: [`npm auth check failed: ${authError}`],
+          timingMs: Date.now() - startTime
+        })
+      };
+    }
+  }
   progress("planning", "Discovering packages and planning release...");
   const plan = await planRelease({
     cwd: repoRoot,
@@ -1376,6 +1626,36 @@ async function runReleasePipeline(options) {
     };
   }
   progress("planning", `Found ${plan.packages.length} package(s) to release`);
+  if (!dryRun) {
+    const existingCheckpoint = loadCheckpoint(repoRoot);
+    if (existingCheckpoint) {
+      const uniqueVersions = new Set(plan.packages.map((p) => p.nextVersion));
+      const planVersion = uniqueVersions.size === 1 ? plan.packages[0].nextVersion : "independent";
+      if (isCheckpointResumable(existingCheckpoint, flow ?? "default", planVersion)) {
+        progress("publishing", "Resuming from checkpoint \u2014 publish already done, running git step...");
+        const resumeGit = await commitAndTagRelease({
+          cwd: scopeCwd,
+          plan,
+          dryRun: false,
+          noVerify,
+          repoRoot,
+          checkpointGitRoots: existingCheckpoint.gitRoots
+        });
+        deleteCheckpoint(repoRoot);
+        const resumeReport = buildReport("verifying", plan, repoRoot, dryRun, startTime, {
+          ok: resumeGit.committed,
+          published: existingCheckpoint.publishedPackages.map((p) => `${p.name}@${p.version}`),
+          git: resumeGit,
+          timingMs: Date.now() - startTime
+        });
+        const scopeDir2 = scope ? scope.replace(/[@/]/g, "-").replace(/^-/, "") : "root";
+        const historyDir2 = join(repoRoot, ".kb", "release", "history", scopeDir2, (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"));
+        await mkdir(historyDir2, { recursive: true });
+        await writeFile(join(historyDir2, "report.json"), JSON.stringify(resumeReport, null, 2), "utf-8");
+        return { success: resumeReport.result.ok, plan, report: resumeReport };
+      }
+    }
+  }
   await saveSnapshot({ cwd: repoRoot, plan });
   if (!skipChecks && checkConfigs && checkConfigs.length > 0) {
     progress("checking", `Running ${checkConfigs.length} pre-release check(s)...`);
@@ -1522,10 +1802,26 @@ async function runReleasePipeline(options) {
       })
     };
   }
+  if (!dryRun) {
+    const uniqueVersions = new Set(plan.packages.map((p) => p.nextVersion));
+    const cpVersion = uniqueVersions.size === 1 ? plan.packages[0].nextVersion : "independent";
+    writeCheckpoint(repoRoot, {
+      flow: flow ?? "default",
+      version: cpVersion,
+      publishedPackages: plan.packages.map((p) => ({
+        name: p.name,
+        version: p.nextVersion,
+        path: p.path,
+        gitRoot: p.gitRoot
+      })),
+      gitRoots: {}
+    });
+  }
   let gitResult;
   if (!dryRun) {
     progress("verifying", "Committing and tagging release...");
-    gitResult = await commitAndTagRelease({ cwd: scopeCwd, plan, dryRun, noVerify });
+    gitResult = await commitAndTagRelease({ cwd: scopeCwd, plan, dryRun, noVerify, repoRoot });
+    deleteCheckpoint(repoRoot);
   }
   const report = buildReport("verifying", plan, repoRoot, dryRun, startTime, {
     ok: !gitResult || gitResult.committed,
@@ -1542,6 +1838,24 @@ async function runReleasePipeline(options) {
   await writeFile(join(historyDir, "report.json"), JSON.stringify(report, null, 2), "utf-8");
   return { success: report.result.ok, plan, report };
 }
+async function verifyNpmAuth(registry) {
+  const token = useEnv("NPM_TOKEN") ?? useEnv("NODE_AUTH_TOKEN");
+  if (!token) {
+    return "NPM_TOKEN or NODE_AUTH_TOKEN environment variable is not set";
+  }
+  try {
+    const res = await fetch(`${registry}/-/whoami`, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) {
+      return `npm token invalid or expired (HTTP ${res.status} from ${registry})`;
+    }
+    return null;
+  } catch (e) {
+    return `npm registry unreachable: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
 function buildReport(stage, plan, repoRoot, dryRun, startTime, result) {
   return {
     schemaVersion: "1.0",