@camstack/server 1.1.26 → 1.1.28

package/dist/api/core/cap-providers.js

@@ -167,6 +167,12 @@ function getLocalIps() {
  */
 async function computeTopology(agentRegistry, addonRegistry) {
     const nodes = await agentRegistry.listNodes();
+    // A2: durable offline-node history. `listNodes()` (above) has just
+    // snapshotted every ONLINE node into this store, so `lastActive` is fresh
+    // for live rows and preserved (at disconnect time) for offline ones.
+    const history = await agentRegistry.getClusterNodeHistory();
+    const historyById = new Map(history.map((h) => [h.id, h]));
+    const liveIds = new Set(nodes.map((n) => n.info.id));
     const allAddons = addonRegistry?.listAddons() ?? [];
     const getInGroupAddonIds = (node) => {
         const subs = (node.subProcesses ?? []);
@@ -184,7 +190,7 @@ async function computeTopology(agentRegistry, addonRegistry) {
         const category = a.declaration?.category ?? 'system';
         addonCategory.set(id, category);
     }
-    return nodes.map((node) => {
+    const liveNodes = nodes.map((node) => {
         const inGroupAddonIds = new Set(getInGroupAddonIds(node));
         const agentAddonIds = node.agentAddons ?? [];
         const allNodeAddons = node.isHub
@@ -286,13 +292,48 @@ async function computeTopology(agentRegistry, addonRegistry) {
             cpuPercent: node.status?.cpuPercent ?? 0,
             memoryPercent: node.status?.memoryPercent ?? 0,
             uptime: Date.now() - node.connectedSince,
-            lastSeen: new Date().toISOString(),
+            // Fix (was hardcoded `new Date().toISOString()` — always "now", a bug
+            // even for online nodes): report the persisted `lastActive` when we have
+            // it, falling back to now only for a node with no history row yet.
+            lastSeen: new Date(historyById.get(node.info.id)?.lastActive ?? Date.now()).toISOString(),
             localIps: node.isHub ? getLocalIps() : (node.localIps ?? []),
             addons: allNodeAddons,
             processes: [mainProcess, ...childProcesses],
             categories: categoriesProjection,
         };
     });
+    // A2: union in OFFLINE rows for every persisted node no longer present in the
+    // live Moleculer window (or gone entirely after a hub restart). These render
+    // straight from the last-known descriptor with live metrics zeroed. Nothing
+    // here participates in capability routing — it is purely a topology row.
+    const offlineNodes = history
+        .filter((persisted) => !liveIds.has(persisted.id))
+        .map((persisted) => ({
+        id: persisted.id,
+        name: persisted.name,
+        hostname: persisted.hostname,
+        platform: persisted.platform,
+        arch: persisted.arch,
+        cpuModel: persisted.cpuModel,
+        cpuCores: persisted.cpuCores,
+        memoryMB: persisted.memoryMB,
+        engines: [...persisted.engines],
+        isHub: persisted.isHub,
+        isOnline: false,
+        cpuPercent: 0,
+        memoryPercent: 0,
+        uptime: 0,
+        lastSeen: new Date(persisted.lastActive).toISOString(),
+        localIps: [...persisted.localIps],
+        addons: persisted.addonIds.map((id) => ({
+            id,
+            capabilities: [...(addonCaps.get(id) ?? [])],
+            status: 'stopped',
+        })),
+        processes: [],
+        categories: [],
+    }));
+    return [...liveNodes, ...offlineNodes];
 }
 function buildNodesProvider(agentRegistry, moleculer, addonRegistry) {
     const broker = moleculer.broker;

package/dist/api/core/cluster-nodes.router.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClusterNodesRouter = createClusterNodesRouter;
+/**
+ * Cluster-nodes router — fixed core API (not a capability).
+ *
+ * Exposes the durable offline-node history's write-side cleanup so the admin
+ * UI's inline "Forget node" action can purge a node the operator never expects
+ * to see again. Hand-written (not a `*.cap.ts`) on purpose: it needs no
+ * per-provider routing and adding a cap method would force a full codegen pass.
+ *
+ * The read side (`getClusterNodeHistory`) is consumed server-side by
+ * `computeTopology` and is intentionally NOT exposed here — the admin UI reads
+ * offline rows off the pushed `cluster.topology-snapshot`, never by polling.
+ */
+const zod_1 = require("zod");
+const trpc_middleware_js_1 = require("../trpc/trpc.middleware.js");
+const ForgetNodeInputSchema = zod_1.z.object({ nodeId: zod_1.z.string().min(1) });
+function createClusterNodesRouter(agentRegistry) {
+    return (0, trpc_middleware_js_1.trpcRouter)({
+        // Purge one node's persisted offline history. Pairs with
+        // `pipelineOrchestrator.removeAgentSettings` on the frontend to fully
+        // forget an offline node (history row + per-node pipeline assignments).
+        forgetNode: trpc_middleware_js_1.adminProcedure
+            .input(ForgetNodeInputSchema)
+            .output(zod_1.z.object({ success: zod_1.z.boolean() }))
+            .mutation(async ({ input }) => {
+            await agentRegistry.forgetClusterNode(input.nodeId);
+            return { success: true };
+        }),
+    });
+}

package/dist/api/core/hwaccel.router.js

@@ -4,16 +4,16 @@ exports.createHwAccelRouter = createHwAccelRouter;
 /**
  * Hwaccel router — fixed core API (not a capability).
  *
- * Thin wrapper around the per-node `$hwaccel.resolve` Moleculer
- * service. The hub-local instance (same process) serves the default
- * `resolve` call; the per-node `resolveForNode` action targets any
- * node in the cluster — used by the admin UI pipeline / NodeDetail
- * pages to show the hwaccel backends available on each agent.
+ * Repointed (S3 consolidation) onto the `platform-probe` capability — the SOLE
+ * cross-node-pinnable hwaccel surface — instead of the retired `$hwaccel`
+ * Moleculer service. The hub-local instance is resolved via
+ * `capabilityRegistry.getSingleton('platform-probe')`; any other cluster node
+ * via `moleculer.createCapabilityProxy('platform-probe', nodeId)` (the same
+ * node-routing the codegen'd cap routers use). Used by the admin UI pipeline /
+ * NodeDetail pages to show which hardware backend each node will use.
  *
- * Cross-node behaviour: `resolveForNode({ nodeId })` forwards via
- * `broker.call('$hwaccel.resolve', params, { nodeID })`. Every node
- * (hub + forked worker + remote agent) registers `$hwaccel` at
- * bootstrap, so any reachable nodeId works.
+ * The tRPC input/output shapes are UNCHANGED for clients (`{prefer}` in,
+ * `{preferred, rationale}` out) — no SDK break.
  */
 const zod_1 = require("zod");
 const trpc_middleware_js_1 = require("../trpc/trpc.middleware.js");
@@ -33,33 +33,69 @@ const HwAccelPreferSchema = zod_1.z
     .union([HwAccelBackendSchema, zod_1.z.literal('none')])
     .nullable()
     .optional();
+// `preferred` is a plain string array (not the decode-backend enum) to match
+// the `platform-probe` cap's own resolution schema: the resolver only ever
+// emits decode backends, but a narrow enum would reject any future addition and
+// force a cast at the cap boundary.
 const HwAccelResolutionSchema = zod_1.z.object({
-    preferred: zod_1.z.array(HwAccelBackendSchema).readonly(),
+    preferred: zod_1.z.array(zod_1.z.string()).readonly(),
     rationale: zod_1.z.string(),
 });
-function createHwAccelRouter(broker) {
+/**
+ * Resolve hwaccel on a specific cluster node through the `platform-probe` cap
+ * proxy. `createCapabilityProxy` returns `Record<string, (params) =>
+ * Promise<unknown>> | null`; rather than casting that to the provider type
+ * (the webrtc-session mount does — repo rule forbids it), we call the proxy's
+ * `resolveHwAccel` and narrow its result through the cap's Zod OUTPUT schema.
+ * A missing proxy (node unreachable), a missing method, a malformed response,
+ * or a thrown call all degrade to an EXPLAINED empty list rather than
+ * corrupting the typed API surface.
+ */
+async function resolveHwAccelOnNode(moleculer, nodeId, prefer) {
+    const proxy = moleculer?.createCapabilityProxy('platform-probe', nodeId) ?? null;
+    const resolveFn = proxy?.['resolveHwAccel'];
+    if (!resolveFn) {
+        return { preferred: [], rationale: `node ${nodeId} unreachable` };
+    }
+    try {
+        const raw = await resolveFn({ prefer });
+        const parsed = HwAccelResolutionSchema.safeParse(raw);
+        if (!parsed.success) {
+            return { preferred: [], rationale: `invalid probe response from ${nodeId}` };
+        }
+        return parsed.data;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { preferred: [], rationale: `resolve failed: ${msg}` };
+    }
+}
+function listAvailableNodeIds(moleculer) {
+    const broker = moleculer?.broker ?? null;
+    if (!broker)
+        return [];
+    const withRegistry = broker;
+    return withRegistry.registry.getNodeList({ onlyAvailable: true }).map((n) => n.id);
+}
+function createHwAccelRouter(capabilityRegistry, moleculer) {
     return (0, trpc_middleware_js_1.trpcRouter)({
-        /** Probe the current hub process. */
+        /** Probe the current hub process via the local `platform-probe` singleton. */
         resolve: trpc_middleware_js_1.adminProcedure
             .input(zod_1.z.object({ prefer: HwAccelPreferSchema }).optional())
             .output(HwAccelResolutionSchema)
             .query(async ({ input }) => {
-            if (!broker)
-                throw new Error('Moleculer broker not available');
-            const params = { prefer: input?.prefer ?? null };
-            return broker.call('$hwaccel.resolve', params);
+            const provider = capabilityRegistry?.getSingleton('platform-probe') ?? null;
+            if (!provider) {
+                return { preferred: [], rationale: 'platform-probe capability not available' };
+            }
+            return provider.resolveHwAccel({ prefer: input?.prefer ?? null });
         }),
         /** Probe a specific node in the cluster — used by per-agent UI cards. */
         resolveForNode: trpc_middleware_js_1.adminProcedure
             .input(zod_1.z.object({ nodeId: zod_1.z.string(), prefer: HwAccelPreferSchema }))
             .output(HwAccelResolutionSchema)
             .query(async ({ input }) => {
-            if (!broker)
-                throw new Error('Moleculer broker not available');
-            const params = { prefer: input.prefer ?? null };
-            return broker.call('$hwaccel.resolve', params, {
-                nodeID: input.nodeId,
-            });
+            return resolveHwAccelOnNode(moleculer, input.nodeId, input.prefer ?? null);
         }),
         /** List every node currently reachable and the hwaccel each resolves to. */
         resolveAll: trpc_middleware_js_1.adminProcedure
@@ -68,24 +104,11 @@ function createHwAccelRouter(broker) {
             resolution: HwAccelResolutionSchema,
         })))
             .query(async () => {
-            if (!broker)
-                throw new Error('Moleculer broker not available');
-            const registry = broker.registry;
-            const nodes = registry.getNodeList({ onlyAvailable: true });
-            const results = await Promise.all(nodes.map(async (n) => {
-                try {
-                    const resolution = (await broker.call('$hwaccel.resolve', { prefer: null }, { nodeID: n.id }));
-                    return { nodeId: n.id, resolution };
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    return {
-                        nodeId: n.id,
-                        resolution: { preferred: [], rationale: `resolve failed: ${msg}` },
-                    };
-                }
-            }));
-            return results;
+            const nodeIds = listAvailableNodeIds(moleculer);
+            return Promise.all(nodeIds.map(async (nodeId) => ({
+                nodeId,
+                resolution: await resolveHwAccelOnNode(moleculer, nodeId, null),
+            })));
         }),
     });
 }

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: 130    Skipped (legacy): 6
+// Mounted: 131    Skipped (legacy): 6
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LEGACY_SHAPE_SKIP = void 0;
 exports.mountAllCaps = mountAllCaps;
@@ -294,6 +294,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),
+        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') ??
             null, remoteCapProxy),