@camstack/server 1.1.26 → 1.1.27

package/dist/api/trpc/trpc.router.js

@@ -143,10 +143,11 @@ function buildCapabilityRouters(services) {
         live: (0, live_events_router_js_1.createLiveEventsRouter)(services.eventBus, services.addonRegistry),
         // stream-probe — fixed core API (ffprobe wrapper), not a cap.
         streamProbe: (0, stream_probe_router_js_1.createStreamProbeRouter)(services.streamProbe),
-        // hwaccel — fixed core API, wraps the per-node `$hwaccel` Moleculer
-        // service. UI pipeline / NodeDetail pages query per-node to show
-        // which hardware backend each agent will use.
-        hwaccel: (0, hwaccel_router_js_1.createHwAccelRouter)(services.moleculer?.broker ?? null),
+        // hwaccel — fixed core API, repointed onto the `platform-probe` cap
+        // (the sole cross-node-pinnable hwaccel surface). UI pipeline /
+        // NodeDetail pages query per-node to show which hardware backend each
+        // agent will use.
+        hwaccel: (0, hwaccel_router_js_1.createHwAccelRouter)(services.capabilityRegistry, services.moleculer),
         auth: (0, auth_router_js_1.createAuthRouter)(services.authService, services.capabilityRegistry),
         // ── Cap overrides: `mount: { kind: 'custom' }` ──────────────────
         // `snapshot-provider.supportsDevice` is an OR across providers;

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

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AddonRegistryService = void 0;
+exports.shouldEmitProviderRegisteredReady = shouldEmitProviderRegisteredReady;
 /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access -- pre-existing lint debt across this 2200-line orchestration class. The flagged sites (StorageService.setLocationManager / setSettingsBackend, LoggingService.addDestination, RouteRegistry, etc.) are typed as `unknown` by their owning services to break circular construction-order dependencies; runtime contracts are validated structurally. Tracked separately; do not amend in unrelated edits. */
 const os = __importStar(require("node:os"));
 const addon_row_manifest_1 = require("./addon-row-manifest");
@@ -159,6 +160,19 @@ function parseDataPlaneEndpoints(raw) {
 // shim that consumed it were deleted. All settings flow through the
 // new `getAddonSettings / getGlobalSettings / getDeviceSettings`
 // endpoints on the `addon-settings` singleton capability.
+/**
+ * Whether the `capability:provider-registered` hook may emit `ready` for a
+ * capability. `platform-probe` OWNS its readiness protocol: its provider
+ * registers synchronously from `onInitialize` while the REAL probe
+ * (hardware + embedded-Python EP scoring) is still running async — the
+ * registration-time emit would flip it `ready` prematurely and probe-gated
+ * consumers (detection-pipeline engine auto-pick) would read
+ * accelerator-blind results. The addon emits `starting`/`ready`/`down`
+ * itself (`autoEmitReadiness=false`, ready on probe-done).
+ */
+function shouldEmitProviderRegisteredReady(capability) {
+    return capability !== 'platform-probe';
+}
 class AddonRegistryService {
     loggingService;
     eventBusService;
@@ -2048,13 +2062,18 @@ class AddonRegistryService {
             // loops). The node-scoped emit is sufficient: the hydrate
             // path on subprocess brokers replays whichever records the
             // hub's `$readiness.getSnapshot` returns, scope and all.
-            try {
-                this.moleculer.readinessRegistry.emitReady(capability, { type: 'node', nodeId: 'hub' });
-            }
-            catch (err) {
-                this.logger.warn('emitReady failed', {
-                    meta: { capability, addonId, error: (0, types_1.errMsg)(err) },
-                });
+            // Caps that OWN their readiness (platform-probe: registration
+            // happens while its async probe still runs) are excluded —
+            // this emit would flip them `ready` prematurely.
+            if (shouldEmitProviderRegisteredReady(capability)) {
+                try {
+                    this.moleculer.readinessRegistry.emitReady(capability, { type: 'node', nodeId: 'hub' });
+                }
+                catch (err) {
+                    this.logger.warn('emitReady failed', {
+                        meta: { capability, addonId, error: (0, types_1.errMsg)(err) },
+                    });
+                }
             }
             switch (capability) {
                 case 'storage': {

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

@@ -407,12 +407,27 @@ class AgentRegistryService {
         const hubEntry = await this.buildHubEntry(hubProcesses);
         const remoteEntries = [];
         const registry = this.moleculer.broker.registry;
-        const nodes = registry?.getNodeList?.({ onlyAvailable: true }) ?? [];
+        // `onlyAvailable: false` intentionally includes nodes Moleculer still
+        // remembers as disconnected (`available: false`) — the same registry
+        // read `listNodeLiveness()` uses for `/health`. This surfaces recently
+        // offline agents inline instead of silently omitting them; it is NOT a
+        // new shadow map (no persistence, no timestamp field added anywhere) —
+        // once Moleculer's own `cleanOfflineNodesTimeout` purges the entry, the
+        // row disappears again. A hub-restart-surviving offline history is a
+        // separate, deliberately deferred piece of work.
+        const nodes = registry?.getNodeList?.({ onlyAvailable: false }) ?? [];
         for (const node of nodes) {
             const nodeId = node.id;
             // Skip hub (already included) and child processes (contain '/')
             if (nodeId === 'hub' || nodeId.includes('/'))
                 continue;
+            if (!node.available) {
+                // Offline: skip the `$agent.status`/`$process.list` RPC fan-out
+                // entirely (the node is unreachable — those calls would just time
+                // out) and surface a minimal, honestly-degraded row instead.
+                remoteEntries.push(this.buildOfflineEntry(node));
+                continue;
+            }
             try {
                 const status = (await this.broker.call('$agent.status', {}, {
                     nodeID: nodeId,
@@ -486,12 +501,50 @@ class AgentRegistryService {
                 // Skip nodes without $agent service
             }
         }
-        // TODO(D3 follow-up): offline-agent history dropped with knownAgents.
-        // Previously, agents that disconnected were kept in a shadow map and
-        // surfaced here as offline rows. listNodes now reflects only live
-        // broker.registry nodes.
+        // Offline agents ARE included above (see the `!node.available` branch)
+        // as long as Moleculer's own registry still remembers them. That window
+        // is transient — it does not survive a hub restart and disappears once
+        // `cleanOfflineNodesTimeout` purges the entry. A durable, restart-proof
+        // offline-node history is a separate, deliberately deferred piece of
+        // work (would need its own routing-blind store — never a `knownAgents`-
+        // style addition to `HubNodeRegistry`).
         return [hubEntry, ...remoteEntries];
     }
+    /**
+     * Minimal, honestly-degraded entry for a node Moleculer's registry still
+     * remembers but marks `available: false`. No RPC round-trip is attempted
+     * (the node is unreachable by definition) so every live-only field is
+     * zeroed/defaulted rather than guessed. `connectedSince: Date.now()`
+     * keeps the downstream `uptime = Date.now() - connectedSince` topology
+     * projection at ~0 instead of asserting a stale/undefined value.
+     */
+    buildOfflineEntry(node) {
+        return {
+            info: {
+                id: node.id,
+                name: node.id,
+                hostname: node.hostname ?? node.id,
+                capabilities: [],
+                platform: 'unknown',
+                arch: 'unknown',
+                cpuCores: 0,
+                memoryMB: 0,
+            },
+            localIps: [],
+            status: {
+                activeCameras: 0,
+                cpuPercent: 0,
+                memoryPercent: 0,
+                fps: {},
+                errors: [],
+            },
+            connectedSince: Date.now(),
+            isHub: false,
+            isOnline: false,
+            subProcesses: [],
+            agentAddons: [],
+        };
+    }
     async buildHubEntry(subProcesses = []) {
         const cpus = os.cpus();
         // Get live metrics from the metrics-provider capability (NativeMetricsProvider).

package/dist/core/moleculer/moleculer.service.js

@@ -251,6 +251,14 @@ class MoleculerService {
                 // handler retries the hub-local route then throws a precise error rather
                 // than the unroutable broker fallback (`switch.switch.getStatus`).
                 isDeviceNativeCap: (capName) => this.capabilityService.getRegistry()?.getDefinition(capName)?.deviceNative === true,
+                // `nodeIdMode: 'data'` signal: for these caps (`addon-settings`,
+                // `addons`, `nodes`, `pipeline-orchestrator`) an inline `args.nodeId`
+                // is provider DATA — the hub singleton dispatches internally — never a
+                // routing pin. Without this a forked child's call carrying `nodeId`
+                // gets pinned to a node with no provider (dead broker fallback →
+                // ServiceNotFoundError). The kernel layer has no cap registry, so feed
+                // it the flag from the cap definition.
+                isDataNodeIdCap: (capName) => this.capabilityService.getRegistry()?.getDefinition(capName)?.nodeIdMode === 'data',
                 // Empty-collection fast-path: a `collection` cap's array-output method
                 // with ZERO providers registered cluster-wide IS the empty aggregate —
                 // return [] instead of routing (resolver miss → broker fallback → ~30s
@@ -388,12 +396,6 @@ class MoleculerService {
             probe: (url, options) => this.streamProbe.probe(url, options),
             probeField: (key, value) => this.streamProbe.probeField(key, value),
         }));
-        // Register `$hwaccel` on hub — every node in the cluster does the
-        // same so `broker.call('$hwaccel.resolve', params, { nodeID })`
-        // returns the backend list for whichever host the caller targets.
-        // Admin UI uses this to show per-agent hwaccel info on the
-        // pipeline / NodeDetail pages.
-        this.brokerSafe.createService((0, system_1.createHwAccelService)((0, system_1.createKernelHwAccel)()));
         await this.brokerSafe.start();
         logger.info('Moleculer broker started (TCP transport)');
         // Construct the CapRouteResolver now that both the broker and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.1.26",
+  "version": "1.1.27",
   "private": false,
   "files": [
     "dist",