opkg 0.9.2 → 0.9.4

package/packages/cli/dist/publish-RULKLNUX.js

@@ -0,0 +1,619 @@
+#!/usr/bin/env node
+import {
+  getCurrentUsername
+} from "./chunk-EGAP6GNA.js";
+import {
+  resolveScopedNameForPushWithUserScope
+} from "./chunk-37256POU.js";
+import {
+  createHttpClient
+} from "./chunk-ATYT3SA6.js";
+import {
+  authManager
+} from "./chunk-UR6VJWA3.js";
+import "./chunk-S6OARUVQ.js";
+import {
+  classifyPackageInput
+} from "./chunk-4TCVCEPB.js";
+import {
+  resolvePackageByName
+} from "./chunk-E2DVTD75.js";
+import {
+  createFormDataForUpload,
+  createTarballFromPackage,
+  formatVersionLabel
+} from "./chunk-TFQ4JBVO.js";
+import "./chunk-V5OW4YEB.js";
+import "./chunk-PXL2RUMX.js";
+import {
+  formatFileSize,
+  formatPathForDisplay
+} from "./chunk-MIURCESJ.js";
+import {
+  createCliExecutionContext,
+  resolveOutput,
+  resolvePrompt
+} from "./chunk-RAKMX654.js";
+import {
+  ensureRegistryDirectories,
+  getPackageVersionPath
+} from "./chunk-XEPVYZO3.js";
+import {
+  parsePackageYml,
+  serializePackageYml
+} from "./chunk-QTQYI4L5.js";
+import {
+  isScopedName
+} from "./chunk-VN22A7NW.js";
+import {
+  normalizePathForProcessing
+} from "./chunk-YMKK4XPN.js";
+import {
+  DIR_PATTERNS,
+  FILE_PATTERNS,
+  OPENPACKAGE_DIRS,
+  PACKAGE_PATHS
+} from "./chunk-J4IFFBLP.js";
+import {
+  countFilesInDirectory,
+  ensureDir,
+  exists,
+  readTextFile,
+  remove,
+  walkFiles,
+  writeTextFile
+} from "./chunk-S47F4OG4.js";
+import {
+  ValidationError
+} from "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/core/publish/publish-pipeline.ts
+import path2 from "path";
+import * as semver2 from "semver";
+
+// ../core/src/utils/package-copy.ts
+import { join, relative, dirname } from "path";
+
+// ../core/src/utils/package-filters.ts
+var EXCLUDED_DIR_PREFIXES = [
+  OPENPACKAGE_DIRS.PACKAGES,
+  // Nested packages are independent units; never copy inline
+  // Note: .openpackage/ is excluded separately in the function below (entire directory is workspace-local metadata)
+  `${DIR_PATTERNS.OPENPACKAGE}/${OPENPACKAGE_DIRS.PACKAGES}`
+  // Legacy: kept for completeness, but covered by .openpackage/ exclusion in function
+], EXCLUDED_FILES = /* @__PURE__ */ new Set([FILE_PATTERNS.OPENPACKAGE_INDEX_YML]);
+function isExcludedFromPackage(relativePath) {
+  let normalized = normalizePathForProcessing(relativePath);
+  if (!normalized || normalized === DIR_PATTERNS.OPENPACKAGE || normalized.startsWith(`${DIR_PATTERNS.OPENPACKAGE}/`))
+    return !0;
+  let baseName = normalized.split("/").pop();
+  return baseName && EXCLUDED_FILES.has(baseName) ? !0 : EXCLUDED_DIR_PREFIXES.some((prefix) => {
+    let normalizedPrefix = normalizePathForProcessing(prefix);
+    return normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`);
+  });
+}
+
+// ../core/src/utils/package-copy.ts
+async function readPackageFilesForRegistry(packageDir) {
+  if (!await exists(packageDir))
+    return [];
+  let files = [];
+  for await (let fullPath of walkFiles(packageDir)) {
+    let relativePath = normalizePathForProcessing(relative(packageDir, fullPath));
+    if (isExcludedFromPackage(relativePath)) {
+      logger.debug(`Skipping static-excluded path: ${relativePath}`);
+      continue;
+    }
+    let content = await readTextFile(fullPath);
+    files.push({ path: relativePath, content, encoding: "utf8" });
+  }
+  return files;
+}
+async function writePackageFilesToDirectory(targetDir, files, options = {}) {
+  await ensureDir(targetDir);
+  let pathsToKeep = new Set(files.map((f) => normalizePathForProcessing(f.path)));
+  options.preserveIndexFile && pathsToKeep.add(FILE_PATTERNS.OPENPACKAGE_INDEX_YML), await removeStaleFiles(targetDir, pathsToKeep), await Promise.all(files.map((file) => writeFile(targetDir, file)));
+}
+async function removeStaleFiles(targetDir, pathsToKeep) {
+  if (await exists(targetDir))
+    for await (let fullPath of walkFiles(targetDir)) {
+      let relPath = normalizePathForProcessing(relative(targetDir, fullPath));
+      if (!pathsToKeep.has(relPath) && !isExcludedFromPackage(relPath))
+        try {
+          await remove(fullPath), logger.debug(`Removed stale file: ${relPath}`);
+        } catch (error) {
+          logger.warn(`Failed to remove stale file ${relPath}: ${error}`);
+        }
+    }
+}
+async function writeFile(targetDir, file) {
+  let targetPath = join(targetDir, file.path);
+  await ensureDir(dirname(targetPath)), await writeTextFile(targetPath, file.content, file.encoding ?? "utf8");
+}
+
+// ../core/src/core/publish/publish-errors.ts
+var PublishError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "PublishError";
+  }
+};
+function handlePublishError(error, packageName, version, output) {
+  let out = output ?? resolveOutput();
+  if (logger.debug("Publish operation failed", { error, packageName, version }), error instanceof PublishError)
+    return out.error(error.message), {
+      success: !1,
+      error: error.message
+    };
+  if (error instanceof Error) {
+    let message = error.message;
+    return message.includes("ENOENT") || message.includes("not found") ? (out.error("Package file not found"), {
+      success: !1,
+      error: "Package file not found"
+    }) : message.includes("authentication") || message.includes("unauthorized") ? (out.error('Authentication failed. Run "opkg login" to configure credentials.'), {
+      success: !1,
+      error: "Authentication failed"
+    }) : message.includes("network") || message.includes("ECONNREFUSED") ? (out.error("Network error: Unable to connect to registry"), {
+      success: !1,
+      error: "Network error"
+    }) : (out.error(message), {
+      success: !1,
+      error: message
+    });
+  }
+  let errorMessage = String(error);
+  return out.error(`Unexpected error: ${errorMessage}`), {
+    success: !1,
+    error: errorMessage
+  };
+}
+
+// ../core/src/core/publish/publish-output.ts
+function logPublishSummary(packageName, profile, registryUrl, output) {
+  let out = output ?? resolveOutput();
+  out.step(`Publishing package '${packageName}'...`), out.message(`Profile: ${profile}`), out.message(`Registry: ${registryUrl}`);
+}
+function displayPublishSuccess(info, cwd, output) {
+  let out = output ?? resolveOutput(), { packageName, version, description, sourcePath, destinationPath, fileCount, isCustomOutput } = info;
+  out.success(`Published ${packageName}@${formatVersionLabel(version)}`), description && out.success(`Description: ${description}`);
+  let displaySource = formatPathForDisplay(sourcePath, cwd);
+  out.success(`Source: ${displaySource}`);
+  let displayDestination = formatPathForDisplay(destinationPath, cwd), destinationType = isCustomOutput ? "Custom output" : "Registry";
+  out.success(`${destinationType}: ${displayDestination}`), out.success(`Files: ${fileCount}`);
+}
+function createPublishResultInfo(packageName, version, sourcePath, destinationPath, fileCount, manifest, isCustomOutput, destinationExists, existingFileCount) {
+  return {
+    packageName,
+    version,
+    description: manifest.description,
+    sourcePath,
+    destinationPath,
+    fileCount,
+    isCustomOutput,
+    destinationExists,
+    existingFileCount
+  };
+}
+
+// ../core/src/core/publish/publish-upload.ts
+function preparePackageForUpload(pkg, uploadName) {
+  if (pkg.metadata.name === uploadName)
+    return pkg;
+  let manifestPath = normalizePathForProcessing(PACKAGE_PATHS.MANIFEST_RELATIVE), updatedMetadata = { ...pkg.metadata, name: uploadName }, manifestUpdated = !1, updatedFiles = pkg.files.map((file) => {
+    if (normalizePathForProcessing(file.path) === manifestPath) {
+      manifestUpdated = !0;
+      let content = serializePackageYml(updatedMetadata);
+      return { ...file, content };
+    }
+    return file;
+  });
+  if (!manifestUpdated)
+    throw new Error("openpackage.yml not found in package files");
+  return {
+    metadata: updatedMetadata,
+    files: updatedFiles
+  };
+}
+async function createPublishTarball(pkg, output) {
+  let out = output ?? resolveOutput(), tarballInfo = await createTarballFromPackage(pkg);
+  return out.success(`Created tarball (${pkg.files.length} files, ${formatFileSize(tarballInfo.size)})`), tarballInfo;
+}
+async function uploadPackage(httpClient, packageName, uploadVersion, tarballInfo, output, stopMessage) {
+  let out = output ?? resolveOutput(), formData = createFormDataForUpload(packageName, uploadVersion, tarballInfo), uploadSpinner = out.spinner();
+  return withSpinner(
+    uploadSpinner,
+    "Uploading to registry...",
+    () => httpClient.uploadFormData("/packages/push", formData),
+    stopMessage
+  );
+}
+async function withSpinner(spinner, message, fn, stopMessage) {
+  spinner.start(message);
+  try {
+    return await fn();
+  } finally {
+    spinner.stop(stopMessage);
+  }
+}
+
+// ../core/src/core/publish/local-publish-pipeline.ts
+import path from "path";
+
+// ../core/src/utils/validation/version.ts
+import * as semver from "semver";
+function validateVersion(version, options = {}) {
+  return version ? semver.valid(version) ? options.rejectPrerelease && semver.prerelease(version) ? {
+    code: "PRERELEASE_DISALLOWED",
+    message: `Prerelease versions are not allowed${options.context ? ` for ${options.context}` : ""}: ${version}`
+  } : null : {
+    code: "INVALID_VERSION",
+    message: `Invalid version: ${version}. Must be valid semver (e.g., 1.0.0)`
+  } : {
+    code: "MISSING_VERSION",
+    message: `Version field is required${options.context ? ` for ${options.context}` : ""}`
+  };
+}
+function assertValidVersion(version, options) {
+  let error = validateVersion(version, options);
+  if (error)
+    throw new Error(error.message);
+}
+function isUnversionedPackage(version) {
+  return version === "0.0.0";
+}
+
+// ../core/src/utils/validation/package-files.ts
+async function validateAndReadPackageFiles(packageRoot, options = {}) {
+  let files = await readPackageFilesForRegistry(packageRoot), throwOnEmpty = options.throwOnEmpty !== !1;
+  if (files.length === 0 && throwOnEmpty) {
+    let context = options.context || "package";
+    throw new Error(`No files found to include in ${context}`);
+  }
+  return files;
+}
+
+// ../core/src/core/registry-writer.ts
+async function writePackageToRegistry(packageName, version, files, options = {}, output, prompt) {
+  let { force = !1, dryRun = !1, context = "operation" } = options, out = output ?? resolveOutput(), prm = prompt ?? resolvePrompt(), destination = getPackageVersionPath(packageName, version), destinationExists = await exists(destination), existingFileCount = destinationExists ? await countFilesInDirectory(destination) : 0, shouldOverwrite = !0;
+  if (destinationExists)
+    if (isUnversionedPackage(version))
+      logger.debug(
+        `Updating unversioned package ${packageName}@${version}`,
+        { destination, existingFileCount }
+      ), out.success(`Updated ${packageName}@${version}`);
+    else if (force)
+      logger.info(
+        `Force mode: Overwriting ${packageName}@${version}`,
+        { destination, existingFileCount }
+      ), out.warn(
+        `Force mode: Overwriting ${packageName}@${version} (${existingFileCount} existing file${existingFileCount !== 1 ? "s" : ""})`
+      );
+    else
+      try {
+        let displayPath = formatPathForDisplay(destination, process.cwd());
+        if (out.info(""), out.warn(`Package '${packageName}@${version}' already exists in registry`), out.info(`   Location: ${displayPath}`), out.info(`   Existing files: ${existingFileCount}`), out.info(""), shouldOverwrite = await prm.confirm(
+          `Overwrite '${packageName}@${version}'? This action cannot be undone.`,
+          !1
+        ), !shouldOverwrite)
+          throw new Error(`${context} cancelled by user`);
+      } catch (promptError) {
+        if (promptError.name === "NonInteractivePromptError") {
+          let displayPath = formatPathForDisplay(destination, process.cwd());
+          throw new Error(
+            `Package ${packageName}@${version} already exists in registry (${displayPath}).
+Use --force to overwrite, or update the version in openpackage.yml.`
+          );
+        }
+        throw promptError;
+      }
+  return dryRun ? {
+    destination,
+    fileCount: files.length,
+    overwritten: destinationExists
+  } : (await ensureRegistryDirectories(), destinationExists && await remove(destination), await writePackageFilesToDirectory(destination, files), logger.info(`Wrote ${packageName}@${version} to registry`, {
+    destination,
+    fileCount: files.length,
+    context
+  }), {
+    destination,
+    fileCount: files.length,
+    overwritten: destinationExists
+  });
+}
+
+// ../core/src/core/publish/local-publish-pipeline.ts
+async function resolveSource(cwd, packageInput, output) {
+  if (!packageInput) {
+    let manifestPath2 = path.join(cwd, FILE_PATTERNS.OPENPACKAGE_YML);
+    if (!await exists(manifestPath2))
+      throw new Error("No openpackage.yml found in current directory; specify a package name or run inside a package root.");
+    let manifest2 = await parsePackageYml(manifestPath2);
+    return {
+      name: manifest2.name,
+      version: manifest2.version ?? "",
+      packageRoot: cwd,
+      manifest: manifest2
+    };
+  }
+  let classification = await classifyPackageInput(packageInput, cwd), packageRoot;
+  if (classification.type === "directory")
+    packageRoot = classification.resolvedPath, logger.info("Resolved package input as directory path", { path: packageRoot });
+  else {
+    if (classification.type === "tarball")
+      throw new ValidationError(
+        `Local publish does not support tarball inputs.
+To publish from a tarball, first extract it to a directory.`
+      );
+    if (classification.type === "git")
+      throw new ValidationError(
+        `Local publish does not support git inputs.
+To publish from a git repository, first clone it to a directory.`
+      );
+    {
+      let resolution = await resolvePackageByName({
+        cwd,
+        packageName: packageInput,
+        checkCwd: !0,
+        // Check if CWD is the package (highest priority)
+        searchWorkspace: !0,
+        // Search workspace packages
+        searchGlobal: !0,
+        // Search global packages
+        searchRegistry: !1
+        // Skip registry (already packed/immutable)
+      });
+      if (!resolution.found || !resolution.path)
+        throw new Error(
+          `Package '${packageInput}' not found.
+Searched: current directory, workspace packages (.openpackage/packages/), and global packages (~/.openpackage/packages/).
+Make sure the package exists in one of these locations.`
+        );
+      if (packageRoot = resolution.path, resolution.resolutionInfo) {
+        let { selected, reason } = resolution.resolutionInfo;
+        logger.info("Resolved package for publishing", {
+          packageInput,
+          selectedSource: selected.type,
+          version: selected.version,
+          path: selected.path,
+          reason
+        });
+        let sourceLabel = selected.type === "cwd" ? "current directory" : selected.type === "workspace" ? "workspace packages" : selected.type === "global" ? "global packages" : selected.type;
+        (output ?? resolveOutput()).success(`Found ${packageInput} in ${sourceLabel}`);
+      }
+    }
+  }
+  let manifestPath = path.join(packageRoot, FILE_PATTERNS.OPENPACKAGE_YML);
+  if (!await exists(manifestPath))
+    throw new Error(`openpackage.yml not found at ${manifestPath}`);
+  let manifest = await parsePackageYml(manifestPath);
+  return {
+    name: manifest.name,
+    version: manifest.version ?? "",
+    packageRoot,
+    manifest
+  };
+}
+async function runLocalPublishPipeline(packageInput, options, output, prompt) {
+  let out = output ?? resolveOutput(), cwd = process.cwd();
+  try {
+    let source = await resolveSource(cwd, packageInput, output), packageName = source.name, version = source.version, publishVersion = version;
+    !version || version.trim() === "" ? (publishVersion = "0.0.0", out.info("No version specified, using 0.0.0 for local publish"), logger.info("Auto-assigned version 0.0.0 for unversioned package", { packageName })) : assertValidVersion(version, {
+      rejectPrerelease: !0,
+      context: "local publish"
+    }), logger.info(`Publishing package '${packageName}' to local registry`, {
+      source: source.packageRoot,
+      version: publishVersion
+    });
+    let files = await validateAndReadPackageFiles(source.packageRoot, {
+      context: "publish"
+    }), result = await writePackageToRegistry(
+      packageName,
+      publishVersion,
+      files,
+      {
+        force: options.force,
+        context: "publish"
+      },
+      output,
+      prompt
+    ), resultInfo = createPublishResultInfo(
+      packageName,
+      publishVersion,
+      source.packageRoot,
+      result.destination,
+      result.fileCount,
+      source.manifest,
+      !1,
+      // isCustomOutput
+      result.overwritten,
+      result.overwritten ? result.fileCount : 0
+    );
+    return displayPublishSuccess(resultInfo, cwd), {
+      success: !0,
+      data: {
+        packageName,
+        version: publishVersion,
+        sourcePath: source.packageRoot,
+        destination: result.destination,
+        fileCount: result.fileCount,
+        overwritten: result.overwritten
+      }
+    };
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    return logger.debug("Local publish failed", { error: message, cwd }), {
+      success: !1,
+      error: message
+    };
+  }
+}
+
+// ../core/src/core/publish/publish-pipeline.ts
+async function runPublishPipeline(packageInput, options, ctx) {
+  let output = resolveOutput(ctx), prompt = resolvePrompt(ctx);
+  return options.local ? await runLocalPublishPipeline(packageInput, options, output, prompt) : await runRemotePublishPipeline(packageInput, options, output, prompt);
+}
+async function resolveSource2(cwd, packageInput, output) {
+  if (!packageInput) {
+    let manifestPath2 = path2.join(cwd, FILE_PATTERNS.OPENPACKAGE_YML);
+    if (!await exists(manifestPath2))
+      throw new Error("No openpackage.yml found in current directory; specify a package name or run inside a package root.");
+    let manifest2 = await parsePackageYml(manifestPath2);
+    return {
+      name: manifest2.name,
+      version: manifest2.version ?? "",
+      packageRoot: cwd,
+      manifest: manifest2
+    };
+  }
+  let classification = await classifyPackageInput(packageInput, cwd), packageRoot;
+  if (classification.type === "directory")
+    packageRoot = classification.resolvedPath, logger.info("Resolved package input as directory path", { path: packageRoot });
+  else {
+    if (classification.type === "tarball")
+      throw new ValidationError(
+        `Remote publish does not support tarball inputs.
+To publish from a tarball, first extract it to a directory, or use local publish mode.`
+      );
+    if (classification.type === "git")
+      throw new ValidationError(
+        `Remote publish does not support git inputs.
+To publish from a git repository, first clone it to a directory.`
+      );
+    {
+      let resolution = await resolvePackageByName({
+        cwd,
+        packageName: packageInput,
+        checkCwd: !0,
+        // Check if CWD is the package (highest priority)
+        searchWorkspace: !0,
+        // Search workspace packages
+        searchGlobal: !0,
+        // Search global packages
+        searchRegistry: !1
+        // Skip registry (already published/immutable)
+      });
+      if (!resolution.found || !resolution.path)
+        throw new Error(
+          `Package '${packageInput}' not found.
+Searched: current directory, workspace packages (.openpackage/packages/), and global packages (~/.openpackage/packages/).
+Make sure the package exists in one of these locations.`
+        );
+      if (packageRoot = resolution.path, resolution.resolutionInfo) {
+        let { selected, reason } = resolution.resolutionInfo;
+        logger.info("Resolved package for publishing", {
+          packageInput,
+          selectedSource: selected.type,
+          version: selected.version,
+          path: selected.path,
+          reason
+        });
+        let sourceLabel = selected.type === "cwd" ? "current directory" : selected.type === "workspace" ? "workspace packages" : selected.type === "global" ? "global packages" : selected.type;
+        output && output.success(`Found ${packageInput} in ${sourceLabel}`);
+      }
+    }
+  }
+  let manifestPath = path2.join(packageRoot, FILE_PATTERNS.OPENPACKAGE_YML);
+  if (!await exists(manifestPath))
+    throw new Error(`openpackage.yml not found at ${manifestPath}`);
+  let manifest = await parsePackageYml(manifestPath);
+  return {
+    name: manifest.name,
+    version: manifest.version ?? "",
+    packageRoot,
+    manifest
+  };
+}
+async function resolveUploadName(packageName, authOptions, prompt) {
+  if (isScopedName(packageName))
+    return packageName;
+  let username = await getCurrentUsername(authOptions);
+  return await resolveScopedNameForPushWithUserScope(packageName, username, authOptions.profile, prompt);
+}
+function validateVersionIfPresent(version) {
+  if (version) {
+    if (!semver2.valid(version))
+      throw new PublishError(
+        `Invalid version: ${version}. Provide a valid semver version.`,
+        "INVALID_VERSION"
+      );
+    if (semver2.prerelease(version))
+      throw new PublishError(
+        `Prerelease versions cannot be published: ${version}`,
+        "PRERELEASE_DISALLOWED"
+      );
+  }
+}
+async function runRemotePublishPipeline(packageInput, options, output, prompt) {
+  let out = output ?? resolveOutput(), cwd = process.cwd(), uploadPackageName, version;
+  try {
+    let source = await resolveSource2(cwd, packageInput, output);
+    if (!source.name)
+      throw new PublishError(
+        "openpackage.yml must contain a name field",
+        "MISSING_NAME"
+      );
+    validateVersionIfPresent(source.version), version = source.version || void 0, logger.info(`Publishing package '${source.name}' from ${source.packageRoot}`, {
+      packageRoot: source.packageRoot,
+      version
+    }), await authManager.validateAuth(options), uploadPackageName = await resolveUploadName(source.name, options, prompt);
+    let files = await readPackageFilesForRegistry(source.packageRoot);
+    if (files.length === 0)
+      throw new PublishError("No package files found to publish", "NO_FILES");
+    let pkg = {
+      metadata: source.manifest,
+      files
+    }, uploadPkg = preparePackageForUpload(pkg, uploadPackageName), httpClient = await createHttpClient(options), registryUrl = authManager.getRegistryUrl(), profile = authManager.getCurrentProfile(options);
+    logPublishSummary(uploadPackageName, profile, registryUrl, out);
+    let tarballInfo = await createPublishTarball(uploadPkg, out), versionSuffix = version ? `@${version}` : "", publishedMessage = `Published ${source.name}${versionSuffix} to remote registry`, response = await uploadPackage(httpClient, uploadPackageName, version, tarballInfo, out, publishedMessage);
+    return printPublishSuccessEnhanced(
+      response,
+      tarballInfo,
+      registryUrl,
+      profile,
+      source,
+      files.length,
+      cwd,
+      out
+    ), {
+      success: !0,
+      data: {
+        packageName: response.package.name,
+        version: response.version.version ?? version ?? "",
+        size: tarballInfo.size,
+        checksum: tarballInfo.checksum,
+        registry: registryUrl,
+        profile,
+        message: response.message
+      }
+    };
+  } catch (error) {
+    return handlePublishError(error, uploadPackageName, version);
+  }
+}
+function printPublishSuccessEnhanced(response, tarballInfo, registryUrl, profile, source, fileCount, cwd, out) {
+  source.manifest.description && out.message(`Description: ${source.manifest.description}`);
+  let displaySource = formatPathForDisplay(source.packageRoot, cwd);
+  out.message(`Source: ${displaySource}`), out.message(`Registry: ${registryUrl}`), out.message(`Profile: ${profile}`), out.message(`Files: ${fileCount}`);
+  let formatFileSize2 = (bytes) => {
+    let kb = bytes / 1024;
+    return kb < 1024 ? `${kb.toFixed(1)} KB` : `${(kb / 1024).toFixed(1)} MB`;
+  };
+  out.message(`Size: ${formatFileSize2(tarballInfo.size)}`), out.message(`Checksum: ${tarballInfo.checksum.substring(0, 12)}...`), response.message && out.message(`
+${response.message}`);
+}
+
+// src/commands/publish.ts
+async function setupPublishCommand(args) {
+  let [packageInput, options] = args, ctx = await createCliExecutionContext(), result = await runPublishPipeline(packageInput, options, ctx);
+  if (!result.success)
+    throw new Error(result.error || "Publish operation failed");
+}
+export {
+  setupPublishCommand
+};
+//# sourceMappingURL=publish-RULKLNUX.js.map