@camstack/kernel 0.1.1 → 0.1.3

package/dist/worker/addon-worker-entry.js

@@ -5,12 +5,8 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -29,110 +25,395 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/fs-utils.ts
-function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-}
-function copyDirRecursive(src, dest) {
-  ensureDir(dest);
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
+// src/worker/worker-process-manager.js
+var require_worker_process_manager = __commonJS({
+  "src/worker/worker-process-manager.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WorkerProcessManager = void 0;
+    var node_child_process_1 = require("child_process");
+    var WorkerProcessManager2 = class {
+      sendToMain;
+      processes = /* @__PURE__ */ new Map();
+      constructor(sendToMain) {
+        this.sendToMain = sendToMain;
+      }
+      async spawn(config) {
+        const child = (0, node_child_process_1.spawn)(config.command, [...config.args ?? []], {
+          cwd: config.cwd,
+          env: config.env ? { ...process.env, ...config.env } : void 0,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const managed = new ManagedProcess(child, config, this.sendToMain);
+        this.processes.set(child.pid, managed);
+        this.sendToMain({
+          type: "SUB_PROCESS_SPAWNED",
+          pid: child.pid,
+          name: config.name,
+          command: config.command
+        });
+        child.on("exit", (code) => {
+          this.sendToMain({
+            type: "SUB_PROCESS_EXITED",
+            pid: child.pid,
+            code
+          });
+          if (config.autoRestart && managed.restartCount < (config.maxRestarts ?? 3)) {
+            managed.restartCount++;
+            setTimeout(() => {
+              this.spawn(config).catch(() => {
+              });
+            }, 2e3);
+          }
+        });
+        return managed;
+      }
+      listProcesses() {
+        return [...this.processes.values()].map((p) => p.toInfo());
+      }
+      getWorkerStats() {
+        const mem = process.memoryUsage();
+        const cpu = process.cpuUsage();
+        return {
+          pid: process.pid,
+          cpuPercent: (cpu.user + cpu.system) / 1e6,
+          memoryRss: mem.rss,
+          heapUsed: mem.heapUsed,
+          uptimeSeconds: Math.round(process.uptime()),
+          restartCount: 0,
+          state: "running"
+        };
+      }
+      async killAll() {
+        for (const [, proc] of this.processes) {
+          proc.kill("SIGTERM");
+        }
+        this.processes.clear();
+      }
+    };
+    exports2.WorkerProcessManager = WorkerProcessManager2;
+    var ManagedProcess = class {
+      child;
+      config;
+      sendToMain;
+      pid;
+      name;
+      restartCount = 0;
+      startedAt = Date.now();
+      exitHandlers = [];
+      errorHandlers = [];
+      constructor(child, config, sendToMain) {
+        this.child = child;
+        this.config = config;
+        this.sendToMain = sendToMain;
+        this.pid = child.pid;
+        this.name = config.name;
+        child.on("exit", (code) => {
+          for (const handler of this.exitHandlers)
+            handler(code);
+        });
+        child.on("error", (err) => {
+          for (const handler of this.errorHandlers)
+            handler(err);
+        });
+      }
+      getStats() {
+        return {
+          pid: this.pid,
+          cpuPercent: 0,
+          memoryRss: 0,
+          uptimeSeconds: Math.round((Date.now() - this.startedAt) / 1e3),
+          restartCount: this.restartCount,
+          state: this.child.exitCode !== null ? "stopped" : "running"
+        };
+      }
+      write(data) {
+        this.child.stdin?.write(data);
+      }
+      get stdout() {
+        return this.child.stdout;
+      }
+      get stderr() {
+        return this.child.stderr;
+      }
+      kill(signal = "SIGTERM") {
+        this.child.kill(signal);
+      }
+      wait() {
+        if (this.child.exitCode !== null) {
+          return Promise.resolve({ code: this.child.exitCode, signal: null });
+        }
+        return new Promise((resolve2) => {
+          this.child.on("exit", (code, signal) => {
+            resolve2({ code, signal });
+          });
+        });
+      }
+      onExit(handler) {
+        this.exitHandlers.push(handler);
+      }
+      onError(handler) {
+        this.errorHandlers.push(handler);
+      }
+      toInfo() {
+        return {
+          pid: this.pid,
+          name: this.name,
+          command: this.config.command,
+          state: this.child.exitCode !== null ? "stopped" : "running",
+          cpuPercent: 0,
+          memoryRss: 0,
+          uptimeSeconds: Math.round((Date.now() - this.startedAt) / 1e3)
+        };
+      }
+    };
   }
-}
-function stripCamstackDeps(pkg) {
-  const result = { ...pkg };
-  for (const depType of ["dependencies", "peerDependencies", "devDependencies"]) {
-    const deps = result[depType];
-    if (deps) {
-      const filtered = {};
-      for (const [name, version] of Object.entries(deps)) {
-        if (!name.startsWith("@camstack/")) {
-          filtered[name] = version;
+});
+
+// src/fs-utils.js
+var require_fs_utils = __commonJS({
+  "src/fs-utils.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ensureDir = ensureDir;
+    exports2.copyDirRecursive = copyDirRecursive;
+    exports2.stripCamstackDeps = stripCamstackDeps;
+    exports2.copyExtraFileDirs = copyExtraFileDirs;
+    exports2.symlinkAddonsToNodeModules = symlinkAddonsToNodeModules;
+    exports2.isSourceNewer = isSourceNewer;
+    exports2.ensureLibraryBuilt = ensureLibraryBuilt;
+    exports2.installPackageFromNpmSync = installPackageFromNpmSync;
+    var node_child_process_1 = require("child_process");
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    function ensureDir(dirPath) {
+      fs2.mkdirSync(dirPath, { recursive: true });
+    }
+    function copyDirRecursive(src, dest) {
+      ensureDir(dest);
+      const entries = fs2.readdirSync(src, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = path2.join(src, entry.name);
+        const destPath = path2.join(dest, entry.name);
+        if (entry.isDirectory()) {
+          copyDirRecursive(srcPath, destPath);
+        } else {
+          fs2.copyFileSync(srcPath, destPath);
         }
       }
-      result[depType] = Object.keys(filtered).length > 0 ? filtered : void 0;
     }
-  }
-  delete result.devDependencies;
-  return result;
-}
-function copyExtraFileDirs(pkgJson, sourceDir, destDir) {
-  const files = pkgJson.files;
-  if (!files) return;
-  for (const fileEntry of files) {
-    if (fileEntry === "dist" || fileEntry.includes("*")) continue;
-    const srcPath = path.join(sourceDir, fileEntry);
-    if (!fs.existsSync(srcPath)) continue;
-    const destPath = path.join(destDir, fileEntry);
-    const stat = fs.statSync(srcPath);
-    if (stat.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else if (stat.isFile()) {
-      ensureDir(path.dirname(destPath));
-      fs.copyFileSync(srcPath, destPath);
+    function stripCamstackDeps(pkg) {
+      const result = { ...pkg };
+      for (const depType of ["dependencies", "peerDependencies", "devDependencies"]) {
+        const deps = result[depType];
+        if (deps) {
+          const filtered = {};
+          for (const [name, version] of Object.entries(deps)) {
+            if (!name.startsWith("@camstack/")) {
+              filtered[name] = version;
+            }
+          }
+          result[depType] = Object.keys(filtered).length > 0 ? filtered : void 0;
+        }
+      }
+      delete result.devDependencies;
+      return result;
     }
-  }
-}
-function isSourceNewer(packageDir) {
-  const srcDir = path.join(packageDir, "src");
-  const distDir = path.join(packageDir, "dist");
-  if (!fs.existsSync(srcDir) || !fs.existsSync(distDir)) return true;
-  try {
-    const distMtime = fs.statSync(distDir).mtimeMs;
-    const entries = fs.readdirSync(srcDir, { withFileTypes: true, recursive: true });
-    for (const entry of entries) {
-      if (!entry.isFile()) continue;
-      const filePath = path.join(entry.parentPath ?? entry.path, entry.name);
-      if (fs.statSync(filePath).mtimeMs > distMtime) return true;
+    function copyExtraFileDirs(pkgJson, sourceDir, destDir) {
+      const files = pkgJson.files;
+      if (!files)
+        return;
+      for (const fileEntry of files) {
+        if (fileEntry === "dist" || fileEntry.includes("*"))
+          continue;
+        const srcPath = path2.join(sourceDir, fileEntry);
+        if (!fs2.existsSync(srcPath))
+          continue;
+        const destPath = path2.join(destDir, fileEntry);
+        const stat = fs2.statSync(srcPath);
+        if (stat.isDirectory()) {
+          copyDirRecursive(srcPath, destPath);
+        } else if (stat.isFile()) {
+          ensureDir(path2.dirname(destPath));
+          fs2.copyFileSync(srcPath, destPath);
+        }
+      }
+    }
+    function symlinkAddonsToNodeModules(addonsDir, nodeModulesDir) {
+      const camstackDir = path2.join(nodeModulesDir, "@camstack");
+      ensureDir(camstackDir);
+      const packagesToLink = ["core"];
+      for (const pkg of packagesToLink) {
+        const addonDir = path2.join(addonsDir, "@camstack", pkg);
+        const linkPath = path2.join(camstackDir, pkg);
+        if (!fs2.existsSync(addonDir))
+          continue;
+        try {
+          const stat = fs2.lstatSync(linkPath);
+          if (stat.isSymbolicLink() || stat.isDirectory()) {
+            fs2.rmSync(linkPath, { recursive: true, force: true });
+          }
+        } catch {
+        }
+        fs2.symlinkSync(addonDir, linkPath, "dir");
+        console.log(`[symlink] node_modules/@camstack/${pkg} -> ${addonDir}`);
+      }
+    }
+    function isSourceNewer(packageDir) {
+      const srcDir = path2.join(packageDir, "src");
+      const distDir = path2.join(packageDir, "dist");
+      if (!fs2.existsSync(srcDir) || !fs2.existsSync(distDir))
+        return true;
+      try {
+        const distMtime = fs2.statSync(distDir).mtimeMs;
+        const entries = fs2.readdirSync(srcDir, { withFileTypes: true, recursive: true });
+        for (const entry of entries) {
+          if (!entry.isFile())
+            continue;
+          const filePath = path2.join(entry.parentPath ?? entry.path, entry.name);
+          if (fs2.statSync(filePath).mtimeMs > distMtime)
+            return true;
+        }
+        return false;
+      } catch {
+        return true;
+      }
+    }
+    function ensureLibraryBuilt(packageName, packagesDir) {
+      const dirName = packageName.replace("@camstack/", "");
+      const sourceDir = path2.join(packagesDir, dirName);
+      if (!fs2.existsSync(sourceDir))
+        return;
+      const distDir = path2.join(sourceDir, "dist");
+      const hasIndex = fs2.existsSync(path2.join(distDir, "index.js")) || fs2.existsSync(path2.join(distDir, "index.mjs"));
+      if (hasIndex)
+        return;
+      console.warn(`[ensureLibraryBuilt] ${packageName} has no dist/ \u2014 run 'npm run build' first`);
+    }
+    function installPackageFromNpmSync(packageName, targetDir) {
+      const os2 = require("os");
+      const tmpDir = fs2.mkdtempSync(path2.join(os2.tmpdir(), "camstack-install-"));
+      try {
+        const stdout = (0, node_child_process_1.execFileSync)("npm", ["pack", packageName, "--pack-destination", tmpDir], {
+          timeout: 12e4,
+          encoding: "utf-8"
+        });
+        const tgzFilename = stdout.trim().split("\n").pop()?.trim();
+        if (!tgzFilename)
+          throw new Error("npm pack produced no output");
+        const tgzPath = path2.join(tmpDir, tgzFilename);
+        const extractDir = path2.join(tmpDir, "extracted");
+        ensureDir(extractDir);
+        (0, node_child_process_1.execFileSync)("tar", ["-xzf", tgzPath, "-C", extractDir], { timeout: 3e4 });
+        const packageSubDir = path2.join(extractDir, "package");
+        const srcPkgJsonDir = fs2.existsSync(path2.join(packageSubDir, "package.json")) ? packageSubDir : extractDir;
+        fs2.rmSync(targetDir, { recursive: true, force: true });
+        ensureDir(targetDir);
+        fs2.copyFileSync(path2.join(srcPkgJsonDir, "package.json"), path2.join(targetDir, "package.json"));
+        const distSrc = path2.join(srcPkgJsonDir, "dist");
+        if (fs2.existsSync(distSrc)) {
+          copyDirRecursive(distSrc, path2.join(targetDir, "dist"));
+        }
+        try {
+          const npmPkg = JSON.parse(fs2.readFileSync(path2.join(srcPkgJsonDir, "package.json"), "utf-8"));
+          copyExtraFileDirs(npmPkg, srcPkgJsonDir, targetDir);
+        } catch {
+        }
+      } finally {
+        fs2.rmSync(tmpDir, { recursive: true, force: true });
+      }
     }
-    return false;
-  } catch {
-    return true;
-  }
-}
-function ensureLibraryBuilt(packageName, packagesDir) {
-  const dirName = packageName.replace("@camstack/", "");
-  const sourceDir = path.join(packagesDir, dirName);
-  if (!fs.existsSync(sourceDir)) return;
-  const distDir = path.join(sourceDir, "dist");
-  const hasIndex = fs.existsSync(path.join(distDir, "index.js")) || fs.existsSync(path.join(distDir, "index.mjs"));
-  if (hasIndex) return;
-  console.warn(`[ensureLibraryBuilt] ${packageName} has no dist/ \u2014 run 'npm run build' first`);
-}
-var import_node_child_process2, fs, path;
-var init_fs_utils = __esm({
-  "src/fs-utils.ts"() {
-    "use strict";
-    import_node_child_process2 = require("child_process");
-    fs = __toESM(require("fs"));
-    path = __toESM(require("path"));
   }
 });
 
-// src/addon-installer.ts
-var addon_installer_exports = {};
-__export(addon_installer_exports, {
-  AddonInstaller: () => AddonInstaller
-});
-var import_node_child_process3, import_node_util, fs2, path2, os, execFileAsync, AddonInstaller;
-var init_addon_installer = __esm({
-  "src/addon-installer.ts"() {
+// src/addon-installer.js
+var require_addon_installer = __commonJS({
+  "src/addon-installer.js"(exports2) {
     "use strict";
-    import_node_child_process3 = require("child_process");
-    import_node_util = require("util");
-    fs2 = __toESM(require("fs"));
-    path2 = __toESM(require("path"));
-    os = __toESM(require("os"));
-    init_fs_utils();
-    execFileAsync = (0, import_node_util.promisify)(import_node_child_process3.execFile);
-    AddonInstaller = class _AddonInstaller {
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AddonInstaller = void 0;
+    var node_child_process_1 = require("child_process");
+    var node_util_1 = require("util");
+    var fs2 = __importStar(require("fs"));
+    var path2 = __importStar(require("path"));
+    var os2 = __importStar(require("os"));
+    var fs_utils_js_1 = require_fs_utils();
+    var execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+    var AddonInstaller = class _AddonInstaller {
       addonsDir;
       registry;
       workspacePackagesDir;
@@ -154,33 +435,35 @@ var init_addon_installer = __esm({
       ];
       /** Ensure the addons directory exists */
       async initialize() {
-        ensureDir(this.addonsDir);
+        (0, fs_utils_js_1.ensureDir)(this.addonsDir);
       }
       /**
        * Ensure all required packages are installed in the addons directory.
        * This replaces the standalone first-boot-installer.ts.
        */
       async ensureRequiredPackages() {
-        ensureDir(this.addonsDir);
+        (0, fs_utils_js_1.ensureDir)(this.addonsDir);
         if (this.workspacePackagesDir) {
           console.log(`[AddonInstaller] Workspace detected: ${this.workspacePackagesDir}`);
-          ensureLibraryBuilt("@camstack/kernel", this.workspacePackagesDir);
-          ensureLibraryBuilt("@camstack/types", this.workspacePackagesDir);
+          (0, fs_utils_js_1.ensureLibraryBuilt)("@camstack/kernel", this.workspacePackagesDir);
+          (0, fs_utils_js_1.ensureLibraryBuilt)("@camstack/types", this.workspacePackagesDir);
         }
         for (const packageName of _AddonInstaller.REQUIRED_PACKAGES) {
           const addonDir = path2.join(this.addonsDir, packageName);
           const pkgJsonPath = path2.join(addonDir, "package.json");
+          const forceNpm = process.env["CAMSTACK_INSTALL_SOURCE"] === "npm";
+          const useWorkspace = this.workspacePackagesDir && !forceNpm;
           if (fs2.existsSync(pkgJsonPath)) {
-            if (!this.workspacePackagesDir) {
+            if (!useWorkspace) {
               continue;
             }
             const srcPkgDir = this.findWorkspacePackage(packageName);
-            if (srcPkgDir && !isSourceNewer(srcPkgDir)) {
+            if (srcPkgDir && !(0, fs_utils_js_1.isSourceNewer)(srcPkgDir)) {
               continue;
             }
           }
           try {
-            if (this.workspacePackagesDir) {
+            if (useWorkspace) {
               const pkgDir = this.findWorkspacePackage(packageName);
               if (pkgDir) {
                 await this.installFromWorkspace(packageName);
@@ -198,14 +481,16 @@ var init_addon_installer = __esm({
         }
       }
       findWorkspacePackage(packageName) {
-        if (!this.workspacePackagesDir) return null;
+        if (!this.workspacePackagesDir)
+          return null;
         const shortName = packageName.replace("@camstack/", "");
         for (const dirName of [shortName, `addon-${shortName}`, shortName.replace("addon-", "")]) {
           const candidate = path2.join(this.workspacePackagesDir, dirName);
           if (fs2.existsSync(path2.join(candidate, "package.json"))) {
             try {
               const pkg = JSON.parse(fs2.readFileSync(path2.join(candidate, "package.json"), "utf-8"));
-              if (pkg.name === packageName) return candidate;
+              if (pkg.name === packageName)
+                return candidate;
             } catch {
             }
           }
@@ -214,7 +499,7 @@ var init_addon_installer = __esm({
       }
       /** Install addon from a tgz file (uploaded or downloaded) */
       async installFromTgz(tgzPath) {
-        const tmpDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "camstack-addon-install-"));
+        const tmpDir = fs2.mkdtempSync(path2.join(os2.tmpdir(), "camstack-addon-install-"));
         try {
           await execFileAsync("tar", ["-xzf", tgzPath, "-C", tmpDir], { timeout: 3e4 });
           const extractedDir = path2.join(tmpDir, "package");
@@ -228,14 +513,14 @@ var init_addon_installer = __esm({
           }
           const targetDir = path2.join(this.addonsDir, pkgJson.name);
           fs2.rmSync(targetDir, { recursive: true, force: true });
-          ensureDir(targetDir);
+          (0, fs_utils_js_1.ensureDir)(targetDir);
           const sourceDir = path2.dirname(pkgJsonPath);
           fs2.copyFileSync(pkgJsonPath, path2.join(targetDir, "package.json"));
           const sourceDist = path2.join(sourceDir, "dist");
           if (fs2.existsSync(sourceDist)) {
-            copyDirRecursive(sourceDist, path2.join(targetDir, "dist"));
+            (0, fs_utils_js_1.copyDirRecursive)(sourceDist, path2.join(targetDir, "dist"));
           }
-          copyExtraFileDirs(pkgJson, sourceDir, targetDir);
+          (0, fs_utils_js_1.copyExtraFileDirs)(pkgJson, sourceDir, targetDir);
           return { name: pkgJson.name, version: pkgJson.version };
         } finally {
           fs2.rmSync(tmpDir, { recursive: true, force: true });
@@ -275,12 +560,12 @@ var init_addon_installer = __esm({
         }
         const targetDir = path2.join(this.addonsDir, packageName);
         fs2.rmSync(targetDir, { recursive: true, force: true });
-        ensureDir(targetDir);
+        (0, fs_utils_js_1.ensureDir)(targetDir);
         const pkgData = JSON.parse(fs2.readFileSync(sourcePkgJson, "utf-8"));
-        const strippedPkg = stripCamstackDeps(pkgData);
+        const strippedPkg = (0, fs_utils_js_1.stripCamstackDeps)(pkgData);
         fs2.writeFileSync(path2.join(targetDir, "package.json"), JSON.stringify(strippedPkg, null, 2));
-        copyDirRecursive(distDir, path2.join(targetDir, "dist"));
-        copyExtraFileDirs(pkgData, sourceDir, targetDir);
+        (0, fs_utils_js_1.copyDirRecursive)(distDir, path2.join(targetDir, "dist"));
+        (0, fs_utils_js_1.copyExtraFileDirs)(pkgData, sourceDir, targetDir);
         try {
           await execFileAsync("npm", ["install", "--omit=dev", "--ignore-scripts=false"], {
             cwd: targetDir,
@@ -292,7 +577,7 @@ var init_addon_installer = __esm({
       }
       /** Install addon from npm (download tgz, then extract) */
       async installFromNpm(packageName, version) {
-        const tmpDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "camstack-addon-npm-"));
+        const tmpDir = fs2.mkdtempSync(path2.join(os2.tmpdir(), "camstack-addon-npm-"));
         const packageSpec = version ? `${packageName}@${version}` : packageName;
         const args = ["pack", packageSpec, "--pack-destination", tmpDir];
         if (this.registry) {
@@ -327,13 +612,16 @@ var init_addon_installer = __esm({
       }
       /** List installed addons (directories with package.json containing camstack.addons) */
       listInstalled() {
-        if (!fs2.existsSync(this.addonsDir)) return [];
+        if (!fs2.existsSync(this.addonsDir))
+          return [];
         return fs2.readdirSync(this.addonsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
           const pkgPath = path2.join(this.addonsDir, d.name, "package.json");
-          if (!fs2.existsSync(pkgPath)) return null;
+          if (!fs2.existsSync(pkgPath))
+            return null;
           try {
             const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
-            if (!pkg.camstack?.addons) return null;
+            if (!pkg.camstack?.addons)
+              return null;
             return { name: pkg.name, version: pkg.version, dir: path2.join(this.addonsDir, d.name) };
           } catch {
             return null;
@@ -342,7 +630,8 @@ var init_addon_installer = __esm({
       }
       /** Check if an addon is installed */
       isInstalled(packageName) {
-        if (fs2.existsSync(path2.join(this.addonsDir, packageName, "package.json"))) return true;
+        if (fs2.existsSync(path2.join(this.addonsDir, packageName, "package.json")))
+          return true;
         const legacy = packageName.replace(/^@[^/]+\//, "");
         return fs2.existsSync(path2.join(this.addonsDir, legacy, "package.json"));
       }
@@ -352,7 +641,8 @@ var init_addon_installer = __esm({
         if (!fs2.existsSync(pkgPath)) {
           pkgPath = path2.join(this.addonsDir, packageName.replace(/^@[^/]+\//, ""), "package.json");
         }
-        if (!fs2.existsSync(pkgPath)) return null;
+        if (!fs2.existsSync(pkgPath))
+          return null;
         try {
           const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
           return { name: pkg.name, version: pkg.version, dir: path2.dirname(pkgPath) };
@@ -361,146 +651,15 @@ var init_addon_installer = __esm({
         }
       }
     };
+    exports2.AddonInstaller = AddonInstaller;
   }
 });
 
 // src/worker/addon-worker-entry.ts
-var os2 = __toESM(require("os"));
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
-
-// src/worker/worker-process-manager.ts
-var import_node_child_process = require("child_process");
-var WorkerProcessManager = class {
-  constructor(sendToMain) {
-    this.sendToMain = sendToMain;
-  }
-  processes = /* @__PURE__ */ new Map();
-  async spawn(config) {
-    const child = (0, import_node_child_process.spawn)(config.command, [...config.args ?? []], {
-      cwd: config.cwd,
-      env: config.env ? { ...process.env, ...config.env } : void 0,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const managed = new ManagedProcess(child, config, this.sendToMain);
-    this.processes.set(child.pid, managed);
-    this.sendToMain({
-      type: "SUB_PROCESS_SPAWNED",
-      pid: child.pid,
-      name: config.name,
-      command: config.command
-    });
-    child.on("exit", (code) => {
-      this.sendToMain({
-        type: "SUB_PROCESS_EXITED",
-        pid: child.pid,
-        code
-      });
-      if (config.autoRestart && managed.restartCount < (config.maxRestarts ?? 3)) {
-        managed.restartCount++;
-        setTimeout(() => {
-          this.spawn(config).catch(() => {
-          });
-        }, 2e3);
-      }
-    });
-    return managed;
-  }
-  listProcesses() {
-    return [...this.processes.values()].map((p) => p.toInfo());
-  }
-  getWorkerStats() {
-    const mem = process.memoryUsage();
-    const cpu = process.cpuUsage();
-    return {
-      pid: process.pid,
-      cpuPercent: (cpu.user + cpu.system) / 1e6,
-      memoryRss: mem.rss,
-      heapUsed: mem.heapUsed,
-      uptimeSeconds: Math.round(process.uptime()),
-      restartCount: 0,
-      state: "running"
-    };
-  }
-  async killAll() {
-    for (const [, proc] of this.processes) {
-      proc.kill("SIGTERM");
-    }
-    this.processes.clear();
-  }
-};
-var ManagedProcess = class {
-  constructor(child, config, sendToMain) {
-    this.child = child;
-    this.config = config;
-    this.sendToMain = sendToMain;
-    this.pid = child.pid;
-    this.name = config.name;
-    child.on("exit", (code) => {
-      for (const handler of this.exitHandlers) handler(code);
-    });
-    child.on("error", (err) => {
-      for (const handler of this.errorHandlers) handler(err);
-    });
-  }
-  pid;
-  name;
-  restartCount = 0;
-  startedAt = Date.now();
-  exitHandlers = [];
-  errorHandlers = [];
-  getStats() {
-    return {
-      pid: this.pid,
-      cpuPercent: 0,
-      memoryRss: 0,
-      uptimeSeconds: Math.round((Date.now() - this.startedAt) / 1e3),
-      restartCount: this.restartCount,
-      state: this.child.exitCode !== null ? "stopped" : "running"
-    };
-  }
-  write(data) {
-    this.child.stdin?.write(data);
-  }
-  get stdout() {
-    return this.child.stdout;
-  }
-  get stderr() {
-    return this.child.stderr;
-  }
-  kill(signal = "SIGTERM") {
-    this.child.kill(signal);
-  }
-  wait() {
-    if (this.child.exitCode !== null) {
-      return Promise.resolve({ code: this.child.exitCode, signal: null });
-    }
-    return new Promise((resolve2) => {
-      this.child.on("exit", (code, signal) => {
-        resolve2({ code, signal });
-      });
-    });
-  }
-  onExit(handler) {
-    this.exitHandlers.push(handler);
-  }
-  onError(handler) {
-    this.errorHandlers.push(handler);
-  }
-  toInfo() {
-    return {
-      pid: this.pid,
-      name: this.name,
-      command: this.config.command,
-      state: this.child.exitCode !== null ? "stopped" : "running",
-      cpuPercent: 0,
-      memoryRss: 0,
-      uptimeSeconds: Math.round((Date.now() - this.startedAt) / 1e3)
-    };
-  }
-};
-
-// src/worker/addon-worker-entry.ts
+var os = __toESM(require("os"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_worker_process_manager = __toESM(require_worker_process_manager());
 async function boot() {
   const hubUrl = process.env.CAMSTACK_WORKER_HUB_URL;
   const token = process.env.CAMSTACK_WORKER_TOKEN ?? "";
@@ -528,14 +687,14 @@ async function boot() {
       id: workerId,
       name: addonId,
       capabilities: [],
-      platform: os2.platform(),
-      arch: os2.arch(),
-      cpuCores: os2.cpus().length,
-      memoryMB: Math.round(os2.totalmem() / 1024 / 1024),
+      platform: os.platform(),
+      arch: os.arch(),
+      cpuCores: os.cpus().length,
+      memoryMB: Math.round(os.totalmem() / 1024 / 1024),
       pythonRuntimes: [],
       installedAddons: [addonId],
       taskTypes: [],
-      host: os2.hostname(),
+      host: os.hostname(),
       port: 0,
       httpPort: 0
     });
@@ -565,10 +724,10 @@ async function boot() {
     };
   }
   const logger = createScopedLogger([addonId]);
-  const processManager = new WorkerProcessManager(() => {
+  const processManager = new import_worker_process_manager.WorkerProcessManager(() => {
   });
-  const pkgJsonPath = path3.join(addonDir, "package.json");
-  const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+  const pkgJsonPath = path.join(addonDir, "package.json");
+  const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
   const manifest = pkgJson.camstack;
   if (!manifest?.addons?.length) {
     console.error(`[worker:${addonId}] No camstack addon manifest in ${pkgJsonPath}`);
@@ -580,10 +739,10 @@ async function boot() {
     process.exit(1);
   }
   const entryFile = declaration.entry.replace(/^\.\//, "").replace(/^src\//, "dist/").replace(/\.ts$/, ".js");
-  let entryPath = path3.resolve(addonDir, entryFile);
-  if (!fs3.existsSync(entryPath)) {
+  let entryPath = path.resolve(addonDir, entryFile);
+  if (!fs.existsSync(entryPath)) {
     const cjsPath = entryPath.replace(/\.js$/, ".cjs");
-    if (fs3.existsSync(cjsPath)) entryPath = cjsPath;
+    if (fs.existsSync(cjsPath)) entryPath = cjsPath;
   }
   const mod = await import(entryPath);
   const firstKey = Object.keys(mod)[0];
@@ -640,8 +799,8 @@ async function boot() {
         try {
           let result;
           if (task.taskType === "addon.install") {
-            const { AddonInstaller: AddonInstaller2 } = await Promise.resolve().then(() => (init_addon_installer(), addon_installer_exports));
-            const installer = new AddonInstaller2({ addonsDir: path3.dirname(addonDir) });
+            const { AddonInstaller } = await Promise.resolve().then(() => __toESM(require_addon_installer()));
+            const installer = new AddonInstaller({ addonsDir: path.dirname(addonDir) });
             const payload = task.payload;
             result = await installer.installFromNpm(payload.package, payload.version);
           } else if (typeof addon.handleTask === "function") {