@botpress/cli 0.0.2

package/dist/app/user.js

@@ -0,0 +1,198 @@
+"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 user_exports = {};
+__export(user_exports, {
+  UserCommands: () => UserCommands
+});
+module.exports = __toCommonJS(user_exports);
+var bpclient = __toESM(require("@botpress/client"));
+var import_chalk = __toESM(require("chalk"));
+var import_lodash = __toESM(require("lodash"));
+var import_prompts = __toESM(require("prompts"));
+var import_api_utils = require("./api-utils");
+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;
+  }
+  async login(argv) {
+    const promptedToken = await this._userCache.sync("token", argv.token, async (previousToken) => {
+      const { prompted } = await (0, import_prompts.default)({
+        type: "password",
+        name: "prompted",
+        message: "Enter your Personal Access Token",
+        initial: previousToken
+      });
+      if (!prompted) {
+        throw new errors.ParamRequiredError("Personal Access Token");
+      }
+      return prompted;
+    });
+    const promptedWorkspaceId = await this._userCache.sync(
+      "workspaceId",
+      argv.workspaceId,
+      async (previousWorkspace) => {
+        const { prompted } = await (0, import_prompts.default)({
+          type: "text",
+          name: "prompted",
+          message: "Enter your default Workspace Id",
+          initial: previousWorkspace
+        });
+        if (!prompted) {
+          throw new errors.ParamRequiredError("Workspace Id");
+        }
+        return prompted;
+      }
+    );
+    await this._userCache.set("host", argv.host);
+    const client = new bpclient.Client({
+      host: argv.host,
+      token: promptedToken,
+      workspaceId: promptedWorkspaceId
+    });
+    const api = new import_api_utils.ApiUtils(client, argv.host, promptedToken, promptedWorkspaceId, this._logger);
+    await api.testLogin();
+    this._logger.success("Logged In");
+  }
+  async logout() {
+    await this._userCache.clear();
+    this._logger.success("Logged Out");
+  }
+  async createBot(argv) {
+    const { client } = await this._ensureLoginAndCreateClient(argv);
+    try {
+      const { bot } = await client.createBot({ name: argv.name });
+      this._logger.success(`Bot ${import_chalk.default.bold(bot.id)}:`);
+      this._logger.json(bot);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not create bot");
+    }
+  }
+  async getBot(botId, argv) {
+    const { client } = await this._ensureLoginAndCreateClient(argv);
+    try {
+      const { bot } = await client.getBot({ id: botId });
+      this._logger.success(`Bot ${import_chalk.default.bold(botId)}:`);
+      this._logger.json(bot);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not get bot ${botId}`);
+    }
+  }
+  async listBots(argv) {
+    const api = await this._ensureLoginAndCreateClient(argv);
+    try {
+      const bots = await api.listAllPages(api.client.listBots, "bots");
+      this._logger.success("Bots:");
+      this._logger.json(bots);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not list bots");
+    }
+  }
+  async deleteBot(botId, argv) {
+    const { client } = await this._ensureLoginAndCreateClient(argv);
+    try {
+      await client.deleteBot({ id: botId });
+      this._logger.success(`Bot ${import_chalk.default.bold(botId)} deleted`);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not delete bot ${botId}`);
+    }
+  }
+  async getIntegration(integrationRef, argv) {
+    const api = await this._ensureLoginAndCreateClient(argv);
+    const parsedRef = (0, import_integration_ref.parseIntegrationRef)(integrationRef);
+    if (!parsedRef) {
+      throw new errors.InvalidIntegrationReferenceError(integrationRef);
+    }
+    try {
+      const integration = await api.findIntegration(parsedRef);
+      if (integration) {
+        this._logger.success(`Integration ${import_chalk.default.bold(integrationRef)}:`);
+        this._logger.json(integration);
+        return;
+      }
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not get integration ${integrationRef}`);
+    }
+    throw new errors.BotpressCLIError(`Integration ${integrationRef} not found`);
+  }
+  async listIntegrations(argv) {
+    const api = await this._ensureLoginAndCreateClient(argv);
+    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 integrations = import_lodash.default.uniqBy([...privateIntegrations, ...publicIntegrations], (i) => i.id);
+      this._logger.success("Integrations:");
+      this._logger.json(integrations);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not list integrations");
+    }
+  }
+  async deleteIntegration(integrationRef, argv) {
+    const api = await this._ensureLoginAndCreateClient(argv);
+    const parsedRef = (0, import_integration_ref.parseIntegrationRef)(integrationRef);
+    if (!parsedRef) {
+      throw new errors.InvalidIntegrationReferenceError(integrationRef);
+    }
+    let integration;
+    try {
+      integration = await api.findPrivateIntegration(parsedRef);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not get integration ${integrationRef}`);
+    }
+    if (!integration) {
+      const publicIntegration = await api.findPublicIntegration(parsedRef);
+      if (publicIntegration) {
+        throw new errors.BotpressCLIError(`Integration ${integrationRef} does not belong to your workspace`);
+      }
+      throw new errors.BotpressCLIError(`Integration ${integrationRef} not found`);
+    }
+    try {
+      await api.client.deleteIntegration({ id: integration.id });
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not delete integration ${integrationRef}`);
+    }
+    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 = {
+  UserCommands
+});

package/dist/config.js

@@ -0,0 +1,245 @@
+"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 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
+});
+module.exports = __toCommonJS(config_exports);
+var consts = __toESM(require("./const"));
+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 definition = {
+  type: "string",
+  description: "The integration definition file to use. If file not found, the project is treated as a bot",
+  default: consts.defaultIntegrationConfigScript
+};
+const outDir = {
+  type: "string",
+  description: "The output directory",
+  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"
+};
+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",
+  default: false
+};
+const host = {
+  type: "string",
+  description: "The URL of the Botpress server"
+};
+const token = {
+  type: "string",
+  description: "You Personal Access Token "
+};
+const workspaceId = {
+  type: "string",
+  description: "The Workspace Id to deploy to"
+};
+const botRef = {
+  type: "string",
+  description: "The bot ID. Bot Name is not supported.",
+  demandOption: true
+};
+const integrationRef = {
+  type: "string",
+  description: "The integration ID or name with optionnal version. Ex: teams or teams@0.2.0",
+  demandOption: true
+};
+const globalSchema = {
+  verbose,
+  confirm,
+  json,
+  botpressHome
+};
+const projectSchema = {
+  ...globalSchema,
+  entryPoint,
+  definition,
+  outDir,
+  workDir
+};
+const loggedInSchema = {
+  host,
+  workspaceId,
+  token
+};
+const generateSchema = {
+  ...projectSchema
+};
+const bundleSchema = {
+  ...projectSchema
+};
+const buildSchema = {
+  ...projectSchema
+};
+const serveSchema = {
+  ...projectSchema,
+  port
+};
+const deploySchema = {
+  ...projectSchema,
+  ...loggedInSchema,
+  botId,
+  noBuild
+};
+const devSchema = {
+  ...projectSchema,
+  ...loggedInSchema,
+  url,
+  port,
+  noBuild
+};
+const addSchema = {
+  ...projectSchema,
+  ...loggedInSchema
+};
+const loginSchema = {
+  ...globalSchema,
+  token,
+  workspaceId,
+  host: { ...host, default: consts.defaultBotpressApi }
+};
+const logoutSchema = {
+  ...globalSchema
+};
+const createBotSchema = {
+  ...globalSchema,
+  ...loggedInSchema,
+  name: { type: "string", description: "The name of the bot to create" }
+};
+const readBotSchema = {
+  ...globalSchema,
+  ...loggedInSchema
+};
+const deleteBotSchema = {
+  ...globalSchema,
+  ...loggedInSchema
+};
+const listBotsSchema = {
+  ...globalSchema,
+  ...loggedInSchema
+};
+const readIntegrationSchema = {
+  ...globalSchema,
+  ...loggedInSchema
+};
+const listIntegrationsSchema = {
+  ...globalSchema,
+  ...loggedInSchema,
+  name: { type: "string", description: "The name filter when listing integrations" },
+  version: { type: "string", description: "The version filter when listing integrations" }
+};
+const deleteIntegrationSchema = {
+  ...globalSchema,
+  ...loggedInSchema
+};
+// 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
+});

package/dist/const.js

@@ -0,0 +1,87 @@
+"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 const_exports = {};
+__export(const_exports, {
+  defDataOutfile: () => defDataOutfile,
+  defaultBotpressApi: () => defaultBotpressApi,
+  defaultBotpressApp: () => defaultBotpressApp,
+  defaultBotpressHome: () => defaultBotpressHome,
+  defaultEntrypoint: () => defaultEntrypoint,
+  defaultIntegrationConfigScript: () => defaultIntegrationConfigScript,
+  defaultOutputFolder: () => defaultOutputFolder,
+  dist: () => dist,
+  implementationTypings: () => implementationTypings,
+  installDir: () => installDir,
+  outfile: () => outfile,
+  projectCache: () => projectCache,
+  relativeToHomeFolder: () => relativeToHomeFolder,
+  relativeToOutFolder: () => relativeToOutFolder,
+  userCache: () => userCache
+});
+module.exports = __toCommonJS(const_exports);
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+const defaultOutputFolder = ".botpress";
+const defaultEntrypoint = "src/index.ts";
+const defaultIntegrationConfigScript = "integration.definition.ts";
+const defaultBotpressApi = "https://api.botpress.cloud";
+const defaultBotpressApp = "https://app.botpress.cloud";
+const defaultBotpressHome = import_path.default.join(import_os.default.homedir(), ".botpress");
+const relativeToHomeFolder = {
+  userCache: "user.cache.json"
+};
+const userCache = (botpressHome) => import_path.default.join(botpressHome, relativeToHomeFolder.userCache);
+const relativeToOutFolder = {
+  dist: "dist",
+  outfile: import_path.default.join("dist", "index.js"),
+  defDataOutfile: import_path.default.join("dist", "integration.definition.json"),
+  implementationTypings: "implementation",
+  installDir: "installations",
+  projectCache: "project.cache.json"
+};
+const dist = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.dist);
+const outfile = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.outfile);
+const defDataOutfile = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.defDataOutfile);
+const implementationTypings = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.implementationTypings);
+const installDir = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.installDir);
+const projectCache = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.projectCache);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defDataOutfile,
+  defaultBotpressApi,
+  defaultBotpressApp,
+  defaultBotpressHome,
+  defaultEntrypoint,
+  defaultIntegrationConfigScript,
+  defaultOutputFolder,
+  dist,
+  implementationTypings,
+  installDir,
+  outfile,
+  projectCache,
+  relativeToHomeFolder,
+  relativeToOutFolder,
+  userCache
+});