@backstage/cli 0.36.0-next.2 → 0.36.0

package/config/webpack-public-path.js

@@ -14,18 +14,14 @@
  * limitations under the License.
  */
 
-// This script is used to pick up and set the public path of the Webpack bundle
-// at runtime. The meta tag is injected by the app build, but only present in
-// the `index.html.tmpl` file. The runtime value of the meta tag is populated by
-// the app backend, when it templates the final `index.html` file.
-//
-// This is needed for additional chunks to use the correct public path, and it
-// is not possible to set the `__webpack_public_path__` variable outside of the
-// build itself. The Webpack output also does not read any <base> tags or
-// similar, this seems to be the only way to dynamically configure the public
-// path at runtime.
-const el = document.querySelector('meta[name="backstage-public-path"]');
-const path = el?.getAttribute('content');
-if (path) {
-  __webpack_public_path__ = path;
+try {
+  require('@backstage/cli-module-build/config/webpack-public-path');
+} catch (e) {
+  if (e.code === 'MODULE_NOT_FOUND') {
+    throw new Error(
+      '@backstage/cli-module-build is required to use the webpack public path configuration. ' +
+        'Please install it as a dependency.',
+    );
+  }
+  throw e;
 }

package/dist/cli-internal/src/InternalCliModule.cjs.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var OpaqueType = require('../../opaque-internal/src/OpaqueType.cjs.js');
+
+const OpaqueCliModule = OpaqueType.OpaqueType.create({
+  type: "@backstage/CliModule",
+  versions: ["v1"]
+});
+
+exports.OpaqueCliModule = OpaqueCliModule;
+//# sourceMappingURL=InternalCliModule.cjs.js.map

package/dist/cli-internal/src/InternalCommandNode.cjs.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var OpaqueType = require('../../opaque-internal/src/OpaqueType.cjs.js');
+
+const OpaqueCommandTreeNode = OpaqueType.OpaqueType.create({
+  type: "@backstage/CommandTreeNode",
+  versions: ["v1"]
+});
+const OpaqueCommandLeafNode = OpaqueType.OpaqueType.create({
+  type: "@backstage/CommandLeafNode",
+  versions: ["v1"]
+});
+function isCommandNodeHidden(node) {
+  if (OpaqueCommandLeafNode.isType(node)) {
+    const { command } = OpaqueCommandLeafNode.toInternal(node);
+    return !!command.deprecated || !!command.experimental;
+  }
+  const { children } = OpaqueCommandTreeNode.toInternal(node);
+  return children.every((child) => isCommandNodeHidden(child));
+}
+
+exports.OpaqueCommandLeafNode = OpaqueCommandLeafNode;
+exports.OpaqueCommandTreeNode = OpaqueCommandTreeNode;
+exports.isCommandNodeHidden = isCommandNodeHidden;
+//# sourceMappingURL=InternalCommandNode.cjs.js.map

package/dist/cli-internal/src/knownPluginPackages.cjs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const knownBackendPluginIds = [
+  "app",
+  "auth",
+  "catalog",
+  "events",
+  "kubernetes",
+  "notifications",
+  "permission",
+  "proxy",
+  "scaffolder",
+  "search",
+  "signals",
+  "techdocs"
+];
+const knownFrontendPluginIds = [
+  "app",
+  "auth",
+  "catalog",
+  "kubernetes",
+  "notifications",
+  "scaffolder",
+  "search",
+  "signals",
+  "techdocs"
+];
+Object.fromEntries(
+  knownBackendPluginIds.map((pluginId) => [
+    pluginId,
+    `@backstage/plugin-${pluginId}-backend`
+  ])
+);
+Object.fromEntries(
+  knownFrontendPluginIds.map((pluginId) => [
+    pluginId,
+    `@backstage/plugin-${pluginId}`
+  ])
+);
+//# sourceMappingURL=knownPluginPackages.cjs.js.map

package/dist/index.cjs.js

@@ -1,20 +1,30 @@
 'use strict';
 
+var chalk = require('chalk');
 var CliInitializer = require('./wiring/CliInitializer.cjs.js');
+var discoverCliModules = require('./wiring/discoverCliModules.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
 
 (async () => {
   const initializer = new CliInitializer.CliInitializer();
-  initializer.add(import('./modules/build/index.cjs.js'));
-  initializer.add(import('./modules/config/index.cjs.js'));
-  initializer.add(import('./modules/create-github-app/index.cjs.js'));
-  initializer.add(import('./modules/info/index.cjs.js'));
-  initializer.add(import('./modules/lint/index.cjs.js'));
-  initializer.add(import('./modules/maintenance/index.cjs.js'));
-  initializer.add(import('./modules/migrate/index.cjs.js'));
-  initializer.add(import('./modules/new/index.cjs.js'));
-  initializer.add(import('./modules/test/index.cjs.js'));
-  initializer.add(import('./modules/translations/index.cjs.js'));
-  initializer.add(import('./modules/auth/index.cjs.js'));
+  const discoveredModules = discoverCliModules.discoverCliModules();
+  if (discoveredModules.length > 0) {
+    for (const resolvedPath of discoveredModules) {
+      initializer.add(import(resolvedPath));
+    }
+  } else {
+    console.error(
+      chalk__default.default.yellow(
+        `No CLI modules found in the project root dependencies. Falling back to the built-in set of modules.
+This fallback will be removed in a future release. Please add @backstage/cli-defaults as a devDependency in your root package.json, or install individual @backstage/cli-module-* packages for fine-grained control.
+`
+      )
+    );
+    initializer.add(import('@backstage/cli-defaults'));
+  }
   await initializer.run();
 })();
 //# sourceMappingURL=index.cjs.js.map

package/dist/wiring/CliInitializer.cjs.js

@@ -1,8 +1,12 @@
 'use strict';
 
 var CommandGraph = require('./CommandGraph.cjs.js');
-var types$1 = require('./types.cjs.js');
-var CommandRegistry = require('./CommandRegistry.cjs.js');
+var InternalCliModule = require('../cli-internal/src/InternalCliModule.cjs.js');
+var InternalCommandNode = require('../cli-internal/src/InternalCommandNode.cjs.js');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('../cli-internal/src/knownPluginPackages.cjs.js');
 var commander = require('commander');
 var version = require('./version.cjs.js');
 var chalk = require('chalk');
@@ -14,36 +18,58 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
 
-function isNodeHidden(node) {
-  if (node.$$type === "@tree/leaf") {
-    return !!node.command.deprecated || !!node.command.experimental;
-  }
-  return node.children.every((child) => isNodeHidden(child));
-}
 class CliInitializer {
   graph = new CommandGraph.CommandGraph();
-  commandRegistry = new CommandRegistry.CommandRegistry(this.graph);
   #uninitiazedFeatures = [];
   add(feature) {
     if (types.isPromise(feature)) {
       this.#uninitiazedFeatures.push(
-        feature.then((f) => unwrapFeature(f.default))
+        feature.then((f) => {
+          const unwrapped = unwrapFeature(f.default);
+          if (Array.isArray(unwrapped)) {
+            return unwrapped.map((m) => ({ feature: m, fromArray: true }));
+          }
+          return [{ feature: unwrapped, fromArray: false }];
+        })
+      );
+    } else if (Array.isArray(feature)) {
+      this.#uninitiazedFeatures.push(
+        Promise.resolve(feature.map((m) => ({ feature: m, fromArray: true })))
       );
     } else {
-      this.#uninitiazedFeatures.push(Promise.resolve(feature));
+      this.#uninitiazedFeatures.push(
+        Promise.resolve([{ feature, fromArray: false }])
+      );
     }
   }
   async #register(feature) {
-    if (types$1.OpaqueCliPlugin.isType(feature)) {
-      const internal = types$1.OpaqueCliPlugin.toInternal(feature);
-      await internal.init(this.commandRegistry);
+    if (InternalCliModule.OpaqueCliModule.isType(feature)) {
+      for (const command of await InternalCliModule.OpaqueCliModule.toInternal(feature).commands) {
+        this.graph.add(command, feature);
+      }
     } else {
       throw new Error(`Unsupported feature type: ${feature.$$type}`);
     }
   }
   async #doInit() {
-    const features = await Promise.all(this.#uninitiazedFeatures);
-    for (const feature of features) {
+    const resolvedGroups = await Promise.all(this.#uninitiazedFeatures);
+    const allFeatures = resolvedGroups.flat();
+    const individualPaths = /* @__PURE__ */ new Set();
+    for (const { feature, fromArray } of allFeatures) {
+      if (!fromArray && InternalCliModule.OpaqueCliModule.isType(feature)) {
+        const cmds = await InternalCliModule.OpaqueCliModule.toInternal(feature).commands;
+        for (const cmd of cmds) {
+          individualPaths.add(cmd.path.join(" "));
+        }
+      }
+    }
+    for (const { feature, fromArray } of allFeatures) {
+      if (fromArray && InternalCliModule.OpaqueCliModule.isType(feature)) {
+        const cmds = await InternalCliModule.OpaqueCliModule.toInternal(feature).commands;
+        if (cmds.some((cmd) => individualPaths.has(cmd.path.join(" ")))) {
+          continue;
+        }
+      }
       await this.#register(feature);
     }
   }
@@ -61,27 +87,29 @@ class CliInitializer {
     }));
     while (queue.length) {
       const { node, argParser } = queue.shift();
-      if (node.$$type === "@tree/root") {
-        const treeParser = argParser.command(`${node.name} [command]`, {
-          hidden: isNodeHidden(node)
-        }).description(node.name);
+      if (InternalCommandNode.OpaqueCommandTreeNode.isType(node)) {
+        const internal = InternalCommandNode.OpaqueCommandTreeNode.toInternal(node);
+        const treeParser = argParser.command(`${internal.name} [command]`, {
+          hidden: InternalCommandNode.isCommandNodeHidden(node)
+        }).description(internal.name);
         queue.push(
-          ...node.children.map((child) => ({
+          ...internal.children.map((child) => ({
             node: child,
             argParser: treeParser
           }))
         );
       } else {
-        argParser.command(node.name, {
-          hidden: !!node.command.deprecated || !!node.command.experimental
-        }).description(node.command.description).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).action(async () => {
+        const internal = InternalCommandNode.OpaqueCommandLeafNode.toInternal(node);
+        argParser.command(internal.name, {
+          hidden: !!internal.command.deprecated || !!internal.command.experimental
+        }).description(internal.command.description).helpOption(false).allowUnknownOption(true).allowExcessArguments(true).action(async () => {
           try {
             const args = program.parseOptions(process.argv);
             const nonProcessArgs = args.operands.slice(2);
             const positionalArgs = [];
             let index = 0;
             for (let argIndex = 0; argIndex < nonProcessArgs.length; argIndex++) {
-              if (argIndex === index && node.command.path[argIndex] === nonProcessArgs[argIndex]) {
+              if (argIndex === index && internal.command.path[argIndex] === nonProcessArgs[argIndex]) {
                 index += 1;
                 continue;
               }
@@ -90,14 +118,14 @@ class CliInitializer {
             const context = {
               args: [...positionalArgs, ...args.unknown],
               info: {
-                usage: [programName, ...node.command.path].join(" "),
-                description: node.command.description
+                usage: [programName, ...internal.command.path].join(" "),
+                name: internal.command.path.join(" ")
               }
             };
-            if (typeof node.command.execute === "function") {
-              await node.command.execute(context);
+            if (typeof internal.command.execute === "function") {
+              await internal.command.execute(context);
             } else {
-              const mod = await node.command.execute.loader();
+              const mod = await internal.command.execute.loader();
               const fn = typeof mod.default === "function" ? mod.default : mod.default.default;
               await fn(context);
             }
@@ -122,6 +150,9 @@ class CliInitializer {
   }
 }
 function unwrapFeature(feature) {
+  if (Array.isArray(feature)) {
+    return feature;
+  }
   if ("$$type" in feature) {
     return feature;
   }

package/dist/wiring/CommandGraph.cjs.js

@@ -1,38 +1,66 @@
 'use strict';
 
+var InternalCliModule = require('../cli-internal/src/InternalCliModule.cjs.js');
+var InternalCommandNode = require('../cli-internal/src/InternalCommandNode.cjs.js');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('../cli-internal/src/knownPluginPackages.cjs.js');
+
 class CommandGraph {
   graph = [];
   /**
    * Adds a command to the graph. The graph is sparse, so we use the path to determine the nodes
    *    to traverse. Only leaf nodes should have a command/action.
    */
-  add(command) {
+  add(command, module) {
     const path = command.path;
     let current = this.graph;
     for (let i = 0; i < path.length - 1; i++) {
       const name = path[i];
-      let next = current.find((n) => n.name === name);
+      let next = current.find(
+        (n) => InternalCommandNode.OpaqueCommandTreeNode.isType(n) && InternalCommandNode.OpaqueCommandTreeNode.toInternal(n).name === name || InternalCommandNode.OpaqueCommandLeafNode.isType(n) && InternalCommandNode.OpaqueCommandLeafNode.toInternal(n).name === name
+      );
       if (!next) {
-        next = { $$type: "@tree/root", name, children: [] };
+        next = InternalCommandNode.OpaqueCommandTreeNode.createInstance("v1", {
+          name,
+          children: []
+        });
         current.push(next);
-      } else if (next.$$type === "@tree/leaf") {
+      } else if (InternalCommandNode.OpaqueCommandLeafNode.isType(next)) {
         throw new Error(
-          `Command already exists at path: "${path.slice(0, i).join(" ")}"`
+          formatConflictError(
+            path,
+            module,
+            InternalCommandNode.OpaqueCommandLeafNode.toInternal(next).module
+          )
         );
       }
-      current = next.children;
+      current = InternalCommandNode.OpaqueCommandTreeNode.toInternal(next).children;
     }
-    const last = current.find((n) => n.name === path[path.length - 1]);
-    if (last && last.$$type === "@tree/leaf") {
+    const lastName = path[path.length - 1];
+    const last = current.find((n) => {
+      if (InternalCommandNode.OpaqueCommandTreeNode.isType(n)) {
+        return InternalCommandNode.OpaqueCommandTreeNode.toInternal(n).name === lastName;
+      }
+      return InternalCommandNode.OpaqueCommandLeafNode.toInternal(n).name === lastName;
+    });
+    if (last && InternalCommandNode.OpaqueCommandLeafNode.isType(last)) {
       throw new Error(
-        `Command already exists at path: "${path.slice(0, -1).join(" ")}"`
+        formatConflictError(
+          path,
+          module,
+          InternalCommandNode.OpaqueCommandLeafNode.toInternal(last).module
+        )
       );
     } else {
-      current.push({
-        $$type: "@tree/leaf",
-        name: path[path.length - 1],
-        command
-      });
+      current.push(
+        InternalCommandNode.OpaqueCommandLeafNode.createInstance("v1", {
+          name: lastName,
+          command,
+          module
+        })
+      );
     }
   }
   /**
@@ -42,30 +70,60 @@ class CommandGraph {
     let current = this.graph;
     for (let i = 0; i < path.length - 1; i++) {
       const name = path[i];
-      const next = current.find((n) => n.name === name);
-      if (!next) {
-        return void 0;
-      } else if (next.$$type === "@tree/leaf") {
+      const next = current.find((n) => {
+        if (InternalCommandNode.OpaqueCommandTreeNode.isType(n)) {
+          return InternalCommandNode.OpaqueCommandTreeNode.toInternal(n).name === name;
+        }
+        return InternalCommandNode.OpaqueCommandLeafNode.toInternal(n).name === name;
+      });
+      if (!next || InternalCommandNode.OpaqueCommandLeafNode.isType(next)) {
         return void 0;
       }
-      current = next.children;
+      current = InternalCommandNode.OpaqueCommandTreeNode.toInternal(next).children;
     }
-    const last = current.find((n) => n.name === path[path.length - 1]);
-    if (!last || last.$$type === "@tree/root") {
+    const lastName = path[path.length - 1];
+    const last = current.find((n) => {
+      if (InternalCommandNode.OpaqueCommandTreeNode.isType(n)) {
+        return InternalCommandNode.OpaqueCommandTreeNode.toInternal(n).name === lastName;
+      }
+      return InternalCommandNode.OpaqueCommandLeafNode.toInternal(n).name === lastName;
+    });
+    if (!last || InternalCommandNode.OpaqueCommandTreeNode.isType(last)) {
       return void 0;
     }
-    return last?.command;
+    return InternalCommandNode.OpaqueCommandLeafNode.toInternal(last).command;
   }
   atDepth(depth) {
     let current = this.graph;
     for (let i = 0; i < depth; i++) {
       current = current.flatMap(
-        (n) => n.$$type === "@tree/root" ? n.children : []
+        (n) => InternalCommandNode.OpaqueCommandTreeNode.isType(n) ? InternalCommandNode.OpaqueCommandTreeNode.toInternal(n).children : []
       );
     }
     return current;
   }
 }
+function getModuleName(module) {
+  if (module && InternalCliModule.OpaqueCliModule.isType(module)) {
+    return InternalCliModule.OpaqueCliModule.toInternal(module).packageName;
+  }
+  return void 0;
+}
+function formatConflictError(path, newModule, existingModule) {
+  const cmd = path.join(" ");
+  const newPkg = getModuleName(newModule);
+  const existingPkg = getModuleName(existingModule);
+  if (newPkg && existingPkg) {
+    return `Command "${cmd}" from "${newPkg}" conflicts with an existing command from "${existingPkg}"`;
+  }
+  if (newPkg) {
+    return `Command "${cmd}" from "${newPkg}" conflicts with an existing command`;
+  }
+  if (existingPkg) {
+    return `Command "${cmd}" conflicts with an existing command from "${existingPkg}"`;
+  }
+  return `Command "${cmd}" conflicts with an existing command`;
+}
 
 exports.CommandGraph = CommandGraph;
 //# sourceMappingURL=CommandGraph.cjs.js.map

package/dist/wiring/discoverCliModules.cjs.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var cliCommon = require('@backstage/cli-common');
+var cliNode = require('@backstage/cli-node');
+var fs = require('node:fs');
+var path = require('node:path');
+var node_url = require('node:url');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function discoverCliModules() {
+  const rootDir = cliCommon.targetPaths.rootDir;
+  const pkgJsonPath = path.resolve(rootDir, "package.json");
+  let projectPkg;
+  try {
+    projectPkg = JSON.parse(fs__default.default.readFileSync(pkgJsonPath, "utf8"));
+  } catch {
+    return [];
+  }
+  const allDeps = {
+    ...projectPkg.dependencies,
+    ...projectPkg.devDependencies
+  };
+  const modules = [];
+  for (const depName of Object.keys(allDeps)) {
+    try {
+      const depPkgPath = require.resolve(`${depName}/package.json`, {
+        paths: [rootDir]
+      });
+      const depPkg = JSON.parse(fs__default.default.readFileSync(depPkgPath, "utf8"));
+      if (cliNode.PackageRoles.getRoleFromPackage(depPkg) === "cli-module") {
+        const resolvedPath = require.resolve(depName, { paths: [rootDir] });
+        modules.push(node_url.pathToFileURL(resolvedPath).href);
+      }
+    } catch {
+    }
+  }
+  return modules;
+}
+
+exports.discoverCliModules = discoverCliModules;
+//# sourceMappingURL=discoverCliModules.cjs.js.map