@red-hat-developer-hub/extensions-cli 0.14.0

package/CHANGELOG.md

@@ -0,0 +1,255 @@
+# @red-hat-developer-hub/extensions-cli
+
+## 0.14.0
+
+### Minor Changes
+
+- 4fafdf3: Renamed plugins from marketplace to extensions
+
+  - Renamed all packages from `backstage-plugin-marketplace-*` to `backstage-plugin-extensions-*`
+  - Updated all internal references, exports, and API endpoints
+  - lazy load codeEditor to reduce the frontend plugin bundle size
+  - Made catalog entities directory path configurable via `extensions.directory` in app-config.yaml with fallback to `extensions` and `marketplace` directories
+
+### Patch Changes
+
+- Updated dependencies [4fafdf3]
+  - @red-hat-developer-hub/backstage-plugin-extensions-common@0.14.0
+
+## 0.13.2
+
+### Patch Changes
+
+- @red-hat-developer-hub/backstage-plugin-marketplace-common@0.13.2
+
+## 0.13.1
+
+### Patch Changes
+
+- @red-hat-developer-hub/backstage-plugin-marketplace-common@0.13.1
+
+## 0.13.0
+
+### Minor Changes
+
+- bee615a: Backstage version bump to v1.45.2
+
+### Patch Changes
+
+- Updated dependencies [bee615a]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.13.0
+
+## 0.12.2
+
+### Patch Changes
+
+- @red-hat-developer-hub/backstage-plugin-marketplace-common@0.12.2
+
+## 0.12.1
+
+### Patch Changes
+
+- @red-hat-developer-hub/backstage-plugin-marketplace-common@0.12.1
+
+## 0.12.0
+
+### Minor Changes
+
+- f8e6f04: Backstage version bump to v1.44.1
+
+### Patch Changes
+
+- Updated dependencies [f8e6f04]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.12.0
+
+## 0.6.1
+
+### Patch Changes
+
+- Updated dependencies [4d79286]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.10.1
+
+## 0.6.0
+
+### Minor Changes
+
+- b33db25: Backstage version bump to v1.42.5
+
+### Patch Changes
+
+- Updated dependencies [b33db25]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.10.0
+
+## 0.5.1
+
+### Patch Changes
+
+- Updated dependencies [fdda9a1]
+- Updated dependencies [cbe1174]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.9.0
+
+## 0.5.0
+
+### Minor Changes
+
+- 8887468: Backstage version bump to v1.41.1
+
+### Patch Changes
+
+- Updated dependencies [8887468]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.8.0
+
+## 0.4.10
+
+### Patch Changes
+
+- Updated dependencies [171b7fd]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.7.2
+
+## 0.4.9
+
+### Patch Changes
+
+- Updated dependencies [fb23720]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.7.1
+
+## 0.4.8
+
+### Patch Changes
+
+- Updated dependencies [f70ccb1]
+- Updated dependencies [7aac60c]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.7.0
+
+## 0.4.7
+
+### Patch Changes
+
+- ca2e330: Bump to backstage version 1.39.1
+- 58ae1fe: Added an alert for production environment
+  Integrated the fetch configuration and install API calls
+  Fixed an import error
+- Updated dependencies [ca2e330]
+- Updated dependencies [3973839]
+- Updated dependencies [58ae1fe]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.6.0
+
+## 0.4.6
+
+### Patch Changes
+
+- Updated dependencies [7ae0ca0]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.5.0
+
+## 0.4.5
+
+### Patch Changes
+
+- Updated dependencies [4413eef]
+- Updated dependencies [7d138e5]
+- Updated dependencies [f56908a]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.4.0
+
+## 0.4.4
+
+### Patch Changes
+
+- dd94b9d: use namespace parameter also for packages location
+
+## 0.4.3
+
+### Patch Changes
+
+- e5e4655: use new Backstage `lazy` loading function
+
+## 0.4.2
+
+### Patch Changes
+
+- 7517e3b: (export-csv) Always escape newlines in each CSV cell and add more columns
+
+## 0.4.1
+
+### Patch Changes
+
+- 5a99fdd: use CJS imports instead of ESM to fix double-encapsulation import issue
+
+## 0.4.0
+
+### Minor Changes
+
+- 6501387: Backstage version bump to v1.36.1
+
+### Patch Changes
+
+- Updated dependencies [6501387]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.3.0
+
+## 0.3.0
+
+### Minor Changes
+
+- efc1592: add new marketplace-cli init command
+- a4b60fd: Added a new command: `export-csv`, which generates a CSV file given a folder of plugin YAML files
+
+## 0.2.0
+
+### Minor Changes
+
+- d3bcc76: rename apiVersion and annotations to extensions.backstage.io
+
+### Patch Changes
+
+- Updated dependencies [d3bcc76]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.2.0
+
+## 0.1.2
+
+### Patch Changes
+
+- a7e38a9: remove core-plugin-api dependency from common
+- Updated dependencies [a7e38a9]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.1.2
+
+## 0.1.1
+
+### Patch Changes
+
+- fa70a22: remove unused knex and zod dependency from common package
+- Updated dependencies [fa70a22]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.1.1
+
+## 0.1.0
+
+### Minor Changes
+
+- d39d4e3: Initial tech-preview of the marketplace
+
+### Patch Changes
+
+- f16dd69: Refactore and update API, UI, and catalog types
+- Updated dependencies [d39d4e3]
+- Updated dependencies [f16dd69]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.1.0
+
+## 0.0.3
+
+### Patch Changes
+
+- Updated dependencies [f310add]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.0.9
+
+## 0.0.2
+
+### Patch Changes
+
+- Updated dependencies [4e0ec06]
+  - @red-hat-developer-hub/backstage-plugin-marketplace-common@0.0.8
+
+## 0.0.1
+
+### Patch Changes
+
+- 3c12103: Added new `marketplace-cli` and implement `generate` command.
+
+  This command generates Plugin entities based on the information from the [dynamic-plugins.default.yaml](https://github.com/redhat-developer/rhdh/blob/main/dynamic-plugins.default.yaml) and wrapper's `package.json`. It assumes that all `packages` in the config files are wrappers.

package/bin/extensions-cli

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/*
+ * Copyright The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const path = require('path');
+
+// Figure out whether we're running inside the backstage repo or as an installed dependency
+/* eslint-disable-next-line no-restricted-syntax */
+const isLocal = require('fs').existsSync(path.resolve(__dirname, '../src'));
+
+if (!isLocal) {
+  require('..');
+} else {
+  require('@backstage/cli/config/nodeTransform.cjs');
+  require('../src');
+}

package/dist/commands/export-csv/index.cjs.js

@@ -0,0 +1,165 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var chalk = require('chalk');
+var backstagePluginExtensionsCommon = require('@red-hat-developer-hub/backstage-plugin-extensions-common');
+var fs = require('fs-extra');
+var path = require('path');
+var yaml = require('yaml');
+var glob = require('glob');
+
+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);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var yaml__default = /*#__PURE__*/_interopDefaultCompat(yaml);
+var glob__default = /*#__PURE__*/_interopDefaultCompat(glob);
+
+class CSVGenerator {
+  /** The columns to be included in the CSV. */
+  columns;
+  /** The rows to be included in the CSV */
+  rows;
+  constructor(columns, rows = []) {
+    this.columns = columns;
+    this.rows = rows;
+  }
+  /** Escape problematic characters in a CSV cell */
+  static escapeCSVCell = (cell) => {
+    const removedNewLines = cell.replace(/\n/g, "\\n");
+    const regex = /[\s,"]/;
+    if (regex.exec(removedNewLines.replace(/ /g, ""))) {
+      return `"${removedNewLines.replace(/"/g, '""')}"`;
+    }
+    return removedNewLines;
+  };
+  /** Add a row to the CSV */
+  addRow(row) {
+    this.rows.push(row);
+  }
+  /**
+   * @param includeHeader Whether to include the header row in the CSV
+   * @returns A CSV generated from the rows and columns provided
+   */
+  generate(includeHeader = true) {
+    const header = Object.keys(this.columns).map((key) => CSVGenerator.escapeCSVCell(key)).join(",");
+    const rows = this.rows.map(
+      (row) => Object.values(this.columns).map((column) => CSVGenerator.escapeCSVCell(String(column(row) || ""))).join(",")
+    ).join("\n");
+    return includeHeader ? `${header}
+${rows}` : rows;
+  }
+}
+const isEntity = (entity) => {
+  return !!entity && typeof entity === "object" && "apiVersion" in entity && "kind" in entity;
+};
+const parseYamls = async (yamls, recurse = false) => {
+  return await Promise.all(
+    (yamls || []).flatMap((basePath) => {
+      return glob__default.default.sync(recurse ? "**/*.yaml" : "*.yaml", { cwd: basePath }).map(async (file) => {
+        const fileContent = await fs__default.default.readFile(
+          path__default.default.join(basePath, file),
+          "utf-8"
+        );
+        const plugins = yaml__default.default.parseAllDocuments(fileContent).map((doc) => doc.toJS()).filter(isEntity);
+        return plugins;
+      });
+    })
+  ).then((plugins) => plugins.flat());
+};
+const getPackagesOfType = (packages, allPackages, types) => {
+  return packages.map((name) => {
+    const pkg = allPackages[name];
+    if (!pkg) {
+      console.error(
+        chalk__default.default.red(`Package ${name} not found in the list of packages`)
+      );
+      return "";
+    }
+    const version = pkg.spec?.version ? `(${pkg.spec?.version})` : "(no version)";
+    if (types.includes(pkg?.spec?.backstage?.role || "")) {
+      return `${pkg.spec?.packageName} ${version}`;
+    }
+    return "";
+  }).filter(Boolean).join(", ");
+};
+var index = async ({
+  outputFile,
+  pluginsYamlPath,
+  recursive,
+  type
+}) => {
+  if (!pluginsYamlPath) {
+    console.error(
+      "No plugins path provided! Provide one using --plugins-yaml-path"
+    );
+    process.exit(1);
+  }
+  const yamls = parseYamls(pluginsYamlPath.split(","), recursive);
+  const packages = {};
+  const packageCSV = new CSVGenerator({
+    name: (yaml) => yaml?.metadata?.name,
+    title: (yaml) => yaml?.metadata?.title,
+    version: (yaml) => yaml?.spec?.version,
+    author: (yaml) => yaml?.spec?.developer || yaml?.spec?.author || yaml?.spec?.owner || (yaml?.spec?.authors || []).join(","),
+    lifecycle: (yaml) => yaml?.spec?.lifecycle,
+    packages: (yaml) => (yaml?.spec?.partOf || []).join(", "),
+    role: (yaml) => yaml?.spec?.role || yaml?.spec?.backstage?.role
+  });
+  const pluginCSV = new CSVGenerator({
+    name: (p) => p?.metadata?.name,
+    title: (p) => p?.metadata?.title,
+    author: (p) => p?.spec?.developer || p?.spec?.author || p?.spec?.owner || (p?.spec?.authors || [])?.map((a) => a.name).join(", "),
+    categories: (p) => (p?.spec?.categories || []).join(", "),
+    lifecycle: (p) => p?.spec?.lifecycle,
+    metadataDescription: (p) => p?.metadata?.description,
+    specDescription: (p) => p?.spec?.description,
+    support: (p) => p?.spec?.support,
+    publisher: (p) => p?.spec?.publisher,
+    highlights: (p) => (p?.spec?.highlights || []).join(", "),
+    "certified-by": (p) => p?.metadata?.annotations?.["extensions.backstage.io/certified-by"],
+    "verified-by": (p) => p?.metadata?.annotations?.["extensions.backstage.io/verified-by"],
+    "pre-installed": (p) => p?.metadata?.annotations?.["extensions.backstage.io/pre-installed"],
+    packages: (p) => (p?.spec?.packages || []).join(", "),
+    "backend packages": (p) => getPackagesOfType(p?.spec?.packages || [], packages, [
+      "backend-plugin",
+      "backend-plugin-module"
+    ]),
+    "frontend packages": (p) => getPackagesOfType(p?.spec?.packages || [], packages, ["frontend-plugin"])
+  });
+  for (const yaml of await yamls) {
+    if (backstagePluginExtensionsCommon.isExtensionsPackage(yaml)) {
+      packages[yaml.metadata.name] = yaml;
+      packageCSV.addRow(yaml);
+    } else if (backstagePluginExtensionsCommon.isExtensionsPlugin(yaml)) {
+      pluginCSV.addRow(yaml);
+    }
+  }
+  const csvs = {};
+  switch (type) {
+    case "plugin":
+      csvs["-plugins.csv"] = pluginCSV.generate();
+      break;
+    case "package":
+      csvs["-packages.csv"] = packageCSV.generate();
+      break;
+    case "all":
+    default:
+      csvs["-plugins.csv"] = pluginCSV.generate();
+      csvs["-packages.csv"] = packageCSV.generate();
+      break;
+  }
+  for (const [suffix, csv] of Object.entries(csvs)) {
+    if (!outputFile) {
+      console.log(csv);
+      continue;
+    }
+    await fs__default.default.writeFile(`${outputFile}${suffix}`, csv);
+  }
+  process.exit(0);
+};
+
+exports.default = index;
+//# sourceMappingURL=index.cjs.js.map

package/dist/commands/generate/index.cjs.js

@@ -0,0 +1,212 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs-extra');
+var path = require('path');
+var yaml = require('yaml');
+var backstagePluginExtensionsCommon = require('@red-hat-developer-hub/backstage-plugin-extensions-common');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var yaml__default = /*#__PURE__*/_interopDefaultCompat(yaml);
+
+const DEFAULT_LIFECYCLE = "unknown";
+var index = async (opts) => {
+  const { defaultDynamicPluginsConfig, outputDir, namespace, owner } = opts;
+  const entities = [];
+  if (defaultDynamicPluginsConfig) {
+    const defaultDynamicPluginsPath = path__default.default.resolve(defaultDynamicPluginsConfig);
+    const defaultDynamicPluginsContent = fs__default.default.readFileSync(
+      defaultDynamicPluginsPath,
+      "utf8"
+    );
+    const defaultPluginsConfig = yaml__default.default.parse(
+      defaultDynamicPluginsContent
+    );
+    for (const plugin of defaultPluginsConfig.plugins) {
+      const wrapperDir = plugin.package.replace("/dist/", "/wrappers/");
+      const wrapperPath = path__default.default.join(
+        path__default.default.dirname(defaultDynamicPluginsConfig),
+        wrapperDir
+      );
+      const packageJSONPath = path__default.default.join(wrapperPath, "package.json");
+      const packageJSON = fs__default.default.readJsonSync(packageJSONPath);
+      const packageName = guessPackageFromDependencies(
+        packageJSON.name,
+        packageJSON.dependencies
+      ) || packageJSON.name;
+      const links = [];
+      if (packageJSON.homepage) {
+        links.push({ url: packageJSON.homepage, title: "Homepage" });
+      }
+      if (packageJSON.bugs) {
+        const bugs = packageJSON.bugs;
+        if (bugs.url) {
+          links.push({ url: bugs.url, title: "Bugs" });
+        } else {
+          links.push({ url: packageJSON.bugs, title: "Bugs" });
+        }
+      }
+      let sourceLocation = "";
+      if (packageJSON.repository) {
+        const repo = packageJSON.repository;
+        const url = { title: "Source Code", url: "" };
+        if (repo.url) {
+          if (repo.url.startsWith("https://github.com")) {
+            url.url = `${repo.url}/tree/main/${repo.directory}`;
+          } else {
+            url.url = `${repo.url}/${repo.directory}`;
+          }
+        } else {
+          url.url = packageJSON.repository;
+        }
+        links.push(url);
+        sourceLocation = `url ${url.url}`;
+      }
+      let author = "";
+      if (packageJSON.author) {
+        const a = packageJSON.author;
+        if (a.name) {
+          author = a.name;
+          author += a.email ? ` <${a.email}>` : "";
+          author += a.url ? ` (${a.url})` : "";
+        } else {
+          author = packageJSON.author;
+        }
+      }
+      const partOf = [];
+      if (packageJSON.backstage?.pluginId) {
+        if (packageJSON.backstage?.role === "backend-plugin-module") {
+          const scope = getScope(packageName);
+          const module = getModuleName(packageName);
+          let pof = "";
+          if (scope) {
+            pof = `${scope}-`;
+          }
+          if (module) {
+            pof += `${module}-`;
+          }
+          pof += `${packageJSON.backstage.pluginId}-module`;
+          partOf.push(pof);
+        } else {
+          partOf.push(packageJSON.backstage.pluginId);
+        }
+      }
+      const appConfigExamples = [];
+      if (plugin.pluginConfig) {
+        appConfigExamples.push({
+          title: "Default configuration",
+          content: plugin.pluginConfig
+        });
+      }
+      const entity = {
+        apiVersion: backstagePluginExtensionsCommon.EXTENSIONS_API_VERSION,
+        kind: backstagePluginExtensionsCommon.ExtensionsKind.Package,
+        metadata: {
+          name: entityName(packageJSON.name),
+          namespace: namespace ?? undefined,
+          title: packageName,
+          links,
+          annotations: {
+            "backstage.io/source-location": sourceLocation
+          },
+          tags: packageJSON.keywords?.filter(
+            (k) => !k.startsWith("support:") && !k.startsWith("lifecycle:")
+          )
+        },
+        spec: {
+          owner,
+          packageName,
+          dynamicArtifact: plugin.package,
+          version: packageJSON.version,
+          backstage: {
+            role: packageJSON.backstage?.role,
+            supportedVersions: packageJSON.backstage?.["supported-versions"]
+          },
+          author,
+          lifecycle: packageJSON.keywords?.find((k) => k.startsWith("lifecycle:"))?.split(":")[1] ?? DEFAULT_LIFECYCLE,
+          partOf,
+          appConfigExamples
+        }
+      };
+      entities.push(entity);
+    }
+  }
+  if (outputDir) {
+    const outputDirPath = path__default.default.resolve(outputDir);
+    await fs__default.default.ensureDir(outputDirPath);
+    const location = {
+      apiVersion: "backstage.io/v1alpha1",
+      kind: "Location",
+      metadata: {
+        namespace,
+        name: "packages"
+      },
+      spec: {
+        targets: []
+      }
+    };
+    for (const entity of entities) {
+      const filename = `${entity.metadata.name}.yaml`;
+      const entityPath = path__default.default.join(outputDirPath, filename);
+      await fs__default.default.writeFile(entityPath, yaml__default.default.stringify(entity));
+      location.spec.targets?.push(`./${filename}`);
+    }
+    await fs__default.default.writeFile(
+      path__default.default.join(outputDirPath, "all.yaml"),
+      yaml__default.default.stringify(location)
+    );
+  } else {
+    for (const entity of entities) {
+      console.log(yaml__default.default.stringify(entity));
+      console.log("---");
+    }
+  }
+};
+function entityName(str) {
+  let name = str.toLowerCase().replace(/[^a-z0-9-_.]/g, "-").replace(/-+/g, "-");
+  if (name.startsWith("-")) {
+    name = name.substring(1);
+  }
+  if (name.endsWith("-")) {
+    name = name.slice(0, -1);
+  }
+  if (name.length > 63) {
+    name = name.substring(0, 63);
+  }
+  return name;
+}
+function guessPackageFromDependencies(pkgname, dependencies) {
+  if (!dependencies) {
+    return undefined;
+  }
+  if (Object.keys(dependencies).length === 1) {
+    return Object.keys(dependencies)[0];
+  }
+  for (const dep of Object.keys(dependencies)) {
+    const convertedName = dep.replaceAll("/", "-").replaceAll("@", "");
+    if (convertedName === pkgname) {
+      return dep;
+    }
+  }
+  return undefined;
+}
+function getScope(pkgname) {
+  if (pkgname.startsWith("@")) {
+    return pkgname.split("/")[0].substring(1);
+  }
+  return undefined;
+}
+function getModuleName(pkgname) {
+  const parts = pkgname.split("-module-");
+  if (parts.length > 1) {
+    return parts[1];
+  }
+  return undefined;
+}
+
+exports.default = index;
+//# sourceMappingURL=index.cjs.js.map

package/dist/commands/index.cjs.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var lazy = require('../lib/lazy.cjs.js');
+
+const registerCommands = (program) => {
+  program.command("init").description("init").action(lazy.lazy(() => import('./init/index.cjs.js'), "default"));
+  program.command("generate").description(
+    "Generate a Plugin entities for the extensions. By default, it will output entities to the standard output"
+  ).option(
+    "-p, --default-dynamic-plugins-config [path]",
+    "Path to the default dynamic plugins file (usually dynamic-plugins.default.yaml in rhdh source code)"
+  ).option(
+    "-o, --output-dir [path]",
+    "Path to the output directory. Each entity will be written to a separate file"
+  ).option(
+    "--namespace [namespace]",
+    "metadata.namespace for the generated Package entities"
+  ).option("--owner [owner]", "spec.owner for the generated Package entities").action(lazy.lazy(() => import('./generate/index.cjs.js'), "default"));
+  program.command("verify").description(
+    "Verify a set of extensions entities. By default, it will read entities from the standard input"
+  ).action(lazy.lazy(() => import('./verify/index.cjs.js'), "default"));
+  program.command("export-csv").description("Export a folder of extensions plugin YAMLs to a CSV file").option(
+    "-o, --output-file [path]",
+    'Path to the output CSV file. By default, it will output to the standard output. When a file is specified, the "csv" file extension will be added automatically'
+  ).option(
+    "-p, --plugins-yaml-path [path]",
+    "Path to the default plugins folder, containing extensions plugin YAML files. Multiple paths can be provided, separated by commas"
+  ).option(
+    "-r, --recursive",
+    "Recursively search for YAML files in each directory provided in plugins-yaml-path"
+  ).option(
+    "-t, --type [type]",
+    'The type of CSV to export. Can be one of: "plugin", "package", or "all". "all" will generate two files.',
+    "all"
+  ).action(lazy.lazy(() => import('./export-csv/index.cjs.js'), "default"));
+};
+
+exports.registerCommands = registerCommands;
+//# sourceMappingURL=index.cjs.js.map

package/dist/commands/init/index.cjs.js

@@ -0,0 +1,143 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var inquirer = require('inquirer');
+var glob = require('glob');
+var yaml = require('yaml');
+var backstagePluginExtensionsCommon = require('@red-hat-developer-hub/backstage-plugin-extensions-common');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
+var glob__default = /*#__PURE__*/_interopDefaultCompat(glob);
+var yaml__default = /*#__PURE__*/_interopDefaultCompat(yaml);
+
+async function init() {
+  const pluginFolders = await glob__default.default.glob("plugins/*/package.json/../");
+  const autoGeneratePackages = pluginFolders.length === 0;
+  const cwd = process.cwd().split("/").pop() ?? "";
+  const defaultTitle = cwd.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const questions = [
+    {
+      type: "input",
+      name: "title",
+      message: "Plugin name (display name)",
+      default: defaultTitle
+    }
+  ];
+  if (autoGeneratePackages) {
+    questions.push({
+      type: "input",
+      name: "packageName",
+      message: "NPM package name incl. org (e.g. @my-org/my-plugin)"
+    });
+    questions.push({
+      type: "checkbox",
+      name: "packages",
+      message: "Packages",
+      choices: [
+        { name: "Frontend", value: "frontend", checked: true },
+        { name: "Backend", value: "backend", checked: true }
+      ]
+    });
+  } else {
+    questions.push({
+      type: "checkbox",
+      name: "packages",
+      message: "Packages",
+      choices: pluginFolders.map((pluginFolder) => ({
+        name: pluginFolder,
+        value: pluginFolder,
+        checked: true
+      }))
+    });
+  }
+  const answers = await inquirer__default.default.prompt(questions);
+  console.log("answers", answers);
+  const { title, packageName, namespace, author } = answers;
+  let name = (packageName || title).toLowerCase().replace(/^@/, "");
+  if (name.includes("/")) {
+    name = name.substring(name.lastIndexOf("/") + 1);
+  }
+  const plugin = {
+    apiVersion: backstagePluginExtensionsCommon.EXTENSIONS_API_VERSION,
+    kind: backstagePluginExtensionsCommon.ExtensionsKind.Plugin,
+    metadata: {
+      namespace,
+      name,
+      title,
+      description: "Plugin summary"
+    },
+    spec: {
+      author,
+      description: "# Plugin name\n\nFull plugin description..."
+    }
+  };
+  console.log(yaml__default.default.stringify(plugin).trim());
+  if (autoGeneratePackages) {
+    if (answers.packages.includes("frontend")) {
+      const frontendPackage = {
+        apiVersion: backstagePluginExtensionsCommon.EXTENSIONS_API_VERSION,
+        kind: backstagePluginExtensionsCommon.ExtensionsKind.Package,
+        metadata: {
+          namespace,
+          name: packageName.toLowerCase().replace(/^@/, "").replaceAll(/[^a-z0-9]/g, "-"),
+          title: packageName
+        },
+        spec: {
+          packageName,
+          version: "0.1.0",
+          partOf: [plugin.metadata.name]
+        }
+      };
+      console.log("---");
+      console.log(yaml__default.default.stringify(frontendPackage).trim());
+    }
+    if (answers.packages.includes("backend")) {
+      const backendPackage = {
+        apiVersion: backstagePluginExtensionsCommon.EXTENSIONS_API_VERSION,
+        kind: backstagePluginExtensionsCommon.ExtensionsKind.Package,
+        metadata: {
+          namespace,
+          name: `${packageName.toLowerCase().replace(/^@/, "").replaceAll(/[^a-z0-9]/g, "-")}-backend`,
+          title: `${packageName}-backend`
+        },
+        spec: {
+          packageName: `${packageName}-backend`,
+          version: "0.1.0",
+          partOf: [plugin.metadata.name]
+        }
+      };
+      console.log("---");
+      console.log(yaml__default.default.stringify(backendPackage).trim());
+    }
+  } else {
+    answers.packages.forEach((pluginFolder) => {
+      const packageJsonPath = `${pluginFolder}/package.json`;
+      const packageJson = JSON.parse(
+        fs__default.default.readFileSync(packageJsonPath, { encoding: "utf8" })
+      );
+      const pkg = {
+        apiVersion: backstagePluginExtensionsCommon.EXTENSIONS_API_VERSION,
+        kind: backstagePluginExtensionsCommon.ExtensionsKind.Package,
+        metadata: {
+          namespace,
+          name: packageJson.name.toLowerCase().replace(/^@/, "").replaceAll(/[^a-z0-9]/g, "-")
+        },
+        spec: {
+          packageName: packageJson.name,
+          version: packageJson.version,
+          partOf: [plugin.metadata.name]
+        }
+      };
+      console.log("---");
+      console.log(yaml__default.default.stringify(pkg).trim());
+    });
+  }
+}
+
+exports.default = init;
+//# sourceMappingURL=index.cjs.js.map

package/dist/commands/verify/index.cjs.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var chalk = require('chalk');
+var fs = require('fs-extra');
+var glob = require('glob');
+var yaml = require('yaml');
+var backstagePluginExtensionsCommon = require('@red-hat-developer-hub/backstage-plugin-extensions-common');
+
+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);
+var yaml__default = /*#__PURE__*/_interopDefaultCompat(yaml);
+
+const packages = {};
+const plugins = {};
+var index = async () => {
+  const filenames = await glob.glob("**/*.yaml", { ignore: "node_modules/**" });
+  filenames.sort();
+  for (const filename of filenames) {
+    const content = await fs__default.default.readFile(filename, "utf8");
+    const parsed = await yaml__default.default.parse(content);
+    if (Array.isArray(content)) {
+      for (const chunk of content) {
+        await load(filename, chunk);
+      }
+    } else {
+      await load(filename, parsed);
+    }
+  }
+  verifyPackages();
+  verifyPlugins();
+};
+function stringifyEntityRef(entity) {
+  return `${entity.metadata.namespace ?? "default"}/${entity.metadata.name}`;
+}
+function isEntity(maybe) {
+  return "apiVersion" in maybe && "kind" in maybe;
+}
+async function load(filename, content) {
+  if (typeof content !== "object") {
+    throw new Error(`Expected object, got ${typeof content}`);
+  }
+  if (backstagePluginExtensionsCommon.isExtensionsPackage(content)) {
+    packages[stringifyEntityRef(content)] = content;
+  } else if (backstagePluginExtensionsCommon.isExtensionsPlugin(content)) {
+    plugins[stringifyEntityRef(content)] = content;
+  } else if (isEntity(content)) {
+    console.log(
+      `Ignore file ${chalk__default.default.blue(filename)} with apiVersion ${content.apiVersion} and kind ${content.kind}`
+    );
+  } else {
+    console.log(
+      `Ignore file ${chalk__default.default.blue(filename)} without apiVersion or kind`
+    );
+  }
+}
+async function verifyPackages() {
+  for (const pkg of Object.values(packages)) {
+    const displayName = pkg.metadata.title ?? pkg.metadata.name ?? "unknown";
+    console.log(`Verifying package ${chalk__default.default.blue(displayName)}...`);
+    if (!pkg.metadata.title) {
+      console.log(`  - missing title`);
+    }
+    if (pkg.spec?.partOf?.length) {
+      for (const partOf of pkg.spec.partOf) {
+        if (!plugins[partOf]) {
+          console.log(`  - missing plugin ${partOf}`);
+        }
+      }
+    }
+  }
+}
+async function verifyPlugins() {
+  for (const plugin of Object.values(plugins)) {
+    const displayName = plugin.metadata.title ?? plugin.metadata.name ?? "unknown";
+    console.log(`Verifying plugin ${chalk__default.default.blue(displayName)}`);
+    if (!plugin.metadata.title) {
+      console.log(`  - missing title`);
+    }
+    if (plugin.spec?.packages?.length) {
+      for (const pkg of plugin.spec.packages) {
+        if (typeof pkg === "string") {
+          if (!packages[pkg]) {
+            console.log(`  - missing package ${pkg}`);
+          }
+        }
+      }
+    }
+    if (!plugin.spec?.documentation?.length) {
+      console.log(`  - missing documentation`);
+    }
+  }
+}
+
+exports.default = index;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.cjs.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var commander = require('commander');
+var chalk = require('chalk');
+var errors = require('./lib/errors.cjs.js');
+var index = require('./commands/index.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+const main = (argv) => {
+  commander.program.name("extensions-cli");
+  index.registerCommands(commander.program);
+  commander.program.on("command:*", () => {
+    console.log();
+    console.log(chalk__default.default.red(`Invalid command: ${commander.program.args.join(" ")}`));
+    console.log();
+    commander.program.outputHelp();
+    process.exit(1);
+  });
+  commander.program.parse(argv);
+};
+process.on("unhandledRejection", (rejection) => {
+  if (rejection instanceof Error) {
+    errors.exitWithError(rejection);
+  } else {
+    errors.exitWithError(new Error(`Unknown rejection: '${rejection}'`));
+  }
+});
+main(process.argv);
+//# sourceMappingURL=index.cjs.js.map

package/dist/lib/errors.cjs.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var chalk = require('chalk');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+class CustomError extends Error {
+  get name() {
+    return this.constructor.name;
+  }
+}
+class ExitCodeError extends CustomError {
+  code;
+  constructor(code, command) {
+    super(
+      command ? `Command '${command}' exited with code ${code}` : `Child exited with code ${code}`
+    );
+    this.code = code;
+  }
+}
+function exitWithError(error) {
+  if (error instanceof ExitCodeError) {
+    process.stderr.write(`
+${chalk__default.default.red(error.message)}
+
+`);
+    process.exit(error.code);
+  } else {
+    process.stderr.write(`
+${chalk__default.default.red(`${error.stack}`)}
+
+`);
+    process.exit(1);
+  }
+}
+
+exports.CustomError = CustomError;
+exports.ExitCodeError = ExitCodeError;
+exports.exitWithError = exitWithError;
+//# sourceMappingURL=errors.cjs.js.map

package/dist/lib/lazy.cjs.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var errors = require('@backstage/errors');
+var errors$1 = require('./errors.cjs.js');
+
+function lazy(moduleLoader, exportName) {
+  return async (...args) => {
+    try {
+      const mod = await moduleLoader();
+      const actualModule = mod.default;
+      const actionFunc = actualModule[exportName];
+      await actionFunc(...args);
+      process.exit(0);
+    } catch (error) {
+      errors.assertError(error);
+      errors$1.exitWithError(error);
+    }
+  };
+}
+
+exports.lazy = lazy;
+//# sourceMappingURL=lazy.cjs.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@red-hat-developer-hub/extensions-cli",
+  "description": "CLI for the Extensions",
+  "version": "0.14.0",
+  "backstage": {
+    "role": "cli"
+  },
+  "homepage": "https://red.ht/rhdh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/redhat-developer/rhdh-plugins",
+    "directory": "workspaces/extensions/packages/cli"
+  },
+  "keywords": [
+    "backstage"
+  ],
+  "license": "Apache-2.0",
+  "main": "dist/index.cjs.js",
+  "scripts": {
+    "build": "backstage-cli package build",
+    "lint": "backstage-cli package lint",
+    "test": "backstage-cli package test",
+    "clean": "backstage-cli package clean",
+    "start": "nodemon --"
+  },
+  "bin": "bin/extensions-cli",
+  "files": [
+    "bin",
+    "dist/**/*.js"
+  ],
+  "dependencies": {
+    "@backstage/catalog-model": "^1.7.6",
+    "@backstage/cli": "^0.34.5",
+    "@backstage/errors": "^1.2.7",
+    "@backstage/types": "^1.2.2",
+    "@red-hat-developer-hub/backstage-plugin-extensions-common": "^0.14.0",
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0",
+    "glob": "^9.3.5",
+    "inquirer": "^12.4.3",
+    "yaml": "^2.7.0"
+  },
+  "nodemonConfig": {
+    "watch": "./src",
+    "exec": "bin/extensions-cli",
+    "ext": "ts"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4"
+  }
+}