@camstack/server 1.1.19 → 1.1.21

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/api/core/notifications.router.js

@@ -4,64 +4,44 @@ exports.createNotificationsRouter = createNotificationsRouter;
 /**
  * Notifications router — fixed core API (not a capability).
  *
- * Routes events by category to registered outputs. The NotificationService
- * is a singleton from @camstack/system; individual outputs are still provided
- * by addons via the `notification-output` capability collection.
+ * Routes events by category to `(addonId, targetId)` notification targets.
+ * The NotificationService is a singleton from @camstack/system; the targets
+ * themselves are provided by addons via the `notification-output` capability
+ * collection (see the notifiers addon / HA addon). Target management + the
+ * test panel live on the cap surface (`api.notificationOutput.*`); this
+ * legacy router only exposes category→target routing.
  */
 const zod_1 = require("zod");
 const trpc_middleware_js_1 = require("../trpc/trpc.middleware.js");
-const NotificationOutputSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    name: zod_1.z.string(),
-    icon: zod_1.z.string(),
-});
-const SendTestResultSchema = zod_1.z.object({
-    success: zod_1.z.boolean(),
-    error: zod_1.z.string().optional(),
+const NotificationTargetRefSchema = zod_1.z.object({
+    addonId: zod_1.z.string(),
+    targetId: zod_1.z.string(),
 });
 function createNotificationsRouter(ns) {
     return (0, trpc_middleware_js_1.trpcRouter)({
-        listOutputs: trpc_middleware_js_1.protectedProcedure
-            .input(zod_1.z.void())
-            .output(zod_1.z.array(NotificationOutputSchema).readonly())
-            .query(() => {
-            if (!ns)
-                return [];
-            return ns.getOutputs();
-        }),
         getRouting: trpc_middleware_js_1.protectedProcedure
             .input(zod_1.z.void())
-            .output(zod_1.z.record(zod_1.z.string(), zod_1.z.array(zod_1.z.string())))
+            .output(zod_1.z.record(zod_1.z.string(), zod_1.z.array(NotificationTargetRefSchema)))
             .query(() => {
             if (!ns)
                 return {};
             const routing = ns.getRouting();
             const result = {};
-            for (const [category, outputIds] of routing) {
-                result[category] = [...outputIds];
+            for (const [category, targets] of routing) {
+                result[category] = [...targets];
             }
             return result;
         }),
         setRouting: trpc_middleware_js_1.adminProcedure
-            .input(zod_1.z.object({ category: zod_1.z.string(), outputIds: zod_1.z.array(zod_1.z.string()) }))
+            .input(zod_1.z.object({
+            category: zod_1.z.string(),
+            targets: zod_1.z.array(NotificationTargetRefSchema),
+        }))
             .output(zod_1.z.void())
             .mutation(({ input }) => {
             if (!ns)
                 throw new Error('Notification service unavailable');
-            ns.setRouting(input.category, input.outputIds);
-        }),
-        sendTest: trpc_middleware_js_1.adminProcedure
-            .input(zod_1.z.object({ outputId: zod_1.z.string() }))
-            .output(SendTestResultSchema)
-            .mutation(async ({ input }) => {
-            if (!ns)
-                return { success: false, error: 'Notification service unavailable' };
-            const output = ns.getOutput(input.outputId);
-            if (!output)
-                return { success: false, error: `Output "${input.outputId}" not found` };
-            if (!output.sendTest)
-                return { success: false, error: 'Output does not support test notifications' };
-            return output.sendTest();
+            ns.setRouting(input.category, input.targets);
         }),
     });
 }

package/dist/api/trpc/generated-cap-mounts.js

@@ -271,7 +271,16 @@ function mountAllCaps(services) {
                 return reg.getProviderByAddonId('notification-output', addonId);
             }
             const entries = reg.getCollectionEntries('notification-output');
-            return entries[0]?.[1] ?? null;
+            if (entries.length === 0)
+                return null;
+            const providers = entries.map(([, p]) => p);
+            const first = providers[0];
+            return {
+                ...first,
+                listTargetKinds: (0, cap_mount_helpers_js_1.concatCollection)(providers, 'listTargetKinds'),
+                listTargets: (0, cap_mount_helpers_js_1.concatCollection)(providers, 'listTargets'),
+                discoverTargets: (0, cap_mount_helpers_js_1.concatCollection)(providers, 'discoverTargets'),
+            };
         }, remoteCapProxy),
         notifier: (0, generated_cap_routers_js_1.createCapRouter_notifier)((_ctx) => (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, 'notifier'), remoteCapProxy),
         numericSensor: (0, generated_cap_routers_js_1.createCapRouter_numericSensor)((_ctx) => (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, 'numeric-sensor'), remoteCapProxy),

package/dist/api/trpc/generated-cap-routers.js

@@ -4469,6 +4469,33 @@ function createCapRouter_nodes(getProvider, _createRemoteProxy) {
 }
 function createCapRouter_notificationOutput(getProvider, createRemoteProxy) {
     return (0, trpc_middleware_js_1.trpcRouter)({
+        listTargetKinds: trpc_middleware_js_1.protectedProcedure
+            .input(types_68.notificationOutputCapability.methods.listTargetKinds.input.loose())
+            .output(types_68.notificationOutputCapability.methods.listTargetKinds.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, addonId, ...methodInput } = input;
+            const p = resolveProvider('notification-output', nodeId, () => getProvider(ctx, addonId), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.listTargetKinds(methodInput);
+        }),
+        listTargets: trpc_middleware_js_1.protectedProcedure
+            .input(types_68.notificationOutputCapability.methods.listTargets.input.loose())
+            .output(types_68.notificationOutputCapability.methods.listTargets.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, addonId, ...methodInput } = input;
+            const p = resolveProvider('notification-output', nodeId, () => getProvider(ctx, addonId), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.listTargets(methodInput);
+        }),
+        discoverTargets: trpc_middleware_js_1.protectedProcedure
+            .input(types_68.notificationOutputCapability.methods.discoverTargets.input.loose())
+            .output(types_68.notificationOutputCapability.methods.discoverTargets.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, addonId, ...methodInput } = input;
+            const p = resolveProvider('notification-output', nodeId, () => getProvider(ctx, addonId), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.discoverTargets(methodInput);
+        }),
         send: trpc_middleware_js_1.protectedProcedure
             .input(types_68.notificationOutputCapability.methods.send.input.loose())
             .output(types_68.notificationOutputCapability.methods.send.output)
@@ -4478,12 +4505,41 @@ function createCapRouter_notificationOutput(getProvider, createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.send(methodInput);
         }),
-        sendTest: trpc_middleware_js_1.protectedProcedure
-            .input(zod_1.z.object({ nodeId: zod_1.z.string().optional(), addonId: zod_1.z.string().optional() }).optional())
-            .output(types_68.notificationOutputCapability.methods.sendTest.output)
+        testTarget: trpc_middleware_js_1.protectedProcedure
+            .input(types_68.notificationOutputCapability.methods.testTarget.input.loose())
+            .output(types_68.notificationOutputCapability.methods.testTarget.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, addonId, ...methodInput } = input;
+            const p = resolveProvider('notification-output', nodeId, () => getProvider(ctx, addonId), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.testTarget(methodInput);
+        }),
+        upsertTarget: trpc_middleware_js_1.protectedProcedure
+            .input(types_68.notificationOutputCapability.methods.upsertTarget.input.loose())
+            .output(types_68.notificationOutputCapability.methods.upsertTarget.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, addonId, ...methodInput } = input;
+            const p = resolveProvider('notification-output', nodeId, () => getProvider(ctx, addonId), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.upsertTarget(methodInput);
+        }),
+        deleteTarget: trpc_middleware_js_1.protectedProcedure
+            .input(types_68.notificationOutputCapability.methods.deleteTarget.input.loose())
+            .output(types_68.notificationOutputCapability.methods.deleteTarget.output)
             .mutation(async ({ input, ctx }) => {
-            const p = resolveProvider('notification-output', input?.nodeId, () => getProvider(ctx, input?.addonId), createRemoteProxy);
-            return p.sendTest();
+            const { nodeId, addonId, ...methodInput } = input;
+            const p = resolveProvider('notification-output', nodeId, () => getProvider(ctx, addonId), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.deleteTarget(methodInput);
+        }),
+        setTargetEnabled: trpc_middleware_js_1.protectedProcedure
+            .input(types_68.notificationOutputCapability.methods.setTargetEnabled.input.loose())
+            .output(types_68.notificationOutputCapability.methods.setTargetEnabled.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, addonId, ...methodInput } = input;
+            const p = resolveProvider('notification-output', nodeId, () => getProvider(ctx, addonId), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.setTargetEnabled(methodInput);
         }),
     });
 }

package/dist/core/addon/addon-call-gateway.js

@@ -18,7 +18,11 @@ class AddonCallGateway {
         const onHub = resolved === 'hub' || resolved === this.deps.hubNodeId;
         if (onHub) {
             const childRegistry = this.deps.getChildRegistry();
-            if (childRegistry !== null && childRegistry.isChildKnown(addonId)) {
+            // Resolve to the runner child id: a grouped addon's UDS child is the
+            // group name, not the addon id. `isChildKnown(addonId)` would be false
+            // for a grouped addon and misclassify it as `in-process`.
+            const childId = this.deps.resolveChildId(addonId);
+            if (childRegistry !== null && childRegistry.isChildKnown(childId)) {
                 return { kind: 'hub-local-child' };
             }
             return { kind: 'in-process' };
@@ -48,7 +52,10 @@ class AddonCallGateway {
                 if (childRegistry === null) {
                     throw new Error(`AddonCallGateway: child registry unavailable for "${addonId}"`);
                 }
-                return childRegistry.callAddonOnChild(addonId, fullInput);
+                // Dispatch to the runner CHILD id (group when grouped, else addon id);
+                // the payload keeps the real `addonId` so the child fans out to the
+                // right co-located addon within the group.
+                return childRegistry.callAddonOnChild(this.deps.resolveChildId(addonId), fullInput);
             }
             case 'remote-agent':
                 return this.callRemoteAgent(addonId, dest.baseNodeId, fullInput);

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

@@ -1674,8 +1674,9 @@ class AddonPackageService {
         this.notificationService
             .notify({
             title: 'Package Updated',
-            message: `${name} updated to v${version}`,
-            severity: 'info',
+            body: `${name} updated to v${version}`,
+            format: 'text',
+            priority: 3,
             category: 'system',
             timestamp: Date.now(),
         })

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

@@ -359,10 +359,15 @@ class AddonRegistryService {
                 // forked-vs-in-process is decided by `isChildKnown` in the gateway.
                 return entry ? this.broker.nodeID : 'hub';
             },
+            resolveChildId: (addonId) => this.childIdForAddon(addonId),
             getChildRegistry: () => this.moleculer.childRegistry,
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- moleculer types unresolvable; see `broker` getter docstring
             broker: this.moleculer.broker,
         });
+        // Hand the UDS registry a live addonId → runner-id resolver so its
+        // active-singleton preference can select a grouped addon (whose child id
+        // is its `execution.group`, not its own id). Identity for ungrouped addons.
+        this.moleculer.setRunnerIdResolver((addonId) => this.childIdForAddon(addonId));
         const settingsProvider = (0, addon_settings_provider_js_1.createAddonSettingsProvider)({
             getAddon: (addonId) => {
                 const entry = this.addonEntries.get(addonId);
@@ -869,6 +874,19 @@ class AddonRegistryService {
      * isn't a cap, but the child is UDS-reachable and has served its endpoints by
      * the time any of its caps register.
      */
+    /**
+     * The UDS runner/child id an addon is reachable under. For a solo addon
+     * (no `execution.group`) this is the addon id itself; for a grouped addon
+     * it is the shared group name (`resolveRunnerId`). The single authority for
+     * "which child hosts this addon" on the parent side — every gateway /
+     * route-mount / data-plane-mount lookup routes through here so a grouped
+     * addon (`execution.group`) is never misclassified as `in-process`.
+     * Falls back to the addon id when the declaration is not yet known.
+     */
+    childIdForAddon(addonId) {
+        const decl = this.addonEntries.get(addonId)?.declaration;
+        return decl ? (0, types_1.resolveRunnerId)(decl, addonId) : addonId;
+    }
     async mountAddonDataPlanes(addonId) {
         const registry = this.dataPlaneRegistry;
         if (!registry)
@@ -880,7 +898,7 @@ class AddonRegistryService {
         // data-plane yet).
         if (!entry || !this.isForkedAddonEntry(entry))
             return;
-        if (childRegistry === null || !childRegistry.isChildKnown(addonId))
+        if (childRegistry === null || !childRegistry.isChildKnown(this.childIdForAddon(addonId)))
             return;
         const raw = await this.addonCallGateway.callForked(addonId, { target: 'data-planes' });
         const endpoints = parseDataPlaneEndpoints(raw);
@@ -2168,7 +2186,7 @@ class AddonRegistryService {
         const entry = this.addonEntries.get(addonId);
         const childRegistry = this.moleculer.childRegistry;
         if (entry && this.isForkedAddonEntry(entry)) {
-            if (childRegistry !== null && childRegistry.isChildKnown(addonId)) {
+            if (childRegistry !== null && childRegistry.isChildKnown(this.childIdForAddon(addonId))) {
                 await this.mountForkedAddonRoutes(addonId, routeProvider, addonRouteRegistry);
                 return;
             }

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

@@ -74,6 +74,23 @@ class MoleculerService {
      * handler, preventing subscriber leaks on shutdown.
      */
     udsEventBridgeDispose = null;
+    /**
+     * addonId → runner/child id resolver, injected late by
+     * `AddonRegistryService` (which owns the addon declarations). Lets the UDS
+     * `LocalChildRegistry` map the operator's active-singleton preference (an
+     * addonId) onto a candidate CHILD id — a grouped addon's child id is its
+     * `execution.group`, not its own id. Read live so a manifest change takes
+     * effect without rebuilding the registry. Null → identity (addonId ===
+     * childId), the correct default for every ungrouped addon.
+     */
+    runnerIdResolver = null;
+    /**
+     * Late-wire the addonId → runner-id resolver used by the UDS singleton
+     * preference. Called once by `AddonRegistryService` during boot.
+     */
+    setRunnerIdResolver(resolver) {
+        this.runnerIdResolver = resolver;
+    }
     get childRegistry() {
         return this.localChildRegistry;
     }
@@ -287,6 +304,11 @@ class MoleculerService {
                 // registry on every call so a runtime swap takes effect
                 // immediately without rebuilding the resolver snapshot.
                 getActiveSingletonAddonId: (capName) => this.capabilityService.getRegistry()?.getSingletonAddonId(capName) ?? null,
+                // Map the preferred addonId to its runner CHILD id (group when the
+                // addon declares `execution.group`, else its own id) so a grouped
+                // addon stays selectable as the active singleton. Identity until
+                // `AddonRegistryService` injects the resolver.
+                resolveChildIdForAddon: (addonId) => this.runnerIdResolver?.(addonId) ?? addonId,
             });
             await registry.start();
             // E1: apply child manifest + cleanup from the UDS lifecycle (hub-local children).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "private": false,
   "files": [
     "dist",
@@ -24,6 +24,7 @@
   "dependencies": {
     "@camstack/addon-admin-ui": "*",
     "@camstack/addon-advanced-notifier": "*",
+    "@camstack/addon-notifiers": "*",
     "@camstack/addon-pipeline": "*",
     "@camstack/addon-pipeline-orchestrator": "*",
     "@camstack/addon-post-analysis": "*",