@botpress/cli 0.0.10 → 0.0.13

package/dist/code-generation/integration-impl.js

@@ -28,7 +28,6 @@ __export(integration_impl_exports, {
 });
 module.exports = __toCommonJS(integration_impl_exports);
 var import_bluebird = __toESM(require("bluebird"));
-var import_utils = require("../utils");
 var import_action = require("./action");
 var import_channel = require("./channel");
 var import_configuration = require("./configuration");
@@ -74,7 +73,7 @@ class IntegrationImplementationIndexModule extends import_module.Module {
   get content() {
     let content = import_const.GENERATED_HEADER;
     const { configModule, actionsModule, channelsModule, eventsModule } = this;
-    content += 'import { Integration } from "@botpress/sdk";\n\n';
+    content += 'import * as sdk from "@botpress/sdk";\n\n';
     const configImport = configModule.import(this);
     const actionsImport = actionsModule.import(this);
     const channelsImport = channelsModule.import(this);
@@ -96,10 +95,8 @@ class IntegrationImplementationIndexModule extends import_module.Module {
     content += `export * as ${eventsModule.name} from "./${eventsImport}";
 `;
     content += "\n";
-    const { name } = this.integrationID;
-    const className = import_utils.strings.pascalCase(name);
-    content += `export class Integration${className}
-      extends Integration<${configModule.name}.${configModule.exports}, ${actionsModule.name}.${actionsModule.exports}, ${channelsModule.name}.${channelsModule.exports}, ${eventsModule.name}.${eventsModule.exports}> {}
+    content += `export class Integration
+      extends sdk.Integration<${configModule.name}.${configModule.exports}, ${actionsModule.name}.${actionsModule.exports}, ${channelsModule.name}.${channelsModule.exports}, ${eventsModule.name}.${eventsModule.exports}> {}
 `;
     return content;
   }

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

@@ -46,26 +46,41 @@ class InitCommand extends import_global_command.GlobalCommand {
       }
       projectType = promptedType;
     }
+    let name = this.argv.name;
+    if (!name) {
+      const defaultName = projectType === "bot" ? consts.echoBotDirName : consts.emptyIntegrationDirName;
+      const promptMessage = `What is the name of your ${projectType}?`;
+      const promptedName = await this.prompt.text(promptMessage, { initial: defaultName });
+      if (!promptedName) {
+        throw new errors.ParamRequiredError("Project Name");
+      }
+      name = promptedName;
+    }
     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 });
+      await this._copy({ srcDir: this.globalPaths.abs.echoBotTemplate, destDir: workDir, name });
       this.logger.success(`Bot project initialized in ${import_chalk.default.bold(workDir)}`);
       return;
     }
-    const destination = pathlib.join(workDir, this.argv.name ?? consts.emptyIntegrationName);
+    await this._copy({ srcDir: this.globalPaths.abs.emptyIntegrationTemplate, destDir: workDir, name });
+    this.logger.success(`Integration project initialized in ${import_chalk.default.bold(this.argv.workDir)}`);
+    return;
+  }
+  _copy = async (props) => {
+    const { srcDir, destDir, name } = props;
+    const destination = pathlib.join(destDir, props.name);
     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;
-  }
+    await fs.promises.cp(srcDir, destination, { recursive: true });
+    const pkgJsonPath = pathlib.join(destination, "package.json");
+    const strContent = await fs.promises.readFile(pkgJsonPath, "utf-8");
+    const { name: _, ...json } = JSON.parse(strContent);
+    const pkgJsonName = utils.strings.snakeCase(name);
+    const updatedJson = { name: pkgJsonName, ...json };
+    await fs.promises.writeFile(pkgJsonPath, JSON.stringify(updatedJson, null, 2));
+  };
   _checkIfDestinationExists = async (destination) => {
     if (fs.existsSync(destination)) {
       const override = await this.prompt.confirm(

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 name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
+  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") {
@@ -24,86 +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,
-  initSchema: () => initSchema,
-  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",
@@ -121,37 +54,51 @@ 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.",
-  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
@@ -171,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,
@@ -198,63 +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,
-  name
+  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,
-  initSchema,
-  integrationRef,
-  listBotsSchema,
-  listIntegrationsSchema,
-  loggedInSchema,
-  loginSchema,
-  logoutSchema,
-  projectSchema,
-  readBotSchema,
-  readIntegrationSchema,
-  serveSchema
+  schemas
 });

package/dist/consts.js

@@ -29,8 +29,8 @@ __export(consts_exports, {
   defaultBotpressHome: () => defaultBotpressHome,
   defaultEntrypoint: () => defaultEntrypoint,
   defaultOutputFolder: () => defaultOutputFolder,
-  echoBotName: () => echoBotName,
-  emptyIntegrationName: () => emptyIntegrationName,
+  echoBotDirName: () => echoBotDirName,
+  emptyIntegrationDirName: () => emptyIntegrationDirName,
   fromCliRootDir: () => fromCliRootDir,
   fromHomeDir: () => fromHomeDir,
   fromOutDir: () => fromOutDir,
@@ -44,15 +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 echoBotDirName = "echo-bot";
+const emptyIntegrationDirName = "empty-integration";
 const fromCliRootDir = {
   packageJson: "package.json",
-  echoBotTemplate: import_path.default.join("templates", echoBotName),
-  emptyIntegrationTemplate: import_path.default.join("templates", emptyIntegrationName)
+  echoBotTemplate: import_path.default.join("templates", echoBotDirName),
+  emptyIntegrationTemplate: import_path.default.join("templates", emptyIntegrationDirName)
 };
 const fromHomeDir = {
-  userCacheFile: "user.cache.json"
+  globalCacheFile: "global.cache.json"
 };
 const fromWorkDir = {
   definition: "integration.definition.ts"
@@ -71,8 +71,8 @@ const fromOutDir = {
   defaultBotpressHome,
   defaultEntrypoint,
   defaultOutputFolder,
-  echoBotName,
-  emptyIntegrationName,
+  echoBotDirName,
+  emptyIntegrationDirName,
   fromCliRootDir,
   fromHomeDir,
   fromOutDir,

package/dist/index.js

@@ -18,273 +18,30 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var import_yargs_extra = __toESM(require("@bpinternal/yargs-extra"));
-var import_process = require("process");
-var app = __toESM(require("./app"));
-var config = __toESM(require("./config"));
+var import_command_definitions = __toESM(require("./command-definitions"));
+var import_command_implementations = __toESM(require("./command-implementations"));
+var tree = __toESM(require("./command-tree"));
+var errors = __toESM(require("./errors"));
 var import_logger = require("./logger");
-var pathutils = __toESM(require("./path-utils"));
-const CLI_ROOT_DIR = pathutils.join(__dirname, "..");
+var import_register_yargs = require("./register-yargs");
+var utils = __toESM(require("./utils"));
+const CLI_ROOT_DIR = utils.path.join(__dirname, "..");
 const logError = (thrown) => {
-  const error = app.errors.BotpressCLIError.map(thrown);
+  const error = errors.BotpressCLIError.map(thrown);
   new import_logger.Logger().error(error.message);
 };
 const onError = (thrown) => {
   logError(thrown);
-  (0, import_process.exit)(1);
+  process.exit(1);
 };
 const yargsFail = (msg) => {
   logError(`${msg}
 `);
   import_yargs_extra.default.showHelp();
-  (0, import_process.exit)(1);
+  process.exit(1);
 };
 process.on("uncaughtException", (thrown) => onError(thrown));
 process.on("unhandledRejection", (thrown) => onError(thrown));
-const parseArguments = (schema, argv) => {
-  const yargsEnv = (0, import_yargs_extra.parseEnv)(schema, "BP");
-  return (0, import_yargs_extra.cleanupConfig)(schema, { ...argv, ...yargsEnv });
-};
-import_yargs_extra.default.command(
-  "login",
-  "Login to Botpress Cloud",
-  () => import_yargs_extra.default.options(config.loginSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.loginSchema, argv);
-      const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.login(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "logout",
-  "Logout of Botpress Cloud",
-  () => import_yargs_extra.default.options(config.logoutSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.logoutSchema, argv);
-      const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.logout();
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command("bots", "bots related commands", (yargz) => {
-  yargz.command(
-    ["create", "new"],
-    "Create new bot",
-    () => yargz.options({ ...config.createBotSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.createBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-        await commands.createBot(parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    ["list", "ls"],
-    "List bots",
-    () => yargz.options({ ...config.listBotsSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.listBotsSchema, argv);
-        const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-        await commands.listBots(parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    "get <botRef>",
-    "Get bot",
-    () => yargz.positional("botRef", config.botRef).options({ ...config.readBotSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.readBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-        await commands.getBot(argv.botRef, parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    ["delete <botRef>", "rm <botRef>"],
-    "Delete bot",
-    () => yargz.positional("botRef", config.botRef).options({ ...config.deleteBotSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.deleteBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-        await commands.deleteBot(argv.botRef, parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  );
-}).command("integrations", "integrations related commands", (yargz) => {
-  yargz.command(
-    ["list", "ls"],
-    "List integrations",
-    () => yargz.options({ ...config.listIntegrationsSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.listIntegrationsSchema, argv);
-        const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-        await commands.listIntegrations(parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    "get <integrationRef>",
-    "Get integration",
-    () => yargz.positional("integrationRef", config.integrationRef).options({ ...config.readIntegrationSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.readIntegrationSchema, argv);
-        const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-        await commands.getIntegration(argv.integrationRef, parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  ).command(
-    ["delete <integrationRef>", "rm <integrationRef>"],
-    "Delete integration",
-    () => yargz.positional("integrationRef", config.integrationRef).options({ ...config.deleteIntegrationSchema }),
-    async (argv) => {
-      try {
-        const parsed = parseArguments(config.readIntegrationSchema, argv);
-        const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-        await commands.deleteIntegration(argv.integrationRef, parsed);
-        commands.teardown();
-      } catch (e) {
-        onError(e);
-      }
-    }
-  );
-}).command(
-  "init",
-  "Initialize a new project",
-  () => import_yargs_extra.default.options(config.initSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.initSchema, argv);
-      const commands = await app.forUser({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.initProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "bundle",
-  "Bundle a botpress project",
-  () => import_yargs_extra.default.options(config.bundleSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.bundleSchema, argv);
-      const commands = await app.forProject({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.bundleProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "gen",
-  "Generate typings for intellisense during development",
-  () => import_yargs_extra.default.options(config.generateSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.generateSchema, argv);
-      const commands = await app.forProject({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.generateTypings(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "build",
-  "Generate typings and bundle a botpress project",
-  () => import_yargs_extra.default.options(config.buildSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.buildSchema, argv);
-      const commands = await app.forProject({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.buildProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "serve",
-  "Serve your project locally",
-  () => import_yargs_extra.default.options(config.serveSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.serveSchema, argv);
-      const commands = await app.forProject({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.serveProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "deploy",
-  "Deploy your project",
-  () => import_yargs_extra.default.options(config.deploySchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.deploySchema, argv);
-      const commands = await app.forProject({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.deployProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "dev",
-  "Run your project in dev mode",
-  () => import_yargs_extra.default.options(config.devSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.devSchema, argv);
-      const commands = await app.forProject({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.devProject(parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-).command(
-  "add <integrationRef>",
-  "Install an integration in your bot",
-  (yargz) => yargz.positional("integrationRef", config.integrationRef).options(config.addSchema),
-  async (argv) => {
-    try {
-      const parsed = parseArguments(config.addSchema, argv);
-      const commands = await app.forProject({ ...parsed, cliRootPath: CLI_ROOT_DIR });
-      await commands.installIntegration(argv.integrationRef, parsed);
-      commands.teardown();
-    } catch (e) {
-      onError(e);
-    }
-  }
-);
+const commands = tree.zipTree(import_command_definitions.default, import_command_implementations.default);
+(0, import_register_yargs.registerYargs)(import_yargs_extra.default, commands, { cliRootDir: CLI_ROOT_DIR });
 void import_yargs_extra.default.version(false).scriptName("bp").demandCommand(1, "You didn't provide any command. Use the --help flag to see the list of available commands.").recommendCommands().strict().help().fail(yargsFail).parse();

package/dist/logger/base-logger.js

@@ -89,7 +89,7 @@ class BaseLogger {
     this.opts = { ...DEFAULT_OPTIONS, ...opts };
   }
   log(message, props = {}) {
-    if (this.opts.json) {
+    if (this.opts.json && !props.stderr) {
       return;
     }
     const prefix = this._resolvePrefix(props.prefix);
@@ -102,44 +102,29 @@ class BaseLogger {
     }
     const { depth } = opts;
     const msg = import_util.default.inspect(data, { colors: true, depth });
-    this.print(msg);
+    this.log(msg);
   }
   debug(message, metadata) {
-    if (!this.opts.verbose || this.opts.json) {
+    if (!this.opts.verbose) {
       return;
     }
     this.log(import_chalk.default.grey(message), { metadata, prefix: { symbol: "\u25CF", fg: "blue" } });
   }
   started(message, metadata) {
-    if (this.opts.json) {
-      return;
-    }
     this.log(message, { metadata, prefix: { symbol: "\u25CB", fg: "purple" } });
   }
   success(message, metadata) {
-    if (this.opts.json) {
-      return;
-    }
     this.log(message, { metadata, prefix: { symbol: "\u2713", fg: "green" } });
   }
   warn(message, metadata) {
-    if (this.opts.json) {
-      return;
-    }
     this.log(message, { metadata, prefix: { symbol: "\u26A0", fg: "yellow" } });
   }
   error(message, metadata) {
-    if (this.opts.json) {
-      return;
-    }
-    this.log(message, { metadata, prefix: { symbol: "\xD7", fg: "red" } });
+    this.log(message, { metadata, prefix: { symbol: "\xD7", fg: "red" }, stderr: true });
   }
   box(message) {
-    if (this.opts.json) {
-      return;
-    }
     const box = (0, import_boxen.default)(message, BOX_OPTIONS);
-    this.print(box);
+    this.log(box);
   }
   _resolvePrefix(prefix) {
     if (!prefix) {

package/dist/logger/index.js

@@ -27,12 +27,13 @@ class Logger extends import_base_logger.BaseLogger {
   static _previousLine;
   print(message, props = {}) {
     this.cleanup();
+    const log = props.stderr ? console.error : console.info;
     const { metadata, prefix } = props;
     if (prefix) {
-      console.log(prefix, message, metadata ?? "");
+      log(prefix, message, metadata ?? "");
       return;
     }
-    console.log(message, metadata ?? "");
+    log(message, metadata ?? "");
   }
   line() {
     this.cleanup();

package/dist/utils/prompt-utils.js

@@ -68,6 +68,15 @@ class CLIPrompt {
     });
     return prompted ? prompted : void 0;
   }
+  async text(message, opts) {
+    const { prompted } = await (0, import_prompts.default)({
+      type: "text",
+      name: "prompted",
+      message,
+      initial: opts?.initial
+    });
+    return prompted ? prompted : void 0;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/utils/string-utils.js

@@ -18,21 +18,40 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var string_utils_exports = {};
 __export(string_utils_exports, {
+  camelCase: () => camelCase,
   kebabCase: () => kebabCase,
-  pascalCase: () => pascalCase
+  pascalCase: () => pascalCase,
+  snakeCase: () => snakeCase
 });
 module.exports = __toCommonJS(string_utils_exports);
-const capitalizeFirstLetter = (string) => string.charAt(0).toUpperCase() + string.slice(1);
-const pascalCase = (string) => {
-  const words = string.split(/[-_]/);
+const capitalizeFirstLetter = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+const splitHyphens = (tokens) => tokens.flatMap((token) => token.split("-"));
+const splitUnderscores = (tokens) => tokens.flatMap((token) => token.split("_"));
+const splitCaseChange = (tokens) => tokens.flatMap((token) => token.split(/(?<=[a-z])(?=[A-Z])/));
+const split = (tokens) => {
+  const steps = [splitHyphens, splitUnderscores, splitCaseChange];
+  return steps.reduce((acc, step) => step(acc), tokens);
+};
+const pascalCase = (text) => {
+  const words = split([text]);
   return words.map(capitalizeFirstLetter).join("");
 };
-const kebabCase = (string) => {
-  const words = string.split(/(?<=[a-z])(?=[A-Z])/);
+const kebabCase = (text) => {
+  const words = split([text]);
   return words.map((word) => word.toLowerCase()).join("-");
 };
+const snakeCase = (text) => {
+  const words = split([text]);
+  return words.map((word) => word.toLowerCase()).join("_");
+};
+const camelCase = (text) => {
+  const [first, ...words] = split([text]);
+  return [first.toLowerCase(), ...words.map(capitalizeFirstLetter)].join("");
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  camelCase,
   kebabCase,
-  pascalCase
+  pascalCase,
+  snakeCase
 });

package/dist/worker/child-entrypoint.js

@@ -27,7 +27,7 @@ __export(child_entrypoint_exports, {
   ENTRY_POINT: () => ENTRY_POINT
 });
 module.exports = __toCommonJS(child_entrypoint_exports);
-var requireutils = __toESM(require("../require-utils"));
+var utils = __toESM(require("../utils"));
 var import_config = require("./config");
 var import_is_child = require("./is-child");
 const ENTRY_POINT = __filename;
@@ -38,10 +38,10 @@ const childProcessEntrypoint = async (_props) => {
   }
   const config = import_config.configSchema.parse(JSON.parse(rawConfig));
   if (config.type === "code") {
-    requireutils.requireJsCode(config.code);
+    utils.require.requireJsCode(config.code);
   }
   if (config.type === "file") {
-    requireutils.requireJsFile(config.file);
+    utils.require.requireJsFile(config.file);
   }
 };
 if (import_is_child.processProps.type === "child") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/cli",
-  "version": "0.0.10",
+  "version": "0.0.13",
   "description": "Botpress CLI",
   "scripts": {
     "build": "pnpm run type-check && pnpm run bundle && pnpm run template:gen && pnpm run template:type-check",
@@ -19,7 +19,7 @@
   },
   "main": "dist/index.js",
   "dependencies": {
-    "@botpress/client": "0.0.10",
+    "@botpress/client": "0.0.11",
     "@bpinternal/yargs-extra": "^0.0.2",
     "@parcel/watcher": "^2.1.0",
     "@types/lodash": "^4.14.191",
@@ -45,7 +45,7 @@
     "zod-to-json-schema": "^3.20.1"
   },
   "devDependencies": {
-    "@botpress/sdk": "0.0.8",
+    "@botpress/sdk": "0.0.9",
     "@types/bluebird": "^3.5.38",
     "@types/prompts": "^2.0.14",
     "@types/semver": "^7.3.11",

package/templates/echo-bot/package.json

@@ -1,7 +1,6 @@
 {
-  "name": "@botpresshub/echo-bot",
+  "name": "echo-bot",
   "version": "0.1.0",
-  "description": "Bot that answers with the received message",
   "scripts": {
     "type-check": "tsc --noEmit"
   },
@@ -10,13 +9,14 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@botpress/client": "0.0.10",
-    "@botpress/sdk": "0.0.8",
+    "@botpress/client": "0.0.11",
+    "@botpress/sdk": "0.0.9",
     "zod": "^3.20.6"
   },
   "devDependencies": {
     "@types/node": "^18.11.17",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.4"
+    "typescript": "^4.9.4",
+    "@tsconfig/node18-strictest": "^1.0.0"
   }
 }

package/templates/empty-integration/.botpress/implementation/index.ts

@@ -2,7 +2,7 @@
 // This file is generated
 // Do not edit this file
 
-import { Integration } from "@botpress/sdk";
+import * as sdk from "@botpress/sdk";
 
 import type * as configuration from "./configuration";
 import type * as actions from "./actions/index";
@@ -13,5 +13,5 @@ export * as actions from "./actions/index";
 export * as channels from "./channels/index";
 export * as events from "./events/index";
 
-export class IntegrationEmpty
-      extends Integration<configuration.Configuration, actions.Actions, channels.Channels, events.Events> {}
+export class Integration
+      extends sdk.Integration<configuration.Configuration, actions.Actions, channels.Channels, events.Events> {}

package/templates/empty-integration/integration.definition.ts

@@ -1,10 +1,10 @@
 import { IntegrationDefinition, messages } from '@botpress/sdk'
-import { version } from './package.json'
+import { version, name } from './package.json'
 
 export default new IntegrationDefinition({
-  name: 'empty',
+  name,
   version,
-  public: true,
+  public: false,
   channels: {
     channel: {
       messages: { ...messages.defaults },

package/templates/empty-integration/package.json

@@ -1,7 +1,6 @@
 {
-  "name": "@botpresshub/empty-integration",
+  "name": "empty-integration",
   "version": "0.1.0",
-  "description": "Integration with no content",
   "scripts": {
     "type-check": "tsc --noEmit"
   },
@@ -10,13 +9,14 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@botpress/client": "0.0.10",
-    "@botpress/sdk": "0.0.8",
+    "@botpress/client": "0.0.11",
+    "@botpress/sdk": "0.0.9",
     "zod": "^3.20.6"
   },
   "devDependencies": {
     "@types/node": "^18.11.17",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.4"
+    "typescript": "^4.9.4",
+    "@tsconfig/node18-strictest": "^1.0.0"
   }
 }

package/templates/empty-integration/src/index.ts

@@ -9,9 +9,19 @@ class NotImplementedError extends Error {
   }
 }
 
-export default new botpress.IntegrationEmpty({
-  register: async () => {},
-  unregister: async () => {},
+export default new botpress.Integration({
+  register: async () => {
+    /**
+     * This is called when a bot installs the integration.
+     * You should use this handler to instanciate ressources in the external service and ensure that the configuration is valid.
+     */
+  },
+  unregister: async () => {
+    /**
+     * This is called when a bot removes the integration.
+     * You should use this handler to instanciate ressources in the external service and ensure that the configuration is valid.
+     */
+  },
   actions: {},
   channels: {
     channel: {

package/templates/echo-bot/readme.md

@@ -1,5 +0,0 @@
-# Echo Bot
-
-## Description
-
-Bot that answers with the received message.

package/templates/empty-integration/readme.md

@@ -1,5 +0,0 @@
-# Empty Integration
-
-## Description
-
-Integration with no content.