@botpress/cli 2.1.0 → 2.1.2

package/dist/code-generation/typings.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/code-generation/typings.ts"],
+  "sourcesContent": ["import * as client from '@botpress/client'\nimport * as utils from '../utils'\n\nexport type File = { path: string; content: string }\n\ntype NameVersion = { name: string; version: string }\nexport type IntegrationInstallablePackage = NameVersion &\n  (\n    | {\n        source: 'remote'\n        integration: client.Integration\n      }\n    | {\n        source: 'local'\n        devId?: string\n        path: utils.path.AbsolutePath\n      }\n  )\n\nexport type InterfaceInstallablePackage = NameVersion &\n  (\n    | {\n        source: 'remote'\n        interface: client.Interface\n      }\n    | {\n        source: 'local'\n        path: utils.path.AbsolutePath\n      }\n  )\n\nexport type PluginInstallablePackage = NameVersion &\n  (\n    | {\n        source: 'local'\n        path: utils.path.AbsolutePath\n        implementationCode: string\n      }\n    | {\n        source: 'remote'\n        plugin: client.Plugin\n      }\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/command-definitions.js

@@ -0,0 +1,85 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var command_definitions_exports = {};
+__export(command_definitions_exports, {
+  default: () => command_definitions_default
+});
+module.exports = __toCommonJS(command_definitions_exports);
+var config = __toESM(require("./config"));
+var command_definitions_default = {
+  login: { description: "Login to Botpress Cloud", schema: config.schemas.login },
+  logout: { description: "Logout of Botpress Cloud", schema: config.schemas.logout },
+  bots: {
+    description: "Bot related commands",
+    subcommands: {
+      create: { description: "Create new bot", schema: config.schemas.createBot, alias: "new" },
+      get: { description: "Get bot", schema: config.schemas.getBot },
+      delete: { description: "Delete bot", schema: config.schemas.deleteBot, alias: "rm" },
+      list: { description: "List bots", schema: config.schemas.listBots, alias: "ls" }
+    }
+  },
+  integrations: {
+    description: "Integration related commands",
+    subcommands: {
+      get: { description: "Get integration", schema: config.schemas.getIntegration },
+      delete: { description: "Delete integration", schema: config.schemas.deleteIntegration, alias: "rm" },
+      list: { description: "List integrations", schema: config.schemas.listIntegrations, alias: "ls" }
+    }
+  },
+  interfaces: {
+    description: "Interface related commands",
+    subcommands: {
+      get: { description: "Get interface", schema: config.schemas.getInterface },
+      delete: { description: "Delete interface", schema: config.schemas.deleteInterface, alias: "rm" },
+      list: { description: "List interfaces", schema: config.schemas.listInterfaces, alias: "ls" }
+    }
+  },
+  plugins: {
+    description: "Plugin related commands",
+    subcommands: {
+      get: { description: "Get plugin", schema: config.schemas.getPlugin },
+      delete: { description: "Delete plugin", schema: config.schemas.deletePlugin, alias: "rm" },
+      list: { description: "List plugins", schema: config.schemas.listPlugins, alias: "ls" }
+    }
+  },
+  init: { description: "Initialize a new project", schema: config.schemas.init },
+  generate: { description: "Generate typings for intellisense", schema: config.schemas.generate, alias: "gen" },
+  bundle: { description: "Bundle a botpress project", schema: config.schemas.bundle },
+  build: { description: "Generate typings and bundle a botpress project", schema: config.schemas.build },
+  read: { description: "Read and parse an integration definition", schema: config.schemas.read },
+  serve: { description: "Serve your project locally", schema: config.schemas.serve },
+  deploy: { description: "Deploy your project to the cloud", schema: config.schemas.deploy },
+  add: { description: "Install a package; could be an integration or an interface", schema: config.schemas.add },
+  dev: { description: "Run your project in dev mode", schema: config.schemas.dev },
+  lint: { description: "EXPERIMENTAL: Lint an integration definition", schema: config.schemas.lint },
+  chat: { description: "EXPERIMENTAL: Chat with a bot directly from the CLI", schema: config.schemas.chat }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});
+//# sourceMappingURL=command-definitions.js.map

package/dist/command-definitions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/command-definitions.ts"],
+  "sourcesContent": ["import type { DefinitionTree } from './command-tree'\nimport * as config from './config'\n\nexport default {\n  login: { description: 'Login to Botpress Cloud', schema: config.schemas.login },\n  logout: { description: 'Logout of Botpress Cloud', schema: config.schemas.logout },\n  bots: {\n    description: 'Bot related commands',\n    subcommands: {\n      create: { description: 'Create new bot', schema: config.schemas.createBot, alias: 'new' },\n      get: { description: 'Get bot', schema: config.schemas.getBot },\n      delete: { description: 'Delete bot', schema: config.schemas.deleteBot, alias: 'rm' },\n      list: { description: 'List bots', schema: config.schemas.listBots, alias: 'ls' },\n    },\n  },\n  integrations: {\n    description: 'Integration related commands',\n    subcommands: {\n      get: { description: 'Get integration', schema: config.schemas.getIntegration },\n      delete: { description: 'Delete integration', schema: config.schemas.deleteIntegration, alias: 'rm' },\n      list: { description: 'List integrations', schema: config.schemas.listIntegrations, alias: 'ls' },\n    },\n  },\n  interfaces: {\n    description: 'Interface related commands',\n    subcommands: {\n      get: { description: 'Get interface', schema: config.schemas.getInterface },\n      delete: { description: 'Delete interface', schema: config.schemas.deleteInterface, alias: 'rm' },\n      list: { description: 'List interfaces', schema: config.schemas.listInterfaces, alias: 'ls' },\n    },\n  },\n  plugins: {\n    description: 'Plugin related commands',\n    subcommands: {\n      get: { description: 'Get plugin', schema: config.schemas.getPlugin },\n      delete: { description: 'Delete plugin', schema: config.schemas.deletePlugin, alias: 'rm' },\n      list: { description: 'List plugins', schema: config.schemas.listPlugins, alias: 'ls' },\n    },\n  },\n  init: { description: 'Initialize a new project', schema: config.schemas.init },\n  generate: { description: 'Generate typings for intellisense', schema: config.schemas.generate, alias: 'gen' },\n  bundle: { description: 'Bundle a botpress project', schema: config.schemas.bundle },\n  build: { description: 'Generate typings and bundle a botpress project', schema: config.schemas.build },\n  read: { description: 'Read and parse an integration definition', schema: config.schemas.read },\n  serve: { description: 'Serve your project locally', schema: config.schemas.serve },\n  deploy: { description: 'Deploy your project to the cloud', schema: config.schemas.deploy },\n  add: { description: 'Install a package; could be an integration or an interface', schema: config.schemas.add },\n  dev: { description: 'Run your project in dev mode', schema: config.schemas.dev },\n  lint: { description: 'EXPERIMENTAL: Lint an integration definition', schema: config.schemas.lint },\n  chat: { description: 'EXPERIMENTAL: Chat with a bot directly from the CLI', schema: config.schemas.chat },\n} satisfies DefinitionTree\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,aAAwB;AAExB,IAAO,8BAAQ;AAAA,EACb,OAAO,EAAE,aAAa,2BAA2B,QAAQ,OAAO,QAAQ,MAAM;AAAA,EAC9E,QAAQ,EAAE,aAAa,4BAA4B,QAAQ,OAAO,QAAQ,OAAO;AAAA,EACjF,MAAM;AAAA,IACJ,aAAa;AAAA,IACb,aAAa;AAAA,MACX,QAAQ,EAAE,aAAa,kBAAkB,QAAQ,OAAO,QAAQ,WAAW,OAAO,MAAM;AAAA,MACxF,KAAK,EAAE,aAAa,WAAW,QAAQ,OAAO,QAAQ,OAAO;AAAA,MAC7D,QAAQ,EAAE,aAAa,cAAc,QAAQ,OAAO,QAAQ,WAAW,OAAO,KAAK;AAAA,MACnF,MAAM,EAAE,aAAa,aAAa,QAAQ,OAAO,QAAQ,UAAU,OAAO,KAAK;AAAA,IACjF;AAAA,EACF;AAAA,EACA,cAAc;AAAA,IACZ,aAAa;AAAA,IACb,aAAa;AAAA,MACX,KAAK,EAAE,aAAa,mBAAmB,QAAQ,OAAO,QAAQ,eAAe;AAAA,MAC7E,QAAQ,EAAE,aAAa,sBAAsB,QAAQ,OAAO,QAAQ,mBAAmB,OAAO,KAAK;AAAA,MACnG,MAAM,EAAE,aAAa,qBAAqB,QAAQ,OAAO,QAAQ,kBAAkB,OAAO,KAAK;AAAA,IACjG;AAAA,EACF;AAAA,EACA,YAAY;AAAA,IACV,aAAa;AAAA,IACb,aAAa;AAAA,MACX,KAAK,EAAE,aAAa,iBAAiB,QAAQ,OAAO,QAAQ,aAAa;AAAA,MACzE,QAAQ,EAAE,aAAa,oBAAoB,QAAQ,OAAO,QAAQ,iBAAiB,OAAO,KAAK;AAAA,MAC/F,MAAM,EAAE,aAAa,mBAAmB,QAAQ,OAAO,QAAQ,gBAAgB,OAAO,KAAK;AAAA,IAC7F;AAAA,EACF;AAAA,EACA,SAAS;AAAA,IACP,aAAa;AAAA,IACb,aAAa;AAAA,MACX,KAAK,EAAE,aAAa,cAAc,QAAQ,OAAO,QAAQ,UAAU;AAAA,MACnE,QAAQ,EAAE,aAAa,iBAAiB,QAAQ,OAAO,QAAQ,cAAc,OAAO,KAAK;AAAA,MACzF,MAAM,EAAE,aAAa,gBAAgB,QAAQ,OAAO,QAAQ,aAAa,OAAO,KAAK;AAAA,IACvF;AAAA,EACF;AAAA,EACA,MAAM,EAAE,aAAa,4BAA4B,QAAQ,OAAO,QAAQ,KAAK;AAAA,EAC7E,UAAU,EAAE,aAAa,qCAAqC,QAAQ,OAAO,QAAQ,UAAU,OAAO,MAAM;AAAA,EAC5G,QAAQ,EAAE,aAAa,6BAA6B,QAAQ,OAAO,QAAQ,OAAO;AAAA,EAClF,OAAO,EAAE,aAAa,kDAAkD,QAAQ,OAAO,QAAQ,MAAM;AAAA,EACrG,MAAM,EAAE,aAAa,4CAA4C,QAAQ,OAAO,QAAQ,KAAK;AAAA,EAC7F,OAAO,EAAE,aAAa,8BAA8B,QAAQ,OAAO,QAAQ,MAAM;AAAA,EACjF,QAAQ,EAAE,aAAa,oCAAoC,QAAQ,OAAO,QAAQ,OAAO;AAAA,EACzF,KAAK,EAAE,aAAa,8DAA8D,QAAQ,OAAO,QAAQ,IAAI;AAAA,EAC7G,KAAK,EAAE,aAAa,gCAAgC,QAAQ,OAAO,QAAQ,IAAI;AAAA,EAC/E,MAAM,EAAE,aAAa,gDAAgD,QAAQ,OAAO,QAAQ,KAAK;AAAA,EACjG,MAAM,EAAE,aAAa,uDAAuD,QAAQ,OAAO,QAAQ,KAAK;AAC1G;",
+  "names": []
+}

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

@@ -0,0 +1,262 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var add_command_exports = {};
+__export(add_command_exports, {
+  AddCommand: () => AddCommand
+});
+module.exports = __toCommonJS(add_command_exports);
+var sdk = __toESM(require("@botpress/sdk"));
+var fslib = __toESM(require("fs"));
+var pathlib = __toESM(require("path"));
+var import_api = require("../api");
+var codegen = __toESM(require("../code-generation"));
+var consts = __toESM(require("../consts"));
+var errors = __toESM(require("../errors"));
+var pkgRef = __toESM(require("../package-ref"));
+var utils = __toESM(require("../utils"));
+var import_global_command = require("./global-command");
+var import_project_command = require("./project-command");
+class AddCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const ref = this._parseArgvRef();
+    if (ref) {
+      return await this._addSinglePackage(ref);
+    }
+    const pkgJson = await utils.pkgJson.readPackageJson(this.argv.installPath);
+    if (!pkgJson) {
+      this.logger.warn("No package.json found in the install path");
+      return;
+    }
+    const { bpDependencies } = pkgJson;
+    if (!bpDependencies) {
+      this.logger.log("No bp dependencies found in package.json");
+      return;
+    }
+    const bpDependenciesSchema = sdk.z.record(sdk.z.string());
+    const parseResults = bpDependenciesSchema.safeParse(bpDependencies);
+    if (!parseResults.success) {
+      throw new errors.BotpressCLIError("Invalid bpDependencies found in package.json");
+    }
+    for (const [pkgAlias, pkgRefStr] of Object.entries(parseResults.data)) {
+      const parsed = pkgRef.parsePackageRef(pkgRefStr);
+      if (!parsed) {
+        throw new errors.InvalidPackageReferenceError(pkgRefStr);
+      }
+      await this._addSinglePackage({ ...parsed, alias: pkgAlias });
+    }
+  }
+  _parseArgvRef = () => {
+    if (!this.argv.packageRef) {
+      return;
+    }
+    const parsed = pkgRef.parsePackageRef(this.argv.packageRef);
+    if (!parsed) {
+      throw new errors.InvalidPackageReferenceError(this.argv.packageRef);
+    }
+    if (parsed.type !== "name") {
+      return parsed;
+    }
+    const argvPkgType = this.argv.packageType;
+    if (!argvPkgType) {
+      return parsed;
+    }
+    const ref = { ...parsed, pkg: argvPkgType };
+    const strRef = pkgRef.formatPackageRef(ref);
+    this.logger.warn(`argument --packageType is deprecated; please use the package reference format "${strRef}"`);
+    return ref;
+  };
+  async _addSinglePackage(ref) {
+    const targetPackage = ref.type === "path" ? await this._findLocalPackage(ref) : await this._findRemotePackage(ref);
+    if (!targetPackage) {
+      const strRef = pkgRef.formatPackageRef(ref);
+      throw new errors.BotpressCLIError(`Could not find package "${strRef}"`);
+    }
+    const packageName = ref.alias ?? targetPackage.pkg.name;
+    const baseInstallPath = utils.path.absoluteFrom(utils.path.cwd(), this.argv.installPath);
+    const packageDirName = utils.casing.to.kebabCase(packageName);
+    const installPath = utils.path.join(baseInstallPath, consts.installDirName, packageDirName);
+    const alreadyInstalled = fslib.existsSync(installPath);
+    if (alreadyInstalled) {
+      this.logger.warn(`Package with name "${packageName}" already installed.`);
+      const res = await this.prompt.confirm("Do you want to overwrite the existing package?");
+      if (!res) {
+        this.logger.log("Aborted");
+        return;
+      }
+      await this._uninstall(installPath);
+    }
+    let files;
+    if (targetPackage.type === "integration") {
+      files = await codegen.generateIntegrationPackage(targetPackage.pkg);
+    } else if (targetPackage.type === "interface") {
+      files = await codegen.generateInterfacePackage(targetPackage.pkg);
+    } else if (targetPackage.type === "plugin") {
+      files = await codegen.generatePluginPackage(targetPackage.pkg);
+    } else {
+      throw new errors.BotpressCLIError("Invalid package type");
+    }
+    await this._install(installPath, files);
+  }
+  async _findRemotePackage(ref) {
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    if (this._pkgCouldBe(ref, "integration")) {
+      const integration = await api.findIntegration(ref);
+      if (integration) {
+        const { name, version } = integration;
+        return { type: "integration", pkg: { source: "remote", integration, name, version } };
+      }
+    }
+    if (this._pkgCouldBe(ref, "interface")) {
+      const intrface = await api.findPublicInterface(ref);
+      if (intrface) {
+        const { name, version } = intrface;
+        return { type: "interface", pkg: { source: "remote", interface: intrface, name, version } };
+      }
+    }
+    if (this._pkgCouldBe(ref, "plugin")) {
+      const plugin = await api.findPublicPlugin(ref);
+      if (plugin) {
+        const { name, version } = plugin;
+        return { type: "plugin", pkg: { source: "remote", plugin, name, version } };
+      }
+    }
+    return;
+  }
+  async _findLocalPackage(ref) {
+    const absPath = utils.path.absoluteFrom(utils.path.cwd(), ref.path);
+    const {
+      definition: projectDefinition,
+      implementation: projectImplementation,
+      devId: projectDevId
+    } = await this._readProject(absPath);
+    if (projectDefinition?.type === "integration") {
+      const { name, version } = projectDefinition.definition;
+      let devId;
+      if (this.argv.useDev && projectDevId) {
+        this.logger.warn(`Installing integration "${name}" with dev version "${projectDevId}"`);
+        devId = projectDevId;
+      }
+      return {
+        type: "integration",
+        pkg: { source: "local", path: absPath, devId, name, version }
+      };
+    }
+    if (projectDefinition?.type === "interface") {
+      const { name, version } = projectDefinition.definition;
+      return {
+        type: "interface",
+        pkg: { source: "local", path: absPath, name, version }
+      };
+    }
+    if (projectDefinition?.type === "plugin") {
+      if (!projectImplementation) {
+        throw new errors.BotpressCLIError(
+          "Plugin implementation not found; Please build the plugin project before installing"
+        );
+      }
+      const { name, version } = projectDefinition.definition;
+      return {
+        type: "plugin",
+        pkg: {
+          source: "local",
+          path: absPath,
+          implementationCode: projectImplementation,
+          name,
+          version
+        }
+      };
+    }
+    if (projectDefinition?.type === "bot") {
+      throw new errors.BotpressCLIError("Cannot install a bot as a package");
+    }
+    return;
+  }
+  async _install(installPath, files) {
+    const line = this.logger.line();
+    line.started(`Installing ${files.length} files to "${installPath}"`);
+    try {
+      for (const file of files) {
+        const filePath = utils.path.absoluteFrom(installPath, file.path);
+        const dirPath = pathlib.dirname(filePath);
+        await fslib.promises.mkdir(dirPath, { recursive: true });
+        await fslib.promises.writeFile(filePath, file.content);
+      }
+      line.success(`Installed ${files.length} files to "${installPath}"`);
+    } finally {
+      line.commit();
+    }
+  }
+  async _uninstall(installPath) {
+    await fslib.promises.rm(installPath, { recursive: true });
+  }
+  async _readProject(workDir) {
+    class AnyProjectCommand extends import_project_command.ProjectCommand {
+      async run() {
+        throw new errors.BotpressCLIError("Not implemented");
+      }
+      async readProjectDefinitionFromFS() {
+        return super.readProjectDefinitionFromFS();
+      }
+      get projectCache() {
+        return super.projectCache;
+      }
+    }
+    const cmd = new AnyProjectCommand(import_api.ApiClient, this.prompt, this.logger, {
+      ...this.argv,
+      workDir
+    });
+    const definition = await cmd.readProjectDefinitionFromFS().catch((thrown) => {
+      if (thrown instanceof errors.ProjectDefinitionNotFoundError) {
+        return void 0;
+      }
+      throw thrown;
+    });
+    const devId = await cmd.projectCache.get("devId");
+    const implementationAbsPath = utils.path.join(workDir, consts.fromWorkDir.outFile);
+    if (!fslib.existsSync(implementationAbsPath)) {
+      return { definition, devId };
+    }
+    const implementation = await fslib.promises.readFile(implementationAbsPath, "utf8");
+    return { definition, implementation, devId };
+  }
+  _pkgCouldBe = (ref, pkgType) => {
+    if (ref.type === "id") {
+      return true;
+    }
+    if (!ref.pkg) {
+      return true;
+    }
+    return ref.pkg === pkgType;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddCommand
+});
+//# sourceMappingURL=add-command.js.map

package/dist/command-implementations/add-command.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/command-implementations/add-command.ts"],
+  "sourcesContent": ["import * as sdk from '@botpress/sdk'\nimport * as fslib from 'fs'\nimport * as pathlib from 'path'\nimport { ApiClient } from '../api'\nimport * as codegen from '../code-generation'\nimport type commandDefinitions from '../command-definitions'\nimport * as consts from '../consts'\nimport * as errors from '../errors'\nimport * as pkgRef from '../package-ref'\nimport * as utils from '../utils'\nimport { GlobalCommand } from './global-command'\nimport { ProjectCache, ProjectCommand, ProjectCommandDefinition, ProjectDefinition } from './project-command'\n\ntype InstallablePackage =\n  | {\n      type: 'integration'\n      pkg: codegen.IntegrationInstallablePackage\n    }\n  | {\n      type: 'interface'\n      pkg: codegen.InterfaceInstallablePackage\n    }\n  | {\n      type: 'plugin'\n      pkg: codegen.PluginInstallablePackage\n    }\n\nexport type AddCommandDefinition = typeof commandDefinitions.add\nexport class AddCommand extends GlobalCommand<AddCommandDefinition> {\n  public async run(): Promise<void> {\n    const ref = this._parseArgvRef()\n    if (ref) {\n      return await this._addSinglePackage(ref)\n    }\n\n    const pkgJson = await utils.pkgJson.readPackageJson(this.argv.installPath)\n    if (!pkgJson) {\n      this.logger.warn('No package.json found in the install path')\n      return\n    }\n\n    const { bpDependencies } = pkgJson\n    if (!bpDependencies) {\n      this.logger.log('No bp dependencies found in package.json')\n      return\n    }\n\n    const bpDependenciesSchema = sdk.z.record(sdk.z.string())\n    const parseResults = bpDependenciesSchema.safeParse(bpDependencies)\n    if (!parseResults.success) {\n      throw new errors.BotpressCLIError('Invalid bpDependencies found in package.json')\n    }\n\n    for (const [pkgAlias, pkgRefStr] of Object.entries(parseResults.data)) {\n      const parsed = pkgRef.parsePackageRef(pkgRefStr)\n      if (!parsed) {\n        throw new errors.InvalidPackageReferenceError(pkgRefStr)\n      }\n\n      await this._addSinglePackage({ ...parsed, alias: pkgAlias })\n    }\n  }\n\n  private _parseArgvRef = (): pkgRef.PackageRef | undefined => {\n    if (!this.argv.packageRef) {\n      return\n    }\n\n    const parsed = pkgRef.parsePackageRef(this.argv.packageRef)\n    if (!parsed) {\n      throw new errors.InvalidPackageReferenceError(this.argv.packageRef)\n    }\n\n    if (parsed.type !== 'name') {\n      return parsed\n    }\n\n    const argvPkgType = this.argv.packageType\n    if (!argvPkgType) {\n      return parsed\n    }\n\n    const ref = { ...parsed, pkg: argvPkgType }\n\n    const strRef = pkgRef.formatPackageRef(ref)\n    this.logger.warn(`argument --packageType is deprecated; please use the package reference format \"${strRef}\"`)\n\n    return ref\n  }\n\n  private async _addSinglePackage(ref: pkgRef.PackageRef & { alias?: string }): Promise<void> {\n    const targetPackage = ref.type === 'path' ? await this._findLocalPackage(ref) : await this._findRemotePackage(ref)\n\n    if (!targetPackage) {\n      const strRef = pkgRef.formatPackageRef(ref)\n      throw new errors.BotpressCLIError(`Could not find package \"${strRef}\"`)\n    }\n\n    const packageName = ref.alias ?? targetPackage.pkg.name\n    const baseInstallPath = utils.path.absoluteFrom(utils.path.cwd(), this.argv.installPath)\n    const packageDirName = utils.casing.to.kebabCase(packageName)\n    const installPath = utils.path.join(baseInstallPath, consts.installDirName, packageDirName)\n\n    const alreadyInstalled = fslib.existsSync(installPath)\n    if (alreadyInstalled) {\n      this.logger.warn(`Package with name \"${packageName}\" already installed.`)\n      const res = await this.prompt.confirm('Do you want to overwrite the existing package?')\n      if (!res) {\n        this.logger.log('Aborted')\n        return\n      }\n\n      await this._uninstall(installPath)\n    }\n\n    let files: codegen.File[]\n    if (targetPackage.type === 'integration') {\n      files = await codegen.generateIntegrationPackage(targetPackage.pkg)\n    } else if (targetPackage.type === 'interface') {\n      files = await codegen.generateInterfacePackage(targetPackage.pkg)\n    } else if (targetPackage.type === 'plugin') {\n      files = await codegen.generatePluginPackage(targetPackage.pkg)\n    } else {\n      type _assertion = utils.types.AssertNever<typeof targetPackage>\n      throw new errors.BotpressCLIError('Invalid package type')\n    }\n\n    await this._install(installPath, files)\n  }\n\n  private async _findRemotePackage(ref: pkgRef.ApiPackageRef): Promise<InstallablePackage | undefined> {\n    const api = await this.ensureLoginAndCreateClient(this.argv)\n    if (this._pkgCouldBe(ref, 'integration')) {\n      const integration = await api.findIntegration(ref)\n      if (integration) {\n        const { name, version } = integration\n        return { type: 'integration', pkg: { source: 'remote', integration, name, version } }\n      }\n    }\n    if (this._pkgCouldBe(ref, 'interface')) {\n      const intrface = await api.findPublicInterface(ref)\n      if (intrface) {\n        const { name, version } = intrface\n        return { type: 'interface', pkg: { source: 'remote', interface: intrface, name, version } }\n      }\n    }\n    if (this._pkgCouldBe(ref, 'plugin')) {\n      const plugin = await api.findPublicPlugin(ref)\n      if (plugin) {\n        const { name, version } = plugin\n        return { type: 'plugin', pkg: { source: 'remote', plugin, name, version } }\n      }\n    }\n    return\n  }\n\n  private async _findLocalPackage(ref: pkgRef.LocalPackageRef): Promise<InstallablePackage | undefined> {\n    const absPath = utils.path.absoluteFrom(utils.path.cwd(), ref.path)\n    const {\n      definition: projectDefinition,\n      implementation: projectImplementation,\n      devId: projectDevId,\n    } = await this._readProject(absPath)\n\n    if (projectDefinition?.type === 'integration') {\n      const { name, version } = projectDefinition.definition\n      let devId: string | undefined\n      if (this.argv.useDev && projectDevId) {\n        this.logger.warn(`Installing integration \"${name}\" with dev version \"${projectDevId}\"`)\n        devId = projectDevId\n      }\n      return {\n        type: 'integration',\n        pkg: { source: 'local', path: absPath, devId, name, version },\n      }\n    }\n\n    if (projectDefinition?.type === 'interface') {\n      const { name, version } = projectDefinition.definition\n      return {\n        type: 'interface',\n        pkg: { source: 'local', path: absPath, name, version },\n      }\n    }\n\n    if (projectDefinition?.type === 'plugin') {\n      if (!projectImplementation) {\n        throw new errors.BotpressCLIError(\n          'Plugin implementation not found; Please build the plugin project before installing'\n        )\n      }\n\n      const { name, version } = projectDefinition.definition\n      return {\n        type: 'plugin',\n        pkg: {\n          source: 'local',\n          path: absPath,\n          implementationCode: projectImplementation,\n          name,\n          version,\n        },\n      }\n    }\n\n    if (projectDefinition?.type === 'bot') {\n      throw new errors.BotpressCLIError('Cannot install a bot as a package')\n    }\n    return\n  }\n\n  private async _install(installPath: utils.path.AbsolutePath, files: codegen.File[]): Promise<void> {\n    const line = this.logger.line()\n    line.started(`Installing ${files.length} files to \"${installPath}\"`)\n    try {\n      for (const file of files) {\n        const filePath = utils.path.absoluteFrom(installPath, file.path)\n        const dirPath = pathlib.dirname(filePath)\n        await fslib.promises.mkdir(dirPath, { recursive: true })\n        await fslib.promises.writeFile(filePath, file.content)\n      }\n      line.success(`Installed ${files.length} files to \"${installPath}\"`)\n    } finally {\n      line.commit()\n    }\n  }\n\n  private async _uninstall(installPath: utils.path.AbsolutePath): Promise<void> {\n    await fslib.promises.rm(installPath, { recursive: true })\n  }\n\n  private async _readProject(workDir: utils.path.AbsolutePath): Promise<{\n    definition?: ProjectDefinition\n    implementation?: string\n    devId?: string\n  }> {\n    // this is a hack to avoid refactoring the project command class\n    class AnyProjectCommand extends ProjectCommand<ProjectCommandDefinition> {\n      public async run(): Promise<void> {\n        throw new errors.BotpressCLIError('Not implemented')\n      }\n\n      public async readProjectDefinitionFromFS(): Promise<ProjectDefinition> {\n        return super.readProjectDefinitionFromFS()\n      }\n\n      public get projectCache(): utils.cache.FSKeyValueCache<ProjectCache> {\n        return super.projectCache\n      }\n    }\n\n    const cmd = new AnyProjectCommand(ApiClient, this.prompt, this.logger, {\n      ...this.argv,\n      workDir,\n    })\n\n    const definition = await cmd.readProjectDefinitionFromFS().catch((thrown) => {\n      if (thrown instanceof errors.ProjectDefinitionNotFoundError) {\n        return undefined\n      }\n      throw thrown\n    })\n\n    const devId = await cmd.projectCache.get('devId')\n\n    const implementationAbsPath = utils.path.join(workDir, consts.fromWorkDir.outFile)\n    if (!fslib.existsSync(implementationAbsPath)) {\n      return { definition, devId }\n    }\n\n    const implementation = await fslib.promises.readFile(implementationAbsPath, 'utf8')\n    return { definition, implementation, devId }\n  }\n\n  private _pkgCouldBe = (ref: pkgRef.ApiPackageRef, pkgType: InstallablePackage['type']) => {\n    if (ref.type === 'id') {\n      // TODO: use ULID prefixes to determine the type of the package\n      return true\n    }\n    if (!ref.pkg) {\n      return true // ref does not specify the package type\n    }\n    return ref.pkg === pkgType\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,69 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_command_exports = {};
+__export(base_command_exports, {
+  BaseCommand: () => BaseCommand
+});
+module.exports = __toCommonJS(base_command_exports);
+var errors = __toESM(require("../errors"));
+class BaseCommand {
+  constructor(logger, argv) {
+    this.logger = logger;
+    this.argv = argv;
+  }
+  async handler() {
+    let exitCode = 0;
+    try {
+      if (this.bootstrap) {
+        await this.bootstrap();
+      }
+      await this.run();
+    } catch (thrown) {
+      const error = errors.BotpressCLIError.map(thrown);
+      if (error.debug) {
+        const msg = error.message + " (Run with verbose flag (-v) to see more details)";
+        this.logger.error(msg);
+        this.logger.debug(error.debug);
+      } else {
+        this.logger.error(error.message);
+      }
+      exitCode = 1;
+    } finally {
+      if (this.teardown) {
+        await this.teardown();
+      }
+    }
+    return { exitCode };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseCommand
+});
+//# sourceMappingURL=base-command.js.map

package/dist/command-implementations/base-command.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/command-implementations/base-command.ts"],
+  "sourcesContent": ["import * as errors from '../errors'\nimport type { Logger } from '../logger'\nimport type { CommandArgv, CommandDefinition } from '../typings'\n\nexport abstract class BaseCommand<C extends CommandDefinition> {\n  public constructor(protected readonly logger: Logger, protected readonly argv: CommandArgv<C>) {}\n\n  protected abstract run(): Promise<void>\n  protected bootstrap?(): Promise<void>\n  protected teardown?(): Promise<void>\n\n  public async handler(): Promise<{ exitCode: number }> {\n    let exitCode = 0\n    try {\n      if (this.bootstrap) {\n        await this.bootstrap()\n      }\n      await this.run()\n    } catch (thrown) {\n      const error = errors.BotpressCLIError.map(thrown)\n\n      if (error.debug) {\n        const msg = error.message + ' (Run with verbose flag (-v) to see more details)'\n        this.logger.error(msg)\n        this.logger.debug(error.debug)\n      } else {\n        this.logger.error(error.message)\n      }\n\n      exitCode = 1\n    } finally {\n      if (this.teardown) {\n        await this.teardown()\n      }\n    }\n\n    return { exitCode }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,aAAwB;AAIjB,MAAe,YAAyC;AAAA,EACtD,YAA+B,QAAmC,MAAsB;AAAzD;AAAmC;AAAA,EAAuB;AAAA,EAMhG,MAAa,UAAyC;AACpD,QAAI,WAAW;AACf,QAAI;AACF,UAAI,KAAK,WAAW;AAClB,cAAM,KAAK,UAAU;AAAA,MACvB;AACA,YAAM,KAAK,IAAI;AAAA,IACjB,SAAS,QAAP;AACA,YAAM,QAAQ,OAAO,iBAAiB,IAAI,MAAM;AAEhD,UAAI,MAAM,OAAO;AACf,cAAM,MAAM,MAAM,UAAU;AAC5B,aAAK,OAAO,MAAM,GAAG;AACrB,aAAK,OAAO,MAAM,MAAM,KAAK;AAAA,MAC/B,OAAO;AACL,aAAK,OAAO,MAAM,MAAM,OAAO;AAAA,MACjC;AAEA,iBAAW;AAAA,IACb,UAAE;AACA,UAAI,KAAK,UAAU;AACjB,cAAM,KAAK,SAAS;AAAA,MACtB;AAAA,IACF;AAEA,WAAO,EAAE,SAAS;AAAA,EACpB;AACF;",
+  "names": []
+}

package/dist/command-implementations/bot-commands.js

@@ -0,0 +1,117 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bot_commands_exports = {};
+__export(bot_commands_exports, {
+  CreateBotCommand: () => CreateBotCommand,
+  DeleteBotCommand: () => DeleteBotCommand,
+  GetBotCommand: () => GetBotCommand,
+  ListBotsCommand: () => ListBotsCommand
+});
+module.exports = __toCommonJS(bot_commands_exports);
+var import_chalk = __toESM(require("chalk"));
+var errors = __toESM(require("../errors"));
+var import_global_command = require("./global-command");
+class GetBotCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const { client } = await this.ensureLoginAndCreateClient(this.argv);
+    try {
+      const { bot } = await client.getBot({ id: this.argv.botRef });
+      this.logger.success(`Bot ${import_chalk.default.bold(this.argv.botRef)}:`);
+      this.logger.json(bot);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not get bot ${this.argv.botRef}`);
+    }
+  }
+}
+class ListBotsCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    try {
+      const { dev } = this.argv;
+      const bots = await api.listAllPages(
+        (x) => api.client.listBots({ ...x, dev }),
+        (r) => r.bots
+      );
+      this.logger.success("Bots:");
+      this.logger.json(bots);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not list bots");
+    }
+  }
+}
+class DeleteBotCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const { client } = await this.ensureLoginAndCreateClient(this.argv);
+    try {
+      await client.deleteBot({ id: this.argv.botRef });
+      this.logger.success(`Bot ${import_chalk.default.bold(this.argv.botRef)} deleted`);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, `Could not delete bot ${this.argv.botRef}`);
+    }
+  }
+}
+class CreateBotCommand extends import_global_command.GlobalCommand {
+  async run() {
+    const api = await this.ensureLoginAndCreateClient(this.argv);
+    try {
+      if (this.argv.ifNotExists) {
+        await this._getOrCreate(api, this.argv.name);
+        return;
+      }
+      await this._create(api, this.argv.name);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not create bot");
+    }
+  }
+  _getOrCreate = async (api, name) => {
+    if (!name) {
+      throw new errors.BotpressCLIError("option --if-not-exists requires that a name be provided");
+    }
+    const existingBot = await api.findBotByName(name);
+    if (existingBot) {
+      this.logger.success(`Bot ${import_chalk.default.bold(name)} already exists`);
+      this.logger.json(existingBot);
+      return;
+    }
+    return this._create(api, name);
+  };
+  _create = async (api, name) => {
+    const { bot } = await api.client.createBot({ name });
+    this.logger.success(`Bot ${import_chalk.default.bold(bot.id)}:`);
+    this.logger.json(bot);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateBotCommand,
+  DeleteBotCommand,
+  GetBotCommand,
+  ListBotsCommand
+});
+//# sourceMappingURL=bot-commands.js.map

package/dist/command-implementations/bot-commands.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/command-implementations/bot-commands.ts"],
+  "sourcesContent": ["import chalk from 'chalk'\nimport { ApiClient } from 'src/api/client'\nimport type commandDefinitions from '../command-definitions'\nimport * as errors from '../errors'\nimport { GlobalCommand } from './global-command'\n\nexport type GetBotCommandDefinition = typeof commandDefinitions.bots.subcommands.get\nexport class GetBotCommand extends GlobalCommand<GetBotCommandDefinition> {\n  public async run(): Promise<void> {\n    const { client } = await this.ensureLoginAndCreateClient(this.argv)\n\n    try {\n      const { bot } = await client.getBot({ id: this.argv.botRef })\n      this.logger.success(`Bot ${chalk.bold(this.argv.botRef)}:`)\n      this.logger.json(bot)\n    } catch (thrown) {\n      throw errors.BotpressCLIError.wrap(thrown, `Could not get bot ${this.argv.botRef}`)\n    }\n  }\n}\n\nexport type ListBotsCommandDefinition = typeof commandDefinitions.bots.subcommands.list\nexport class ListBotsCommand extends GlobalCommand<ListBotsCommandDefinition> {\n  public async run(): Promise<void> {\n    const api = await this.ensureLoginAndCreateClient(this.argv)\n\n    try {\n      const { dev } = this.argv\n      const bots = await api.listAllPages(\n        (x) => api.client.listBots({ ...x, dev }),\n        (r) => r.bots\n      )\n      this.logger.success('Bots:')\n      this.logger.json(bots)\n    } catch (thrown) {\n      throw errors.BotpressCLIError.wrap(thrown, 'Could not list bots')\n    }\n  }\n}\n\nexport type DeleteBotCommandDefinition = typeof commandDefinitions.bots.subcommands.delete\nexport class DeleteBotCommand extends GlobalCommand<DeleteBotCommandDefinition> {\n  public async run(): Promise<void> {\n    const { client } = await this.ensureLoginAndCreateClient(this.argv)\n\n    try {\n      await client.deleteBot({ id: this.argv.botRef })\n      this.logger.success(`Bot ${chalk.bold(this.argv.botRef)} deleted`)\n    } catch (thrown) {\n      throw errors.BotpressCLIError.wrap(thrown, `Could not delete bot ${this.argv.botRef}`)\n    }\n  }\n}\n\nexport type CreateBotCommandDefinition = typeof commandDefinitions.bots.subcommands.create\nexport class CreateBotCommand extends GlobalCommand<CreateBotCommandDefinition> {\n  public async run(): Promise<void> {\n    const api = await this.ensureLoginAndCreateClient(this.argv)\n\n    try {\n      if (this.argv.ifNotExists) {\n        await this._getOrCreate(api, this.argv.name)\n        return\n      }\n      await this._create(api, this.argv.name)\n    } catch (thrown) {\n      throw errors.BotpressCLIError.wrap(thrown, 'Could not create bot')\n    }\n  }\n\n  private _getOrCreate = async (api: ApiClient, name: string | undefined) => {\n    if (!name) {\n      throw new errors.BotpressCLIError('option --if-not-exists requires that a name be provided')\n    }\n    const existingBot = await api.findBotByName(name)\n    if (existingBot) {\n      this.logger.success(`Bot ${chalk.bold(name)} already exists`)\n      this.logger.json(existingBot)\n      return\n    }\n    return this._create(api, name)\n  }\n\n  private _create = async (api: ApiClient, name: string | undefined) => {\n    const { bot } = await api.client.createBot({ name })\n    this.logger.success(`Bot ${chalk.bold(bot.id)}:`)\n    this.logger.json(bot)\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkB;AAGlB,aAAwB;AACxB,4BAA8B;AAGvB,MAAM,sBAAsB,oCAAuC;AAAA,EACxE,MAAa,MAAqB;AAChC,UAAM,EAAE,OAAO,IAAI,MAAM,KAAK,2BAA2B,KAAK,IAAI;AAElE,QAAI;AACF,YAAM,EAAE,IAAI,IAAI,MAAM,OAAO,OAAO,EAAE,IAAI,KAAK,KAAK,OAAO,CAAC;AAC5D,WAAK,OAAO,QAAQ,OAAO,aAAAA,QAAM,KAAK,KAAK,KAAK,MAAM,IAAI;AAC1D,WAAK,OAAO,KAAK,GAAG;AAAA,IACtB,SAAS,QAAP;AACA,YAAM,OAAO,iBAAiB,KAAK,QAAQ,qBAAqB,KAAK,KAAK,QAAQ;AAAA,IACpF;AAAA,EACF;AACF;AAGO,MAAM,wBAAwB,oCAAyC;AAAA,EAC5E,MAAa,MAAqB;AAChC,UAAM,MAAM,MAAM,KAAK,2BAA2B,KAAK,IAAI;AAE3D,QAAI;AACF,YAAM,EAAE,IAAI,IAAI,KAAK;AACrB,YAAM,OAAO,MAAM,IAAI;AAAA,QACrB,CAAC,MAAM,IAAI,OAAO,SAAS,EAAE,GAAG,GAAG,IAAI,CAAC;AAAA,QACxC,CAAC,MAAM,EAAE;AAAA,MACX;AACA,WAAK,OAAO,QAAQ,OAAO;AAC3B,WAAK,OAAO,KAAK,IAAI;AAAA,IACvB,SAAS,QAAP;AACA,YAAM,OAAO,iBAAiB,KAAK,QAAQ,qBAAqB;AAAA,IAClE;AAAA,EACF;AACF;AAGO,MAAM,yBAAyB,oCAA0C;AAAA,EAC9E,MAAa,MAAqB;AAChC,UAAM,EAAE,OAAO,IAAI,MAAM,KAAK,2BAA2B,KAAK,IAAI;AAElE,QAAI;AACF,YAAM,OAAO,UAAU,EAAE,IAAI,KAAK,KAAK,OAAO,CAAC;AAC/C,WAAK,OAAO,QAAQ,OAAO,aAAAA,QAAM,KAAK,KAAK,KAAK,MAAM,WAAW;AAAA,IACnE,SAAS,QAAP;AACA,YAAM,OAAO,iBAAiB,KAAK,QAAQ,wBAAwB,KAAK,KAAK,QAAQ;AAAA,IACvF;AAAA,EACF;AACF;AAGO,MAAM,yBAAyB,oCAA0C;AAAA,EAC9E,MAAa,MAAqB;AAChC,UAAM,MAAM,MAAM,KAAK,2BAA2B,KAAK,IAAI;AAE3D,QAAI;AACF,UAAI,KAAK,KAAK,aAAa;AACzB,cAAM,KAAK,aAAa,KAAK,KAAK,KAAK,IAAI;AAC3C;AAAA,MACF;AACA,YAAM,KAAK,QAAQ,KAAK,KAAK,KAAK,IAAI;AAAA,IACxC,SAAS,QAAP;AACA,YAAM,OAAO,iBAAiB,KAAK,QAAQ,sBAAsB;AAAA,IACnE;AAAA,EACF;AAAA,EAEQ,eAAe,OAAO,KAAgB,SAA6B;AACzE,QAAI,CAAC,MAAM;AACT,YAAM,IAAI,OAAO,iBAAiB,yDAAyD;AAAA,IAC7F;AACA,UAAM,cAAc,MAAM,IAAI,cAAc,IAAI;AAChD,QAAI,aAAa;AACf,WAAK,OAAO,QAAQ,OAAO,aAAAA,QAAM,KAAK,IAAI,kBAAkB;AAC5D,WAAK,OAAO,KAAK,WAAW;AAC5B;AAAA,IACF;AACA,WAAO,KAAK,QAAQ,KAAK,IAAI;AAAA,EAC/B;AAAA,EAEQ,UAAU,OAAO,KAAgB,SAA6B;AACpE,UAAM,EAAE,IAAI,IAAI,MAAM,IAAI,OAAO,UAAU,EAAE,KAAK,CAAC;AACnD,SAAK,OAAO,QAAQ,OAAO,aAAAA,QAAM,KAAK,IAAI,EAAE,IAAI;AAChD,SAAK,OAAO,KAAK,GAAG;AAAA,EACtB;AACF;",
+  "names": ["chalk"]
+}