@reliverse/publish 2.2.7

package/dist/mod.d.ts

@@ -0,0 +1,76 @@
+import { type BumpType } from "@reliverse/bump";
+import type { BaseConfig } from "@reliverse/config/impl/core";
+import { type PackageKind, type RegistryType } from "@reliverse/config/impl/publish";
+export interface PackagePublishConfig {
+    enable?: boolean;
+    dryRun?: boolean;
+    tag?: string;
+    access?: "public" | "restricted";
+    otp?: string;
+    authType?: "web" | "legacy";
+    concurrency?: number;
+    verbose?: boolean;
+    bump?: "major" | "minor" | "patch" | "premajor" | "preminor" | "prepatch" | "prerelease";
+    bumpDisable?: boolean;
+    registry?: RegistryType;
+    kind?: PackageKind;
+}
+export interface PublishConfig extends BaseConfig {
+    global?: PackagePublishConfig;
+    packages?: Record<string, PackagePublishConfig>;
+    patterns?: Array<{
+        pattern: string;
+        config: PackagePublishConfig;
+    }>;
+}
+export interface DlerConfig {
+    publish?: PublishConfig;
+}
+export interface PublishOptions {
+    dryRun?: boolean;
+    tag?: string;
+    access?: "public" | "restricted";
+    otp?: string;
+    authType?: "web" | "legacy";
+    verbose?: boolean;
+    bump?: BumpType;
+    bumpDisable?: boolean;
+    concurrency?: number;
+    registry?: RegistryType;
+    kind?: PackageKind;
+    withNpmLogs?: boolean;
+    gzipLevel?: string;
+    ca?: string;
+    cafile?: string;
+    ignoreScripts?: boolean;
+    silent?: boolean;
+    noProgress?: boolean;
+    noSummary?: boolean;
+    bunRegistry?: string;
+    skipTip2FA?: boolean;
+    filter?: string | string[];
+}
+export type { PackageKind, RegistryType, } from "@reliverse/config/impl/publish";
+export interface PublishResult {
+    success: boolean;
+    packageName: string;
+    packagePath: string;
+    version?: string;
+    error?: string;
+    warning?: string;
+}
+export interface PublishAllResult {
+    results: PublishResult[];
+    hasErrors: boolean;
+    successCount: number;
+    errorCount: number;
+    warningCount: number;
+}
+/**
+ * Publish a single package
+ */
+export declare function publishPackage(packagePath: string, options?: PublishOptions, bumpedVersions?: Map<string, string>): Promise<PublishResult>;
+/**
+ * Publish all workspace packages
+ */
+export declare function publishAllPackages(cwd?: string, ignore?: string | string[], options?: PublishOptions): Promise<PublishAllResult>;

package/dist/mod.js

@@ -0,0 +1,1251 @@
+import { resolve } from "node:path";
+import { transformExportsForBuild } from "@reliverse/build";
+import { bumpVersion, getNextVersion } from "@reliverse/bump";
+import {
+  filterPackages,
+  findMonorepoRoot,
+  getWorkspacePackages,
+  loadDlerConfig
+} from "@reliverse/config/impl/discovery";
+import {
+  getPackagePublishConfig,
+  mergePublishOptions
+} from "@reliverse/config/impl/publish";
+import { re } from "@reliverse/relico";
+import { logger } from "@reliverse/relinka";
+import { readPackageJSON, writePackageJSON } from "@reliverse/typerso";
+const THROW_2FA_ERROR = false;
+let hasShown2FATip = false;
+async function runBunPublishCommand(packagePath, args, verbose, withNpmLogs) {
+  try {
+    if (verbose) {
+      logger.debug(`Spawning bun publish command: bun ${args.join(" ")}`);
+      logger.debug(`Working directory: ${packagePath}`);
+      if (withNpmLogs) {
+        logger.debug(
+          "With npm logs enabled - output will be displayed directly"
+        );
+      }
+    }
+    const proc = Bun.spawn(args, {
+      cwd: packagePath,
+      stdout: withNpmLogs ? "inherit" : "pipe",
+      stderr: withNpmLogs ? "inherit" : "pipe",
+      stdin: withNpmLogs ? "inherit" : "ignore",
+      // Allow input when showing logs, prevent hangs when hiding logs
+      env: process.env
+      // Explicitly pass environment variables
+    });
+    const timeout = 5 * 60 * 1e3;
+    let timeoutFired = false;
+    const timeoutId = setTimeout(() => {
+      timeoutFired = true;
+      proc.kill();
+    }, timeout);
+    if (verbose) {
+      logger.debug(`Set timeout of ${timeout / 1e3}s for publish command`);
+    }
+    let stdout = "";
+    let stderr = "";
+    if (withNpmLogs) {
+      const exitCode2 = await proc.exited;
+      clearTimeout(timeoutId);
+      if (verbose) {
+        logger.debug(`Command exited with code: ${exitCode2}`);
+      }
+      if (timeoutFired) {
+        if (verbose) {
+          logger.debug("Publish command timed out after 5 minutes");
+        }
+        return {
+          stdout: "",
+          stderr: "Error: Publishing timed out after 5 minutes. This may indicate an authentication issue or network problem.",
+          exitCode: 1
+        };
+      }
+      return { stdout, stderr, exitCode: exitCode2 };
+    }
+    [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    clearTimeout(timeoutId);
+    if (verbose) {
+      logger.debug(`Command exited with code: ${exitCode}`);
+      if (stdout) {
+        logger.debug(`Stdout length: ${stdout.length} bytes`);
+      }
+      if (stderr) {
+        logger.debug(`Stderr length: ${stderr.length} bytes`);
+      }
+    }
+    if (timeoutFired) {
+      if (verbose) {
+        logger.debug("Publish command timed out after 5 minutes");
+      }
+      return {
+        stdout,
+        stderr: `${stderr}
+
+Error: Publishing timed out after 5 minutes. This may indicate an authentication issue or network problem.`,
+        exitCode: 1
+      };
+    }
+    const combinedOutput = `${stdout}${stderr}`;
+    if (THROW_2FA_ERROR && combinedOutput.includes("This operation requires a one-time password.")) {
+      throw new Error(
+        "This operation requires a one-time password. You have 2FA enabled in your npm account. Please set NPM_CONFIG_TOKEN environment variable with your npm token."
+      );
+    }
+    if (combinedOutput.includes("failed to read OTP input") || combinedOutput.includes("use your security key for authentication")) {
+      const hasToken = !!(process.env.NPM_CONFIG_TOKEN || process.env.NPM_TOKEN);
+      if (hasToken) {
+        throw new Error(
+          "2FA authentication required. NPM_CONFIG_TOKEN is set but authentication failed. Please verify:\n  1. The token is valid and not expired\n  2. The token has publish permissions\n  3. Use --with-npm-logs flag to allow interactive OTP input if token authentication is not working"
+        );
+      }
+      throw new Error(
+        "2FA authentication required. The publish command cannot read OTP input when output is captured. Please either:\n  1. Set NPM_CONFIG_TOKEN environment variable with your npm token (note: .env files are not automatically loaded - export it in your shell or use a tool like dotenv-cli), or\n  2. Use --with-npm-logs flag to allow interactive OTP input."
+      );
+    }
+    return { stdout, stderr, exitCode };
+  } catch (error) {
+    if (verbose) {
+      logger.debug(
+        `Failed to spawn bun publish: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    throw new Error(
+      `Failed to spawn bun publish: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateKindRegistryCombination(kind, registry, verbose) {
+  if (verbose) {
+    logger.debug(
+      `Validating kind-registry combination: kind=${kind ?? "undefined"}, registry=${registry ?? "undefined"}`
+    );
+  }
+  if (!kind) {
+    if (verbose) {
+      logger.debug("No kind specified, allowing any registry");
+    }
+    return { valid: true };
+  }
+  if (!registry) {
+    if (verbose) {
+      logger.debug("No registry specified, allowing any kind");
+    }
+    return { valid: true };
+  }
+  const allowedCombinations = {
+    library: ["npm", "jsr", "npm-jsr", "none"],
+    "browser-app": ["vercel", "none"],
+    "native-app": ["none"],
+    cli: ["npm", "none"]
+  };
+  const allowedRegistries = allowedCombinations[kind];
+  if (verbose) {
+    logger.debug(
+      `Allowed registries for kind "${kind}": ${allowedRegistries.join(", ")}`
+    );
+  }
+  if (!allowedRegistries.includes(registry)) {
+    if (verbose) {
+      logger.debug(
+        `Validation failed: registry "${registry}" not allowed for kind "${kind}"`
+      );
+    }
+    return {
+      valid: false,
+      error: `Package kind "${kind}" is not compatible with registry "${registry}". Allowed registries for "${kind}": ${allowedRegistries.join(", ")}`
+    };
+  }
+  if (verbose) {
+    logger.debug("Kind-registry combination is valid");
+  }
+  return { valid: true };
+}
+async function validateDistFolder(packagePath, verbose) {
+  const distPath = resolve(packagePath, "dist");
+  if (verbose) {
+    logger.debug(`Checking dist folder at: ${distPath}`);
+  }
+  try {
+    const stat = await Bun.file(distPath).stat();
+    const isValid = stat.isDirectory();
+    if (verbose) {
+      logger.debug(
+        `Dist folder ${isValid ? "exists and is a directory" : "is not a directory"}`
+      );
+    }
+    return isValid;
+  } catch (error) {
+    if (verbose) {
+      logger.debug(
+        `Dist folder validation failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return false;
+  }
+}
+function validatePackageJsonFields(pkg, _packageName, kind, verbose) {
+  if (verbose) {
+    logger.debug(`Validating package.json fields for package: ${pkg.name}`);
+    logger.debug(`Package kind: ${kind ?? "undefined"}`);
+  }
+  const errors = [];
+  if (!pkg.name) {
+    errors.push("Missing required field: 'name'");
+  }
+  if (!pkg.version) {
+    errors.push("Missing required field: 'version'");
+  } else if (verbose) {
+    logger.debug(`Package version: ${pkg.version}`);
+  }
+  if (pkg.private === true) {
+    errors.push(
+      "Package has 'private: true' - cannot publish. Run 'dler build' to prepare the package."
+    );
+  }
+  if (!pkg.files || !Array.isArray(pkg.files) || pkg.files.length === 0) {
+    errors.push("Missing or empty 'files' field - Run 'dler build' to add it.");
+  } else {
+    if (verbose) {
+      logger.debug(`Files field: ${JSON.stringify(pkg.files)}`);
+    }
+    const hasDist = pkg.files.includes("dist") || pkg.files.includes("dist/*");
+    if (!hasDist) {
+      errors.push("'files' field must include 'dist' directory");
+    }
+  }
+  const hasBinField = pkg.bin && typeof pkg.bin === "object" && Object.keys(pkg.bin).length > 0;
+  if (verbose) {
+    logger.debug(`Has bin field: ${hasBinField}`);
+    logger.debug(`Has exports field: ${!!pkg.exports}`);
+  }
+  if (!pkg.exports && !hasBinField) {
+    errors.push("Missing 'exports' field - Run 'dler build' to add it.");
+  }
+  if (!pkg.publishConfig) {
+    errors.push("Missing 'publishConfig' field - Run 'dler build' to add it.");
+  } else if (!pkg.publishConfig.access) {
+    errors.push(
+      "Missing 'publishConfig.access' field - Run 'dler build' to add it."
+    );
+  } else if (verbose) {
+    logger.debug(`PublishConfig access: ${pkg.publishConfig.access}`);
+  }
+  if (kind === "cli") {
+    if (!pkg.bin) {
+      errors.push(
+        "CLI package missing 'bin' field - Run 'dler build' to add it."
+      );
+    } else if (typeof pkg.bin === "object") {
+      const binEntries = Object.keys(pkg.bin);
+      if (verbose) {
+        logger.debug(`CLI bin entries: ${binEntries.join(", ")}`);
+      }
+      if (binEntries.length === 0) {
+        errors.push("CLI package has empty 'bin' field");
+      } else {
+        for (const [binName, binPath] of Object.entries(pkg.bin)) {
+          if (typeof binPath === "string" && !binPath.startsWith("dist/")) {
+            errors.push(
+              `CLI bin entry '${binName}' should point to 'dist/' directory, found: '${binPath}'`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (verbose) {
+    logger.debug(
+      `Package validation ${errors.length === 0 ? "passed" : "failed"} with ${errors.length} error(s)`
+    );
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+async function restoreOriginalDependencies(packagePath, originalDependencies, originalDevDependencies, originalScripts, originalExports, verbose) {
+  if (verbose) {
+    logger.debug(`Restoring original package.json for: ${packagePath}`);
+  }
+  try {
+    const pkg = await readPackageJSON(packagePath);
+    if (pkg) {
+      if (originalDependencies !== void 0) {
+        if (verbose) {
+          logger.debug(
+            `Restoring ${Object.keys(originalDependencies).length} dependencies`
+          );
+        }
+        pkg.dependencies = originalDependencies;
+      }
+      if (originalDevDependencies !== void 0) {
+        if (verbose) {
+          logger.debug(
+            `Restoring ${Object.keys(originalDevDependencies).length} devDependencies`
+          );
+        }
+        pkg.devDependencies = originalDevDependencies;
+      }
+      if (originalScripts !== void 0) {
+        if (verbose) {
+          logger.debug(
+            `Restoring ${Object.keys(originalScripts).length} scripts`
+          );
+        }
+        pkg.scripts = originalScripts;
+      }
+      if (originalExports !== void 0) {
+        if (verbose) {
+          logger.debug("Restoring original exports field");
+        }
+        pkg.exports = originalExports;
+      }
+      await writePackageJSON(resolve(packagePath, "package.json"), pkg);
+      if (verbose) {
+        logger.debug("Successfully restored original package.json");
+      }
+    }
+  } catch (error) {
+    logger.warn(
+      `\u26A0\uFE0F  Failed to restore original dependencies: ${error instanceof Error ? error.message : String(error)}`
+    );
+    if (verbose) {
+      logger.debug(
+        `Restore error details: ${error instanceof Error ? error.stack : String(error)}`
+      );
+    }
+  }
+}
+async function resolveWorkspaceVersion(packagePath, depName, workspacePackages, bumpedVersions, verbose) {
+  try {
+    if (verbose) {
+      logger.debug(`Resolving workspace version for: ${depName}`);
+    }
+    if (bumpedVersions?.has(depName)) {
+      const version = bumpedVersions.get(depName) || null;
+      if (verbose) {
+        logger.debug(`Found ${depName} in bumped versions map: ${version}`);
+      }
+      return version;
+    }
+    if (!workspacePackages) {
+      if (verbose) {
+        logger.debug("Workspace packages not provided, discovering...");
+      }
+      const monorepoRoot = await findMonorepoRoot(packagePath);
+      if (!monorepoRoot) {
+        if (verbose) {
+          logger.debug("Monorepo root not found");
+        }
+        return null;
+      }
+      workspacePackages = await getWorkspacePackages(monorepoRoot);
+      if (verbose) {
+        logger.debug(`Found ${workspacePackages.length} workspace packages`);
+      }
+    }
+    const workspacePkg = workspacePackages.find((pkg) => pkg.name === depName);
+    if (workspacePkg?.pkg?.version) {
+      if (verbose) {
+        logger.debug(
+          `Resolved workspace version for ${depName}: ${workspacePkg.pkg.version}`
+        );
+      }
+      return workspacePkg.pkg.version;
+    }
+    if (verbose) {
+      logger.debug(`Workspace package ${depName} not found or has no version`);
+    }
+    return null;
+  } catch (error) {
+    if (verbose) {
+      logger.debug(
+        `Error resolving workspace version: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return null;
+  }
+}
+async function resolveCatalogVersion(packagePath, depName, verbose) {
+  try {
+    if (verbose) {
+      logger.debug(`Resolving catalog version for: ${depName}`);
+    }
+    const possibleRoots = [
+      resolve(packagePath, ".."),
+      resolve(packagePath, "..", ".."),
+      resolve(packagePath, "..", "..", "..")
+    ];
+    if (verbose) {
+      logger.debug(`Checking ${possibleRoots.length} possible root paths`);
+    }
+    for (const possibleRoot of possibleRoots) {
+      try {
+        if (verbose) {
+          logger.debug(`Checking root path: ${possibleRoot}`);
+        }
+        const rootPkg = await readPackageJSON(possibleRoot);
+        if (rootPkg?.workspaces) {
+          const workspaces = rootPkg.workspaces;
+          if (typeof workspaces === "object" && workspaces !== null && "catalog" in workspaces) {
+            const catalog = workspaces.catalog;
+            if (catalog && typeof catalog === "object") {
+              const catalogVersion = catalog[depName];
+              if (catalogVersion) {
+                if (verbose) {
+                  logger.debug(
+                    `Resolved catalog version for ${depName}: ${catalogVersion}`
+                  );
+                }
+                return catalogVersion;
+              } else if (verbose) {
+                logger.debug(`Catalog found but ${depName} not in catalog`);
+              }
+            }
+          }
+        }
+      } catch (error) {
+        if (verbose) {
+          logger.debug(
+            `Error checking root ${possibleRoot}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    if (verbose) {
+      logger.debug(`Catalog version for ${depName} not found`);
+    }
+    return null;
+  } catch (error) {
+    if (verbose) {
+      logger.debug(
+        `Error resolving catalog version: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return null;
+  }
+}
+async function preparePackageForPublishing(packagePath, options, workspacePackages, bumpedVersions, shouldBumpVersion = true) {
+  try {
+    if (options.verbose) {
+      logger.debug(`Preparing package for publishing: ${packagePath}`);
+    }
+    const pkg = await readPackageJSON(packagePath);
+    if (!pkg) {
+      if (options.verbose) {
+        logger.debug("Failed to read package.json");
+      }
+      return { success: false, error: "Could not read package.json" };
+    }
+    if (options.verbose) {
+      logger.debug(`Package name: ${pkg.name}, version: ${pkg.version}`);
+    }
+    const originalPkg = { ...pkg };
+    const originalExports = pkg.exports ? JSON.parse(JSON.stringify(pkg.exports)) : void 0;
+    if (options.verbose) {
+      logger.debug("Created backup of original package.json");
+    }
+    if (shouldBumpVersion && options.bump && !options.bumpDisable && !options.dryRun && pkg.version) {
+      if (options.verbose) {
+        logger.debug(`Bumping version: ${pkg.version} -> ${options.bump}`);
+      }
+      const bumpResult = bumpVersion(pkg.version, options.bump);
+      if (!bumpResult) {
+        if (options.verbose) {
+          logger.debug(`Invalid version bump: ${options.bump}`);
+        }
+        return {
+          success: false,
+          error: `Invalid version bump: ${options.bump}`
+        };
+      }
+      if (options.verbose) {
+        logger.log(
+          re.blue(
+            `  Bumping version from ${re.bold(pkg.version)} to ${re.bold(re.green(bumpResult.bumped))} (${options.bump})`
+          )
+        );
+      }
+      pkg.version = bumpResult.bumped;
+    } else if (options.verbose) {
+      logger.debug(
+        `Skipping version bump: shouldBumpVersion=${shouldBumpVersion}, bump=${options.bump}, bumpDisable=${options.bumpDisable}, dryRun=${options.dryRun}`
+      );
+    }
+    if (!pkg.publishConfig) {
+      pkg.publishConfig = {};
+      if (options.verbose) {
+        logger.debug("Created publishConfig object");
+      }
+    }
+    pkg.publishConfig.access = options.access || "public";
+    if (options.verbose) {
+      logger.debug(`Set publishConfig.access: ${pkg.publishConfig.access}`);
+    }
+    const originalDependencies = pkg.dependencies && Object.keys(pkg.dependencies).length > 0 ? { ...pkg.dependencies } : void 0;
+    const originalDevDependencies = pkg.devDependencies && Object.keys(pkg.devDependencies).length > 0 ? { ...pkg.devDependencies } : void 0;
+    const originalScripts = pkg.scripts && Object.keys(pkg.scripts).length > 0 ? { ...pkg.scripts } : void 0;
+    if (options.verbose) {
+      logger.debug(
+        `Stored originals: ${originalDependencies ? Object.keys(originalDependencies).length : 0} deps, ${originalDevDependencies ? Object.keys(originalDevDependencies).length : 0} devDeps, ${originalScripts ? Object.keys(originalScripts).length : 0} scripts`
+      );
+    }
+    delete pkg.devDependencies;
+    delete pkg.scripts;
+    if (options.verbose) {
+      logger.debug("Removed devDependencies and scripts for publishing");
+    }
+    if (pkg.dependencies) {
+      const depCount = Object.keys(pkg.dependencies).length;
+      if (options.verbose) {
+        logger.debug(`Resolving ${depCount} dependencies`);
+      }
+      for (const [depName, version] of Object.entries(pkg.dependencies)) {
+        if (typeof version === "string") {
+          if (version.startsWith("workspace:")) {
+            const workspaceVersion = await resolveWorkspaceVersion(
+              packagePath,
+              depName,
+              workspacePackages,
+              bumpedVersions,
+              options.verbose
+            );
+            if (workspaceVersion) {
+              if (options.verbose) {
+                logger.log(
+                  re.blue(
+                    `  Resolving workspace dependency ${re.bold(depName)}: ${version} -> ${re.green(workspaceVersion)}`
+                  )
+                );
+              }
+              pkg.dependencies[depName] = workspaceVersion;
+            } else {
+              if (options.verbose) {
+                logger.warn(
+                  `  \u26A0\uFE0F  Cannot resolve workspace dependency ${re.bold(depName)}, removing it`
+                );
+              }
+              delete pkg.dependencies[depName];
+            }
+          } else if (version === "catalog:") {
+            const catalogVersion = await resolveCatalogVersion(
+              packagePath,
+              depName,
+              options.verbose
+            );
+            if (catalogVersion) {
+              if (options.verbose) {
+                logger.log(
+                  re.blue(
+                    `  Resolving catalog dependency ${re.bold(depName)}: ${version} -> ${re.green(catalogVersion)}`
+                  )
+                );
+              }
+              pkg.dependencies[depName] = catalogVersion;
+            } else {
+              if (options.verbose) {
+                logger.warn(
+                  `  \u26A0\uFE0F  Cannot resolve catalog dependency ${re.bold(depName)}, removing it`
+                );
+              }
+              delete pkg.dependencies[depName];
+            }
+          }
+        }
+      }
+      if (options.verbose) {
+        logger.debug(
+          `After resolution: ${Object.keys(pkg.dependencies).length} dependencies remaining`
+        );
+      }
+    }
+    if (pkg.exports) {
+      if (options.verbose) {
+        logger.debug("Transforming exports field for publishing");
+      }
+      pkg.exports = transformExportsForBuild(pkg.exports);
+    }
+    await writePackageJSON(resolve(packagePath, "package.json"), pkg);
+    if (options.verbose) {
+      logger.debug("Successfully wrote modified package.json");
+    }
+    return {
+      success: true,
+      version: pkg.version,
+      originalPkg,
+      originalDependencies,
+      originalDevDependencies,
+      originalScripts,
+      originalExports
+    };
+  } catch (error) {
+    if (options.verbose) {
+      logger.debug(
+        `Error preparing package: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+export async function publishPackage(packagePath, options = {}, bumpedVersions) {
+  if (options.verbose) {
+    logger.debug(`Starting publish for package at: ${packagePath}`);
+  }
+  const rootPkg = await readPackageJSON(packagePath);
+  const rootPackageName = rootPkg?.name || "unknown";
+  if (options.verbose) {
+    logger.debug(`Package name: ${rootPackageName}`);
+    logger.debug(`Publish options: ${JSON.stringify(options, null, 2)}`);
+  }
+  let originalDependencies = null;
+  let originalDevDependencies = null;
+  let originalScripts = null;
+  let originalExports = null;
+  let workspacePackages;
+  let monorepoRoot = null;
+  try {
+    if (options.verbose) {
+      logger.debug("Discovering monorepo root and workspace packages...");
+    }
+    monorepoRoot = await findMonorepoRoot(packagePath);
+    if (monorepoRoot) {
+      if (options.verbose) {
+        logger.debug(`Monorepo root: ${monorepoRoot}`);
+      }
+      workspacePackages = await getWorkspacePackages(monorepoRoot);
+      if (options.verbose) {
+        logger.log(
+          re.blue(
+            `  Found ${re.bold(workspacePackages.length)} workspace packages`
+          )
+        );
+      }
+    } else if (options.verbose) {
+      logger.debug("Not in a monorepo (no root found)");
+    }
+  } catch (error) {
+    if (options.verbose) {
+      logger.debug(
+        `Error discovering workspace: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const copiedFiles = [];
+  try {
+    if (rootPkg?.private === true) {
+      if (options.verbose) {
+        logger.debug("Package is private, skipping publish");
+      }
+      return {
+        success: true,
+        packageName: rootPackageName,
+        packagePath,
+        warning: `The package has "private: true", publishing skipped.`
+      };
+    }
+    if (options.verbose) {
+      logger.debug("Validating kind-registry combination...");
+    }
+    const validation = validateKindRegistryCombination(
+      options.kind,
+      options.registry,
+      options.verbose
+    );
+    if (!validation.valid) {
+      if (options.verbose) {
+        logger.debug(`Validation failed: ${validation.error}`);
+      }
+      return {
+        success: false,
+        packageName: rootPackageName,
+        packagePath,
+        error: validation.error
+      };
+    }
+    if (options.registry === "none") {
+      if (options.verbose) {
+        logger.debug("Registry is 'none', skipping publish");
+      }
+      return {
+        success: true,
+        packageName: rootPackageName,
+        packagePath,
+        version: (await readPackageJSON(packagePath))?.version
+      };
+    }
+    if (monorepoRoot) {
+      if (options.verbose) {
+        logger.debug("Checking for files to copy from monorepo root...");
+      }
+      const filesToCopy = ["README.md", "LICENSE"];
+      for (const fileName of filesToCopy) {
+        const sourcePath = resolve(monorepoRoot, fileName);
+        const targetPath = resolve(packagePath, fileName);
+        try {
+          const sourceFile = Bun.file(sourcePath);
+          const sourceExists = await sourceFile.exists();
+          if (sourceExists) {
+            const targetFile = Bun.file(targetPath);
+            const targetExists = await targetFile.exists();
+            if (!targetExists) {
+              const content = await sourceFile.text();
+              await Bun.write(targetPath, content);
+              copiedFiles.push(targetPath);
+              if (options.verbose) {
+                logger.log(
+                  re.blue(`  Copied ${re.bold(fileName)} from monorepo root`)
+                );
+                logger.debug(
+                  `Copied ${fileName} from ${sourcePath} to ${targetPath}`
+                );
+              }
+            } else if (options.verbose) {
+              logger.debug(
+                `${fileName} already exists in package, skipping copy`
+              );
+            }
+          } else if (options.verbose) {
+            logger.debug(`${fileName} not found in monorepo root`);
+          }
+        } catch (error) {
+          if (options.verbose) {
+            logger.debug(
+              `Error copying ${fileName}: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+      }
+    }
+    if (options.verbose) {
+      logger.debug("Validating package.json fields...");
+    }
+    const pkgValidation = validatePackageJsonFields(
+      rootPkg,
+      rootPackageName,
+      options.kind,
+      options.verbose
+    );
+    if (!pkgValidation.valid) {
+      if (options.verbose) {
+        logger.debug(
+          `Package validation failed with ${pkgValidation.errors.length} error(s)`
+        );
+      }
+      return {
+        success: false,
+        packageName: rootPackageName,
+        packagePath,
+        error: `Package.json validation failed:
+  ${pkgValidation.errors.join("\n  ")}`
+      };
+    }
+    if (options.verbose) {
+      logger.debug("Validating dist folder...");
+    }
+    const hasDist = await validateDistFolder(packagePath, options.verbose);
+    if (!hasDist) {
+      if (options.verbose) {
+        logger.debug("Dist folder validation failed");
+      }
+      return {
+        success: false,
+        packageName: rootPackageName,
+        packagePath,
+        error: "dist folder not found. Run 'dler build' first."
+      };
+    }
+    if (options.verbose) {
+      logger.debug("Preparing package for publishing...");
+    }
+    const prepResult = await preparePackageForPublishing(
+      packagePath,
+      options,
+      workspacePackages,
+      bumpedVersions
+    );
+    if (!prepResult.success) {
+      if (options.verbose) {
+        logger.debug(`Preparation failed: ${prepResult.error}`);
+      }
+      return {
+        success: false,
+        packageName: rootPackageName,
+        packagePath,
+        error: prepResult.error
+      };
+    }
+    if (options.verbose) {
+      logger.debug(
+        `Package prepared successfully, version: ${prepResult.version}`
+      );
+    }
+    originalDependencies = prepResult.originalDependencies;
+    originalDevDependencies = prepResult.originalDevDependencies;
+    originalScripts = prepResult.originalScripts;
+    originalExports = prepResult.originalExports;
+    const rootPackage = await readPackageJSON(packagePath);
+    const packageName = rootPackage?.name || rootPackageName;
+    const registry = options.registry || "npm";
+    if (options.verbose) {
+      logger.debug(`Publishing to registry: ${registry}`);
+    }
+    if (registry === "npm" || registry === "npm-jsr") {
+      const args = ["publish"];
+      if (options.dryRun) {
+        args.push("--dry-run");
+      }
+      if (options.tag) {
+        args.push("--tag", options.tag);
+      }
+      if (options.access) {
+        args.push("--access", options.access);
+      }
+      if (options.otp) {
+        args.push("--otp", options.otp);
+      }
+      if (options.authType) {
+        args.push("--auth-type", options.authType);
+      }
+      if (options.gzipLevel) {
+        args.push("--gzip-level", options.gzipLevel);
+      }
+      if (options.bunRegistry) {
+        args.push("--registry", options.bunRegistry);
+      }
+      if (options.ca) {
+        args.push("--ca", options.ca);
+      }
+      if (options.cafile) {
+        args.push("--cafile", options.cafile);
+      }
+      if (options.ignoreScripts) {
+        args.push("--ignore-scripts");
+      }
+      if (options.silent) {
+        args.push("--silent");
+      }
+      if (options.noProgress) {
+        args.push("--no-progress");
+      }
+      if (options.noSummary) {
+        args.push("--no-summary");
+      }
+      if (options.verbose) {
+        logger.debug(`Bun publish args: ${args.join(" ")}`);
+      }
+      if (options.withNpmLogs && options.skipTip2FA !== true && !hasShown2FATip) {
+        hasShown2FATip = true;
+        logger.log(
+          `
+${re.cyan.bold("\u{1F4A1} 2FA Authentication Tip")}
+If you have 2FA enabled on npm, you may be prompted for a one-time password during publishing (on each publish attempt).
+${re.bold("Quick fix:")}
+  When prompted, check the box: "Do not challenge npm publish operations from your IP address for the next 5 minutes"
+${re.bold("Permanent solution:")}
+  https://npmjs.com \u2192 Avatar \u2192 Account \u2192 Modify 2FA \u2192 Uncheck "Require two-factor authentication for write actions"
+
+${re.bold(`Use --skip-tip-2fa to skip this information and the 3s wait.
+
+`)}`
+        );
+        await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+      }
+      try {
+        const result = await runBunPublishCommand(
+          packagePath,
+          ["bun", ...args],
+          options.verbose,
+          options.withNpmLogs
+        );
+        if (result.exitCode !== 0) {
+          const errorOutput = result.stderr || result.stdout;
+          if (options.verbose) {
+            logger.debug(
+              `Publish command failed with exit code ${result.exitCode}`
+            );
+            logger.debug(`Error output: ${errorOutput}`);
+          }
+          if (THROW_2FA_ERROR && errorOutput.includes("This operation requires a one-time password.")) {
+            throw new Error(
+              "This operation requires a one-time password. You have 2FA enabled in your npm account. Please set NPM_CONFIG_TOKEN environment variable with your npm token."
+            );
+          }
+          if (errorOutput.includes("failed to read OTP input") || errorOutput.includes("use your security key for authentication")) {
+            const hasToken = !!(process.env.NPM_CONFIG_TOKEN || process.env.NPM_TOKEN);
+            if (hasToken) {
+              throw new Error(
+                "2FA authentication required. NPM_CONFIG_TOKEN is set but authentication failed. Please verify:\n  1. The token is valid and not expired\n  2. The token has publish permissions\n  3. Use --with-npm-logs flag to allow interactive OTP input if token authentication is not working"
+              );
+            }
+            throw new Error(
+              "2FA authentication required. The publish command cannot read OTP input when output is captured. Please either:\n  1. Set NPM_CONFIG_TOKEN environment variable with your npm token (note: .env files are not automatically loaded - export it in your shell or use a tool like dotenv-cli), or\n  2. Use --with-npm-logs flag to allow interactive OTP input."
+            );
+          }
+          throw new Error(
+            `Failed to publish ${packageName} (exit code ${result.exitCode}): ${errorOutput}`
+          );
+        }
+        const output = result.stdout || result.stderr;
+        if (options.verbose) {
+          logger.debug(`Publish command succeeded`);
+          logger.debug(`Output length: ${output.length} bytes`);
+        }
+        const versionMatch = output.match(/published\s+([^\s]+)/i) || output.match(/@([0-9]+\.[0-9]+\.[0-9]+)/);
+        const version = versionMatch ? versionMatch[1] : rootPackage?.version;
+        if (options.verbose) {
+          logger.debug(`Extracted version: ${version ?? "unknown"}`);
+        }
+        if (options.verbose) {
+          logger.log(
+            re.green(
+              `\u2713 Published ${re.bold(packageName)}@${re.bold(version || "unknown")}`
+            )
+          );
+        } else {
+          logger.log(
+            re.green(
+              `\u2713 Published ${re.bold(packageName)}${version ? `@${re.bold(version)}` : ""}`
+            )
+          );
+        }
+      } catch (error) {
+        if (options.verbose) {
+          logger.debug(
+            `Publish error: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        throw new Error(
+          `Failed to publish ${packageName}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (registry === "jsr" || registry === "npm-jsr") {
+      if (options.verbose) {
+        logger.debug("JSR publishing not implemented, skipping");
+      }
+      logger.warn(
+        `\u26A0\uFE0F  JSR publishing not yet implemented for ${re.bold(packageName)}. Skipping JSR publish.`
+      );
+    }
+    if (registry === "vercel") {
+      if (options.verbose) {
+        logger.debug("Vercel publishing not implemented, skipping");
+      }
+      logger.warn(
+        `\u26A0\uFE0F  Vercel publishing not yet implemented for ${re.bold(packageName)}. Skipping Vercel publish.`
+      );
+      return {
+        success: true,
+        packageName,
+        packagePath,
+        version: rootPackage?.version
+      };
+    }
+    if (originalDependencies || originalDevDependencies || originalScripts || originalExports) {
+      if (options.verbose) {
+        logger.debug("Restoring original package.json...");
+      }
+      await restoreOriginalDependencies(
+        packagePath,
+        originalDependencies,
+        originalDevDependencies,
+        originalScripts,
+        originalExports,
+        options.verbose
+      );
+    }
+    return {
+      success: true,
+      packageName,
+      packagePath,
+      version: rootPackage?.version
+    };
+  } catch (error) {
+    if (options.verbose) {
+      logger.debug(
+        `Publish failed with error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (originalDependencies || originalDevDependencies || originalScripts || originalExports) {
+      if (options.verbose) {
+        logger.debug("Restoring original package.json after error...");
+      }
+      await restoreOriginalDependencies(
+        packagePath,
+        originalDependencies,
+        originalDevDependencies,
+        originalScripts,
+        originalExports,
+        options.verbose
+      );
+    }
+    return {
+      success: false,
+      packageName: rootPackageName,
+      packagePath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (options.verbose && copiedFiles.length > 0) {
+      logger.debug(`Cleaning up ${copiedFiles.length} copied file(s)...`);
+    }
+    for (const copiedFile of copiedFiles) {
+      try {
+        await Bun.file(copiedFile).unlink();
+        if (options.verbose) {
+          const fileName = copiedFile.split(/[/\\]/).pop();
+          logger.log(
+            re.blue(`  Removed copied file: ${re.bold(fileName || "")}`)
+          );
+          logger.debug(`Removed copied file: ${copiedFile}`);
+        }
+      } catch (error) {
+        if (options.verbose) {
+          logger.debug(
+            `Error removing copied file ${copiedFile}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+  }
+}
+export async function publishAllPackages(cwd, ignore, options = {}) {
+  try {
+    if (options.verbose) {
+      logger.debug(`Starting publishAllPackages, cwd: ${cwd ?? "current"}`);
+      if (options.filter) {
+        logger.debug(
+          `Filter patterns: ${Array.isArray(options.filter) ? options.filter.join(", ") : options.filter}`
+        );
+      } else {
+        logger.debug(
+          `Ignore patterns: ${ignore ? Array.isArray(ignore) ? ignore.join(", ") : ignore : "none"}`
+        );
+      }
+    }
+    if (options.verbose) {
+      logger.debug("Loading dler.ts configuration...");
+    }
+    const dlerConfig = await loadDlerConfig(cwd);
+    if (options.verbose) {
+      logger.debug("Discovering workspace packages...");
+    }
+    const packages = await getWorkspacePackages(cwd);
+    if (options.verbose) {
+      logger.debug(`Found ${packages.length} total workspace package(s)`);
+    }
+    const isSingleRepo = packages.length === 1 && !ignore && !options.filter;
+    const filteredPackages = isSingleRepo ? packages : filterPackages(packages, ignore, options.filter);
+    if (options.verbose) {
+      logger.debug(
+        `After filtering: ${filteredPackages.length} package(s) (single-repo mode: ${isSingleRepo})`
+      );
+      if (options.filter) {
+        const filterPatterns = Array.isArray(options.filter) ? options.filter : [options.filter];
+        logger.info(
+          re.blue(
+            `   Filtering to ${re.bold(filteredPackages.length)} packages matching: ${re.bold(filterPatterns.join(", "))}`
+          )
+        );
+      }
+    }
+    if (filteredPackages.length === 0) {
+      logger.warn("No packages found to publish");
+      return {
+        results: [],
+        hasErrors: false,
+        successCount: 0,
+        errorCount: 0,
+        warningCount: 0
+      };
+    }
+    logger.info(
+      re.blue(
+        `Found ${re.bold(filteredPackages.length)} package(s) to publish`
+      )
+    );
+    const results = [];
+    const concurrency = options.concurrency || 3;
+    if (options.verbose) {
+      logger.debug(`Concurrency: ${concurrency}`);
+    }
+    const packagesToPublish = filteredPackages.filter((pkg) => {
+      const packageConfig = getPackagePublishConfig(pkg.name, dlerConfig);
+      if (packageConfig?.enable === false) {
+        if (options.verbose) {
+          logger.info(
+            re.yellow(`Skipping ${re.bold(pkg.name)} (disabled in config)`)
+          );
+          logger.debug(
+            `Package config for ${pkg.name}: ${JSON.stringify(packageConfig)}`
+          );
+        }
+        return false;
+      }
+      return true;
+    });
+    if (options.verbose) {
+      logger.debug(
+        `After enable filter: ${packagesToPublish.length} package(s) enabled`
+      );
+    }
+    if (packagesToPublish.length === 0) {
+      logger.warn("No packages enabled for publishing");
+      return {
+        results: [],
+        hasErrors: false,
+        successCount: 0,
+        errorCount: 0,
+        warningCount: 0
+      };
+    }
+    logger.info(
+      re.blue(
+        `Publishing ${re.bold(packagesToPublish.length)} enabled package(s)`
+      )
+    );
+    const bumpedVersions = /* @__PURE__ */ new Map();
+    if (options.verbose) {
+      logger.info(re.blue("Pre-bumping package versions..."));
+    }
+    for (const pkg of packagesToPublish) {
+      const mergedOptions = mergePublishOptions(options, pkg.name, dlerConfig);
+      const bumpType = mergedOptions.bump || (mergedOptions.bumpDisable ? void 0 : "patch");
+      if (options.verbose) {
+        logger.debug(
+          `Pre-bumping ${pkg.name}: current=${pkg.pkg.version}, bumpType=${bumpType ?? "none"}, bumpDisable=${mergedOptions.bumpDisable}`
+        );
+      }
+      if (bumpType && !mergedOptions.bumpDisable && pkg.pkg.version) {
+        try {
+          const nextVersion = getNextVersion(pkg.pkg.version, bumpType);
+          if (nextVersion) {
+            bumpedVersions.set(pkg.name, nextVersion);
+            if (options.verbose) {
+              logger.log(
+                re.blue(
+                  `  ${re.bold(pkg.name)}: ${pkg.pkg.version} -> ${re.green.bold(nextVersion)}`
+                )
+              );
+            }
+          } else if (options.verbose) {
+            logger.debug(`Failed to calculate next version for ${pkg.name}`);
+          }
+        } catch (error) {
+          if (options.verbose) {
+            logger.debug(
+              `Error bumping ${pkg.name}: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+      } else if (pkg.pkg.version) {
+        bumpedVersions.set(pkg.name, pkg.pkg.version);
+        if (options.verbose) {
+          logger.debug(
+            `Using current version for ${pkg.name}: ${pkg.pkg.version}`
+          );
+        }
+      }
+    }
+    if (options.verbose) {
+      logger.debug(`Pre-bumped ${bumpedVersions.size} package version(s)`);
+    }
+    const totalBatches = Math.ceil(packagesToPublish.length / concurrency);
+    if (options.verbose) {
+      logger.debug(
+        `Processing ${totalBatches} batch(es) with concurrency ${concurrency}`
+      );
+    }
+    for (let i = 0; i < packagesToPublish.length; i += concurrency) {
+      const batch = packagesToPublish.slice(i, i + concurrency);
+      const batchNumber = Math.floor(i / concurrency) + 1;
+      if (options.verbose) {
+        logger.debug(
+          `Processing batch ${batchNumber}/${totalBatches} with ${batch.length} package(s)`
+        );
+      }
+      const batchPromises = batch.map(async (pkg) => {
+        const mergedOptions = mergePublishOptions(
+          options,
+          pkg.name,
+          dlerConfig
+        );
+        if (!mergedOptions.bump && !mergedOptions.bumpDisable) {
+          mergedOptions.bump = "patch";
+        }
+        if (options.verbose) {
+          logger.debug(
+            `Merged options for ${pkg.name}: ${JSON.stringify(mergedOptions)}`
+          );
+        }
+        if (mergedOptions.verbose) {
+          logger.info(re.blue(`Publishing ${re.bold(pkg.name)}...`));
+        }
+        return await publishPackage(pkg.path, mergedOptions, bumpedVersions);
+      });
+      const batchResults = await Promise.all(batchPromises);
+      results.push(...batchResults);
+      if (options.verbose) {
+        const batchSuccess = batchResults.filter((r) => r.success).length;
+        const batchErrors = batchResults.filter((r) => !r.success).length;
+        logger.debug(
+          `Batch ${batchNumber} completed: ${batchSuccess} success, ${batchErrors} error(s)`
+        );
+      }
+      const hasBatchErrors = batchResults.some((r) => !r.success);
+      if (hasBatchErrors) {
+        if (options.verbose) {
+          logger.debug(
+            `Batch ${batchNumber} had errors, stopping processing of remaining batches`
+          );
+        }
+        break;
+      }
+    }
+    const successCount = results.filter(
+      (r) => r.success && !r.warning?.includes('"private: true"')
+    ).length;
+    const errorCount = results.filter((r) => !r.success).length;
+    const warningCount = results.filter((r) => r.warning).length;
+    const hasErrors = errorCount > 0;
+    if (options.verbose) {
+      logger.debug(
+        `Publish all completed: ${successCount} success, ${errorCount} error(s), ${warningCount} warning(s)`
+      );
+    }
+    return {
+      results,
+      hasErrors,
+      successCount,
+      errorCount,
+      warningCount
+    };
+  } catch (error) {
+    if (options.verbose) {
+      logger.debug(
+        `Publish all failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    logger.error(
+      re.red("Failed to publish packages:"),
+      re.red(error instanceof Error ? error.message : String(error))
+    );
+    return {
+      results: [],
+      hasErrors: true,
+      successCount: 0,
+      errorCount: 1,
+      warningCount: 0
+    };
+  }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@reliverse/publish",
+  "version": "2.2.7",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    }
+  },
+  "dependencies": {
+    "c12": "^3.3.3",
+    "@reliverse/typerso": "2.2.7",
+    "@reliverse/config": "2.2.7",
+    "@reliverse/relinka": "2.2.7",
+    "@reliverse/bump": "2.2.8",
+    "@reliverse/relico": "2.2.7",
+    "@reliverse/build": "2.2.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "license": "MIT"
+}