@camstack/server 1.1.23 → 1.1.25

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

@@ -1,15 +1,38 @@
 "use strict";
+/**
+ * Health endpoints — fast probe surface for monitoring (k8s, uptime,
+ * external watchdogs).
+ *
+ * Routes:
+ *   - GET /health                 → hub self-health (in-memory registry ONLY, no RPC)
+ *   - GET /health/agents          → online agent node IDs (in-memory registry ONLY, no RPC)
+ *   - GET /health/agents/:nodeId  → forward to agent's `$agent.health`
+ *   - GET /health/cluster         → hub + every online agent in one shot
+ *
+ * `/health` and `/health/agents` are served purely from the hub's in-memory
+ * Moleculer node registry (`listNodeLiveness`) and NEVER fan out to agent
+ * nodes — a frozen/ghost agent cannot slow them. This is what makes `/health`
+ * safe as the admin-ui's 4s hub-liveness probe (#26): the old path went
+ * through `listNodes()` which RPCs `$agent.status`/`$process.list` at 5s/node.
+ * `/health/agents/:nodeId` and `/health/cluster` are the (intentional)
+ * forwarding surfaces backed by the `$agent.health` Moleculer action, so
+ * monitors talking to the hub and monitors talking directly to an agent
+ * (`http://<agent>:4444/health`) see identical payloads.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHubHealth = buildHubHealth;
 exports.registerHealthRoutes = registerHealthRoutes;
 const AGENT_HEALTH_TIMEOUT_MS = 3_000;
 function nowIso() {
     return new Date().toISOString();
 }
 async function buildHubHealth(deps, proc = process) {
-    const nodes = await deps.agentRegistry.listNodes();
+    // Fan-out-free: in-memory registry snapshot only, never a per-node RPC (#26).
+    const nodes = deps.agentRegistry.listNodeLiveness();
     const remote = nodes.filter((n) => !n.isHub);
-    const online = remote.filter((n) => n.isOnline !== false).length;
+    const offlineNodes = remote.filter((n) => !n.isOnline);
     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 +42,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.id),
+        },
         cpuPercent: 0,
         memoryPercent,
         checkedAt: nowIso(),
@@ -46,10 +76,8 @@ function registerHealthRoutes(fastify, deps) {
         return health;
     });
     fastify.get('/health/agents', async () => {
-        const nodes = await deps.agentRegistry.listNodes();
-        return {
-            agents: nodes.filter((n) => !n.isHub && n.isOnline !== false).map((n) => n.info.id),
-        };
+        const nodes = deps.agentRegistry.listNodeLiveness();
+        return { agents: nodes.filter((n) => !n.isHub && n.isOnline).map((n) => n.id) };
     });
     fastify.get('/health/agents/:nodeId', async (req, reply) => {
         const { nodeId } = req.params;
@@ -64,9 +92,10 @@ function registerHealthRoutes(fastify, deps) {
     });
     fastify.get('/health/cluster', async () => {
         const hub = await buildHubHealth(deps);
-        const nodes = await deps.agentRegistry.listNodes();
-        const remote = nodes.filter((n) => !n.isHub && n.isOnline !== false);
-        const agents = await Promise.all(remote.map((n) => fetchAgentHealth(deps, n.info.id)));
+        // Enumeration only (fan-out-free); the $agent.health fan-out below is intentional.
+        const nodes = deps.agentRegistry.listNodeLiveness();
+        const remote = nodes.filter((n) => !n.isHub && n.isOnline);
+        const agents = await Promise.all(remote.map((n) => fetchAgentHealth(deps, n.id)));
         const ok = hub.ok && agents.every((a) => a.ok);
         return { ok, hub, agents, 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/api/trpc/generated-cap-routers.js

@@ -2337,6 +2337,33 @@ function createCapRouter_deviceManager(getProvider, createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.setDeviceLinks(methodInput);
         }),
+        setDisplay: trpc_middleware_js_1.adminProcedure
+            .input(types_38.deviceManagerCapability.methods.setDisplay.input.loose())
+            .output(types_38.deviceManagerCapability.methods.setDisplay.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('device-manager', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.setDisplay(methodInput);
+        }),
+        getRoleDisplayDefaults: trpc_middleware_js_1.protectedProcedure
+            .input(types_38.deviceManagerCapability.methods.getRoleDisplayDefaults.input.loose())
+            .output(types_38.deviceManagerCapability.methods.getRoleDisplayDefaults.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('device-manager', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.getRoleDisplayDefaults(methodInput);
+        }),
+        setRoleDisplayDefaults: trpc_middleware_js_1.adminProcedure
+            .input(types_38.deviceManagerCapability.methods.setRoleDisplayDefaults.input.loose())
+            .output(types_38.deviceManagerCapability.methods.setRoleDisplayDefaults.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('device-manager', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.setRoleDisplayDefaults(methodInput);
+        }),
         getWireableFields: trpc_middleware_js_1.protectedProcedure
             .input(types_38.deviceManagerCapability.methods.getWireableFields.input.loose())
             .output(types_38.deviceManagerCapability.methods.getWireableFields.output)

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

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRegistryService = void 0;
+exports.toNodeLiveness = toNodeLiveness;
 const node_crypto_1 = require("node:crypto");
 const os = __importStar(require("node:os"));
 const system_1 = require("@camstack/system");
@@ -70,6 +71,16 @@ const AGENT_BOOTSTRAP_PACKAGES = new Set([
     '@camstack/system',
     '@camstack/addon-agent-ui',
 ]);
+/**
+ * Map raw Moleculer registry nodes to the health-surface liveness rows.
+ * Child runner ids (`hub/foo`, `agent/bar`) are processes, not cluster
+ * nodes — excluded, same rule as `listNodes()` / `classifyNode`.
+ */
+function toNodeLiveness(nodes) {
+    return nodes
+        .filter((node) => !node.id.includes('/'))
+        .map((node) => ({ id: node.id, isHub: node.id === 'hub', isOnline: node.available }));
+}
 class AgentRegistryService {
     eventBus;
     moleculer;
@@ -339,6 +350,19 @@ class AgentRegistryService {
     updateAgentName(nodeId, name) {
         console.log(`[agent-registry] Agent renamed: "${nodeId}" → "${name}"`);
     }
+    /**
+     * Fan-out-free liveness snapshot for the `/health` surface. Reads ONLY
+     * the hub's in-memory Moleculer node registry — never a per-node RPC —
+     * so a frozen/ghost agent can never slow the hub-liveness probe.
+     * (`listNodes()` fans `$agent.status`/`$process.list` out at 5s/node;
+     * the admin-ui probe aborts `/health` at 4s, which turned one frozen
+     * node into a false RED "Server unreachable" banner — #26.)
+     * `onlyAvailable: false` keeps recently-offline nodes listed with
+     * `available:false`, which is what populates `agents.offlineIds`.
+     */
+    listNodeLiveness() {
+        return toNodeLiveness(this.moleculer.broker.registry.getNodeList({ onlyAvailable: false }));
+    }
     async listNodes() {
         // Get child processes for hub via $process.list
         let hubProcesses = [];

package/package.json

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