@kb-labs/release-manager-cli 2.82.0 → 2.87.0

package/dist/cli/commands/publish.js

@@ -1,13 +1,49 @@
 import { defineCommand, useEnv, findRepoRoot, useLoader, useConfig, useLogger } from '@kb-labs/sdk';
 import { planRelease } from '@kb-labs/release-manager-core';
-import { join } from 'path';
-import 'fs/promises';
-import 'globby';
 import { spawn } from 'child_process';
 import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
 import * as readline from 'readline/promises';
 
 // src/cli/commands/publish.ts
+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");
@@ -18,32 +54,8 @@ function rewriteWorkspaceDeps(pkgPath, versionMap, packageManager) {
     if (!deps) {
       continue;
     }
-    for (const depName of Object.keys(deps)) {
-      const val = deps[depName];
-      if (typeof val !== "string") {
-        continue;
-      }
-      if (val.startsWith("link:")) {
-        const pinned = versionMap.get(depName);
-        if (pinned) {
-          deps[depName] = `^${pinned}`;
-        } else {
-          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] = "*";
-          }
-        }
-        modified = true;
-      } else if (val.startsWith("workspace:") && packageManager !== "pnpm") {
-        const pinned = versionMap.get(depName);
-        if (pinned) {
-          deps[depName] = val === "workspace:*" ? `^${pinned}` : val.replace("workspace:", "");
-          modified = true;
-        }
-      }
+    if (rewriteDepsSection(deps, pkgPath, versionMap, packageManager)) {
+      modified = true;
     }
   }
   if (modified) {
@@ -51,8 +63,7 @@ function rewriteWorkspaceDeps(pkgPath, versionMap, packageManager) {
   }
   return () => writeFileSync(pkgJsonPath, original);
 }
-function topoSort(packages, packageManager) {
-  const nameSet = new Set(packages.map((p) => p.name));
+function buildIntraDeps(packages, nameSet) {
   const deps = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
     const intra = /* @__PURE__ */ new Set();
@@ -69,12 +80,9 @@ function topoSort(packages, packageManager) {
     }
     deps.set(pkg.name, intra);
   }
-  const inDegree = new Map(packages.map((p) => [p.name, 0]));
-  for (const [, d] of deps) {
-    for (const dep of d) {
-      inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
-    }
-  }
+  return deps;
+}
+function buildDependantsMap(packages, deps) {
   const dependants = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
     for (const dep of deps.get(pkg.name) ?? []) {
@@ -84,10 +92,13 @@ function topoSort(packages, packageManager) {
       dependants.get(dep).add(pkg.name);
     }
   }
+  return dependants;
+}
+function computeWaves(packages, deps, dependants) {
+  const byName = new Map(packages.map((p) => [p.name, p]));
   const remaining = new Map(
     packages.map((p) => [p.name, (deps.get(p.name) ?? /* @__PURE__ */ new Set()).size])
   );
-  const byName = new Map(packages.map((p) => [p.name, p]));
   const waves = [];
   while (remaining.size > 0) {
     const wave = [...remaining.entries()].filter(([, count]) => count === 0).map(([name]) => byName.get(name));
@@ -107,6 +118,12 @@ function topoSort(packages, packageManager) {
   }
   return waves.filter((w) => w.length > 0);
 }
+function topoSort(packages, _packageManager) {
+  const nameSet = new Set(packages.map((p) => p.name));
+  const deps = buildIntraDeps(packages, nameSet);
+  const dependants = buildDependantsMap(packages, deps);
+  return computeWaves(packages, deps, dependants);
+}
 
 // src/shared/publish-programmatic.ts
 var MAX_RETRIES = 5;
@@ -248,7 +265,9 @@ async function publishOne(pkg, opts, logger) {
           logger.warn(
             `Transient error for ${pkg.name}@${pkg.version} (attempt ${attempt + 1}/${MAX_RETRIES}), retrying in ${(delay / 1e3).toFixed(1)}s: ${message.split("\n")[0]}`
           );
-          await new Promise((r) => setTimeout(r, delay));
+          await new Promise((r) => {
+            setTimeout(r, delay);
+          });
           continue;
         }
         logger.error(`Failed to publish ${pkg.name}@${pkg.version}`, void 0, { error: message });
@@ -265,6 +284,20 @@ async function publishOne(pkg, opts, logger) {
     restore();
   }
 }
+function skipRemainingWaves(waves, waveIdx, waveFailed, logger, allResults) {
+  const remaining = waves.slice(waveIdx + 1).reduce((acc, w) => acc + w.length, 0);
+  if (remaining === 0) {
+    return;
+  }
+  logger.warn(
+    `Wave ${waveIdx + 1} had ${waveFailed.length} failure(s) \u2014 skipping ${remaining} package(s) in later waves to avoid broken dependency chain`
+  );
+  for (const laterWave of waves.slice(waveIdx + 1)) {
+    for (const pkg of laterWave) {
+      allResults.push({ name: pkg.name, version: pkg.version, success: false, error: "Skipped: dependency wave failed" });
+    }
+  }
+}
 async function publishPackagesProgrammatic(options) {
   const {
     packages,
@@ -310,22 +343,7 @@ async function publishPackagesProgrammatic(options) {
     }
     const waveFailed = allResults.slice(-wave.length).filter((r) => !r.success);
     if (waveFailed.length > 0) {
-      const remaining = waves.slice(waveIdx + 1).reduce((acc, w) => acc + w.length, 0);
-      if (remaining > 0) {
-        logger.warn(
-          `Wave ${waveIdx + 1} had ${waveFailed.length} failure(s) \u2014 skipping ${remaining} package(s) in later waves to avoid broken dependency chain`
-        );
-        for (const laterWave of waves.slice(waveIdx + 1)) {
-          for (const pkg of laterWave) {
-            allResults.push({
-              name: pkg.name,
-              version: pkg.version,
-              success: false,
-              error: "Skipped: dependency wave failed"
-            });
-          }
-        }
-      }
+      skipRemainingWaves(waves, waveIdx, waveFailed, logger, allResults);
       break;
     }
   }
@@ -417,65 +435,125 @@ function publishSinglePackage(options) {
     child.on("error", (err) => reject(err));
   });
 }
-async function publishPackagesWithOTP(options) {
-  const { packages, packageManager = "pnpm", dryRun, tag, access, ui, logger } = options;
-  let otp = options.otp;
-  const results = [];
-  const versionMap = new Map(packages.map((p) => [p.name, p.version]));
-  const CONCURRENCY = Number(useEnv("KB_PUBLISH_CONCURRENCY") ?? 4);
-  const remaining = [];
-  let otpFailureDetected = false;
-  const fastPublishOne = async (pkg) => {
-    const restore = rewriteWorkspaceDeps(pkg.path, versionMap, packageManager);
-    try {
-      for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
-        try {
-          await publishSinglePackage({ packagePath: pkg.path, packageManager, otp, dryRun, tag, access });
-          logger?.info("Published (fast-path)", { name: pkg.name, version: pkg.version });
-          return { name: pkg.name, version: pkg.version, success: true };
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          if (isAlreadyPublished2(msg)) {
-            logger?.info(`${pkg.name}@${pkg.version} already published \u2014 skipping`);
-            return { name: pkg.name, version: pkg.version, success: true, alreadyPublished: true };
-          }
-          if (msg.includes("EOTP") || msg.includes("one-time password")) {
-            otpFailureDetected = true;
-            return null;
-          }
-          if (isRetryable2(msg) && attempt < MAX_RETRIES2) {
-            const delay = retryDelay2(attempt);
-            logger?.warn(
-              `Transient error for ${pkg.name} (attempt ${attempt + 1}/${MAX_RETRIES2}), retrying in ${(delay / 1e3).toFixed(1)}s`
-            );
-            await new Promise((r) => setTimeout(r, delay));
-            continue;
+async function fastPublishPkg(pkg, ctx, logger) {
+  const restore = rewriteWorkspaceDeps(pkg.path, ctx.versionMap, ctx.packageManager);
+  try {
+    for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
+      try {
+        await publishSinglePackage({ packagePath: pkg.path, packageManager: ctx.packageManager, otp: ctx.otp, dryRun: ctx.dryRun, tag: ctx.tag, access: ctx.access });
+        logger?.info("Published (fast-path)", { name: pkg.name, version: pkg.version });
+        return { result: { name: pkg.name, version: pkg.version, success: true }, otpFailed: false };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (isAlreadyPublished2(msg)) {
+          logger?.info(`${pkg.name}@${pkg.version} already published \u2014 skipping`);
+          return { result: { name: pkg.name, version: pkg.version, success: true, alreadyPublished: true }, otpFailed: false };
+        }
+        if (msg.includes("EOTP") || msg.includes("one-time password")) {
+          return { result: null, otpFailed: true };
+        }
+        if (isRetryable2(msg) && attempt < MAX_RETRIES2) {
+          const delay = retryDelay2(attempt);
+          logger?.warn(`Transient error for ${pkg.name} (attempt ${attempt + 1}/${MAX_RETRIES2}), retrying in ${(delay / 1e3).toFixed(1)}s`);
+          await new Promise((r) => {
+            setTimeout(r, delay);
+          });
+          continue;
+        }
+        logger?.error("Publish failed (fast-path)", void 0, { name: pkg.name, error: msg });
+        return { result: { name: pkg.name, version: pkg.version, success: false, error: msg }, otpFailed: false };
+      }
+    }
+    return { result: { name: pkg.name, version: pkg.version, success: false, error: `Publish failed after ${MAX_RETRIES2} retries (transient errors)` }, otpFailed: false };
+  } finally {
+    restore();
+  }
+}
+async function promptForOtp(ui, loader, pkgName) {
+  loader.succeed(`\u{1F510} 2FA required for ${pkgName}`);
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const entered = await rl.question("   Enter OTP code: ");
+    rl.close();
+    if (!entered || entered.trim().length !== 6) {
+      ui.write?.("   \u26A0\uFE0F  Invalid OTP (must be 6 digits)\n");
+      return void 0;
+    }
+    return entered.trim();
+  } catch (e) {
+    rl.close();
+    throw e;
+  }
+}
+async function sequentialPublishPkg(pkg, ctx, otpState, ui, logger) {
+  const loader = useLoader(`Publishing ${pkg.name}@${pkg.version}...`);
+  loader.start();
+  const restore = rewriteWorkspaceDeps(pkg.path, ctx.versionMap, ctx.packageManager);
+  try {
+    const MAX_OTP_ATTEMPTS = 3;
+    for (let otpAttempts = 0; otpAttempts < MAX_OTP_ATTEMPTS; otpAttempts++) {
+      try {
+        await publishSinglePackage({ packagePath: pkg.path, packageManager: ctx.packageManager, otp: otpState.otp, dryRun: ctx.dryRun, tag: ctx.tag, access: ctx.access });
+        loader.succeed(ctx.dryRun ? `Dry-run: ${pkg.name}@${pkg.version}` : `Published ${pkg.name}@${pkg.version}`);
+        return { name: pkg.name, version: pkg.version, success: true };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (isAlreadyPublished2(msg)) {
+          loader.succeed(`${pkg.name}@${pkg.version} already published`);
+          return { name: pkg.name, version: pkg.version, success: true, alreadyPublished: true };
+        }
+        if (msg.includes("EOTP") || msg.includes("one-time password")) {
+          if (otpAttempts + 1 < MAX_OTP_ATTEMPTS) {
+            otpState.otp = await promptForOtp(ui, loader, pkg.name);
+            loader.update({ text: `Publishing ${pkg.name}@${pkg.version} with OTP...` });
+            loader.start();
+          } else {
+            loader.fail("Max OTP attempts reached");
+            return { name: pkg.name, version: pkg.version, success: false, error: "Max OTP attempts reached" };
           }
-          logger?.error("Publish failed (fast-path)", { name: pkg.name, error: msg });
+        } else if (isRetryable2(msg)) {
+          const delay = retryDelay2(MAX_RETRIES2 - 1);
+          loader.update({ text: `Rate limited \u2014 waiting ${(delay / 1e3).toFixed(0)}s\u2026` });
+          loader.start();
+          await new Promise((r) => {
+            setTimeout(r, delay);
+          });
+          otpAttempts--;
+        } else {
+          loader.fail(`Failed: ${msg.split("\n")[0]}`);
           return { name: pkg.name, version: pkg.version, success: false, error: msg };
         }
       }
-      return {
-        name: pkg.name,
-        version: pkg.version,
-        success: false,
-        error: `Publish failed after ${MAX_RETRIES2} retries (transient errors)`
-      };
-    } finally {
-      restore();
     }
-  };
+    return { name: pkg.name, version: pkg.version, success: false, error: "Publish failed after max OTP attempts" };
+  } finally {
+    restore();
+  }
+}
+async function publishPackagesWithOTP(options) {
+  const { packages, packageManager = "pnpm", dryRun, tag, access, ui, logger } = options;
+  const otpState = { otp: options.otp };
+  const versionMap = new Map(packages.map((p) => [p.name, p.version]));
+  const fastCtx = { packageManager, versionMap, otp: otpState.otp, dryRun, tag, access };
+  const seqCtx = { packageManager, versionMap, dryRun, tag, access };
+  const results = [];
+  const remaining = [];
+  const CONCURRENCY = Number(useEnv("KB_PUBLISH_CONCURRENCY") ?? 4);
+  let otpFailureDetected = false;
   ui.write?.(`  Publishing ${packages.length} package(s) in parallel (concurrency=${CONCURRENCY})...
 `);
   for (let i = 0; i < packages.length; i += CONCURRENCY) {
     const batch = packages.slice(i, i + CONCURRENCY);
-    const batchResults = await Promise.all(batch.map(fastPublishOne));
+    const outcomes = await Promise.all(batch.map((pkg) => fastPublishPkg(pkg, fastCtx, logger)));
     for (let j = 0; j < batch.length; j++) {
-      const res = batchResults[j];
-      if (res === null || res === void 0) {
+      const outcome = outcomes[j];
+      if (outcome.result === null) {
         remaining.push(batch[j]);
       } else {
-        results.push(res);
+        results.push(outcome.result);
+      }
+      if (outcome.otpFailed) {
+        otpFailureDetected = true;
       }
     }
     if (otpFailureDetected) {
@@ -490,68 +568,7 @@ async function publishPackagesWithOTP(options) {
 `);
   for (const pkg of remaining) {
     logger?.info("Publishing package (sequential)", { name: pkg.name, version: pkg.version });
-    const loader = useLoader(`Publishing ${pkg.name}@${pkg.version}...`);
-    loader.start();
-    const restore = rewriteWorkspaceDeps(pkg.path, versionMap, packageManager);
-    try {
-      let published = false;
-      let otpAttempts = 0;
-      const MAX_OTP_ATTEMPTS = 3;
-      while (!published && otpAttempts < MAX_OTP_ATTEMPTS) {
-        otpAttempts++;
-        try {
-          await publishSinglePackage({ packagePath: pkg.path, packageManager, otp, dryRun, tag, access });
-          published = true;
-          results.push({ name: pkg.name, version: pkg.version, success: true });
-          loader.succeed(dryRun ? `Dry-run: ${pkg.name}@${pkg.version}` : `Published ${pkg.name}@${pkg.version}`);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          if (isAlreadyPublished2(msg)) {
-            published = true;
-            results.push({ name: pkg.name, version: pkg.version, success: true, alreadyPublished: true });
-            loader.succeed(`${pkg.name}@${pkg.version} already published`);
-            break;
-          }
-          if (msg.includes("EOTP") || msg.includes("one-time password")) {
-            if (otpAttempts < MAX_OTP_ATTEMPTS) {
-              loader.succeed(`\u{1F510} 2FA required for ${pkg.name}`);
-              const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-              try {
-                const entered = await rl.question("   Enter OTP code: ");
-                rl.close();
-                if (!entered || entered.trim().length !== 6) {
-                  ui.write?.("   \u26A0\uFE0F  Invalid OTP (must be 6 digits)\n");
-                  otp = void 0;
-                } else {
-                  otp = entered.trim();
-                }
-              } catch (e) {
-                rl.close();
-                throw e;
-              }
-              loader.update({ text: `Publishing ${pkg.name}@${pkg.version} with OTP...` });
-              loader.start();
-            } else {
-              loader.fail("Max OTP attempts reached");
-              results.push({ name: pkg.name, version: pkg.version, success: false, error: "Max OTP attempts reached" });
-              break;
-            }
-          } else if (isRetryable2(msg)) {
-            const delay = retryDelay2(MAX_RETRIES2 - 1);
-            loader.update({ text: `Rate limited \u2014 waiting ${(delay / 1e3).toFixed(0)}s\u2026` });
-            loader.start();
-            await new Promise((r) => setTimeout(r, delay));
-            otpAttempts--;
-          } else {
-            loader.fail(`Failed: ${msg.split("\n")[0]}`);
-            results.push({ name: pkg.name, version: pkg.version, success: false, error: msg });
-            break;
-          }
-        }
-      }
-    } finally {
-      restore();
-    }
+    results.push(await sequentialPublishPkg(pkg, seqCtx, otpState, ui));
   }
   return buildResult(results, packages, dryRun);
 }
@@ -567,6 +584,40 @@ function buildResult(results, packages, dryRun) {
 }
 
 // src/cli/commands/publish.ts
+function buildPublishSections(results, symbols) {
+  const sections = [];
+  const successful = results.filter((r) => r.success);
+  if (successful.length > 0) {
+    const items = [];
+    for (const r of successful) {
+      items.push(`${symbols.success} ${r.name}@${r.version}`);
+      items.push(`  \u2514\u2500 https://www.npmjs.com/package/${r.name}`);
+    }
+    sections.push({ header: "Published", items });
+  }
+  const failed = results.filter((r) => !r.success);
+  if (failed.length > 0) {
+    sections.push({
+      header: "Failed",
+      items: failed.map((r) => `${symbols.error} ${r.name}@${r.version} - ${r.error}`)
+    });
+  }
+  return sections;
+}
+function toPublishResult(results) {
+  const successful = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  return {
+    exitCode: failed === 0 ? 0 : 1,
+    published: results.filter((r) => r.success).map((r) => ({ name: r.name, version: r.version })),
+    failed: results.filter((r) => !r.success).map((r) => ({
+      name: r.name,
+      version: r.version,
+      error: r.error || "Unknown error"
+    })),
+    summary: { total: results.length, successful, failed }
+  };
+}
 var publish_default = defineCommand({
   id: "release:publish",
   description: "Publish packages to npm registry",
@@ -598,9 +649,9 @@ var publish_default = defineCommand({
         }
         return { exitCode: 1, summary: { total: 0, successful: 0, failed: 0 } };
       }
-      let result;
+      let rawResult;
       if (token) {
-        result = await publishPackagesProgrammatic({
+        rawResult = await publishPackagesProgrammatic({
           packages,
           dryRun,
           otp: initialOtp,
@@ -609,7 +660,7 @@ var publish_default = defineCommand({
           token
         });
       } else {
-        result = await publishPackagesWithOTP({
+        rawResult = await publishPackagesWithOTP({
           packages,
           dryRun,
           otp: initialOtp,
@@ -619,39 +670,19 @@ var publish_default = defineCommand({
           logger: ctx.platform?.logger
         });
       }
-      const successful = result.results.filter((r) => r.success).length;
-      const failed = result.results.filter((r) => !r.success).length;
-      const publishResult = {
-        exitCode: failed === 0 ? 0 : 1,
-        published: result.results.filter((r) => r.success).map((r) => ({ name: r.name, version: r.version })),
-        failed: result.results.filter((r) => !r.success).map((r) => ({
-          name: r.name,
-          version: r.version,
-          error: r.error || "Unknown error"
-        })),
-        summary: { total: result.results.length, successful, failed }
-      };
+      const publishResult = toPublishResult(rawResult.results);
+      console.log("::kb-output::" + JSON.stringify({
+        published: publishResult.published?.map((p) => `${p.name}@${p.version}`) ?? [],
+        failed: publishResult.failed?.map((p) => p.name) ?? []
+      }));
       if (json) {
         ctx.ui?.json?.(publishResult);
         return publishResult;
       }
-      const sections = [];
-      if (successful > 0) {
-        const successItems = [];
-        for (const r of result.results.filter((r2) => r2.success)) {
-          successItems.push(`${ctx.ui.symbols.success} ${r.name}@${r.version}`);
-          successItems.push(`  \u2514\u2500 https://www.npmjs.com/package/${r.name}`);
-        }
-        sections.push({ header: "Published", items: successItems });
-      }
-      if (failed > 0) {
-        const failItems = result.results.filter((r) => !r.success).map((r) => `${ctx.ui.symbols.error} ${r.name}@${r.version} - ${r.error}`);
-        sections.push({ header: "Failed", items: failItems });
-      }
       ctx.ui.sideBox({
         title: dryRun ? "Publish Dry-Run" : "Publish Summary",
-        sections,
-        status: failed === 0 ? "success" : "error"
+        sections: buildPublishSections(rawResult.results, ctx.ui.symbols),
+        status: publishResult.exitCode === 0 ? "success" : "error"
       });
       return publishResult;
     }