@botpress/cli 0.0.7 → 0.0.9

package/.ignore.me.github/index.ts

@@ -0,0 +1,38 @@
+import fs from 'fs'
+import pathlib from 'path'
+import { Octokit } from 'octokit'
+import { Logger } from '../src/logger'
+import { GithubFetcher } from '../src/github-fetch'
+
+const maybeExit = (exit: boolean) => {
+  if (exit) {
+    process.exit(0)
+  }
+}
+
+const SSH_URI = 'ssh://github.com/botpress/openbook-cli.git'
+const GIT_SSH_URI = 'git@github.com:botpress/openbook-cli.git'
+const HTTPS_URI = 'https://github.com/botpress/openbook-cli.git'
+const HTTPS_GITHUB_URI = 'https://github.com/botpress/skynet/tree/master'
+
+const githubAuth = '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'
+
+const main = async () => {
+  const logger = new Logger({ verbose: true })
+  const parsedUri = new GithubFetcher(logger)._parseUri(HTTPS_GITHUB_URI)
+
+  const octokit = new Octokit({ auth: githubAuth })
+
+  const { data: content } = await octokit.rest.repos.getContent({ ...parsedUri })
+
+  logger.json(content)
+  // const {
+  //   data: { content: blob },
+  // } = await octokit.rest.git.getBlob({
+  //   ...parsedUri,
+  //   file_sha: content,
+  // })
+
+  maybeExit(true)
+}
+void main()

package/dist/app/file-paths.js

@@ -33,47 +33,42 @@ var consts = __toESM(require("../consts"));
 var pathutils = __toESM(require("../path-utils"));
 class ProjectPaths {
   abs;
-  rel;
-  constructor({ workDir, definition, entryPoint: entrypoint, outDir }) {
-    const absWorkdir = pathutils.absoluteFrom(pathutils.cwd(), workDir);
-    const absDefinition = pathutils.absoluteFrom(absWorkdir, definition);
-    const absEntrypoint = pathutils.absoluteFrom(absWorkdir, entrypoint);
-    const absOutdir = pathutils.absoluteFrom(absWorkdir, outDir);
+  constructor({ workDir, entryPoint, outDir }) {
+    const absWorkDir = pathutils.absoluteFrom(pathutils.cwd(), workDir);
+    const absEntrypoint = pathutils.absoluteFrom(absWorkDir, entryPoint);
+    const absOutDir = pathutils.absoluteFrom(absWorkDir, outDir);
     this.abs = {
-      workDir: absWorkdir,
-      definition: absDefinition,
+      workDir: absWorkDir,
       entryPoint: absEntrypoint,
-      outDir: absOutdir,
-      ...import_lodash.default.mapValues(consts.relativeToOutFolder, (p) => pathutils.absoluteFrom(absOutdir, p))
-    };
-    const relDefinition = pathutils.relativeFrom(this.abs.workDir, this.abs.definition);
-    const relEntrypoint = pathutils.relativeFrom(this.abs.workDir, this.abs.entryPoint);
-    const relOutdir = pathutils.relativeFrom(this.abs.workDir, this.abs.outDir);
-    const relWorkdir = ".";
-    this.rel = {
-      workDir: relWorkdir,
-      definition: relDefinition,
-      entryPoint: relEntrypoint,
-      outDir: relOutdir,
-      ...import_lodash.default.mapValues(consts.relativeToOutFolder, (p) => pathutils.relativeFrom(this.abs.outDir, p))
+      outDir: absOutDir,
+      ...import_lodash.default.mapValues(consts.fromOutDir, (p) => pathutils.absoluteFrom(absOutDir, p)),
+      ...import_lodash.default.mapValues(consts.fromWorkDir, (p) => pathutils.absoluteFrom(absWorkDir, p))
     };
   }
+  get rel() {
+    return this.relFrom("workDir");
+  }
+  relFrom(dir) {
+    const from = this.abs[dir];
+    return import_lodash.default.mapValues(this.abs, (to) => pathutils.relativeFrom(from, to));
+  }
 }
 class UserPaths {
   abs;
-  rel;
-  constructor({ botpressHome }) {
-    const absBotpressHome = pathutils.absoluteFrom(pathutils.cwd(), botpressHome);
+  constructor({ botpressHomeDir }) {
+    const absBotpressHome = pathutils.absoluteFrom(pathutils.cwd(), botpressHomeDir);
     this.abs = {
-      botpressHome: absBotpressHome,
-      ...import_lodash.default.mapValues(consts.relativeToHomeFolder, (p) => pathutils.absoluteFrom(absBotpressHome, p))
-    };
-    const relBotpressHome = ".";
-    this.rel = {
-      botpressHome: relBotpressHome,
-      ...import_lodash.default.mapValues(consts.relativeToHomeFolder, (p) => pathutils.relativeFrom(this.abs.botpressHome, p))
+      botpressHomeDir: absBotpressHome,
+      ...import_lodash.default.mapValues(consts.fromHomeDir, (p) => pathutils.absoluteFrom(absBotpressHome, p))
     };
   }
+  get rel() {
+    return this.relFrom("botpressHomeDir");
+  }
+  relFrom(dir) {
+    const from = this.abs[dir];
+    return import_lodash.default.mapValues(this.abs, (to) => pathutils.relativeFrom(from, to));
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/app/index.js

@@ -50,10 +50,11 @@ const logBootInfo = async (logger, props) => {
 const forProject = async (props) => {
   const logger = new import_logger.Logger(props);
   await logBootInfo(logger, props);
-  const projectPaths = new import_file_paths.ProjectPaths(props);
+  const { workDir, entryPoint, outDir, botpressHome } = props;
+  const projectPaths = new import_file_paths.ProjectPaths({ workDir, entryPoint, outDir });
   const projectCachePath = projectPaths.abs.projectCacheFile;
   const projectCache = await import_cache.FSConfigCache.loadFrom(projectCachePath);
-  const userPaths = new import_file_paths.UserPaths(props);
+  const userPaths = new import_file_paths.UserPaths({ botpressHomeDir: botpressHome });
   const userCacheFile = userPaths.abs.userCacheFile;
   const userCache = await import_cache.FSConfigCache.loadFrom(userCacheFile);
   await import_fs.default.promises.mkdir(projectPaths.abs.distDir, { recursive: true });
@@ -62,7 +63,8 @@ const forProject = async (props) => {
 const forUser = async (props) => {
   const logger = new import_logger.Logger(props);
   await logBootInfo(logger, props);
-  const userPaths = new import_file_paths.UserPaths(props);
+  const { botpressHome } = props;
+  const userPaths = new import_file_paths.UserPaths({ botpressHomeDir: botpressHome });
   const userCacheFile = userPaths.abs.userCacheFile;
   const userCache = await import_cache.FSConfigCache.loadFrom(userCacheFile);
   return new import_user.UserCommands(props, userCache, logger);

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"));
@@ -125,9 +126,9 @@ class ProjectCommands extends import_base.BaseCommands {
     line.started(`Generating typings for integration ${import_chalk.default.bold(name)}...`);
     const typingFiles = await generator.generateIntegrationImplementationTypings(
       integrationDef,
-      consts.relativeToOutFolder.implementationDir
+      this._paths.relFrom("outDir").implementationDir
     );
-    const indexFile = await generator.generateIntegrationIndex(consts.relativeToOutFolder.implementationDir);
+    const indexFile = await generator.generateIntegrationIndex(this._paths.relFrom("outDir").implementationDir);
     const generatedFiles = [...typingFiles, indexFile];
     await this._writeFilesToOutFolder(generatedFiles);
     line.success(`Typings available at ${import_chalk.default.grey(this._paths.rel.outDir)}`);
@@ -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");
@@ -412,7 +438,7 @@ class ProjectCommands extends import_base.BaseCommands {
     line.started(`Installing ${import_chalk.default.bold(name)} v${version}...`);
     const instanceFiles = await generator.generateIntegrationInstance(
       integration,
-      consts.relativeToOutFolder.installDir
+      this._paths.relFrom("outDir").installDir
     );
     await this._writeFilesToOutFolder(instanceFiles);
     await this._generateBotIndex();
@@ -421,7 +447,7 @@ class ProjectCommands extends import_base.BaseCommands {
   async _generateBotIndex() {
     const allInstances = await this._listIntegrationInstances();
     const indexFile = await generator.generateBotIndex(
-      consts.relativeToOutFolder.installDir,
+      this._paths.relFrom("outDir").installDir,
       allInstances.map((i) => i.dirname)
     );
     await this._writeFilesToOutFolder([indexFile]);

package/dist/config.js

@@ -80,11 +80,6 @@ const entryPoint = {
   description: "The entry point of the project",
   default: consts.defaultEntrypoint
 };
-const definition = {
-  type: "string",
-  description: "The integration definition file to use. If file not found, the project is treated as a bot",
-  default: consts.defaultIntegrationConfigScript
-};
 const outDir = {
   type: "string",
   description: "The output directory",
@@ -144,7 +139,6 @@ const globalSchema = {
 const projectSchema = {
   ...globalSchema,
   entryPoint,
-  definition,
   outDir,
   workDir
 };

package/dist/consts.js

@@ -28,10 +28,10 @@ __export(consts_exports, {
   defaultBotpressApp: () => defaultBotpressApp,
   defaultBotpressHome: () => defaultBotpressHome,
   defaultEntrypoint: () => defaultEntrypoint,
-  defaultIntegrationConfigScript: () => defaultIntegrationConfigScript,
   defaultOutputFolder: () => defaultOutputFolder,
-  relativeToHomeFolder: () => relativeToHomeFolder,
-  relativeToOutFolder: () => relativeToOutFolder
+  fromHomeDir: () => fromHomeDir,
+  fromOutDir: () => fromOutDir,
+  fromWorkDir: () => fromWorkDir
 });
 module.exports = __toCommonJS(consts_exports);
 var import_os = __toESM(require("os"));
@@ -39,13 +39,15 @@ var import_path = __toESM(require("path"));
 const defaultBotpressHome = import_path.default.join(import_os.default.homedir(), ".botpress");
 const defaultOutputFolder = ".botpress";
 const defaultEntrypoint = import_path.default.join("src", "index.ts");
-const defaultIntegrationConfigScript = "integration.definition.ts";
 const defaultBotpressApi = "https://api.botpress.cloud";
 const defaultBotpressApp = "https://app.botpress.cloud";
-const relativeToHomeFolder = {
+const fromHomeDir = {
   userCacheFile: "user.cache.json"
 };
-const relativeToOutFolder = {
+const fromWorkDir = {
+  definition: "integration.definition.ts"
+};
+const fromOutDir = {
   distDir: "dist",
   outFile: import_path.default.join("dist", "index.js"),
   installDir: "installations",
@@ -58,8 +60,8 @@ const relativeToOutFolder = {
   defaultBotpressApp,
   defaultBotpressHome,
   defaultEntrypoint,
-  defaultIntegrationConfigScript,
   defaultOutputFolder,
-  relativeToHomeFolder,
-  relativeToOutFolder
+  fromHomeDir,
+  fromOutDir,
+  fromWorkDir
 });

package/dist/github-download.js

@@ -0,0 +1,159 @@
+"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 github_download_exports = {};
+__export(github_download_exports, {
+  GithubDownloader: () => GithubDownloader
+});
+module.exports = __toCommonJS(github_download_exports);
+var import_fs = __toESM(require("fs"));
+var import_git_url_parse = __toESM(require("git-url-parse"));
+var import_octokit = require("octokit");
+var import_path = __toESM(require("path"));
+const GITHUB_HOST = "github.com";
+const DEFAULT_REF = "HEAD";
+const GIT_URI = /^(?:git|ssh|https?|git@[-\w.]+):(\/\/)?(.*?)(\.git)(\/?|\#[-\d\w._]+?)$/;
+const GITHUB_TREE_URI = /^^https:\/\/(.*?)(\.com)\/.*$/;
+class GithubDownloader {
+  constructor(_logger) {
+    this._logger = _logger;
+  }
+  async listFiles(props) {
+    const parsedUri = this._parseUri(props.srcUri);
+    const { path: _, ...repoUri } = parsedUri;
+    const octo = new import_octokit.Octokit({ auth: props.githubAuth });
+    const files = await this._listFiles({
+      octo,
+      srcUri: parsedUri,
+      recursive: props.recursive
+    });
+    return files.map((f) => ({
+      uri: this._formatUri({ ...repoUri, path: f.path }),
+      name: f.name,
+      type: f.type
+    }));
+  }
+  async downloadFiles(props) {
+    const { destDir, srcUri } = props;
+    const dirExists = import_fs.default.existsSync(destDir);
+    if (dirExists) {
+      throw new Error(`Directory ${destDir} already exists`);
+    }
+    const parsedUri = this._parseUri(srcUri);
+    const octo = new import_octokit.Octokit({ auth: props.githubAuth });
+    await this._downloadFiles({
+      octo,
+      srcUri: parsedUri,
+      destDir,
+      allowedExtensions: props.allowedExtensions
+    });
+  }
+  async _downloadFiles(props) {
+    const { octo, srcUri, destDir, allowedExtensions } = props;
+    const files = await this._listFiles(props);
+    this._logger.debug(`Downloading ${files.length} files from ${srcUri.path} to ${destDir}`);
+    await import_fs.default.promises.mkdir(destDir);
+    for (const file of files) {
+      if (file.type === "dir") {
+        const subDir = import_path.default.join(destDir, file.name);
+        await this._downloadFiles({
+          octo,
+          srcUri: { ...srcUri, path: [srcUri.path, file.name].join("/") },
+          destDir: subDir
+        });
+        continue;
+      }
+      const fileExt = import_path.default.extname(file.name);
+      if (allowedExtensions && !allowedExtensions.includes(fileExt)) {
+        this._logger.debug(`Skipping file ${file.name} because it is not an allowed file type`);
+        continue;
+      }
+      const { data: blob } = await octo.rest.git.getBlob({
+        ...srcUri,
+        file_sha: file.sha
+      });
+      const filePath = import_path.default.join(destDir, file.name);
+      const content = Buffer.from(blob.content, "base64");
+      await import_fs.default.promises.writeFile(filePath, content);
+    }
+  }
+  async _listFiles(props) {
+    const { octo, srcUri, recursive } = props;
+    const { data } = await octo.rest.repos.getContent({
+      ...srcUri
+    });
+    let allFiles;
+    if (!Array.isArray(data)) {
+      allFiles = [data];
+    } else {
+      allFiles = data;
+    }
+    let supportedFiles = allFiles.filter((f) => f.type === "dir" || f.type === "file");
+    if (!recursive) {
+      return supportedFiles;
+    }
+    for (const dir of allFiles.filter((f) => f.type === "dir")) {
+      const subFiles = await this._listFiles({
+        ...props,
+        srcUri: {
+          ...srcUri,
+          path: [srcUri.path, dir.name].join("/")
+        }
+      });
+      supportedFiles = [...supportedFiles, ...subFiles];
+    }
+    return supportedFiles;
+  }
+  _formatUri(uri) {
+    if (uri.protocol === "ssh") {
+      return `git@${GITHUB_HOST}:${uri.owner}/${uri.repo}.git`;
+    }
+    return `https://${GITHUB_HOST}/${uri.owner}/${uri.repo}/tree/${uri.ref}/${uri.path}`;
+  }
+  _parseUri(uri) {
+    const isGit = this._isGitUri(uri);
+    if (!isGit) {
+      throw new Error("URI is not a valid git repository URI");
+    }
+    const parsed = (0, import_git_url_parse.default)(uri);
+    if (parsed.resource !== GITHUB_HOST) {
+      throw new Error(`Unsupported git host: ${parsed.resource}`);
+    }
+    if (parsed.protocol !== "ssh" && parsed.protocol !== "https") {
+      throw new Error(`Unsupported git protocol: ${parsed.protocol}}`);
+    }
+    return {
+      protocol: parsed.protocol,
+      owner: parsed.owner,
+      repo: parsed.name,
+      ref: parsed.ref ? parsed.ref : DEFAULT_REF,
+      path: parsed.filepath
+    };
+  }
+  _isGitUri = (uri) => GITHUB_TREE_URI.test(uri) || GIT_URI.test(uri);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GithubDownloader
+});

package/dist/github-fetch.js

@@ -0,0 +1,173 @@
+"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 github_fetch_exports = {};
+__export(github_fetch_exports, {
+  GithubFetchError: () => GithubFetchError,
+  GithubFetcher: () => GithubFetcher
+});
+module.exports = __toCommonJS(github_fetch_exports);
+var import_git_url_parse = __toESM(require("git-url-parse"));
+var import_octokit = require("octokit");
+var import_path = __toESM(require("path"));
+class GithubFetchError extends Error {
+}
+const GITHUB_HOST = "github.com";
+const DEFAULT_REF = "HEAD";
+const GIT_URI = /^(?:git|ssh|https?|git@[-\w.]+):(\/\/)?(.*?)(\.git)(\/?|\#[-\d\w._]+?)$/;
+const GITHUB_TREE_URI = /^https:\/\/(.*?)(\.com)\/.*$/;
+class GithubFetcher {
+  constructor(_logger) {
+    this._logger = _logger;
+  }
+  async listFiles(props) {
+    const { uri, auth, recursive, pattern } = props;
+    if (pattern?.global) {
+      throw new GithubFetchError("Pattern must not be global");
+    }
+    const parsedUri = this._parseUri(uri);
+    const octo = new import_octokit.Octokit({ auth });
+    const dir = await this._browseTree({
+      octo,
+      uri: parsedUri,
+      recursive: recursive ?? false,
+      pattern,
+      leafMap: async (entry) => {
+        const entryUri = { ...parsedUri, path: entry.path };
+        return {
+          type: "file",
+          uri: this._formatUri(entryUri),
+          name: import_path.default.basename(entry.path),
+          content: null
+        };
+      }
+    });
+    return dir;
+  }
+  async fetchFiles(props) {
+    const { uri, auth, recursive, pattern } = props;
+    if (pattern?.global) {
+      throw new GithubFetchError("Pattern must not be global");
+    }
+    const parsedUri = this._parseUri(uri);
+    const octo = new import_octokit.Octokit({ auth });
+    const dir = await this._browseTree({
+      octo,
+      uri: parsedUri,
+      recursive: recursive ?? false,
+      pattern,
+      leafMap: async (entry) => {
+        const entryUri = { ...parsedUri, path: entry.path };
+        const {
+          data: { content: blob }
+        } = await octo.rest.git.getBlob({ ...entryUri, file_sha: entry.sha });
+        return {
+          type: "file",
+          uri: this._formatUri({ ...parsedUri, path: entry.path }),
+          name: import_path.default.basename(entry.path),
+          content: Buffer.from(blob, "base64").toString("utf8")
+        };
+      }
+    });
+    return dir;
+  }
+  async _browseTree(props) {
+    const { octo, uri, recursive, leafMap, pattern } = props;
+    const { data } = await octo.rest.repos.getContent({
+      ...uri
+    });
+    if (!Array.isArray(data)) {
+      const formattedUri = this._formatUri(uri);
+      throw new GithubFetchError(`URI ${formattedUri} is not a directory. Cannot list or fetch a single file.`);
+    }
+    const allTopLevelEntries = data;
+    const supportedEntries = allTopLevelEntries.filter(this._isSupported);
+    const dir = {
+      type: "dir",
+      uri: this._formatUri(uri),
+      name: import_path.default.basename(uri.path)
+    };
+    const content = [];
+    for (const entry of supportedEntries) {
+      const entryUri = { ...uri, path: entry.path };
+      if (entry.type === "file") {
+        if (pattern && !pattern.test(entry.path)) {
+          this._logger.debug(`Skipping ${entry.path} because it does not match pattern ${pattern}`);
+        } else {
+          const leaf = await leafMap(entry);
+          content.push(leaf);
+        }
+        continue;
+      }
+      if (!recursive) {
+        content.push({
+          type: "dir",
+          uri: this._formatUri(entryUri),
+          name: entry.name,
+          content: []
+        });
+        continue;
+      }
+      const subDirEntry = await this._browseTree({ octo, uri: entryUri, recursive, leafMap });
+      content.push(subDirEntry);
+    }
+    return {
+      ...dir,
+      content
+    };
+  }
+  _formatUri(uri) {
+    if (uri.protocol === "ssh") {
+      return `git@${GITHUB_HOST}:${uri.owner}/${uri.repo}.git`;
+    }
+    return `https://${GITHUB_HOST}/${uri.owner}/${uri.repo}/tree/${uri.ref}/${uri.path}`;
+  }
+  _parseUri(uri) {
+    const isGit = this._isGitUri(uri);
+    if (!isGit) {
+      throw new Error("URI is not a valid git repository URI");
+    }
+    const parsed = (0, import_git_url_parse.default)(uri);
+    if (parsed.resource !== GITHUB_HOST) {
+      throw new Error(`Unsupported git host: ${parsed.resource}`);
+    }
+    if (parsed.protocol !== "ssh" && parsed.protocol !== "https") {
+      throw new Error(`Unsupported git protocol: ${parsed.protocol}}`);
+    }
+    return {
+      protocol: parsed.protocol,
+      owner: parsed.owner,
+      repo: parsed.name,
+      ref: parsed.ref ? parsed.ref : DEFAULT_REF,
+      path: parsed.filepath
+    };
+  }
+  _isGitUri = (uri) => GITHUB_TREE_URI.test(uri) || GIT_URI.test(uri);
+  _isSupported = (file) => file.type === "dir" || file.type === "file";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GithubFetchError,
+  GithubFetcher
+});

package/dist/path-utils.js

@@ -52,10 +52,7 @@ const relativeFrom = (rootdir, target) => {
   } else {
     absPath = import_path.default.resolve(import_path.default.join(rootdir, target));
   }
-  if (!absPath.startsWith(rootdir)) {
-    return target;
-  }
-  return absPath.slice(rootdir.length + 1);
+  return import_path.default.relative(rootdir, absPath);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/cli",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Botpress CLI",
   "scripts": {
     "build": "pnpm run type-check && pnpm run bundle",
@@ -17,8 +17,9 @@
   },
   "main": "dist/index.js",
   "dependencies": {
-    "@botpress/client": "0.0.6",
+    "@botpress/client": "0.0.7",
     "@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",
@@ -42,7 +43,7 @@
     "zod-to-json-schema": "^3.20.1"
   },
   "devDependencies": {
-    "@botpress/sdk": "0.0.7",
+    "@botpress/sdk": "0.0.8",
     "@types/bluebird": "^3.5.38",
     "@types/prompts": "^2.0.14",
     "@types/semver": "^7.3.11",

package/dist/app/esbuild.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 esbuild_exports = {};
-__export(esbuild_exports, {
-  buildCode: () => buildCode,
-  buildEntrypoint: () => buildEntrypoint
-});
-module.exports = __toCommonJS(esbuild_exports);
-var import_esbuild = require("esbuild");
-const keepNames = true;
-function buildCode({
-  cwd,
-  minify = true,
-  bundle = true,
-  sourcemap = false,
-  logLevel = "silent",
-  outfile,
-  code,
-  write
-}) {
-  return (0, import_esbuild.build)({
-    stdin: {
-      contents: code,
-      resolveDir: cwd,
-      loader: "ts"
-    },
-    logOverride: {
-      "equals-negative-zero": "silent"
-    },
-    platform: "node",
-    target: "es2020",
-    sourcemap,
-    minify,
-    bundle,
-    outfile,
-    absWorkingDir: cwd,
-    logLevel,
-    keepNames,
-    write
-  });
-}
-function buildEntrypoint({
-  cwd,
-  minify = true,
-  bundle = true,
-  sourcemap = false,
-  logLevel = "silent",
-  outfile,
-  entrypoint,
-  write
-}) {
-  return (0, import_esbuild.build)({
-    entryPoints: [entrypoint],
-    logOverride: {
-      "equals-negative-zero": "silent"
-    },
-    platform: "node",
-    target: "es2020",
-    sourcemap,
-    minify,
-    bundle,
-    outfile,
-    absWorkingDir: cwd,
-    logLevel,
-    keepNames,
-    write
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildCode,
-  buildEntrypoint
-});

package/dist/const.js

@@ -1,87 +0,0 @@
-"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 const_exports = {};
-__export(const_exports, {
-  defDataOutfile: () => defDataOutfile,
-  defaultBotpressApi: () => defaultBotpressApi,
-  defaultBotpressApp: () => defaultBotpressApp,
-  defaultBotpressHome: () => defaultBotpressHome,
-  defaultEntrypoint: () => defaultEntrypoint,
-  defaultIntegrationConfigScript: () => defaultIntegrationConfigScript,
-  defaultOutputFolder: () => defaultOutputFolder,
-  dist: () => dist,
-  implementationTypings: () => implementationTypings,
-  installDir: () => installDir,
-  outfile: () => outfile,
-  projectCache: () => projectCache,
-  relativeToHomeFolder: () => relativeToHomeFolder,
-  relativeToOutFolder: () => relativeToOutFolder,
-  userCache: () => userCache
-});
-module.exports = __toCommonJS(const_exports);
-var import_os = __toESM(require("os"));
-var import_path = __toESM(require("path"));
-const defaultOutputFolder = ".botpress";
-const defaultEntrypoint = "src/index.ts";
-const defaultIntegrationConfigScript = "integration.definition.ts";
-const defaultBotpressApi = "https://api.botpress.cloud";
-const defaultBotpressApp = "https://app.botpress.cloud";
-const defaultBotpressHome = import_path.default.join(import_os.default.homedir(), ".botpress");
-const relativeToHomeFolder = {
-  userCache: "user.cache.json"
-};
-const userCache = (botpressHome) => import_path.default.join(botpressHome, relativeToHomeFolder.userCache);
-const relativeToOutFolder = {
-  dist: "dist",
-  outfile: import_path.default.join("dist", "index.js"),
-  defDataOutfile: import_path.default.join("dist", "integration.definition.json"),
-  implementationTypings: "implementation",
-  installDir: "installations",
-  projectCache: "project.cache.json"
-};
-const dist = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.dist);
-const outfile = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.outfile);
-const defDataOutfile = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.defDataOutfile);
-const implementationTypings = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.implementationTypings);
-const installDir = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.installDir);
-const projectCache = (outFolder) => import_path.default.join(outFolder, relativeToOutFolder.projectCache);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  defDataOutfile,
-  defaultBotpressApi,
-  defaultBotpressApp,
-  defaultBotpressHome,
-  defaultEntrypoint,
-  defaultIntegrationConfigScript,
-  defaultOutputFolder,
-  dist,
-  implementationTypings,
-  installDir,
-  outfile,
-  projectCache,
-  relativeToHomeFolder,
-  relativeToOutFolder,
-  userCache
-});

package/dist/paths.js

@@ -1,69 +0,0 @@
-"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 paths_exports = {};
-__export(paths_exports, {
-  absoluteFrom: () => absoluteFrom,
-  cwd: () => cwd,
-  isAbsolute: () => isAbsolute,
-  isPath: () => isPath,
-  relativeFrom: () => relativeFrom,
-  rmExtension: () => rmExtension,
-  toUnix: () => toUnix
-});
-module.exports = __toCommonJS(paths_exports);
-var import_path = __toESM(require("path"));
-const cwd = () => process.cwd();
-const isAbsolute = (path) => import_path.default.isAbsolute(path);
-const isPath = (path) => isAbsolute(path) || path.startsWith(".");
-const rmExtension = (filename) => filename.replace(/\.[^/.]+$/, "");
-const toUnix = (path) => path.split(import_path.default.sep).join(import_path.default.posix.sep);
-const absoluteFrom = (rootdir, target) => {
-  if (isAbsolute(target)) {
-    return target;
-  }
-  return import_path.default.join(rootdir, target);
-};
-const relativeFrom = (rootdir, target) => {
-  let absPath;
-  if (isAbsolute(target)) {
-    absPath = target;
-  } else {
-    absPath = import_path.default.resolve(import_path.default.join(rootdir, target));
-  }
-  if (!absPath.startsWith(rootdir)) {
-    return target;
-  }
-  return absPath.slice(rootdir.length + 1);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  absoluteFrom,
-  cwd,
-  isAbsolute,
-  isPath,
-  relativeFrom,
-  rmExtension,
-  toUnix
-});

package/dist/requires.js

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

package/dist/type-utils.js

@@ -1,16 +0,0 @@
-"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);

package/dist/worker/keyboard.js

@@ -1,48 +0,0 @@
-"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/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
-});

package/dist/worker/messaging.js

@@ -1,39 +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 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
-});