@botpress/cli 0.0.8 → 0.0.10

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

package/dist/command-tree.js

@@ -0,0 +1,59 @@
+"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 command_tree_exports = {};
+__export(command_tree_exports, {
+  guards: () => guards,
+  zipTree: () => zipTree
+});
+module.exports = __toCommonJS(command_tree_exports);
+const guards = {
+  definition: {
+    isDef: (x) => "schema" in x,
+    isSubTree: (x) => "subcommands" in x
+  },
+  implementation: {
+    isImpl: (x) => typeof x === "function",
+    isSubTree: (x) => typeof x === "object"
+  },
+  command: {
+    isLeaf: (x) => "handler" in x,
+    isSubTree: (x) => "subcommands" in x
+  }
+};
+const zipTree = (defTree, implTree) => {
+  const tree = {};
+  for (const key in defTree) {
+    const def = defTree[key];
+    const impl = implTree[key];
+    if (guards.definition.isDef(def) && guards.implementation.isImpl(impl)) {
+      tree[key] = { ...def, handler: impl };
+      continue;
+    }
+    if (guards.definition.isSubTree(def) && guards.implementation.isSubTree(impl)) {
+      tree[key] = { ...def, subcommands: zipTree(def.subcommands, impl.subcommands) };
+      continue;
+    }
+  }
+  return tree;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  guards,
+  zipTree
+});

package/dist/config.js

@@ -6,8 +6,8 @@ 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 });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -35,6 +35,7 @@ __export(config_exports, {
   devSchema: () => devSchema,
   generateSchema: () => generateSchema,
   globalSchema: () => globalSchema,
+  initSchema: () => initSchema,
   integrationRef: () => integrationRef,
   listBotsSchema: () => listBotsSchema,
   listIntegrationsSchema: () => listIntegrationsSchema,
@@ -80,11 +81,6 @@ const entryPoint = {
   description: "The entry point of the project",
   default: consts.defaultEntrypoint
 };
-const definition = {
-  type: "string",
-  description: "The integration definition file to use. If file not found, the project is treated as a bot",
-  default: consts.defaultIntegrationConfigScript
-};
 const outDir = {
   type: "string",
   description: "The output directory",
@@ -125,6 +121,14 @@ const workspaceId = {
   type: "string",
   description: "The Workspace Id to deploy to"
 };
+const type = {
+  type: "string",
+  choices: ["bot", "integration"]
+};
+const name = {
+  type: "string",
+  description: "The name of the project"
+};
 const botRef = {
   type: "string",
   description: "The bot ID. Bot Name is not supported.",
@@ -144,7 +148,6 @@ const globalSchema = {
 const projectSchema = {
   ...globalSchema,
   entryPoint,
-  definition,
   outDir,
   workDir
 };
@@ -224,6 +227,12 @@ const deleteIntegrationSchema = {
   ...globalSchema,
   ...loggedInSchema
 };
+const initSchema = {
+  ...globalSchema,
+  workDir,
+  type,
+  name
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addSchema,
@@ -237,6 +246,7 @@ const deleteIntegrationSchema = {
   devSchema,
   generateSchema,
   globalSchema,
+  initSchema,
   integrationRef,
   listBotsSchema,
   listIntegrationsSchema,

package/dist/consts.js

@@ -28,10 +28,13 @@ __export(consts_exports, {
   defaultBotpressApp: () => defaultBotpressApp,
   defaultBotpressHome: () => defaultBotpressHome,
   defaultEntrypoint: () => defaultEntrypoint,
-  defaultIntegrationConfigScript: () => defaultIntegrationConfigScript,
   defaultOutputFolder: () => defaultOutputFolder,
-  relativeToHomeFolder: () => relativeToHomeFolder,
-  relativeToOutFolder: () => relativeToOutFolder
+  echoBotName: () => echoBotName,
+  emptyIntegrationName: () => emptyIntegrationName,
+  fromCliRootDir: () => fromCliRootDir,
+  fromHomeDir: () => fromHomeDir,
+  fromOutDir: () => fromOutDir,
+  fromWorkDir: () => fromWorkDir
 });
 module.exports = __toCommonJS(consts_exports);
 var import_os = __toESM(require("os"));
@@ -39,13 +42,22 @@ var import_path = __toESM(require("path"));
 const defaultBotpressHome = import_path.default.join(import_os.default.homedir(), ".botpress");
 const defaultOutputFolder = ".botpress";
 const defaultEntrypoint = import_path.default.join("src", "index.ts");
-const defaultIntegrationConfigScript = "integration.definition.ts";
 const defaultBotpressApi = "https://api.botpress.cloud";
 const defaultBotpressApp = "https://app.botpress.cloud";
-const relativeToHomeFolder = {
+const echoBotName = "echo-bot";
+const emptyIntegrationName = "empty-integration";
+const fromCliRootDir = {
+  packageJson: "package.json",
+  echoBotTemplate: import_path.default.join("templates", echoBotName),
+  emptyIntegrationTemplate: import_path.default.join("templates", emptyIntegrationName)
+};
+const fromHomeDir = {
   userCacheFile: "user.cache.json"
 };
-const relativeToOutFolder = {
+const fromWorkDir = {
+  definition: "integration.definition.ts"
+};
+const fromOutDir = {
   distDir: "dist",
   outFile: import_path.default.join("dist", "index.js"),
   installDir: "installations",
@@ -58,8 +70,11 @@ const relativeToOutFolder = {
   defaultBotpressApp,
   defaultBotpressHome,
   defaultEntrypoint,
-  defaultIntegrationConfigScript,
   defaultOutputFolder,
-  relativeToHomeFolder,
-  relativeToOutFolder
+  echoBotName,
+  emptyIntegrationName,
+  fromCliRootDir,
+  fromHomeDir,
+  fromOutDir,
+  fromWorkDir
 });

package/dist/errors.js

@@ -0,0 +1,156 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  BotpressCLIError: () => BotpressCLIError,
+  ExclusiveBotFeatureError: () => ExclusiveBotFeatureError,
+  ExclusiveIntegrationFeatureError: () => ExclusiveIntegrationFeatureError,
+  HTTPError: () => HTTPError,
+  InvalidIntegrationReferenceError: () => InvalidIntegrationReferenceError,
+  NoBotsFoundError: () => NoBotsFoundError,
+  NoBundleFoundError: () => NoBundleFoundError,
+  NoWorkspacesFoundError: () => NoWorkspacesFoundError,
+  NotLoggedInError: () => NotLoggedInError,
+  ParamRequiredError: () => ParamRequiredError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_client = require("@botpress/client");
+var import_axios = __toESM(require("axios"));
+var import_verror = require("verror");
+var consts = __toESM(require("./consts"));
+const isKnownApiError = (e) => (0, import_client.isApiError)(e) && !(e instanceof import_client.UnknownError);
+class BotpressCLIError extends import_verror.VError {
+  static wrap(thrown, message) {
+    const err = BotpressCLIError.map(thrown);
+    return new BotpressCLIError(err, message ?? "");
+  }
+  static map(thrown) {
+    if (thrown instanceof import_client.UnknownError) {
+      return new HTTPError(500, "An unknown error has occurred.");
+    }
+    if (isKnownApiError(thrown)) {
+      return HTTPError.fromApi(thrown);
+    }
+    if (import_axios.default.isAxiosError(thrown)) {
+      return HTTPError.fromAxios(thrown);
+    }
+    if (thrown instanceof Error) {
+      const { message } = thrown;
+      return new BotpressCLIError(message);
+    }
+    return new BotpressCLIError(`${thrown}`);
+  }
+}
+class ExclusiveBotFeatureError extends BotpressCLIError {
+  constructor() {
+    const message = "This feature is only available for bots. This project is an integration";
+    super(message);
+  }
+}
+class ExclusiveIntegrationFeatureError extends BotpressCLIError {
+  constructor() {
+    const message = "This feature is only available for integration. This project is a bot";
+    super(message);
+  }
+}
+class HTTPError extends BotpressCLIError {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  static fromAxios(e) {
+    const message = this._axiosMsg(e);
+    return new HTTPError(e.response?.status, message);
+  }
+  static fromApi(e) {
+    const { message, code } = e;
+    return new HTTPError(code, message);
+  }
+  static _axiosMsg(e) {
+    let message = e.message;
+    if (e.response?.statusText) {
+      message += `
+  ${e.response?.statusText}`;
+    }
+    if (e.response?.status && e.request?.method && e.request?.path) {
+      message += `
+  (${e.response?.status}) ${e.request.method} ${e.request.path}`;
+    }
+    if (e.response?.data?.message) {
+      message += `
+  ${e.response?.data?.message}`;
+    }
+    return message;
+  }
+}
+class NoBundleFoundError extends BotpressCLIError {
+  constructor() {
+    const message = "No bundle found. Please run `bp bundle` first.";
+    super(message);
+  }
+}
+class NoBotsFoundError extends BotpressCLIError {
+  constructor() {
+    const message = `No Bot found in your Workspace. Please create one first at ${consts.defaultBotpressApp}.`;
+    super(message);
+  }
+}
+class NoWorkspacesFoundError extends BotpressCLIError {
+  constructor() {
+    const message = "No Workspace found. Please create one first.";
+    super(message);
+  }
+}
+class NotLoggedInError extends BotpressCLIError {
+  constructor() {
+    const message = "Not logged in. Please run `bp login` first.";
+    super(message);
+  }
+}
+class ParamRequiredError extends BotpressCLIError {
+  constructor(param) {
+    const message = `${param} is required.`;
+    super(message);
+  }
+}
+class InvalidIntegrationReferenceError extends BotpressCLIError {
+  constructor(ref) {
+    const message = `Invalid integration reference "${ref}".`;
+    super(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotpressCLIError,
+  ExclusiveBotFeatureError,
+  ExclusiveIntegrationFeatureError,
+  HTTPError,
+  InvalidIntegrationReferenceError,
+  NoBotsFoundError,
+  NoBundleFoundError,
+  NoWorkspacesFoundError,
+  NotLoggedInError,
+  ParamRequiredError
+});