@camstack/server 0.1.8 → 0.2.0

package/src/core/logging/logging.service.ts

@@ -43,7 +43,12 @@ export class LoggingService extends LogManager {
   setDeviceNames(entries: ReadonlyArray<{ id: number; name: string }>): void {
     this.deviceNames.clear()
     for (const { id, name } of entries) {
-      if (typeof id === 'number' && Number.isFinite(id) && typeof name === 'string' && name.length > 0) {
+      if (
+        typeof id === 'number' &&
+        Number.isFinite(id) &&
+        typeof name === 'string' &&
+        name.length > 0
+      ) {
         this.deviceNames.set(id, name)
       }
     }
@@ -73,7 +78,11 @@ export class LoggingService extends LogManager {
       if (data && typeof data.deviceId === 'number') {
         this.upsertDeviceName(data.deviceId, data.name)
         selfLogger.info('device-name cache upserted', {
-          meta: { deviceId: data.deviceId, name: data.name ?? null, cacheSize: this.deviceNames.size },
+          meta: {
+            deviceId: data.deviceId,
+            name: data.name ?? null,
+            cacheSize: this.deviceNames.size,
+          },
         })
       }
     })
@@ -117,7 +126,7 @@ export class LoggingService extends LogManager {
     const nodeId = entry.nodeId
     const agentId = nodeId?.includes('/') ? nodeId.split('/')[0]! : nodeId
     const mergedTags: LogTags = {
-      ...(entry.tags ?? {}),
+      ...entry.tags,
       addonId: entry.addonId,
       ...(nodeId !== undefined ? { nodeId } : {}),
       ...(agentId !== undefined ? { agentId } : {}),

package/src/core/moleculer/cap-call-fn.spec.ts

@@ -1,10 +1,6 @@
 import { describe, it, expect, vi } from 'vitest'
 import type { CapRoute, CapCallInput } from '@camstack/kernel'
-import {
-  buildCapCallFn,
-  type CapCallFnLocalChild,
-  type CapCallFnResolver,
-} from './cap-call-fn.js'
+import { buildCapCallFn, type CapCallFnLocalChild, type CapCallFnResolver } from './cap-call-fn.js'
 
 /**
  * buildCapCallFn — the per-(cap,node) dispatcher behind every CapabilityRegistry
@@ -84,7 +80,10 @@ describe('buildCapCallFn', () => {
 
     expect(result).toEqual({ from: 'uds' })
     expect(child.callCapOnChildCalls).toEqual([
-      { childId: 'benchmark', input: { capName: 'cap-x', method: 'listPages', args: { deviceId: 7 }, deviceId: 7 } },
+      {
+        childId: 'benchmark',
+        input: { capName: 'cap-x', method: 'listPages', args: { deviceId: 7 }, deviceId: 7 },
+      },
     ])
     expect(resolver.resolveCalls).toEqual([]) // resolver never consulted
     expect(legacy).not.toHaveBeenCalled()
@@ -125,8 +124,12 @@ describe('buildCapCallFn', () => {
     const result = await fn('listPages', { deviceId: 3 })
 
     expect(result).toEqual({ from: 'resolver' })
-    expect(resolver.resolveCalls).toEqual([{ capName: 'cap-x', nodeId: 'dev-agent-0', deviceId: 3 }])
-    expect(resolver.dispatchCalls).toEqual([{ route: REMOTE_ROUTE, method: 'listPages', args: { deviceId: 3 } }])
+    expect(resolver.resolveCalls).toEqual([
+      { capName: 'cap-x', nodeId: 'dev-agent-0', deviceId: 3 },
+    ])
+    expect(resolver.dispatchCalls).toEqual([
+      { route: REMOTE_ROUTE, method: 'listPages', args: { deviceId: 3 } },
+    ])
     expect(legacy).not.toHaveBeenCalled()
   })
 
@@ -144,11 +147,15 @@ describe('buildCapCallFn', () => {
 
     await fn('listPages', undefined, 'dev-agent-1')
 
-    expect(resolver.resolveCalls).toEqual([{ capName: 'cap-x', nodeId: 'dev-agent-1', deviceId: undefined }])
+    expect(resolver.resolveCalls).toEqual([
+      { capName: 'cap-x', nodeId: 'dev-agent-1', deviceId: undefined },
+    ])
   })
 
   it('resolver not yet built → falls back to the legacy broker call', async () => {
-    const legacy = vi.fn<(m: string, p: unknown, n: string) => Promise<unknown>>(async () => ({ from: 'legacy' }))
+    const legacy = vi.fn<(m: string, p: unknown, n: string) => Promise<unknown>>(async () => ({
+      from: 'legacy',
+    }))
     const fn = buildCapCallFn({
       capName: 'cap-x',
       nodeId: 'dev-agent-0',

package/src/core/moleculer/cap-call-fn.ts

@@ -44,7 +44,11 @@ export interface CapCallFnDeps {
   /** Live getter for the resolver (`null` before `onModuleInit` builds it). */
   readonly getResolver: () => CapCallFnResolver | null
   /** Legacy Moleculer call — used ONLY in the pre-init window (no resolver yet). */
-  readonly legacyBrokerCall: (method: string, params: unknown, targetNodeId: string) => Promise<unknown>
+  readonly legacyBrokerCall: (
+    method: string,
+    params: unknown,
+    targetNodeId: string,
+  ) => Promise<unknown>
   /** Optional diagnostic hook fired the first time this cap routes over UDS. */
   readonly onUdsRoute?: (capName: string) => void
 }

package/src/core/moleculer/cap-route-authority.ts

@@ -26,14 +26,21 @@ import type { InProcessProviderRef } from '@camstack/kernel'
  * is required. HubNodeRegistry satisfies this interface structurally.
  */
 export interface NodeRegistryLike {
-  getNodeManifest(nodeId: string): readonly { readonly addonId: string; readonly capabilities: readonly string[] }[] | undefined
+  getNodeManifest(
+    nodeId: string,
+  ): readonly { readonly addonId: string; readonly capabilities: readonly string[] }[] | undefined
   listNodeIds(): readonly string[]
   /**
    * Optional: returns flat (nodeId, addonId, capName, deviceId) native-cap tuples.
    * When provided, `nodeKnowsCap` and `isNativeCap` also consult native caps so
    * device-scoped native caps (ptz, motion-zones, …) are visible to the resolver.
    */
-  listNativeCapEntries?(): readonly { readonly nodeId: string; readonly addonId: string; readonly capName: string; readonly deviceId: number }[]
+  listNativeCapEntries?(): readonly {
+    readonly nodeId: string
+    readonly addonId: string
+    readonly capName: string
+    readonly deviceId: number
+  }[]
 }
 
 // ---------------------------------------------------------------------------
@@ -87,7 +94,10 @@ export function createNodeCapAuthority(
     nodeKnowsCap(nodeId: string, capName: string): boolean {
       // Check system (manifest) caps first
       const manifest = nodeRegistry.getNodeManifest(nodeId)
-      if (manifest !== undefined && manifest.some((addon) => addon.capabilities.includes(capName))) {
+      if (
+        manifest !== undefined &&
+        manifest.some((addon) => addon.capabilities.includes(capName))
+      ) {
         return true
       }
       // Also check device-scoped native caps — these are NOT in the addon manifest
@@ -139,7 +149,9 @@ export function createNodeCapAuthority(
     isNativeCap(nodeId: string, capName: string, deviceId?: number): boolean {
       const nativeEntries = nodeRegistry.listNativeCapEntries?.() ?? []
       if (deviceId !== undefined) {
-        return nativeEntries.some((n) => n.nodeId === nodeId && n.capName === capName && n.deviceId === deviceId)
+        return nativeEntries.some(
+          (n) => n.nodeId === nodeId && n.capName === capName && n.deviceId === deviceId,
+        )
       }
       return nativeEntries.some((n) => n.nodeId === nodeId && n.capName === capName)
     },
@@ -163,8 +175,8 @@ export function createInProcessProviderLookup(
 ): InProcessProviderLookup {
   return (capName: string): InProcessProviderRef | null => {
     const provider =
-      capabilityService.getSingletonForNode?.(capName, 'hub')
-      ?? capabilityService.getSingleton(capName)
+      capabilityService.getSingletonForNode?.(capName, 'hub') ??
+      capabilityService.getSingleton(capName)
     if (provider === null || provider === undefined) return null
 
     const ref: InProcessProviderRef = {

package/src/core/moleculer/moleculer.service.ts

@@ -16,8 +16,37 @@ interface BrokerLike {
   call(action: string, params?: unknown, opts?: unknown): Promise<unknown>
   waitForServices(services: string[], timeout?: number): Promise<unknown>
 }
-import { createBroker, createHubService, createProcessService, isInfraCapability, registerEventBusService, createReadinessServiceForRegistry, createStreamProbeBrokerService, createHwAccelService, createKernelHwAccel, HubNodeRegistry, serializeTypedArrays, callWithServiceDiscovery, hashClusterSecret, LocalChildRegistry, createLocalTransport, localEndpointPath, CapRouteResolver, CapRouteError, capActionName, udsChildLogToWorkerEntry, createUdsEventBridge, createParentUnownedCallHandler } from '@camstack/kernel'
-import type { HubServiceDeps, CallFn, RegisterNodeParams, RegisteredAddonManifest, ChildCapDescriptor } from '@camstack/kernel'
+import {
+  createBroker,
+  createHubService,
+  createProcessService,
+  isInfraCapability,
+  registerEventBusService,
+  createReadinessServiceForRegistry,
+  createStreamProbeBrokerService,
+  createHwAccelService,
+  createKernelHwAccel,
+  HubNodeRegistry,
+  serializeTypedArrays,
+  callWithServiceDiscovery,
+  hashClusterSecret,
+  LocalChildRegistry,
+  createLocalTransport,
+  localEndpointPath,
+  CapRouteResolver,
+  CapRouteError,
+  capActionName,
+  udsChildLogToWorkerEntry,
+  createUdsEventBridge,
+  createParentUnownedCallHandler,
+} from '@camstack/kernel'
+import type {
+  HubServiceDeps,
+  CallFn,
+  RegisterNodeParams,
+  RegisteredAddonManifest,
+  ChildCapDescriptor,
+} from '@camstack/kernel'
 import { buildCapCallFn } from './cap-call-fn.js'
 import { createNodeCapAuthority, createInProcessProviderLookup } from './cap-route-authority.js'
 import { EventCategory, expandCapMethods, ReadinessRegistry, emitReadiness } from '@camstack/types'
@@ -55,7 +84,9 @@ interface AppliedCapEntry {
 export class MoleculerService {
   readonly broker: ServiceBroker
   /** Narrow-typed view of `this.broker` — see `BrokerLike` doc above. */
-  private get brokerSafe(): BrokerLike { return this.broker as unknown as BrokerLike }
+  private get brokerSafe(): BrokerLike {
+    return this.broker as unknown as BrokerLike
+  }
   private readonly logger: ReturnType<LoggingService['createLogger']>
   /**
    * D3 authority: union of every node's manifest delivered via
@@ -148,7 +179,8 @@ export class MoleculerService {
     // moleculer→eventemitter2 whose types are unresolvable at this
     // boundary, so the inference falls to `error` and trips
     // `no-unsafe-assignment`. Going via `unknown` documents the boundary.
-    this.clusterSecret = process.env['CAMSTACK_CLUSTER_SECRET'] ?? this.config.get<string>('cluster.secret')
+    this.clusterSecret =
+      process.env['CAMSTACK_CLUSTER_SECRET'] ?? this.config.get<string>('cluster.secret')
     const broker = createBroker({
       nodeID: 'hub',
       mode: 'hub',
@@ -226,7 +258,9 @@ export class MoleculerService {
       onUnregisterNode: (nodeId) => {
         this.removeNodeFromRegistry(nodeId)
       },
-      expectedClusterSecretHash: this.clusterSecret ? hashClusterSecret(this.clusterSecret) : undefined,
+      expectedClusterSecretHash: this.clusterSecret
+        ? hashClusterSecret(this.clusterSecret)
+        : undefined,
     }
 
     const hubService: unknown = createHubService(hubDeps)
@@ -265,20 +299,41 @@ export class MoleculerService {
         // UDS before any broker fallback. Getter: `this.localChildRegistry` is
         // assigned later in this method, after the handler is constructed.
         getLocalDispatcher: () => this.localChildRegistry,
+        // Device-native signal for the registration-race recovery: a forked
+        // child's device-native cap (e.g. `switch` on an export target) can be
+        // briefly absent from the LocalChildRegistry just after a respawn. The
+        // kernel layer has no cap registry, so feed it the `deviceNative` flag
+        // from the cap definition. When true + binding-not-yet-registered, the
+        // handler retries the hub-local route then throws a precise error rather
+        // than the unroutable broker fallback (`switch.switch.getStatus`).
+        isDeviceNativeCap: (capName) =>
+          this.capabilityService.getRegistry()?.getDefinition(capName)?.deviceNative === true,
         logger: {
-          warn: (msg, meta) => logger.warn(msg, meta !== null && meta !== undefined ? { meta: meta as Record<string, unknown> } : undefined),
+          warn: (msg, meta) =>
+            logger.warn(
+              msg,
+              meta !== null && meta !== undefined
+                ? { meta: meta as Record<string, unknown> }
+                : undefined,
+            ),
         },
       })
       const registry = new LocalChildRegistry({
         server: createLocalTransport().createServer(nodeId),
         onUnownedCall,
         logger: {
-          info: (msg, meta) => logger.info(msg, meta !== null && meta !== undefined ? { meta: meta as Record<string, unknown> } : undefined),
+          info: (msg, meta) =>
+            logger.info(
+              msg,
+              meta !== null && meta !== undefined
+                ? { meta: meta as Record<string, unknown> }
+                : undefined,
+            ),
         },
         // Hand the UDS-routing layer a view into the operator's
         // active-singleton preference. Without this, when two local
-        // children own the same singleton cap (today: `webrtc-session`
-        // → `stream-broker` + `addon-webrtc-native`), routing returns
+        // children own the same singleton cap (e.g. two `webrtc-session`
+        // providers), routing returns
         // the first-registered child by insertion order — silently
         // bypassing `setActiveSingleton`. The closure reads the live
         // registry on every call so a runtime swap takes effect
@@ -327,10 +382,18 @@ export class MoleculerService {
       parentUdsPath = localEndpointPath(nodeId)
       logger.info('UDS child registry listening', { meta: { path: parentUdsPath } })
     } catch (err) {
-      logger.warn('UDS child registry failed to start; children stay broker-only', { meta: { err: err instanceof Error ? err.message : String(err) } })
+      logger.warn('UDS child registry failed to start; children stay broker-only', {
+        meta: { err: err instanceof Error ? err.message : String(err) },
+      })
     }
 
-    const processService: unknown = createProcessService(this.brokerSafe.nodeID, dataDir, undefined, undefined, parentUdsPath)
+    const processService: unknown = createProcessService(
+      this.brokerSafe.nodeID,
+      dataDir,
+      undefined,
+      undefined,
+      parentUdsPath,
+    )
     this.brokerSafe.createService(processService)
 
     // $addonHost — REMOVED (Sprint 6). Three-level settings are now
@@ -363,10 +426,12 @@ export class MoleculerService {
     // workers). Keeps ffprobe + HTTP-reachability as a single
     // hub-side implementation; see `createStreamProbeBrokerService`
     // for the shape.
-    this.brokerSafe.createService(createStreamProbeBrokerService({
-      probe: (url, options) => this.streamProbe.probe(url, options),
-      probeField: (key, value) => this.streamProbe.probeField(key, value),
-    }))
+    this.brokerSafe.createService(
+      createStreamProbeBrokerService({
+        probe: (url, options) => this.streamProbe.probe(url, options),
+        probeField: (key, value) => this.streamProbe.probeField(key, value),
+      }),
+    )
 
     // Register `$hwaccel` on hub — every node in the cluster does the
     // same so `broker.call('$hwaccel.resolve', params, { nodeID })`
@@ -390,7 +455,8 @@ export class MoleculerService {
       hubLocalRegistry: this.localChildRegistry,
       nodeAuthority: createNodeCapAuthority(this.nodeRegistry, {
         resolveSingleton: (capName, nodeId) =>
-          this.capabilityService.getRegistry()?.resolveSingletonAddonIdForNode(capName, nodeId) ?? null,
+          this.capabilityService.getRegistry()?.resolveSingletonAddonIdForNode(capName, nodeId) ??
+          null,
       }),
       inProcessProviders: createInProcessProviderLookup(this.capabilityService),
     })
@@ -503,12 +569,16 @@ export class MoleculerService {
       // the legacy callFn store. The deviceId hint is a number extracted from the method args.
       const rawDeviceId: unknown =
         params !== null && typeof params === 'object' ? Reflect.get(params, 'deviceId') : undefined
-      const routeDeviceId: number | undefined = typeof rawDeviceId === 'number' ? rawDeviceId : undefined
+      const routeDeviceId: number | undefined =
+        typeof rawDeviceId === 'number' ? rawDeviceId : undefined
       try {
         const route = resolver.resolveCapRoute(capabilityName, { nodeId, deviceId: routeDeviceId })
         return await resolver.dispatch(route, methodName, params)
       } catch (err) {
-        if (err instanceof CapRouteError && (err.reason === 'no-provider' || err.reason === 'node-offline')) {
+        if (
+          err instanceof CapRouteError &&
+          (err.reason === 'no-provider' || err.reason === 'node-offline')
+        ) {
           // Resolver couldn't find the cap — try the legacy callFn store as a
           // fallback. This covers caps registered in nodeCallFns (e.g. agent
           // nodes that registered before the resolver's snapshot was built or
@@ -534,7 +604,8 @@ export class MoleculerService {
       const provider = registry?.getSingleton<Record<string, unknown>>(capabilityName) ?? null
       if (provider !== null) {
         const fn = provider[methodName]
-        if (typeof fn !== 'function') throw new Error(`Method "${methodName}" not found on "${capabilityName}"`)
+        if (typeof fn !== 'function')
+          throw new Error(`Method "${methodName}" not found on "${capabilityName}"`)
         return fn.call(provider, params)
       }
     }
@@ -547,7 +618,9 @@ export class MoleculerService {
     throw new CapRouteError(capabilityName, methodName, {
       reason: 'no-provider',
       nodeId,
-      rejected: [{ kind: 'hub-in-process', why: 'CapRouteResolver not initialised (pre-onModuleInit)' }],
+      rejected: [
+        { kind: 'hub-in-process', why: 'CapRouteResolver not initialised (pre-onModuleInit)' },
+      ],
     })
   }
 
@@ -596,7 +669,10 @@ export class MoleculerService {
    * already; this method handles only `params.addons` (system caps).
    * Native-cap wiring into device-manager is done in a later task.
    */
-  private applyNodeManifest(params: RegisterNodeParams, previousManifest?: readonly RegisteredAddonManifest[]): void {
+  private applyNodeManifest(
+    params: RegisterNodeParams,
+    previousManifest?: readonly RegisteredAddonManifest[],
+  ): void {
     const { nodeId, addons } = params
     const hubNodeId = this.brokerSafe.nodeID
     const isLocalChild = nodeId.startsWith(hubNodeId + '/')
@@ -622,7 +698,9 @@ export class MoleculerService {
     // what is (or would have been) registered. Keyed `${registryKey}::${capName}`.
     // The resolved `capDef` is carried through so the register loop never
     // re-looks it up (and never needs a non-null assertion).
-    const appliedKeys = (manifest: readonly RegisteredAddonManifest[]): Map<string, AppliedCapEntry> => {
+    const appliedKeys = (
+      manifest: readonly RegisteredAddonManifest[],
+    ): Map<string, AppliedCapEntry> => {
       const keys = new Map<string, AppliedCapEntry>()
       for (const addon of manifest) {
         const registryKey = registryKeyFor(addon.addonId)
@@ -754,7 +832,7 @@ export class MoleculerService {
    */
   private removeNodeFromRegistry(nodeId: string): void {
     const manifest = this.nodeRegistry.getNodeManifest(nodeId)
-    if (!manifest) return  // node never sent a handshake — nothing to do
+    if (!manifest) return // node never sent a handshake — nothing to do
 
     const hubNodeId = this.brokerSafe.nodeID
     const isLocalChild = nodeId.startsWith(hubNodeId + '/')
@@ -820,7 +898,6 @@ export class MoleculerService {
     return undefined
   }
 
-
   /**
    * Returns true when a (nodeId, capabilityName) pair is reachable via the
    * legacy fallback paths: either a stored callFn in nodeCallFns, or a
@@ -849,7 +926,10 @@ export class MoleculerService {
    * built unconditionally for hub-local children so `callCapabilityOnNode` can
    * route the actual method call via the resolver's hub-local-uds branch.
    */
-  createCapabilityProxy(capabilityName: string, nodeId: string): Record<string, (params: unknown) => Promise<unknown>> | null {
+  createCapabilityProxy(
+    capabilityName: string,
+    nodeId: string,
+  ): Record<string, (params: unknown) => Promise<unknown>> | null {
     const resolver = this.resolver
     if (resolver !== null) {
       // Use the resolver to determine reachability. If it resolves a route, we
@@ -860,7 +940,10 @@ export class MoleculerService {
         resolver.resolveCapRoute(capabilityName, { nodeId })
         // Resolver found a route — proxy is reachable.
       } catch (err) {
-        if (err instanceof CapRouteError && (err.reason === 'no-provider' || err.reason === 'node-offline')) {
+        if (
+          err instanceof CapRouteError &&
+          (err.reason === 'no-provider' || err.reason === 'node-offline')
+        ) {
           // Check legacy callFn store and hub-local child fallbacks.
           if (!this.isReachableViaLegacy(nodeId, capabilityName)) return null
           // Proxy reachable via fallback paths — fall through to build it.
@@ -875,12 +958,15 @@ export class MoleculerService {
 
     // Build a dynamic proxy: every property access returns a function that
     // routes the call through callCapabilityOnNode (which delegates to the resolver).
-    return new Proxy<Record<string, (params: unknown) => Promise<unknown>>>({}, {
-      get: (_target, methodName: string) => {
-        return (params: unknown): Promise<unknown> =>
-          this.callCapabilityOnNode(nodeId, capabilityName, methodName, params)
+    return new Proxy<Record<string, (params: unknown) => Promise<unknown>>>(
+      {},
+      {
+        get: (_target, methodName: string) => {
+          return (params: unknown): Promise<unknown> =>
+            this.callCapabilityOnNode(nodeId, capabilityName, methodName, params)
+        },
       },
-    })
+    )
   }
 
   /**
@@ -904,7 +990,9 @@ export class MoleculerService {
    * per-device `getBindings` hot path so `getAllBindings` doesn't flatten the
    * whole cluster once per device.
    */
-  listClusterNativeCapsForDevice(deviceId: number): readonly import('@camstack/kernel').NodeNativeCapEntry[] {
+  listClusterNativeCapsForDevice(
+    deviceId: number,
+  ): readonly import('@camstack/kernel').NodeNativeCapEntry[] {
     return this.nodeRegistry.listNativeCapEntriesForDevice(deviceId)
   }
 

package/src/core/network/network-quality.service.spec.ts

@@ -32,7 +32,12 @@ describe('NetworkQualityService', () => {
   })
 
   it('should track client stats', () => {
-    service.reportClientStats(1, { rttMs: 50, jitterMs: 5, estimatedBandwidthKbps: 20000, packetLossPercent: 3 })
+    service.reportClientStats(1, {
+      rttMs: 50,
+      jitterMs: 5,
+      estimatedBandwidthKbps: 20000,
+      packetLossPercent: 3,
+    })
     const stats = service.getDeviceStats(1)
     expect(stats!.client?.rttMs).toBe(50)
     expect(stats!.client?.estimatedBandwidthKbps).toBe(20000)

package/src/core/notification/notification-wrapper.service.ts

@@ -19,9 +19,7 @@ export class NotificationServiceWrapper {
 
   get service(): NotificationService {
     if (!this._service) {
-      this._service = new NotificationService(
-        this.logging.createLogger('notifications'),
-      )
+      this._service = new NotificationService(this.logging.createLogger('notifications'))
       const registry = this.caps.getRegistry()
       if (registry) {
         this._service.setRegistry(registry)

package/src/core/notification/toast-wrapper.service.ts

@@ -21,11 +21,7 @@ export class ToastServiceWrapper {
     this._service.sendToUser(userId, toast)
   }
 
-  subscribe(
-    connectionId: string,
-    userId: string,
-    callback: (toast: Toast) => void,
-  ): () => void {
+  subscribe(connectionId: string, userId: string, callback: (toast: Toast) => void): () => void {
     return this._service.subscribe(connectionId, userId, callback)
   }
 }