@botpress/cli 0.0.14 → 0.0.17

package/dist/app/project.js

@@ -1,486 +0,0 @@
-"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_exports = {};
-__export(project_exports, {
-  ProjectCommands: () => ProjectCommands
-});
-module.exports = __toCommonJS(project_exports);
-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("../consts"));
-var esbuildutils = __toESM(require("../esbuild-utils"));
-var pathutils = __toESM(require("../path-utils"));
-var requireutils = __toESM(require("../require-utils"));
-var import_watcher = require("../watcher");
-var import_worker = require("../worker");
-var import_base = require("./base");
-var errors = __toESM(require("./errors"));
-var generator = __toESM(require("./generator"));
-var import_integration_ref = require("./integration-ref");
-class ProjectCommands extends import_base.BaseCommands {
-  constructor(props, _paths, _projectCache, userCache, logger) {
-    super(props, userCache, logger);
-    this._paths = _paths;
-    this._projectCache = _projectCache;
-  }
-  async installIntegration(integrationRef, argv) {
-    const integrationDef = await this._readIntegrationDefinitionFromFS();
-    if (integrationDef) {
-      throw new errors.ExclusiveBotFeatureError();
-    }
-    const api = await this._ensureLoginAndCreateClient(argv);
-    const parsedRef = (0, import_integration_ref.parseIntegrationRef)(integrationRef);
-    if (!parsedRef) {
-      throw new errors.InvalidIntegrationReferenceError(integrationRef);
-    }
-    const integration = await api.findIntegration(parsedRef);
-    if (!integration) {
-      throw new errors.BotpressCLIError(`Integration "${integrationRef}" not found`);
-    }
-    const allInstances = await this._listIntegrationInstances();
-    const existingInstance = allInstances.find((i) => i.name === integration.name);
-    if (existingInstance) {
-      this._logger.warn(`Integration with name "${integration.name}" already installed.`);
-      const res = await this._confirm("Do you want to overwrite the existing instance?");
-      if (!res) {
-        this._logger.log("Aborted");
-        return;
-      }
-      await this._uninstallIntegration(existingInstance);
-    }
-    await this._generateIntegrationInstance(integration);
-  }
-  async buildProject(argv) {
-    const t0 = Date.now();
-    const integrationDef = await this._readIntegrationDefinitionFromFS();
-    if (integrationDef) {
-      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 outfile = this._paths.abs.outFile;
-    if (!import_fs.default.existsSync(outfile)) {
-      throw new errors.NoBundleFoundError();
-    }
-    const isIntegration = !!await this._readIntegrationDefinitionFromFS();
-    this._logger.log(`Serving ${isIntegration ? "integration" : "bot"}...`);
-    const { default: serveable } = requireutils.requireJsFile(outfile);
-    return serveable.start(argv.port);
-  }
-  async bundleProject(_argv) {
-    const integrationDef = await this._readIntegrationDefinitionFromFS();
-    const { rel, abs } = this._paths;
-    const line = this._logger.line();
-    const logLevel = this._props.verbose ? "info" : "silent";
-    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 integrationDef = await this._readIntegrationDefinitionFromFS();
-    if (!integrationDef) {
-      this._logger.warn("No typings to generate for bot");
-      return;
-    }
-    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,
-      this._paths.relFrom("outDir").implementationDir
-    );
-    const indexFile = await generator.generateIntegrationIndex(this._paths.relFrom("outDir").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);
-    if (api.host !== consts.defaultBotpressApi) {
-      this._logger.log(`Using custom host ${api.host}`);
-    }
-    if (!argv.noBuild) {
-      await this.buildProject(argv);
-    }
-    const integrationDef = await this._readIntegrationDefinitionFromFS();
-    if (integrationDef) {
-      return this._deployIntegration(api, integrationDef);
-    }
-    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.");
-    if (!argv.noBuild) {
-      await this.buildProject(argv);
-    }
-    const api = await this._ensureLoginAndCreateClient(argv);
-    const integrationDef = await this._readIntegrationDefinitionFromFS();
-    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})`;
-    const worker = await import_worker.Worker.spawn(
-      {
-        type: "code",
-        code,
-        env: {
-          BP_API_URL: api.host,
-          BP_TOKEN: api.token
-        }
-      },
-      this._logger
-    ).catch((thrown) => {
-      throw errors.BotpressCLIError.wrap(thrown, "Could not start dev worker");
-    });
-    try {
-      const watcher = await import_watcher.FileWatcher.watch(
-        argv.workDir,
-        async (events) => {
-          const typescriptEvents = events.filter((e) => import_path.default.extname(e.path) === ".ts");
-          if (typescriptEvents.length === 0) {
-            return;
-          }
-          this._logger.log("Changes detected, reloading...");
-          await this.buildProject(argv);
-          await worker.reload();
-        },
-        { ignore: [this._paths.abs.outDir] }
-      );
-      await Promise.race([worker.wait(), watcher.wait()]);
-      await watcher.close();
-    } catch (thrown) {
-      throw errors.BotpressCLIError.wrap(thrown, "An error occurred while running the dev worker");
-    } finally {
-      if (worker.running) {
-        await worker.kill();
-      }
-    }
-  }
-  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 _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 bot");
-      });
-      bot = resp.bot;
-      createLine.success(`Dev Bot created with id "${bot.id}"`);
-      await this._projectCache.set("devId", bot.id);
-    }
-    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");
-    });
-    updateLine.success("Integrations installed successfully");
-    this._displayWebhookUrls(updatedBot);
-  }
-  async _deployIntegration(api, integrationDef) {
-    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 });
-    let message;
-    if (integration) {
-      this._logger.warn("Integration already exists. If you decide to deploy, it will overwrite the existing one.");
-      message = `Are you sure you want to override integration ${integrationDef.name} v${integrationDef.version}?`;
-    } else {
-      message = `Are you sure you want to deploy integration ${integrationDef.name} v${integrationDef.version}?`;
-    }
-    const confirm = await this._confirm(message);
-    if (!confirm) {
-      this._logger.log("Aborted");
-      return;
-    }
-    const line = this._logger.line();
-    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, 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, 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, (r) => r.bots).catch((thrown) => {
-        throw errors.BotpressCLIError.wrap(thrown, "Could not fetch existing bots");
-      });
-      if (!userBots.length) {
-        throw new errors.NoBotsFoundError();
-      }
-      const initial = userBots.find((bot) => bot.id === defaultId);
-      const { prompted } = await (0, import_prompts.default)({
-        type: "autocomplete",
-        name: "prompted",
-        message: "Which bot do you want to deploy?",
-        initial: initial?.name,
-        choices: userBots.map((bot) => ({ title: bot.name, value: bot.id }))
-      });
-      if (!prompted) {
-        throw new errors.ParamRequiredError("Bot Id");
-      }
-      return prompted;
-    });
-    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();
-    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 }
-        });
-      }
-    }
-  }
-  async _listIntegrationInstances() {
-    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 [];
-    }
-    const allFiles = await import_fs.default.promises.readdir(installPath);
-    const allPaths = allFiles.map((name) => import_path.default.join(installPath, name));
-    const directories = await import_bluebird.default.filter(allPaths, async (path) => {
-      const stat = await import_fs.default.promises.stat(path);
-      return stat.isDirectory();
-    });
-    let jsons = directories.map((root) => ({ root, json: import_path.default.join(root, generator.INTEGRATION_JSON) }));
-    jsons = jsons.filter(({ json: x }) => import_fs.default.existsSync(x));
-    return import_bluebird.default.map(jsons, async ({ root, json }) => {
-      const content = await import_fs.default.promises.readFile(json, "utf-8");
-      const { name, version, id } = JSON.parse(content);
-      const dirname = import_path.default.basename(root);
-      return {
-        dirname,
-        id,
-        name,
-        version
-      };
-    });
-  }
-  async _uninstallIntegration(instance) {
-    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 instanceFiles = await generator.generateIntegrationInstance(
-      integration,
-      this._paths.relFrom("outDir").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();
-    const indexFile = await generator.generateBotIndex(
-      this._paths.relFrom("outDir").installDir,
-      allInstances.map((i) => i.dirname)
-    );
-    await this._writeFilesToOutFolder([indexFile]);
-  }
-  async _writeFilesToOutFolder(files) {
-    for (const file of files) {
-      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);
-    }
-  }
-  async _readIntegrationDefinitionFromFS() {
-    const { abs, rel } = this._paths;
-    if (!import_fs.default.existsSync(abs.definition)) {
-      this._logger.debug(`Integration definition not found at ${rel.definition}`);
-      return;
-    }
-    const { outputFiles } = await esbuildutils.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 } = requireutils.requireJsCode(artifact.text);
-    return definition;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ProjectCommands
-});

package/dist/app/typings.js

@@ -1,16 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 typings_exports = {};
-module.exports = __toCommonJS(typings_exports);