@botpress/cli 0.0.9 → 0.0.10

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

@@ -0,0 +1,111 @@
+"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 global_command_exports = {};
+__export(global_command_exports, {
+  GlobalCommand: () => GlobalCommand
+});
+module.exports = __toCommonJS(global_command_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_fs = __toESM(require("fs"));
+var import_latest_version = __toESM(require("latest-version"));
+var import_lodash = __toESM(require("lodash"));
+var pathlib = __toESM(require("path"));
+var consts = __toESM(require("../consts"));
+var errors = __toESM(require("../errors"));
+var utils = __toESM(require("../utils"));
+var import_base_command = require("./base-command");
+class GlobalPaths extends utils.path.PathStore {
+  constructor(argv) {
+    const absBotpressHome = utils.path.absoluteFrom(utils.path.cwd(), argv.botpressHome);
+    super({
+      cliRootDir: argv.cliRootDir,
+      botpressHomeDir: absBotpressHome,
+      ...import_lodash.default.mapValues(consts.fromHomeDir, (p) => utils.path.absoluteFrom(absBotpressHome, p)),
+      ...import_lodash.default.mapValues(consts.fromCliRootDir, (p) => utils.path.absoluteFrom(argv.cliRootDir, p))
+    });
+  }
+}
+const UPDATE_MSG = (props) => `${import_chalk.default.bold("Update available")} ${import_chalk.default.dim(props.version)} \u2192 ${import_chalk.default.green(props.latest)}
+
+To update, run:
+  for npm  ${import_chalk.default.cyan(`npm i -g ${props.name}`)}
+  for yarn ${import_chalk.default.cyan(`yarn global add ${props.name}`)}
+  for pnpm ${import_chalk.default.cyan(`pnpm i -g ${props.name}`)}`;
+class GlobalCommand extends import_base_command.BaseCommand {
+  api;
+  prompt;
+  constructor(api, prompt, ...args) {
+    super(...args);
+    this.api = api;
+    this.prompt = prompt;
+  }
+  get globalPaths() {
+    return new GlobalPaths(this.argv);
+  }
+  get globalCache() {
+    return new utils.cache.FSKeyValueCache(this.globalPaths.abs.globalCacheFile);
+  }
+  bootstrap = async () => {
+    const pkgJson = await this._readPackageJson();
+    const versionText = import_chalk.default.bold(`v${pkgJson.version}`);
+    this.logger.log(`Botpress CLI ${versionText}`, { prefix: "\u{1F916}" });
+    await this._notifyUpdate(pkgJson);
+    const paths = this.globalPaths;
+    if (paths.abs.botpressHomeDir !== consts.defaultBotpressHome) {
+      this.logger.log(`Using custom botpress home: ${paths.abs.botpressHomeDir}`, { prefix: "\u{1F3E0}" });
+    }
+  };
+  async ensureLoginAndCreateClient(credentials) {
+    const cache = this.globalCache;
+    const token = await cache.get("token");
+    const workspaceId = credentials.workspaceId ?? await cache.get("workspaceId");
+    const host = credentials.host ?? await cache.get("host");
+    if (!(token && workspaceId && host)) {
+      throw new errors.NotLoggedInError();
+    }
+    return this.api.newClient({ host, token, workspaceId }, this.logger);
+  }
+  _notifyUpdate = async (pkgJson) => {
+    try {
+      const latest = await (0, import_latest_version.default)(pkgJson.name);
+      if (latest !== pkgJson.version) {
+        this.logger.box(UPDATE_MSG({ ...pkgJson, latest }));
+      }
+    } catch (thrown) {
+      const err = errors.BotpressCLIError.map(thrown);
+      this.logger.debug(`Failed to check for updates: ${err.message}`);
+    }
+  };
+  _readPackageJson = async () => {
+    const path = pathlib.join(this.globalPaths.abs.cliRootDir, "package.json");
+    const strContent = await import_fs.default.promises.readFile(path, "utf8");
+    const jsonContent = JSON.parse(strContent);
+    return jsonContent;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GlobalCommand
+});

package/dist/command-implementations/index.js

@@ -0,0 +1,78 @@
+"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 command_implementations_exports = {};
+__export(command_implementations_exports, {
+  default: () => command_implementations_default
+});
+module.exports = __toCommonJS(command_implementations_exports);
+var import_api_client = require("../api-client");
+var import_logger = require("../logger");
+var utils = __toESM(require("../utils"));
+var import_add_command = require("./add-command");
+var bots = __toESM(require("./bot-commands"));
+var import_build_command = require("./build-command");
+var import_bundle_command = require("./bundle-command");
+var import_deploy_command = require("./deploy-command");
+var import_dev_command = require("./dev-command");
+var import_gen_command = require("./gen-command");
+var import_init_command = require("./init-command");
+var integrations = __toESM(require("./integration-commands"));
+var import_login_command = require("./login-command");
+var import_logout_command = require("./logout-command");
+var import_serve_command = require("./serve-command");
+const getHandler = (cls) => async (argv) => {
+  const logger = new import_logger.Logger(argv);
+  const prompt = new utils.prompt.CLIPrompt(argv, logger);
+  return new cls(import_api_client.ApiClient, prompt, logger, argv).handler();
+};
+var command_implementations_default = {
+  login: getHandler(import_login_command.LoginCommand),
+  logout: getHandler(import_logout_command.LogoutCommand),
+  bots: {
+    subcommands: {
+      create: getHandler(bots.CreateBotCommand),
+      get: getHandler(bots.GetBotCommand),
+      delete: getHandler(bots.DeleteBotCommand),
+      list: getHandler(bots.ListBotsCommand)
+    }
+  },
+  integrations: {
+    subcommands: {
+      get: getHandler(integrations.GetIntegrationCommand),
+      list: getHandler(integrations.ListIntegrationsCommand),
+      delete: getHandler(integrations.DeleteIntegrationCommand)
+    }
+  },
+  init: getHandler(import_init_command.InitCommand),
+  generate: getHandler(import_gen_command.GenerateCommand),
+  bundle: getHandler(import_bundle_command.BundleCommand),
+  build: getHandler(import_build_command.BuildCommand),
+  serve: getHandler(import_serve_command.ServeCommand),
+  deploy: getHandler(import_deploy_command.DeployCommand),
+  add: getHandler(import_add_command.AddCommand),
+  dev: getHandler(import_dev_command.DevCommand)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/command-implementations/init-command.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 init_command_exports = {};
+__export(init_command_exports, {
+  InitCommand: () => InitCommand
+});
+module.exports = __toCommonJS(init_command_exports);
+var import_chalk = __toESM(require("chalk"));
+var fs = __toESM(require("fs"));
+var pathlib = __toESM(require("path"));
+var consts = __toESM(require("../consts"));
+var errors = __toESM(require("../errors"));
+var utils = __toESM(require("../utils"));
+var import_global_command = require("./global-command");
+class InitCommand extends import_global_command.GlobalCommand {
+  async run() {
+    let { type: projectType } = this.argv;
+    if (!projectType) {
+      const promptedType = await this.prompt.select("What type of project do you wish to initialize?", {
+        choices: ["bot", "integration"].map((t) => ({ title: t, value: t }))
+      });
+      if (!promptedType) {
+        throw new errors.ParamRequiredError("Project Type");
+      }
+      projectType = promptedType;
+    }
+    const workDir = utils.path.absoluteFrom(utils.path.cwd(), this.argv.workDir);
+    if (projectType === "bot") {
+      const destination2 = pathlib.join(workDir, this.argv.name ?? consts.echoBotName);
+      const exist2 = await this._checkIfDestinationExists(destination2);
+      if (exist2) {
+        return;
+      }
+      await fs.promises.cp(this.globalPaths.abs.echoBotTemplate, destination2, { recursive: true });
+      this.logger.success(`Bot project initialized in ${import_chalk.default.bold(workDir)}`);
+      return;
+    }
+    const destination = pathlib.join(workDir, this.argv.name ?? consts.emptyIntegrationName);
+    const exist = await this._checkIfDestinationExists(destination);
+    if (exist) {
+      return;
+    }
+    await fs.promises.cp(this.globalPaths.abs.emptyIntegrationTemplate, destination, { recursive: true });
+    this.logger.success(`Integration project initialized in ${import_chalk.default.bold(this.argv.workDir)}`);
+    return;
+  }
+  _checkIfDestinationExists = async (destination) => {
+    if (fs.existsSync(destination)) {
+      const override = await this.prompt.confirm(
+        `Directory ${import_chalk.default.bold(destination)} already exists. Do you want to overwrite it?`
+      );
+      if (!override) {
+        this.logger.log("Aborting");
+        return true;
+      }
+    }
+    return false;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InitCommand
+});

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

@@ -0,0 +1,107 @@
+"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_commands_exports = {};
+__export(integration_commands_exports, {
+  DeleteIntegrationCommand: () => DeleteIntegrationCommand,
+  GetIntegrationCommand: () => GetIntegrationCommand,
+  ListIntegrationsCommand: () => ListIntegrationsCommand
+});
+module.exports = __toCommonJS(integration_commands_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_lodash = __toESM(require("lodash"));
+var errors = __toESM(require("../errors"));
+var import_integration_ref = require("../integration-ref");
+var import_global_command = require("./global-command");
+class GetIntegrationCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    const parsedRef = (0, import_integration_ref.parseIntegrationRef)(this.argv.integrationRef);
+    if (!parsedRef) {
+      throw new errors.InvalidIntegrationReferenceError(this.argv.integrationRef);
+    }
+    try {
+      const integration = await api.findIntegration(parsedRef);
+      if (integration) {
+        this.logger.success(`Integration ${import_chalk.default.bold(this.argv.integrationRef)}:`);
+        this.logger.json(integration);
+        return;
+      }
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not get integration ${this.argv.integrationRef}`);
+    }
+    throw new errors.BotpressCLIError(`Integration ${this.argv.integrationRef} not found`);
+  }
+}
+class ListIntegrationsCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    const privateLister = (req) => api.client.listIntegrations({ nextToken: req.nextToken, name: this.argv.name, version: this.argv.version });
+    const publicLister = (req) => api.client.listPublicIntegrations({ nextToken: req.nextToken, name: this.argv.name, version: this.argv.version });
+    try {
+      const privateIntegrations = await api.listAllPages(privateLister, (r) => r.integrations);
+      const publicIntegrations = await api.listAllPages(publicLister, (r) => r.integrations);
+      const integrations = import_lodash.default.uniqBy([...privateIntegrations, ...publicIntegrations], (i) => i.id);
+      this.logger.success("Integrations:");
+      this.logger.json(integrations);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not list integrations");
+    }
+  }
+}
+class DeleteIntegrationCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    const parsedRef = (0, import_integration_ref.parseIntegrationRef)(this.argv.integrationRef);
+    if (!parsedRef) {
+      throw new errors.InvalidIntegrationReferenceError(this.argv.integrationRef);
+    }
+    let integration;
+    try {
+      integration = await api.findPrivateIntegration(parsedRef);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not get integration ${this.argv.integrationRef}`);
+    }
+    if (!integration) {
+      const publicIntegration = await api.findPublicIntegration(parsedRef);
+      if (publicIntegration) {
+        throw new errors.BotpressCLIError(`Integration ${this.argv.integrationRef} does not belong to your workspace`);
+      }
+      throw new errors.BotpressCLIError(`Integration ${this.argv.integrationRef} not found`);
+    }
+    try {
+      await api.client.deleteIntegration({ id: integration.id });
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not delete integration ${this.argv.integrationRef}`);
+    }
+    this.logger.success(`Integration ${import_chalk.default.bold(this.argv.integrationRef)} deleted`);
+    return;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeleteIntegrationCommand,
+  GetIntegrationCommand,
+  ListIntegrationsCommand
+});

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

@@ -0,0 +1,75 @@
+"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 login_command_exports = {};
+__export(login_command_exports, {
+  LoginCommand: () => LoginCommand
+});
+module.exports = __toCommonJS(login_command_exports);
+var errors = __toESM(require("../errors"));
+var import_global_command = require("./global-command");
+class LoginCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const promptedToken = await this.globalCache.sync("token", this.argv.token, async (previousToken) => {
+      const prompted = await this.prompt.password("Enter your Personal Access Token", {
+        initial: previousToken
+      });
+      if (!prompted) {
+        throw new errors.ParamRequiredError("Personal Access Token");
+      }
+      return prompted;
+    });
+    const promptedWorkspaceId = await this.globalCache.sync("workspaceId", this.argv.workspaceId, async (defaultId) => {
+      const tmpApi = this.api.newClient({ host: this.argv.host, token: promptedToken }, this.logger);
+      const userWorkspaces = await tmpApi.listAllPages(tmpApi.client.listWorkspaces, (r) => r.workspaces).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, "Could not list workspaces");
+      });
+      if (userWorkspaces.length === 0) {
+        throw new errors.NoWorkspacesFoundError();
+      }
+      const initial = userWorkspaces.find((ws) => ws.id === defaultId);
+      const prompted = await this.prompt.select("Which workspace do you want to login to?", {
+        initial: initial && { title: initial.name, value: initial.id },
+        choices: userWorkspaces.map((ws) => ({ title: ws.name, value: ws.id }))
+      });
+      if (!prompted) {
+        throw new errors.ParamRequiredError("Workspace Id");
+      }
+      return prompted;
+    });
+    await this.globalCache.set("host", this.argv.host);
+    const api = this.api.newClient(
+      { host: this.argv.host, token: promptedToken, workspaceId: promptedWorkspaceId },
+      this.logger
+    );
+    await api.testLogin().catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Login failed. Please check your credentials");
+    });
+    this.logger.success("Logged In");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoginCommand
+});

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

@@ -0,0 +1,34 @@
+"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 logout_command_exports = {};
+__export(logout_command_exports, {
+  LogoutCommand: () => LogoutCommand
+});
+module.exports = __toCommonJS(logout_command_exports);
+var import_global_command = require("./global-command");
+class LogoutCommand extends import_global_command.GlobalCommand {
+  async run() {
+    await this.globalCache.clear();
+    this.logger.success("Logged Out");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogoutCommand
+});

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

@@ -0,0 +1,115 @@
+"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 project_command_exports = {};
+__export(project_command_exports, {
+  ProjectCommand: () => ProjectCommand
+});
+module.exports = __toCommonJS(project_command_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_fs = __toESM(require("fs"));
+var import_lodash = __toESM(require("lodash"));
+var import_path = __toESM(require("path"));
+var consts = __toESM(require("../consts"));
+var errors = __toESM(require("../errors"));
+var utils = __toESM(require("../utils"));
+var import_global_command = require("./global-command");
+class ProjectPaths extends utils.path.PathStore {
+  constructor(argv) {
+    const absWorkDir = utils.path.absoluteFrom(utils.path.cwd(), argv.workDir);
+    const absEntrypoint = utils.path.absoluteFrom(absWorkDir, argv.entryPoint);
+    const absOutDir = utils.path.absoluteFrom(absWorkDir, argv.outDir);
+    super({
+      workDir: absWorkDir,
+      entryPoint: absEntrypoint,
+      outDir: absOutDir,
+      ...import_lodash.default.mapValues(consts.fromOutDir, (p) => utils.path.absoluteFrom(absOutDir, p)),
+      ...import_lodash.default.mapValues(consts.fromWorkDir, (p) => utils.path.absoluteFrom(absWorkDir, p))
+    });
+  }
+}
+class ProjectCommand extends import_global_command.GlobalCommand {
+  get projectPaths() {
+    return new ProjectPaths(this.argv);
+  }
+  get projectCache() {
+    return new utils.cache.FSKeyValueCache(this.projectPaths.abs.projectCacheFile);
+  }
+  async readIntegrationDefinitionFromFS() {
+    const abs = this.projectPaths.abs;
+    const rel = this.projectPaths.rel("workDir");
+    if (!import_fs.default.existsSync(abs.definition)) {
+      this.logger.debug(`Integration definition not found at ${rel.definition}`);
+      return;
+    }
+    const { outputFiles } = await utils.esbuild.buildEntrypoint({
+      cwd: abs.workDir,
+      outfile: "",
+      entrypoint: rel.definition,
+      write: false
+    });
+    const artifact = outputFiles[0];
+    if (!artifact) {
+      throw new errors.BotpressCLIError("Could not read integration definition");
+    }
+    const { default: definition } = utils.require.requireJsCode(artifact.text);
+    return definition;
+  }
+  async writeGeneratedFilesToOutFolder(files) {
+    for (const file of files) {
+      const filePath = utils.path.absoluteFrom(this.projectPaths.abs.outDir, file.path);
+      const dirPath = import_path.default.dirname(filePath);
+      await import_fs.default.promises.mkdir(dirPath, { recursive: true });
+      await import_fs.default.promises.writeFile(filePath, file.content);
+    }
+  }
+  prepareIntegrations(botImpl, botInfo) {
+    const { integrations: integrationList } = botImpl;
+    const integrationsToUninstall = (0, import_lodash.default)(botInfo.integrations).keys().filter((key) => !integrationList?.map((i) => i.id).includes(key)).zipObject().mapValues(() => null).value();
+    const integrationsToInstall = (0, import_lodash.default)(integrationList ?? []).keyBy((i) => i.id).mapValues(({ enabled, configuration }) => ({ enabled, configuration })).value();
+    return { ...integrationsToUninstall, ...integrationsToInstall };
+  }
+  displayWebhookUrls(bot) {
+    if (!import_lodash.default.keys(bot.integrations).length) {
+      this.logger.log("No integrations in bot");
+      return;
+    }
+    this.logger.log("Integrations:");
+    for (const integration of Object.values(bot.integrations)) {
+      if (!integration.enabled) {
+        this.logger.log(`${import_chalk.default.grey(integration.name)} ${import_chalk.default.italic("(disabled)")}: ${integration.webhookUrl}`, {
+          prefix: { symbol: "\u25CB", indent: 2 }
+        });
+      } else {
+        this.logger.log(`${import_chalk.default.bold(integration.name)} : ${integration.webhookUrl}`, {
+          prefix: { symbol: "\u25CF", indent: 2 }
+        });
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProjectCommand
+});

package/dist/command-implementations/serve-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 serve_command_exports = {};
+__export(serve_command_exports, {
+  ServeCommand: () => ServeCommand
+});
+module.exports = __toCommonJS(serve_command_exports);
+var fs = __toESM(require("fs"));
+var errors = __toESM(require("../errors"));
+var utils = __toESM(require("../utils"));
+var import_project_command = require("./project-command");
+class ServeCommand extends import_project_command.ProjectCommand {
+  async run() {
+    const outfile = this.projectPaths.abs.outFile;
+    if (!fs.existsSync(outfile)) {
+      throw new errors.NoBundleFoundError();
+    }
+    const isIntegration = !!await this.readIntegrationDefinitionFromFS();
+    this.logger.log(`Serving ${isIntegration ? "integration" : "bot"}...`);
+    const { default: serveable } = utils.require.requireJsFile(outfile);
+    const server = await serveable.start(this.argv.port);
+    await new Promise((resolve, reject) => {
+      server.on("error", reject);
+      server.on("close", resolve);
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServeCommand
+});