@botpress/cli 0.0.4 → 0.0.5

package/dist/app/project.js

@@ -24,63 +24,29 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var project_exports = {};
 __export(project_exports, {
-  ProjectCommands: () => ProjectCommands,
-  ProjectPaths: () => ProjectPaths
+  ProjectCommands: () => ProjectCommands
 });
 module.exports = __toCommonJS(project_exports);
-var bpclient = __toESM(require("@botpress/client"));
 var import_bluebird = __toESM(require("bluebird"));
 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 import_prompts = __toESM(require("prompts"));
-var consts = __toESM(require("../const"));
-var pathutils = __toESM(require("../paths"));
-var requireutils = __toESM(require("../requires"));
+var consts = __toESM(require("../consts"));
+var esbuildutils = __toESM(require("../esbuild-utils"));
+var pathutils = __toESM(require("../path-utils"));
+var requireutils = __toESM(require("../require-utils"));
 var import_worker = require("../worker");
-var import_api_utils = require("./api-utils");
 var import_base = require("./base");
 var errors = __toESM(require("./errors"));
-var esbuild = __toESM(require("./esbuild"));
 var generator = __toESM(require("./generator"));
 var import_integration_ref = require("./integration-ref");
-class ProjectPaths {
-  abs;
-  rel;
-  static from(paths, overrides) {
-    const rel = { ...paths.rel, ...overrides };
-    return new ProjectPaths(rel);
-  }
-  constructor({ workDir, definition, entryPoint: entrypoint, outDir }) {
-    const absWorkdir = pathutils.absoluteFrom(pathutils.cwd(), workDir);
-    const absDefinition = pathutils.absoluteFrom(absWorkdir, definition);
-    const absEntrypoint = pathutils.absoluteFrom(absWorkdir, entrypoint);
-    const absOutdir = pathutils.absoluteFrom(absWorkdir, outDir);
-    this.abs = { workDir: absWorkdir, definition: absDefinition, entryPoint: absEntrypoint, outDir: absOutdir };
-    const relDefinition = pathutils.relativeFrom(this.abs.workDir, this.abs.definition);
-    const relEntrypoint = pathutils.relativeFrom(this.abs.workDir, this.abs.entryPoint);
-    const relOutdir = pathutils.relativeFrom(this.abs.workDir, this.abs.outDir);
-    const relWorkdir = ".";
-    this.rel = { workDir: relWorkdir, definition: relDefinition, entryPoint: relEntrypoint, outDir: relOutdir };
-  }
-}
-const ENTRY_CODE = (entrypoint) => {
-  const unixPath = pathutils.toUnix(entrypoint);
-  const importFrom = pathutils.rmExtension(unixPath);
-  return `
-import x from './${importFrom}'
-export default x
-export const handler = x.handler
-`;
-};
 class ProjectCommands extends import_base.BaseCommands {
-  constructor(_props, _paths, _projectCache, _userCache, logger) {
-    super(logger);
-    this._props = _props;
+  constructor(props, _paths, _projectCache, userCache, logger) {
+    super(props, userCache, logger);
     this._paths = _paths;
     this._projectCache = _projectCache;
-    this._userCache = _userCache;
   }
   async installIntegration(integrationRef, argv) {
     const integrationDef = await this._readIntegrationDefinitionFromFS();
@@ -110,20 +76,17 @@ class ProjectCommands extends import_base.BaseCommands {
     await this._generateIntegrationInstance(integration);
   }
   async buildProject(argv) {
-    const { abs } = this._paths;
     const t0 = Date.now();
     const integrationDef = await this._readIntegrationDefinitionFromFS();
     if (integrationDef) {
-      await this._generateImplementationTypings(integrationDef);
-      await import_fs.default.promises.writeFile(consts.defDataOutfile(abs.outDir), JSON.stringify(integrationDef, void 0, 2));
+      await this.generateTypings(argv);
     }
     await this.bundleProject(argv);
     const dt = Date.now() - t0;
     this._logger.log(`Build completed in ${dt}ms`);
   }
   async serveProject(argv) {
-    const { abs } = this._paths;
-    const outfile = consts.outfile(abs.outDir);
+    const outfile = this._paths.abs.outFile;
     if (!import_fs.default.existsSync(outfile)) {
       throw new errors.NoBundleFoundError();
     }
@@ -137,29 +100,37 @@ class ProjectCommands extends import_base.BaseCommands {
     const { rel, abs } = this._paths;
     const line = this._logger.line();
     const logLevel = this._props.verbose ? "info" : "silent";
-    try {
-      if (integrationDef) {
-        const { name } = integrationDef;
-        line.started(`Bundling integration ${import_chalk.default.bold(name)}...`);
-      } else {
-        line.started("Bundling bot...");
-      }
-      const code = ENTRY_CODE(rel.entryPoint);
-      const outfile = consts.outfile(rel.outDir);
-      line.debug(`Writing bundle to ${outfile}`);
-      await esbuild.buildCode({ code, cwd: abs.workDir, outfile, logLevel, write: true });
-      line.success(`Bundle available at ${import_chalk.default.grey(rel.outDir)}`);
-    } finally {
-      line.commit();
-    }
+    if (integrationDef) {
+      const { name } = integrationDef;
+      line.started(`Bundling integration ${import_chalk.default.bold(name)}...`);
+    } else {
+      line.started("Bundling bot...");
+    }
+    const unixPath = pathutils.toUnix(rel.entryPoint);
+    const importFrom = pathutils.rmExtension(unixPath);
+    const code = `import x from './${importFrom}'; export default x; export const handler = x.handler;`;
+    const outfile = abs.outFile;
+    line.debug(`Writing bundle to ${outfile}`);
+    await esbuildutils.buildCode({ code, cwd: abs.workDir, outfile, logLevel, write: true });
+    line.success(`Bundle available at ${import_chalk.default.grey(rel.outDir)}`);
   }
   async generateTypings(_argv) {
-    const integrationDefinition = await this._readIntegrationDefinitionFromFS();
-    if (!integrationDefinition) {
+    const integrationDef = await this._readIntegrationDefinitionFromFS();
+    if (!integrationDef) {
       this._logger.warn("No typings to generate for bot");
       return;
     }
-    return this._generateImplementationTypings(integrationDefinition);
+    const line = this._logger.line();
+    const { name } = integrationDef;
+    line.started(`Generating typings for integration ${import_chalk.default.bold(name)}...`);
+    const typingFiles = await generator.generateIntegrationImplementationTypings(
+      integrationDef,
+      consts.relativeToOutFolder.implementationDir
+    );
+    const indexFile = await generator.generateIntegrationIndex(consts.relativeToOutFolder.implementationDir);
+    const generatedFiles = [...typingFiles, indexFile];
+    await this._writeFilesToOutFolder(generatedFiles);
+    line.success(`Typings available at ${import_chalk.default.grey(this._paths.rel.outDir)}`);
   }
   async deployProject(argv) {
     const api = await this._ensureLoginAndCreateClient(argv);
@@ -173,85 +144,108 @@ class ProjectCommands extends import_base.BaseCommands {
     if (integrationDef) {
       return this._deployIntegration(api, integrationDef);
     }
-    return this._deployBot(api, argv.botId);
+    return this._deployBot(api, argv.botId, argv.createNewBot);
   }
   async devProject(argv) {
     this._logger.warn("This command is experimental and subject to breaking changes without notice.");
-    const { abs } = this._paths;
-    const outfile = consts.outfile(abs.outDir);
-    if (!import_fs.default.existsSync(outfile)) {
-      throw new errors.NoBundleFoundError();
-    }
     if (!argv.noBuild) {
       await this.buildProject(argv);
     }
     const api = await this._ensureLoginAndCreateClient(argv);
     const integrationDef = await this._readIntegrationDefinitionFromFS();
-    const { cleanup } = await this._createDevRessource(api, argv.url, integrationDef);
-    try {
-      const importPath = pathutils.toUnix(outfile);
-      const code = `require('${importPath}').default.start(${argv.port})`;
-      await (0, import_worker.spawnChildProcess)(
-        {
-          type: "code",
-          code,
-          env: {
-            BP_API_URL: api.host,
-            BP_TOKEN: api.token
-          }
-        },
-        this._logger
-      );
-    } finally {
-      this._logger.log("Cleaning up ressources...");
-      await cleanup();
+    if (integrationDef) {
+      await this._deployDevIntegration(api, argv.url, integrationDef);
+    } else {
+      await this._deployDevBot(api, argv.url);
+    }
+    const outfile = this._paths.abs.outFile;
+    const importPath = pathutils.toUnix(outfile);
+    const requireFrom = pathutils.rmExtension(importPath);
+    const code = `require('${requireFrom}').default.start(${argv.port})`;
+    await (0, import_worker.spawnChildProcess)(
+      {
+        type: "code",
+        code,
+        env: {
+          BP_API_URL: api.host,
+          BP_TOKEN: api.token
+        }
+      },
+      this._logger
+    );
+  }
+  async _deployDevIntegration(api, externalUrl, integrationDef) {
+    const devId = await this._projectCache.get("devId");
+    let integration = void 0;
+    if (devId) {
+      const resp = await api.client.getIntegration({ id: devId }).catch(async (thrown) => {
+        const err = errors.BotpressCLIError.wrap(thrown, `Could not find existing dev integration with id "${devId}"`);
+        this._logger.warn(err.message);
+        return { integration: void 0 };
+      });
+      if (resp.integration?.dev) {
+        integration = resp.integration;
+      } else {
+        await this._projectCache.rm("devId");
+      }
+    }
+    const line = this._logger.line();
+    line.started(`Deploying dev integration ${import_chalk.default.bold(integrationDef.name)}...`);
+    if (integration) {
+      const resp = await api.client.updateIntegration({ ...integrationDef, id: integration.id, url: externalUrl }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not update dev integration "${integrationDef.name}"`);
+      });
+      integration = resp.integration;
+    } else {
+      const resp = await api.client.createIntegration({ ...integrationDef, dev: true, url: externalUrl }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not deploy dev integration "${integrationDef.name}"`);
+      });
+      integration = resp.integration;
     }
+    line.success(`Dev Integration deployed with id "${integration.id}"`);
+    await this._projectCache.set("devId", integration.id);
   }
-  async _createDevRessource(api, externalUrl, integrationDef) {
-    if (integrationDef) {
-      const { integration } = await api.client.createIntegration({
-        ...integrationDef,
+  async _deployDevBot(api, externalUrl) {
+    const devId = await this._projectCache.get("devId");
+    let bot = void 0;
+    if (devId) {
+      const resp = await api.client.getBot({ id: devId }).catch(async (thrown) => {
+        const err = errors.BotpressCLIError.wrap(thrown, `Could not find existing dev bot with id "${devId}"`);
+        this._logger.warn(err.message);
+        return { bot: void 0 };
+      });
+      if (resp.bot?.dev) {
+        bot = resp.bot;
+      } else {
+        await this._projectCache.rm("devId");
+      }
+    }
+    if (!bot) {
+      const createLine = this._logger.line();
+      createLine.started("Creating dev bot...");
+      const resp = await api.client.createBot({
         dev: true,
         url: externalUrl
       }).catch((thrown) => {
-        throw errors.BotpressCLIError.wrap(thrown, `Could not deploy dev integration "${integrationDef.name}"`);
+        throw errors.BotpressCLIError.wrap(thrown, "Could not deploy dev bot");
       });
-      this._logger.success(`Dev Integration created with id "${integration.id}"`);
-      return {
-        cleanup: () => api.client.deleteIntegration({ id: integration.id }).then(() => {
-        }).catch((thrown) => {
-          throw errors.BotpressCLIError.wrap(thrown, `Could not delete dev integration "${integrationDef.name}"`);
-        })
-      };
+      bot = resp.bot;
+      createLine.success(`Dev Bot created with id "${bot.id}"`);
+      await this._projectCache.set("devId", bot.id);
     }
-    const { abs } = this._paths;
-    const outfile = consts.outfile(abs.outDir);
-    const {
-      default: { integrations: integrationList }
-    } = requireutils.requireJsFile(outfile);
-    const { bot: createdBot } = await api.client.createBot({
-      dev: true,
-      url: externalUrl
-    }).catch((thrown) => {
-      throw errors.BotpressCLIError.wrap(thrown, "Could not deploy dev bot");
-    });
-    const integrations = (0, import_lodash.default)(integrationList ?? []).keyBy((i) => i.id).mapValues(({ enabled, configuration }) => ({ enabled, configuration })).value();
-    this._logger.debug("Bot created, updating integrations...", { integrations });
-    const { bot: updatedBot } = await api.client.updateBot({ id: createdBot.id, integrations }).catch((thrown) => {
+    const outfile = this._paths.abs.outFile;
+    const { default: botImpl } = requireutils.requireJsFile(outfile);
+    const integrations = this._prepareIntegrations(botImpl, bot);
+    const updateLine = this._logger.line();
+    updateLine.started("Updating bot integrations...");
+    const { bot: updatedBot } = await api.client.updateBot({ id: bot.id, integrations, url: externalUrl }).catch((thrown) => {
       throw errors.BotpressCLIError.wrap(thrown, "Could not deploy dev bot");
     });
-    this._logger.success(`Dev Bot created with id "${updatedBot.id}"`);
+    updateLine.success("Integrations installed successfully");
     this._displayWebhookUrls(updatedBot);
-    return {
-      cleanup: () => api.client.deleteBot({ id: updatedBot.id }).then(() => {
-      }).catch((thrown) => {
-        throw errors.BotpressCLIError.wrap(thrown, "Could not delete dev bot");
-      })
-    };
   }
   async _deployIntegration(api, integrationDef) {
-    const { abs } = this._paths;
-    const outfile = consts.outfile(abs.outDir);
+    const outfile = this._paths.abs.outFile;
     const code = await import_fs.default.promises.readFile(outfile, "utf-8");
     const { name, version } = integrationDef;
     const integration = await api.findIntegration({ type: "name", name, version });
@@ -268,29 +262,62 @@ class ProjectCommands extends import_base.BaseCommands {
       return;
     }
     const line = this._logger.line();
-    try {
-      line.started(`Deploying integration ${import_chalk.default.bold(integrationDef.name)} v${integrationDef.version}...`);
-      if (integration) {
-        await api.client.updateIntegration({ id: integration.id, ...integrationDef, code });
-      } else {
-        await api.client.createIntegration({ ...integrationDef, code });
-      }
-      line.success("Integration deployed");
-    } catch (thrown) {
-      const action = integration ? "update" : "create";
-      throw errors.BotpressCLIError.wrap(thrown, `Could not ${action} integration "${integrationDef.name}"`);
-    } finally {
-      line.commit();
+    line.started(`Deploying integration ${import_chalk.default.bold(integrationDef.name)} v${integrationDef.version}...`);
+    if (integration) {
+      await api.client.updateIntegration({ id: integration.id, ...integrationDef, code }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not update integration "${integrationDef.name}"`);
+      });
+    } else {
+      await api.client.createIntegration({ ...integrationDef, code }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not create integration "${integrationDef.name}"`);
+      });
     }
+    line.success("Integration deployed");
   }
-  async _deployBot(api, botId) {
-    const { abs } = this._paths;
-    const outfile = consts.outfile(abs.outDir);
+  async _deployBot(api, argvBotId, argvCreateNew) {
+    const outfile = this._paths.abs.outFile;
     const code = await import_fs.default.promises.readFile(outfile, "utf-8");
     const { default: botImpl } = requireutils.requireJsFile(outfile);
-    const { tags, states, integrations: integrationList } = botImpl;
+    const { tags, states, events, recurringEvents, configuration: botConfiguration } = botImpl;
+    let bot;
+    if (argvBotId && argvCreateNew) {
+      throw new errors.BotpressCLIError("Cannot specify both --botId and --createNew");
+    } else if (argvCreateNew) {
+      const confirm = await this._confirm("Are you sure you want to create a new bot ?");
+      if (!confirm) {
+        this._logger.log("Aborted");
+        return;
+      }
+      bot = await this._createNewBot(api);
+    } else {
+      bot = await this._getExistingBot(api, argvBotId);
+      const confirm = await this._confirm(`Are you sure you want to deploy the bot "${bot.name}"?`);
+      if (!confirm) {
+        this._logger.log("Aborted");
+        return;
+      }
+    }
+    const integrations = this._prepareIntegrations(botImpl, bot);
+    const line = this._logger.line();
+    line.started(`Deploying bot ${import_chalk.default.bold(bot.name)}...`);
+    const { bot: updatedBot } = await api.client.updateBot({
+      id: bot.id,
+      code,
+      states,
+      recurringEvents,
+      configuration: botConfiguration,
+      events,
+      tags,
+      integrations
+    }).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not update bot "${bot.name}"`);
+    });
+    line.success("Bot deployed");
+    this._displayWebhookUrls(updatedBot);
+  }
+  async _getExistingBot(api, botId) {
     const promptedBotId = await this._projectCache.sync("botId", botId, async (defaultId) => {
-      const userBots = await api.listAllPages(api.client.listBots, "bots").catch((thrown) => {
+      const userBots = await api.listAllPages(api.client.listBots, (r) => r.bots).catch((thrown) => {
         throw errors.BotpressCLIError.wrap(thrown, "Could not fetch existing bots");
       });
       if (!userBots.length) {
@@ -309,34 +336,25 @@ class ProjectCommands extends import_base.BaseCommands {
       }
       return prompted;
     });
-    const { bot: botInfo } = await api.client.getBot({ id: promptedBotId }).catch((thrown) => {
+    const { bot: fetchedBot } = await api.client.getBot({ id: promptedBotId }).catch((thrown) => {
       throw errors.BotpressCLIError.wrap(thrown, "Could not get bot info");
     });
+    return fetchedBot;
+  }
+  async _createNewBot(api) {
+    const line = this._logger.line();
+    const { bot: createdBot } = await api.client.createBot({}).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not create bot");
+    });
+    line.success(`Bot created with ID "${createdBot.id}" and name "${createdBot.name}"`);
+    await this._projectCache.set("botId", createdBot.id);
+    return createdBot;
+  }
+  _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();
-    const integrations = { ...integrationsToUninstall, ...integrationsToInstall };
-    const confirm = await this._confirm(`Are you sure you want to deploy bot ${botInfo.name} ?`);
-    if (!confirm) {
-      this._logger.log("Aborted");
-      return;
-    }
-    const line = this._logger.line();
-    try {
-      line.started(`Deploying bot ${import_chalk.default.bold(botInfo.name)}...`);
-      const { bot: updatedBot } = await api.client.updateBot({
-        id: promptedBotId,
-        code,
-        states,
-        tags,
-        integrations
-      });
-      line.success("Bot deployed");
-      this._displayWebhookUrls(updatedBot);
-    } catch (thrown) {
-      throw errors.BotpressCLIError.wrap(thrown, "Could not update bot");
-    } finally {
-      line.commit();
-    }
+    return { ...integrationsToUninstall, ...integrationsToInstall };
   }
   _displayWebhookUrls(bot) {
     if (!import_lodash.default.keys(bot.integrations).length) {
@@ -357,8 +375,7 @@ class ProjectCommands extends import_base.BaseCommands {
     }
   }
   async _listIntegrationInstances() {
-    const { abs } = this._paths;
-    const installPath = consts.installDir(abs.outDir);
+    const installPath = this._paths.abs.installDir;
     if (!import_fs.default.existsSync(installPath)) {
       this._logger.debug("Install path does not exist. Skipping listing of integration instances");
       return [];
@@ -383,70 +400,23 @@ class ProjectCommands extends import_base.BaseCommands {
       };
     });
   }
-  async _confirm(message) {
-    if (this._props.confirm) {
-      this._logger.debug(`Confirming automatically: ${message}`);
-      return true;
-    }
-    const { confirm } = await (0, import_prompts.default)({
-      type: "confirm",
-      name: "confirm",
-      message,
-      initial: false
-    });
-    if (!confirm) {
-      return false;
-    }
-    return true;
-  }
-  async _generateImplementationTypings(integrationDef) {
-    const line = this._logger.line();
-    const { name } = integrationDef;
-    line.started(`Generating typings for integration ${import_chalk.default.bold(name)}...`);
-    const { rel } = this._paths;
-    try {
-      const typingFiles = await generator.generateIntegrationImplementationTypings(
-        integrationDef,
-        consts.relativeToOutFolder.implementationTypings
-      );
-      const indexFile = await generator.generateIntegrationIndex(consts.relativeToOutFolder.implementationTypings);
-      const generatedFiles = [...typingFiles, indexFile];
-      await this._writeFilesToOutFolder(generatedFiles);
-      line.success(`Typings available at ${import_chalk.default.grey(rel.outDir)}`);
-    } catch (thrown) {
-      throw errors.BotpressCLIError.wrap(thrown, "Could not generate typings");
-    } finally {
-      line.commit();
-    }
-  }
   async _uninstallIntegration(instance) {
-    const { abs } = this._paths;
-    try {
-      const instancePath = import_path.default.join(consts.installDir(abs.outDir), instance.dirname);
-      await import_fs.default.promises.rm(instancePath, { recursive: true });
-      await this._generateBotIndex();
-    } catch (thrown) {
-      throw errors.BotpressCLIError.wrap(thrown, "Could not uninstall integration");
-    }
+    const installDir = this._paths.abs.installDir;
+    const instancePath = import_path.default.join(installDir, instance.dirname);
+    await import_fs.default.promises.rm(instancePath, { recursive: true });
+    await this._generateBotIndex();
   }
   async _generateIntegrationInstance(integration) {
     const line = this._logger.line();
     const { name, version } = integration;
     line.started(`Installing ${import_chalk.default.bold(name)} v${version}...`);
-    const { rel } = this._paths;
-    try {
-      const instanceFiles = await generator.generateIntegrationInstance(
-        integration,
-        consts.relativeToOutFolder.installDir
-      );
-      await this._writeFilesToOutFolder(instanceFiles);
-      await this._generateBotIndex();
-      line.success(`Installed integration available at ${import_chalk.default.grey(rel.outDir)}`);
-    } catch (thrown) {
-      throw errors.BotpressCLIError.wrap(thrown, "Could not install integration");
-    } finally {
-      line.commit();
-    }
+    const instanceFiles = await generator.generateIntegrationInstance(
+      integration,
+      consts.relativeToOutFolder.installDir
+    );
+    await this._writeFilesToOutFolder(instanceFiles);
+    await this._generateBotIndex();
+    line.success(`Installed integration available at ${import_chalk.default.grey(this._paths.rel.outDir)}`);
   }
   async _generateBotIndex() {
     const allInstances = await this._listIntegrationInstances();
@@ -457,9 +427,8 @@ class ProjectCommands extends import_base.BaseCommands {
     await this._writeFilesToOutFolder([indexFile]);
   }
   async _writeFilesToOutFolder(files) {
-    const { abs } = this._paths;
     for (const file of files) {
-      const filePath = pathutils.absoluteFrom(abs.outDir, file.path);
+      const filePath = pathutils.absoluteFrom(this._paths.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);
@@ -471,7 +440,7 @@ class ProjectCommands extends import_base.BaseCommands {
       this._logger.debug(`Integration definition not found at ${rel.definition}`);
       return;
     }
-    const { outputFiles } = await esbuild.buildEntrypoint({
+    const { outputFiles } = await esbuildutils.buildEntrypoint({
       cwd: abs.workDir,
       outfile: "",
       entrypoint: rel.definition,
@@ -484,19 +453,8 @@ class ProjectCommands extends import_base.BaseCommands {
     const { default: definition } = requireutils.requireJsCode(artifact.text);
     return definition;
   }
-  async _ensureLoginAndCreateClient(argv) {
-    const token = await this._userCache.get("token");
-    const workspaceId = argv.workspaceId ?? await this._userCache.get("workspaceId");
-    const host = argv.host ?? await this._userCache.get("host");
-    if (!(token && workspaceId && host)) {
-      throw new errors.NotLoggedInError();
-    }
-    const client = new bpclient.Client({ host, token, workspaceId });
-    return new import_api_utils.ApiUtils(client, host, token, workspaceId, this._logger);
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ProjectCommands,
-  ProjectPaths
+  ProjectCommands
 });

package/dist/app/user.js

@@ -36,9 +36,8 @@ var import_base = require("./base");
 var errors = __toESM(require("./errors"));
 var import_integration_ref = require("./integration-ref");
 class UserCommands extends import_base.BaseCommands {
-  constructor(_props, _userCache, logger) {
-    super(logger);
-    this._userCache = _userCache;
+  constructor(props, userCache, logger) {
+    super(props, userCache, logger);
   }
   async login(argv) {
     const promptedToken = await this._userCache.sync("token", argv.token, async (previousToken) => {
@@ -106,7 +105,7 @@ class UserCommands extends import_base.BaseCommands {
   async listBots(argv) {
     const api = await this._ensureLoginAndCreateClient(argv);
     try {
-      const bots = await api.listAllPages(api.client.listBots, "bots");
+      const bots = await api.listAllPages(api.client.listBots, (r) => r.bots);
       this._logger.success("Bots:");
       this._logger.json(bots);
     } catch (thrown) {
@@ -145,8 +144,8 @@ class UserCommands extends import_base.BaseCommands {
     const privateLister = (req) => api.client.listIntegrations({ nextToken: req.nextToken, name: argv.name, version: argv.version });
     const publicLister = (req) => api.client.listPublicIntegrations({ nextToken: req.nextToken, name: argv.name, version: argv.version });
     try {
-      const privateIntegrations = await api.listAllPages(privateLister, "integrations");
-      const publicIntegrations = await api.listAllPages(publicLister, "integrations");
+      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);
@@ -181,16 +180,6 @@ class UserCommands extends import_base.BaseCommands {
     this._logger.success(`Integration ${import_chalk.default.bold(integrationRef)} deleted`);
     return;
   }
-  async _ensureLoginAndCreateClient(argv) {
-    const token = await this._userCache.get("token");
-    const workspaceId = argv.workspaceId ?? await this._userCache.get("workspaceId");
-    const host = argv.host ?? await this._userCache.get("host");
-    if (!(token && workspaceId && host)) {
-      throw new errors.NotLoggedInError();
-    }
-    const client = new bpclient.Client({ host, token, workspaceId });
-    return new import_api_utils.ApiUtils(client, host, token, workspaceId, this._logger);
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/config.js

@@ -47,7 +47,7 @@ __export(config_exports, {
   serveSchema: () => serveSchema
 });
 module.exports = __toCommonJS(config_exports);
-var consts = __toESM(require("./const"));
+var consts = __toESM(require("./consts"));
 const botpressHome = {
   type: "string",
   description: "The path to the Botpress home directory",
@@ -97,7 +97,11 @@ const workDir = {
 };
 const botId = {
   type: "string",
-  description: "The bot ID to deploy"
+  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",
@@ -166,7 +170,8 @@ const deploySchema = {
   ...projectSchema,
   ...loggedInSchema,
   botId,
-  noBuild
+  noBuild,
+  createNewBot
 };
 const devSchema = {
   ...projectSchema,