@botpress/cli 0.0.9 → 0.0.11

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

@@ -24,85 +24,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var config_exports = {};
 __export(config_exports, {
-  addSchema: () => addSchema,
-  botRef: () => botRef,
-  buildSchema: () => buildSchema,
-  bundleSchema: () => bundleSchema,
-  createBotSchema: () => createBotSchema,
-  deleteBotSchema: () => deleteBotSchema,
-  deleteIntegrationSchema: () => deleteIntegrationSchema,
-  deploySchema: () => deploySchema,
-  devSchema: () => devSchema,
-  generateSchema: () => generateSchema,
-  globalSchema: () => globalSchema,
-  integrationRef: () => integrationRef,
-  listBotsSchema: () => listBotsSchema,
-  listIntegrationsSchema: () => listIntegrationsSchema,
-  loggedInSchema: () => loggedInSchema,
-  loginSchema: () => loginSchema,
-  logoutSchema: () => logoutSchema,
-  projectSchema: () => projectSchema,
-  readBotSchema: () => readBotSchema,
-  readIntegrationSchema: () => readIntegrationSchema,
-  serveSchema: () => serveSchema
+  schemas: () => schemas
 });
 module.exports = __toCommonJS(config_exports);
 var consts = __toESM(require("./consts"));
-const botpressHome = {
-  type: "string",
-  description: "The path to the Botpress home directory",
-  default: consts.defaultBotpressHome
-};
-const verbose = {
-  type: "boolean",
-  description: "Enable verbose logging",
-  alias: "v",
-  default: false
-};
-const json = {
-  type: "boolean",
-  description: "Prevent logging anything else than raw json. Useful for piping output to other tools",
-  alias: "j",
-  default: false
-};
-const confirm = {
-  type: "boolean",
-  description: "Confirm all prompts",
-  alias: "y",
-  default: false
-};
 const port = {
   type: "number",
   description: "The port to use"
 };
-const entryPoint = {
-  type: "string",
-  description: "The entry point of the project",
-  default: consts.defaultEntrypoint
-};
-const outDir = {
-  type: "string",
-  description: "The output directory",
-  default: consts.defaultOutputFolder
-};
 const workDir = {
   type: "string",
   description: "The path to the project",
   default: process.cwd()
 };
-const botId = {
-  type: "string",
-  description: "The bot ID to deploy. Only used when deploying a bot"
-};
-const createNewBot = {
-  type: "boolean",
-  description: "Create a new bot when deploying. Only used when deploying a bot"
-};
-const url = {
-  type: "string",
-  description: "The publicly available URL of the bot or integration (often using ngrok)",
-  demandOption: true
-};
 const noBuild = {
   type: "boolean",
   description: "Skip the build step",
@@ -123,26 +57,48 @@ const workspaceId = {
 const botRef = {
   type: "string",
   description: "The bot ID. Bot Name is not supported.",
-  demandOption: true
+  demandOption: true,
+  positional: true,
+  idx: 0
 };
 const integrationRef = {
   type: "string",
   description: "The integration ID or name with optionnal version. Ex: teams or teams@0.2.0",
-  demandOption: true
+  demandOption: true,
+  positional: true,
+  idx: 0
 };
 const globalSchema = {
-  verbose,
-  confirm,
-  json,
-  botpressHome
+  verbose: {
+    type: "boolean",
+    description: "Enable verbose logging",
+    alias: "v",
+    default: false
+  },
+  confirm: {
+    type: "boolean",
+    description: "Confirm all prompts",
+    alias: "y",
+    default: false
+  },
+  json: {
+    type: "boolean",
+    description: "Prevent logging anything else than raw json in stdout. Useful for piping output to other tools",
+    default: false
+  },
+  botpressHome: {
+    type: "string",
+    description: "The path to the Botpress home directory",
+    default: consts.defaultBotpressHome
+  }
 };
 const projectSchema = {
   ...globalSchema,
-  entryPoint,
-  outDir,
+  entryPoint: { type: "string", description: "The entry point of the project", default: consts.defaultEntrypoint },
+  outDir: { type: "string", description: "The output directory", default: consts.defaultOutputFolder },
   workDir
 };
-const loggedInSchema = {
+const credentialsSchema = {
   host,
   workspaceId,
   token
@@ -162,21 +118,26 @@ const serveSchema = {
 };
 const deploySchema = {
   ...projectSchema,
-  ...loggedInSchema,
-  botId,
+  ...credentialsSchema,
+  botId: { type: "string", description: "The bot ID to deploy. Only used when deploying a bot" },
   noBuild,
-  createNewBot
+  createNewBot: { type: "boolean", description: "Create a new bot when deploying. Only used when deploying a bot" }
 };
 const devSchema = {
   ...projectSchema,
-  ...loggedInSchema,
-  url,
+  ...credentialsSchema,
+  url: {
+    type: "string",
+    description: "The publicly available URL of the bot or integration (often using ngrok)",
+    demandOption: true
+  },
   port,
   noBuild
 };
 const addSchema = {
   ...projectSchema,
-  ...loggedInSchema
+  ...credentialsSchema,
+  integrationRef
 };
 const loginSchema = {
   ...globalSchema,
@@ -189,56 +150,68 @@ const logoutSchema = {
 };
 const createBotSchema = {
   ...globalSchema,
-  ...loggedInSchema,
+  ...credentialsSchema,
   name: { type: "string", description: "The name of the bot to create" }
 };
-const readBotSchema = {
+const getBotSchema = {
   ...globalSchema,
-  ...loggedInSchema
+  ...credentialsSchema,
+  botRef
 };
 const deleteBotSchema = {
   ...globalSchema,
-  ...loggedInSchema
+  ...credentialsSchema,
+  botRef
 };
 const listBotsSchema = {
   ...globalSchema,
-  ...loggedInSchema
+  ...credentialsSchema
 };
-const readIntegrationSchema = {
+const getIntegrationSchema = {
   ...globalSchema,
-  ...loggedInSchema
+  ...credentialsSchema,
+  integrationRef
 };
 const listIntegrationsSchema = {
   ...globalSchema,
-  ...loggedInSchema,
+  ...credentialsSchema,
   name: { type: "string", description: "The name filter when listing integrations" },
   version: { type: "string", description: "The version filter when listing integrations" }
 };
 const deleteIntegrationSchema = {
   ...globalSchema,
-  ...loggedInSchema
+  ...credentialsSchema,
+  integrationRef
+};
+const initSchema = {
+  ...globalSchema,
+  workDir,
+  type: { type: "string", choices: ["bot", "integration"] },
+  name: { type: "string", description: "The name of the project" }
+};
+const schemas = {
+  global: globalSchema,
+  project: projectSchema,
+  credentials: credentialsSchema,
+  login: loginSchema,
+  logout: logoutSchema,
+  createBot: createBotSchema,
+  getBot: getBotSchema,
+  deleteBot: deleteBotSchema,
+  listBots: listBotsSchema,
+  getIntegration: getIntegrationSchema,
+  listIntegrations: listIntegrationsSchema,
+  deleteIntegration: deleteIntegrationSchema,
+  init: initSchema,
+  generate: generateSchema,
+  bundle: bundleSchema,
+  build: buildSchema,
+  serve: serveSchema,
+  deploy: deploySchema,
+  add: addSchema,
+  dev: devSchema
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  addSchema,
-  botRef,
-  buildSchema,
-  bundleSchema,
-  createBotSchema,
-  deleteBotSchema,
-  deleteIntegrationSchema,
-  deploySchema,
-  devSchema,
-  generateSchema,
-  globalSchema,
-  integrationRef,
-  listBotsSchema,
-  listIntegrationsSchema,
-  loggedInSchema,
-  loginSchema,
-  logoutSchema,
-  projectSchema,
-  readBotSchema,
-  readIntegrationSchema,
-  serveSchema
+  schemas
 });

package/dist/consts.js

@@ -29,6 +29,9 @@ __export(consts_exports, {
   defaultBotpressHome: () => defaultBotpressHome,
   defaultEntrypoint: () => defaultEntrypoint,
   defaultOutputFolder: () => defaultOutputFolder,
+  echoBotName: () => echoBotName,
+  emptyIntegrationName: () => emptyIntegrationName,
+  fromCliRootDir: () => fromCliRootDir,
   fromHomeDir: () => fromHomeDir,
   fromOutDir: () => fromOutDir,
   fromWorkDir: () => fromWorkDir
@@ -41,8 +44,15 @@ const defaultOutputFolder = ".botpress";
 const defaultEntrypoint = import_path.default.join("src", "index.ts");
 const defaultBotpressApi = "https://api.botpress.cloud";
 const defaultBotpressApp = "https://app.botpress.cloud";
+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"
+  globalCacheFile: "global.cache.json"
 };
 const fromWorkDir = {
   definition: "integration.definition.ts"
@@ -61,6 +71,9 @@ const fromOutDir = {
   defaultBotpressHome,
   defaultEntrypoint,
   defaultOutputFolder,
+  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
+});