@camstack/kernel 0.1.6 → 0.1.9

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

@@ -5,8 +5,12 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+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 __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -25,395 +29,111 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// 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)
-        };
-      }
-    };
-  }
-});
-
-// 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);
-        }
-      }
-    }
-    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 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}`);
-      }
+// 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);
     }
-    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;
+  }
+}
+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;
         }
-        return false;
-      } catch {
-        return true;
       }
+      result[depType] = Object.keys(filtered).length > 0 ? filtered : void 0;
     }
-    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`);
+  }
+  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 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 });
-      }
+  }
+}
+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;
     }
+    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, os, path;
+var init_fs_utils = __esm({
+  "src/fs-utils.ts"() {
+    "use strict";
+    import_node_child_process2 = require("child_process");
+    fs = __toESM(require("fs"));
+    os = __toESM(require("os"));
+    path = __toESM(require("path"));
   }
 });
 
-// src/addon-installer.js
-var require_addon_installer = __commonJS({
-  "src/addon-installer.js"(exports2) {
+// src/addon-installer.ts
+var addon_installer_exports = {};
+__export(addon_installer_exports, {
+  AddonInstaller: () => AddonInstaller
+});
+var import_node_child_process3, import_node_util, fs2, path2, os2, execFileAsync, AddonInstaller;
+var init_addon_installer = __esm({
+  "src/addon-installer.ts"() {
     "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.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 {
+    import_node_child_process3 = require("child_process");
+    import_node_util = require("util");
+    fs2 = __toESM(require("fs"));
+    path2 = __toESM(require("path"));
+    os2 = __toESM(require("os"));
+    init_fs_utils();
+    execFileAsync = (0, import_node_util.promisify)(import_node_child_process3.execFile);
+    AddonInstaller = class _AddonInstaller {
       addonsDir;
       registry;
       workspacePackagesDir;
@@ -425,28 +145,29 @@ var require_addon_installer = __commonJS({
       /** Required addon packages that must be installed for the server to function */
       static REQUIRED_PACKAGES = [
         "@camstack/core",
-        "@camstack/addon-pipeline",
+        "@camstack/addon-stream-broker",
+        "@camstack/addon-recording",
         "@camstack/addon-vision",
         "@camstack/addon-admin-ui",
         "@camstack/addon-webrtc-adaptive",
-        "@camstack/addon-pipeline-analysis",
+        "@camstack/addon-analytics",
         "@camstack/addon-scene-intelligence",
         "@camstack/addon-advanced-notifier"
       ];
       /** Ensure the addons directory exists */
       async initialize() {
-        (0, fs_utils_js_1.ensureDir)(this.addonsDir);
+        ensureDir(this.addonsDir);
       }
       /**
        * Ensure all required packages are installed in the addons directory.
        * This replaces the standalone first-boot-installer.ts.
        */
       async ensureRequiredPackages() {
-        (0, fs_utils_js_1.ensureDir)(this.addonsDir);
+        ensureDir(this.addonsDir);
         if (this.workspacePackagesDir) {
           console.log(`[AddonInstaller] Workspace detected: ${this.workspacePackagesDir}`);
-          (0, fs_utils_js_1.ensureLibraryBuilt)("@camstack/kernel", this.workspacePackagesDir);
-          (0, fs_utils_js_1.ensureLibraryBuilt)("@camstack/types", this.workspacePackagesDir);
+          ensureLibraryBuilt("@camstack/kernel", this.workspacePackagesDir);
+          ensureLibraryBuilt("@camstack/types", this.workspacePackagesDir);
         }
         for (const packageName of _AddonInstaller.REQUIRED_PACKAGES) {
           const addonDir = path2.join(this.addonsDir, packageName);
@@ -455,10 +176,12 @@ var require_addon_installer = __commonJS({
           const useWorkspace = this.workspacePackagesDir && !forceNpm;
           if (fs2.existsSync(pkgJsonPath)) {
             if (!useWorkspace) {
+              console.log(`[AddonInstaller] ${packageName} \u2014 already installed (npm), skipping`);
               continue;
             }
             const srcPkgDir = this.findWorkspacePackage(packageName);
-            if (srcPkgDir && !(0, fs_utils_js_1.isSourceNewer)(srcPkgDir)) {
+            if (srcPkgDir && !isSourceNewer(srcPkgDir)) {
+              console.log(`[AddonInstaller] ${packageName} \u2014 workspace up-to-date, skipping`);
               continue;
             }
           }
@@ -466,10 +189,12 @@ var require_addon_installer = __commonJS({
             if (useWorkspace) {
               const pkgDir = this.findWorkspacePackage(packageName);
               if (pkgDir) {
+                console.log(`[AddonInstaller] ${packageName} \u2014 installing from workspace`);
                 await this.installFromWorkspace(packageName);
                 continue;
               }
             }
+            console.log(`[AddonInstaller] ${packageName} \u2014 installing from npm`);
             await this.installFromNpm(packageName);
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -481,16 +206,14 @@ var require_addon_installer = __commonJS({
         }
       }
       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 {
             }
           }
@@ -513,14 +236,14 @@ var require_addon_installer = __commonJS({
           }
           const targetDir = path2.join(this.addonsDir, pkgJson.name);
           fs2.rmSync(targetDir, { recursive: true, force: true });
-          (0, fs_utils_js_1.ensureDir)(targetDir);
+          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)) {
-            (0, fs_utils_js_1.copyDirRecursive)(sourceDist, path2.join(targetDir, "dist"));
+            copyDirRecursive(sourceDist, path2.join(targetDir, "dist"));
           }
-          (0, fs_utils_js_1.copyExtraFileDirs)(pkgJson, sourceDir, targetDir);
+          copyExtraFileDirs(pkgJson, sourceDir, targetDir);
           return { name: pkgJson.name, version: pkgJson.version };
         } finally {
           fs2.rmSync(tmpDir, { recursive: true, force: true });
@@ -560,12 +283,13 @@ var require_addon_installer = __commonJS({
         }
         const targetDir = path2.join(this.addonsDir, packageName);
         fs2.rmSync(targetDir, { recursive: true, force: true });
-        (0, fs_utils_js_1.ensureDir)(targetDir);
+        ensureDir(targetDir);
         const pkgData = JSON.parse(fs2.readFileSync(sourcePkgJson, "utf-8"));
-        const strippedPkg = (0, fs_utils_js_1.stripCamstackDeps)(pkgData);
+        const strippedPkg = stripCamstackDeps(pkgData);
         fs2.writeFileSync(path2.join(targetDir, "package.json"), JSON.stringify(strippedPkg, null, 2));
-        (0, fs_utils_js_1.copyDirRecursive)(distDir, path2.join(targetDir, "dist"));
-        (0, fs_utils_js_1.copyExtraFileDirs)(pkgData, sourceDir, targetDir);
+        copyDirRecursive(distDir, path2.join(targetDir, "dist"));
+        copyExtraFileDirs(pkgData, sourceDir, targetDir);
+        fs2.writeFileSync(path2.join(targetDir, ".install-source"), "workspace");
         try {
           await execFileAsync("npm", ["install", "--omit=dev", "--ignore-scripts=false"], {
             cwd: targetDir,
@@ -583,16 +307,21 @@ var require_addon_installer = __commonJS({
         if (this.registry) {
           args.push("--registry", this.registry);
         }
+        console.log(`[AddonInstaller] npm pack ${packageSpec} \u2192 ${tmpDir}`);
         try {
           const { stdout } = await execFileAsync("npm", args, {
             timeout: 12e4
           });
           const tgzFiles = fs2.readdirSync(tmpDir).filter((f) => f.endsWith(".tgz"));
+          console.log(`[AddonInstaller] npm pack stdout: ${stdout.trim()}, tgzFiles: ${tgzFiles.join(", ")}`);
           if (tgzFiles.length === 0) {
             throw new Error(`npm pack produced no tgz file for ${packageSpec}. stdout: ${stdout.trim()}`);
           }
           const tgzPath = path2.join(tmpDir, tgzFiles[0]);
           const result = await this.installFromTgz(tgzPath);
+          console.log(`[AddonInstaller] installFromTgz result: ${result.name}@${result.version} \u2192 ${path2.join(this.addonsDir, result.name)}`);
+          const targetDir = path2.join(this.addonsDir, result.name);
+          fs2.writeFileSync(path2.join(targetDir, ".install-source"), "npm");
           return result;
         } finally {
           fs2.rmSync(tmpDir, { recursive: true, force: true });
@@ -612,17 +341,29 @@ var require_addon_installer = __commonJS({
       }
       /** List installed addons (directories with package.json containing camstack.addons) */
       listInstalled() {
-        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(this.addonsDir)) return [];
+        const packageDirs = [];
+        for (const entry of fs2.readdirSync(this.addonsDir, { withFileTypes: true })) {
+          if (!entry.isDirectory()) continue;
+          if (entry.name.startsWith("@")) {
+            const scopeDir = path2.join(this.addonsDir, entry.name);
+            for (const inner of fs2.readdirSync(scopeDir, { withFileTypes: true })) {
+              if (inner.isDirectory()) packageDirs.push(path2.join(scopeDir, inner.name));
+            }
+          } else {
+            packageDirs.push(path2.join(this.addonsDir, entry.name));
+          }
+        }
+        return packageDirs.map((dir) => {
+          const pkgPath = path2.join(dir, "package.json");
+          if (!fs2.existsSync(pkgPath)) return null;
           try {
             const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
-            if (!pkg.camstack?.addons)
-              return null;
-            return { name: pkg.name, version: pkg.version, dir: path2.join(this.addonsDir, d.name) };
+            if (!pkg.camstack?.addons) return null;
+            const sourceFile = path2.join(dir, ".install-source");
+            const installSource = fs2.existsSync(sourceFile) ? fs2.readFileSync(sourceFile, "utf-8").trim() : void 0;
+            const result = { name: pkg.name, version: pkg.version, dir, ...installSource ? { installSource } : {} };
+            return result;
           } catch {
             return null;
           }
@@ -630,8 +371,7 @@ var require_addon_installer = __commonJS({
       }
       /** 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"));
       }
@@ -641,8 +381,7 @@ var require_addon_installer = __commonJS({
         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) };
@@ -651,15 +390,146 @@ var require_addon_installer = __commonJS({
         }
       }
     };
-    exports2.AddonInstaller = AddonInstaller;
   }
 });
 
 // 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());
+var os3 = __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
 async function boot() {
   const hubUrl = process.env.CAMSTACK_WORKER_HUB_URL;
   const token = process.env.CAMSTACK_WORKER_TOKEN ?? "";
@@ -687,14 +557,14 @@ async function boot() {
       id: workerId,
       name: addonId,
       capabilities: [],
-      platform: os.platform(),
-      arch: os.arch(),
-      cpuCores: os.cpus().length,
-      memoryMB: Math.round(os.totalmem() / 1024 / 1024),
+      platform: os3.platform(),
+      arch: os3.arch(),
+      cpuCores: os3.cpus().length,
+      memoryMB: Math.round(os3.totalmem() / 1024 / 1024),
       pythonRuntimes: [],
       installedAddons: [addonId],
       taskTypes: [],
-      host: os.hostname(),
+      host: os3.hostname(),
       port: 0,
       httpPort: 0
     });
@@ -724,10 +594,10 @@ async function boot() {
     };
   }
   const logger = createScopedLogger([addonId]);
-  const processManager = new import_worker_process_manager.WorkerProcessManager(() => {
+  const processManager = new WorkerProcessManager(() => {
   });
-  const pkgJsonPath = path.join(addonDir, "package.json");
-  const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+  const pkgJsonPath = path3.join(addonDir, "package.json");
+  const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
   const manifest = pkgJson.camstack;
   if (!manifest?.addons?.length) {
     console.error(`[worker:${addonId}] No camstack addon manifest in ${pkgJsonPath}`);
@@ -739,10 +609,10 @@ async function boot() {
     process.exit(1);
   }
   const entryFile = declaration.entry.replace(/^\.\//, "").replace(/^src\//, "dist/").replace(/\.ts$/, ".js");
-  let entryPath = path.resolve(addonDir, entryFile);
-  if (!fs.existsSync(entryPath)) {
+  let entryPath = path3.resolve(addonDir, entryFile);
+  if (!fs3.existsSync(entryPath)) {
     const cjsPath = entryPath.replace(/\.js$/, ".cjs");
-    if (fs.existsSync(cjsPath)) entryPath = cjsPath;
+    if (fs3.existsSync(cjsPath)) entryPath = cjsPath;
   }
   const mod = await import(entryPath);
   const firstKey = Object.keys(mod)[0];
@@ -799,8 +669,8 @@ async function boot() {
         try {
           let result;
           if (task.taskType === "addon.install") {
-            const { AddonInstaller } = await Promise.resolve().then(() => __toESM(require_addon_installer()));
-            const installer = new AddonInstaller({ addonsDir: path.dirname(addonDir) });
+            const { AddonInstaller: AddonInstaller2 } = await Promise.resolve().then(() => (init_addon_installer(), addon_installer_exports));
+            const installer = new AddonInstaller2({ addonsDir: path3.dirname(addonDir) });
             const payload = task.payload;
             result = await installer.installFromNpm(payload.package, payload.version);
           } else if (typeof addon.handleTask === "function") {