@camstack/agent 1.0.3 → 1.0.5

package/dist/index.js

@@ -104,10 +104,87 @@ function loadAgentConfig(configPath, dataDirOverride) {
 
 // src/agent-service.ts
 var os2 = __toESM(require("os"));
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 var import_moleculer = require("moleculer");
 var import_system = require("@camstack/system");
+
+// src/agent-deploy-swap.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_node_crypto = require("crypto");
+function rmrf(target) {
+  fs2.rmSync(target, { recursive: true, force: true });
+}
+function moveDir(from, to) {
+  try {
+    fs2.renameSync(from, to);
+  } catch (err) {
+    const code = err.code;
+    if (code === "EXDEV") {
+      fs2.cpSync(from, to, { recursive: true });
+      rmrf(from);
+    } else {
+      throw err;
+    }
+  }
+}
+async function applyDeployedBundle(input) {
+  const { addonsDir, addonId, bundle, extract, logger } = input;
+  fs2.mkdirSync(addonsDir, { recursive: true });
+  const liveDir = path2.join(addonsDir, addonId);
+  const liveParent = path2.dirname(liveDir);
+  const liveBase = path2.basename(liveDir);
+  fs2.mkdirSync(liveParent, { recursive: true });
+  const token = (0, import_node_crypto.randomBytes)(6).toString("hex");
+  const nextDir = path2.join(liveParent, `.${liveBase}.next.${token}`);
+  const backupDir = path2.join(liveParent, `.${liveBase}.backup.${token}`);
+  fs2.mkdirSync(nextDir, { recursive: true });
+  try {
+    await extract(bundle, nextDir);
+  } catch (err) {
+    rmrf(nextDir);
+    throw err;
+  }
+  const hadLive = fs2.existsSync(liveDir);
+  if (hadLive) {
+    fs2.renameSync(liveDir, backupDir);
+  }
+  try {
+    moveDir(nextDir, liveDir);
+  } catch (swapErr) {
+    if (hadLive) {
+      try {
+        if (fs2.existsSync(liveDir)) rmrf(liveDir);
+        fs2.renameSync(backupDir, liveDir);
+      } catch (restoreErr) {
+        logger.error(
+          `agent deploy swap: restore of "${addonId}" failed after a failed swap \u2014 manual recovery may be needed`,
+          {
+            meta: {
+              backupDir,
+              error: restoreErr instanceof Error ? restoreErr.message : String(restoreErr)
+            }
+          }
+        );
+      }
+    }
+    rmrf(nextDir);
+    throw swapErr;
+  }
+  if (hadLive) rmrf(backupDir);
+  return { addonDir: liveDir };
+}
+
+// src/agent-service.ts
+var deploySwapLogger = {
+  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: () => deploySwapLogger,
+  withTags: () => deploySwapLogger
+};
 function getLocalIps() {
   const interfaces = os2.networkInterfaces();
   const ips = [];
@@ -120,11 +197,23 @@ function getLocalIps() {
   }
   return ips;
 }
+async function withTimeout(p, ms, fallback) {
+  let timer;
+  const timeout = new Promise((resolve5) => {
+    timer = setTimeout(() => resolve5(fallback), ms);
+  });
+  try {
+    return await Promise.race([p, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var METRICS_SNAPSHOT_TIMEOUT_MS = 2e3;
 function readHubAddressFromConfig(configPath) {
   if (!configPath) return null;
   try {
-    if (!fs2.existsSync(configPath)) return null;
-    const raw = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    if (!fs3.existsSync(configPath)) return null;
+    const raw = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
     return typeof raw.hubAddress === "string" && raw.hubAddress.length > 0 ? raw.hubAddress : null;
   } catch {
     return null;
@@ -132,9 +221,9 @@ function readHubAddressFromConfig(configPath) {
 }
 function readDeployedAddonIds(addonDir) {
   try {
-    const manifestPath = path2.join(addonDir, "package.json");
-    if (!fs2.existsSync(manifestPath)) return [];
-    const raw = JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
+    const manifestPath = path3.join(addonDir, "package.json");
+    if (!fs3.existsSync(manifestPath)) return [];
+    const raw = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
     const entries = raw.camstack?.addons ?? [];
     const ids = [];
     for (const entry of entries) {
@@ -166,7 +255,11 @@ function createAgentService(deps) {
           let memoryPercent = 0;
           const metrics = deps.getMetricsProvider?.();
           if (metrics) {
-            const snapshot = await metrics.getCached();
+            const snapshot = await withTimeout(
+              metrics.getCached(),
+              METRICS_SNAPSHOT_TIMEOUT_MS,
+              null
+            );
             if (snapshot) {
               cpuPercent = snapshot.cpu.total;
               memoryPercent = snapshot.memory.percent;
@@ -189,7 +282,9 @@ function createAgentService(deps) {
             addons: [...deps.loadedAddons.values()].map((a) => ({
               id: a.id,
               status: a.status,
-              version: a.version,
+              // Report the PACKAGE version (falls back to the declaration
+              // version) so the hub's per-node update check is accurate.
+              version: a.packageVersion ?? a.version,
               packageName: a.packageName
             }))
           };
@@ -203,7 +298,11 @@ function createAgentService(deps) {
           const metrics = deps.getMetricsProvider?.();
           if (metrics) {
             try {
-              const snapshot = await metrics.getCached();
+              const snapshot = await withTimeout(
+                metrics.getCached(),
+                METRICS_SNAPSHOT_TIMEOUT_MS,
+                null
+              );
               if (snapshot) {
                 cpuPercent = snapshot.cpu.total;
                 memoryPercent = snapshot.memory.percent;
@@ -253,17 +352,17 @@ function createAgentService(deps) {
           deps.agentName = newName.trim();
           broker.logger.info(`Agent renamed: "${oldName}" \u2192 "${deps.agentName}"`);
           try {
-            const configFile = path2.resolve(deps.configPath);
+            const configFile = path3.resolve(deps.configPath);
             let raw = {};
-            if (fs2.existsSync(configFile)) {
+            if (fs3.existsSync(configFile)) {
               try {
-                raw = JSON.parse(fs2.readFileSync(configFile, "utf-8"));
+                raw = JSON.parse(fs3.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");
+            fs3.mkdirSync(path3.dirname(configFile), { recursive: true });
+            fs3.writeFileSync(configFile, JSON.stringify(raw, null, 2), "utf-8");
             broker.logger.info(`Agent name persisted to ${configFile}`);
           } catch (err) {
             broker.logger.warn(
@@ -283,20 +382,31 @@ function createAgentService(deps) {
         handler: async (ctx) => {
           const { params } = ctx;
           const { addonId, bundle } = 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 { execFileSync } = await import("child_process");
-          if (fs2.existsSync(addonDir)) {
-            fs2.rmSync(addonDir, { recursive: true, force: true });
-          }
-          fs2.mkdirSync(addonDir, { recursive: true });
-          execFileSync("tar", ["-xzf", bundlePath, "-C", addonDir, "--strip-components=1"], {
-            timeout: 3e4
+          const { execFile } = await import("child_process");
+          const { promisify } = await import("util");
+          const execFileAsync = promisify(execFile);
+          const extract = async (tgz, destDir) => {
+            const tgzPath = path3.join(destDir, "..", `.${path3.basename(destDir)}.tgz`);
+            fs3.writeFileSync(tgzPath, tgz);
+            try {
+              await execFileAsync("tar", ["-xzf", tgzPath, "-C", destDir, "--strip-components=1"], {
+                timeout: 6e4
+              });
+            } finally {
+              try {
+                fs3.unlinkSync(tgzPath);
+              } catch {
+              }
+            }
+          };
+          const { addonDir } = await applyDeployedBundle({
+            addonsDir: deps.addonsDir,
+            addonId,
+            bundle: bufferData,
+            extract,
+            logger: deploySwapLogger
           });
-          fs2.unlinkSync(bundlePath);
           for (const declId of readDeployedAddonIds(addonDir)) {
             deps.loadedAddons.delete(declId);
           }
@@ -343,15 +453,15 @@ function createAgentService(deps) {
           } catch {
           }
           deps.loadedAddons.delete(addonId);
-          const addonDir = path2.join(deps.addonsDir, addonId);
-          if (fs2.existsSync(addonDir)) {
-            fs2.rmSync(addonDir, { recursive: true, force: true });
+          const addonDir = path3.join(deps.addonsDir, addonId);
+          if (fs3.existsSync(addonDir)) {
+            fs3.rmSync(addonDir, { recursive: true, force: true });
           }
           const pkgName = entry?.packageName;
           if (pkgName && pkgName !== addonId) {
-            const pkgDir = path2.join(deps.addonsDir, pkgName);
-            if (fs2.existsSync(pkgDir)) {
-              fs2.rmSync(pkgDir, { recursive: true, force: true });
+            const pkgDir = path3.join(deps.addonsDir, pkgName);
+            if (fs3.existsSync(pkgDir)) {
+              fs3.rmSync(pkgDir, { recursive: true, force: true });
             }
           }
           broker.logger.info(`$agent.undeploy: ${addonId} disposed (instance + service + folder)`);
@@ -406,35 +516,35 @@ function createAgentService(deps) {
 }
 
 // src/agent-bootstrap.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 
 // src/agent-http.ts
 var import_fastify = __toESM(require("fastify"));
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var path4 = __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")
+    path4.resolve(__dirname, "../../addon-agent-ui/dist"),
+    path4.join(dataDir, "addons", "@camstack", "addon-agent-ui", "dist"),
+    path4.join(dataDir, "agent-ui")
   ];
   for (const dir of candidates) {
-    if (fs3.existsSync(path3.join(dir, "index.html"))) return dir;
+    if (fs4.existsSync(path4.join(dir, "index.html"))) return dir;
   }
   return null;
 }
 function readConfigFile(configPath) {
-  if (!fs3.existsSync(configPath)) return {};
+  if (!fs4.existsSync(configPath)) return {};
   try {
-    return JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs4.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");
+  fs4.mkdirSync(path4.dirname(configPath), { recursive: true });
+  fs4.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
 }
 function getRegistryNodes(broker) {
   try {
@@ -598,8 +708,86 @@ async function startAgentHttpServer(getBroker, config) {
 
 // src/agent-bootstrap.ts
 var import_system3 = require("@camstack/system");
-var import_types = require("@camstack/types");
 var import_types2 = require("@camstack/types");
+var import_types3 = require("@camstack/types");
+
+// src/agent-group-runner.ts
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var import_types = require("@camstack/types");
+function readPackageManifestAddons(dir) {
+  try {
+    const pkgPath = path5.join(dir, "package.json");
+    if (!fs5.existsSync(pkgPath)) return null;
+    const raw = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+    const packageName = typeof raw.name === "string" ? raw.name : "";
+    const packageVersion = typeof raw.version === "string" ? raw.version : "0.0.0";
+    const entries = Array.isArray(raw.camstack?.addons) ? raw.camstack.addons : [];
+    const declarations = [];
+    for (const entry of entries) {
+      if (entry !== null && typeof entry === "object" && typeof entry.id === "string") {
+        declarations.push(entry);
+      }
+    }
+    if (!packageName || declarations.length === 0) return null;
+    return { packageName, packageVersion, declarations };
+  } catch {
+    return null;
+  }
+}
+function isGroupRunnerAddon(decl) {
+  return decl.execution !== void 0 && (0, import_types.resolveAddonPlacement)(decl) !== "hub-only";
+}
+function registerGroupRunnerProviders(deps, addons) {
+  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) => deps.broker.call(`${a.addonId}.${capName}.${prop}`, params);
+          }
+        }
+      );
+      deps.capabilityRegistry.registerProvider(capName, a.addonId, proxy);
+    }
+    deps.loadedAddons.set(a.addonId, {
+      id: a.addonId,
+      status: "running",
+      version: a.version,
+      packageName: a.packageName,
+      packageVersion: a.packageVersion
+    });
+  }
+}
+async function ensureGroupRunner(deps, groupId, addons) {
+  try {
+    const restart = await deps.broker.call("$process.restart", { name: groupId });
+    if (!restart.success) {
+      if (restart.reason !== void 0 && restart.reason !== "not found") {
+        deps.logger.warn(
+          `group "${groupId}" restart returned "${restart.reason}" \u2014 spawning a fresh runner`
+        );
+      }
+      await deps.broker.call("$process.spawnRunner", {
+        runnerId: groupId,
+        addons: addons.map((a) => ({ addonId: a.addonId, addonDir: a.addonDir }))
+      });
+    }
+    registerGroupRunnerProviders(deps, addons);
+    deps.logger.info(
+      `group "${groupId}" live with ${addons.length} addon(s): ${addons.map((a) => a.addonId).join(", ")}`
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.stack ?? err.message : String(err);
+    deps.logger.error(`failed to ensure group "${groupId}": ${msg}`);
+    for (const a of addons) {
+      deps.loadedAddons.set(a.addonId, { id: a.addonId, status: "error" });
+    }
+  }
+}
 
 // src/agent-cap-dispatch-service.ts
 var import_system2 = require("@camstack/system");
@@ -682,7 +870,7 @@ async function startAgent(configPath) {
   const bundledDir = process.env["CAMSTACK_BUNDLED_ADDONS_DIR"];
   let workspaceDir = null;
   let resolvedSource = explicitSource;
-  if (bundledDir && fs4.existsSync(bundledDir)) {
+  if (bundledDir && fs6.existsSync(bundledDir)) {
     workspaceDir = bundledDir;
     resolvedSource = "local";
     console.log(`[Agent] Using bundled addons from ${bundledDir}`);
@@ -801,17 +989,17 @@ async function startAgent(configPath) {
   };
   const capabilityRegistry = new import_system3.CapabilityRegistry(consoleLogger);
   const agentCapabilities = [
-    import_types2.storageCapability,
-    import_types2.storageProviderCapability,
-    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
+    import_types3.storageCapability,
+    import_types3.storageProviderCapability,
+    import_types3.settingsStoreCapability,
+    import_types3.logDestinationCapability,
+    import_types3.metricsProviderCapability,
+    import_types3.decoderCapability,
+    import_types3.motionDetectionCapability,
+    import_types3.pipelineExecutorCapability,
+    import_types3.pipelineRunnerCapability,
+    import_types3.audioAnalyzerCapability,
+    import_types3.platformProbeCapability
   ];
   for (const cap of agentCapabilities) {
     capabilityRegistry.declareCapability(cap);
@@ -1010,7 +1198,7 @@ async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFact
     try {
       await loader.loadFromAddonDir(dir);
     } catch (err) {
-      console.warn(`[Agent] Failed to scan ${dir}: ${(0, import_types2.errMsg)(err)}`);
+      console.warn(`[Agent] Failed to scan ${dir}: ${(0, import_types3.errMsg)(err)}`);
     }
   }
   for (const infra of AGENT_INFRA) {
@@ -1039,10 +1227,15 @@ async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFact
           storageProvider,
           addonConfig: { rootPath: config.dataDir },
           createLogger: loggerFactory,
-          capabilityRegistry: registry
+          capabilityRegistry: registry,
+          // Feed the storage-orchestrator its first-boot seed declarations
+          // (addons-data:default, models:default, …). Without this the agent's
+          // sqlite-settings aborts boot: "No default storage location
+          // configured for type addons-data" → fatal crash-loop.
+          listStorageLocationDeclarations: () => loader.listStorageLocationDeclarations()
         }
       );
-      const initResult = (0, import_types.normalizeAddonInitResult)(await instance.initialize(context));
+      const initResult = (0, import_types2.normalizeAddonInitResult)(await instance.initialize(context));
       for (const reg of initResult?.providers ?? []) {
         const capName = reg.capability.name;
         registry.registerProvider(capName, addonId, reg.provider);
@@ -1053,11 +1246,12 @@ async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFact
         status: "running",
         version: addon.declaration.version,
         packageName: addon.packageName,
+        packageVersion: addon.packageVersion,
         addon: instance
       });
       console.log(`[Agent] Core addon "${addonId}" initialized`);
     } catch (err) {
-      const msg = (0, import_types2.errMsg)(err);
+      const msg = (0, import_types3.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 });
@@ -1075,21 +1269,22 @@ async function loadClusterCapableAddons(broker, config, capabilityRegistry, load
     try {
       await loader.loadFromAddonDir(dir);
     } catch (err) {
-      console.warn(`[Agent] Skipping ${dir}: ${(0, import_types2.errMsg)(err)}`);
+      console.warn(`[Agent] Skipping ${dir}: ${(0, import_types3.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);
+      const placement = (0, import_types2.resolveAddonPlacement)(registered.declaration);
       if (placement === "hub-only") continue;
       allGroupCandidates.push({
-        groupId: (0, import_types.resolveRunnerId)(registered.declaration, registered.declaration.id),
+        groupId: (0, import_types2.resolveRunnerId)(registered.declaration, registered.declaration.id),
         addonId: registered.declaration.id,
         addonDir: dir,
         version: registered.declaration.version ?? "0.0.0",
         packageName: registered.packageName,
+        packageVersion: registered.packageVersion,
         capabilities: registered.declaration.capabilities ?? []
       });
     }
@@ -1107,27 +1302,7 @@ async function loadClusterCapableAddons(broker, config, capabilityRegistry, load
           runnerId: 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
-          });
-        }
+        registerGroupRunnerProviders({ broker, capabilityRegistry, loadedAddons }, addons);
         console.log(
           `[Agent] Group "${groupId}" spawned with ${addons.length} addon(s): ${addons.map((a) => a.addonId).join(", ")}`
         );
@@ -1146,7 +1321,7 @@ async function loadClusterCapableAddons(broker, config, capabilityRegistry, load
     for (const registered of loader.listAddons()) {
       const addonId = registered.declaration.id;
       if (loadedAddons.has(addonId)) continue;
-      if (!(0, import_types.isDeployableToAgent)(registered.declaration)) continue;
+      if (!(0, import_types2.isDeployableToAgent)(registered.declaration)) continue;
       console.warn(
         `[Agent] Addon "${addonId}" is deployable but missing from any spawned group \u2014 verify package.json execution field`
       );
@@ -1154,9 +1329,66 @@ async function loadClusterCapableAddons(broker, config, capabilityRegistry, load
   }
 }
 async function loadDeployedAddons(broker, addonsDir, dataDir, loadedAddons, storageProvider, loggerFactory, capabilityRegistry) {
-  if (!fs4.existsSync(addonsDir)) return;
-  const loader = new import_system3.AddonLoader();
-  await loader.loadFromDirectory(addonsDir);
+  if (!fs6.existsSync(addonsDir)) return;
+  const packageDirs = resolveAddonPackageDirs(addonsDir);
+  const groupCandidates = [];
+  const inProcessDirs = /* @__PURE__ */ new Set();
+  for (const dir of packageDirs) {
+    const manifest = readPackageManifestAddons(dir);
+    if (!manifest) continue;
+    for (const decl of manifest.declarations) {
+      const addonId = decl.id;
+      if (loadedAddons.has(addonId)) continue;
+      if (!(0, import_types2.isDeployableToAgent)(decl)) continue;
+      if (isGroupRunnerAddon(decl)) {
+        groupCandidates.push({
+          groupId: (0, import_types2.resolveRunnerId)(decl, addonId),
+          addonId,
+          addonDir: dir,
+          version: decl.version ?? "0.0.0",
+          packageName: manifest.packageName,
+          packageVersion: manifest.packageVersion,
+          capabilities: decl.capabilities ?? []
+        });
+      } else {
+        inProcessDirs.add(dir);
+      }
+    }
+  }
+  if (inProcessDirs.size > 0) {
+    await loadInProcessDeployedAddons(
+      broker,
+      [...inProcessDirs],
+      dataDir,
+      loadedAddons,
+      storageProvider,
+      loggerFactory,
+      capabilityRegistry
+    );
+  }
+  if (groupCandidates.length === 0) return;
+  if (!capabilityRegistry) {
+    console.warn(
+      `[Agent] ${groupCandidates.length} deployed group addon(s) skipped \u2014 no capabilityRegistry passed`
+    );
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const c of groupCandidates) {
+    const arr = grouped.get(c.groupId) ?? [];
+    arr.push(c);
+    grouped.set(c.groupId, arr);
+  }
+  const deployLogger = loggerFactory("agent-group-runner");
+  for (const [groupId, addons] of grouped) {
+    await ensureGroupRunner(
+      { broker, capabilityRegistry, loadedAddons, logger: deployLogger },
+      groupId,
+      addons
+    );
+  }
+}
+async function loadInProcessDeployedAddons(broker, dirs, dataDir, loadedAddons, storageProvider, loggerFactory, capabilityRegistry) {
   const modelsDir = storageProvider ? await storageProvider.resolve({ location: "models", relativePath: "" }).catch(() => void 0) : void 0;
   const contextOptions = {
     storageProvider,
@@ -1164,45 +1396,56 @@ async function loadDeployedAddons(broker, addonsDir, dataDir, loadedAddons, stor
     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;
+  for (const dir of dirs) {
+    const loader = new import_system3.AddonLoader();
     try {
-      const instance = new registered.addonClass();
-      const context = await (0, import_system3.createAddonContext)(
-        broker,
-        registered.declaration,
-        dataDir,
-        contextOptions
-      );
-      await instance.initialize(context);
-      const serviceSchema = (0, import_system3.createAddonService)(instance, registered.declaration);
-      broker.createService(serviceSchema);
-      loadedAddons.set(addonId, {
-        id: addonId,
-        status: "running",
-        version: registered.declaration.version,
-        packageName: registered.packageName,
-        addon: instance
-      });
-      console.log(`[Agent] Deployed addon "${addonId}" loaded`);
+      await loader.loadFromAddonDir(dir);
     } 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" });
+      console.warn(`[Agent] Skipping ${dir}: ${(0, import_types3.errMsg)(err)}`);
+      continue;
+    }
+    for (const registered of loader.listAddons()) {
+      const addonId = registered.declaration.id;
+      if (loadedAddons.has(addonId)) continue;
+      if (!(0, import_types2.isDeployableToAgent)(registered.declaration)) continue;
+      if (isGroupRunnerAddon(registered.declaration)) continue;
+      try {
+        const instance = new registered.addonClass();
+        const context = await (0, import_system3.createAddonContext)(
+          broker,
+          registered.declaration,
+          dataDir,
+          contextOptions
+        );
+        await instance.initialize(context);
+        const serviceSchema = (0, import_system3.createAddonService)(instance, registered.declaration);
+        broker.createService(serviceSchema);
+        loadedAddons.set(addonId, {
+          id: addonId,
+          status: "running",
+          version: registered.declaration.version,
+          packageName: registered.packageName,
+          packageVersion: registered.packageVersion,
+          addon: instance
+        });
+        console.log(`[Agent] Deployed addon "${addonId}" loaded in-process`);
+      } catch (err) {
+        const msg = (0, import_types3.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")
+    path6.resolve(__dirname, "..", "package.json"),
+    path6.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 (!fs6.existsSync(candidate)) continue;
+      const raw = JSON.parse(fs6.readFileSync(candidate, "utf-8"));
       if (raw.name === "@camstack/agent" && typeof raw.version === "string") return raw.version;
     } catch {
     }
@@ -1211,24 +1454,24 @@ function readAgentVersion() {
 }
 function isDir(p) {
   try {
-    return fs4.statSync(p).isDirectory();
+    return fs6.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 (!fs6.existsSync(addonsDir)) return dirs;
+  for (const name of fs6.readdirSync(addonsDir)) {
+    const full = path6.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"))) {
+      for (const sub of fs6.readdirSync(full)) {
+        const subFull = path6.join(full, sub);
+        if (isDir(subFull) && fs6.existsSync(path6.join(subFull, "package.json"))) {
           dirs.push(subFull);
         }
       }
-    } else if (isDir(full) && fs4.existsSync(path4.join(full, "package.json"))) {
+    } else if (isDir(full) && fs6.existsSync(path6.join(full, "package.json"))) {
       dirs.push(full);
     }
   }