@kb-labs/release-manager-cli 2.100.0 → 2.101.0

package/dist/cli/commands/promote.js

@@ -0,0 +1,709 @@
+import { defineCommand, useEnv, findRepoRoot, useConfig, useLoader, useLogger } from '@kb-labs/sdk';
+import { resolvePublishTag, resolvePublishRegistry, discoverCurrentPackages } from '@kb-labs/release-manager-core';
+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/promote.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(pkg, versionMap, packageManager) {
+  const pkgPath = pkg.path;
+  const pkgJsonPath = join(pkgPath, "package.json");
+  const original = readFileSync(pkgJsonPath, "utf-8");
+  const pkgJson = JSON.parse(original);
+  let modified = false;
+  if (pkgJson.version !== pkg.version) {
+    pkgJson.version = pkg.version;
+    modified = true;
+  }
+  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 buildIntraDeps(packages, nameSet) {
+  const deps = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const intra = /* @__PURE__ */ new Set();
+    try {
+      const pkgJson = JSON.parse(readFileSync(join(pkg.path, "package.json"), "utf-8"));
+      for (const section of ["dependencies", "peerDependencies"]) {
+        for (const depName of Object.keys(pkgJson[section] ?? {})) {
+          if (nameSet.has(depName)) {
+            intra.add(depName);
+          }
+        }
+      }
+    } catch {
+    }
+    deps.set(pkg.name, intra);
+  }
+  return deps;
+}
+function buildDependantsMap(packages, deps) {
+  const dependants = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    for (const dep of deps.get(pkg.name) ?? []) {
+      if (!dependants.has(dep)) {
+        dependants.set(dep, /* @__PURE__ */ new Set());
+      }
+      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 waves = [];
+  while (remaining.size > 0) {
+    const wave = [...remaining.entries()].filter(([, count]) => count === 0).map(([name]) => byName.get(name));
+    if (wave.length === 0) {
+      waves.push([...remaining.keys()].map((n) => byName.get(n)));
+      break;
+    }
+    waves.push(wave);
+    for (const pkg of wave) {
+      remaining.delete(pkg.name);
+      for (const dependant of dependants.get(pkg.name) ?? []) {
+        if (remaining.has(dependant)) {
+          remaining.set(dependant, (remaining.get(dependant) ?? 1) - 1);
+        }
+      }
+    }
+  }
+  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;
+var RETRY_BASE_DELAYS_MS = [1e4, 2e4, 4e4, 8e4, 16e4];
+var RETRYABLE_PATTERNS = [
+  "E429",
+  "429 Too Many Requests",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "socket hang up",
+  "network timeout",
+  "read ECONNRESET"
+];
+var ALREADY_PUBLISHED_PATTERNS = [
+  "You cannot publish over the previously published versions",
+  "cannot publish over the previously published version",
+  "EPUBLISHCONFLICT"
+  // Some registries return 403 for conflicts
+];
+function isRetryable(message) {
+  return RETRYABLE_PATTERNS.some((p) => message.includes(p));
+}
+function isAlreadyPublished(message) {
+  return ALREADY_PUBLISHED_PATTERNS.some((p) => message.includes(p));
+}
+function retryDelay(attempt) {
+  const base = RETRY_BASE_DELAYS_MS[Math.min(attempt, RETRY_BASE_DELAYS_MS.length - 1)];
+  const jitter = 0.8 + Math.random() * 0.4;
+  return Math.round(base * jitter);
+}
+function resolveToken(token) {
+  return token ?? useEnv("NPM_TOKEN") ?? useEnv("NODE_AUTH_TOKEN");
+}
+function spawnPublish(options) {
+  const { packagePath, packageManager, token, otp, dryRun, tag, access, registry } = options;
+  return new Promise((resolve, reject) => {
+    const args = ["publish"];
+    if (packageManager === "pnpm") {
+      args.push("--no-git-checks");
+    }
+    if (dryRun) {
+      args.push("--dry-run");
+    }
+    if (tag) {
+      args.push(`--tag=${tag}`);
+    }
+    if (access) {
+      args.push(`--access=${access}`);
+    }
+    if (registry) {
+      args.push(`--registry=${registry}`);
+    }
+    if (otp) {
+      args.push(`--otp=${otp}`);
+    }
+    const env = { ...process.env };
+    if (token) {
+      env["NODE_AUTH_TOKEN"] = token;
+    }
+    const npmrcPath = join(packagePath, ".npmrc");
+    const npmrcExisted = existsSync(npmrcPath);
+    const npmrcBackup = npmrcExisted ? readFileSync(npmrcPath, "utf-8") : null;
+    const registryHost = registry ? new URL(registry).host : "registry.npmjs.org";
+    const authLine = `//${registryHost}/:_authToken=\${NODE_AUTH_TOKEN}
+`;
+    if (token) {
+      const existing = npmrcExisted ? readFileSync(npmrcPath, "utf-8") : "";
+      if (!existing.includes("_authToken")) {
+        writeFileSync(npmrcPath, existing + authLine);
+      }
+    }
+    const restoreNpmrc = () => {
+      if (!token) {
+        return;
+      }
+      try {
+        if (npmrcBackup !== null) {
+          writeFileSync(npmrcPath, npmrcBackup);
+        } else if (existsSync(npmrcPath)) {
+          unlinkSync(npmrcPath);
+        }
+      } catch {
+      }
+    };
+    const child = spawn(packageManager, args, {
+      cwd: packagePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true,
+      env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      restoreNpmrc();
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(stderr || stdout || `${packageManager} publish exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      restoreNpmrc();
+      reject(err);
+    });
+  });
+}
+async function publishOne(pkg, opts, logger) {
+  const restore = rewriteWorkspaceDeps(pkg, opts.versionMap, opts.packageManager);
+  try {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await spawnPublish({
+          packagePath: pkg.path,
+          packageManager: opts.packageManager,
+          token: opts.token,
+          otp: opts.otp,
+          dryRun: opts.dryRun,
+          tag: opts.tag,
+          access: opts.access,
+          registry: opts.registry
+        });
+        logger.info(`Published ${pkg.name}@${pkg.version}`);
+        return { name: pkg.name, version: pkg.version, success: true };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (isAlreadyPublished(message)) {
+          logger.info(`${pkg.name}@${pkg.version} already published \u2014 skipping`);
+          return { name: pkg.name, version: pkg.version, success: true, alreadyPublished: true };
+        }
+        if (isRetryable(message) && attempt < MAX_RETRIES) {
+          const delay = retryDelay(attempt);
+          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);
+          });
+          continue;
+        }
+        logger.error(`Failed to publish ${pkg.name}@${pkg.version}`, void 0, { error: message });
+        return { name: pkg.name, version: pkg.version, success: false, error: message };
+      }
+    }
+    return {
+      name: pkg.name,
+      version: pkg.version,
+      success: false,
+      error: `Publish failed after ${MAX_RETRIES} retries (transient errors)`
+    };
+  } finally {
+    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,
+    packageManager = "pnpm",
+    dryRun,
+    otp,
+    tag,
+    access,
+    registry
+  } = options;
+  const logger = useLogger();
+  const token = resolveToken(options.token);
+  if (!token && !dryRun) {
+    const error = "No npm token found. Set NPM_TOKEN (or NODE_AUTH_TOKEN) in environment.";
+    logger.error(error);
+    return {
+      results: [],
+      published: [],
+      alreadyPublished: [],
+      failed: packages.map((p) => `${p.name}@${p.version}`),
+      skipped: [],
+      errors: [error]
+    };
+  }
+  const versionMap = new Map(packages.map((p) => [p.name, p.version]));
+  const CONCURRENCY = Number(useEnv("KB_PUBLISH_CONCURRENCY") ?? 4);
+  const waves = topoSort(packages);
+  logger.info(
+    `Publishing ${packages.length} package(s) in ${waves.length} topological wave(s) (concurrency=${CONCURRENCY}, dryRun=${dryRun ?? false})`
+  );
+  const allResults = [];
+  for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
+    const wave = waves[waveIdx];
+    logger.info(`Wave ${waveIdx + 1}/${waves.length}: publishing ${wave.length} package(s)`);
+    for (let i = 0; i < wave.length; i += CONCURRENCY) {
+      const batch = wave.slice(i, i + CONCURRENCY);
+      const batchResults = await Promise.all(
+        batch.map(
+          (pkg) => publishOne(pkg, { packageManager, token, versionMap, dryRun, otp, tag, access, registry }, logger)
+        )
+      );
+      allResults.push(...batchResults);
+    }
+    const waveFailed = allResults.slice(-wave.length).filter((r) => !r.success);
+    if (waveFailed.length > 0) {
+      skipRemainingWaves(waves, waveIdx, waveFailed, logger, allResults);
+      break;
+    }
+  }
+  const published = allResults.filter((r) => r.success && !r.alreadyPublished).map((r) => `${r.name}@${r.version}`);
+  const alreadyPublished = allResults.filter((r) => r.alreadyPublished).map((r) => `${r.name}@${r.version}`);
+  const failed = allResults.filter((r) => !r.success).map((r) => `${r.name}@${r.version}`);
+  const errors = allResults.filter((r) => !r.success && r.error).map((r) => `${r.name}: ${r.error}`);
+  if (alreadyPublished.length > 0) {
+    logger.info(`${alreadyPublished.length} package(s) already published \u2014 counted as success`);
+  }
+  return {
+    results: allResults,
+    published,
+    alreadyPublished,
+    failed,
+    skipped: dryRun ? packages.map((p) => `${p.name}@${p.version} (dry-run)`) : [],
+    errors
+  };
+}
+var MAX_RETRIES2 = 5;
+var RETRY_BASE_DELAYS_MS2 = [1e4, 2e4, 4e4, 8e4, 16e4];
+var RETRYABLE_PATTERNS2 = [
+  "E429",
+  "429 Too Many Requests",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "socket hang up",
+  "network timeout",
+  "read ECONNRESET"
+];
+var ALREADY_PUBLISHED_PATTERNS2 = [
+  "You cannot publish over the previously published versions",
+  "cannot publish over the previously published version",
+  "EPUBLISHCONFLICT"
+];
+function isRetryable2(msg) {
+  return RETRYABLE_PATTERNS2.some((p) => msg.includes(p));
+}
+function isAlreadyPublished2(msg) {
+  return ALREADY_PUBLISHED_PATTERNS2.some((p) => msg.includes(p));
+}
+function retryDelay2(attempt) {
+  const base = RETRY_BASE_DELAYS_MS2[Math.min(attempt, RETRY_BASE_DELAYS_MS2.length - 1)];
+  const jitter = 0.8 + Math.random() * 0.4;
+  return Math.round(base * jitter);
+}
+function publishSinglePackage(options) {
+  const { packagePath, packageManager = "pnpm", otp, dryRun, tag, access, registry } = options;
+  return new Promise((resolve, reject) => {
+    const args = ["publish"];
+    if (packageManager === "pnpm") {
+      args.push("--no-git-checks");
+    }
+    if (dryRun) {
+      args.push("--dry-run");
+    }
+    if (otp) {
+      args.push(`--otp=${otp}`);
+    }
+    if (tag) {
+      args.push(`--tag=${tag}`);
+    }
+    if (access) {
+      args.push(`--access=${access}`);
+    }
+    if (registry) {
+      args.push(`--registry=${registry}`);
+    }
+    const child = spawn(packageManager, args, {
+      cwd: packagePath,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(stderr || stdout || `${packageManager} publish exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => reject(err));
+  });
+}
+async function fastPublishPkg(pkg, ctx, logger) {
+  const restore = rewriteWorkspaceDeps(pkg, 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, registry: ctx.registry });
+        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, 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, registry: ctx.registry });
+        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" };
+          }
+        } 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 OTP attempts" };
+  } finally {
+    restore();
+  }
+}
+async function publishPackagesWithOTP(options) {
+  const { packages, packageManager = "pnpm", dryRun, tag, access, registry, 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, registry };
+  const seqCtx = { packageManager, versionMap, dryRun, tag, access, registry };
+  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 outcomes = await Promise.all(batch.map((pkg) => fastPublishPkg(pkg, fastCtx, logger)));
+    for (let j = 0; j < batch.length; j++) {
+      const outcome = outcomes[j];
+      if (outcome.result === null) {
+        remaining.push(batch[j]);
+      } else {
+        results.push(outcome.result);
+      }
+      if (outcome.otpFailed) {
+        otpFailureDetected = true;
+      }
+    }
+    if (otpFailureDetected) {
+      remaining.push(...packages.slice(i + CONCURRENCY));
+      break;
+    }
+  }
+  if (remaining.length === 0) {
+    return buildResult(results, packages, dryRun);
+  }
+  ui.write?.(`  OTP required \u2014 falling back to sequential publish for ${remaining.length} package(s)
+`);
+  for (const pkg of remaining) {
+    logger?.info("Publishing package (sequential)", { name: pkg.name, version: pkg.version });
+    results.push(await sequentialPublishPkg(pkg, seqCtx, otpState, ui));
+  }
+  return buildResult(results, packages, dryRun);
+}
+function buildResult(results, packages, dryRun) {
+  return {
+    results,
+    published: results.filter((r) => r.success && !r.alreadyPublished).map((r) => `${r.name}@${r.version}`),
+    alreadyPublished: results.filter((r) => r.alreadyPublished).map((r) => `${r.name}@${r.version}`),
+    failed: results.filter((r) => !r.success).map((r) => `${r.name}@${r.version}`),
+    skipped: dryRun ? packages.map((p) => `${p.name}@${p.version} (dry-run)`) : [],
+    errors: results.filter((r) => !r.success && r.error).map((r) => `${r.name}: ${r.error}`)
+  };
+}
+
+// src/cli/commands/promote.ts
+function buildPromoteSections(results, tag, registry, symbols) {
+  const sections = [];
+  sections.push({ header: "Promoting to", items: [`registry: ${registry}`, `tag: ${tag}`] });
+  const successful = results.filter((r) => r.success);
+  if (successful.length > 0) {
+    sections.push({
+      header: "Promoted",
+      items: successful.map((r) => `${symbols.success} ${r.name}@${r.version}`)
+    });
+  }
+  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 toPromoteResult(results, tag, registry) {
+  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, tag, registry }
+  };
+}
+var promote_default = defineCommand({
+  id: "release:promote",
+  description: "Promote already-released package versions to npm (no re-bump, no rebuild)",
+  handler: {
+    async execute(ctx, input) {
+      const { flags } = input;
+      const { scope, otp: initialOtp, access, json } = flags;
+      const dryRun = flags["dry-run"];
+      const token = flags.token ?? useEnv("NPM_TOKEN") ?? useEnv("NODE_AUTH_TOKEN");
+      const cwd = ctx.cwd || process.cwd();
+      const repoRoot = await findRepoRoot(cwd);
+      const fileConfig = await useConfig();
+      const config = fileConfig ?? {};
+      const tag = flags.tag ?? resolvePublishTag(config, "stable");
+      const registry = flags.registry ?? resolvePublishRegistry(config, "stable");
+      const discoveryLoader = useLoader("Discovering already-released packages...");
+      discoveryLoader.start();
+      const discovered = await discoverCurrentPackages(repoRoot, scope, config);
+      const packages = discovered.map((pkg) => ({
+        name: pkg.name,
+        version: pkg.currentVersion,
+        path: pkg.path
+      }));
+      discoveryLoader.succeed(`Found ${packages.length} package(s) to promote`);
+      if (packages.length === 0) {
+        const msg = `No packages found to promote${scope ? ` matching scope: ${scope}` : ""}`;
+        if (json) {
+          ctx.ui?.json?.({ error: msg });
+        } else {
+          ctx.ui?.write?.(msg);
+        }
+        return { exitCode: 1, summary: { total: 0, successful: 0, failed: 0, tag, registry } };
+      }
+      let rawResult;
+      if (token) {
+        rawResult = await publishPackagesProgrammatic({
+          packages,
+          dryRun,
+          otp: initialOtp,
+          tag,
+          registry,
+          access: access ?? config.publish?.access,
+          token
+        });
+      } else {
+        rawResult = await publishPackagesWithOTP({
+          packages,
+          dryRun,
+          otp: initialOtp,
+          tag,
+          registry,
+          access: access ?? config.publish?.access ?? "public",
+          ui: ctx.ui,
+          logger: ctx.platform?.logger
+        });
+      }
+      const promoteResult = toPromoteResult(rawResult.results, tag, registry);
+      console.log("::kb-output::" + JSON.stringify({
+        promoted: promoteResult.published?.map((p) => `${p.name}@${p.version}`) ?? [],
+        failed: promoteResult.failed?.map((p) => p.name) ?? [],
+        tag,
+        registry
+      }));
+      if (json) {
+        ctx.ui?.json?.(promoteResult);
+        return promoteResult;
+      }
+      ctx.ui?.sideBox?.({
+        title: dryRun ? "Promote Dry-Run" : "Promote Summary",
+        sections: buildPromoteSections(rawResult.results, tag, registry, ctx.ui.symbols),
+        status: promoteResult.exitCode === 0 ? "success" : "error"
+      });
+      return promoteResult;
+    }
+  }
+});
+
+export { promote_default as default };
+//# sourceMappingURL=promote.js.map
+//# sourceMappingURL=promote.js.map