@botpress/cli 0.0.8 → 0.0.10

package/dist/command-implementations/add-command.js

@@ -0,0 +1,124 @@
+"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 add_command_exports = {};
+__export(add_command_exports, {
+  AddCommand: () => AddCommand
+});
+module.exports = __toCommonJS(add_command_exports);
+var import_bluebird = __toESM(require("bluebird"));
+var import_chalk = __toESM(require("chalk"));
+var fs = __toESM(require("fs"));
+var pathlib = __toESM(require("path"));
+var codegen = __toESM(require("../code-generation"));
+var errors = __toESM(require("../errors"));
+var import_integration_ref = require("../integration-ref");
+var import_project_command = require("./project-command");
+class AddCommand extends import_project_command.ProjectCommand {
+  async run() {
+    const integrationDef = await this.readIntegrationDefinitionFromFS();
+    if (integrationDef) {
+      throw new errors.ExclusiveBotFeatureError();
+    }
+    const integrationRef = this.argv.integrationRef;
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    const parsedRef = (0, import_integration_ref.parseIntegrationRef)(integrationRef);
+    if (!parsedRef) {
+      throw new errors.InvalidIntegrationReferenceError(integrationRef);
+    }
+    const integration = await api.findIntegration(parsedRef);
+    if (!integration) {
+      throw new errors.BotpressCLIError(`Integration "${integrationRef}" not found`);
+    }
+    const allInstances = await this._listIntegrationInstances();
+    const existingInstance = allInstances.find((i) => i.name === integration.name);
+    if (existingInstance) {
+      this.logger.warn(`Integration with name "${integration.name}" already installed.`);
+      const res = await this.prompt.confirm("Do you want to overwrite the existing instance?");
+      if (!res) {
+        this.logger.log("Aborted");
+        return;
+      }
+      await this._uninstallIntegration(existingInstance);
+    }
+    await this._generateIntegrationInstance(integration);
+  }
+  async _listIntegrationInstances() {
+    const installPath = this.projectPaths.abs.installDir;
+    if (!fs.existsSync(installPath)) {
+      this.logger.debug("Install path does not exist. Skipping listing of integration instances");
+      return [];
+    }
+    const allFiles = await fs.promises.readdir(installPath);
+    const allPaths = allFiles.map((name) => pathlib.join(installPath, name));
+    const directories = await import_bluebird.default.filter(allPaths, async (path) => {
+      const stat = await fs.promises.stat(path);
+      return stat.isDirectory();
+    });
+    let jsons = directories.map((root) => ({ root, json: pathlib.join(root, codegen.INTEGRATION_JSON) }));
+    jsons = jsons.filter(({ json: x }) => fs.existsSync(x));
+    return import_bluebird.default.map(jsons, async ({ root, json }) => {
+      const content = await fs.promises.readFile(json, "utf-8");
+      const { name, version, id } = JSON.parse(content);
+      const dirname = pathlib.basename(root);
+      return {
+        dirname,
+        id,
+        name,
+        version
+      };
+    });
+  }
+  async _uninstallIntegration(instance) {
+    const installDir = this.projectPaths.abs.installDir;
+    const instancePath = pathlib.join(installDir, instance.dirname);
+    await fs.promises.rm(instancePath, { recursive: true });
+    await this._generateBotIndex();
+  }
+  async _generateIntegrationInstance(integration) {
+    const line = this.logger.line();
+    const { name, version } = integration;
+    line.started(`Installing ${import_chalk.default.bold(name)} v${version}...`);
+    const instanceFiles = await codegen.generateIntegrationInstance(
+      integration,
+      this.projectPaths.rel("outDir").installDir
+    );
+    await this.writeGeneratedFilesToOutFolder(instanceFiles);
+    await this._generateBotIndex();
+    const rel = this.projectPaths.rel("workDir");
+    line.success(`Installed integration available at ${import_chalk.default.grey(rel.outDir)}`);
+  }
+  async _generateBotIndex() {
+    const allInstances = await this._listIntegrationInstances();
+    const indexFile = await codegen.generateBotIndex(
+      this.projectPaths.rel("outDir").installDir,
+      allInstances.map((i) => i.dirname)
+    );
+    await this.writeGeneratedFilesToOutFolder([indexFile]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddCommand
+});

package/dist/command-implementations/base-command.js

@@ -0,0 +1,53 @@
+"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 base_command_exports = {};
+__export(base_command_exports, {
+  BaseCommand: () => BaseCommand
+});
+module.exports = __toCommonJS(base_command_exports);
+var errors = __toESM(require("../errors"));
+class BaseCommand {
+  constructor(logger, argv) {
+    this.logger = logger;
+    this.argv = argv;
+  }
+  async handler() {
+    try {
+      if (this.bootstrap) {
+        await this.bootstrap();
+      }
+      await this.run();
+    } catch (thrown) {
+      const error = errors.BotpressCLIError.map(thrown);
+      this.logger.error(error.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseCommand
+});

package/dist/command-implementations/bot-commands.js

@@ -0,0 +1,89 @@
+"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 bot_commands_exports = {};
+__export(bot_commands_exports, {
+  CreateBotCommand: () => CreateBotCommand,
+  DeleteBotCommand: () => DeleteBotCommand,
+  GetBotCommand: () => GetBotCommand,
+  ListBotsCommand: () => ListBotsCommand
+});
+module.exports = __toCommonJS(bot_commands_exports);
+var import_chalk = __toESM(require("chalk"));
+var errors = __toESM(require("../errors"));
+var import_global_command = require("./global-command");
+class GetBotCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const { client } = await this.ensureLoginAndCreateClient(this.argv);
+    try {
+      const { bot } = await client.getBot({ id: this.argv.botRef });
+      this.logger.success(`Bot ${import_chalk.default.bold(this.argv.botRef)}:`);
+      this.logger.json(bot);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not get bot ${this.argv.botRef}`);
+    }
+  }
+}
+class ListBotsCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    try {
+      const bots = await api.listAllPages(api.client.listBots, (r) => r.bots);
+      this.logger.success("Bots:");
+      this.logger.json(bots);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not list bots");
+    }
+  }
+}
+class DeleteBotCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const { client } = await this.ensureLoginAndCreateClient(this.argv);
+    try {
+      await client.deleteBot({ id: this.argv.botRef });
+      this.logger.success(`Bot ${import_chalk.default.bold(this.argv.botRef)} deleted`);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not delete bot ${this.argv.botRef}`);
+    }
+  }
+}
+class CreateBotCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const { client } = await this.ensureLoginAndCreateClient(this.argv);
+    try {
+      const { bot } = await client.createBot({ name: this.argv.name });
+      this.logger.success(`Bot ${import_chalk.default.bold(bot.id)}:`);
+      this.logger.json(bot);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not create bot");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateBotCommand,
+  DeleteBotCommand,
+  GetBotCommand,
+  ListBotsCommand
+});

package/dist/command-implementations/build-command.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var build_command_exports = {};
+__export(build_command_exports, {
+  BuildCommand: () => BuildCommand
+});
+module.exports = __toCommonJS(build_command_exports);
+var import_bundle_command = require("./bundle-command");
+var import_gen_command = require("./gen-command");
+var import_project_command = require("./project-command");
+class BuildCommand extends import_project_command.ProjectCommand {
+  async run() {
+    const t0 = Date.now();
+    const integrationDef = await this.readIntegrationDefinitionFromFS();
+    if (integrationDef) {
+      await this._runGenerate();
+    }
+    await this._runBundle();
+    const dt = Date.now() - t0;
+    this.logger.log(`Build completed in ${dt}ms`);
+  }
+  _runGenerate() {
+    return new import_gen_command.GenerateCommand(this.api, this.prompt, this.logger, this.argv).run();
+  }
+  _runBundle() {
+    return new import_bundle_command.BundleCommand(this.api, this.prompt, this.logger, this.argv).run();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuildCommand
+});

package/dist/command-implementations/bundle-command.js

@@ -0,0 +1,58 @@
+"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 bundle_command_exports = {};
+__export(bundle_command_exports, {
+  BundleCommand: () => BundleCommand
+});
+module.exports = __toCommonJS(bundle_command_exports);
+var import_chalk = __toESM(require("chalk"));
+var utils = __toESM(require("../utils"));
+var import_project_command = require("./project-command");
+class BundleCommand extends import_project_command.ProjectCommand {
+  async run() {
+    const integrationDef = await this.readIntegrationDefinitionFromFS();
+    const abs = this.projectPaths.abs;
+    const rel = this.projectPaths.rel("workDir");
+    const line = this.logger.line();
+    const logLevel = this.argv.verbose ? "info" : "silent";
+    if (integrationDef) {
+      const { name } = integrationDef;
+      line.started(`Bundling integration ${import_chalk.default.bold(name)}...`);
+    } else {
+      line.started("Bundling bot...");
+    }
+    const unixPath = utils.path.toUnix(rel.entryPoint);
+    const importFrom = utils.path.rmExtension(unixPath);
+    const code = `import x from './${importFrom}'; export default x; export const handler = x.handler;`;
+    const outfile = abs.outFile;
+    line.debug(`Writing bundle to ${outfile}`);
+    await utils.esbuild.buildCode({ code, cwd: abs.workDir, outfile, logLevel, write: true });
+    line.success(`Bundle available at ${import_chalk.default.grey(rel.outDir)}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BundleCommand
+});

package/dist/command-implementations/deploy-command.js

@@ -0,0 +1,162 @@
+"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 deploy_command_exports = {};
+__export(deploy_command_exports, {
+  DeployCommand: () => DeployCommand
+});
+module.exports = __toCommonJS(deploy_command_exports);
+var import_chalk = __toESM(require("chalk"));
+var fs = __toESM(require("fs"));
+var consts = __toESM(require("../consts"));
+var errors = __toESM(require("../errors"));
+var utils = __toESM(require("../utils"));
+var import_build_command = require("./build-command");
+var import_project_command = require("./project-command");
+class DeployCommand extends import_project_command.ProjectCommand {
+  async run() {
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    if (api.host !== consts.defaultBotpressApi) {
+      this.logger.log(`Using custom host ${api.host}`);
+    }
+    if (!this.argv.noBuild) {
+      await this._runBuild();
+    }
+    const integrationDef = await this.readIntegrationDefinitionFromFS();
+    if (integrationDef) {
+      return this._deployIntegration(api, integrationDef);
+    }
+    return this._deployBot(api, this.argv.botId, this.argv.createNewBot);
+  }
+  async _runBuild() {
+    return new import_build_command.BuildCommand(this.api, this.prompt, this.logger, this.argv).run();
+  }
+  async _deployIntegration(api, integrationDef) {
+    const outfile = this.projectPaths.abs.outFile;
+    const code = await fs.promises.readFile(outfile, "utf-8");
+    const { name, version } = integrationDef;
+    const integration = await api.findIntegration({ type: "name", name, version });
+    let message;
+    if (integration) {
+      this.logger.warn("Integration already exists. If you decide to deploy, it will overwrite the existing one.");
+      message = `Are you sure you want to override integration ${integrationDef.name} v${integrationDef.version}?`;
+    } else {
+      message = `Are you sure you want to deploy integration ${integrationDef.name} v${integrationDef.version}?`;
+    }
+    const confirm = await this.prompt.confirm(message);
+    if (!confirm) {
+      this.logger.log("Aborted");
+      return;
+    }
+    const line = this.logger.line();
+    line.started(`Deploying integration ${import_chalk.default.bold(integrationDef.name)} v${integrationDef.version}...`);
+    if (integration) {
+      await api.client.updateIntegration({ id: integration.id, ...integrationDef, code }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not update integration "${integrationDef.name}"`);
+      });
+    } else {
+      await api.client.createIntegration({ ...integrationDef, code }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not create integration "${integrationDef.name}"`);
+      });
+    }
+    line.success("Integration deployed");
+  }
+  async _deployBot(api, argvBotId, argvCreateNew) {
+    const outfile = this.projectPaths.abs.outFile;
+    const code = await fs.promises.readFile(outfile, "utf-8");
+    const { default: botImpl } = utils.require.requireJsFile(outfile);
+    const { tags, states, events, recurringEvents, configuration: botConfiguration } = botImpl;
+    let bot;
+    if (argvBotId && argvCreateNew) {
+      throw new errors.BotpressCLIError("Cannot specify both --botId and --createNew");
+    } else if (argvCreateNew) {
+      const confirm = await this.prompt.confirm("Are you sure you want to create a new bot ?");
+      if (!confirm) {
+        this.logger.log("Aborted");
+        return;
+      }
+      bot = await this._createNewBot(api);
+    } else {
+      bot = await this._getExistingBot(api, argvBotId);
+      const confirm = await this.prompt.confirm(`Are you sure you want to deploy the bot "${bot.name}"?`);
+      if (!confirm) {
+        this.logger.log("Aborted");
+        return;
+      }
+    }
+    const integrations = this.prepareIntegrations(botImpl, bot);
+    const line = this.logger.line();
+    line.started(`Deploying bot ${import_chalk.default.bold(bot.name)}...`);
+    const { bot: updatedBot } = await api.client.updateBot({
+      id: bot.id,
+      code,
+      states,
+      recurringEvents,
+      configuration: botConfiguration,
+      events,
+      tags,
+      integrations
+    }).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not update bot "${bot.name}"`);
+    });
+    line.success("Bot deployed");
+    this.displayWebhookUrls(updatedBot);
+  }
+  async _createNewBot(api) {
+    const line = this.logger.line();
+    const { bot: createdBot } = await api.client.createBot({}).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not create bot");
+    });
+    line.success(`Bot created with ID "${createdBot.id}" and name "${createdBot.name}"`);
+    await this.projectCache.set("botId", createdBot.id);
+    return createdBot;
+  }
+  async _getExistingBot(api, botId) {
+    const promptedBotId = await this.projectCache.sync("botId", botId, async (defaultId) => {
+      const userBots = await api.listAllPages(api.client.listBots, (r) => r.bots).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, "Could not fetch existing bots");
+      });
+      if (!userBots.length) {
+        throw new errors.NoBotsFoundError();
+      }
+      const initial = userBots.find((bot) => bot.id === defaultId);
+      const prompted = await this.prompt.select("Which bot do you want to deploy?", {
+        initial: initial && { title: initial.name, value: initial.id },
+        choices: userBots.map((bot) => ({ title: bot.name, value: bot.id }))
+      });
+      if (!prompted) {
+        throw new errors.ParamRequiredError("Bot Id");
+      }
+      return prompted;
+    });
+    const { bot: fetchedBot } = await api.client.getBot({ id: promptedBotId }).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not get bot info");
+    });
+    return fetchedBot;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeployCommand
+});