@camstack/server 1.2.72 → 1.2.74

package/dist/agent/agent-service.js

@@ -545,6 +545,13 @@ function createAgentService(deps) {
                         return { success: false, loaded: [] };
                     }
                     const loaded = await deps.reloadDeployedAddons();
+                    // The reload just changed this node's capability set. Re-run the
+                    // atomic registerNode so the hub's routing authority learns it now,
+                    // instead of at the next restart / reconnect. Unconditional: an
+                    // empty `loaded` still covers a RE-load of an existing addon whose
+                    // manifest gained a capability, and registerNode is an idempotent
+                    // replace (D3), so a no-op re-register costs one acked RPC.
+                    deps.reconcileNodeRegistration?.();
                     return { success: true, loaded };
                 },
             },

package/dist/agent/infra-boot-guard.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * infra-boot-guard.ts — the agent's "did my infrastructure actually load?" gate.
+ *
+ * `bootCoreAddons` resolves each {@link INFRA_CAPABILITIES} entry to an addon
+ * package found under `<dataDir>/addons`. Two things can go wrong, and until
+ * 2026-08-08 only ONE of them was fatal:
+ *
+ *   - the addon was found but its `initialize()` threw  → boot aborted (correct);
+ *   - the addon was NOT FOUND at all                    → `console.error`, continue.
+ *
+ * The second branch is strictly worse than the first and it was the quiet one.
+ * On `little-unraid` the whole `@camstack/system` package was renamed out of
+ * `/data/addons/@camstack/` at 16:40 on 2026-08-07 (a builtin-shadow cleanup).
+ * On an AGENT that directory is the SOLE source of the builtins — there is no
+ * seed fallback — so the next boot came up with ZERO infra addons: no storage,
+ * no settings-store, no metrics, no `platform-probe`, and no `hub-forwarder`.
+ *
+ * The node then reported `healthy`, registered its 14 forked addons with the
+ * hub, and kept running. Nothing said otherwise, because the ONE addon that
+ * ships an agent's logs to the hub (`hub-forwarder`, a `log-destination`) is in
+ * the same missing package: the failure was unobservable BY CONSTRUCTION. It
+ * surfaced five hours later, and only indirectly, as
+ * `getNodeInferenceDevices → reachable:false` on the hub — because the node's
+ * `registerNode` manifest legitimately no longer contained `platform-probe`,
+ * so `CapRouteResolver.nodeKnowsCap` correctly answered "no provider".
+ *
+ * `InfraCapability.required` is documented as "boot aborts when this
+ * capability's addon fails to initialize". A capability whose addon is not
+ * even present has failed harder. This guard makes both branches agree.
+ *
+ * It reports EVERY missing required capability in one throw, not just the
+ * first — an operator staring at a crash-loop needs the whole list, and the
+ * four that vanished together on little-unraid vanished for one single reason.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRequiredInfraResolved = assertRequiredInfraResolved;
+/**
+ * Throw when any `required` infra capability resolved to no addon at all.
+ *
+ * Called AFTER the resolution pass so the message names every missing
+ * capability at once. Non-required misses (`platform-probe`,
+ * `metrics-provider`, `log-destination`) are the caller's business — they are
+ * already logged individually and are legitimately absent on some nodes.
+ */
+function assertRequiredInfraResolved(resolutions, addonsDir) {
+    const missing = resolutions.filter((r) => r.required && r.addonId === null).map((r) => r.name);
+    if (missing.length === 0)
+        return;
+    throw new Error(`Required infrastructure capabilities have no addon under "${addonsDir}": ` +
+        `${missing.join(', ')}. The agent's builtins package (@camstack/system) is ` +
+        `missing or unreadable — this node cannot store, configure or probe itself, ` +
+        `and every hub routing decision that consults its manifest would be wrong. ` +
+        `Refusing to boot degraded.`);
+}

package/dist/agent/main.js

@@ -45,6 +45,7 @@ const types_2 = require("@camstack/types");
 const agent_config_js_1 = require("./agent-config.js");
 const agent_update_service_js_1 = require("./agent-update-service.js");
 const server_management_provider_js_1 = require("../api/core/server-management.provider.js");
+const infra_boot_guard_js_1 = require("./infra-boot-guard.js");
 const agent_service_js_1 = require("./agent-service.js");
 const agent_group_runner_js_1 = require("./agent-group-runner.js");
 const register_agent_cap_dispatch_js_1 = require("./register-agent-cap-dispatch.js");
@@ -409,6 +410,13 @@ async function startAgent(configPath) {
             }
             return loaded;
         },
+        // The reload above changed this node's capability set — re-derive the
+        // manifest from the live registry and re-run the atomic `registerNode`
+        // so the hub's `CapRouteResolver` can route to what this node now has.
+        // Hung on the existing `$agent.reload` trigger; no timer (D3).
+        reconcileNodeRegistration: () => {
+            triggerUpwardRegistration();
+        },
         // D3 subtree aggregation: when a group-runner child delivers its manifest
         // via `$agent.registerNode`, merge it into the local subtree registry and
         // immediately re-register the complete union with the hub.
@@ -776,6 +784,10 @@ async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFact
             console.warn(`[Agent] Failed to scan ${dir}: ${(0, types_2.errMsg)(err)}`);
         }
     }
+    // Every infra capability and the addon that will serve it — collected as we
+    // go so `assertRequiredInfraResolved` can name ALL missing required caps in
+    // one throw once the pass is done (see `infra-boot-guard.ts`).
+    const resolutions = [];
     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;
@@ -786,12 +798,16 @@ async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFact
             ? (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`);
-            }
+            // Say it per-capability (an OPTIONAL miss is the only thing this line
+            // will ever report once the guard below is in place), then record the
+            // miss so the required ones abort boot together rather than one at a
+            // time.
+            console.error(`[Agent] Infrastructure addon for "${infra.name}" not found`);
+            resolutions.push({ name: infra.name, required: infra.required, addonId: null });
             continue;
         }
         const addonId = addon.declaration.id;
+        resolutions.push({ name: infra.name, required: infra.required, addonId });
         try {
             const instance = new addon.addonClass();
             // Seed ctx.kernel.storage from whatever storage provider is already
@@ -834,6 +850,12 @@ async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFact
             }
         }
     }
+    // A required infra capability with NO addon at all is strictly worse than
+    // one whose addon threw (which already aborted above) — and it used to be
+    // the SILENT branch. Abort here instead of booting a node that cannot
+    // store, configure or probe itself and whose manifest then makes every hub
+    // routing decision about it wrong. See `infra-boot-guard.ts`.
+    (0, infra_boot_guard_js_1.assertRequiredInfraResolved)(resolutions, config.addonsDir);
 }
 // ---------------------------------------------------------------------------
 // Phase 1.5: Load cluster-capable addon packages

package/dist/api/sse-no-compression.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markSseRequestNoCompression = markSseRequestNoCompression;
+/** Mutates the request headers in place; returns whether it marked the request. */
+function markSseRequestNoCompression(request) {
+    const accept = request.headers.accept;
+    if (typeof accept === 'string' && accept.includes('text/event-stream')) {
+        request.headers['x-no-compression'] = '1';
+        return true;
+    }
+    return false;
+}

package/dist/api/trpc/generated-cap-mounts.js

@@ -2,7 +2,7 @@
 // AUTO-GENERATED by scripts/generate-cap-mounts.ts — DO NOT EDIT
 // Re-run: npx tsx scripts/generate-cap-mounts.ts
 //
-// Mounted: 143    Skipped (legacy): 3
+// Mounted: 144    Skipped (legacy): 3
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LEGACY_SHAPE_SKIP = void 0;
 exports.mountAllCaps = mountAllCaps;
@@ -350,6 +350,7 @@ function mountAllCaps(services) {
             return entries[0]?.[1] ?? null;
         }, remoteCapProxy),
         osd: (0, generated_cap_routers_js_1.createCapRouter_osd)((_ctx) => (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, 'osd'), remoteCapProxy),
+        osdManager: (0, generated_cap_routers_js_1.createCapRouter_osdManager)((_ctx) => reg?.getSingleton('osd-manager') ?? null, remoteCapProxy),
         petFeeder: (0, generated_cap_routers_js_1.createCapRouter_petFeeder)((_ctx) => (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, 'pet-feeder'), remoteCapProxy),
         pipelineAnalytics: (0, generated_cap_routers_js_1.createCapRouter_pipelineAnalytics)((_ctx) => reg?.getSingleton('pipeline-analytics') ?? null, remoteCapProxy),
         pipelineExecutor: (0, generated_cap_routers_js_1.createCapRouter_pipelineExecutor)((_ctx) => reg?.getSingleton('pipeline-executor') ??