@botpress/adk-cli 1.2.1 → 1.4.0

package/dist/bp-cli/dist/worker/worker-state.js

@@ -0,0 +1,71 @@
+"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
+});
+//# sourceMappingURL=worker-state.js.map

package/dist/bp-cli/dist/worker/worker-state.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/worker/worker-state.ts"],
+  "sourcesContent": ["import type { ChildProcessWrapper } from './child-wrapper'\n\nexport type WorkerStatus = WorkerState['status']\nexport type WorkerState =\n  | { status: 'errored'; thrown: unknown } // only occurs if the event error is emitted https://nodejs.org/api/child_process.html#event-error\n  | { status: 'dead'; murdered: boolean }\n  | { status: 'killing' }\n  | { status: 'reloading' }\n  | {\n      status: 'live'\n      child: ChildProcessWrapper\n    }\n\nexport type StateOf<S extends WorkerStatus> = Extract<WorkerState, { status: S }>\nexport type WorkerStateHandler<S extends WorkerStatus> = (state: StateOf<S>) => void\n\nexport class WorkerStateObserver {\n  private _state: WorkerState\n  private _handlers: {\n    [K in WorkerStatus]: WorkerStateHandler<K>[]\n  } = {\n    dead: [],\n    reloading: [],\n    live: [],\n    killing: [],\n    errored: [],\n  }\n\n  public constructor(initialState: WorkerState) {\n    this._state = initialState\n  }\n\n  public waitFor<S extends WorkerStatus>(status: S): Promise<void> {\n    return new Promise<void>((resolve) => {\n      const cb = () => {\n        this.off(status, cb)\n        resolve()\n      }\n      this.on(status, cb)\n    })\n  }\n\n  public on<S extends WorkerStatus>(status: S, handler: WorkerStateHandler<S>) {\n    this._handlers[status].push(handler)\n    if (this._state.status === status) {\n      handler(this._state as StateOf<S>)\n    }\n  }\n\n  public off<S extends WorkerStatus>(status: S, handler: WorkerStateHandler<S>) {\n    const index = this._handlers[status].indexOf(handler)\n    this._handlers[status].splice(index, 1)\n  }\n\n  public get() {\n    return this._state\n  }\n\n  public set(newState: WorkerState) {\n    this._state = newState\n    const { status } = newState\n    for (const handler of this._handlers[status]) {\n      const fn = handler as WorkerStateHandler<typeof status>\n      fn(newState)\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,MAAM,oBAAoB;AAAA,EACvB;AAAA,EACA,YAEJ;AAAA,IACF,MAAM,CAAC;AAAA,IACP,WAAW,CAAC;AAAA,IACZ,MAAM,CAAC;AAAA,IACP,SAAS,CAAC;AAAA,IACV,SAAS,CAAC;AAAA,EACZ;AAAA,EAEO,YAAY,cAA2B;AAC5C,SAAK,SAAS;AAAA,EAChB;AAAA,EAEO,QAAgC,QAA0B;AAC/D,WAAO,IAAI,QAAc,CAAC,YAAY;AACpC,YAAM,KAAK,MAAM;AACf,aAAK,IAAI,QAAQ,EAAE;AACnB,gBAAQ;AAAA,MACV;AACA,WAAK,GAAG,QAAQ,EAAE;AAAA,IACpB,CAAC;AAAA,EACH;AAAA,EAEO,GAA2B,QAAW,SAAgC;AAC3E,SAAK,UAAU,MAAM,EAAE,KAAK,OAAO;AACnC,QAAI,KAAK,OAAO,WAAW,QAAQ;AACjC,cAAQ,KAAK,MAAoB;AAAA,IACnC;AAAA,EACF;AAAA,EAEO,IAA4B,QAAW,SAAgC;AAC5E,UAAM,QAAQ,KAAK,UAAU,MAAM,EAAE,QAAQ,OAAO;AACpD,SAAK,UAAU,MAAM,EAAE,OAAO,OAAO,CAAC;AAAA,EACxC;AAAA,EAEO,MAAM;AACX,WAAO,KAAK;AAAA,EACd;AAAA,EAEO,IAAI,UAAuB;AAChC,SAAK,SAAS;AACd,UAAM,EAAE,OAAO,IAAI;AACnB,eAAW,WAAW,KAAK,UAAU,MAAM,GAAG;AAC5C,YAAM,KAAK;AACX,SAAG,QAAQ;AAAA,IACb;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/bp-cli/dist/worker/worker.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '../logger';
+import type { Config } from './config';
+export type WorkerProps = {
+    hangOnExit?: boolean;
+};
+export declare class Worker {
+    private _config;
+    private _logger;
+    private _props;
+    static spawn(config: Config, logger: Logger, props?: Partial<WorkerProps>): Promise<Worker>;
+    private _state;
+    private constructor();
+    /**
+     * Used to determine if the worker can be killed
+     */
+    get running(): boolean;
+    kill: () => Promise<import("./child-wrapper").ChildOutput>;
+    reload: () => Promise<void>;
+    wait: () => Promise<void>;
+}

package/dist/bp-cli/dist/worker/worker.js

@@ -0,0 +1,91 @@
+"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 });
+  /**
+   * Used to determine if the worker can be killed
+   */
+  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
+});
+//# sourceMappingURL=worker.js.map

package/dist/bp-cli/dist/worker/worker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/worker/worker.ts"],
+  "sourcesContent": ["import type { Logger } from '../logger'\nimport { ChildProcessWrapper } from './child-wrapper'\nimport type { Config } from './config'\nimport { WorkerStateObserver } from './worker-state'\n\nexport type WorkerProps = {\n  hangOnExit?: boolean\n}\n\nexport class Worker {\n  public static async spawn(config: Config, logger: Logger, props?: Partial<WorkerProps>): Promise<Worker> {\n    const instance = new Worker(config, logger, props)\n    await instance.reload()\n    return instance\n  }\n\n  private _state = new WorkerStateObserver({ status: 'dead', murdered: false })\n\n  private constructor(\n    private _config: Config,\n    private _logger: Logger,\n    private _props: Partial<WorkerProps> = {}\n  ) {}\n\n  /**\n   * Used to determine if the worker can be killed\n   */\n  public get running() {\n    return this._state.get().status === 'live'\n  }\n\n  public kill = () => {\n    const state = this._state.get()\n    if (state.status !== 'live') {\n      throw new Error('Cannot kill a child process that is not alive')\n    }\n\n    this._state.set({ status: 'killing' })\n    return state.child.kill()\n  }\n\n  public reload = async () => {\n    if (this._state.get().status === 'reloading') {\n      this._logger.debug('Already reloading')\n      return\n    }\n\n    const previousState = this._state.get()\n    this._state.set({ status: 'reloading' })\n\n    if (previousState.status === 'live') {\n      await previousState.child.kill()\n    }\n\n    const child = await ChildProcessWrapper.spawn(this._config, this._logger)\n    this._state.set({ status: 'live', child })\n\n    void child\n      .listen()\n      .catch((thrown) => {\n        this._state.set({ status: 'errored', thrown })\n      })\n      .then(() => {\n        const { status } = this._state.get()\n        if (status === 'reloading') {\n          return\n        }\n        this._state.set({ status: 'dead', murdered: status === 'killing' })\n      })\n  }\n\n  public wait = () =>\n    new Promise<void>((resolve, reject) => {\n      this._state.on('dead', (state) => {\n        if (state.murdered || !this._props.hangOnExit) {\n          resolve()\n          return\n        }\n\n        this._logger.debug('Child process died of natural causes...')\n      })\n\n      this._state.on('errored', (state) => {\n        reject(state.thrown)\n      })\n    })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,2BAAoC;AAEpC,0BAAoC;AAM7B,MAAM,OAAO;AAAA,EASV,YACE,SACA,SACA,SAA+B,CAAC,GACxC;AAHQ;AACA;AACA;AAAA,EACP;AAAA,EAZH,aAAoB,MAAM,QAAgB,QAAgB,OAA+C;AACvG,UAAM,WAAW,IAAI,OAAO,QAAQ,QAAQ,KAAK;AACjD,UAAM,SAAS,OAAO;AACtB,WAAO;AAAA,EACT;AAAA,EAEQ,SAAS,IAAI,wCAAoB,EAAE,QAAQ,QAAQ,UAAU,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA,EAW5E,IAAW,UAAU;AACnB,WAAO,KAAK,OAAO,IAAI,EAAE,WAAW;AAAA,EACtC;AAAA,EAEO,OAAO,MAAM;AAClB,UAAM,QAAQ,KAAK,OAAO,IAAI;AAC9B,QAAI,MAAM,WAAW,QAAQ;AAC3B,YAAM,IAAI,MAAM,+CAA+C;AAAA,IACjE;AAEA,SAAK,OAAO,IAAI,EAAE,QAAQ,UAAU,CAAC;AACrC,WAAO,MAAM,MAAM,KAAK;AAAA,EAC1B;AAAA,EAEO,SAAS,YAAY;AAC1B,QAAI,KAAK,OAAO,IAAI,EAAE,WAAW,aAAa;AAC5C,WAAK,QAAQ,MAAM,mBAAmB;AACtC;AAAA,IACF;AAEA,UAAM,gBAAgB,KAAK,OAAO,IAAI;AACtC,SAAK,OAAO,IAAI,EAAE,QAAQ,YAAY,CAAC;AAEvC,QAAI,cAAc,WAAW,QAAQ;AACnC,YAAM,cAAc,MAAM,KAAK;AAAA,IACjC;AAEA,UAAM,QAAQ,MAAM,yCAAoB,MAAM,KAAK,SAAS,KAAK,OAAO;AACxE,SAAK,OAAO,IAAI,EAAE,QAAQ,QAAQ,MAAM,CAAC;AAEzC,SAAK,MACF,OAAO,EACP,MAAM,CAAC,WAAW;AACjB,WAAK,OAAO,IAAI,EAAE,QAAQ,WAAW,OAAO,CAAC;AAAA,IAC/C,CAAC,EACA,KAAK,MAAM;AACV,YAAM,EAAE,OAAO,IAAI,KAAK,OAAO,IAAI;AACnC,UAAI,WAAW,aAAa;AAC1B;AAAA,MACF;AACA,WAAK,OAAO,IAAI,EAAE,QAAQ,QAAQ,UAAU,WAAW,UAAU,CAAC;AAAA,IACpE,CAAC;AAAA,EACL;AAAA,EAEO,OAAO,MACZ,IAAI,QAAc,CAAC,SAAS,WAAW;AACrC,SAAK,OAAO,GAAG,QAAQ,CAAC,UAAU;AAChC,UAAI,MAAM,YAAY,CAAC,KAAK,OAAO,YAAY;AAC7C,gBAAQ;AACR;AAAA,MACF;AAEA,WAAK,QAAQ,MAAM,yCAAyC;AAAA,IAC9D,CAAC;AAED,SAAK,OAAO,GAAG,WAAW,CAAC,UAAU;AACnC,aAAO,MAAM,MAAM;AAAA,IACrB,CAAC;AAAA,EACH,CAAC;AACL;",
+  "names": []
+}

package/dist/bp-cli/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "bundled-bp-cli",
+  "version": "1.0.0",
+  "private": true,
+  "dependencies": {
+    "@botpress/cli": "^4.18.2"
+  }
+}