@camstack/server 1.1.22 → 1.1.24

package/dist/api/health/health.routes.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHubHealth = buildHubHealth;
 exports.registerHealthRoutes = registerHealthRoutes;
 const AGENT_HEALTH_TIMEOUT_MS = 3_000;
 function nowIso() {
@@ -8,8 +9,9 @@ function nowIso() {
 async function buildHubHealth(deps, proc = process) {
     const nodes = await deps.agentRegistry.listNodes();
     const remote = nodes.filter((n) => !n.isHub);
-    const online = remote.filter((n) => n.isOnline !== false).length;
+    const offlineNodes = remote.filter((n) => n.isOnline === false);
     const total = remote.length;
+    const online = total - offlineNodes.length;
     const memUsage = proc.memoryUsage();
     const totalMem = memUsage.heapTotal + memUsage.external + memUsage.arrayBuffers;
     const memoryPercent = totalMem > 0 ? Math.round((memUsage.heapUsed / totalMem) * 100) : 0;
@@ -19,7 +21,14 @@ async function buildHubHealth(deps, proc = process) {
         version: deps.hubVersion,
         uptimeSeconds: Math.round(proc.uptime()),
         pid: proc.pid,
-        agents: { total, online, offline: total - online },
+        agents: {
+            total,
+            online,
+            offline: offlineNodes.length,
+            // Named so health consumers (admin-ui connection banner) can say
+            // WHICH node is degraded, not only how many.
+            offlineIds: offlineNodes.map((n) => n.info.id),
+        },
         cpuPercent: 0,
         memoryPercent,
         checkedAt: nowIso(),

package/dist/api/trpc/cap-mount-helpers.js

@@ -55,6 +55,21 @@ function requireDeviceScoped(registry, capName) {
                 }
                 const native = registry.getNativeProvider(capName, deviceId);
                 if (!native) {
+                    // No native provider. For `getStatus`, the device may still have a
+                    // SYNTHESIZED status from device-links (battery/consumables wired
+                    // from sibling sensors). Consult the resolver with a null base
+                    // (the synthesize path) before failing — it returns null when the
+                    // device has no links for this cap, preserving today's error.
+                    if (prop === 'getStatus') {
+                        const deviceManager = registry.getSingleton('device-manager');
+                        const synthesized = await deviceManager?.resolveLinkedStatus?.({
+                            deviceId,
+                            cap: String(capName),
+                            baseStatus: null,
+                        });
+                        if (synthesized != null)
+                            return synthesized;
+                    }
                     throw new server_1.TRPCError({
                         code: 'PRECONDITION_FAILED',
                         message: `Capability "${String(capName)}" not registered for device ${deviceId}`,

package/dist/core/moleculer/cap-route-authority.js

@@ -16,6 +16,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodeCapAuthority = createNodeCapAuthority;
 exports.createInProcessProviderLookup = createInProcessProviderLookup;
+exports.createHubResidentProviderLookup = createHubResidentProviderLookup;
 /**
  * Build a NodeCapAuthority backed by a HubNodeRegistry.
  *
@@ -107,16 +108,42 @@ function createInProcessProviderLookup(capabilityService) {
             capabilityService.getSingleton(capName);
         if (provider === null || provider === undefined)
             return null;
-        const ref = {
-            invoke: (method, args) => {
-                const fn = provider[method];
-                if (typeof fn !== 'function') {
-                    return Promise.reject(new Error(`method "${method}" not found on cap "${capName}"`));
-                }
-                const result = fn.call(provider, args);
-                return Promise.resolve(result);
-            },
-        };
-        return ref;
+        return buildProviderRef(capName, provider);
+    };
+}
+/**
+ * NODE-ACCURATE variant of {@link createInProcessProviderLookup}: resolves a
+ * provider ONLY when one is physically resident on the hub node
+ * (`getSingletonForNode(cap, 'hub')`) — no fallback to the cluster-elected
+ * ACTIVE singleton.
+ *
+ * Rationale: `getSingleton(cap)` returns the elected provider OBJECT, which
+ * for a remote election is a Moleculer-proxy registered in the hub registry.
+ * That fallback is correct for UNPINNED singleton dispatch (election
+ * adherence) but must never satisfy an explicit `nodePin('hub')` — the
+ * "hub-in-process" route would silently execute on another node (the shm
+ * frame-plane cross-node decoder-session storm: a `decoder` call pinned to
+ * the hub landed on a remote agent whenever the hub's decoder runner was
+ * circuit-broken). Wired into `CapRouteResolver.hubResidentProviders`.
+ */
+function createHubResidentProviderLookup(capabilityService) {
+    return (capName) => {
+        const provider = capabilityService.getSingletonForNode?.(capName, 'hub');
+        if (provider === null || provider === undefined)
+            return null;
+        return buildProviderRef(capName, provider);
+    };
+}
+/** Shared cast-free InProcessProviderRef builder over a provider object. */
+function buildProviderRef(capName, provider) {
+    return {
+        invoke: (method, args) => {
+            const fn = provider[method];
+            if (typeof fn !== 'function') {
+                return Promise.reject(new Error(`method "${method}" not found on cap "${capName}"`));
+            }
+            const result = fn.call(provider, args);
+            return Promise.resolve(result);
+        },
     };
 }

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

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoleculerService = void 0;
 exports.buildChildUdsManifest = buildChildUdsManifest;
+const node_crypto_1 = require("node:crypto");
 const system_1 = require("@camstack/system");
+const types_1 = require("@camstack/types");
 const cap_router_runtime_js_1 = require("../../api/trpc/cap-router-runtime.js");
 const cap_call_fn_js_1 = require("./cap-call-fn.js");
 const cap_route_authority_js_1 = require("./cap-route-authority.js");
-const types_1 = require("@camstack/types");
-const node_crypto_1 = require("node:crypto");
 class MoleculerService {
     eventBus;
     config;
@@ -411,6 +411,12 @@ class MoleculerService {
                     null,
             }),
             inProcessProviders: (0, cap_route_authority_js_1.createInProcessProviderLookup)(this.capabilityService),
+            // Node-accurate lookup for EXPLICITLY hub-pinned calls: unlike the
+            // lookup above (which falls back to the cluster-elected ACTIVE
+            // singleton — possibly a remote proxy), this resolves only providers
+            // physically resident on the hub, so a `nodePin('hub')` fails precisely
+            // instead of silently executing on another node.
+            hubResidentProviders: (0, cap_route_authority_js_1.createHubResidentProviderLookup)(this.capabilityService),
             // Per-cap-method RPC timeout override (e.g. model-convert.convert, which
             // runs for minutes) — read from the cap definition's declared timeoutMs.
             capTimeoutMs: (capName, method) => this.capabilityService.getRegistry()?.getDefinition(capName)?.methods?.[method]?.timeoutMs,

package/package.json

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