@botpress/cli 0.0.5 → 0.0.8

package/dist/app/errors.js

@@ -39,13 +39,17 @@ var import_client = require("@botpress/client");
 var import_axios = __toESM(require("axios"));
 var import_verror = require("verror");
 var consts = __toESM(require("../consts"));
+const isKnownApiError = (e) => (0, import_client.isApiError)(e) && !(e instanceof import_client.UnknownError);
 class BotpressCLIError extends import_verror.VError {
   static wrap(thrown, message) {
     const err = BotpressCLIError.map(thrown);
     return new BotpressCLIError(err, message ?? "");
   }
   static map(thrown) {
-    if ((0, import_client.isApiError)(thrown)) {
+    if (thrown instanceof import_client.UnknownError) {
+      return new HTTPError(500, "An unknown error has occurred.");
+    }
+    if (isKnownApiError(thrown)) {
       return HTTPError.fromApi(thrown);
     }
     if (import_axios.default.isAxiosError(thrown)) {

package/dist/app/index.js

@@ -33,21 +33,23 @@ var import_chalk = __toESM(require("chalk"));
 var import_fs = __toESM(require("fs"));
 var consts = __toESM(require("../consts"));
 var import_logger = require("../logger");
+var import_update_notif = require("../update-notif");
 var import_cache = require("./cache");
 var import_file_paths = require("./file-paths");
 var import_project = require("./project");
 var import_user = require("./user");
 var errors = __toESM(require("./errors"));
-const logBootInfo = (logger, props) => {
+const logBootInfo = async (logger, props) => {
   const versionText = import_chalk.default.bold(`v${props.version}`);
   logger.log(`Botpress CLI ${versionText}`, { prefix: "\u{1F916}" });
+  await (0, import_update_notif.notifyUpdate)(props, logger);
   if (props.botpressHome !== consts.defaultBotpressHome) {
     logger.log(`Using custom botpress home: ${props.botpressHome}`, { prefix: "\u{1F3E0}" });
   }
 };
 const forProject = async (props) => {
   const logger = new import_logger.Logger(props);
-  logBootInfo(logger, props);
+  await logBootInfo(logger, props);
   const projectPaths = new import_file_paths.ProjectPaths(props);
   const projectCachePath = projectPaths.abs.projectCacheFile;
   const projectCache = await import_cache.FSConfigCache.loadFrom(projectCachePath);
@@ -59,7 +61,7 @@ const forProject = async (props) => {
 };
 const forUser = async (props) => {
   const logger = new import_logger.Logger(props);
-  logBootInfo(logger, props);
+  await logBootInfo(logger, props);
   const userPaths = new import_file_paths.UserPaths(props);
   const userCacheFile = userPaths.abs.userCacheFile;
   const userCache = await import_cache.FSConfigCache.loadFrom(userCacheFile);

package/dist/app/project.js

@@ -37,6 +37,7 @@ 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"));
@@ -162,7 +163,7 @@ class ProjectCommands extends import_base.BaseCommands {
     const importPath = pathutils.toUnix(outfile);
     const requireFrom = pathutils.rmExtension(importPath);
     const code = `require('${requireFrom}').default.start(${argv.port})`;
-    await (0, import_worker.spawnChildProcess)(
+    const worker = await import_worker.Worker.spawn(
       {
         type: "code",
         code,
@@ -172,7 +173,32 @@ class ProjectCommands extends import_base.BaseCommands {
         }
       },
       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");

package/dist/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/index.js

@@ -22,7 +22,8 @@ var import_process = require("process");
 var app = __toESM(require("./app"));
 var config = __toESM(require("./config"));
 var import_logger = require("./logger");
-const { version } = require("../package.json");
+const { name, version } = require("../package.json");
+const pkg = { name, version };
 const errorLogger = new import_logger.Logger();
 const logError = (thrown) => {
   const error = app.errors.BotpressCLIError.map(thrown);
@@ -51,7 +52,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.loginSchema, argv);
-      const commands = await app.forUser({ ...parsed, version });
+      const commands = await app.forUser({ ...parsed, ...pkg });
       await commands.login(parsed);
       commands.teardown();
     } catch (e) {
@@ -65,7 +66,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.logoutSchema, argv);
-      const commands = await app.forUser({ ...parsed, version });
+      const commands = await app.forUser({ ...parsed, ...pkg });
       await commands.logout();
       commands.teardown();
     } catch (e) {
@@ -80,7 +81,7 @@ import_yargs_extra.default.command(
     async (argv) => {
       try {
         const parsed = parseArguments(config.createBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, version });
+        const commands = await app.forUser({ ...parsed, ...pkg });
         await commands.createBot(parsed);
         commands.teardown();
       } catch (e) {
@@ -94,7 +95,7 @@ import_yargs_extra.default.command(
     async (argv) => {
       try {
         const parsed = parseArguments(config.listBotsSchema, argv);
-        const commands = await app.forUser({ ...parsed, version });
+        const commands = await app.forUser({ ...parsed, ...pkg });
         await commands.listBots(parsed);
         commands.teardown();
       } catch (e) {
@@ -108,7 +109,7 @@ import_yargs_extra.default.command(
     async (argv) => {
       try {
         const parsed = parseArguments(config.readBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, version });
+        const commands = await app.forUser({ ...parsed, ...pkg });
         await commands.getBot(argv.botRef, parsed);
         commands.teardown();
       } catch (e) {
@@ -122,7 +123,7 @@ import_yargs_extra.default.command(
     async (argv) => {
       try {
         const parsed = parseArguments(config.deleteBotSchema, argv);
-        const commands = await app.forUser({ ...parsed, version });
+        const commands = await app.forUser({ ...parsed, ...pkg });
         await commands.deleteBot(argv.botRef, parsed);
         commands.teardown();
       } catch (e) {
@@ -138,7 +139,7 @@ import_yargs_extra.default.command(
     async (argv) => {
       try {
         const parsed = parseArguments(config.listIntegrationsSchema, argv);
-        const commands = await app.forUser({ ...parsed, version });
+        const commands = await app.forUser({ ...parsed, ...pkg });
         await commands.listIntegrations(parsed);
         commands.teardown();
       } catch (e) {
@@ -152,7 +153,7 @@ import_yargs_extra.default.command(
     async (argv) => {
       try {
         const parsed = parseArguments(config.readIntegrationSchema, argv);
-        const commands = await app.forUser({ ...parsed, version });
+        const commands = await app.forUser({ ...parsed, ...pkg });
         await commands.getIntegration(argv.integrationRef, parsed);
         commands.teardown();
       } catch (e) {
@@ -166,7 +167,7 @@ import_yargs_extra.default.command(
     async (argv) => {
       try {
         const parsed = parseArguments(config.readIntegrationSchema, argv);
-        const commands = await app.forUser({ ...parsed, version });
+        const commands = await app.forUser({ ...parsed, ...pkg });
         await commands.deleteIntegration(argv.integrationRef, parsed);
         commands.teardown();
       } catch (e) {
@@ -181,7 +182,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.bundleSchema, argv);
-      const commands = await app.forProject({ ...parsed, version });
+      const commands = await app.forProject({ ...parsed, ...pkg });
       await commands.bundleProject(parsed);
       commands.teardown();
     } catch (e) {
@@ -195,7 +196,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.generateSchema, argv);
-      const commands = await app.forProject({ ...parsed, version });
+      const commands = await app.forProject({ ...parsed, ...pkg });
       await commands.generateTypings(parsed);
       commands.teardown();
     } catch (e) {
@@ -209,7 +210,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.buildSchema, argv);
-      const commands = await app.forProject({ ...parsed, version });
+      const commands = await app.forProject({ ...parsed, ...pkg });
       await commands.buildProject(parsed);
       commands.teardown();
     } catch (e) {
@@ -223,7 +224,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.serveSchema, argv);
-      const commands = await app.forProject({ ...parsed, version });
+      const commands = await app.forProject({ ...parsed, ...pkg });
       await commands.serveProject(parsed);
       commands.teardown();
     } catch (e) {
@@ -237,7 +238,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.deploySchema, argv);
-      const commands = await app.forProject({ ...parsed, version });
+      const commands = await app.forProject({ ...parsed, ...pkg });
       await commands.deployProject(parsed);
       commands.teardown();
     } catch (e) {
@@ -251,7 +252,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.devSchema, argv);
-      const commands = await app.forProject({ ...parsed, version });
+      const commands = await app.forProject({ ...parsed, ...pkg });
       await commands.devProject(parsed);
       commands.teardown();
     } catch (e) {
@@ -265,7 +266,7 @@ import_yargs_extra.default.command(
   async (argv) => {
     try {
       const parsed = parseArguments(config.addSchema, argv);
-      const commands = await app.forProject({ ...parsed, version });
+      const commands = await app.forProject({ ...parsed, ...pkg });
       await commands.installIntegration(argv.integrationRef, parsed);
       commands.teardown();
     } catch (e) {

package/dist/logger/base-logger.js

@@ -27,6 +27,7 @@ __export(base_logger_exports, {
   BaseLogger: () => BaseLogger
 });
 module.exports = __toCommonJS(base_logger_exports);
+var import_boxen = __toESM(require("boxen"));
 var import_chalk = __toESM(require("chalk"));
 var import_lodash = __toESM(require("lodash"));
 var import_util = __toESM(require("util"));
@@ -76,6 +77,12 @@ const renderers = {
   "\u25CF": disc,
   " ": space
 };
+const BOX_OPTIONS = {
+  padding: 1,
+  margin: 1,
+  borderStyle: "round",
+  borderColor: "yellow"
+};
 class BaseLogger {
   opts;
   constructor(opts = {}) {
@@ -127,6 +134,13 @@ class BaseLogger {
     }
     this.log(message, { metadata, prefix: { symbol: "\xD7", fg: "red" } });
   }
+  box(message) {
+    if (this.opts.json) {
+      return;
+    }
+    const box = (0, import_boxen.default)(message, BOX_OPTIONS);
+    this.print(box);
+  }
   _resolvePrefix(prefix) {
     if (!prefix) {
       return;

package/dist/update-notif.js

@@ -0,0 +1,47 @@
+"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 update_notif_exports = {};
+__export(update_notif_exports, {
+  notifyUpdate: () => notifyUpdate
+});
+module.exports = __toCommonJS(update_notif_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_latest_version = __toESM(require("latest-version"));
+const updateMsg = (props) => `${import_chalk.default.bold("Update available")} ${import_chalk.default.dim(props.version)} \u2192 ${import_chalk.default.green(props.latest)}
+
+To update, run:
+  for npm  ${import_chalk.default.cyan(`npm i -g ${props.name}`)}
+  for yarn ${import_chalk.default.cyan(`yarn global add ${props.name}`)}
+  for pnpm ${import_chalk.default.cyan(`pnpm i -g ${props.name}`)}`;
+const notifyUpdate = async (props, logger) => {
+  const latest = await (0, import_latest_version.default)(props.name);
+  if (latest !== props.version) {
+    logger.box(updateMsg({ ...props, latest }));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  notifyUpdate
+});

package/dist/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 watcher_exports = {};
+__export(watcher_exports, {
+  FileWatcher: () => FileWatcher
+});
+module.exports = __toCommonJS(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/worker/child-entrypoint.js

@@ -27,31 +27,21 @@ __export(child_entrypoint_exports, {
   ENTRY_POINT: () => ENTRY_POINT
 });
 module.exports = __toCommonJS(child_entrypoint_exports);
-var import_readline = __toESM(require("readline"));
 var requireutils = __toESM(require("../require-utils"));
 var import_config = require("./config");
 var import_is_child = require("./is-child");
 const ENTRY_POINT = __filename;
 const childProcessEntrypoint = async (_props) => {
-  const config = (0, import_config.getConfigFromEnv)();
-  import_readline.default.emitKeypressEvents(process.stdin);
-  process.stdin.on("keypress", (_, key) => {
-    if (key && key.ctrl && key.name === "c") {
-      process.exit(0);
-    }
-    if (key && key.name === "escape") {
-      process.exit(0);
-    }
-  });
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
+  const rawConfig = process.env[import_config.CONFIG_ENV_KEY];
+  if (!rawConfig) {
+    throw new Error(`Config variable ${import_config.CONFIG_ENV_KEY} was not set`);
   }
-  process.stdin.resume();
+  const config = import_config.configSchema.parse(JSON.parse(rawConfig));
   if (config.type === "code") {
-    await requireutils.requireJsCode(config.code);
+    requireutils.requireJsCode(config.code);
   }
   if (config.type === "file") {
-    await requireutils.requireJsFile(config.file);
+    requireutils.requireJsFile(config.file);
   }
 };
 if (import_is_child.processProps.type === "child") {

package/dist/worker/child-wrapper.js

@@ -0,0 +1,109 @@
+"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 child_wrapper_exports = {};
+__export(child_wrapper_exports, {
+  ChildProcessWrapper: () => ChildProcessWrapper
+});
+module.exports = __toCommonJS(child_wrapper_exports);
+var childProcess = __toESM(require("child_process"));
+var import_child_entrypoint = require("./child-entrypoint");
+var import_config = require("./config");
+var import_is_child = require("./is-child");
+const listenForChildSpawn = (child, logger) => new Promise((resolve, reject) => {
+  child.on("spawn", () => {
+    logger.debug(`Child process spawned with pid ${child.pid}`);
+    resolve();
+  });
+  child.on("error", (err) => {
+    logger.debug(`Child process error: ${err.message}`);
+    reject(err);
+  });
+});
+const listenForChildExit = (child, logger) => new Promise((resolve, reject) => {
+  child.on("disconnect", () => {
+    logger.debug("Child process disconnected");
+  });
+  child.on("close", (exitCode, signal) => {
+    logger.debug(`Child process closed with code ${exitCode} and signal ${signal}`);
+  });
+  child.on("exit", (exitCode, signal) => {
+    logger.debug(`Child process exited with code ${exitCode} and signal ${signal}`);
+    resolve({ exitCode, signal });
+  });
+  child.on("error", (err) => {
+    logger.debug(`Child process error: ${err.message}`);
+    reject(err);
+  });
+  child.on("message", (message) => {
+    logger.debug(`Child process message: ${message}`);
+  });
+});
+class ChildProcessWrapper {
+  constructor(_child, _exitPromise) {
+    this._child = _child;
+    this._exitPromise = _exitPromise;
+  }
+  static async spawn(config, logger) {
+    if (import_is_child.isChildProcess) {
+      throw new Error("Cannot spawn child process from child process");
+    }
+    const child = childProcess.fork(import_child_entrypoint.ENTRY_POINT, [], {
+      stdio: "inherit",
+      env: {
+        [import_is_child.CHILD_ENV_KEY]: import_is_child.CHILD_ENV_VALUE,
+        [import_config.CONFIG_ENV_KEY]: JSON.stringify(config),
+        ...config.env
+      }
+    });
+    const childSpawnPromise = listenForChildSpawn(child, logger);
+    const childExitPromise = listenForChildExit(child, logger);
+    const instance = new ChildProcessWrapper(child, childExitPromise);
+    childExitPromise.finally(() => {
+      instance._exited = true;
+    });
+    await childSpawnPromise;
+    return instance;
+  }
+  _exited = false;
+  async kill() {
+    if (this._exited) {
+      throw new Error("Child process already exited and cannot be killed");
+    }
+    this._child.kill();
+    const res = await this._exitPromise;
+    return res;
+  }
+  async listen() {
+    if (this._exited) {
+      throw new Error("Child process already exited and cannot be listened on");
+    }
+    const res = await this._exitPromise;
+    return res;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChildProcessWrapper
+});

package/dist/worker/config.js

@@ -25,8 +25,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var config_exports = {};
 __export(config_exports, {
   CONFIG_ENV_KEY: () => CONFIG_ENV_KEY,
-  configSchema: () => configSchema,
-  getConfigFromEnv: () => getConfigFromEnv
+  configSchema: () => configSchema
 });
 module.exports = __toCommonJS(config_exports);
 var import_zod = __toESM(require("zod"));
@@ -43,16 +42,8 @@ const configSchema = import_zod.default.union([
     env: import_zod.default.record(import_zod.default.string(), import_zod.default.string()).optional()
   })
 ]);
-const getConfigFromEnv = () => {
-  const config = process.env[CONFIG_ENV_KEY];
-  if (!config) {
-    throw new Error(`Config variable ${CONFIG_ENV_KEY} was not set`);
-  }
-  return configSchema.parse(JSON.parse(config));
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CONFIG_ENV_KEY,
-  configSchema,
-  getConfigFromEnv
+  configSchema
 });

package/dist/worker/index.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,39 +15,17 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 worker_exports = {};
 __export(worker_exports, {
-  Config: () => import_config2.Config,
-  spawnChildProcess: () => spawnChildProcess
+  Config: () => import_config.Config,
+  Worker: () => import_worker.Worker
 });
 module.exports = __toCommonJS(worker_exports);
-var childProcess = __toESM(require("child_process"));
-var import_child_entrypoint = require("./child-entrypoint");
 var import_config = require("./config");
-var import_is_child = require("./is-child");
-var import_listen_child = require("./listen-child");
-var import_config2 = require("./config");
-const spawnChildProcess = async (config, logger) => {
-  if (import_is_child.isChildProcess) {
-    throw new Error("Cannot spawn child process from child process");
-  }
-  const child = childProcess.fork(import_child_entrypoint.ENTRY_POINT, [], {
-    stdio: "inherit",
-    env: {
-      [import_is_child.CHILD_ENV_KEY]: import_is_child.CHILD_ENV_VALUE,
-      [import_config.CONFIG_ENV_KEY]: JSON.stringify(config),
-      ...config.env
-    }
-  });
-  return (0, import_listen_child.listenChild)(child, logger);
-};
+var import_worker = require("./worker");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,
-  spawnChildProcess
+  Worker
 });

package/dist/worker/is-child.js

@@ -30,7 +30,8 @@ const getProcessProps = () => {
   const type = process.env[CHILD_ENV_KEY] === CHILD_ENV_VALUE ? "child" : "main";
   if (type === "main") {
     return {
-      type
+      type,
+      pid: process.pid
     };
   }
   if (!process.send) {
@@ -38,7 +39,8 @@ const getProcessProps = () => {
   }
   return {
     type,
-    sendMessage: process.send
+    sendMessage: process.send,
+    pid: process.pid
   };
 };
 const processProps = getProcessProps();

package/dist/worker/worker-state.js

@@ -0,0 +1,70 @@
+"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 worker_state_exports = {};
+__export(worker_state_exports, {
+  WorkerStateObserver: () => WorkerStateObserver
+});
+module.exports = __toCommonJS(worker_state_exports);
+class WorkerStateObserver {
+  _state;
+  _handlers = {
+    dead: [],
+    reloading: [],
+    live: [],
+    killing: [],
+    errored: []
+  };
+  constructor(initialState) {
+    this._state = initialState;
+  }
+  waitFor(status) {
+    return new Promise((resolve) => {
+      const cb = () => {
+        this.off(status, cb);
+        resolve();
+      };
+      this.on(status, cb);
+    });
+  }
+  on(status, handler) {
+    this._handlers[status].push(handler);
+    if (this._state.status === status) {
+      handler(this._state);
+    }
+  }
+  off(status, handler) {
+    const index = this._handlers[status].indexOf(handler);
+    this._handlers[status].splice(index, 1);
+  }
+  get() {
+    return this._state;
+  }
+  set(newState) {
+    this._state = newState;
+    const { status } = newState;
+    for (const handler of this._handlers[status]) {
+      const fn = handler;
+      fn(newState);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorkerStateObserver
+});

package/dist/worker/worker.js

@@ -0,0 +1,87 @@
+"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 worker_exports = {};
+__export(worker_exports, {
+  Worker: () => Worker
+});
+module.exports = __toCommonJS(worker_exports);
+var import_child_wrapper = require("./child-wrapper");
+var import_worker_state = require("./worker-state");
+class Worker {
+  constructor(_config, _logger, _props = {}) {
+    this._config = _config;
+    this._logger = _logger;
+    this._props = _props;
+  }
+  static async spawn(config, logger, props) {
+    const instance = new Worker(config, logger, props);
+    await instance.reload();
+    return instance;
+  }
+  _state = new import_worker_state.WorkerStateObserver({ status: "dead", murdered: false });
+  get running() {
+    return this._state.get().status === "live";
+  }
+  kill = () => {
+    const state = this._state.get();
+    if (state.status !== "live") {
+      throw new Error("Cannot kill a child process that is not alive");
+    }
+    this._state.set({ status: "killing" });
+    return state.child.kill();
+  };
+  reload = async () => {
+    if (this._state.get().status === "reloading") {
+      this._logger.debug("Already reloading");
+      return;
+    }
+    const previousState = this._state.get();
+    this._state.set({ status: "reloading" });
+    if (previousState.status === "live") {
+      await previousState.child.kill();
+    }
+    const child = await import_child_wrapper.ChildProcessWrapper.spawn(this._config, this._logger);
+    this._state.set({ status: "live", child });
+    void child.listen().catch((thrown) => {
+      this._state.set({ status: "errored", thrown });
+    }).then(() => {
+      const { status } = this._state.get();
+      if (status === "reloading") {
+        return;
+      }
+      this._state.set({ status: "dead", murdered: status === "killing" });
+    });
+  };
+  wait = () => new Promise((resolve, reject) => {
+    this._state.on("dead", (state) => {
+      if (state.murdered || !this._props.hangOnExit) {
+        resolve();
+        return;
+      }
+      this._logger.debug("Child process died of natural causes...");
+    });
+    this._state.on("errored", (state) => {
+      reject(state.thrown);
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Worker
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/cli",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "description": "Botpress CLI",
   "scripts": {
     "build": "pnpm run type-check && pnpm run bundle",
@@ -19,15 +19,18 @@
   "dependencies": {
     "@botpress/client": "0.0.6",
     "@bpinternal/yargs-extra": "^0.0.2",
+    "@parcel/watcher": "^2.1.0",
     "@types/lodash": "^4.14.191",
     "@types/node": "^18.11.17",
     "@types/verror": "^1.10.6",
     "axios": "^1.2.5",
     "bluebird": "^3.7.2",
+    "boxen": "5.1.2",
     "chalk": "^4.1.2",
     "chokidar": "^3.5.3",
     "esbuild": "^0.15.18",
     "json-schema-to-typescript": "^11.0.2",
+    "latest-version": "5.1.0",
     "lodash": "^4.17.21",
     "prompts": "^2.4.2",
     "radash": "^9.5.0",
@@ -40,7 +43,7 @@
     "zod-to-json-schema": "^3.20.1"
   },
   "devDependencies": {
-    "@botpress/sdk": "0.0.6",
+    "@botpress/sdk": "0.0.7",
     "@types/bluebird": "^3.5.38",
     "@types/prompts": "^2.0.14",
     "@types/semver": "^7.3.11",

package/dist/worker/listen-child.js

@@ -1,89 +0,0 @@
-"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 listen_child_exports = {};
-__export(listen_child_exports, {
-  listenChild: () => listenChild
-});
-module.exports = __toCommonJS(listen_child_exports);
-const listenChild = async (child, logger) => {
-  let isClosed = false;
-  return new Promise((resolve, reject) => {
-    child.on("close", (code) => {
-      if (isClosed) {
-        return;
-      }
-      isClosed = true;
-      const msg = `Child process closed with code ${code}`;
-      if (code) {
-        logger.error(msg);
-        reject(new Error(msg));
-        return;
-      }
-      logger.log(msg);
-      resolve();
-    });
-    child.on("disconnect", () => {
-      if (isClosed) {
-        return;
-      }
-      const msg = "Child process disconnected";
-      logger.debug(msg);
-    });
-    child.on("exit", (code, signal) => {
-      if (isClosed) {
-        return;
-      }
-      isClosed = true;
-      const msg = `Child process exited with code ${code} and signal ${signal}`;
-      if (code || signal) {
-        logger.error(msg);
-        reject(new Error(msg));
-        return;
-      }
-      logger.debug(msg);
-      resolve();
-    });
-    child.on("error", (err) => {
-      if (isClosed) {
-        return;
-      }
-      const msg = `Child process error: ${err.message}`;
-      logger.error(msg);
-      reject(err);
-    });
-    child.on("message", (message) => {
-      if (isClosed) {
-        return;
-      }
-      const msg = `Child process message: ${message}`;
-      logger.log(msg);
-    });
-    child.on("spawn", () => {
-      if (isClosed) {
-        return;
-      }
-      const msg = "Child process spawned";
-      logger.debug(msg);
-    });
-  });
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  listenChild
-});