@botpress/cli 0.0.9 → 0.0.10

package/dist/utils/cache-utils.js

@@ -0,0 +1,99 @@
+"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 cache_utils_exports = {};
+__export(cache_utils_exports, {
+  FSKeyValueCache: () => FSKeyValueCache
+});
+module.exports = __toCommonJS(cache_utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+class FSKeyValueCache {
+  constructor(_filepath) {
+    this._filepath = _filepath;
+  }
+  _initialized = false;
+  async init() {
+    if (this._initialized) {
+      return;
+    }
+    const dirname = import_path.default.dirname(this._filepath);
+    if (!import_fs.default.existsSync(dirname)) {
+      await import_fs.default.promises.mkdir(dirname, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(this._filepath)) {
+      await this._writeJSON(this._filepath, {});
+    }
+    this._initialized = true;
+  }
+  async sync(key, value, prompt) {
+    await this.init();
+    if (value) {
+      await this.set(key, value);
+      return value;
+    }
+    const data = await this.get(key);
+    const newValue = await prompt(data);
+    await this.set(key, newValue);
+    return newValue;
+  }
+  async has(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    return data[key] !== void 0;
+  }
+  async get(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    return data[key];
+  }
+  async set(key, value) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    data[key] = value;
+    return this._writeJSON(this._filepath, data);
+  }
+  async rm(key) {
+    await this.init();
+    const data = await this._readJSON(this._filepath);
+    delete data[key];
+    return this._writeJSON(this._filepath, data);
+  }
+  async clear() {
+    await this.init();
+    return this._writeJSON(this._filepath, {});
+  }
+  _writeJSON = (filepath, data) => {
+    const fileContent = JSON.stringify(data, null, 2);
+    return import_fs.default.promises.writeFile(filepath, fileContent);
+  };
+  _readJSON = async (filepath) => {
+    const fileContent = await import_fs.default.promises.readFile(filepath, "utf8");
+    return JSON.parse(fileContent);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FSKeyValueCache
+});

package/dist/utils/esbuild-utils.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var esbuild_utils_exports = {};
+__export(esbuild_utils_exports, {
+  buildCode: () => buildCode,
+  buildEntrypoint: () => buildEntrypoint
+});
+module.exports = __toCommonJS(esbuild_utils_exports);
+var import_esbuild = require("esbuild");
+const keepNames = true;
+function buildCode({
+  cwd,
+  minify = true,
+  bundle = true,
+  sourcemap = false,
+  logLevel = "silent",
+  outfile,
+  code,
+  write
+}) {
+  return (0, import_esbuild.build)({
+    stdin: {
+      contents: code,
+      resolveDir: cwd,
+      loader: "ts"
+    },
+    logOverride: {
+      "equals-negative-zero": "silent"
+    },
+    platform: "node",
+    target: "es2020",
+    sourcemap,
+    minify,
+    bundle,
+    outfile,
+    absWorkingDir: cwd,
+    logLevel,
+    keepNames,
+    write
+  });
+}
+function buildEntrypoint({
+  cwd,
+  minify = true,
+  bundle = true,
+  sourcemap = false,
+  logLevel = "silent",
+  outfile,
+  entrypoint,
+  write
+}) {
+  return (0, import_esbuild.build)({
+    entryPoints: [entrypoint],
+    logOverride: {
+      "equals-negative-zero": "silent"
+    },
+    platform: "node",
+    target: "es2020",
+    sourcemap,
+    minify,
+    bundle,
+    outfile,
+    absWorkingDir: cwd,
+    logLevel,
+    keepNames,
+    write
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCode,
+  buildEntrypoint
+});

package/dist/utils/event-emitter.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_emitter_exports = {};
+__export(event_emitter_exports, {
+  EventEmitter: () => EventEmitter
+});
+module.exports = __toCommonJS(event_emitter_exports);
+class EventEmitter {
+  listeners = {};
+  emit(type, event) {
+    const listeners = this.listeners[type];
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+  once(type, listener) {
+    const wrapped = (event) => {
+      this.off(type, wrapped);
+      listener(event);
+    };
+    this.on(type, wrapped);
+  }
+  on(type, listener) {
+    if (!this.listeners[type]) {
+      this.listeners[type] = [];
+    }
+    this.listeners[type].push(listener);
+  }
+  off(type, listener) {
+    const listeners = this.listeners[type];
+    if (!listeners) {
+      return;
+    }
+    const index = listeners.indexOf(listener);
+    if (index !== -1) {
+      listeners.splice(index, 1);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventEmitter
+});

package/dist/utils/file-watcher.js

@@ -0,0 +1,68 @@
+"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 file_watcher_exports = {};
+__export(file_watcher_exports, {
+  FileWatcher: () => FileWatcher
+});
+module.exports = __toCommonJS(file_watcher_exports);
+var import_watcher = __toESM(require("@parcel/watcher"));
+var import_event_emitter = require("./event-emitter");
+class FileWatcher {
+  constructor(subscription, errorEmitter) {
+    this.subscription = subscription;
+    this.errorEmitter = errorEmitter;
+  }
+  static async watch(dir, fn, opt) {
+    const eventEmitter = new import_event_emitter.EventEmitter();
+    const subscription = await import_watcher.default.subscribe(
+      dir,
+      async (err, events) => {
+        if (err) {
+          eventEmitter.emit("error", err);
+          return;
+        }
+        try {
+          await fn(events);
+        } catch (thrown) {
+          eventEmitter.emit("error", thrown);
+        }
+      },
+      opt
+    );
+    return new FileWatcher(subscription, eventEmitter);
+  }
+  async close() {
+    await this.subscription.unsubscribe();
+    this.errorEmitter.emit("close", {});
+  }
+  wait = () => new Promise((resolve, reject) => {
+    this.errorEmitter.once("error", reject);
+    this.errorEmitter.once("close", resolve);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileWatcher
+});

package/dist/utils/index.js

@@ -0,0 +1,55 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  cache: () => cache,
+  emitter: () => emitter,
+  esbuild: () => esbuild,
+  filewatcher: () => filewatcher,
+  path: () => path,
+  prompt: () => prompt,
+  require: () => require2,
+  strings: () => strings
+});
+module.exports = __toCommonJS(utils_exports);
+var esbuild = __toESM(require("./esbuild-utils"));
+var path = __toESM(require("./path-utils"));
+var require2 = __toESM(require("./require-utils"));
+var filewatcher = __toESM(require("./file-watcher"));
+var emitter = __toESM(require("./event-emitter"));
+var cache = __toESM(require("./cache-utils"));
+var strings = __toESM(require("./string-utils"));
+var prompt = __toESM(require("./prompt-utils"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cache,
+  emitter,
+  esbuild,
+  filewatcher,
+  path,
+  prompt,
+  require,
+  strings
+});

package/dist/utils/path-utils.js

@@ -0,0 +1,83 @@
+"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 path_utils_exports = {};
+__export(path_utils_exports, {
+  PathStore: () => PathStore,
+  absoluteFrom: () => absoluteFrom,
+  cwd: () => cwd,
+  isAbsolute: () => isAbsolute,
+  isPath: () => isPath,
+  join: () => join,
+  relativeFrom: () => relativeFrom,
+  rmExtension: () => rmExtension,
+  toUnix: () => toUnix
+});
+module.exports = __toCommonJS(path_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_path = __toESM(require("path"));
+const cwd = () => process.cwd();
+const isAbsolute = (path) => import_path.default.isAbsolute(path);
+const isPath = (path) => isAbsolute(path) || path.startsWith(".");
+const join = (abs, ...paths) => {
+  const joined = import_path.default.join(abs, ...paths);
+  return import_path.default.normalize(joined);
+};
+const rmExtension = (filename) => filename.replace(/\.[^/.]+$/, "");
+const toUnix = (path) => path.split(import_path.default.sep).join(import_path.default.posix.sep);
+const absoluteFrom = (rootdir, target) => {
+  if (isAbsolute(target)) {
+    return target;
+  }
+  return import_path.default.join(rootdir, target);
+};
+const relativeFrom = (rootdir, target) => {
+  let absPath;
+  if (isAbsolute(target)) {
+    absPath = target;
+  } else {
+    absPath = import_path.default.resolve(import_path.default.join(rootdir, target));
+  }
+  return import_path.default.relative(rootdir, absPath);
+};
+class PathStore {
+  constructor(abs) {
+    this.abs = abs;
+  }
+  rel(from) {
+    return import_lodash.default.mapValues(this.abs, (to) => relativeFrom(this.abs[from], to));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PathStore,
+  absoluteFrom,
+  cwd,
+  isAbsolute,
+  isPath,
+  join,
+  relativeFrom,
+  rmExtension,
+  toUnix
+});

package/dist/utils/prompt-utils.js

@@ -0,0 +1,75 @@
+"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 prompt_utils_exports = {};
+__export(prompt_utils_exports, {
+  CLIPrompt: () => CLIPrompt
+});
+module.exports = __toCommonJS(prompt_utils_exports);
+var import_prompts = __toESM(require("prompts"));
+class CLIPrompt {
+  constructor(_props, _logger) {
+    this._props = _props;
+    this._logger = _logger;
+  }
+  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 password(message, opts) {
+    const { prompted } = await (0, import_prompts.default)({
+      type: "password",
+      name: "prompted",
+      message,
+      initial: opts?.initial
+    });
+    return prompted ? prompted : void 0;
+  }
+  async select(message, opts) {
+    const { prompted } = await (0, import_prompts.default)({
+      type: "autocomplete",
+      name: "prompted",
+      message,
+      initial: opts?.initial?.value,
+      choices: opts?.choices
+    });
+    return prompted ? prompted : void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLIPrompt
+});

package/dist/utils/require-utils.js

@@ -0,0 +1,49 @@
+"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 require_utils_exports = {};
+__export(require_utils_exports, {
+  requireJsCode: () => requireJsCode,
+  requireJsFile: () => requireJsFile
+});
+module.exports = __toCommonJS(require_utils_exports);
+var import_module = __toESM(require("module"));
+var import_path = __toESM(require("path"));
+const requireJsFile = (path) => {
+  return require(path);
+};
+const requireJsCode = (code) => {
+  const filedir = "tmp";
+  const filename = `${Date.now()}.js`;
+  const fileid = import_path.default.join(filedir, filename);
+  const m = new import_module.default(fileid);
+  m.filename = filename;
+  m._compile(code, filename);
+  return m.exports;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requireJsCode,
+  requireJsFile
+});

package/dist/utils/string-utils.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var string_utils_exports = {};
+__export(string_utils_exports, {
+  kebabCase: () => kebabCase,
+  pascalCase: () => pascalCase
+});
+module.exports = __toCommonJS(string_utils_exports);
+const capitalizeFirstLetter = (string) => string.charAt(0).toUpperCase() + string.slice(1);
+const pascalCase = (string) => {
+  const words = string.split(/[-_]/);
+  return words.map(capitalizeFirstLetter).join("");
+};
+const kebabCase = (string) => {
+  const words = string.split(/(?<=[a-z])(?=[A-Z])/);
+  return words.map((word) => word.toLowerCase()).join("-");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  kebabCase,
+  pascalCase
+});

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@botpress/cli",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Botpress CLI",
   "scripts": {
-    "build": "pnpm run type-check && pnpm run bundle",
+    "build": "pnpm run type-check && pnpm run bundle && pnpm run template:gen && pnpm run template:type-check",
     "dev": "ts-node -T src/index.ts",
     "start": "node dist/index.js",
     "type-check": "tsc --noEmit",
-    "bundle": "ts-node -T build.ts"
+    "bundle": "ts-node -T build.ts",
+    "template:type-check": "pnpm -r --stream -F './**/templates/*' run type-check",
+    "template:gen": "pnpm -r --stream -F './**/templates/*' exec bp gen"
   },
   "keywords": [],
   "author": "",
@@ -17,7 +19,7 @@
   },
   "main": "dist/index.js",
   "dependencies": {
-    "@botpress/client": "0.0.7",
+    "@botpress/client": "0.0.10",
     "@bpinternal/yargs-extra": "^0.0.2",
     "@parcel/watcher": "^2.1.0",
     "@types/lodash": "^4.14.191",

package/templates/echo-bot/.botpress/project.cache.json

@@ -0,0 +1 @@
+{}

package/templates/echo-bot/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@botpresshub/echo-bot",
+  "version": "0.1.0",
+  "description": "Bot that answers with the received message",
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [],
+  "private": true,
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@botpress/client": "0.0.10",
+    "@botpress/sdk": "0.0.8",
+    "zod": "^3.20.6"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.17",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  }
+}

package/templates/echo-bot/readme.md

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