@camstack/server 0.1.8 → 0.2.1

package/src/core/addon/addon-search.service.ts

@@ -62,7 +62,8 @@ export class AddonSearchService {
     }
 
     // npm registry v1 search: packages with BOTH "camstack" and "addon" keywords
-    const url = 'https://registry.npmjs.org/-/v1/search?text=keywords:camstack+keywords:addon&size=250'
+    const url =
+      'https://registry.npmjs.org/-/v1/search?text=keywords:camstack+keywords:addon&size=250'
 
     try {
       const response = await fetch(url, {

package/src/core/addon/addon-settings-provider.ts

@@ -154,10 +154,15 @@ function createAddonSettingsProvider(deps: AddonSettingsProviderDeps): IAddonSet
         const result = await addon.getGlobalSettings(input.overlay, input.cap)
         return result ? reshapeForOutput(result) : null
       }
-      return forkedGet(input.addonId, 'getGlobalSettings', {
-        ...(input.overlay ? { overlay: input.overlay } : {}),
-        ...(input.cap ? { cap: input.cap } : {}),
-      }, input.nodeId)
+      return forkedGet(
+        input.addonId,
+        'getGlobalSettings',
+        {
+          ...(input.overlay ? { overlay: input.overlay } : {}),
+          ...(input.cap ? { cap: input.cap } : {}),
+        },
+        input.nodeId,
+      )
     },
 
     async updateGlobalSettings(input: AddonPatchInput) {
@@ -169,7 +174,12 @@ function createAddonSettingsProvider(deps: AddonSettingsProviderDeps): IAddonSet
         await addon.updateGlobalSettings(input.patch)
         return { success: true as const }
       }
-      return forkedUpdate(input.addonId, 'updateGlobalSettings', { patch: input.patch }, input.nodeId)
+      return forkedUpdate(
+        input.addonId,
+        'updateGlobalSettings',
+        { patch: input.patch },
+        input.nodeId,
+      )
     },
 
     async getDeviceSettings(input: DeviceGetInput) {
@@ -179,7 +189,12 @@ function createAddonSettingsProvider(deps: AddonSettingsProviderDeps): IAddonSet
         const result = await addon.getDeviceSettings(input.deviceId)
         return result ? reshapeForOutput(result) : null
       }
-      return forkedGet(input.addonId, 'getDeviceSettings', { deviceId: input.deviceId }, input.nodeId)
+      return forkedGet(
+        input.addonId,
+        'getDeviceSettings',
+        { deviceId: input.deviceId },
+        input.nodeId,
+      )
     },
 
     async updateDeviceSettings(input: DeviceUpdateInput) {
@@ -191,7 +206,12 @@ function createAddonSettingsProvider(deps: AddonSettingsProviderDeps): IAddonSet
         await addon.updateDeviceSettings(input.deviceId, input.patch)
         return { success: true as const }
       }
-      return forkedUpdate(input.addonId, 'updateDeviceSettings', { deviceId: input.deviceId, patch: input.patch }, input.nodeId)
+      return forkedUpdate(
+        input.addonId,
+        'updateDeviceSettings',
+        { deviceId: input.deviceId, patch: input.patch },
+        input.nodeId,
+      )
     },
   }
 }

package/src/core/addon-bridge/addon-bridge.service.ts

@@ -37,9 +37,7 @@ export class AddonBridgeService {
   /** Whether the bridge initialised successfully */
   private available = false
 
-  constructor(
-    private readonly loggingService: LoggingService,
-  ) {
+  constructor(private readonly loggingService: LoggingService) {
     this.logger = this.loggingService.createLogger('AddonBridge')
 
     // Initialize installer eagerly in constructor (no async needed).
@@ -49,7 +47,10 @@ export class AddonBridgeService {
       const dataDir = process.env.CAMSTACK_DATA ?? 'camstack-data'
       const addonsDir = path.resolve(dataDir, 'addons')
       const workspacePackagesDir = kernel.detectWorkspacePackagesDir(__dirname)
-      this.installer = new kernel.AddonInstaller({ addonsDir, workspacePackagesDir: workspacePackagesDir ?? undefined })
+      this.installer = new kernel.AddonInstaller({
+        addonsDir,
+        workspacePackagesDir: workspacePackagesDir ?? undefined,
+      })
       kernel.ensureDir(addonsDir)
     } catch (error: unknown) {
       const msg = errMsg(error)
@@ -70,10 +71,14 @@ export class AddonBridgeService {
       await this.loader.loadFromDirectory(addonsDir)
 
       this.available = true
-      this.logger.info('Addon bridge initialized', { meta: { count: this.loader.listAddons().length } })
+      this.logger.info('Addon bridge initialized', {
+        meta: { count: this.loader.listAddons().length },
+      })
     } catch (error: unknown) {
       const msg = errMsg(error)
-      this.logger.warn('Addon bridge loader failed — install/uninstall still available', { meta: { error: msg } })
+      this.logger.warn('Addon bridge loader failed — install/uninstall still available', {
+        meta: { error: msg },
+      })
     }
   }
 

package/src/core/addon-pages/addon-pages.service.ts

@@ -47,7 +47,9 @@ export class AddonPagesService {
     const providers = this.caps.getCollection<IAddonPageProvider>('addon-pages-source')
     const isRegistered = providers.some((p) => p.id === addonId)
     if (!isRegistered) {
-      this.logger.warn('Bundle resolve failed: addon not registered as page provider', { tags: { addonId } })
+      this.logger.warn('Bundle resolve failed: addon not registered as page provider', {
+        tags: { addonId },
+      })
       return null
     }
 

package/src/core/addon-widgets/addon-widgets.service.ts

@@ -60,10 +60,13 @@ export class AddonWidgetsService {
     // the bare manifest id, so the route always carries the bare
     // `addonId` — match it against each registry key with the
     // `@<nodeId>` suffix stripped.
-    const entries = this.caps.getCollectionEntries<IAddonWidgetsSourceProvider>('addon-widgets-source')
+    const entries =
+      this.caps.getCollectionEntries<IAddonWidgetsSourceProvider>('addon-widgets-source')
     const isRegistered = entries.some(([id]) => stripNodeSuffix(id) === addonId)
     if (!isRegistered) {
-      this.logger.warn('Bundle resolve failed: addon not registered as widget provider', { tags: { addonId } })
+      this.logger.warn('Bundle resolve failed: addon not registered as widget provider', {
+        tags: { addonId },
+      })
       return null
     }
 

package/src/core/agent/agent-registry.service.ts

@@ -181,9 +181,7 @@ export class AgentRegistryService {
       | { getNodeList?: (opts: { onlyAvailable: boolean }) => readonly { id: string }[] }
       | undefined
     const nodes = registry?.getNodeList?.({ onlyAvailable: true }) ?? []
-    const agentIds = nodes
-      .map((n) => n.id)
-      .filter((id) => id !== 'hub' && !id.includes('/'))
+    const agentIds = nodes.map((n) => n.id).filter((id) => id !== 'hub' && !id.includes('/'))
     if (agentIds.length === 0) return
     console.log(`[agent-registry] Boot reconcile: ${agentIds.length} connected agent(s)`)
     for (const agentId of agentIds) {
@@ -217,10 +215,14 @@ export class AgentRegistryService {
     }
     try {
       const broker = this.broker
-      const statusRaw = await broker.call('$agent.status', {}, {
-        nodeID: agentId,
-        timeout: AGENT_RECONCILE_RPC_TIMEOUT_MS,
-      })
+      const statusRaw = await broker.call(
+        '$agent.status',
+        {},
+        {
+          nodeID: agentId,
+          timeout: AGENT_RECONCILE_RPC_TIMEOUT_MS,
+        },
+      )
       const agentAddons = this.extractAgentAddons(statusRaw)
       if (agentAddons.length === 0) return
 
@@ -243,7 +245,9 @@ export class AgentRegistryService {
       })
 
       if (stale.length === 0) {
-        console.log(`[agent-registry] Reconcile ${agentId}: no stale addons (${agentAddons.length} checked)`)
+        console.log(
+          `[agent-registry] Reconcile ${agentId}: no stale addons (${agentAddons.length} checked)`,
+        )
         return
       }
 
@@ -252,11 +256,17 @@ export class AgentRegistryService {
           ? 'placement is hub-only'
           : 'not installed on hub'
         try {
-          await broker.call('$agent.undeploy', { addonId: addon.id }, {
-            nodeID: agentId,
-            timeout: AGENT_RECONCILE_RPC_TIMEOUT_MS,
-          })
-          console.log(`[agent-registry] Reconcile ${agentId}: undeployed stale addon "${addon.id}" (${reason})`)
+          await broker.call(
+            '$agent.undeploy',
+            { addonId: addon.id },
+            {
+              nodeID: agentId,
+              timeout: AGENT_RECONCILE_RPC_TIMEOUT_MS,
+            },
+          )
+          console.log(
+            `[agent-registry] Reconcile ${agentId}: undeployed stale addon "${addon.id}" (${reason})`,
+          )
           this.eventBus.emit({
             id: randomUUID(),
             timestamp: new Date(),
@@ -303,7 +313,10 @@ export class AgentRegistryService {
     // Get child processes for hub via $process.list
     let hubProcesses: readonly unknown[] = []
     try {
-      const processes = await this.broker.call('$process.list') as readonly Record<string, unknown>[]
+      const processes = (await this.broker.call('$process.list')) as readonly Record<
+        string,
+        unknown
+      >[]
       hubProcesses = processes.map((p) => ({
         pid: (p.pid as number) ?? 0,
         name: (p.name as string) ?? '',
@@ -333,18 +346,26 @@ export class AgentRegistryService {
       if (nodeId === 'hub' || nodeId.includes('/')) continue
 
       try {
-        const status = await this.broker.call('$agent.status', {}, {
-          nodeID: nodeId,
-          timeout: 5000,
-        }) as Record<string, unknown>
+        const status = (await this.broker.call(
+          '$agent.status',
+          {},
+          {
+            nodeID: nodeId,
+            timeout: 5000,
+          },
+        )) as Record<string, unknown>
 
         // Get real sub-process stats from the agent's $process.list
         let subProcesses: readonly unknown[] = []
         try {
-          const processes = await this.broker.call('$process.list', {}, {
-            nodeID: nodeId,
-            timeout: 5000,
-          }) as readonly Record<string, unknown>[]
+          const processes = (await this.broker.call(
+            '$process.list',
+            {},
+            {
+              nodeID: nodeId,
+              timeout: 5000,
+            },
+          )) as readonly Record<string, unknown>[]
           subProcesses = processes.map((p) => ({
             pid: (p.pid as number) ?? 0,
             name: (p.name as string) ?? '',
@@ -358,20 +379,21 @@ export class AgentRegistryService {
           }))
         } catch {
           // Fall back to addon list from $agent.status (no stats)
-          subProcesses = (status.addons as readonly Record<string, unknown>[] | undefined)?.map((a) => ({
-            pid: 0,
-            name: (a.id as string) ?? '',
-            command: 'moleculer-service',
-            state: ((a.status as string) ?? 'running') as 'running' | 'stopped' | 'crashed',
-            cpuPercent: 0,
-            memoryRss: 0,
-            uptimeSeconds: 0,
-          })) ?? []
+          subProcesses =
+            (status.addons as readonly Record<string, unknown>[] | undefined)?.map((a) => ({
+              pid: 0,
+              name: (a.id as string) ?? '',
+              command: 'moleculer-service',
+              state: ((a.status as string) ?? 'running') as 'running' | 'stopped' | 'crashed',
+              cpuPercent: 0,
+              memoryRss: 0,
+              uptimeSeconds: 0,
+            })) ?? []
         }
 
         // Extract addon IDs from $agent.status
-        const agentAddons: readonly string[] = (status.addons as readonly { id: string }[] | undefined)
-          ?.map(a => a.id) ?? []
+        const agentAddons: readonly string[] =
+          (status.addons as readonly { id: string }[] | undefined)?.map((a) => a.id) ?? []
 
         const hostname = typeof status.hostname === 'string' ? status.hostname : null
         const agentName = typeof status.name === 'string' ? status.name : nodeId
@@ -387,7 +409,7 @@ export class AgentRegistryService {
             memoryMB: (status.totalMemoryMB as number) ?? 0,
             cpuModel: status.cpuModel as string | undefined,
           },
-          localIps: Array.isArray(status.localIps) ? status.localIps as string[] : [],
+          localIps: Array.isArray(status.localIps) ? (status.localIps as string[]) : [],
           status: {
             activeCameras: 0,
             cpuPercent: (status.cpuPercent as number) ?? 0,
@@ -395,14 +417,14 @@ export class AgentRegistryService {
             fps: {},
             errors: [],
           },
-          connectedSince: typeof status.uptime === 'number'
-            ? Date.now() - (status.uptime as number) * 1000
-            : Date.now(),
+          connectedSince:
+            typeof status.uptime === 'number'
+              ? Date.now() - (status.uptime as number) * 1000
+              : Date.now(),
           isHub: false,
           subProcesses,
           agentAddons,
         })
-
       } catch {
         // Skip nodes without $agent service
       }

package/src/core/auth/auth.service.spec.ts

@@ -1,4 +1,3 @@
- 
 import { describe, it, expect, beforeEach } from 'vitest'
 import { AuthService } from './auth.service'
 import type { ConfigService } from '../config/config.service'
@@ -28,20 +27,19 @@ describe('AuthService', () => {
       }
 
       const token = service.signToken(payload)
-       
+
       const decoded = service.verifyToken(token)
 
-       
       expect(decoded.userId).toBe('user-1')
-       
+
       expect(decoded.username).toBe('admin')
-       
+
       expect(decoded.role).toBe('admin')
-       
+
       expect(decoded.allowedProviders).toBe('*')
-       
+
       expect(decoded.iat).toBeDefined()
-       
+
       expect(decoded.exp).toBeDefined()
     })
 

package/src/core/config/config.service.spec.ts

@@ -92,7 +92,7 @@ describe('ConfigService', () => {
     expect(raw.features.objectDetection).toBe(false)
     expect(raw.storage.provider).toBe('sqlite-storage')
     expect(raw.logging.level).toBe('info')
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access -- 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access --
     expect((raw.logging as any).retentionDays).toBe(30)
     expect(raw.eventBus.ringBufferSize).toBe(10000)
     // addons.enabled removed — installed = active

package/src/core/events/event-bus.service.spec.ts

@@ -10,7 +10,7 @@ import type { ISettingsStore } from '@camstack/kernel'
 import type { SystemEvent } from '@camstack/types'
 
 /** Flush pending queueMicrotask callbacks */
-const flush = () => new Promise<void>(resolve => queueMicrotask(resolve))
+const flush = () => new Promise<void>((resolve) => queueMicrotask(resolve))
 
 const makeEvent = (category: string, overrides: Partial<SystemEvent> = {}): SystemEvent => ({
   id: `evt-${Math.random().toString(36).slice(2, 8)}`,
@@ -35,19 +35,43 @@ class InMemorySettingsStore implements ISettingsStore {
     this.system = { ...seed }
   }
 
-  getSystem(key: string): unknown { return this.system[key] }
-  setSystem(key: string, value: unknown): void { this.system[key] = value }
-  getAllSystem(): Record<string, unknown> { return { ...this.system } }
-
-  getAllAddon(_addonId: string): Record<string, unknown> { return {} }
-  setAllAddon(_addonId: string, _config: Record<string, unknown>): void { /* no-op */ }
-  getAllProvider(_providerId: string): Record<string, unknown> { return {} }
-  setProvider(_providerId: string, _key: string, _value: unknown): void { /* no-op */ }
-  getAllDevice(_deviceId: string): Record<string, unknown> { return {} }
-  setDevice(_deviceId: string, _key: string, _value: unknown): void { /* no-op */ }
-  getAddonDevice(_addonId: string, _deviceId: string): Record<string, unknown> { return {} }
-  setAddonDevice(_addonId: string, _deviceId: string, _values: Record<string, unknown>): void { /* no-op */ }
-  clearAddonDevice(_addonId: string, _deviceId: string): void { /* no-op */ }
+  getSystem(key: string): unknown {
+    return this.system[key]
+  }
+  setSystem(key: string, value: unknown): void {
+    this.system[key] = value
+  }
+  getAllSystem(): Record<string, unknown> {
+    return { ...this.system }
+  }
+
+  getAllAddon(_addonId: string): Record<string, unknown> {
+    return {}
+  }
+  setAllAddon(_addonId: string, _config: Record<string, unknown>): void {
+    /* no-op */
+  }
+  getAllProvider(_providerId: string): Record<string, unknown> {
+    return {}
+  }
+  setProvider(_providerId: string, _key: string, _value: unknown): void {
+    /* no-op */
+  }
+  getAllDevice(_deviceId: string): Record<string, unknown> {
+    return {}
+  }
+  setDevice(_deviceId: string, _key: string, _value: unknown): void {
+    /* no-op */
+  }
+  getAddonDevice(_addonId: string, _deviceId: string): Record<string, unknown> {
+    return {}
+  }
+  setAddonDevice(_addonId: string, _deviceId: string, _values: Record<string, unknown>): void {
+    /* no-op */
+  }
+  clearAddonDevice(_addonId: string, _deviceId: string): void {
+    /* no-op */
+  }
 }
 
 describe('EventBusService', () => {
@@ -80,9 +104,11 @@ describe('EventBusService', () => {
       'utf-8',
     )
     const configService = new ConfigService(configPath)
-    configService.setSettingsStore(new InMemorySettingsStore({
-      'eventBus.ringBufferSize': bufferSize,
-    }))
+    configService.setSettingsStore(
+      new InMemorySettingsStore({
+        'eventBus.ringBufferSize': bufferSize,
+      }),
+    )
     const service = new EventBusService(configService)
     // EventBusService is a delegate that needs a broker to dispatch
     // through. Use a unique nodeID per call so each test gets its own
@@ -152,10 +178,7 @@ describe('EventBusService', () => {
     const service = await createService()
     const received: SystemEvent[] = []
 
-    service.subscribe(
-      { source: { type: 'addon', id: 'frigate' } },
-      (event) => received.push(event),
-    )
+    service.subscribe({ source: { type: 'addon', id: 'frigate' } }, (event) => received.push(event))
 
     service.emit(makeEvent('addon.started', { source: { type: 'addon', id: 'frigate' } }))
     service.emit(makeEvent('addon.started', { source: { type: 'addon', id: 'scrypted' } }))

package/src/core/events/event-bus.service.ts

@@ -27,7 +27,11 @@ export class EventBusService implements IEventBus {
   // before `attachBroker` runs (NestJS-era boot legacy). Drained into
   // the real bus on attach.
   private pending: SystemEvent[] = []
-  private deferredSubs: Array<{ filter: EventFilter; handler: (event: SystemEvent) => void; unsub?: () => void }> = []
+  private deferredSubs: Array<{
+    filter: EventFilter
+    handler: (event: SystemEvent) => void
+    unsub?: () => void
+  }> = []
 
   constructor(_configService: ConfigService) {
     // The shared bus owns the ring-buffer size — hub-side config is

package/src/core/feature/feature.service.spec.ts

@@ -14,7 +14,10 @@ import type { FeatureManifest } from '@camstack/types'
  * ConfigManager constructor succeeds.
  */
 class StaticFeatureConfigService extends ConfigService {
-  constructor(configPath: string, private readonly staticFeatures: FeatureManifest) {
+  constructor(
+    configPath: string,
+    private readonly staticFeatures: FeatureManifest,
+  ) {
     super(configPath)
   }
 

package/src/core/lifecycle/lifecycle-state-machine.spec.ts

@@ -27,9 +27,8 @@ describe('LifecycleStateMachine', () => {
   let machine: LifecycleStateMachine
 
   beforeEach(() => {
-     
     eventBus = createMockEventBus()
-     
+
     logger = createMockLogger()
     machine = new LifecycleStateMachine('test-element', 'device', eventBus, logger)
   })
@@ -55,7 +54,7 @@ describe('LifecycleStateMachine', () => {
     const result = machine.transition('running')
     expect(result).toBe(false)
     expect(machine.state).toBe('stopped')
-     
+
     expect(logger.warn).toHaveBeenCalledWith(
       expect.stringContaining('Invalid state transition'),
       expect.anything(),
@@ -66,21 +65,20 @@ describe('LifecycleStateMachine', () => {
     machine.transition('starting')
     machine.transition('running')
 
-     
     expect(eventBus.emit).toHaveBeenCalledTimes(2)
-     
+
     expect(eventBus.emitted[0]!.category).toBe('device.state.starting')
-     
+
     expect(eventBus.emitted[0]!.source).toEqual({ type: 'device', id: 'test-element' })
-     
+
     expect(eventBus.emitted[0]!.data).toMatchObject({
       from: 'stopped',
       to: 'starting',
       elementId: 'test-element',
     })
-     
+
     expect(eventBus.emitted[1]!.category).toBe('device.state.running')
-     
+
     expect(eventBus.emitted[1]!.data).toMatchObject({
       from: 'starting',
       to: 'running',
@@ -89,7 +87,7 @@ describe('LifecycleStateMachine', () => {
 
   it('does not emit event on invalid transition', () => {
     machine.transition('running')
-     
+
     expect(eventBus.emit).not.toHaveBeenCalled()
   })
 

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

@@ -1,4 +1,3 @@
-
 import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import * as fs from 'node:fs'
 import * as path from 'node:path'
@@ -25,19 +24,43 @@ class InMemorySettingsStore implements ISettingsStore {
     this.system = { ...seed }
   }
 
-  getSystem(key: string): unknown { return this.system[key] }
-  setSystem(key: string, value: unknown): void { this.system[key] = value }
-  getAllSystem(): Record<string, unknown> { return { ...this.system } }
-
-  getAllAddon(_addonId: string): Record<string, unknown> { return {} }
-  setAllAddon(_addonId: string, _config: Record<string, unknown>): void { /* no-op */ }
-  getAllProvider(_providerId: string): Record<string, unknown> { return {} }
-  setProvider(_providerId: string, _key: string, _value: unknown): void { /* no-op */ }
-  getAllDevice(_deviceId: string): Record<string, unknown> { return {} }
-  setDevice(_deviceId: string, _key: string, _value: unknown): void { /* no-op */ }
-  getAddonDevice(_addonId: string, _deviceId: string): Record<string, unknown> { return {} }
-  setAddonDevice(_addonId: string, _deviceId: string, _values: Record<string, unknown>): void { /* no-op */ }
-  clearAddonDevice(_addonId: string, _deviceId: string): void { /* no-op */ }
+  getSystem(key: string): unknown {
+    return this.system[key]
+  }
+  setSystem(key: string, value: unknown): void {
+    this.system[key] = value
+  }
+  getAllSystem(): Record<string, unknown> {
+    return { ...this.system }
+  }
+
+  getAllAddon(_addonId: string): Record<string, unknown> {
+    return {}
+  }
+  setAllAddon(_addonId: string, _config: Record<string, unknown>): void {
+    /* no-op */
+  }
+  getAllProvider(_providerId: string): Record<string, unknown> {
+    return {}
+  }
+  setProvider(_providerId: string, _key: string, _value: unknown): void {
+    /* no-op */
+  }
+  getAllDevice(_deviceId: string): Record<string, unknown> {
+    return {}
+  }
+  setDevice(_deviceId: string, _key: string, _value: unknown): void {
+    /* no-op */
+  }
+  getAddonDevice(_addonId: string, _deviceId: string): Record<string, unknown> {
+    return {}
+  }
+  setAddonDevice(_addonId: string, _deviceId: string, _values: Record<string, unknown>): void {
+    /* no-op */
+  }
+  clearAddonDevice(_addonId: string, _deviceId: string): void {
+    /* no-op */
+  }
 }
 
 describe('ScopedLogger', () => {
@@ -147,13 +170,28 @@ describe('LogRingBuffer', () => {
   it('filters by tags (addonId exact match)', () => {
     const buffer = new LogRingBuffer(100)
 
-    buffer.push({ timestamp: new Date(), level: 'info', message: 'a', tags: { addonId: 'stream-broker' } })
-    buffer.push({ timestamp: new Date(), level: 'info', message: 'b', tags: { addonId: 'provider-rtsp' } })
-    buffer.push({ timestamp: new Date(), level: 'info', message: 'c', tags: { addonId: 'stream-broker' } })
+    buffer.push({
+      timestamp: new Date(),
+      level: 'info',
+      message: 'a',
+      tags: { addonId: 'stream-broker' },
+    })
+    buffer.push({
+      timestamp: new Date(),
+      level: 'info',
+      message: 'b',
+      tags: { addonId: 'provider-rtsp' },
+    })
+    buffer.push({
+      timestamp: new Date(),
+      level: 'info',
+      message: 'c',
+      tags: { addonId: 'stream-broker' },
+    })
 
     const result = buffer.query({ tags: { addonId: 'stream-broker' } })
     expect(result).toHaveLength(2)
-    expect(result.map((e) => e.message).sort()).toEqual(['a', 'c'])
+    expect(result.map((e) => e.message).toSorted()).toEqual(['a', 'c'])
   })
 
   it('respects limit', () => {
@@ -190,9 +228,11 @@ describe('LoggingService', () => {
       'utf-8',
     )
     const configService = new ConfigService(configPath)
-    configService.setSettingsStore(new InMemorySettingsStore({
-      'eventBus.ringBufferSize': bufferSize,
-    }))
+    configService.setSettingsStore(
+      new InMemorySettingsStore({
+        'eventBus.ringBufferSize': bufferSize,
+      }),
+    )
     return new LoggingService(configService)
   }