@camstack/server 1.2.13 → 1.2.15

package/dist/core/agent/agent-registry.service.js

@@ -33,15 +33,25 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentRegistryService = void 0;
+exports.AgentRegistryService = exports.AGENT_BACKFILL_RPC_TIMEOUT_MS = void 0;
 exports.toNodeLiveness = toNodeLiveness;
 exports.toDescriptor = toDescriptor;
 const node_crypto_1 = require("node:crypto");
 const os = __importStar(require("node:os"));
 const system_1 = require("@camstack/system");
 const types_1 = require("@camstack/types");
+const agent_addon_backfill_1 = require("./agent-addon-backfill");
 /** Per-call timeout for `$agent.*` RPC during reconciliation. */
 const AGENT_RECONCILE_RPC_TIMEOUT_MS = 8_000;
+/**
+ * Timeout for a back-fill `$agent.deploy` / `$agent.reload`. Generous on
+ * purpose: the agent pulls the tarball over HTTP, runs its installer
+ * (`installFromTgz` → runtime-dep `npm install` → native prebuilds) and
+ * re-instantiates the package's addons. For the pipeline stack that is minutes,
+ * and a timeout here aborts the call even though the deploy already landed.
+ * Matches the `addons.updatePackage` agent path.
+ */
+exports.AGENT_BACKFILL_RPC_TIMEOUT_MS = 300_000;
 /**
  * Package name of the system/infrastructure builtins. Addons shipped in
  * `@camstack/system` (filesystem-storage, storage-orchestrator,
@@ -73,6 +83,24 @@ const AGENT_BOOTSTRAP_PACKAGES = new Set([
     '@camstack/system',
     '@camstack/addon-agent-ui',
 ]);
+/** Derive the package roster (name → version) from a node's addon list. */
+function rosterFromAddons(addons) {
+    const byName = new Map();
+    for (const addon of addons) {
+        if (addon.packageName === undefined || addon.packageName.length === 0)
+            continue;
+        const existing = byName.get(addon.packageName);
+        // Prefer an entry that carries a version — sibling addons of one package
+        // report the same package version, but a degraded one may omit it.
+        if (existing !== undefined && existing.version !== null)
+            continue;
+        byName.set(addon.packageName, {
+            name: addon.packageName,
+            version: addon.version !== undefined && addon.version.length > 0 ? addon.version : null,
+        });
+    }
+    return [...byName.values()];
+}
 /**
  * Map raw Moleculer registry nodes to the health-surface liveness rows.
  * Child runner ids (`hub/foo`, `agent/bar`) are processes, not cluster
@@ -130,6 +158,26 @@ class AgentRegistryService {
      * fakes) stay untouched; a null store means "history disabled" (best-effort).
      */
     historyStore = null;
+    /**
+     * Side-effecting half of the addon back-fill (pack → `$agent.deploy` →
+     * `$agent.reload`). Wired post-construction from `manual-boot` because it
+     * needs `AddonPackageService`, which is built in a later layer. `null` means
+     * "back-fill disabled" — the reconcile then behaves exactly as it did before
+     * (undeploy-only), which is what unit fakes and the agent role rely on.
+     */
+    addonBackfill = null;
+    /**
+     * Bounded per-`(node, package)` delivery breaker — see
+     * `agent-addon-backfill.ts`. Process-scoped, holds no intent.
+     */
+    backfillTracker = new agent_addon_backfill_1.BackfillAttemptTracker();
+    /**
+     * Nodes with a reconcile in flight. The pass is triggered from two places
+     * (the `registerNode` ack and the hub-boot sweep) and a reconnect can fire
+     * both within one tick; without this guard two passes would compute the same
+     * diff and each deliver it.
+     */
+    reconcilingNodes = new Set();
     constructor(eventBus, moleculer, capabilityService) {
         this.eventBus = eventBus;
         this.moleculer = moleculer;
@@ -143,6 +191,46 @@ class AgentRegistryService {
     setClusterNodeHistoryStore(store) {
         this.historyStore = store;
     }
+    /** Wire (or clear) the addon back-fill delivery seam. */
+    setAddonBackfill(seam) {
+        this.addonBackfill = seam;
+    }
+    /**
+     * Delivery failures the breaker is tracking for a node — surfaced so a node
+     * that is missing capabilities never merely *looks* healthy.
+     */
+    getBackfillFailures(nodeId) {
+        return this.backfillTracker.failuresFor(nodeId);
+    }
+    /**
+     * Record that an addon was deliberately removed from a node, so the back-fill
+     * does not put it straight back on the next reconnect.
+     *
+     * This is the ONLY way a node's intended set shrinks. Called from the
+     * operator's `nodes.undeployAddon` and from the stale-addon reconcile. The
+     * addon DECLARATION id is resolved to its package through the hub registry,
+     * because delivery — and therefore the record — is per package.
+     */
+    async noteAddonUndeployed(nodeId, addonId) {
+        const packageName = this.resolvePackageForAddon(addonId);
+        if (packageName === null)
+            return;
+        if (AGENT_BOOTSTRAP_PACKAGES.has(packageName))
+            return;
+        await this.historyStore?.prunePackages(nodeId, [packageName]);
+    }
+    /** Map an addon declaration id to the package that ships it, via the hub registry. */
+    resolvePackageForAddon(addonId) {
+        if (!this.addonRegistry)
+            return null;
+        for (const row of this.addonRegistry.listAddons()) {
+            if (row.manifest.id !== addonId)
+                continue;
+            const packageName = row.manifest.packageName;
+            return typeof packageName === 'string' && packageName.length > 0 ? packageName : null;
+        }
+        return null;
+    }
     /**
      * Read the durable offline-node history — consumed by `computeTopology`
      * to render OFFLINE rows for nodes no longer in the live Moleculer window.
@@ -154,6 +242,9 @@ class AgentRegistryService {
     /** Permanently forget a node's persisted history (inline "Forget node"). */
     async forgetClusterNode(nodeId) {
         await this.historyStore?.forget(nodeId);
+        // Its intended set is gone with the row, so the back-fill breaker's memory
+        // of failed deliveries to it is meaningless — drop it too.
+        this.backfillTracker.forget(nodeId);
     }
     /** Typed view of the Moleculer broker — single documented cast. */
     get broker() {
@@ -307,6 +398,15 @@ class AgentRegistryService {
      * every sibling runner. Only a decl-id whose PACKAGE is absent from the
      * hub is treated as genuinely stale.
      *
+     * SECOND DIRECTION — back-fill. The pass is not only a remover: after the
+     * stale sweep it converges the node UP to the roster that node itself last
+     * declared (`ClusterNodeHistoryStore.getPackages`), delivering whatever is
+     * missing. Without it a node whose addons dir was wiped came back with only
+     * its bootstrap packages and the hub never sent the rest — 4 of 14 on
+     * `little-unraid`, measured. Under the volume-only image that empty state is
+     * the ordinary first boot of every rebuilt node. See `agent-addon-backfill.ts`
+     * for what defines the intended set and how retries are bounded.
+     *
      * All errors are caught and logged so a single bad agent never breaks
      * the caller (connect handler or boot pass).
      */
@@ -315,6 +415,14 @@ class AgentRegistryService {
             console.warn(`[agent-registry] Reconcile skipped for ${agentId}: addon registry not wired`);
             return;
         }
+        // Re-entrancy guard: the registration ack and the hub-boot sweep can both
+        // fire for one node, and a second pass would recompute the same diff and
+        // deliver it again while the first is still shipping bytes.
+        if (this.reconcilingNodes.has(agentId)) {
+            console.log(`[agent-registry] Reconcile ${agentId}: already in flight — skipping`);
+            return;
+        }
+        this.reconcilingNodes.add(agentId);
         try {
             const broker = this.broker;
             // The reconcile fires the moment `$hub.registerNode` acks, which can race
@@ -329,13 +437,21 @@ class AgentRegistryService {
                 timeout: AGENT_RECONCILE_RPC_TIMEOUT_MS,
             });
             const agentAddons = this.extractAgentAddons(statusRaw);
-            if (agentAddons.length === 0)
+            // `null` = the node answered with no parseable `addons` array. That is a
+            // broken status, NOT an empty node: acting on it would undeploy nothing
+            // (fine) but would back-fill the node's ENTIRE roster (not fine). Fail
+            // closed and say so.
+            if (agentAddons === null) {
+                console.warn(`[agent-registry] Reconcile ${agentId}: $agent.status carried no addon list — skipping (no undeploy, no back-fill)`);
                 return;
+            }
             // Build the hub's placement map: decl id → placement. Absence from
             // this map means "not installed on the hub". Also collect the set of
-            // PACKAGE names the hub ships — used by the version-skew guard below.
+            // PACKAGE names the hub ships — used by the version-skew guard below —
+            // and the version the hub runs, which is the back-fill's pin source.
             const hubPlacements = new Map();
             const hubPackages = new Set();
+            const hubVersions = new Map();
             for (const row of this.addonRegistry.listAddons()) {
                 const declId = row.manifest.id;
                 if (typeof declId !== 'string')
@@ -345,6 +461,10 @@ class AgentRegistryService {
                 const packageName = row.manifest.packageName;
                 if (typeof packageName === 'string' && packageName.length > 0) {
                     hubPackages.add(packageName);
+                    const packageVersion = row.manifest.packageVersion;
+                    if (typeof packageVersion === 'string' && packageVersion.length > 0) {
+                        hubVersions.set(packageName, packageVersion);
+                    }
                 }
             }
             const stale = agentAddons.filter((addon) => {
@@ -374,8 +494,12 @@ class AgentRegistryService {
             });
             if (stale.length === 0) {
                 console.log(`[agent-registry] Reconcile ${agentId}: no stale addons (${agentAddons.length} checked)`);
-                return;
             }
+            // Packages fully removed from the node by this pass. Recorded so the
+            // back-fill below cannot immediately put them back, and so the node's
+            // intended set shrinks — the only way that happens.
+            const undeployedPackages = new Set();
+            const survivingIds = new Set(agentAddons.filter((a) => !stale.includes(a)).map((a) => a.id));
             for (const addon of stale) {
                 const reason = hubPlacements.has(addon.id)
                     ? 'placement is hub-only'
@@ -386,6 +510,15 @@ class AgentRegistryService {
                         timeout: AGENT_RECONCILE_RPC_TIMEOUT_MS,
                     });
                     console.log(`[agent-registry] Reconcile ${agentId}: undeployed stale addon "${addon.id}" (${reason})`);
+                    // A package only leaves the intended set when NO surviving addon
+                    // still belongs to it — one package ships many addons, and the agent
+                    // keeps the bundle dir while a sibling is still loaded.
+                    const packageName = addon.packageName;
+                    if (packageName !== undefined && packageName.length > 0) {
+                        const siblingSurvives = agentAddons.some((a) => a.packageName === packageName && survivingIds.has(a.id));
+                        if (!siblingSurvives)
+                            undeployedPackages.add(packageName);
+                    }
                     this.eventBus.emit({
                         id: (0, node_crypto_1.randomUUID)(),
                         timestamp: new Date(),
@@ -398,18 +531,95 @@ class AgentRegistryService {
                     console.error(`[agent-registry] Reconcile ${agentId}: failed to undeploy "${addon.id}":`, err instanceof Error ? err.message : String(err));
                 }
             }
+            await this.backfillAgentAddons(agentId, agentAddons, undeployedPackages, hubVersions);
         }
         catch (err) {
             console.error(`[agent-registry] Reconcile failed for agent ${agentId}:`, err instanceof Error ? err.message : String(err));
         }
+        finally {
+            this.reconcilingNodes.delete(agentId);
+        }
     }
-    /** Narrow the `$agent.status` response down to its addon list. */
+    /**
+     * Converge a node UP to the roster it last declared.
+     *
+     * Order matters and is deliberate:
+     *   1. record what the node declares NOW (grow-only merge) — a wiped node
+     *      reporting 4 packages must not erase the record of its 14;
+     *   2. prune what this pass undeployed — the intended set's only shrink;
+     *   3. read the resulting intended set and deliver the difference.
+     *
+     * Every leg is idempotent: run twice with no change in between and step 3
+     * finds nothing to do.
+     */
+    async backfillAgentAddons(agentId, agentAddons, undeployedPackages, hubVersions) {
+        const store = this.historyStore;
+        if (!store)
+            return;
+        const live = rosterFromAddons(agentAddons);
+        await store.recordPackages(agentId, live);
+        if (undeployedPackages.size > 0) {
+            await store.prunePackages(agentId, [...undeployedPackages]);
+        }
+        const seam = this.addonBackfill;
+        if (!seam)
+            return;
+        const recorded = await store.getPackages(agentId);
+        const plan = (0, agent_addon_backfill_1.computeBackfillPlan)({
+            recorded,
+            live,
+            bootstrap: AGENT_BOOTSTRAP_PACKAGES,
+            undeployed: undeployedPackages,
+            retired: this.backfillTracker.retiredFor(agentId),
+            hubVersions,
+        });
+        if (plan.targets.length === 0 && plan.retired.length === 0 && plan.unresolvable.length === 0) {
+            return;
+        }
+        const outcome = await (0, agent_addon_backfill_1.executeBackfill)(seam, agentId, plan, this.backfillTracker);
+        if (outcome.delivered.length > 0) {
+            console.log(`[agent-registry] Back-fill ${agentId}: delivered ${outcome.delivered
+                .map((d) => `${d.name}@${d.version}`)
+                .join(', ')}`);
+            this.eventBus.emit({
+                id: (0, node_crypto_1.randomUUID)(),
+                timestamp: new Date(),
+                source: { type: 'core', id: 'agent-registry' },
+                category: types_1.EventCategory.AddonInstalled,
+                data: {
+                    agentId,
+                    packages: outcome.delivered.map((d) => `${d.name}@${d.version}`),
+                    reason: 'back-fill: node missing packages from its declared roster',
+                },
+            });
+        }
+        // Fail LOUD: a node missing capabilities must never merely look healthy.
+        for (const failure of outcome.failed) {
+            console.error(`[agent-registry] Back-fill ${agentId}: FAILED to deliver ${failure.name}@${failure.version} — ${failure.error}` +
+                (failure.retired
+                    ? ` (retired after ${agent_addon_backfill_1.MAX_BACKFILL_ATTEMPTS} attempts; this node is running WITHOUT that package)`
+                    : ''));
+        }
+        for (const name of outcome.skipped) {
+            console.error(`[agent-registry] Back-fill ${agentId}: ${name} is still missing and RETIRED — the node is degraded until an operator intervenes`);
+        }
+        for (const name of outcome.unresolvable) {
+            console.error(`[agent-registry] Back-fill ${agentId}: ${name} is missing but no version could be resolved (not installed on the hub, no version recorded) — not guessing "latest"`);
+        }
+    }
+    /**
+     * Narrow the `$agent.status` response down to its addon list.
+     *
+     * Returns `null` — not `[]` — when the response carries no parseable addon
+     * array. The distinction is load-bearing: `[]` means "this node runs no
+     * addons" (act on it), `null` means "this node did not tell us" (do not act).
+     */
     extractAgentAddons(statusRaw) {
         if (statusRaw === null || typeof statusRaw !== 'object')
-            return [];
+            return null;
         const addons = statusRaw.addons;
         if (!Array.isArray(addons))
-            return [];
+            return null;
         const result = [];
         for (const entry of addons) {
             if (entry === null || typeof entry !== 'object')
@@ -417,9 +627,15 @@ class AgentRegistryService {
             const id = entry.id;
             if (typeof id !== 'string' || id.length === 0)
                 continue;
-            // Preserve `packageName` — the reconcile uses it to skip system builtins.
+            // Preserve `packageName` — the reconcile uses it to skip system builtins,
+            // and `version` — the back-fill records it as the node's declared pin.
             const packageName = entry.packageName;
-            result.push({ id, packageName: typeof packageName === 'string' ? packageName : undefined });
+            const version = entry.version;
+            result.push({
+                id,
+                packageName: typeof packageName === 'string' ? packageName : undefined,
+                version: typeof version === 'string' ? version : undefined,
+            });
         }
         return result;
     }

package/dist/core/agent/cluster-node-history-store.js

@@ -16,6 +16,10 @@ const DescriptorSchema = zod_1.z.object({
     isHub: zod_1.z.boolean(),
     localIps: zod_1.z.array(zod_1.z.string()).readonly(),
     addonIds: zod_1.z.array(zod_1.z.string()).readonly(),
+    packages: zod_1.z
+        .array(zod_1.z.object({ name: zod_1.z.string(), version: zod_1.z.string().nullable() }))
+        .readonly()
+        .optional(),
 });
 /** Shape of a `settings-store.query` record's `data` for this collection. */
 const RowDataSchema = zod_1.z.object({
@@ -71,10 +75,18 @@ class ClusterNodeHistoryStore {
         if (!store)
             return;
         try {
+            // Carry the package roster forward. `listNodes()` does not resolve it
+            // (only the reconcile does), so writing this descriptor blind would erase
+            // the back-fill's intended set on the very next topology poll.
+            const existing = await this.readRow(store, descriptor.id);
+            const packages = descriptor.packages ?? existing?.descriptor.packages;
             await store.set({
                 collection: COLLECTION,
                 key: descriptor.id,
-                value: { lastActive: Date.now(), descriptor },
+                value: {
+                    lastActive: Date.now(),
+                    descriptor: packages === undefined ? descriptor : { ...descriptor, packages },
+                },
             });
         }
         catch (err) {
@@ -84,6 +96,131 @@ class ClusterNodeHistoryStore {
             });
         }
     }
+    /** Read one node's row, validated. `null` when absent or malformed. */
+    async readRow(store, nodeId) {
+        const raw = await store.get({ collection: COLLECTION, key: nodeId });
+        if (raw === null || raw === undefined)
+            return null;
+        const parsed = RowDataSchema.safeParse(raw);
+        return parsed.success ? parsed.data : null;
+    }
+    /** A placeholder descriptor for a node the topology pass has not seen yet. */
+    static placeholderDescriptor(nodeId) {
+        return {
+            id: nodeId,
+            name: nodeId,
+            hostname: nodeId,
+            platform: 'unknown',
+            arch: 'unknown',
+            cpuModel: null,
+            cpuCores: 0,
+            memoryMB: 0,
+            engines: [],
+            isHub: false,
+            localIps: [],
+            addonIds: [],
+        };
+    }
+    /**
+     * The node's last-declared package roster — the intended set the back-fill
+     * converges to. Empty when the hub has no record, which is the safe answer:
+     * nothing is delivered rather than something guessed.
+     */
+    async getPackages(nodeId) {
+        const store = await this.ensureDeclared();
+        if (!store)
+            return [];
+        try {
+            return (await this.readRow(store, nodeId))?.descriptor.packages ?? [];
+        }
+        catch (err) {
+            this.logger.warn('getPackages failed (best-effort)', {
+                tags: { nodeId },
+                meta: { error: (0, types_1.errMsg)(err) },
+            });
+            return [];
+        }
+    }
+    /**
+     * Merge a node's freshly declared package roster into its record.
+     *
+     * GROW-ONLY by construction: an entry absent from `packages` is left in place.
+     * That is what makes a wiped node recoverable — it reconnects declaring 4 of
+     * its 14 packages, and the record still names all 14. Removal is a separate,
+     * explicit act ({@link prunePackages}).
+     */
+    async recordPackages(nodeId, packages) {
+        if (packages.length === 0)
+            return;
+        const store = await this.ensureDeclared();
+        if (!store)
+            return;
+        try {
+            const existing = await this.readRow(store, nodeId);
+            const merged = new Map((existing?.descriptor.packages ?? []).map((p) => [p.name, p]));
+            // The node's current declaration wins on version — it is the authority on
+            // what it is actually running.
+            for (const entry of packages)
+                merged.set(entry.name, entry);
+            const descriptor = {
+                ...(existing?.descriptor ?? ClusterNodeHistoryStore.placeholderDescriptor(nodeId)),
+                packages: [...merged.values()],
+            };
+            await store.set({
+                collection: COLLECTION,
+                key: nodeId,
+                value: { lastActive: existing?.lastActive ?? Date.now(), descriptor },
+            });
+        }
+        catch (err) {
+            this.logger.warn('recordPackages failed (best-effort)', {
+                tags: { nodeId },
+                meta: { error: (0, types_1.errMsg)(err) },
+            });
+        }
+    }
+    /**
+     * Drop packages from a node's record. The ONLY way the intended set shrinks —
+     * driven by an explicit undeploy (the operator's `nodes.undeployAddon`, or the
+     * stale-addon reconcile), never by a node simply failing to report something.
+     */
+    async prunePackages(nodeId, names) {
+        if (names.length === 0)
+            return;
+        const store = await this.ensureDeclared();
+        if (!store)
+            return;
+        try {
+            const existing = await this.readRow(store, nodeId);
+            if (existing === null)
+                return;
+            const current = existing.descriptor.packages;
+            if (current === undefined || current.length === 0)
+                return;
+            const drop = new Set(names);
+            const remaining = current.filter((p) => !drop.has(p.name));
+            if (remaining.length === current.length)
+                return;
+            await store.set({
+                collection: COLLECTION,
+                key: nodeId,
+                value: {
+                    lastActive: existing.lastActive,
+                    descriptor: { ...existing.descriptor, packages: remaining },
+                },
+            });
+            this.logger.info('pruned node package record', {
+                tags: { nodeId },
+                meta: { removed: [...drop] },
+            });
+        }
+        catch (err) {
+            this.logger.warn('prunePackages failed (best-effort)', {
+                tags: { nodeId },
+                meta: { error: (0, types_1.errMsg)(err) },
+            });
+        }
+    }
     /**
      * Touch `lastActive` for a node without rewriting its descriptor — used on
      * `$node.disconnected` so an offline node's "last seen" is the disconnect

package/dist/launcher.js

@@ -355,6 +355,20 @@ async function launch() {
     else {
         console.warn('[launcher] installer.reconcileManifest unavailable — skipping manifest reconcile');
     }
+    // Reclaim orphaned pre-update rollback copies under `addons/.backups/`.
+    // Nothing used to delete them: a second update overwrote `lastBackupDir`
+    // and the previous backup lost its only pointer — 814 MiB of them on the
+    // live hub, 796 MiB of it two copies of one addon. The sweep keeps at most
+    // the manifest's rollback target per addon (and never the last surviving
+    // copy of an addon whose install dir is missing). Runs here, before any
+    // update can be in flight. Same typeof guard as reconcileManifest: an
+    // older @camstack/system must not crash boot.
+    if (typeof installer.sweepBackups === 'function') {
+        const swept = await installer.sweepBackups();
+        if (swept.removed.length > 0) {
+            console.log(`[launcher] Backup sweep — reclaimed ${swept.removed.length}, retained ${swept.kept.length}`);
+        }
+    }
     // Self-contained addon bundles (build preset `self-contained`) inline
     // @camstack/types + zod + @camstack/sdk into each addon's dist. The
     // hub no longer plants peer-dep symlinks under

package/dist/manual-boot.js

@@ -66,6 +66,7 @@ const addon_bridge_service_1 = require("./core/addon-bridge/addon-bridge.service
 const moleculer_service_1 = require("./core/moleculer/moleculer.service");
 const agent_registry_service_1 = require("./core/agent/agent-registry.service");
 const cluster_node_history_store_1 = require("./core/agent/cluster-node-history-store");
+const addon_upload_1 = require("./api/addon-upload");
 const addon_registry_service_1 = require("./core/addon/addon-registry.service");
 const addon_search_service_1 = require("./core/addon/addon-search.service");
 const addon_package_service_1 = require("./core/addon/addon-package.service");
@@ -139,6 +140,20 @@ async function bootManual(opts) {
     // dist sub-folder lookup (see service docstring).
     const addonWidgetsService = new addon_widgets_service_1.AddonWidgetsService(loggingService, capabilityService, addonRegistryService);
     const addonPackageService = new addon_package_service_1.AddonPackageService(loggingService, eventBusService, configService, addonRegistryService, notificationWrapper, toastWrapper);
+    // Addon back-fill delivery seam. Wired here (not in the AgentRegistryService
+    // constructor) because it needs AddonPackageService, which is a later layer.
+    // Bytes come from the hub's own resolution of the package — the agent needs no
+    // registry reachability of its own, and every node in the cluster lands on the
+    // same version. Delivery is an RPC pair, never an event (D8/D11).
+    agentRegistryService.setAddonBackfill({
+        pack: async (name, version) => (await addonPackageService.packPackage(name, version)).buffer,
+        deploy: async (nodeId, packageName, bundle) => {
+            await moleculerService.broker.call('$agent.deploy', { addonId: packageName, source: (0, addon_upload_1.buildHubHttpSource)(bundle, (0, addon_upload_1.hubBundleBaseUrl)()) }, { nodeID: nodeId, timeout: agent_registry_service_1.AGENT_BACKFILL_RPC_TIMEOUT_MS });
+        },
+        reload: async (nodeId) => {
+            await moleculerService.broker.call('$agent.reload', {}, { nodeID: nodeId, timeout: agent_registry_service_1.AGENT_BACKFILL_RPC_TIMEOUT_MS });
+        },
+    });
     // ---- Lifecycle job runner (boot singleton) -----------------------------
     // The runner used to be built per-tRPC-request inside the `addons` cap
     // factory. Boot-reconcile (F3 Task 4) and the auto-update scheduler (F3

package/dist/server-root/index.js

@@ -743,7 +743,9 @@ var require_dist = __commonJS({
       "@trpc/server",
       "@trpc/client",
       "sharp",
-      "node-av"
+      "node-av",
+      "node-pty",
+      "ssh2"
     ];
     function isHostExternal(specifier) {
       return HOST_EXTERNAL_SPECIFIERS.some((name) => specifier === name || specifier.startsWith(`${name}/`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.2.13",
+  "version": "1.2.15",
   "private": false,
   "files": [
     "dist",
@@ -33,19 +33,19 @@
     ]
   },
   "dependencies": {
-    "@camstack/addon-admin-ui": "1.2.13",
+    "@camstack/addon-admin-ui": "1.2.14",
     "@camstack/addon-agent-ui": "1.2.5",
     "@camstack/addon-auth": "1.2.5",
     "@camstack/addon-decoder-nodeav": "1.2.5",
     "@camstack/addon-notifiers": "1.2.6",
-    "@camstack/addon-pipeline": "1.2.11",
+    "@camstack/addon-pipeline": "1.2.13",
     "@camstack/addon-pipeline-orchestrator": "1.2.10",
-    "@camstack/addon-post-analysis": "1.2.9",
+    "@camstack/addon-post-analysis": "1.2.11",
     "@camstack/sdk": "1.2.5",
     "@camstack/shm-ring": "1.1.5",
-    "@camstack/system": "1.2.15",
-    "@camstack/types": "1.2.12",
-    "@camstack/ui-library": "1.2.10",
+    "@camstack/system": "1.2.16",
+    "@camstack/types": "1.2.14",
+    "@camstack/ui-library": "1.2.11",
     "@fastify/compress": "^9.0.0",
     "@fastify/cookie": "^11.0.2",
     "@fastify/cors": "^11.2.0",
@@ -56,6 +56,10 @@
     "fastify": "^5",
     "js-yaml": "^4",
     "moleculer": "^0.15.0",
+    "node-av": "^6.0.0",
+    "node-pty": "^1.0.0",
+    "sharp": "^0.35.2",
+    "ssh2": "^1.16.0",
     "superjson": "^2.2.6",
     "tar": "7.5.16",
     "undici": "^7.28.0",