@botpress/cli 0.0.4 → 0.0.7

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/keyboard.js

@@ -0,0 +1,48 @@
+"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 keyboard_exports = {};
+__export(keyboard_exports, {
+  listenForKeypress: () => listenForKeypress
+});
+module.exports = __toCommonJS(keyboard_exports);
+var import_readline = __toESM(require("readline"));
+const listenForKeypress = (handler) => {
+  import_readline.default.emitKeypressEvents(process.stdin);
+  const wrapper = (_str, key) => {
+    handler(key);
+  };
+  process.stdin.on("keypress", wrapper);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  return () => {
+    process.stdin.off("keypress", wrapper);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  listenForKeypress
+});

package/dist/worker/messaging.js

@@ -0,0 +1,39 @@
+"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 messaging_exports = {};
+__export(messaging_exports, {
+  exitCodes: () => exitCodes,
+  messages: () => messages
+});
+module.exports = __toCommonJS(messaging_exports);
+const exitCodes = {
+  success: 0,
+  restart: 69,
+  keyboard: 42,
+  terminate: 66
+};
+const messages = {
+  restart: "__restart__",
+  terminate: "__terminate__"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exitCodes,
+  messages
+});

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.4",
+  "version": "0.0.7",
   "description": "Botpress CLI",
   "scripts": {
     "build": "pnpm run type-check && pnpm run bundle",
@@ -24,10 +24,12 @@
     "@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 +42,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/readme.md

@@ -19,6 +19,5 @@ pnpm add @botpress/cli # for pnpm
 ```bash
 bp login --workspaceId $YOUR_WORKSPACE_ID --token $YOUR_TOKEN
 bp bots ls # list all bots
-
 bp --help # list all commands
 ```