@botpress/adk-cli 1.2.1 → 1.4.0

package/dist/bp-cli/dist/utils/type-utils.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 type_utils_exports = {};
+module.exports = __toCommonJS(type_utils_exports);
+//# sourceMappingURL=type-utils.js.map

package/dist/bp-cli/dist/utils/type-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/type-utils.ts"],
+  "sourcesContent": ["export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B\nexport type SafeOmit<T, K extends keyof T> = Omit<T, K>\nexport type Writable<T> = { -readonly [K in keyof T]: T[K] }\n\nexport type AssertNever<_T extends never> = true\nexport type AssertExtends<_A extends B, B> = true\nexport type AssertKeyOf<_K extends keyof T, T> = true\nexport type AssertTrue<_T extends true> = true\nexport type AssertAll<_T extends true[]> = true\n\nexport type IsExtend<X, Y> = X extends Y ? true : false\nexport type IsEquivalent<X, Y> = IsExtend<X, Y> extends true ? IsExtend<Y, X> : false\nexport type IsIdentical<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false\nexport type IsEqual<X, Y> = IsIdentical<Normalize<X>, Normalize<Y>>\n\ntype NormalizeObject<T extends object> = T extends infer O ? { [K in keyof O]: Normalize<O[K]> } : never\nexport type Normalize<T> = T extends (...args: infer A) => infer R\n  ? (...args: Normalize<A>) => Normalize<R>\n  : T extends Array<infer E>\n    ? Array<Normalize<E>>\n    : T extends ReadonlyArray<infer E>\n      ? ReadonlyArray<Normalize<E>>\n      : T extends Promise<infer R>\n        ? Promise<Normalize<R>>\n        : T extends Buffer\n          ? Buffer\n          : T extends object\n            ? NormalizeObject<T>\n            : T\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/url-utils.d.ts

@@ -0,0 +1,19 @@
+declare const _PROTOCOLS: readonly ["http", "https", "ws", "wss"];
+export type Protocol = (typeof _PROTOCOLS)[number];
+export type Path = `/${string}`;
+export type Url = {
+    protocol: Protocol;
+    host: string;
+    port?: number;
+    path?: Path;
+};
+export type UrlParseResult = {
+    status: 'success';
+    url: Url;
+} | {
+    status: 'error';
+    error: string;
+};
+export declare function parse(hostOrUrl: string): UrlParseResult;
+export declare const format: (url: Url) => string;
+export {};

package/dist/bp-cli/dist/utils/url-utils.js

@@ -0,0 +1,67 @@
+"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 url_utils_exports = {};
+__export(url_utils_exports, {
+  format: () => format,
+  parse: () => parse
+});
+module.exports = __toCommonJS(url_utils_exports);
+const _PROTOCOLS = ["http", "https", "ws", "wss"];
+const toPath = (path) => {
+  if (!path.startsWith("/")) {
+    return `/${path}`;
+  }
+  return path;
+};
+function parse(hostOrUrl) {
+  try {
+    const url = new URL(hostOrUrl);
+    return {
+      status: "success",
+      url: {
+        protocol: url.protocol.replace(":", ""),
+        host: url.hostname,
+        port: url.port ? parseInt(url.port) : void 0,
+        path: toPath(url.pathname)
+      }
+    };
+  } catch (thrown) {
+    const message = thrown instanceof Error ? thrown.message : `${thrown}`;
+    return {
+      status: "error",
+      error: message
+    };
+  }
+}
+const format = (url) => {
+  let formatted = `${url.protocol}://${url.host}`;
+  if (url.port) {
+    formatted += `:${url.port}`;
+  }
+  if (url.path && url.path !== "/") {
+    formatted += url.path;
+  }
+  return formatted;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  format,
+  parse
+});
+//# sourceMappingURL=url-utils.js.map

package/dist/bp-cli/dist/utils/url-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/url-utils.ts"],
+  "sourcesContent": ["const _PROTOCOLS = ['http', 'https', 'ws', 'wss'] as const\n\nexport type Protocol = (typeof _PROTOCOLS)[number]\n\nexport type Path = `/${string}`\n\nexport type Url = {\n  protocol: Protocol\n  host: string\n  port?: number\n  path?: Path\n}\n\nexport type UrlParseResult =\n  | {\n      status: 'success'\n      url: Url\n    }\n  | {\n      status: 'error'\n      error: string\n    }\n\nconst toPath = (path: string): Path => {\n  if (!path.startsWith('/')) {\n    return `/${path}`\n  }\n  return path as Path\n}\n\nexport function parse(hostOrUrl: string): UrlParseResult {\n  try {\n    const url = new URL(hostOrUrl)\n    return {\n      status: 'success',\n      url: {\n        protocol: url.protocol.replace(':', '') as Url['protocol'],\n        host: url.hostname,\n        port: url.port ? parseInt(url.port) : undefined,\n        path: toPath(url.pathname),\n      },\n    }\n  } catch (thrown) {\n    const message = thrown instanceof Error ? thrown.message : `${thrown}`\n    return {\n      status: 'error',\n      error: message,\n    }\n  }\n}\n\nexport const format = (url: Url): string => {\n  let formatted = `${url.protocol}://${url.host}`\n  if (url.port) {\n    formatted += `:${url.port}`\n  }\n  if (url.path && url.path !== '/') {\n    formatted += url.path\n  }\n  return formatted\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAAM,aAAa,CAAC,QAAQ,SAAS,MAAM,KAAK;AAuBhD,MAAM,SAAS,CAAC,SAAuB;AACrC,MAAI,CAAC,KAAK,WAAW,GAAG,GAAG;AACzB,WAAO,IAAI,IAAI;AAAA,EACjB;AACA,SAAO;AACT;AAEO,SAAS,MAAM,WAAmC;AACvD,MAAI;AACF,UAAM,MAAM,IAAI,IAAI,SAAS;AAC7B,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,KAAK;AAAA,QACH,UAAU,IAAI,SAAS,QAAQ,KAAK,EAAE;AAAA,QACtC,MAAM,IAAI;AAAA,QACV,MAAM,IAAI,OAAO,SAAS,IAAI,IAAI,IAAI;AAAA,QACtC,MAAM,OAAO,IAAI,QAAQ;AAAA,MAC3B;AAAA,IACF;AAAA,EACF,SAAS,QAAQ;AACf,UAAM,UAAU,kBAAkB,QAAQ,OAAO,UAAU,GAAG,MAAM;AACpE,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,OAAO;AAAA,IACT;AAAA,EACF;AACF;AAEO,MAAM,SAAS,CAAC,QAAqB;AAC1C,MAAI,YAAY,GAAG,IAAI,QAAQ,MAAM,IAAI,IAAI;AAC7C,MAAI,IAAI,MAAM;AACZ,iBAAa,IAAI,IAAI,IAAI;AAAA,EAC3B;AACA,MAAI,IAAI,QAAQ,IAAI,SAAS,KAAK;AAChC,iBAAa,IAAI;AAAA,EACnB;AACA,SAAO;AACT;",
+  "names": []
+}

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

@@ -0,0 +1 @@
+export declare const ENTRY_POINT: string;

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

@@ -0,0 +1,58 @@
+"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 child_entrypoint_exports = {};
+__export(child_entrypoint_exports, {
+  ENTRY_POINT: () => ENTRY_POINT
+});
+module.exports = __toCommonJS(child_entrypoint_exports);
+var utils = __toESM(require("../utils"));
+var import_config = require("./config");
+var import_is_child = require("./is-child");
+const ENTRY_POINT = __filename;
+const childProcessEntrypoint = async (_props) => {
+  const rawConfig = process.env[import_config.CONFIG_ENV_KEY];
+  if (!rawConfig) {
+    throw new Error(`Config variable ${import_config.CONFIG_ENV_KEY} was not set`);
+  }
+  const config = import_config.configSchema.parse(JSON.parse(rawConfig));
+  if (config.type === "code") {
+    utils.require.requireJsCode(config.code);
+  }
+  if (config.type === "file") {
+    utils.require.requireJsFile(config.file);
+  }
+};
+if (import_is_child.processProps.type === "child") {
+  void childProcessEntrypoint(import_is_child.processProps);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENTRY_POINT
+});
+//# sourceMappingURL=child-entrypoint.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/worker/child-entrypoint.ts"],
+  "sourcesContent": ["import * as utils from '../utils'\nimport { CONFIG_ENV_KEY, configSchema } from './config'\nimport { ChildProcessProps, processProps } from './is-child'\n\nexport const ENTRY_POINT = __filename\n\nconst childProcessEntrypoint = async (_props: ChildProcessProps) => {\n  const rawConfig = process.env[CONFIG_ENV_KEY]\n  if (!rawConfig) {\n    throw new Error(`Config variable ${CONFIG_ENV_KEY} was not set`)\n  }\n  const config = configSchema.parse(JSON.parse(rawConfig))\n\n  if (config.type === 'code') {\n    utils.require.requireJsCode(config.code)\n  }\n  if (config.type === 'file') {\n    utils.require.requireJsFile(config.file)\n  }\n}\n\nif (processProps.type === 'child') {\n  // here we are in the child process\n  void childProcessEntrypoint(processProps)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAuB;AACvB,oBAA6C;AAC7C,sBAAgD;AAEzC,MAAM,cAAc;AAE3B,MAAM,yBAAyB,OAAO,WAA8B;AAClE,QAAM,YAAY,QAAQ,IAAI,4BAAc;AAC5C,MAAI,CAAC,WAAW;AACd,UAAM,IAAI,MAAM,mBAAmB,4BAAc,cAAc;AAAA,EACjE;AACA,QAAM,SAAS,2BAAa,MAAM,KAAK,MAAM,SAAS,CAAC;AAEvD,MAAI,OAAO,SAAS,QAAQ;AAC1B,UAAM,QAAQ,cAAc,OAAO,IAAI;AAAA,EACzC;AACA,MAAI,OAAO,SAAS,QAAQ;AAC1B,UAAM,QAAQ,cAAc,OAAO,IAAI;AAAA,EACzC;AACF;AAEA,IAAI,6BAAa,SAAS,SAAS;AAEjC,OAAK,uBAAuB,4BAAY;AAC1C;",
+  "names": []
+}

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

@@ -0,0 +1,18 @@
+import type { Logger } from '../logger';
+import { Config } from './config';
+export type ChildOutput = {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+};
+/**
+ * Wrapper above child_process.ChildProcess to simplify usage
+ */
+export declare class ChildProcessWrapper {
+    private _child;
+    private _exitPromise;
+    static spawn(config: Config, logger: Logger): Promise<ChildProcessWrapper>;
+    private _exited;
+    private constructor();
+    kill(): Promise<ChildOutput>;
+    listen(): Promise<ChildOutput>;
+}

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

@@ -0,0 +1,119 @@
+"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 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 SPAWN_SHELL_ENV = {
+  FORCE_COLOR: "true"
+  // well-known env var used by most shells to enable color output in child processes
+};
+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: {
+        ...SPAWN_SHELL_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);
+    void 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
+});
+//# sourceMappingURL=child-wrapper.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/worker/child-wrapper.ts"],
+  "sourcesContent": ["import * as childProcess from 'child_process'\nimport type { Logger } from '../logger'\nimport { ENTRY_POINT } from './child-entrypoint'\nimport { CONFIG_ENV_KEY, Config } from './config'\nimport { CHILD_ENV_KEY, CHILD_ENV_VALUE, isChildProcess } from './is-child'\n\nexport type ChildOutput = {\n  exitCode: number | null\n  signal: NodeJS.Signals | null\n}\n\nconst SPAWN_SHELL_ENV: Record<string, string> = {\n  FORCE_COLOR: 'true', // well-known env var used by most shells to enable color output in child processes\n} as const\n\nconst listenForChildSpawn = (child: childProcess.ChildProcess, logger: Logger) =>\n  new Promise<void>((resolve, reject) => {\n    child.on('spawn', () => {\n      logger.debug(`Child process spawned with pid ${child.pid}`)\n      resolve()\n    })\n    child.on('error', (err: Error) => {\n      /**\n       * The 'error' event is emitted whenever:\n       *  - The process could not be spawned.\n       *  - The child process was aborted via the signal option.\n       */\n      logger.debug(`Child process error: ${err.message}`)\n      reject(err)\n    })\n  })\n\nconst listenForChildExit = (child: childProcess.ChildProcess, logger: Logger) =>\n  new Promise<ChildOutput>((resolve, reject) => {\n    child.on('disconnect', () => {\n      logger.debug('Child process disconnected')\n    })\n    child.on('close', (exitCode: number | null, signal: NodeJS.Signals | null) => {\n      /**\n       * this event usually fires after exit unless stdio streams are shared across multiple processes.\n       * see https://stackoverflow.com/questions/37522010/difference-between-childprocess-close-exit-events\n       */\n      logger.debug(`Child process closed with code ${exitCode} and signal ${signal}`)\n    })\n    child.on('exit', (exitCode: number | null, signal: NodeJS.Signals | null) => {\n      logger.debug(`Child process exited with code ${exitCode} and signal ${signal}`)\n      resolve({ exitCode, signal })\n    })\n    child.on('error', (err: Error) => {\n      /**\n       * The 'error' event is emitted whenever:\n       *  - The process could not be killed.\n       *  - The child process was aborted via the signal option.\n       */\n      logger.debug(`Child process error: ${err.message}`)\n      reject(err)\n    })\n    child.on('message', (message) => {\n      logger.debug(`Child process message: ${message}`)\n    })\n  })\n\n/**\n * Wrapper above child_process.ChildProcess to simplify usage\n */\nexport class ChildProcessWrapper {\n  public static async spawn(config: Config, logger: Logger): Promise<ChildProcessWrapper> {\n    if (isChildProcess) {\n      throw new Error('Cannot spawn child process from child process')\n    }\n\n    const child = childProcess.fork(ENTRY_POINT, [], {\n      stdio: 'inherit',\n      env: {\n        ...SPAWN_SHELL_ENV,\n        [CHILD_ENV_KEY]: CHILD_ENV_VALUE,\n        [CONFIG_ENV_KEY]: JSON.stringify(config),\n        ...config.env,\n      },\n    })\n\n    const childSpawnPromise = listenForChildSpawn(child, logger)\n    const childExitPromise = listenForChildExit(child, logger)\n\n    const instance = new ChildProcessWrapper(child, childExitPromise)\n\n    void childExitPromise.finally(() => {\n      instance._exited = true\n    })\n\n    await childSpawnPromise\n\n    return instance\n  }\n\n  private _exited = false\n  private constructor(\n    private _child: childProcess.ChildProcess,\n    private _exitPromise: Promise<ChildOutput>\n  ) {}\n\n  public async kill(): Promise<ChildOutput> {\n    if (this._exited) {\n      throw new Error('Child process already exited and cannot be killed')\n    }\n    this._child.kill()\n    const res = await this._exitPromise\n    return res\n  }\n\n  public async listen(): Promise<ChildOutput> {\n    if (this._exited) {\n      throw new Error('Child process already exited and cannot be listened on')\n    }\n    const res = await this._exitPromise\n    return res\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA8B;AAE9B,8BAA4B;AAC5B,oBAAuC;AACvC,sBAA+D;AAO/D,MAAM,kBAA0C;AAAA,EAC9C,aAAa;AAAA;AACf;AAEA,MAAM,sBAAsB,CAAC,OAAkC,WAC7D,IAAI,QAAc,CAAC,SAAS,WAAW;AACrC,QAAM,GAAG,SAAS,MAAM;AACtB,WAAO,MAAM,kCAAkC,MAAM,GAAG,EAAE;AAC1D,YAAQ;AAAA,EACV,CAAC;AACD,QAAM,GAAG,SAAS,CAAC,QAAe;AAMhC,WAAO,MAAM,wBAAwB,IAAI,OAAO,EAAE;AAClD,WAAO,GAAG;AAAA,EACZ,CAAC;AACH,CAAC;AAEH,MAAM,qBAAqB,CAAC,OAAkC,WAC5D,IAAI,QAAqB,CAAC,SAAS,WAAW;AAC5C,QAAM,GAAG,cAAc,MAAM;AAC3B,WAAO,MAAM,4BAA4B;AAAA,EAC3C,CAAC;AACD,QAAM,GAAG,SAAS,CAAC,UAAyB,WAAkC;AAK5E,WAAO,MAAM,kCAAkC,QAAQ,eAAe,MAAM,EAAE;AAAA,EAChF,CAAC;AACD,QAAM,GAAG,QAAQ,CAAC,UAAyB,WAAkC;AAC3E,WAAO,MAAM,kCAAkC,QAAQ,eAAe,MAAM,EAAE;AAC9E,YAAQ,EAAE,UAAU,OAAO,CAAC;AAAA,EAC9B,CAAC;AACD,QAAM,GAAG,SAAS,CAAC,QAAe;AAMhC,WAAO,MAAM,wBAAwB,IAAI,OAAO,EAAE;AAClD,WAAO,GAAG;AAAA,EACZ,CAAC;AACD,QAAM,GAAG,WAAW,CAAC,YAAY;AAC/B,WAAO,MAAM,0BAA0B,OAAO,EAAE;AAAA,EAClD,CAAC;AACH,CAAC;AAKI,MAAM,oBAAoB;AAAA,EA+BvB,YACE,QACA,cACR;AAFQ;AACA;AAAA,EACP;AAAA,EAjCH,aAAoB,MAAM,QAAgB,QAA8C;AACtF,QAAI,gCAAgB;AAClB,YAAM,IAAI,MAAM,+CAA+C;AAAA,IACjE;AAEA,UAAM,QAAQ,aAAa,KAAK,qCAAa,CAAC,GAAG;AAAA,MAC/C,OAAO;AAAA,MACP,KAAK;AAAA,QACH,GAAG;AAAA,QACH,CAAC,6BAAa,GAAG;AAAA,QACjB,CAAC,4BAAc,GAAG,KAAK,UAAU,MAAM;AAAA,QACvC,GAAG,OAAO;AAAA,MACZ;AAAA,IACF,CAAC;AAED,UAAM,oBAAoB,oBAAoB,OAAO,MAAM;AAC3D,UAAM,mBAAmB,mBAAmB,OAAO,MAAM;AAEzD,UAAM,WAAW,IAAI,oBAAoB,OAAO,gBAAgB;AAEhE,SAAK,iBAAiB,QAAQ,MAAM;AAClC,eAAS,UAAU;AAAA,IACrB,CAAC;AAED,UAAM;AAEN,WAAO;AAAA,EACT;AAAA,EAEQ,UAAU;AAAA,EAMlB,MAAa,OAA6B;AACxC,QAAI,KAAK,SAAS;AAChB,YAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AACA,SAAK,OAAO,KAAK;AACjB,UAAM,MAAM,MAAM,KAAK;AACvB,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,SAA+B;AAC1C,QAAI,KAAK,SAAS;AAChB,YAAM,IAAI,MAAM,wDAAwD;AAAA,IAC1E;AACA,UAAM,MAAM,MAAM,KAAK;AACvB,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,28 @@
+import { z } from '@botpress/sdk';
+export declare const CONFIG_ENV_KEY = "CHILD_PROCESS_CONFIGURATION";
+export type Config = z.infer<typeof configSchema>;
+export declare const configSchema: import("@botpress/sdk").ZodUnion<[import("@botpress/sdk").ZodObject<{
+    type: import("@botpress/sdk").ZodLiteral<"code">;
+    code: import("@botpress/sdk").ZodString;
+    env: import("@botpress/sdk").ZodOptional<import("@botpress/sdk").ZodRecord<import("@botpress/sdk").ZodString, import("@botpress/sdk").ZodString>>;
+}, "strip", {
+    type: "code";
+    code: string;
+    env?: Record<string, string> | undefined;
+}, {
+    type: "code";
+    code: string;
+    env?: Record<string, string> | undefined;
+}>, import("@botpress/sdk").ZodObject<{
+    type: import("@botpress/sdk").ZodLiteral<"file">;
+    file: import("@botpress/sdk").ZodString;
+    env: import("@botpress/sdk").ZodOptional<import("@botpress/sdk").ZodRecord<import("@botpress/sdk").ZodString, import("@botpress/sdk").ZodString>>;
+}, "strip", {
+    type: "file";
+    file: string;
+    env?: Record<string, string> | undefined;
+}, {
+    type: "file";
+    file: string;
+    env?: Record<string, string> | undefined;
+}>]>;

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

@@ -0,0 +1,44 @@
+"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 config_exports = {};
+__export(config_exports, {
+  CONFIG_ENV_KEY: () => CONFIG_ENV_KEY,
+  configSchema: () => configSchema
+});
+module.exports = __toCommonJS(config_exports);
+var import_sdk = require("@botpress/sdk");
+const CONFIG_ENV_KEY = "CHILD_PROCESS_CONFIGURATION";
+const configSchema = import_sdk.z.union([
+  import_sdk.z.object({
+    type: import_sdk.z.literal("code"),
+    code: import_sdk.z.string(),
+    env: import_sdk.z.record(import_sdk.z.string(), import_sdk.z.string()).optional()
+  }),
+  import_sdk.z.object({
+    type: import_sdk.z.literal("file"),
+    file: import_sdk.z.string(),
+    env: import_sdk.z.record(import_sdk.z.string(), import_sdk.z.string()).optional()
+  })
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_ENV_KEY,
+  configSchema
+});
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/worker/config.ts"],
+  "sourcesContent": ["import { z } from '@botpress/sdk'\n\nexport const CONFIG_ENV_KEY = 'CHILD_PROCESS_CONFIGURATION'\n\nexport type Config = z.infer<typeof configSchema>\nexport const configSchema = z.union([\n  z.object({\n    type: z.literal('code'),\n    code: z.string(),\n    env: z.record(z.string(), z.string()).optional(),\n  }),\n  z.object({\n    type: z.literal('file'),\n    file: z.string(),\n    env: z.record(z.string(), z.string()).optional(),\n  }),\n])\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAkB;AAEX,MAAM,iBAAiB;AAGvB,MAAM,eAAe,aAAE,MAAM;AAAA,EAClC,aAAE,OAAO;AAAA,IACP,MAAM,aAAE,QAAQ,MAAM;AAAA,IACtB,MAAM,aAAE,OAAO;AAAA,IACf,KAAK,aAAE,OAAO,aAAE,OAAO,GAAG,aAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EACjD,CAAC;AAAA,EACD,aAAE,OAAO;AAAA,IACP,MAAM,aAAE,QAAQ,MAAM;AAAA,IACtB,MAAM,aAAE,OAAO;AAAA,IACf,KAAK,aAAE,OAAO,aAAE,OAAO,GAAG,aAAE,OAAO,CAAC,EAAE,SAAS;AAAA,EACjD,CAAC;AACH,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,2 @@
+export { Config } from './config';
+export { Worker } from './worker';

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

@@ -0,0 +1,32 @@
+"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, {
+  Config: () => import_config.Config,
+  Worker: () => import_worker.Worker
+});
+module.exports = __toCommonJS(worker_exports);
+var import_config = require("./config");
+var import_worker = require("./worker");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  Worker
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/worker/index.ts"],
+  "sourcesContent": ["export { Config } from './config'\nexport { Worker } from './worker'\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuB;AACvB,oBAAuB;",
+  "names": []
+}

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

@@ -0,0 +1,14 @@
+export declare const CHILD_ENV_KEY = "IS_CHILD";
+export declare const CHILD_ENV_VALUE = "true";
+export type MainProcessProps = {
+    type: 'main';
+    pid: number;
+};
+export type ChildProcessProps = {
+    type: 'child';
+    sendMessage: (message: string) => void;
+    pid: number;
+};
+export type ProcessProps = MainProcessProps | ChildProcessProps;
+export declare const processProps: ProcessProps;
+export declare const isChildProcess: boolean;

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

@@ -0,0 +1,55 @@
+"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 is_child_exports = {};
+__export(is_child_exports, {
+  CHILD_ENV_KEY: () => CHILD_ENV_KEY,
+  CHILD_ENV_VALUE: () => CHILD_ENV_VALUE,
+  isChildProcess: () => isChildProcess,
+  processProps: () => processProps
+});
+module.exports = __toCommonJS(is_child_exports);
+const CHILD_ENV_KEY = "IS_CHILD";
+const CHILD_ENV_VALUE = "true";
+const getProcessProps = () => {
+  const type = process.env[CHILD_ENV_KEY] === CHILD_ENV_VALUE ? "child" : "main";
+  if (type === "main") {
+    return {
+      type,
+      pid: process.pid
+    };
+  }
+  if (!process.send) {
+    throw new Error(`Please do not use variable ${CHILD_ENV_KEY} manually`);
+  }
+  return {
+    type,
+    sendMessage: process.send,
+    pid: process.pid
+  };
+};
+const processProps = getProcessProps();
+const isChildProcess = processProps.type === "child";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHILD_ENV_KEY,
+  CHILD_ENV_VALUE,
+  isChildProcess,
+  processProps
+});
+//# sourceMappingURL=is-child.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/worker/is-child.ts"],
+  "sourcesContent": ["export const CHILD_ENV_KEY = 'IS_CHILD'\nexport const CHILD_ENV_VALUE = 'true'\n\nexport type MainProcessProps = {\n  type: 'main'\n  pid: number\n}\nexport type ChildProcessProps = {\n  type: 'child'\n  sendMessage: (message: string) => void\n  pid: number\n}\n\nexport type ProcessProps = MainProcessProps | ChildProcessProps\n\nconst getProcessProps = (): ProcessProps => {\n  const type = process.env[CHILD_ENV_KEY] === CHILD_ENV_VALUE ? 'child' : 'main'\n  if (type === 'main') {\n    return {\n      type,\n      pid: process.pid,\n    }\n  }\n\n  if (!process.send) {\n    throw new Error(`Please do not use variable ${CHILD_ENV_KEY} manually`)\n  }\n\n  return {\n    type,\n    sendMessage: process.send,\n    pid: process.pid,\n  }\n}\n\nexport const processProps = getProcessProps()\nexport const isChildProcess = processProps.type === 'child'\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,gBAAgB;AACtB,MAAM,kBAAkB;AAc/B,MAAM,kBAAkB,MAAoB;AAC1C,QAAM,OAAO,QAAQ,IAAI,aAAa,MAAM,kBAAkB,UAAU;AACxE,MAAI,SAAS,QAAQ;AACnB,WAAO;AAAA,MACL;AAAA,MACA,KAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAEA,MAAI,CAAC,QAAQ,MAAM;AACjB,UAAM,IAAI,MAAM,8BAA8B,aAAa,WAAW;AAAA,EACxE;AAEA,SAAO;AAAA,IACL;AAAA,IACA,aAAa,QAAQ;AAAA,IACrB,KAAK,QAAQ;AAAA,EACf;AACF;AAEO,MAAM,eAAe,gBAAgB;AACrC,MAAM,iBAAiB,aAAa,SAAS;",
+  "names": []
+}

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

@@ -0,0 +1,30 @@
+import type { ChildProcessWrapper } from './child-wrapper';
+export type WorkerStatus = WorkerState['status'];
+export type WorkerState = {
+    status: 'errored';
+    thrown: unknown;
+} | {
+    status: 'dead';
+    murdered: boolean;
+} | {
+    status: 'killing';
+} | {
+    status: 'reloading';
+} | {
+    status: 'live';
+    child: ChildProcessWrapper;
+};
+export type StateOf<S extends WorkerStatus> = Extract<WorkerState, {
+    status: S;
+}>;
+export type WorkerStateHandler<S extends WorkerStatus> = (state: StateOf<S>) => void;
+export declare class WorkerStateObserver {
+    private _state;
+    private _handlers;
+    constructor(initialState: WorkerState);
+    waitFor<S extends WorkerStatus>(status: S): Promise<void>;
+    on<S extends WorkerStatus>(status: S, handler: WorkerStateHandler<S>): void;
+    off<S extends WorkerStatus>(status: S, handler: WorkerStateHandler<S>): void;
+    get(): WorkerState;
+    set(newState: WorkerState): void;
+}