@camstack/server 0.1.7 → 0.2.0

package/src/api/core/capabilities.router.ts

@@ -18,21 +18,21 @@ export function createCapabilitiesRouter(
       .input(z.void())
       .query(() => registry?.listCapabilities() ?? []),
 
-    getCapability: adminProcedure
-      .input(z.object({ name: z.string() }))
-      .query(({ input }) => {
-        if (!registry) return null
-        return registry.listCapabilities().find(
-          (c: { name: string }) => c.name === input.name,
-        ) ?? null
-      }),
+    getCapability: adminProcedure.input(z.object({ name: z.string() })).query(({ input }) => {
+      if (!registry) return null
+      return (
+        registry.listCapabilities().find((c: { name: string }) => c.name === input.name) ?? null
+      )
+    }),
 
     setActiveSingleton: adminProcedure
-      .input(z.object({
-        capability: z.string(),
-        addonId: z.string(),
-        nodeId: z.string().optional(),
-      }))
+      .input(
+        z.object({
+          capability: z.string(),
+          addonId: z.string(),
+          nodeId: z.string().optional(),
+        }),
+      )
       .output(z.void())
       .mutation(async ({ input }) => {
         if (!registry) throw new Error('Capability registry unavailable')
@@ -40,7 +40,10 @@ export function createCapabilitiesRouter(
         if (input.nodeId !== undefined) {
           // Per-node override: persist under the node-qualified key so the boot
           // restorer (`setNodeConfigReader`) replays it on restart.
-          config.set(`capabilities.singletonNode.${input.capability}.${input.nodeId}`, input.addonId)
+          config.set(
+            `capabilities.singletonNode.${input.capability}.${input.nodeId}`,
+            input.addonId,
+          )
         } else {
           // Cluster-global default: persist to the SAME key the boot restorer reads
           // (addon-registry `setConfigReader` → `capabilities.singleton.<cap>`).
@@ -67,10 +70,12 @@ export function createCapabilitiesRouter(
      * save endpoint for a bulk multi-select UI.
      */
     setCollectionEnabledProviders: adminProcedure
-      .input(z.object({
-        capability: z.string(),
-        enabledAddonIds: z.array(z.string()),
-      }))
+      .input(
+        z.object({
+          capability: z.string(),
+          enabledAddonIds: z.array(z.string()),
+        }),
+      )
       .output(z.void())
       .mutation(({ input }) => {
         if (!registry) throw new Error('Capability registry unavailable')
@@ -120,11 +125,13 @@ export function createCapabilitiesRouter(
       }),
 
     setDeviceCollectionFilter: adminProcedure
-      .input(z.object({
-        deviceId: z.string(),
-        capability: z.string(),
-        addonIds: z.array(z.string()),
-      }))
+      .input(
+        z.object({
+          deviceId: z.string(),
+          capability: z.string(),
+          addonIds: z.array(z.string()),
+        }),
+      )
       .output(z.void())
       .mutation(({ input }) => {
         if (!registry) throw new Error('Capability registry unavailable')

package/src/api/core/hwaccel.router.ts

@@ -18,11 +18,22 @@ import type { HwAccelResolution } from '@camstack/types'
 import { trpcRouter, adminProcedure } from '../trpc/trpc.middleware.js'
 
 const HwAccelBackendSchema = z.enum([
-  'videotoolbox', 'cuda', 'nvdec', 'vaapi', 'qsv',
-  'd3d11va', 'dxva2', 'amf', 'vdpau', 'drm',
+  'videotoolbox',
+  'cuda',
+  'nvdec',
+  'vaapi',
+  'qsv',
+  'd3d11va',
+  'dxva2',
+  'amf',
+  'vdpau',
+  'drm',
 ])
 
-const HwAccelPreferSchema = z.union([HwAccelBackendSchema, z.literal('none')]).nullable().optional()
+const HwAccelPreferSchema = z
+  .union([HwAccelBackendSchema, z.literal('none')])
+  .nullable()
+  .optional()
 
 const HwAccelResolutionSchema = z.object({
   preferred: z.array(HwAccelBackendSchema).readonly(),
@@ -48,23 +59,39 @@ export function createHwAccelRouter(broker: ServiceBroker | null) {
       .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 }) as Promise<HwAccelResolution>
+        return broker.call('$hwaccel.resolve', params, {
+          nodeID: input.nodeId,
+        }) as Promise<HwAccelResolution>
       }),
 
     /** List every node currently reachable and the hwaccel each resolves to. */
     resolveAll: adminProcedure
-      .output(z.array(z.object({
-        nodeId: z.string(),
-        resolution: HwAccelResolutionSchema,
-      })))
+      .output(
+        z.array(
+          z.object({
+            nodeId: z.string(),
+            resolution: HwAccelResolutionSchema,
+          }),
+        ),
+      )
       .query(async () => {
         if (!broker) throw new Error('Moleculer broker not available')
-        const registry = (broker as unknown as { registry: { getNodeList: (opts: { onlyAvailable: boolean }) => readonly { id: string }[] } }).registry
+        const registry = (
+          broker as unknown as {
+            registry: {
+              getNodeList: (opts: { onlyAvailable: boolean }) => readonly { id: string }[]
+            }
+          }
+        ).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 }) as HwAccelResolution
+              const resolution = (await broker.call(
+                '$hwaccel.resolve',
+                { prefer: null },
+                { nodeID: n.id },
+              )) as HwAccelResolution
               return { nodeId: n.id, resolution }
             } catch (err) {
               const msg = err instanceof Error ? err.message : String(err)

package/src/api/core/live-events.router.ts

@@ -9,22 +9,29 @@ import type { EventBusService } from '../../core/events/event-bus.service.js'
 import type { AddonRegistryService } from '../../core/addon/addon-registry.service.js'
 import { trpcRouter, protectedProcedure, iterableSubscription } from '../trpc/trpc.middleware.js'
 
-export function createLiveEventsRouter(
-  eb: EventBusService,
-  ar: AddonRegistryService,
-) {
+export function createLiveEventsRouter(eb: EventBusService, ar: AddonRegistryService) {
   return trpcRouter({
     recentSystemEvents: protectedProcedure
-      .input(z.object({
-        category: z.string().optional(),
-        limit: z.number().optional(),
-      }).optional())
+      .input(
+        z
+          .object({
+            category: z.string().optional(),
+            limit: z.number().optional(),
+          })
+          .optional(),
+      )
       .query(({ input }) => eb.getRecent(input ?? {}, input?.limit ?? 50)),
 
     onEvent: protectedProcedure
       .input(z.object({ category: z.string().optional() }))
       .subscription(({ input }) => {
-        return iterableSubscription<{ id: string; timestamp: Date; source: { type: string; id: string | number }; category: string; data: Record<string, unknown> }>((push) => {
+        return iterableSubscription<{
+          id: string
+          timestamp: Date
+          source: { type: string; id: string | number }
+          category: string
+          data: Record<string, unknown>
+        }>((push) => {
           const filter: Record<string, unknown> = {}
           if (input.category) filter.category = input.category
           return eb.subscribe(filter, push)

package/src/api/core/logs.router.ts

@@ -8,7 +8,12 @@
  */
 import { z } from 'zod'
 import type { LoggingService } from '../../core/logging/logging.service.js'
-import { trpcRouter, protectedProcedure, adminProcedure, iterableSubscription } from '../trpc/trpc.middleware.js'
+import {
+  trpcRouter,
+  protectedProcedure,
+  adminProcedure,
+  iterableSubscription,
+} from '../trpc/trpc.middleware.js'
 import type { LogEntry } from '@camstack/types'
 
 const LogLevelSchema = z.enum(['debug', 'info', 'warn', 'error'])
@@ -18,6 +23,10 @@ const LogTagsSchema = z.object({
   nodeId: z.string().optional(),
   /** Numeric progressive id (or its string form for legacy callers). */
   deviceId: z.union([z.string(), z.number()]).optional(),
+  /** Parent container id — set on every accessory child's logs (and on the
+   *  container's own logs). Filtering by it returns the whole container subtree
+   *  (container + all children) in one query. */
+  containerDeviceId: z.union([z.string(), z.number()]).optional(),
   deviceName: z.string().optional(),
   integrationId: z.string().optional(),
   addonId: z.string().optional(),
@@ -55,13 +64,15 @@ const LogEntryArraySchema = z.array(LogEntrySchema)
 export function createLogsRouter(logging: LoggingService) {
   return trpcRouter({
     query: adminProcedure
-      .input(z.object({
-        level: LogLevelSchema.optional(),
-        since: z.number().optional(),
-        until: z.number().optional(),
-        limit: z.number().optional(),
-        tags: LogTagsSchema.optional(),
-      }))
+      .input(
+        z.object({
+          level: LogLevelSchema.optional(),
+          since: z.number().optional(),
+          until: z.number().optional(),
+          limit: z.number().optional(),
+          tags: LogTagsSchema.optional(),
+        }),
+      )
       .output(LogEntryArraySchema)
       .query(({ input, ctx }) => {
         const filter: Record<string, unknown> = { limit: input.limit ?? 100 }
@@ -75,10 +86,10 @@ export function createLogsRouter(logging: LoggingService) {
             const ap = ctx.user.permissions?.allowedProviders
             if (ap && ap !== '*') {
               const allowed = ap as string[]
-              return entries.filter(e => {
+              return entries.filter((e) => {
                 const addonId = e.tags?.addonId
                 if (typeof addonId !== 'string') return false
-                return allowed.some(p => {
+                return allowed.some((p) => {
                   const bare = p.startsWith('addon:') ? p.slice('addon:'.length) : p
                   return addonId === bare || addonId.startsWith(bare)
                 })
@@ -87,7 +98,7 @@ export function createLogsRouter(logging: LoggingService) {
           }
           return entries
         })()
-        return filtered.map(e => ({
+        return filtered.map((e) => ({
           timestamp: e.timestamp instanceof Date ? e.timestamp.toISOString() : String(e.timestamp),
           level: e.level,
           ...(e.scope !== undefined ? { scope: e.scope } : {}),
@@ -98,7 +109,10 @@ export function createLogsRouter(logging: LoggingService) {
           // the same normalisation applied in `subscribe` below.
           tags: e.tags
             ? Object.fromEntries(
-                Object.entries(e.tags).map(([k, v]) => [k, v === undefined ? undefined : String(v)]),
+                Object.entries(e.tags).map(([k, v]) => [
+                  k,
+                  v === undefined ? undefined : String(v),
+                ]),
               )
             : undefined,
           ...(e.meta !== undefined ? { meta: e.meta } : {}),
@@ -113,12 +127,14 @@ export function createLogsRouter(logging: LoggingService) {
      * are reading.
      */
     clear: adminProcedure
-      .input(z.object({
-        level: LogLevelSchema.optional(),
-        since: z.number().optional(),
-        until: z.number().optional(),
-        tags: LogTagsSchema.optional(),
-      }))
+      .input(
+        z.object({
+          level: LogLevelSchema.optional(),
+          since: z.number().optional(),
+          until: z.number().optional(),
+          tags: LogTagsSchema.optional(),
+        }),
+      )
       .output(z.object({ removed: z.number().int().nonnegative() }))
       .mutation(({ input }) => {
         const filter: Record<string, unknown> = {}
@@ -131,10 +147,12 @@ export function createLogsRouter(logging: LoggingService) {
       }),
 
     subscribe: protectedProcedure
-      .input(z.object({
-        level: LogLevelSchema.optional(),
-        tags: LogTagsSchema.optional(),
-      }))
+      .input(
+        z.object({
+          level: LogLevelSchema.optional(),
+          tags: LogTagsSchema.optional(),
+        }),
+      )
       .subscription(({ input }) => {
         return iterableSubscription<unknown>((push) => {
           return logging.subscribe(
@@ -142,12 +160,27 @@ export function createLogsRouter(logging: LoggingService) {
               level: input.level,
               tags: input.tags as Record<string, string> | undefined,
             },
-            (entry: { timestamp: Date | string | number; level: string; message: string; scope?: string; tags?: Record<string, string | number | undefined>; meta?: Record<string, unknown> }) => {
+            (entry: {
+              timestamp: Date | string | number
+              level: string
+              message: string
+              scope?: string
+              tags?: Record<string, string | number | undefined>
+              meta?: Record<string, unknown>
+            }) => {
               const stringifiedTags = entry.tags
-                ? Object.fromEntries(Object.entries(entry.tags).map(([k, v]) => [k, v === undefined ? undefined : String(v)]))
+                ? Object.fromEntries(
+                    Object.entries(entry.tags).map(([k, v]) => [
+                      k,
+                      v === undefined ? undefined : String(v),
+                    ]),
+                  )
                 : undefined
               push({
-                timestamp: entry.timestamp instanceof Date ? entry.timestamp.toISOString() : String(entry.timestamp),
+                timestamp:
+                  entry.timestamp instanceof Date
+                    ? entry.timestamp.toISOString()
+                    : String(entry.timestamp),
                 level: entry.level,
                 message: entry.message,
                 scope: entry.scope,

package/src/api/core/notifications.router.ts

@@ -58,7 +58,8 @@ export function createNotificationsRouter(ns: NotificationService | null) {
         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' }
+        if (!output.sendTest)
+          return { success: false, error: 'Output does not support test notifications' }
         return output.sendTest()
       }),
   })

package/src/api/core/repl.router.ts

@@ -27,9 +27,7 @@ export function createReplRouter(repl: ReplEngineService) {
     execute: adminProcedure
       .input(z.object({ code: z.string().max(10000), scope: ReplScopeSchema }))
       .output(ReplResultSchema)
-      .mutation(({ input }) =>
-        repl.execute(input.code, { scope: input.scope, variables: {} }),
-      ),
+      .mutation(({ input }) => repl.execute(input.code, { scope: input.scope, variables: {} })),
 
     completions: adminProcedure
       .input(z.object({ partial: z.string(), scope: ReplScopeSchema }))

package/src/api/core/settings-backend.router.ts

@@ -27,17 +27,21 @@ const SetValueSchema = z.object({
   value: z.unknown(),
 })
 
-const QueryFilterSchema = z.object({
-  where: z.record(z.string(), z.unknown()).optional(),
-  whereIn: z.record(z.string(), z.array(z.unknown())).optional(),
-  whereBetween: z.record(z.string(), z.tuple([z.unknown(), z.unknown()])).optional(),
-  orderBy: z.object({
-    field: z.string(),
-    direction: z.enum(['asc', 'desc']),
-  }).optional(),
-  limit: z.number().optional(),
-  offset: z.number().optional(),
-}).optional()
+const QueryFilterSchema = z
+  .object({
+    where: z.record(z.string(), z.unknown()).optional(),
+    whereIn: z.record(z.string(), z.array(z.unknown())).optional(),
+    whereBetween: z.record(z.string(), z.tuple([z.unknown(), z.unknown()])).optional(),
+    orderBy: z
+      .object({
+        field: z.string(),
+        direction: z.enum(['asc', 'desc']),
+      })
+      .optional(),
+    limit: z.number().optional(),
+    offset: z.number().optional(),
+  })
+  .optional()
 
 const QueryInputSchema = z.object({
   collection: z.string(),
@@ -71,72 +75,66 @@ const IsEmptyInputSchema = z.object({
 // Router factory
 // ---------------------------------------------------------------------------
 
-export function createSettingsBackendRouter(
-  getBackend: () => ISettingsBackend | null,
-) {
+export function createSettingsBackendRouter(getBackend: () => ISettingsBackend | null) {
   const requireBackend = (): ISettingsBackend => {
     const backend = getBackend()
     if (!backend) {
-      throw new Error('Settings backend not available — settings-store addon may not be initialized yet')
+      throw new Error(
+        'Settings backend not available — settings-store addon may not be initialized yet',
+      )
     }
     return backend
   }
 
   return trpcRouter({
-    get: protectedProcedure
-      .input(CollectionKeySchema)
-      .query(async ({ input }) => {
-        const result = await requireBackend().get(input)
-        return { value: result }
-      }),
-
-    set: protectedProcedure
-      .input(SetValueSchema)
-      .mutation(async ({ input }) => {
-        await requireBackend().set({ collection: input.collection, key: input.key, value: input.value })
-        return { success: true as const }
-      }),
-
-    query: protectedProcedure
-      .input(QueryInputSchema)
-      .query(async ({ input }) => {
-        const records = await requireBackend().query({ collection: input.collection, filter: input.filter ?? undefined })
-        return { records: records.map(r => ({ id: r.id, data: r.data })) }
-      }),
-
-    insert: protectedProcedure
-      .input(InsertInputSchema)
-      .mutation(async ({ input }) => {
-        await requireBackend().insert(input)
-        return { success: true as const }
-      }),
-
-    update: protectedProcedure
-      .input(UpdateInputSchema)
-      .mutation(async ({ input }) => {
-        await requireBackend().update(input)
-        return { success: true as const }
-      }),
-
-    delete: protectedProcedure
-      .input(CollectionKeySchema)
-      .mutation(async ({ input }) => {
-        await requireBackend().delete(input)
-        return { success: true as const }
-      }),
-
-    count: protectedProcedure
-      .input(CountInputSchema)
-      .query(async ({ input }) => {
-        const result = await requireBackend().count({ collection: input.collection, filter: input.filter ?? undefined })
-        return { count: result }
-      }),
-
-    isEmpty: protectedProcedure
-      .input(IsEmptyInputSchema)
-      .query(async ({ input }) => {
-        const result = await requireBackend().isEmpty(input)
-        return { empty: result }
-      }),
+    get: protectedProcedure.input(CollectionKeySchema).query(async ({ input }) => {
+      const result = await requireBackend().get(input)
+      return { value: result }
+    }),
+
+    set: protectedProcedure.input(SetValueSchema).mutation(async ({ input }) => {
+      await requireBackend().set({
+        collection: input.collection,
+        key: input.key,
+        value: input.value,
+      })
+      return { success: true as const }
+    }),
+
+    query: protectedProcedure.input(QueryInputSchema).query(async ({ input }) => {
+      const records = await requireBackend().query({
+        collection: input.collection,
+        filter: input.filter ?? undefined,
+      })
+      return { records: records.map((r) => ({ id: r.id, data: r.data })) }
+    }),
+
+    insert: protectedProcedure.input(InsertInputSchema).mutation(async ({ input }) => {
+      await requireBackend().insert(input)
+      return { success: true as const }
+    }),
+
+    update: protectedProcedure.input(UpdateInputSchema).mutation(async ({ input }) => {
+      await requireBackend().update(input)
+      return { success: true as const }
+    }),
+
+    delete: protectedProcedure.input(CollectionKeySchema).mutation(async ({ input }) => {
+      await requireBackend().delete(input)
+      return { success: true as const }
+    }),
+
+    count: protectedProcedure.input(CountInputSchema).query(async ({ input }) => {
+      const result = await requireBackend().count({
+        collection: input.collection,
+        filter: input.filter ?? undefined,
+      })
+      return { count: result }
+    }),
+
+    isEmpty: protectedProcedure.input(IsEmptyInputSchema).query(async ({ input }) => {
+      const result = await requireBackend().isEmpty(input)
+      return { empty: result }
+    }),
   })
 }

package/src/api/core/system-events.router.ts

@@ -14,7 +14,13 @@ import { trpcRouter, protectedProcedure, iterableSubscription } from '../trpc/tr
 type SerializedEvent = {
   id: string
   timestamp: string
-  source: { type: string; id: string | number; nodeId?: string; addonId?: string; deviceId?: number }
+  source: {
+    type: string
+    id: string | number
+    nodeId?: string
+    addonId?: string
+    deviceId?: number
+  }
   category: string
   data: unknown
 }
@@ -42,10 +48,12 @@ function serialize(e: SystemEvent): SerializedEvent {
  */
 const ScopeFieldsSchema = z.object({
   /** Legacy source filter (exact type+id match). */
-  source: z.object({
-    type: z.string(),
-    id: z.union([z.string(), z.number()]),
-  }).optional(),
+  source: z
+    .object({
+      type: z.string(),
+      id: z.union([z.string(), z.number()]),
+    })
+    .optional(),
   /** Agent/node filter (prefix match: 'hub' matches 'hub/pipeline'). */
   agentId: z.string().optional(),
   /** Addon filter. Matches source.addonId or source.id when type='addon'. */
@@ -84,33 +92,34 @@ const SubscribeInputSchema = ScopeFieldsSchema.extend({
 
 export function createSystemEventsRouter(eb: EventBusService) {
   return trpcRouter({
-    getRecent: protectedProcedure
-      .input(GetRecentInputSchema)
-      .query(({ input }) => {
-        return eb.getRecent({
-          ...(input.source ? { source: input.source } : {}),
-          ...(input.agentId ? { agentId: input.agentId } : {}),
-          ...(input.addonId ? { addonId: input.addonId } : {}),
-          ...(input.deviceId !== undefined ? { deviceId: input.deviceId } : {}),
-          ...(input.category ? { category: input.category } : {}),
-        }, input.limit).map(serialize)
-      }),
+    getRecent: protectedProcedure.input(GetRecentInputSchema).query(({ input }) => {
+      return eb
+        .getRecent(
+          {
+            ...(input.source ? { source: input.source } : {}),
+            ...(input.agentId ? { agentId: input.agentId } : {}),
+            ...(input.addonId ? { addonId: input.addonId } : {}),
+            ...(input.deviceId !== undefined ? { deviceId: input.deviceId } : {}),
+            ...(input.category ? { category: input.category } : {}),
+          },
+          input.limit,
+        )
+        .map(serialize)
+    }),
 
-    subscribe: protectedProcedure
-      .input(SubscribeInputSchema)
-      .subscription(({ input }) => {
-        return iterableSubscription<unknown>((push) => {
-          return eb.subscribe(
-            {
-              ...(input.source ? { source: input.source } : {}),
-              ...(input.agentId ? { agentId: input.agentId } : {}),
-              ...(input.addonId ? { addonId: input.addonId } : {}),
-              ...(input.deviceId !== undefined ? { deviceId: input.deviceId } : {}),
-              ...(input.category ? { category: input.category } : {}),
-            },
-            (event: SystemEvent) => push(serialize(event)),
-          )
-        })
-      }),
+    subscribe: protectedProcedure.input(SubscribeInputSchema).subscription(({ input }) => {
+      return iterableSubscription<unknown>((push) => {
+        return eb.subscribe(
+          {
+            ...(input.source ? { source: input.source } : {}),
+            ...(input.agentId ? { agentId: input.agentId } : {}),
+            ...(input.addonId ? { addonId: input.addonId } : {}),
+            ...(input.deviceId !== undefined ? { deviceId: input.deviceId } : {}),
+            ...(input.category ? { category: input.category } : {}),
+          },
+          (event: SystemEvent) => push(serialize(event)),
+        )
+      })
+    }),
   })
 }