@backstage/cli 0.36.0-next.1 → 0.36.0-next.2

package/dist/modules/auth/lib/localServer.cjs.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var http = require('node:http');
+var node_url = require('node:url');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var http__default = /*#__PURE__*/_interopDefaultCompat(http);
+
+const CALLBACK_PORT = 8055;
+async function startCallbackServer(options) {
+  const server = http__default.default.createServer();
+  let resolveResult;
+  const resultPromise = new Promise(
+    (resolve) => {
+      resolveResult = resolve;
+    }
+  );
+  server.on("request", (req, res) => {
+    if (!req.url) {
+      res.statusCode = 400;
+      res.end("Bad Request");
+      return;
+    }
+    const u = new node_url.URL(req.url, "http://127.0.0.1");
+    if (u.pathname !== "/callback") {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+    const code = u.searchParams.get("code") ?? void 0;
+    const state = u.searchParams.get("state") ?? void 0;
+    if (!code) {
+      res.statusCode = 400;
+      res.end("Missing code");
+      return;
+    }
+    if (state !== options.state) {
+      res.statusCode = 400;
+      res.end("State mismatch");
+      return;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("You may now close this window.");
+    resolveResult?.({ code, state });
+  });
+  const port = await new Promise((resolve, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${CALLBACK_PORT} is already in use. Close the application using it and try again.`
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(CALLBACK_PORT, "127.0.0.1", () => {
+      const address = server.address();
+      if (typeof address === "object" && address && "port" in address) {
+        resolve(address.port);
+      } else {
+        reject(new Error("Failed to bind local server"));
+      }
+    });
+  });
+  return {
+    url: `http://127.0.0.1:${port}/callback`,
+    waitForCode: () => resultPromise,
+    close: async () => {
+      server.closeAllConnections();
+      return new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+exports.startCallbackServer = startCallbackServer;
+//# sourceMappingURL=localServer.cjs.js.map

package/dist/modules/auth/lib/pkce.cjs.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var crypto = require('node:crypto');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefaultCompat(crypto);
+
+function base64url(input) {
+  return input.toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function generateVerifier(length = 64) {
+  const bytes = crypto__default.default.randomBytes(Math.max(32, Math.min(96, length)));
+  return base64url(bytes);
+}
+function challengeFromVerifier(verifier) {
+  const hash = crypto__default.default.createHash("sha256").update(verifier).digest();
+  return base64url(hash);
+}
+
+exports.challengeFromVerifier = challengeFromVerifier;
+exports.generateVerifier = generateVerifier;
+//# sourceMappingURL=pkce.cjs.js.map

package/dist/modules/auth/lib/prompt.cjs.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var inquirer = require('inquirer');
+var storage = require('./storage.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
+
+async function pickInstance(name) {
+  if (name) {
+    return storage.getInstanceByName(name);
+  }
+  const { instances, selected } = await storage.getAllInstances();
+  if (instances.length === 0) {
+    throw new Error(
+      'No instances found. Run "auth login" to authenticate first.'
+    );
+  }
+  return await promptForInstance(instances, selected);
+}
+async function promptForInstance(instances, selected) {
+  const choices = instances.map((i) => ({
+    name: `${i.name === selected?.name ? "* " : "  "}${i.name} (${i.baseUrl})`,
+    value: i.name
+  }));
+  const { choice } = await inquirer__default.default.prompt([
+    {
+      type: "list",
+      name: "choice",
+      message: "Select instance:",
+      choices,
+      default: selected?.name
+    }
+  ]);
+  const instance = instances.find((i) => i.name === choice);
+  if (!instance) {
+    throw new Error(`Instance '${choice}' not found`);
+  }
+  return instance;
+}
+
+exports.pickInstance = pickInstance;
+//# sourceMappingURL=prompt.cjs.js.map

package/dist/modules/auth/lib/secretStore.cjs.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var fs = require('fs-extra');
+var os = require('node:os');
+var path = require('node:path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var os__default = /*#__PURE__*/_interopDefaultCompat(os);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+async function loadKeytar() {
+  try {
+    const keytar = require("keytar");
+    if (keytar && typeof keytar.getPassword === "function") {
+      return keytar;
+    }
+  } catch {
+  }
+  return void 0;
+}
+class KeytarSecretStore {
+  keytar;
+  constructor(keytar) {
+    this.keytar = keytar;
+  }
+  async get(service, account) {
+    const result = await this.keytar.getPassword(service, account);
+    return result ?? void 0;
+  }
+  async set(service, account, secret) {
+    await this.keytar.setPassword(service, account, secret);
+  }
+  async delete(service, account) {
+    await this.keytar.deletePassword(service, account);
+  }
+}
+class FileSecretStore {
+  baseDir;
+  constructor() {
+    const root = process.env.XDG_DATA_HOME || (process.platform === "win32" ? process.env.APPDATA || path__default.default.join(os__default.default.homedir(), "AppData", "Roaming") : path__default.default.join(os__default.default.homedir(), ".local", "share"));
+    this.baseDir = path__default.default.join(root, "backstage-cli", "auth-secrets");
+  }
+  filePath(service, account) {
+    return path__default.default.join(
+      this.baseDir,
+      encodeURIComponent(service),
+      `${encodeURIComponent(account)}.secret`
+    );
+  }
+  async get(service, account) {
+    const file = this.filePath(service, account);
+    if (!await fs__default.default.pathExists(file)) return void 0;
+    return await fs__default.default.readFile(file, "utf8");
+  }
+  async set(service, account, secret) {
+    const file = this.filePath(service, account);
+    await fs__default.default.ensureDir(path__default.default.dirname(file));
+    await fs__default.default.writeFile(file, secret, { encoding: "utf8", mode: 384 });
+  }
+  async delete(service, account) {
+    const file = this.filePath(service, account);
+    await fs__default.default.remove(file);
+  }
+}
+let singleton;
+async function getSecretStore() {
+  if (!singleton) {
+    const keytar = await loadKeytar();
+    if (keytar) {
+      singleton = new KeytarSecretStore(keytar);
+    } else {
+      singleton = new FileSecretStore();
+    }
+  }
+  return singleton;
+}
+
+exports.getSecretStore = getSecretStore;
+//# sourceMappingURL=secretStore.cjs.js.map

package/dist/modules/auth/lib/storage.cjs.js

@@ -0,0 +1,152 @@
+'use strict';
+
+var errors = require('@backstage/errors');
+var fs = require('fs-extra');
+var os = require('node:os');
+var path = require('node:path');
+var lockfile = require('proper-lockfile');
+var YAML = require('yaml');
+var zod = require('zod');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var os__default = /*#__PURE__*/_interopDefaultCompat(os);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var lockfile__default = /*#__PURE__*/_interopDefaultCompat(lockfile);
+var YAML__default = /*#__PURE__*/_interopDefaultCompat(YAML);
+
+const METADATA_FILE = "auth-instances.yaml";
+const INSTANCE_NAME_PATTERN = /^[a-zA-Z0-9._:@-]+$/;
+const storedInstanceSchema = zod.z.object({
+  name: zod.z.string().min(1).regex(INSTANCE_NAME_PATTERN, "Instance name contains invalid characters"),
+  baseUrl: zod.z.string().url(),
+  clientId: zod.z.string().min(1),
+  issuedAt: zod.z.number().int().nonnegative(),
+  accessTokenExpiresAt: zod.z.number().int().nonnegative(),
+  selected: zod.z.boolean().optional()
+});
+const authYamlSchema = zod.z.object({
+  instances: zod.z.array(storedInstanceSchema).default([])
+});
+function getMetadataFilePath() {
+  const root = process.env.XDG_CONFIG_HOME || (process.platform === "win32" ? process.env.APPDATA || path__default.default.join(os__default.default.homedir(), "AppData", "Roaming") : path__default.default.join(os__default.default.homedir(), ".config"));
+  return path__default.default.join(root, "backstage-cli", METADATA_FILE);
+}
+async function readAll() {
+  const file = getMetadataFilePath();
+  if (!await fs__default.default.pathExists(file)) {
+    return { instances: [] };
+  }
+  const text = await fs__default.default.readFile(file, "utf8");
+  if (!text.trim()) {
+    return { instances: [] };
+  }
+  try {
+    const doc = YAML__default.default.parse(text);
+    const parsed = authYamlSchema.safeParse(doc);
+    if (parsed.success) {
+      return parsed.data;
+    }
+    return { instances: [] };
+  } catch {
+    return { instances: [] };
+  }
+}
+async function writeAll(data) {
+  const file = getMetadataFilePath();
+  await fs__default.default.ensureDir(path__default.default.dirname(file));
+  const yaml = YAML__default.default.stringify(authYamlSchema.parse(data), { indentSeq: false });
+  await fs__default.default.writeFile(file, yaml, { encoding: "utf8", mode: 384 });
+}
+async function getAllInstances() {
+  const { instances } = await readAll();
+  const selected = instances.find((i) => i.selected) ?? instances[0];
+  return {
+    // Normalize selection prop
+    instances: instances.map((i) => ({
+      ...i,
+      selected: i.name === selected.name
+    })),
+    selected
+  };
+}
+async function getSelectedInstance(instanceName) {
+  if (instanceName) {
+    return await getInstanceByName(instanceName);
+  }
+  const { selected } = await getAllInstances();
+  if (!selected) {
+    throw new Error(
+      'No instances found. Run "auth login" to authenticate first.'
+    );
+  }
+  return selected;
+}
+async function getInstanceByName(name) {
+  const { instances } = await readAll();
+  const instance = instances.find((i) => i.name === name);
+  if (!instance) {
+    throw new errors.NotFoundError(`Instance '${name}' not found`);
+  }
+  return instance;
+}
+async function upsertInstance(instance) {
+  const data = await readAll();
+  const idx = data.instances.findIndex((i) => i.name === instance.name);
+  if (idx === -1) {
+    data.instances.push(instance);
+  } else {
+    data.instances[idx] = instance;
+  }
+  await writeAll(data);
+}
+async function removeInstance(name) {
+  const data = await readAll();
+  const next = data.instances.filter((i) => i.name !== name);
+  if (next.length !== data.instances.length) {
+    await writeAll({ instances: next });
+  }
+}
+async function setSelectedInstance(name) {
+  return withMetadataLock(async () => {
+    const data = await readAll();
+    let found = false;
+    data.instances = data.instances.map((i) => {
+      if (i.name === name) {
+        found = true;
+        return { ...i, selected: true };
+      }
+      const { selected, ...rest } = i;
+      return { ...rest, selected: false };
+    });
+    if (!found) {
+      throw new Error(`Unknown instance '${name}'`);
+    }
+    await writeAll(data);
+  });
+}
+async function withMetadataLock(fn) {
+  const file = getMetadataFilePath();
+  await fs__default.default.ensureDir(path__default.default.dirname(file));
+  if (!await fs__default.default.pathExists(file)) {
+    await fs__default.default.writeFile(file, "", { encoding: "utf8", mode: 384 });
+  }
+  const release = await lockfile__default.default.lock(file, {
+    retries: { retries: 5, factor: 1.5, minTimeout: 100, maxTimeout: 1e3 }
+  });
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
+exports.getAllInstances = getAllInstances;
+exports.getInstanceByName = getInstanceByName;
+exports.getSelectedInstance = getSelectedInstance;
+exports.removeInstance = removeInstance;
+exports.setSelectedInstance = setSelectedInstance;
+exports.upsertInstance = upsertInstance;
+exports.withMetadataLock = withMetadataLock;
+//# sourceMappingURL=storage.cjs.js.map

package/dist/modules/build/commands/buildWorkspace.cjs.js

@@ -3,19 +3,48 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var fs = require('fs-extra');
+var cleye = require('cleye');
 var createDistWorkspace = require('../lib/packager/createDistWorkspace.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 
-var buildWorkspace = async (dir, packages, options) => {
+var buildWorkspace = async ({ args, info }) => {
+  const normalizedArgs = args.map((a) => {
+    if (a === "--alwaysYarnPack") {
+      return "--always-pack";
+    }
+    if (a.startsWith("--alwaysYarnPack=")) {
+      return `--always-pack${a.substring("--alwaysYarnPack".length)}`;
+    }
+    return a;
+  });
+  const {
+    flags: { alwaysPack },
+    _: positionals
+  } = cleye.cli(
+    {
+      help: { ...info, usage: `${info.usage} <workspace-dir> [packages...]` },
+      booleanFlagNegation: true,
+      parameters: ["<workspace-dir>", "[packages...]"],
+      flags: {
+        alwaysPack: {
+          type: Boolean,
+          description: "Force workspace output to be a result of running `yarn pack` on each package (warning: very slow)"
+        }
+      }
+    },
+    void 0,
+    normalizedArgs
+  );
+  const [dir, ...packages] = positionals;
   if (!await fs__default.default.pathExists(dir)) {
     throw new Error(`Target workspace directory doesn't exist, '${dir}'`);
   }
   await createDistWorkspace.createDistWorkspace(packages, {
     targetDir: dir,
-    alwaysPack: options.alwaysPack,
+    alwaysPack,
     enableFeatureDetection: true
   });
 };

package/dist/modules/build/commands/package/build/command.cjs.js

@@ -1,5 +1,8 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cleye = require('cleye');
 var fs = require('fs-extra');
 var packager = require('../../../lib/builder/packager.cjs.js');
 var types = require('../../../lib/builder/types.cjs.js');
@@ -16,33 +19,77 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
 
-async function command(opts) {
+var command = async ({ args, info }) => {
+  const {
+    flags: {
+      role: role$1,
+      minify,
+      skipBuildDependencies,
+      stats,
+      config,
+      moduleFederation
+    }
+  } = cleye.cli(
+    {
+      help: info,
+      booleanFlagNegation: true,
+      flags: {
+        role: {
+          type: String,
+          description: "Run the command with an explicit package role"
+        },
+        minify: {
+          type: Boolean,
+          description: "Minify the generated code. Does not apply to app package (app is minified by default)."
+        },
+        skipBuildDependencies: {
+          type: Boolean,
+          description: "Skip the automatic building of local dependencies. Applies to backend packages only."
+        },
+        stats: {
+          type: Boolean,
+          description: "If bundle stats are available, write them to the output directory. Applies to app packages only."
+        },
+        config: {
+          type: [String],
+          description: "Config files to load instead of app-config.yaml. Applies to app packages only.",
+          default: []
+        },
+        moduleFederation: {
+          type: Boolean,
+          description: "Build a package as a module federation remote. Applies to frontend plugin packages only."
+        }
+      }
+    },
+    void 0,
+    args
+  );
   const webpack = process.env.LEGACY_WEBPACK_BUILD ? require("webpack") : void 0;
-  const role$1 = await role.findRoleFromCommand(opts);
-  if (role$1 === "frontend" || role$1 === "backend") {
-    const configPaths = opts.config.map((arg) => {
+  const resolvedRole = await role.findRoleFromCommand({ role: role$1 });
+  if (resolvedRole === "frontend" || resolvedRole === "backend") {
+    const configPaths = config.map((arg) => {
       if (urls.isValidUrl(arg)) {
         return arg;
       }
       return cliCommon.targetPaths.resolve(arg);
     });
-    if (role$1 === "frontend") {
+    if (resolvedRole === "frontend") {
       return buildFrontend.buildFrontend({
         targetDir: cliCommon.targetPaths.dir,
         configPaths,
-        writeStats: Boolean(opts.stats),
+        writeStats: Boolean(stats),
         webpack
       });
     }
     return buildBackend.buildBackend({
       targetDir: cliCommon.targetPaths.dir,
       configPaths,
-      skipBuildDependencies: Boolean(opts.skipBuildDependencies),
-      minify: Boolean(opts.minify)
+      skipBuildDependencies: Boolean(skipBuildDependencies),
+      minify: Boolean(minify)
     });
   }
   let isModuleFederationRemote = void 0;
-  if (role$1 === "frontend-dynamic-container") {
+  if (resolvedRole === "frontend-dynamic-container") {
     console.log(
       chalk__default.default.yellow(
         `\u26A0\uFE0F  WARNING: The 'frontend-dynamic-container' package role is experimental and will receive immediate breaking changes in the future.`
@@ -50,7 +97,7 @@ async function command(opts) {
     );
     isModuleFederationRemote = true;
   }
-  if (opts.moduleFederation) {
+  if (moduleFederation) {
     isModuleFederationRemote = true;
   }
   if (isModuleFederationRemote) {
@@ -58,12 +105,12 @@ async function command(opts) {
     return buildFrontend.buildFrontend({
       targetDir: cliCommon.targetPaths.dir,
       configPaths: [],
-      writeStats: Boolean(opts.stats),
+      writeStats: Boolean(stats),
       isModuleFederationRemote,
       webpack
     });
   }
-  const roleInfo = cliNode.PackageRoles.getRoleInfo(role$1);
+  const roleInfo = cliNode.PackageRoles.getRoleInfo(resolvedRole);
   const outputs = /* @__PURE__ */ new Set();
   if (roleInfo.output.includes("cjs")) {
     outputs.add(types.Output.cjs);
@@ -80,10 +127,10 @@ async function command(opts) {
   return packager.buildPackage({
     outputs,
     packageJson,
-    minify: Boolean(opts.minify),
+    minify: Boolean(minify),
     workspacePackages: await cliNode.PackageGraph.listTargetPackages()
   });
-}
+};
 
-exports.command = command;
+exports.default = command;
 //# sourceMappingURL=command.cjs.js.map

package/dist/modules/build/commands/package/build/index.cjs.js

@@ -1,8 +1,10 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var command = require('./command.cjs.js');
 
 
 
-exports.command = command.command;
+exports.default = command.default;
 //# sourceMappingURL=index.cjs.js.map

package/dist/modules/build/commands/package/clean.cjs.js

@@ -11,7 +11,7 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 
 var clean = async ({ args, info }) => {
-  cleye.cli({ help: info }, void 0, args);
+  cleye.cli({ help: info, booleanFlagNegation: true }, void 0, args);
   await fs__default.default.remove(cliCommon.targetPaths.resolve("dist"));
   await fs__default.default.remove(cliCommon.targetPaths.resolve("dist-types"));
   await fs__default.default.remove(cliCommon.targetPaths.resolve("coverage"));

package/dist/modules/build/commands/package/postpack.cjs.js

@@ -7,7 +7,7 @@ var cliCommon = require('@backstage/cli-common');
 var productionPack = require('../../lib/packager/productionPack.cjs.js');
 
 var postpack = async ({ args, info }) => {
-  cleye.cli({ help: info }, void 0, args);
+  cleye.cli({ help: info, booleanFlagNegation: true }, void 0, args);
   await productionPack.revertProductionPack(cliCommon.targetPaths.dir);
 };
 

package/dist/modules/build/commands/package/prepack.cjs.js

@@ -14,7 +14,7 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 
 var prepack = async ({ args, info }) => {
-  cleye.cli({ help: info }, void 0, args);
+  cleye.cli({ help: info, booleanFlagNegation: true }, void 0, args);
   publishing.publishPreflightCheck({
     dir: cliCommon.targetPaths.dir,
     packageJson: await fs__default.default.readJson(cliCommon.targetPaths.resolve("package.json"))