@camstack/kernel 0.1.1

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

@@ -0,0 +1,688 @@
+"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 __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") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// 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 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 = 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 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, 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"() {
+    "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 {
+      addonsDir;
+      registry;
+      workspacePackagesDir;
+      constructor(config) {
+        this.addonsDir = config.addonsDir;
+        this.registry = config.registry;
+        this.workspacePackagesDir = config.workspacePackagesDir;
+      }
+      /** Required addon packages that must be installed for the server to function */
+      static REQUIRED_PACKAGES = [
+        "@camstack/core",
+        "@camstack/addon-pipeline",
+        "@camstack/addon-vision",
+        "@camstack/addon-admin-ui",
+        "@camstack/addon-webrtc-adaptive",
+        "@camstack/addon-pipeline-analysis",
+        "@camstack/addon-scene-intelligence",
+        "@camstack/addon-advanced-notifier"
+      ];
+      /** Ensure the addons directory exists */
+      async initialize() {
+        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);
+        if (this.workspacePackagesDir) {
+          console.log(`[AddonInstaller] Workspace detected: ${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);
+          const pkgJsonPath = path2.join(addonDir, "package.json");
+          if (fs2.existsSync(pkgJsonPath)) {
+            if (!this.workspacePackagesDir) {
+              continue;
+            }
+            const srcPkgDir = this.findWorkspacePackage(packageName);
+            if (srcPkgDir && !isSourceNewer(srcPkgDir)) {
+              continue;
+            }
+          }
+          try {
+            if (this.workspacePackagesDir) {
+              const pkgDir = this.findWorkspacePackage(packageName);
+              if (pkgDir) {
+                await this.installFromWorkspace(packageName);
+                continue;
+              }
+            }
+            await this.installFromNpm(packageName);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (packageName === "@camstack/core") {
+              throw new Error(`Required package ${packageName} failed to install: ${msg}`);
+            }
+            console.error(`[AddonInstaller] Failed to install ${packageName}: ${msg}`);
+          }
+        }
+      }
+      findWorkspacePackage(packageName) {
+        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;
+            } catch {
+            }
+          }
+        }
+        return null;
+      }
+      /** Install addon from a tgz file (uploaded or downloaded) */
+      async installFromTgz(tgzPath) {
+        const tmpDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "camstack-addon-install-"));
+        try {
+          await execFileAsync("tar", ["-xzf", tgzPath, "-C", tmpDir], { timeout: 3e4 });
+          const extractedDir = path2.join(tmpDir, "package");
+          const pkgJsonPath = fs2.existsSync(path2.join(extractedDir, "package.json")) ? path2.join(extractedDir, "package.json") : path2.join(tmpDir, "package.json");
+          if (!fs2.existsSync(pkgJsonPath)) {
+            throw new Error("No package.json found in tgz archive");
+          }
+          const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+          if (!pkgJson.camstack?.addons) {
+            throw new Error(`Package ${pkgJson.name} has no camstack.addons manifest`);
+          }
+          const targetDir = path2.join(this.addonsDir, pkgJson.name);
+          fs2.rmSync(targetDir, { recursive: true, force: true });
+          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"));
+          }
+          copyExtraFileDirs(pkgJson, sourceDir, targetDir);
+          return { name: pkgJson.name, version: pkgJson.version };
+        } finally {
+          fs2.rmSync(tmpDir, { recursive: true, force: true });
+        }
+      }
+      /**
+       * Install addon — prefers workspace if available, falls back to npm.
+       * This ensures dev builds (with vite output, etc.) are used when in workspace mode.
+       */
+      async install(packageName, version) {
+        if (this.workspacePackagesDir) {
+          const workspaceDirName = packageName.replace("@camstack/", "");
+          const sourceDir = path2.join(this.workspacePackagesDir, workspaceDirName);
+          if (fs2.existsSync(path2.join(sourceDir, "package.json"))) {
+            return this.installFromWorkspace(packageName);
+          }
+        }
+        return this.installFromNpm(packageName, version);
+      }
+      /**
+       * Install addon from workspace by copying package.json + dist/ to addons dir.
+       * Does NOT build — expects dist/ to already exist (run `npm run build` separately).
+       */
+      async installFromWorkspace(packageName) {
+        if (!this.workspacePackagesDir) {
+          throw new Error("Workspace packages directory not configured");
+        }
+        const workspaceDirName = packageName.replace("@camstack/", "");
+        const sourceDir = path2.join(this.workspacePackagesDir, workspaceDirName);
+        const sourcePkgJson = path2.join(sourceDir, "package.json");
+        if (!fs2.existsSync(sourcePkgJson)) {
+          throw new Error(`Workspace package not found: ${sourceDir}`);
+        }
+        const distDir = path2.join(sourceDir, "dist");
+        if (!fs2.existsSync(distDir)) {
+          throw new Error(`${packageName} has no dist/ directory \u2014 run 'npm run build' first`);
+        }
+        const targetDir = path2.join(this.addonsDir, packageName);
+        fs2.rmSync(targetDir, { recursive: true, force: true });
+        ensureDir(targetDir);
+        const pkgData = JSON.parse(fs2.readFileSync(sourcePkgJson, "utf-8"));
+        const strippedPkg = stripCamstackDeps(pkgData);
+        fs2.writeFileSync(path2.join(targetDir, "package.json"), JSON.stringify(strippedPkg, null, 2));
+        copyDirRecursive(distDir, path2.join(targetDir, "dist"));
+        copyExtraFileDirs(pkgData, sourceDir, targetDir);
+        try {
+          await execFileAsync("npm", ["install", "--omit=dev", "--ignore-scripts=false"], {
+            cwd: targetDir,
+            timeout: 12e4
+          });
+        } catch {
+        }
+        return { name: pkgData.name, version: pkgData.version };
+      }
+      /** Install addon from npm (download tgz, then extract) */
+      async installFromNpm(packageName, version) {
+        const tmpDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "camstack-addon-npm-"));
+        const packageSpec = version ? `${packageName}@${version}` : packageName;
+        const args = ["pack", packageSpec, "--pack-destination", tmpDir];
+        if (this.registry) {
+          args.push("--registry", this.registry);
+        }
+        try {
+          const { stdout } = await execFileAsync("npm", args, {
+            timeout: 12e4
+          });
+          const tgzFiles = fs2.readdirSync(tmpDir).filter((f) => f.endsWith(".tgz"));
+          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);
+          return result;
+        } finally {
+          fs2.rmSync(tmpDir, { recursive: true, force: true });
+        }
+      }
+      /** Uninstall addon (delete directory) */
+      async uninstall(packageName) {
+        const addonDir = path2.join(this.addonsDir, packageName);
+        if (fs2.existsSync(addonDir)) {
+          fs2.rmSync(addonDir, { recursive: true, force: true });
+          return;
+        }
+        const legacyDir = path2.join(this.addonsDir, packageName.replace(/^@[^/]+\//, ""));
+        if (fs2.existsSync(legacyDir)) {
+          fs2.rmSync(legacyDir, { recursive: true, force: true });
+        }
+      }
+      /** 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;
+          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) };
+          } catch {
+            return null;
+          }
+        }).filter((item) => item !== null);
+      }
+      /** Check if an addon is installed */
+      isInstalled(packageName) {
+        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"));
+      }
+      /** Get installed package info */
+      getInstalledPackage(packageName) {
+        let pkgPath = path2.join(this.addonsDir, packageName, "package.json");
+        if (!fs2.existsSync(pkgPath)) {
+          pkgPath = path2.join(this.addonsDir, packageName.replace(/^@[^/]+\//, ""), "package.json");
+        }
+        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) };
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// 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
+async function boot() {
+  const hubUrl = process.env.CAMSTACK_WORKER_HUB_URL;
+  const token = process.env.CAMSTACK_WORKER_TOKEN ?? "";
+  const addonId = process.env.CAMSTACK_ADDON_ID;
+  const addonDir = process.env.CAMSTACK_ADDON_DIR;
+  const dataDir = process.env.CAMSTACK_DATA_DIR ?? `/tmp/camstack-worker-${addonId}`;
+  const addonConfig = JSON.parse(process.env.CAMSTACK_ADDON_CONFIG ?? "{}");
+  const locationPaths = JSON.parse(process.env.CAMSTACK_LOCATION_PATHS ?? "{}");
+  if (!hubUrl || !addonId || !addonDir) {
+    console.error("[worker] Missing required env vars: CAMSTACK_WORKER_HUB_URL, CAMSTACK_ADDON_ID, CAMSTACK_ADDON_DIR");
+    process.exit(1);
+  }
+  const workerId = `worker-${addonId}-${process.pid}`;
+  const { createTRPCClient, createWSClient, wsLink } = await import("@trpc/client");
+  const superjson = (await import("superjson")).default;
+  const wsClient = createWSClient({
+    url: hubUrl,
+    connectionParams: () => ({ token })
+  });
+  const api = createTRPCClient({
+    links: [wsLink({ client: wsClient, transformer: superjson })]
+  });
+  try {
+    await api.agent.register.mutate({
+      id: workerId,
+      name: addonId,
+      capabilities: [],
+      platform: os2.platform(),
+      arch: os2.arch(),
+      cpuCores: os2.cpus().length,
+      memoryMB: Math.round(os2.totalmem() / 1024 / 1024),
+      pythonRuntimes: [],
+      installedAddons: [addonId],
+      taskTypes: [],
+      host: os2.hostname(),
+      port: 0,
+      httpPort: 0
+    });
+    console.log(`[worker:${addonId}] Registered with hub as ${workerId}`);
+  } catch (err) {
+    console.error(`[worker:${addonId}] Failed to register:`, err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+  function createScopedLogger(scope) {
+    const sendLog = (level, message, context2) => {
+      if (process.send) {
+        process.send({ type: "LOG", level, message, context: context2 });
+      } else {
+        const prefix = `[${scope.join(":")}]`;
+        if (level === "error") console.error(prefix, message, context2 ?? "");
+        else if (level === "warn") console.warn(prefix, message, context2 ?? "");
+        else if (level === "debug") console.debug(prefix, message, context2 ?? "");
+        else console.log(prefix, message, context2 ?? "");
+      }
+    };
+    return {
+      info: (msg, ctx) => sendLog("info", msg, ctx),
+      warn: (msg, ctx) => sendLog("warn", msg, ctx),
+      error: (msg, ctx) => sendLog("error", msg, ctx),
+      debug: (msg, ctx) => sendLog("debug", msg, ctx),
+      child: (childScope) => createScopedLogger([...scope, childScope])
+    };
+  }
+  const logger = createScopedLogger([addonId]);
+  const processManager = new WorkerProcessManager(() => {
+  });
+  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}`);
+    process.exit(1);
+  }
+  const declaration = manifest.addons.find((a) => a.id === addonId);
+  if (!declaration) {
+    console.error(`[worker:${addonId}] Addon "${addonId}" not found in manifest`);
+    process.exit(1);
+  }
+  const entryFile = declaration.entry.replace(/^\.\//, "").replace(/^src\//, "dist/").replace(/\.ts$/, ".js");
+  let entryPath = path3.resolve(addonDir, entryFile);
+  if (!fs3.existsSync(entryPath)) {
+    const cjsPath = entryPath.replace(/\.js$/, ".cjs");
+    if (fs3.existsSync(cjsPath)) entryPath = cjsPath;
+  }
+  const mod = await import(entryPath);
+  const firstKey = Object.keys(mod)[0];
+  const AddonClass = mod.default?.default ?? mod.default ?? (firstKey ? mod[firstKey] : void 0);
+  if (typeof AddonClass !== "function") {
+    console.error(`[worker:${addonId}] No addon class found in ${entryPath}`);
+    process.exit(1);
+  }
+  const addon = new AddonClass();
+  const context = {
+    id: addonId,
+    api,
+    logger,
+    addonConfig,
+    process: processManager,
+    dataDir,
+    locationPaths,
+    // Legacy fields — stubs for backward compat during migration
+    eventBus: { emit: () => {
+    }, subscribe: () => () => {
+    }, getRecent: () => [] },
+    storage: {},
+    config: { get: () => void 0, set: async () => {
+    } }
+  };
+  await addon.initialize(context);
+  console.log(`[worker:${addonId}] Addon initialized`);
+  const heartbeatInterval = setInterval(async () => {
+    try {
+      const mem = process.memoryUsage();
+      const subProcs = processManager.listProcesses().map((p) => ({
+        pid: p.pid,
+        name: p.name,
+        command: p.command,
+        state: p.state,
+        cpuPercent: p.cpuPercent,
+        memoryRss: p.memoryRss,
+        uptimeSeconds: p.uptimeSeconds
+      }));
+      await api.agent.heartbeat.mutate({
+        agentId: workerId,
+        cpuPercent: 0,
+        memoryUsedMB: Math.round(mem.rss / 1024 / 1024),
+        activeTasks: 0,
+        subProcesses: subProcs
+      });
+    } catch {
+    }
+  }, 1e4);
+  try {
+    ;
+    api.agent.onTaskAssignment.subscribe(void 0, {
+      onData: async (task) => {
+        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 payload = task.payload;
+            result = await installer.installFromNpm(payload.package, payload.version);
+          } else if (typeof addon.handleTask === "function") {
+            result = await addon.handleTask(task.taskType, task.payload);
+          }
+          await api.agent.reportTaskResult.mutate({
+            taskId: task.taskId,
+            success: true,
+            result
+          });
+        } catch (err) {
+          await api.agent.reportTaskResult.mutate({
+            taskId: task.taskId,
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    });
+  } catch {
+  }
+  const shutdown = async () => {
+    clearInterval(heartbeatInterval);
+    await processManager.killAll();
+    await addon.shutdown();
+    wsClient.close();
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown().catch(() => process.exit(1)));
+  process.on("SIGINT", () => shutdown().catch(() => process.exit(1)));
+  process.send?.({ type: "READY" });
+}
+process.on("uncaughtException", (err) => {
+  console.error("[worker] Uncaught exception:", err.message, err.stack);
+});
+process.on("unhandledRejection", (reason) => {
+  const msg = reason instanceof Error ? reason.message : String(reason);
+  console.error("[worker] Unhandled rejection:", msg);
+});
+boot().catch((err) => {
+  console.error("[worker] Boot failed:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=addon-worker-entry.js.map