@backstage/cli-module-build 0.0.0-nightly-20260317031259

package/dist/commands/package/bundle/command.cjs.js

@@ -0,0 +1,691 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cliNode = require('@backstage/cli-node');
+var cliCommon = require('@backstage/cli-common');
+var chalk = require('chalk');
+var cleye = require('cleye');
+var fs = require('fs-extra');
+var node_module = require('node:module');
+var os = require('node:os');
+var node_path = require('node:path');
+var configLoader = require('@backstage/config-loader');
+var buildFrontend = require('../../../lib/buildFrontend.cjs.js');
+var createDistWorkspace = require('../../../lib/packager/createDistWorkspace.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+async function bundleCommand(opts) {
+  const pkgJsonPath = cliCommon.targetPaths.resolve("package.json");
+  const pkg = await fs__default.default.readJson(pkgJsonPath);
+  const outputDestination = opts.outputDestination ? node_path.resolve(opts.outputDestination) : cliCommon.targetPaths.dir;
+  const mangledName = pkg.name.replace(/^@/, "").replace(/\//, "-");
+  let bundleName = "bundle";
+  if (opts.outputName) {
+    bundleName = opts.outputName;
+  } else if (opts.outputDestination) {
+    bundleName = mangledName;
+  }
+  const target = node_path.join(outputDestination, bundleName);
+  const role = pkg.backstage?.role;
+  if (!role) {
+    throw new Error(
+      `Package ${chalk__default.default.cyan(
+        pkg.name
+      )} does not have a backstage.role defined in package.json`
+    );
+  }
+  const validRoles = [
+    "backend-plugin",
+    "backend-plugin-module",
+    "frontend-plugin",
+    "frontend-plugin-module"
+  ];
+  if (!validRoles.includes(role)) {
+    throw new Error(
+      `Package ${chalk__default.default.cyan(pkg.name)} has role ${chalk__default.default.cyan(
+        role
+      )}, but bundle command only supports: ${validRoles.map((r) => chalk__default.default.cyan(r)).join(", ")}`
+    );
+  }
+  const pluginType = role === "frontend-plugin" || role === "frontend-plugin-module" ? "frontend" : "backend";
+  if (pkg.bundled) {
+    throw new Error(
+      `Package ${chalk__default.default.cyan(pkg.name)} has ${chalk__default.default.cyan(
+        "bundled: true"
+      )} which is not compatible with dynamic plugin bundling.`
+    );
+  }
+  console.log(
+    chalk__default.default.blue(`Bundling ${chalk__default.default.cyan(pkg.name)} for dynamic loading...`)
+  );
+  console.log(`${chalk__default.default.dim("Output:")} ${chalk__default.default.cyan(target)}`);
+  if (opts.clean) {
+    console.log(chalk__default.default.blue(`Cleaning ${chalk__default.default.cyan(target)}`));
+    await fs__default.default.remove(target);
+  }
+  await fs__default.default.mkdirs(target);
+  await fs__default.default.writeFile(node_path.join(target, ".gitignore"), "*\n");
+  await fs__default.default.writeFile(node_path.join(target, ".bundle-output"), "");
+  const rootPkg = await fs__default.default.readJson(
+    node_path.resolve(cliCommon.targetPaths.rootDir, "package.json")
+  );
+  const needsDependencies = pluginType === "backend" || !!opts.prePackedDir;
+  if (needsDependencies) {
+    const yarnrcLines = ["nodeLinker: node-modules"];
+    try {
+      const resolved = await cliCommon.runOutput(["yarn", "config", "get", "yarnPath"], {
+        cwd: cliCommon.targetPaths.rootDir
+      });
+      const yarnPathSentinels = /* @__PURE__ */ new Set(["undefined", "null"]);
+      if (resolved && !yarnPathSentinels.has(resolved)) {
+        yarnrcLines.push(`yarnPath: ${resolved}`);
+      }
+    } catch {
+      if (!rootPkg.packageManager) {
+        console.warn(
+          chalk__default.default.yellow(
+            "No yarnPath configured and no packageManager field found. The Yarn version in PATH will be used for lockfile operations."
+          )
+        );
+      }
+    }
+    await fs__default.default.writeFile(
+      node_path.join(target, ".yarnrc.yml"),
+      `${yarnrcLines.join("\n")}
+`
+    );
+  }
+  if (pluginType === "frontend" && opts.build) {
+    console.log(chalk__default.default.blue("Building module federation remote..."));
+    await buildFrontend.buildFrontend({
+      targetDir: cliCommon.targetPaths.dir,
+      configPaths: [],
+      writeStats: false,
+      isModuleFederationRemote: true
+    });
+  }
+  const embeddedResolutions = {};
+  const bundleOutputDirs = [];
+  try {
+    const entries = await fs__default.default.readdir(cliCommon.targetPaths.dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (await fs__default.default.pathExists(
+          node_path.join(cliCommon.targetPaths.dir, entry.name, ".bundle-output")
+        )) {
+          bundleOutputDirs.push(entry.name);
+        }
+      }
+    }
+  } catch {
+  }
+  if (needsDependencies) {
+    const embeddedDir = node_path.join(target, "embedded");
+    let targets;
+    if (opts.prePackedDir) {
+      const prePackedDir = node_path.resolve(opts.prePackedDir);
+      console.log(
+        chalk__default.default.blue(
+          `Using pre-packed workspace at ${chalk__default.default.cyan(prePackedDir)}...`
+        )
+      );
+      const packages = await cliNode.PackageGraph.listTargetPackages();
+      targets = await createDistWorkspace.resolveLocalDependencies([pkg.name], packages);
+      await fs__default.default.ensureDir(embeddedDir);
+      for (const dep of targets) {
+        const relDir = node_path.relative(cliCommon.targetPaths.rootDir, dep.dir);
+        const srcDir = node_path.resolve(prePackedDir, relDir);
+        const destDir = node_path.resolve(embeddedDir, relDir);
+        if (await fs__default.default.pathExists(srcDir)) {
+          await fs__default.default.copy(srcDir, destDir);
+        } else {
+          console.warn(
+            chalk__default.default.yellow(
+              `  Package ${chalk__default.default.cyan(dep.name)} not found in pre-packed dir (expected at ${chalk__default.default.cyan(relDir)})`
+            )
+          );
+        }
+      }
+    } else {
+      const tempWorkspaceDir = await fs__default.default.mkdtemp(
+        node_path.join(os.tmpdir(), "bundle-workspace-")
+      );
+      console.log(chalk__default.default.blue("Packing local dependencies..."));
+      const distLog = createStepLogger(
+        node_path.join(target, "dist-workspace.log"),
+        opts.verbose
+      );
+      const packingPattern = /^(?:Moving|Repacking) (.+) into dist workspace$/;
+      const distLogger = {
+        log(msg) {
+          const match = msg.match(packingPattern);
+          if (match) {
+            console.log(`  ${chalk__default.default.dim("Packing")} ${chalk__default.default.cyan(match[1])}`);
+          }
+          distLog.logger.log(msg);
+        },
+        warn(msg) {
+          console.warn(`  ${chalk__default.default.yellow(msg)}`);
+          distLog.logger.warn(msg);
+        }
+      };
+      try {
+        ({ targets } = await createDistWorkspace.createDistWorkspace([pkg.name], {
+          targetDir: tempWorkspaceDir,
+          files: [],
+          alwaysPack: true,
+          buildDependencies: opts.build,
+          buildExcludes: opts.build ? [] : void 0,
+          logger: distLogger
+        }));
+        await fs__default.default.remove(embeddedDir);
+        await fs__default.default.move(tempWorkspaceDir, embeddedDir);
+      } catch (err) {
+        await distLog.close();
+        await showLogOnError(distLog.path, opts.verbose);
+        throw err;
+      } finally {
+        if (await fs__default.default.pathExists(tempWorkspaceDir)) {
+          await fs__default.default.remove(tempWorkspaceDir);
+        }
+      }
+      await distLog.close();
+      await fs__default.default.remove(distLog.path);
+    }
+    const mainPluginRelDir = node_path.relative(cliCommon.targetPaths.rootDir, cliCommon.targetPaths.dir);
+    const mainPluginEmbeddedDir = node_path.resolve(embeddedDir, mainPluginRelDir);
+    console.log(
+      chalk__default.default.blue(
+        `Moving main plugin ${chalk__default.default.cyan(pkg.name)} to bundle root...`
+      )
+    );
+    if (!await fs__default.default.pathExists(mainPluginEmbeddedDir)) {
+      throw new Error(
+        `Main plugin ${chalk__default.default.cyan(pkg.name)} was not found in the embedded workspace at ${chalk__default.default.cyan(mainPluginRelDir)}. Ensure the pre-packed workspace includes this plugin.`
+      );
+    }
+    const mainPluginEntries = await fs__default.default.readdir(mainPluginEmbeddedDir);
+    for (const entry of mainPluginEntries) {
+      await fs__default.default.move(
+        node_path.join(mainPluginEmbeddedDir, entry),
+        node_path.join(target, entry),
+        { overwrite: true }
+      );
+    }
+    await fs__default.default.remove(mainPluginEmbeddedDir);
+    if (pluginType === "frontend") {
+      const sourceDist = node_path.resolve(cliCommon.targetPaths.dir, "dist");
+      if (await fs__default.default.pathExists(sourceDist)) {
+        await fs__default.default.copy(sourceDist, node_path.join(target, "dist"), {
+          overwrite: true
+        });
+      }
+    }
+    const localDeps = targets.filter((t) => t.name !== pkg.name);
+    for (const dep of localDeps) {
+      const depRelDir = node_path.relative(cliCommon.targetPaths.rootDir, dep.dir);
+      const depEmbeddedDir = node_path.resolve(embeddedDir, depRelDir);
+      if (!await fs__default.default.pathExists(depEmbeddedDir)) {
+        continue;
+      }
+      embeddedResolutions[dep.name] = `file:./embedded/${depRelDir}`;
+    }
+    if (Object.keys(embeddedResolutions).length === 0) {
+      await fs__default.default.remove(embeddedDir);
+    }
+  } else {
+    console.log(chalk__default.default.blue(`Packing main plugin ${chalk__default.default.cyan(pkg.name)}...`));
+    const distLog = createStepLogger(
+      node_path.join(target, "dist-workspace.log"),
+      opts.verbose
+    );
+    try {
+      await createDistWorkspace.packToDirectory({
+        packageDir: cliCommon.targetPaths.dir,
+        packageName: pkg.name,
+        targetDir: target,
+        logger: distLog.logger
+      });
+    } catch (err) {
+      await distLog.close();
+      await showLogOnError(distLog.path, opts.verbose);
+      throw err;
+    }
+    await distLog.close();
+    await fs__default.default.remove(distLog.path);
+  }
+  for (const dir of bundleOutputDirs) {
+    const nestedPath = node_path.join(target, dir);
+    if (await fs__default.default.pathExists(nestedPath)) {
+      await fs__default.default.remove(nestedPath);
+    }
+  }
+  if (pluginType === "frontend") {
+    const srcExplicitlyIncluded = (pkg.files ?? []).some(
+      (f) => f === "src" || f.startsWith("src/")
+    );
+    if (!srcExplicitlyIncluded) {
+      const srcPath = node_path.join(target, "src");
+      if (await fs__default.default.pathExists(srcPath)) {
+        await fs__default.default.remove(srcPath);
+      }
+    }
+  }
+  console.log(chalk__default.default.blue("Filtering config schema..."));
+  const schemaPath = node_path.resolve(target, "dist", ".config-schema.json");
+  let schemas = [];
+  if (pluginType === "frontend" && await fs__default.default.pathExists(schemaPath)) {
+    const existing = await fs__default.default.readJson(schemaPath);
+    schemas = existing.schemas ?? [];
+  } else {
+    const configSchema = await configLoader.loadConfigSchema({
+      dependencies: [],
+      packagePaths: ["package.json"]
+    });
+    const serialized = configSchema.serialize();
+    schemas = serialized.schemas ?? [];
+  }
+  let schemaWritten = false;
+  if (schemas.length > 0) {
+    const filtered = filterBundleConfigSchemas(schemas, cliCommon.targetPaths.dir);
+    if (filtered.length > 0) {
+      await fs__default.default.ensureDir(node_path.resolve(target, "dist"));
+      await fs__default.default.writeJson(
+        schemaPath,
+        { backstageConfigSchemaVersion: 1, schemas: filtered },
+        { spaces: 2 }
+      );
+      schemaWritten = true;
+    } else {
+      console.log(
+        chalk__default.default.dim("  No config schemas found for this plugin bundle")
+      );
+    }
+  } else {
+    console.log(chalk__default.default.dim("  No config schemas found for this plugin bundle"));
+  }
+  console.log(
+    chalk__default.default.blue(
+      `Customizing ${chalk__default.default.cyan("package.json")} for dynamic loading...`
+    )
+  );
+  const targetPkgPath = node_path.resolve(target, "package.json");
+  const targetPkg = await fs__default.default.readJson(targetPkgPath);
+  postProcessBundlePackageJson(
+    targetPkg,
+    target,
+    pluginType,
+    needsDependencies ? rootPkg?.resolutions : void 0,
+    embeddedResolutions,
+    needsDependencies
+  );
+  if (schemaWritten) {
+    targetPkg.configSchema = "dist/.config-schema.json";
+  }
+  await fs__default.default.writeJson(targetPkgPath, targetPkg, { spaces: 2 });
+  if (needsDependencies) {
+    await seedBundleLockfile(target, cliCommon.targetPaths.dir, cliCommon.targetPaths.rootDir);
+    const sourceCacheFolder = await cliCommon.runOutput(
+      ["yarn", "config", "get", "cacheFolder"],
+      { cwd: cliCommon.targetPaths.rootDir }
+    );
+    await pruneBundleLockfile(target, opts.verbose, sourceCacheFolder);
+    if (pluginType === "backend") {
+      if (opts.install) {
+        await installBundleDependencies(target, opts.verbose);
+        const yarnDir = node_path.join(target, ".yarn");
+        if (await fs__default.default.pathExists(yarnDir)) {
+          await fs__default.default.remove(yarnDir);
+        }
+        console.log(chalk__default.default.blue("Validating plugin entry points..."));
+        const NodeModule = require("node:module");
+        const origResolveFilename = NodeModule._resolveFilename;
+        NodeModule._resolveFilename = (request, ...args) => {
+          if (request === `${targetPkg.name}/package.json`) {
+            return node_path.resolve(target, "package.json");
+          }
+          return origResolveFilename(request, ...args);
+        };
+        try {
+          const pluginRequire = node_module.createRequire(`${target}/package.json`);
+          const mainModule = pluginRequire(target);
+          const alphaPath = node_path.resolve(target, "alpha");
+          const alphaModule = await fs__default.default.pathExists(alphaPath) ? pluginRequire(alphaPath) : void 0;
+          const isBackendFeature = (v) => !!v && (typeof v === "object" || typeof v === "function") && v.$$type === "@backstage/BackendFeature";
+          const hasValidExport = [mainModule, alphaModule].filter(Boolean).some((m) => isBackendFeature(m?.default));
+          if (!hasValidExport) {
+            throw new Error(
+              `Backend plugin is not valid for dynamic loading: it must export a ${chalk__default.default.cyan(
+                "BackendFeature"
+              )} as default export`
+            );
+          }
+        } finally {
+          NodeModule._resolveFilename = origResolveFilename;
+        }
+      } else {
+        console.log(
+          chalk__default.default.yellow(
+            "Skipping dependency installation and validation. Run without --no-install to validate the bundle."
+          )
+        );
+      }
+    }
+  }
+  console.log(chalk__default.default.green(`Bundle created at ${chalk__default.default.cyan(target)}`));
+}
+function postProcessBundlePackageJson(targetPkg, targetDir, pluginType, rootResolutions, embeddedResolutions, needsDependencies) {
+  targetPkg.scripts = {};
+  targetPkg.devDependencies = {};
+  if (pluginType === "frontend") {
+    targetPkg.main = "./dist/remoteEntry.js";
+    const mfTypesIndex = node_path.resolve(
+      targetDir,
+      "dist",
+      "@mf-types",
+      "index.d.ts"
+    );
+    if (fs__default.default.pathExistsSync(mfTypesIndex)) {
+      targetPkg.types = "./dist/@mf-types/index.d.ts";
+    } else {
+      delete targetPkg.types;
+    }
+    delete targetPkg.exports;
+    delete targetPkg.module;
+    delete targetPkg.typesVersions;
+  } else if (pluginType === "backend") {
+    targetPkg.bundleDependencies = true;
+  }
+  if (needsDependencies) {
+    const patchVersionPattern = /^patch:.+@npm%3A([^#]+)#/;
+    const stripped = {};
+    if (rootResolutions) {
+      for (const [key, value] of Object.entries(rootResolutions)) {
+        if (typeof value !== "string") {
+          continue;
+        }
+        const patchMatch = value.match(patchVersionPattern);
+        stripped[key] = patchMatch ? patchMatch[1] : value;
+      }
+    }
+    targetPkg.resolutions = {
+      ...stripped,
+      ...targetPkg.resolutions,
+      ...embeddedResolutions
+    };
+  }
+}
+async function seedBundleLockfile(targetDir, pluginDir, monorepoRoot) {
+  let sourceYarnLock;
+  if (await fs__default.default.pathExists(node_path.join(pluginDir, "yarn.lock"))) {
+    sourceYarnLock = node_path.join(pluginDir, "yarn.lock");
+  } else if (await fs__default.default.pathExists(node_path.join(monorepoRoot, "yarn.lock"))) {
+    sourceYarnLock = node_path.join(monorepoRoot, "yarn.lock");
+  }
+  if (!sourceYarnLock) {
+    throw new Error(
+      `Could not find a ${chalk__default.default.cyan(
+        "yarn.lock"
+      )} file in either the plugin directory or the monorepo root (${chalk__default.default.cyan(
+        monorepoRoot
+      )})`
+    );
+  }
+  const isMonorepoLock = sourceYarnLock === node_path.join(monorepoRoot, "yarn.lock");
+  console.log(
+    chalk__default.default.blue(
+      `Seeding bundle ${chalk__default.default.cyan("yarn.lock")} from source plugin${isMonorepoLock ? " monorepo" : ""} lockfile...`
+    )
+  );
+  await fs__default.default.copyFile(sourceYarnLock, node_path.resolve(targetDir, "yarn.lock"));
+}
+async function pruneBundleLockfile(targetDir, verbose, sourceCacheFolder) {
+  console.log(
+    chalk__default.default.blue(
+      `Pruning bundle ${chalk__default.default.cyan(
+        "yarn.lock"
+      )} to remove unused dependencies...`
+    )
+  );
+  const pruneLog = createStepLogger(
+    node_path.join(targetDir, "lockfile-prune.log"),
+    verbose,
+    "[lockfile-prune] "
+  );
+  try {
+    await cliCommon.run(
+      ["yarn", "install", "--no-immutable", "--mode", "update-lockfile"],
+      {
+        cwd: targetDir,
+        env: {
+          YARN_ENABLE_GLOBAL_CACHE: "false",
+          YARN_ENABLE_NETWORK: "0",
+          YARN_ENABLE_MIRROR: "false",
+          YARN_CACHE_FOLDER: sourceCacheFolder
+        },
+        onStdout: pruneLog.logRunOutput("out"),
+        onStderr: pruneLog.logRunOutput("err")
+      }
+    ).waitForExit();
+  } catch (err) {
+    await pruneLog.close();
+    await showLogOnError(pruneLog.path, verbose);
+    throw err;
+  }
+  await pruneLog.close();
+  await fs__default.default.remove(pruneLog.path);
+}
+async function installBundleDependencies(targetDir, verbose) {
+  console.log(chalk__default.default.blue("Installing private dependencies..."));
+  const installLog = createStepLogger(
+    node_path.join(targetDir, "yarn-install.log"),
+    verbose,
+    "[yarn-install] "
+  );
+  try {
+    await cliCommon.run(["yarn", "install", "--immutable"], {
+      cwd: targetDir,
+      onStdout: installLog.logRunOutput("out"),
+      onStderr: installLog.logRunOutput("err")
+    }).waitForExit();
+  } catch (err) {
+    await installLog.close();
+    await showLogOnError(installLog.path, verbose);
+    throw err;
+  }
+  await installLog.close();
+  await fs__default.default.remove(installLog.path);
+}
+function filterBundleConfigSchemas(schemas, pluginDir) {
+  const PLUGIN_OR_MODULE_ROLES = /* @__PURE__ */ new Set([
+    "backend-plugin",
+    "backend-plugin-module",
+    "frontend-plugin",
+    "frontend-plugin-module"
+  ]);
+  const LIBRARY_ROLES = /* @__PURE__ */ new Set([
+    "node-library",
+    "common-library",
+    "web-library"
+  ]);
+  const allowed = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const localRequire = node_module.createRequire(node_path.resolve(pluginDir, "package.json"));
+  function walk(pkg) {
+    if (visited.has(pkg.name)) {
+      return;
+    }
+    visited.add(pkg.name);
+    allowed.add(pkg.name);
+    const pluginId = pkg.backstage?.pluginId;
+    for (const depName of Object.keys(pkg.dependencies ?? {})) {
+      let depPkgPath;
+      try {
+        depPkgPath = localRequire.resolve(`${depName}/package.json`);
+      } catch {
+        continue;
+      }
+      let depPkg;
+      try {
+        depPkg = fs__default.default.readJsonSync(depPkgPath);
+      } catch {
+        continue;
+      }
+      const depRole = depPkg.backstage?.role;
+      if (!depPkg.backstage) {
+        allowed.add(depName);
+        continue;
+      }
+      if (depRole && PLUGIN_OR_MODULE_ROLES.has(depRole)) {
+        walk(depPkg);
+        continue;
+      }
+      if (depRole && LIBRARY_ROLES.has(depRole) && pluginId && depPkg.backstage?.pluginId === pluginId) {
+        allowed.add(depName);
+        continue;
+      }
+    }
+  }
+  let rootPkg;
+  try {
+    rootPkg = fs__default.default.readJsonSync(node_path.resolve(pluginDir, "package.json"));
+  } catch {
+    return [];
+  }
+  walk(rootPkg);
+  return schemas.filter((s) => allowed.has(s.packageName));
+}
+const ansiPattern = (
+  // eslint-disable-next-line no-control-regex
+  /[\x1b\x9b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><~]|\x1b]8;;[^\x07\x1b]*(?:\x07|\x1b\\)/g
+);
+function stripAnsi(str) {
+  return str.replace(ansiPattern, "");
+}
+function createStepLogger(logFilePath, verbose, prefix) {
+  const logStream = fs__default.default.createWriteStream(logFilePath);
+  const writeLine = (line, stream) => {
+    const prefixed = prefix ? `${prefix}${line}` : line;
+    logStream.write(
+      `${stream === "err" ? "[WARN] " : ""}${stripAnsi(prefixed)}
+`
+    );
+    if (verbose) {
+      const writer = stream === "err" ? console.warn : console.log;
+      writer(chalk__default.default.dim(prefixed));
+    }
+  };
+  const logger = {
+    log(msg) {
+      writeLine(msg, "out");
+    },
+    warn(msg) {
+      writeLine(msg, "err");
+    }
+  };
+  const logRunOutput = (stream) => (data) => {
+    if (prefix) {
+      for (const line of data.toString("utf8").split(/\r?\n/)) {
+        if (line) writeLine(line, stream);
+      }
+    } else {
+      logStream.write(
+        `${stream === "err" ? "[WARN] " : ""}${stripAnsi(
+          data.toString("utf8")
+        )}`
+      );
+      if (verbose) {
+        const writer = stream === "err" ? console.warn : console.log;
+        writer(chalk__default.default.dim(data.toString("utf8")));
+      }
+    }
+  };
+  const close = () => new Promise((r) => logStream.end(r));
+  return { logger, logRunOutput, close, path: logFilePath };
+}
+async function showLogOnError(logFilePath, verbose) {
+  console.error(
+    chalk__default.default.red(`
+Full log available at: ${chalk__default.default.cyan(logFilePath)}`)
+  );
+  if (!verbose) {
+    try {
+      const content = await fs__default.default.readFile(logFilePath, "utf8");
+      const tail = content.split("\n").slice(-20).join("\n");
+      if (tail) {
+        console.error(chalk__default.default.dim("\n--- last 20 lines ---"));
+        console.error(tail);
+      }
+    } catch {
+    }
+  }
+}
+var command = async ({ args, info }) => {
+  const {
+    flags: {
+      outputDestination,
+      outputName,
+      clean,
+      noBuild,
+      noInstall,
+      verbose,
+      prePackedDir
+    }
+  } = cleye.cli(
+    {
+      help: info,
+      flags: {
+        outputDestination: {
+          type: String,
+          description: "Directory in which the bundle subdirectory is created. Defaults to the current package directory."
+        },
+        outputName: {
+          type: String,
+          description: 'Name of the bundle subdirectory. Defaults to "bundle" when output stays in the package directory, or to the mangled package name (e.g. myorg-plugin-foo) when --output-destination is specified.'
+        },
+        clean: {
+          type: Boolean,
+          description: "Clean the output directory before bundling"
+        },
+        noBuild: {
+          type: Boolean,
+          description: "Skip building packages (assumes they are already built)"
+        },
+        noInstall: {
+          type: Boolean,
+          description: "Skip dependency installation and entrypoint validation."
+        },
+        verbose: {
+          type: Boolean,
+          description: "Stream detailed output from internal steps (build, pack, install) to the console. Without this flag, output is captured to per-step log files and only shown on error."
+        },
+        prePackedDir: {
+          type: String,
+          description: "Path to a pre-built dist workspace (from build-workspace --alwaysPack). Skips local dependency packing and uses pre-packed packages directly. For frontend plugins, this also enables yarn.lock generation for SBOM."
+        }
+      }
+    },
+    void 0,
+    args
+  );
+  return bundleCommand({
+    build: !noBuild,
+    install: !noInstall,
+    clean: Boolean(clean),
+    verbose: Boolean(verbose),
+    outputDestination: outputDestination ?? void 0,
+    outputName: outputName ?? void 0,
+    prePackedDir: prePackedDir ?? void 0
+  });
+};
+
+exports.bundleCommand = bundleCommand;
+exports.default = command;
+exports.filterBundleConfigSchemas = filterBundleConfigSchemas;
+exports.postProcessBundlePackageJson = postProcessBundlePackageJson;
+//# sourceMappingURL=command.cjs.js.map