@botpress/cli 0.0.9 → 0.0.11

package/dist/index.js

@@ -18,260 +18,30 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var import_yargs_extra = __toESM(require("@bpinternal/yargs-extra"));
-var import_process = require("process");
-var app = __toESM(require("./app"));
-var config = __toESM(require("./config"));
+var import_command_definitions = __toESM(require("./command-definitions"));
+var import_command_implementations = __toESM(require("./command-implementations"));
+var tree = __toESM(require("./command-tree"));
+var errors = __toESM(require("./errors"));
 var import_logger = require("./logger");
-const { name, version } = require("../package.json");
-const pkg = { name, version };
-const errorLogger = new import_logger.Logger();
+var import_register_yargs = require("./register-yargs");
+var utils = __toESM(require("./utils"));
+const CLI_ROOT_DIR = utils.path.join(__dirname, "..");
 const logError = (thrown) => {
-  const error = app.errors.BotpressCLIError.map(thrown);
-  errorLogger.error(error.message);
+  const error = errors.BotpressCLIError.map(thrown);
+  new import_logger.Logger().error(error.message);
 };
 const onError = (thrown) => {
   logError(thrown);
-  (0, import_process.exit)(1);
+  process.exit(1);
 };
 const yargsFail = (msg) => {
   logError(`${msg}
 `);
   import_yargs_extra.default.showHelp();
-  (0, import_process.exit)(1);
+  process.exit(1);
 };
 process.on("uncaughtException", (thrown) => onError(thrown));
 process.on("unhandledRejection", (thrown) => onError(thrown));
-const parseArguments = (schema, argv) => {
-  const yargsEnv = (0, import_yargs_extra.parseEnv)(schema, "BP");
-  return (0, import_yargs_extra.cleanupConfig)(schema, { ...argv, ...yargsEnv });
-};
-import_yargs_extra.default.command(
-  "login",
-  "Login to Botpress Cloud",
-  () => import_yargs_extra.default.options(config.loginSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.loginSchema, argv);
-      const commands = await app.forUser({ ...parsed, ...pkg });
-      await commands.login(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "logout",
-  "Logout of Botpress Cloud",
-  () => import_yargs_extra.default.options(config.logoutSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.logoutSchema, argv);
-      const commands = await app.forUser({ ...parsed, ...pkg });
-      await commands.logout();
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command("bots", "bots related commands", (yargz) => {
-  yargz.command(
-    ["create", "new"],
-    "Create new bot",
-    () => yargz.options({ ...config.createBotSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.createBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, ...pkg });
-        await commands.createBot(parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    ["list", "ls"],
-    "List bots",
-    () => yargz.options({ ...config.listBotsSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.listBotsSchema, argv);
-        const commands = await app.forUser({ ...parsed, ...pkg });
-        await commands.listBots(parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    "get <botRef>",
-    "Get bot",
-    () => yargz.positional("botRef", config.botRef).options({ ...config.readBotSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.readBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, ...pkg });
-        await commands.getBot(argv.botRef, parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    ["delete <botRef>", "rm <botRef>"],
-    "Delete bot",
-    () => yargz.positional("botRef", config.botRef).options({ ...config.deleteBotSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.deleteBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, ...pkg });
-        await commands.deleteBot(argv.botRef, parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  );
-}).command("integrations", "integrations related commands", (yargz) => {
-  yargz.command(
-    ["list", "ls"],
-    "List integrations",
-    () => yargz.options({ ...config.listIntegrationsSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.listIntegrationsSchema, argv);
-        const commands = await app.forUser({ ...parsed, ...pkg });
-        await commands.listIntegrations(parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    "get <integrationRef>",
-    "Get integration",
-    () => yargz.positional("integrationRef", config.integrationRef).options({ ...config.readIntegrationSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.readIntegrationSchema, argv);
-        const commands = await app.forUser({ ...parsed, ...pkg });
-        await commands.getIntegration(argv.integrationRef, parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    ["delete <integrationRef>", "rm <integrationRef>"],
-    "Delete integration",
-    () => yargz.positional("integrationRef", config.integrationRef).options({ ...config.deleteIntegrationSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.readIntegrationSchema, argv);
-        const commands = await app.forUser({ ...parsed, ...pkg });
-        await commands.deleteIntegration(argv.integrationRef, parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  );
-}).command(
-  "bundle",
-  "Bundle a botpress project",
-  () => import_yargs_extra.default.options(config.bundleSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.bundleSchema, argv);
-      const commands = await app.forProject({ ...parsed, ...pkg });
-      await commands.bundleProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "gen",
-  "Generate typings for intellisense during development",
-  () => import_yargs_extra.default.options(config.generateSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.generateSchema, argv);
-      const commands = await app.forProject({ ...parsed, ...pkg });
-      await commands.generateTypings(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "build",
-  "Generate typings and bundle a botpress project",
-  () => import_yargs_extra.default.options(config.buildSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.buildSchema, argv);
-      const commands = await app.forProject({ ...parsed, ...pkg });
-      await commands.buildProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "serve",
-  "Serve your project locally",
-  () => import_yargs_extra.default.options(config.serveSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.serveSchema, argv);
-      const commands = await app.forProject({ ...parsed, ...pkg });
-      await commands.serveProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "deploy",
-  "Deploy your project",
-  () => import_yargs_extra.default.options(config.deploySchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.deploySchema, argv);
-      const commands = await app.forProject({ ...parsed, ...pkg });
-      await commands.deployProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "dev",
-  "Run your project in dev mode",
-  () => import_yargs_extra.default.options(config.devSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.devSchema, argv);
-      const commands = await app.forProject({ ...parsed, ...pkg });
-      await commands.devProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "add <integrationRef>",
-  "Install an integration in your bot",
-  (yargz) => yargz.positional("integrationRef", config.integrationRef).options(config.addSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.addSchema, argv);
-      const commands = await app.forProject({ ...parsed, ...pkg });
-      await commands.installIntegration(argv.integrationRef, parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-);
+const commands = tree.zipTree(import_command_definitions.default, import_command_implementations.default);
+(0, import_register_yargs.registerYargs)(import_yargs_extra.default, commands, { cliRootDir: CLI_ROOT_DIR });
 void import_yargs_extra.default.version(false).scriptName("bp").demandCommand(1, "You didn't provide any command. Use the --help flag to see the list of available commands.").recommendCommands().strict().help().fail(yargsFail).parse();

package/dist/integration-ref.js

@@ -0,0 +1,61 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var integration_ref_exports = {};
+__export(integration_ref_exports, {
+  formatIntegrationRef: () => formatIntegrationRef,
+  parseIntegrationRef: () => parseIntegrationRef
+});
+module.exports = __toCommonJS(integration_ref_exports);
+var import_semver = __toESM(require("semver"));
+var uuid = __toESM(require("uuid"));
+const LATEST_TAG = "latest";
+const formatIntegrationRef = (ref) => {
+  if (ref.type === "id") {
+    return ref.id;
+  }
+  return `${ref.name}@${ref.version}`;
+};
+const parseIntegrationRef = (ref) => {
+  if (uuid.validate(ref)) {
+    return { type: "id", id: ref };
+  }
+  if (!ref.includes("@")) {
+    return { type: "name", name: ref, version: LATEST_TAG };
+  }
+  const [name, version] = ref.split("@");
+  if (!name || !version) {
+    return;
+  }
+  const cleanedVersion = version === LATEST_TAG ? version : import_semver.default.clean(version);
+  if (!cleanedVersion) {
+    return;
+  }
+  return { type: "name", name, version: cleanedVersion };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatIntegrationRef,
+  parseIntegrationRef
+});

package/dist/logger/base-logger.js

@@ -89,7 +89,7 @@ class BaseLogger {
     this.opts = { ...DEFAULT_OPTIONS, ...opts };
   }
   log(message, props = {}) {
-    if (this.opts.json) {
+    if (this.opts.json && !props.stderr) {
       return;
     }
     const prefix = this._resolvePrefix(props.prefix);
@@ -102,44 +102,29 @@ class BaseLogger {
     }
     const { depth } = opts;
     const msg = import_util.default.inspect(data, { colors: true, depth });
-    this.print(msg);
+    this.log(msg);
   }
   debug(message, metadata) {
-    if (!this.opts.verbose || this.opts.json) {
+    if (!this.opts.verbose) {
       return;
     }
     this.log(import_chalk.default.grey(message), { metadata, prefix: { symbol: "\u25CF", fg: "blue" } });
   }
   started(message, metadata) {
-    if (this.opts.json) {
-      return;
-    }
     this.log(message, { metadata, prefix: { symbol: "\u25CB", fg: "purple" } });
   }
   success(message, metadata) {
-    if (this.opts.json) {
-      return;
-    }
     this.log(message, { metadata, prefix: { symbol: "\u2713", fg: "green" } });
   }
   warn(message, metadata) {
-    if (this.opts.json) {
-      return;
-    }
     this.log(message, { metadata, prefix: { symbol: "\u26A0", fg: "yellow" } });
   }
   error(message, metadata) {
-    if (this.opts.json) {
-      return;
-    }
-    this.log(message, { metadata, prefix: { symbol: "\xD7", fg: "red" } });
+    this.log(message, { metadata, prefix: { symbol: "\xD7", fg: "red" }, stderr: true });
   }
   box(message) {
-    if (this.opts.json) {
-      return;
-    }
     const box = (0, import_boxen.default)(message, BOX_OPTIONS);
-    this.print(box);
+    this.log(box);
   }
   _resolvePrefix(prefix) {
     if (!prefix) {

package/dist/logger/index.js

@@ -27,12 +27,13 @@ class Logger extends import_base_logger.BaseLogger {
   static _previousLine;
   print(message, props = {}) {
     this.cleanup();
+    const log = props.stderr ? console.error : console.info;
     const { metadata, prefix } = props;
     if (prefix) {
-      console.log(prefix, message, metadata ?? "");
+      log(prefix, message, metadata ?? "");
       return;
     }
-    console.log(message, metadata ?? "");
+    log(message, metadata ?? "");
   }
   line() {
     this.cleanup();

package/dist/path-utils.js

@@ -28,6 +28,7 @@ __export(path_utils_exports, {
   cwd: () => cwd,
   isAbsolute: () => isAbsolute,
   isPath: () => isPath,
+  join: () => join,
   relativeFrom: () => relativeFrom,
   rmExtension: () => rmExtension,
   toUnix: () => toUnix
@@ -37,6 +38,10 @@ var import_path = __toESM(require("path"));
 const cwd = () => process.cwd();
 const isAbsolute = (path) => import_path.default.isAbsolute(path);
 const isPath = (path) => isAbsolute(path) || path.startsWith(".");
+const join = (abs, ...paths) => {
+  const joined = import_path.default.join(abs, ...paths);
+  return import_path.default.normalize(joined);
+};
 const rmExtension = (filename) => filename.replace(/\.[^/.]+$/, "");
 const toUnix = (path) => path.split(import_path.default.sep).join(import_path.default.posix.sep);
 const absoluteFrom = (rootdir, target) => {
@@ -60,6 +65,7 @@ const relativeFrom = (rootdir, target) => {
   cwd,
   isAbsolute,
   isPath,
+  join,
   relativeFrom,
   rmExtension,
   toUnix

package/dist/register-yargs.js

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var register_yargs_exports = {};
+__export(register_yargs_exports, {
+  registerYargs: () => registerYargs
+});
+module.exports = __toCommonJS(register_yargs_exports);
+var import_yargs_extra = require("@bpinternal/yargs-extra");
+var import_lodash = __toESM(require("lodash"));
+var tree = __toESM(require("./command-tree"));
+const parseArguments = (schema, argv) => {
+  const yargsEnv = (0, import_yargs_extra.parseEnv)(schema, "BP");
+  return (0, import_yargs_extra.cleanupConfig)(schema, { ...argv, ...yargsEnv });
+};
+const registerYargs = (yargz, commands, props) => {
+  for (const cmdName in commands) {
+    const command = commands[cmdName];
+    if (tree.guards.command.isSubTree(command)) {
+      yargz.command(cmdName, command.description ?? cmdName, (y) => {
+        registerYargs(y, command.subcommands, props);
+        return y;
+      });
+      continue;
+    }
+    const { schema, description, alias } = command;
+    const aliases = alias ? [cmdName, alias] : [cmdName];
+    const options = Object.entries(schema);
+    let positionals = options.filter(
+      (value) => !!value[1].positional
+    );
+    let usage = aliases;
+    if (positionals.length) {
+      positionals = import_lodash.default.sortBy(positionals, ([, option]) => option.idx);
+      const positionalArgs = positionals.map(
+        ([optName, option]) => option.demandOption ? `<${optName}>` : `[${optName}]`
+      );
+      const positionalStr = positionalArgs.join(" ");
+      usage = aliases.map((optAlias) => `${optAlias} ${positionalStr}`);
+    }
+    yargz.command(
+      usage,
+      description ?? cmdName,
+      (y) => {
+        for (const [key, option] of Object.entries(schema)) {
+          if (option.positional) {
+            y = y.positional(key, option);
+          } else {
+            y = y.option(key, option);
+          }
+        }
+        return y;
+      },
+      async (argv) => {
+        const parsed = parseArguments(schema, argv);
+        await command.handler({ ...parsed, ...props });
+      }
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerYargs
+});

package/dist/typings.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/utils/cache-utils.js

@@ -0,0 +1,99 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_utils_exports = {};
+__export(cache_utils_exports, {
+  FSKeyValueCache: () => FSKeyValueCache
+});
+module.exports = __toCommonJS(cache_utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+class FSKeyValueCache {
+  constructor(_filepath) {
+    this._filepath = _filepath;
+  }
+  _initialized = false;
+  async init() {
+    if (this._initialized) {
+      return;
+    }
+    const dirname = import_path.default.dirname(this._filepath);
+    if (!import_fs.default.existsSync(dirname)) {
+      await import_fs.default.promises.mkdir(dirname, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(this._filepath)) {
+      await this._writeJSON(this._filepath, {});
+    }
+    this._initialized = true;
+  }
+  async sync(key, value, prompt) {
+    await this.init();
+    if (value) {
+      await this.set(key, value);
+      return value;
+    }
+    const data = await this.get(key);
+    const newValue = await prompt(data);
+    await this.set(key, newValue);
+    return newValue;
+  }
+  async has(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    return data[key] !== void 0;
+  }
+  async get(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    return data[key];
+  }
+  async set(key, value) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    data[key] = value;
+    return this._writeJSON(this._filepath, data);
+  }
+  async rm(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    delete data[key];
+    return this._writeJSON(this._filepath, data);
+  }
+  async clear() {
+    await this.init();
+    return this._writeJSON(this._filepath, {});
+  }
+  _writeJSON = (filepath, data) => {
+    const fileContent = JSON.stringify(data, null, 2);
+    return import_fs.default.promises.writeFile(filepath, fileContent);
+  };
+  _readJSON = async (filepath) => {
+    const fileContent = await import_fs.default.promises.readFile(filepath, "utf8");
+    return JSON.parse(fileContent);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FSKeyValueCache
+});