@botpress/cli 0.0.9 → 0.0.10

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
+});

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

@@ -0,0 +1,168 @@
+"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 dev_command_exports = {};
+__export(dev_command_exports, {
+  DevCommand: () => DevCommand
+});
+module.exports = __toCommonJS(dev_command_exports);
+var import_chalk = __toESM(require("chalk"));
+var pathlib = __toESM(require("path"));
+var errors = __toESM(require("../errors"));
+var utils = __toESM(require("../utils"));
+var import_worker = require("../worker");
+var import_build_command = require("./build-command");
+var import_project_command = require("./project-command");
+class DevCommand extends import_project_command.ProjectCommand {
+  async run() {
+    this.logger.warn("This command is experimental and subject to breaking changes without notice.");
+    if (!this.argv.noBuild) {
+      await this._runBuild();
+    }
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    const integrationDef = await this.readIntegrationDefinitionFromFS();
+    if (integrationDef) {
+      await this._deployDevIntegration(api, this.argv.url, integrationDef);
+    } else {
+      await this._deployDevBot(api, this.argv.url);
+    }
+    const outfile = this.projectPaths.abs.outFile;
+    const importPath = utils.path.toUnix(outfile);
+    const requireFrom = utils.path.rmExtension(importPath);
+    const code = `require('${requireFrom}').default.start(${this.argv.port})`;
+    const worker = await import_worker.Worker.spawn(
+      {
+        type: "code",
+        code,
+        env: {
+          BP_API_URL: api.host,
+          BP_TOKEN: api.token
+        }
+      },
+      this.logger
+    ).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not start dev worker");
+    });
+    try {
+      const watcher = await utils.filewatcher.FileWatcher.watch(
+        this.argv.workDir,
+        async (events) => {
+          const typescriptEvents = events.filter((e) => pathlib.extname(e.path) === ".ts");
+          if (typescriptEvents.length === 0) {
+            return;
+          }
+          this.logger.log("Changes detected, reloading...");
+          await this._runBuild();
+          await worker.reload();
+        },
+        { ignore: [this.projectPaths.abs.outDir] }
+      );
+      await Promise.race([worker.wait(), watcher.wait()]);
+      await watcher.close();
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "An error occurred while running the dev worker");
+    } finally {
+      if (worker.running) {
+        await worker.kill();
+      }
+    }
+  }
+  _runBuild() {
+    return new import_build_command.BuildCommand(this.api, this.prompt, this.logger, this.argv).run();
+  }
+  async _deployDevIntegration(api, externalUrl, integrationDef) {
+    const devId = await this.projectCache.get("devId");
+    let integration = void 0;
+    if (devId) {
+      const resp = await api.client.getIntegration({ id: devId }).catch(async (thrown) => {
+        const err = errors.BotpressCLIError.wrap(thrown, `Could not find existing dev integration with id "${devId}"`);
+        this.logger.warn(err.message);
+        return { integration: void 0 };
+      });
+      if (resp.integration?.dev) {
+        integration = resp.integration;
+      } else {
+        await this.projectCache.rm("devId");
+      }
+    }
+    const line = this.logger.line();
+    line.started(`Deploying dev integration ${import_chalk.default.bold(integrationDef.name)}...`);
+    if (integration) {
+      const resp = await api.client.updateIntegration({ ...integrationDef, id: integration.id, url: externalUrl }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not update dev integration "${integrationDef.name}"`);
+      });
+      integration = resp.integration;
+    } else {
+      const resp = await api.client.createIntegration({ ...integrationDef, dev: true, url: externalUrl }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not deploy dev integration "${integrationDef.name}"`);
+      });
+      integration = resp.integration;
+    }
+    line.success(`Dev Integration deployed with id "${integration.id}"`);
+    await this.projectCache.set("devId", integration.id);
+  }
+  async _deployDevBot(api, externalUrl) {
+    const devId = await this.projectCache.get("devId");
+    let bot = void 0;
+    if (devId) {
+      const resp = await api.client.getBot({ id: devId }).catch(async (thrown) => {
+        const err = errors.BotpressCLIError.wrap(thrown, `Could not find existing dev bot with id "${devId}"`);
+        this.logger.warn(err.message);
+        return { bot: void 0 };
+      });
+      if (resp.bot?.dev) {
+        bot = resp.bot;
+      } else {
+        await this.projectCache.rm("devId");
+      }
+    }
+    if (!bot) {
+      const createLine = this.logger.line();
+      createLine.started("Creating dev bot...");
+      const resp = await api.client.createBot({
+        dev: true,
+        url: externalUrl
+      }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, "Could not deploy dev bot");
+      });
+      bot = resp.bot;
+      createLine.success(`Dev Bot created with id "${bot.id}"`);
+      await this.projectCache.set("devId", bot.id);
+    }
+    const outfile = this.projectPaths.abs.outFile;
+    const { default: botImpl } = utils.require.requireJsFile(outfile);
+    const integrations = this.prepareIntegrations(botImpl, bot);
+    const updateLine = this.logger.line();
+    updateLine.started("Updating bot integrations...");
+    const { bot: updatedBot } = await api.client.updateBot({ id: bot.id, integrations, url: externalUrl }).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not deploy dev bot");
+    });
+    updateLine.success("Integrations installed successfully");
+    this.displayWebhookUrls(updatedBot);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevCommand
+});

package/dist/command-implementations/gen-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 gen_command_exports = {};
+__export(gen_command_exports, {
+  GenerateCommand: () => GenerateCommand
+});
+module.exports = __toCommonJS(gen_command_exports);
+var import_chalk = __toESM(require("chalk"));
+var codegen = __toESM(require("../code-generation"));
+var import_project_command = require("./project-command");
+class GenerateCommand extends import_project_command.ProjectCommand {
+  async run() {
+    const integrationDef = await this.readIntegrationDefinitionFromFS();
+    if (!integrationDef) {
+      this.logger.warn("No typings to generate for bot");
+      return;
+    }
+    const line = this.logger.line();
+    const { name } = integrationDef;
+    line.started(`Generating typings for integration ${import_chalk.default.bold(name)}...`);
+    const fromWorkDir = this.projectPaths.rel("workDir");
+    const fromOutDir = this.projectPaths.rel("outDir");
+    const typingFiles = await codegen.generateIntegrationImplementationTypings(
+      integrationDef,
+      fromOutDir.implementationDir
+    );
+    const indexFile = await codegen.generateIntegrationIndex(fromOutDir.implementationDir);
+    const generatedFiles = [...typingFiles, indexFile];
+    await this.writeGeneratedFilesToOutFolder(generatedFiles);
+    line.success(`Typings available at ${import_chalk.default.grey(fromWorkDir.outDir)}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenerateCommand
+});