@camstack/server 1.1.20 → 1.1.22

package/dist/api/core/event-bus-proxy.router.js

@@ -1,21 +1,38 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEventBusProxyRouter = createEventBusProxyRouter;
 /**
- * EventBus proxy router — allows forked workers to emit events to the
- * hub's EventBus via tRPC.
+ * EventBus proxy router — allows forked workers to emit events to, and
+ * read the recent-events registry of, the hub's EventBus via tRPC.
  *
  * Workers call `trpc.eventBusProxy.emit.mutate(event)` from their
  * `context.eventBus.emit()` implementation. The hub-side router
  * deserializes the event and emits it on the real EventBus.
  *
- * Subscribe/getRecent are routed through the existing `live.onEvent`
- * subscription and `events` query routers — no duplication needed here.
+ * `getRecent` exposes the hub's retained recent-events registry to forked
+ * addon runners. Post the `retainRecent` change (f5a93332) ONLY the hub
+ * main process keeps the `recent[]` buffer — a child runner's own
+ * `ctx.eventBus.getRecent()` now returns `[]`. Addons that need event
+ * HISTORY (e.g. advanced-notifier's `testRule`) must read it from the hub
+ * over this proxy instead of their local, non-retaining bus. This router
+ * is in `CORE_NAMESPACES` (`core-cap-bridge.ts`), so the call reaches the
+ * hub's `services.eventBus` from any hub-local child over the UDS/core-cap
+ * path — exactly like `capabilities.*` / `system.*`.
+ *
+ * `subscribe` is routed through the existing `live.onEvent` subscription
+ * and `systemEvents.subscribe` routers — no duplication needed here.
  *
  * Introduced in session 7 (EventBus wiring for forked addons).
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventBusProxyRouter = createEventBusProxyRouter;
 const zod_1 = require("zod");
 const trpc_middleware_js_1 = require("../trpc/trpc.middleware.js");
+/**
+ * Upper bound on the `getRecent` limit — kept in step with the hub's
+ * `recent[]` ring-buffer size (`MAX_RECENT_EVENTS` in `event-bus-core.ts`).
+ * Duplicated as a local literal rather than imported so this router does
+ * not depend on the event-bus core internals.
+ */
+const MAX_RECENT_EVENTS = 1000;
 const SystemEventInputSchema = zod_1.z.object({
     id: zod_1.z.string(),
     timestamp: zod_1.z.string(), // ISO 8601 — converted to Date on emit
@@ -26,6 +43,50 @@ const SystemEventInputSchema = zod_1.z.object({
     category: zod_1.z.string(),
     data: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
 });
+/**
+ * `getRecent` input — mirrors `systemEvents.getRecent`'s category/limit
+ * semantics. `category` accepts a single string or an array so a caller
+ * can whitelist the categories it cares about server-side; `limit` is
+ * capped at the hub's `recent[]` buffer size (`MAX_RECENT_EVENTS`).
+ */
+const GetRecentInputSchema = zod_1.z.object({
+    category: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+    limit: zod_1.z.number().int().min(1).max(MAX_RECENT_EVENTS).optional(),
+});
+/**
+ * Serialized recent event — `timestamp` is an ISO-8601 string so the
+ * shape survives every transport (UDS/MsgPack, Moleculer) unchanged.
+ * Callers reconstruct the `Date` on receipt. Mirrors the serialization
+ * used by `systemEvents.getRecent`.
+ */
+const RecentEventOutputSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    timestamp: zod_1.z.string(),
+    source: zod_1.z.object({
+        type: zod_1.z.string(),
+        id: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]),
+        nodeId: zod_1.z.string().optional(),
+        addonId: zod_1.z.string().optional(),
+        deviceId: zod_1.z.number().optional(),
+    }),
+    category: zod_1.z.string(),
+    data: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+});
+function serializeRecentEvent(e) {
+    return {
+        id: e.id,
+        timestamp: new Date(e.timestamp).toISOString(),
+        source: {
+            type: e.source.type,
+            id: e.source.id,
+            ...(e.source.nodeId ? { nodeId: e.source.nodeId } : {}),
+            ...(e.source.addonId ? { addonId: e.source.addonId } : {}),
+            ...(e.source.deviceId !== undefined ? { deviceId: e.source.deviceId } : {}),
+        },
+        category: e.category,
+        data: e.data,
+    };
+}
 function createEventBusProxyRouter(eventBus) {
     return (0, trpc_middleware_js_1.trpcRouter)({
         emit: trpc_middleware_js_1.protectedProcedure
@@ -41,5 +102,13 @@ function createEventBusProxyRouter(eventBus) {
             });
             return { ok: true };
         }),
+        getRecent: trpc_middleware_js_1.protectedProcedure
+            .input(GetRecentInputSchema)
+            .output(zod_1.z.array(RecentEventOutputSchema))
+            .query(({ input }) => {
+            return eventBus
+                .getRecent(input.category !== undefined ? { category: input.category } : undefined, input.limit)
+                .map(serializeRecentEvent);
+        }),
     });
 }

package/dist/core/events/event-bus.service.js

@@ -36,7 +36,12 @@ class EventBusService {
         if (this.broker === broker)
             return;
         this.broker = broker;
-        const inner = (0, system_1.getBrokerEventBus)(broker);
+        // The hub main process is the ONLY process that serves `getRecent` — so it
+        // is the only bus that opts into retaining the recent[] registry. Child
+        // addon runners + remote agents leave `retainRecent` false: their events
+        // are one-shot (fire-and-forget), fanned out to local subscribers but never
+        // accumulated, so their heap can't grow an unbounded recent[] backlog.
+        const inner = (0, system_1.getBrokerEventBus)(broker, { retainRecent: true });
         this.inner = inner;
         // Replay deferred subscriptions onto the real bus.
         for (const sub of this.deferredSubs) {

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

@@ -436,7 +436,20 @@ class MoleculerService {
                 registry: this.localChildRegistry,
                 parentBus: this.eventBus,
                 parentNodeId: hubNodeId,
+                // D2: relay via pass-through so the bridge's wildcard is not counted as
+                // local interest (uniform with the agent; harmless here since the hub
+                // retains and always accepts inbound cross-node events anyway).
+                subscribePassthrough: (handler) => (0, system_1.subscribePassthrough)(this.broker, handler),
             });
+            // D2: expose the hub's aggregate child interest to its `$event-bus`
+            // inbound gate for uniformity with the agent. NOTE: the hub main process
+            // opts into `retainRecent` (it serves `getRecent` + the admin-ui live
+            // event stream), so `crossNodeAcceptsCategory` always accepts every
+            // inbound category here — the hub never filters agent-origin events. This
+            // wiring is therefore harmless-but-uniform; the real efficiency win is on
+            // agents (non-retaining nodes).
+            const hubChildRegistry = this.localChildRegistry;
+            (0, system_1.setNodeEventInterest)(this.broker, () => hubChildRegistry.aggregateEventInterest());
         }
     }
     /**

package/package.json

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