@camstack/agent 0.1.1

package/dist/index.js

@@ -0,0 +1,861 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createAgentHttpServer: () => createAgentHttpServer,
+  createAgentService: () => createAgentService,
+  loadAgentConfig: () => loadAgentConfig,
+  startAgent: () => startAgent,
+  startAgentHttpServer: () => startAgentHttpServer
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/agent-config.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var os = __toESM(require("os"));
+function ensurePersistedNodeId(configPath, dataDir) {
+  const resolvedPath = path.resolve(dataDir, configPath);
+  let raw = {};
+  if (fs.existsSync(resolvedPath)) {
+    try {
+      raw = JSON.parse(fs.readFileSync(resolvedPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (typeof raw.nodeId === "string" && raw.nodeId.length > 0) {
+    return raw.nodeId;
+  }
+  const envSeed = process.env.CAMSTACK_NODE_ID;
+  const id = envSeed && envSeed.length > 0 ? envSeed : `agent-${crypto.randomBytes(4).toString("hex")}`;
+  raw.nodeId = id;
+  try {
+    fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+    fs.writeFileSync(resolvedPath, JSON.stringify(raw, null, 2), "utf-8");
+  } catch {
+  }
+  return id;
+}
+function loadAgentConfig(configPath, dataDirOverride) {
+  const filePath = configPath ?? process.env.CAMSTACK_AGENT_CONFIG ?? "agent.json";
+  const dataDir = dataDirOverride ?? process.env.CAMSTACK_DATA_DIR ?? "./camstack-data";
+  const resolvedDataDir = path.resolve(dataDir);
+  const envName = process.env.CAMSTACK_NODE_ID ?? process.env.CAMSTACK_AGENT_NAME ?? `${os.hostname()}-${os.arch()}`;
+  const envHubAddress = process.env.CAMSTACK_HUB_ADDRESS || void 0;
+  const envSecret = process.env.CAMSTACK_CLUSTER_SECRET || void 0;
+  const configFullPath = path.resolve(resolvedDataDir, filePath);
+  const nodeId = ensurePersistedNodeId(filePath, resolvedDataDir);
+  let fileHubAddress;
+  let fileName;
+  let fileSecret;
+  if (fs.existsSync(configFullPath)) {
+    try {
+      const raw = JSON.parse(fs.readFileSync(configFullPath, "utf-8"));
+      fileHubAddress = typeof raw.hubAddress === "string" ? raw.hubAddress : void 0;
+      fileName = typeof raw.name === "string" ? raw.name : void 0;
+      fileSecret = typeof raw.secret === "string" ? raw.secret : void 0;
+    } catch {
+    }
+  }
+  const effectiveName = fileName ?? envName;
+  const effectiveHub = fileHubAddress ?? envHubAddress;
+  const effectiveSecret = fileSecret ?? envSecret;
+  return {
+    nodeId,
+    name: effectiveName,
+    hubAddress: effectiveHub,
+    dataDir: resolvedDataDir,
+    addonsDir: path.resolve(resolvedDataDir, "addons"),
+    logLevel: process.env.CAMSTACK_LOG_LEVEL ?? "info",
+    secret: effectiveSecret,
+    configPath: configFullPath,
+    statusPort: Number(process.env.CAMSTACK_STATUS_PORT) || 4444
+  };
+}
+
+// src/agent-service.ts
+var os2 = __toESM(require("os"));
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+function getLocalIps() {
+  const interfaces = os2.networkInterfaces();
+  const ips = [];
+  for (const ifaces of Object.values(interfaces)) {
+    if (!ifaces) continue;
+    for (const iface of ifaces) {
+      if (iface.internal) continue;
+      ips.push(iface.address);
+    }
+  }
+  return ips;
+}
+function readHubAddressFromConfig(configPath) {
+  if (!configPath) return null;
+  try {
+    if (!fs2.existsSync(configPath)) return null;
+    const raw = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    return typeof raw.hubAddress === "string" && raw.hubAddress.length > 0 ? raw.hubAddress : null;
+  } catch {
+    return null;
+  }
+}
+function isHubConnected(broker) {
+  try {
+    const registry = broker.registry;
+    const nodes = registry?.getNodeList?.({ onlyAvailable: true }) ?? [];
+    return nodes.some((n) => n.id === "hub");
+  } catch {
+    return false;
+  }
+}
+function createAgentService(deps) {
+  return {
+    name: "$agent",
+    actions: {
+      status: {
+        handler: async (ctx) => {
+          const cpus2 = os2.cpus();
+          let cpuPercent = 0;
+          let memoryPercent = 0;
+          const metrics = deps.getMetricsProvider?.();
+          if (metrics) {
+            const snapshot = await metrics.getCached();
+            if (snapshot) {
+              cpuPercent = snapshot.cpu.total;
+              memoryPercent = snapshot.memory.percent;
+            }
+          }
+          return {
+            nodeId: ctx.broker.nodeID,
+            name: deps.agentName,
+            platform: os2.platform(),
+            arch: os2.arch(),
+            hostname: os2.hostname(),
+            cpuCores: cpus2.length,
+            cpuModel: cpus2[0]?.model,
+            totalMemoryMB: Math.round(os2.totalmem() / 1024 / 1024),
+            freeMemoryMB: Math.round(os2.freemem() / 1024 / 1024),
+            cpuPercent,
+            memoryPercent,
+            uptime: os2.uptime(),
+            localIps: getLocalIps(),
+            addons: [...deps.loadedAddons.values()].map((a) => ({
+              id: a.id,
+              status: a.status,
+              version: a.version,
+              packageName: a.packageName
+            }))
+          };
+        }
+      },
+      health: {
+        handler: async (ctx) => {
+          let cpuPercent = 0;
+          let memoryPercent = 0;
+          const metrics = deps.getMetricsProvider?.();
+          if (metrics) {
+            try {
+              const snapshot = await metrics.getCached();
+              if (snapshot) {
+                cpuPercent = snapshot.cpu.total;
+                memoryPercent = snapshot.memory.percent;
+              }
+            } catch {
+            }
+          }
+          let total = 0;
+          let running = 0;
+          let errored = 0;
+          for (const a of deps.loadedAddons.values()) {
+            total++;
+            if (a.status === "running") running++;
+            else if (a.status === "error") errored++;
+          }
+          const hubAddress = readHubAddressFromConfig(deps.configPath);
+          return {
+            ok: errored === 0,
+            nodeId: ctx.broker.nodeID,
+            name: deps.agentName,
+            version: deps.agentVersion ?? "unknown",
+            uptimeSeconds: Math.round(process.uptime()),
+            pid: process.pid,
+            hubConnected: isHubConnected(ctx.broker),
+            hubAddress,
+            addons: { total, running, error: errored },
+            cpuPercent,
+            memoryPercent,
+            checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+      },
+      shutdown: {
+        handler() {
+          setTimeout(() => process.exit(0), 500);
+          return { success: true };
+        }
+      },
+      rename: {
+        handler(ctx) {
+          const newName = ctx.params.name;
+          if (!newName || typeof newName !== "string") {
+            throw new Error("$agent.rename: name is required");
+          }
+          const oldName = deps.agentName;
+          deps.agentName = newName.trim();
+          ctx.broker.logger.info(`Agent renamed: "${oldName}" \u2192 "${deps.agentName}"`);
+          try {
+            const configFile = path2.resolve(deps.configPath);
+            let raw = {};
+            if (fs2.existsSync(configFile)) {
+              try {
+                raw = JSON.parse(fs2.readFileSync(configFile, "utf-8"));
+              } catch {
+              }
+            }
+            raw.name = deps.agentName;
+            fs2.mkdirSync(path2.dirname(configFile), { recursive: true });
+            fs2.writeFileSync(configFile, JSON.stringify(raw, null, 2), "utf-8");
+            ctx.broker.logger.info(`Agent name persisted to ${configFile}`);
+          } catch (err) {
+            ctx.broker.logger.warn("Agent rename: config file write failed (in-memory rename still active)", { error: String(err) });
+          }
+          return { success: true, name: deps.agentName };
+        }
+      },
+      listAddons: {
+        handler() {
+          return [...deps.loadedAddons.keys()];
+        }
+      },
+      deploy: {
+        handler: async (ctx) => {
+          const { addonId, bundle } = ctx.params;
+          const addonDir = path2.join(deps.addonsDir, addonId);
+          fs2.mkdirSync(deps.addonsDir, { recursive: true });
+          const bundlePath = path2.join(deps.addonsDir, `${addonId}.tgz`);
+          const bufferData = typeof bundle === "string" ? Buffer.from(bundle, "base64") : bundle;
+          fs2.writeFileSync(bundlePath, bufferData);
+          const { execSync } = await import("child_process");
+          fs2.mkdirSync(addonDir, { recursive: true });
+          execSync(`tar -xzf "${bundlePath}" -C "${addonDir}" --strip-components=1`, {
+            timeout: 3e4
+          });
+          fs2.unlinkSync(bundlePath);
+          return { success: true, addonId, path: addonDir };
+        }
+      },
+      undeploy: {
+        handler: async (ctx) => {
+          const { addonId } = ctx.params;
+          const addonDir = path2.join(deps.addonsDir, addonId);
+          deps.loadedAddons.delete(addonId);
+          if (fs2.existsSync(addonDir)) {
+            fs2.rmSync(addonDir, { recursive: true, force: true });
+          }
+          return { success: true, addonId };
+        }
+      },
+      restart: {
+        handler: async (ctx) => {
+          const { addonId } = ctx.params;
+          return { success: true, addonId, action: "restart-queued" };
+        }
+      }
+    }
+  };
+}
+
+// src/agent-bootstrap.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+
+// src/agent-http.ts
+var import_fastify = __toESM(require("fastify"));
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+function resolveUiDistDir(dataDir) {
+  const candidates = [
+    path3.resolve(__dirname, "../../addon-agent-ui/dist"),
+    path3.join(dataDir, "addons", "@camstack", "addon-agent-ui", "dist"),
+    path3.join(dataDir, "agent-ui")
+  ];
+  for (const dir of candidates) {
+    if (fs3.existsSync(path3.join(dir, "index.html"))) return dir;
+  }
+  return null;
+}
+function readConfigFile(configPath) {
+  if (!fs3.existsSync(configPath)) return {};
+  try {
+    return JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfigFile(configPath, data) {
+  fs3.mkdirSync(path3.dirname(configPath), { recursive: true });
+  fs3.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
+}
+function getRegistryNodes(broker) {
+  try {
+    const registry = broker.registry;
+    return registry?.getNodeList?.({ onlyAvailable: true }) ?? [];
+  } catch {
+    return [];
+  }
+}
+function getEffectiveConfig(configPath, nodeId) {
+  const raw = readConfigFile(configPath);
+  return {
+    name: typeof raw.name === "string" ? raw.name : nodeId,
+    hubAddress: typeof raw.hubAddress === "string" ? raw.hubAddress : null,
+    hasSecret: typeof raw.secret === "string" && raw.secret.length > 0
+  };
+}
+async function createAgentHttpServer(getBroker, config) {
+  const app = (0, import_fastify.default)({ logger: false });
+  const cors = await import("@fastify/cors");
+  await app.register(cors.default);
+  app.get("/health", async (_req, reply) => {
+    try {
+      const result = await getBroker().call("$agent.health");
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return reply.status(503).send({
+        ok: false,
+        nodeId: config.nodeId,
+        error: message
+      });
+    }
+  });
+  app.get("/api/agent/status", async () => {
+    const broker = getBroker();
+    const eff = getEffectiveConfig(config.configPath, config.nodeId);
+    const nodes = getRegistryNodes(broker);
+    const hubConnected = nodes.some((n) => n.id === "hub");
+    const discoveryMode = !eff.hubAddress;
+    try {
+      const status = await broker.call("$agent.status");
+      return {
+        ...status,
+        name: eff.name,
+        hubAddress: eff.hubAddress,
+        hubConnected,
+        discoveryMode,
+        hasSecret: eff.hasSecret,
+        discoveredNodes: nodes.filter((n) => n.id !== broker.nodeID).map((n) => n.id)
+      };
+    } catch {
+      return {
+        nodeId: config.nodeId,
+        name: eff.name,
+        hubAddress: eff.hubAddress,
+        hubConnected,
+        discoveryMode,
+        hasSecret: eff.hasSecret,
+        discoveredNodes: [],
+        addons: [],
+        localIps: []
+      };
+    }
+  });
+  app.get("/api/agent/processes", async () => {
+    try {
+      return await getBroker().call("$process.list");
+    } catch {
+      return [];
+    }
+  });
+  app.post("/api/agent/addon/restart", async (req, reply) => {
+    const addonId = req.body?.addonId;
+    if (!addonId) return reply.status(400).send({ error: "addonId required" });
+    return getBroker().call("$agent.restart", { addonId });
+  });
+  app.post("/api/agent/process/restart", async (req, reply) => {
+    const name = req.body?.name;
+    if (!name) return reply.status(400).send({ error: "name required" });
+    return getBroker().call("$process.restart", { name });
+  });
+  app.get("/api/agent/config", async () => {
+    const persisted = readConfigFile(config.configPath);
+    const eff = getEffectiveConfig(config.configPath, config.nodeId);
+    return {
+      nodeId: config.nodeId,
+      name: eff.name,
+      hubAddress: eff.hubAddress,
+      hasSecret: eff.hasSecret,
+      configPath: config.configPath,
+      dataDir: config.dataDir,
+      // Include all persisted fields except raw secret
+      ...Object.fromEntries(
+        Object.entries(persisted).filter(([k]) => k !== "secret")
+      )
+    };
+  });
+  app.post("/api/agent/config", async (req) => {
+    const patch = req.body ?? {};
+    const existing = readConfigFile(config.configPath);
+    const merged = { ...existing, ...patch };
+    writeConfigFile(config.configPath, merged);
+    if (typeof patch.name === "string" && patch.name.trim()) {
+      try {
+        await getBroker().call("$agent.rename", { name: patch.name.trim() });
+        console.log(`[Agent] Name changed to "${patch.name.trim()}"`);
+      } catch {
+      }
+    }
+    const needsReconnect = Boolean(
+      patch.hubAddress !== void 0 || patch.secret !== void 0
+    );
+    return {
+      success: true,
+      restartRequired: needsReconnect
+    };
+  });
+  app.post("/api/agent/restart", async () => {
+    if (!config.onReconnect) {
+      return { success: false, message: "Reconnect not available" };
+    }
+    console.log("[Agent] Reconnect requested from UI");
+    void config.onReconnect().catch((err) => {
+      console.error("[Agent] Reconnect failed:", err);
+    });
+    return { success: true, message: "Agent reconnecting..." };
+  });
+  app.get("/api/agent/discovered-nodes", async () => {
+    const b = getBroker();
+    const nodes = getRegistryNodes(b);
+    return nodes.filter((n) => n.id !== b.nodeID).map((n) => ({ id: n.id, isHub: n.id === "hub" }));
+  });
+  const uiDir = resolveUiDistDir(config.dataDir);
+  if (uiDir) {
+    const fastifyStatic = await import("@fastify/static");
+    await app.register(fastifyStatic.default, {
+      root: uiDir,
+      prefix: "/",
+      wildcard: false,
+      decorateReply: false
+    });
+    app.setNotFoundHandler(async (req, reply) => {
+      if (req.url.startsWith("/api/") || req.url.startsWith("/health")) {
+        return reply.status(404).send({ error: "Not found" });
+      }
+      return reply.type("text/html").sendFile("index.html");
+    });
+    console.log(`[Agent] UI served from: ${uiDir}`);
+  }
+  return app;
+}
+async function startAgentHttpServer(getBroker, config) {
+  try {
+    const app = await createAgentHttpServer(getBroker, config);
+    await app.listen({ port: config.port, host: "0.0.0.0" });
+    console.log(`[Agent] HTTP server: http://localhost:${config.port}`);
+  } catch (err) {
+    console.warn(`[Agent] HTTP server failed to start on port ${config.port}:`, err);
+  }
+}
+
+// src/agent-bootstrap.ts
+var import_kernel = require("@camstack/kernel");
+var import_types = require("@camstack/types");
+var import_types2 = require("@camstack/types");
+var import_core = require("@camstack/core");
+var agentLogManager = new import_core.LogManager(5e3);
+async function startAgent(configPath) {
+  const config = loadAgentConfig(configPath);
+  if (config.hubAddress) {
+    console.log(`[Agent] Starting node "${config.nodeId}" (name="${config.name}") connecting to ${config.hubAddress}`);
+  } else {
+    console.log(`[Agent] Starting node "${config.nodeId}" (name="${config.name}") in discovery mode`);
+  }
+  console.log(`[Agent] Config: ${config.configPath}`);
+  console.log(`[Agent] Data dir: ${config.dataDir}`);
+  const explicitSource = process.env["CAMSTACK_INSTALL_SOURCE"];
+  const workspaceDir = explicitSource === "npm" ? null : (0, import_kernel.detectWorkspacePackagesDir)(config.dataDir);
+  const installer = new import_kernel.AddonInstaller({
+    addonsDir: config.addonsDir,
+    workspacePackagesDir: workspaceDir ?? void 0,
+    installSource: explicitSource
+  });
+  await installer.ensureRequiredPackages(import_kernel.AddonInstaller.AGENT_PACKAGES);
+  console.log(`[Agent] Addon packages ready in ${config.addonsDir}`);
+  let broker = (0, import_kernel.createBroker)({
+    nodeID: config.nodeId,
+    mode: "agent",
+    hubAddress: config.hubAddress,
+    logLevel: config.logLevel,
+    secret: config.secret
+  });
+  const reconnect = async () => {
+    console.log("[Agent] Reconnecting with updated config...");
+    try {
+      await broker.stop();
+    } catch {
+    }
+    const fresh = loadAgentConfig(void 0, config.dataDir);
+    console.log(`[Agent] New config: hub=${fresh.hubAddress ?? "discovery"}, secret=${fresh.secret ? "yes" : "none"}`);
+    broker = (0, import_kernel.createBroker)({
+      nodeID: config.nodeId,
+      mode: "agent",
+      hubAddress: fresh.hubAddress,
+      logLevel: fresh.logLevel,
+      secret: fresh.secret
+    });
+    await broker.start();
+    console.log("[Agent] Reconnected successfully");
+  };
+  const loadedAddons = /* @__PURE__ */ new Map();
+  const consoleLogger = {
+    info: (msg) => console.log(`[Agent] ${msg}`),
+    warn: (msg) => console.warn(`[Agent] ${msg}`),
+    error: (msg) => console.error(`[Agent] ${msg}`),
+    debug: (msg) => console.debug(`[Agent] ${msg}`),
+    child: () => consoleLogger,
+    withTags: () => consoleLogger
+  };
+  const capabilityRegistry = new import_kernel.CapabilityRegistry(consoleLogger);
+  const agentCapabilities = [
+    import_types2.storageCapability,
+    import_types2.settingsStoreCapability,
+    import_types2.logDestinationCapability,
+    import_types2.metricsProviderCapability,
+    import_types2.decoderCapability,
+    import_types2.motionDetectionCapability,
+    import_types2.pipelineExecutorCapability,
+    import_types2.pipelineRunnerCapability,
+    import_types2.audioAnalyzerCapability,
+    import_types2.platformProbeCapability
+  ];
+  for (const cap of agentCapabilities) {
+    capabilityRegistry.declareCapability(cap);
+  }
+  const loggerFactory = (addonId) => agentLogManager.createLogger().withTags({ addonId });
+  const agentService = createAgentService({
+    addonsDir: config.addonsDir,
+    dataDir: config.dataDir,
+    agentName: config.name,
+    configPath: config.configPath,
+    loadedAddons,
+    // Resolve the current metrics-provider cap lazily from the registry.
+    // The cap is registered during bootCoreAddons but may not exist in test
+    // scenarios — `null` is a documented fallback for both.
+    getMetricsProvider: () => capabilityRegistry.getSingleton("metrics-provider"),
+    agentVersion: readAgentVersion()
+  });
+  broker.createService(agentService);
+  const processService = (0, import_kernel.createProcessService)(broker.nodeID, config.dataDir);
+  broker.createService(processService);
+  (0, import_kernel.registerClusterEventsService)(broker);
+  broker.createService((0, import_kernel.createHwAccelService)((0, import_kernel.createKernelHwAccel)()));
+  await broker.start();
+  void startAgentHttpServer(() => broker, {
+    port: config.statusPort ?? 4444,
+    nodeId: config.nodeId,
+    dataDir: config.dataDir,
+    configPath: config.configPath,
+    onReconnect: reconnect
+  });
+  await bootCoreAddons(broker, config, capabilityRegistry, loadedAddons, loggerFactory);
+  for (const dest of capabilityRegistry.getCollection("log-destination")) {
+    agentLogManager.addDestination(dest);
+  }
+  const storageProvider = capabilityRegistry.getSingleton("storage") ?? void 0;
+  await loadClusterCapableAddons(broker, config, capabilityRegistry, loadedAddons);
+  await loadDeployedAddons(broker, config.addonsDir, config.dataDir, loadedAddons, storageProvider, loggerFactory, capabilityRegistry);
+  let hubReachableFired = false;
+  broker.localBus.on("$node.connected", ({ node }) => {
+    if (node.id !== "hub") return;
+    if (hubReachableFired) return;
+    hubReachableFired = true;
+    for (const [, entry] of loadedAddons) {
+      if (!entry.addon || typeof entry.addon.onHubReachable !== "function") continue;
+      Promise.resolve(entry.addon.onHubReachable()).catch((err) => {
+        console.error(`[Agent] ${entry.id} onHubReachable() threw:`, err);
+      });
+    }
+  });
+  console.log(`[Agent] Node "${config.nodeId}" (name="${config.name}") ready \u2014 ${loadedAddons.size} addon(s) loaded`);
+  const shutdown = async () => {
+    console.log("[Agent] Shutting down...");
+    for (const [, entry] of loadedAddons) {
+      if (entry.addon?.shutdown) {
+        try {
+          await entry.addon.shutdown();
+        } catch {
+        }
+      }
+    }
+    await broker.stop();
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+var AGENT_INFRA = import_kernel.INFRA_CAPABILITIES;
+async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFactory) {
+  const packageDirs = resolveAddonPackageDirs(config.addonsDir);
+  if (packageDirs.length === 0) {
+    console.warn("[Agent] No addon packages found \u2014 running without infrastructure addons");
+    return;
+  }
+  console.log(`[Agent] Scanning ${packageDirs.length} addon package(s) for infra providers`);
+  const loader = new import_kernel.AddonLoader();
+  for (const dir of packageDirs) {
+    try {
+      await loader.loadFromAddonDir(dir);
+    } catch (err) {
+      console.warn(`[Agent] Failed to scan ${dir}: ${(0, import_types2.errMsg)(err)}`);
+    }
+  }
+  for (const infra of AGENT_INFRA) {
+    const candidates = loader.listAddons().filter(
+      (a) => a.declaration.capabilities?.some((c) => {
+        const capName = typeof c === "string" ? c : c.name;
+        return capName === infra.name;
+      })
+    );
+    const addon = infra.name === "log-destination" ? candidates.find((a) => a.declaration.id === "hub-forwarder") ?? candidates[0] : candidates[0];
+    if (!addon) {
+      if (infra.required) {
+        console.error(`[Agent] Required infrastructure addon for "${infra.name}" not found`);
+      }
+      continue;
+    }
+    const addonId = addon.declaration.id;
+    try {
+      const instance = new addon.addonClass();
+      const storageProvider = registry.getSingleton("storage") ?? void 0;
+      const context = (0, import_kernel.createAddonContext)(broker, addon.declaration, config.dataDir, {
+        storageProvider,
+        addonConfig: { rootPath: config.dataDir },
+        createLogger: loggerFactory,
+        capabilityRegistry: registry
+      });
+      const initResult = (0, import_types.normalizeAddonInitResult)(await instance.initialize(context));
+      for (const reg of initResult?.providers ?? []) {
+        const capName = reg.capability.name;
+        registry.registerProvider(capName, addonId, reg.provider);
+        context.registerProvider(capName, reg.provider);
+      }
+      loadedAddons.set(addonId, {
+        id: addonId,
+        status: "running",
+        version: addon.declaration.version,
+        packageName: addon.packageName,
+        addon: instance
+      });
+      console.log(`[Agent] Core addon "${addonId}" initialized`);
+    } catch (err) {
+      const msg = (0, import_types2.errMsg)(err);
+      console.error(`[Agent] Failed to initialize core addon "${addonId}": ${msg}`);
+      if (infra.required) {
+        throw new Error(`Required infrastructure addon "${addonId}" failed: ${msg}`, { cause: err });
+      }
+    }
+  }
+}
+async function loadClusterCapableAddons(broker, config, capabilityRegistry, loadedAddons) {
+  const addonPackageDirs = resolveAddonPackageDirs(config.addonsDir);
+  if (addonPackageDirs.length === 0) return;
+  const allGroupCandidates = [];
+  const dirToLoader = /* @__PURE__ */ new Map();
+  for (const dir of addonPackageDirs) {
+    const loader = new import_kernel.AddonLoader();
+    try {
+      await loader.loadFromAddonDir(dir);
+    } catch (err) {
+      console.warn(`[Agent] Skipping ${dir}: ${(0, import_types2.errMsg)(err)}`);
+      continue;
+    }
+    dirToLoader.set(dir, loader);
+    for (const registered of loader.listAddons()) {
+      if (loadedAddons.has(registered.declaration.id)) continue;
+      if (registered.declaration.execution === void 0) continue;
+      const placement = (0, import_types.resolveAddonPlacement)(registered.declaration);
+      if (placement === "hub-only") continue;
+      allGroupCandidates.push({
+        groupId: (0, import_types.resolveAddonGroup)(registered.declaration),
+        addonId: registered.declaration.id,
+        addonDir: dir,
+        version: registered.declaration.version ?? "0.0.0",
+        packageName: registered.packageName,
+        capabilities: registered.declaration.capabilities ?? []
+      });
+    }
+  }
+  if (allGroupCandidates.length > 0) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const c of allGroupCandidates) {
+      const arr = grouped.get(c.groupId) ?? [];
+      arr.push(c);
+      grouped.set(c.groupId, arr);
+    }
+    for (const [groupId, addons] of grouped) {
+      try {
+        await broker.call("$process.spawnGroup", {
+          groupId,
+          addons: addons.map((a) => ({ addonId: a.addonId, addonDir: a.addonDir }))
+        });
+        for (const a of addons) {
+          for (const cap of a.capabilities) {
+            const capName = typeof cap === "string" ? cap : cap.name;
+            const proxy = new Proxy({}, {
+              get(_target, prop) {
+                if (prop === "then" || typeof prop === "symbol") return void 0;
+                return (params) => broker.call(`${a.addonId}.${capName}.${prop}`, params);
+              }
+            });
+            capabilityRegistry.registerProvider(capName, a.addonId, proxy);
+          }
+          loadedAddons.set(a.addonId, {
+            id: a.addonId,
+            status: "running",
+            version: a.version,
+            packageName: a.packageName
+          });
+        }
+        console.log(`[Agent] Group "${groupId}" spawned with ${addons.length} addon(s): ${addons.map((a) => a.addonId).join(", ")}`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.stack ?? err.message : String(err);
+        console.error(`[Agent] Failed to spawn group "${groupId}": ${msg}`);
+        for (const a of addons) {
+          loadedAddons.set(a.addonId, { id: a.addonId, status: "error" });
+        }
+      }
+    }
+  }
+  for (const dir of addonPackageDirs) {
+    const loader = dirToLoader.get(dir);
+    if (!loader) continue;
+    for (const registered of loader.listAddons()) {
+      const addonId = registered.declaration.id;
+      if (loadedAddons.has(addonId)) continue;
+      if (!(0, import_types.isDeployableToAgent)(registered.declaration)) continue;
+      console.warn(
+        `[Agent] Addon "${addonId}" is deployable but missing from any spawned group \u2014 verify package.json execution field`
+      );
+    }
+  }
+}
+async function loadDeployedAddons(broker, addonsDir, dataDir, loadedAddons, storageProvider, loggerFactory, capabilityRegistry) {
+  if (!fs4.existsSync(addonsDir)) return;
+  const loader = new import_kernel.AddonLoader();
+  await loader.loadFromDirectory(addonsDir);
+  const contextOptions = {
+    storageProvider,
+    addonConfig: storageProvider ? { modelsDir: storageProvider.resolve({ location: "models", relativePath: "" }) } : {},
+    createLogger: loggerFactory,
+    capabilityRegistry
+  };
+  for (const registered of loader.listAddons()) {
+    const addonId = registered.declaration.id;
+    if (loadedAddons.has(addonId)) continue;
+    if (!(0, import_types.isDeployableToAgent)(registered.declaration)) continue;
+    try {
+      const instance = new registered.addonClass();
+      const context = (0, import_kernel.createAddonContext)(broker, registered.declaration, dataDir, contextOptions);
+      await instance.initialize(context);
+      const service = (0, import_kernel.createAddonService)(instance, registered.declaration);
+      broker.createService(service);
+      loadedAddons.set(addonId, {
+        id: addonId,
+        status: "running",
+        version: registered.declaration.version,
+        packageName: registered.packageName,
+        addon: instance
+      });
+      console.log(`[Agent] Deployed addon "${addonId}" loaded`);
+    } catch (err) {
+      const msg = (0, import_types2.errMsg)(err);
+      console.error(`[Agent] Failed to load deployed addon "${addonId}": ${msg}`);
+      loadedAddons.set(addonId, { id: addonId, status: "error" });
+    }
+  }
+}
+function readAgentVersion() {
+  const candidates = [
+    path4.resolve(__dirname, "..", "package.json"),
+    path4.resolve(__dirname, "..", "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (!fs4.existsSync(candidate)) continue;
+      const raw = JSON.parse(fs4.readFileSync(candidate, "utf-8"));
+      if (raw.name === "@camstack/agent" && typeof raw.version === "string") return raw.version;
+    } catch {
+    }
+  }
+  return "unknown";
+}
+function isDir(p) {
+  try {
+    return fs4.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveAddonPackageDirs(addonsDir) {
+  const dirs = [];
+  if (!fs4.existsSync(addonsDir)) return dirs;
+  for (const name of fs4.readdirSync(addonsDir)) {
+    const full = path4.join(addonsDir, name);
+    if (name.startsWith("@") && isDir(full)) {
+      for (const sub of fs4.readdirSync(full)) {
+        const subFull = path4.join(full, sub);
+        if (isDir(subFull) && fs4.existsSync(path4.join(subFull, "package.json"))) {
+          dirs.push(subFull);
+        }
+      }
+    } else if (isDir(full) && fs4.existsSync(path4.join(full, "package.json"))) {
+      dirs.push(full);
+    }
+  }
+  return dirs;
+}
+var scriptName = process.argv[1] ?? "";
+if (scriptName.endsWith("agent-bootstrap.js") || scriptName.endsWith("agent-bootstrap.ts")) {
+  startAgent().catch((err) => {
+    console.error("[Agent] Fatal error:", err);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAgentHttpServer,
+  createAgentService,
+  loadAgentConfig,
+  startAgent,
+  startAgentHttpServer
+});
+//# sourceMappingURL=index.js.map