@camstack/server 0.1.7 → 0.2.0

package/src/api/capabilities.router.ts

@@ -60,92 +60,109 @@ export function createCapabilitiesRouter(
 
     // ─── Get current preference for a capability ──────────────────────
 
-    getPreference: adminProcedure
-      .input(z.object({ capability: z.string() }))
-      .query(({ input }) => {
-        const registry = addonRegistry.getCapabilityRegistry()
-        const mode = registry.getMode(input.capability)
-        if (!mode) return null
-
-        if (mode === 'singleton') {
-          const addonId = configService.get<string>(`capabilities.singleton.${input.capability}`)
-          return {
-            capability: input.capability,
-            mode: mode as 'singleton',
-            preference: addonId ? { addonId } : null,
-          }
-        }
+    getPreference: adminProcedure.input(z.object({ capability: z.string() })).query(({ input }) => {
+      const registry = addonRegistry.getCapabilityRegistry()
+      const mode = registry.getMode(input.capability)
+      if (!mode) return null
 
-        // collection
-        const raw = configService.get<string>(collectionPreferenceKey(input.capability))
-        let disabled: string[] = []
-        if (raw) {
-          try {
-            const parsed = JSON.parse(raw) as { disabled?: string[] }
-            disabled = Array.isArray(parsed.disabled) ? parsed.disabled : []
-          } catch { /* ignore malformed */ }
-        }
+      if (mode === 'singleton') {
+        const addonId = configService.get<string>(`capabilities.singleton.${input.capability}`)
         return {
           capability: input.capability,
-          mode: mode as 'collection',
-          preference: { disabled },
+          mode: mode as 'singleton',
+          preference: addonId ? { addonId } : null,
         }
-      }),
-
-    // ─── Set preference (singleton switch or collection toggle) ───────
-
-    setPreference: adminProcedure
-      .input(setPreferenceInput)
-      .mutation(async ({ input }) => {
-        const registry = addonRegistry.getCapabilityRegistry()
-
-        if (input.mode === 'singleton') {
-          const { capability, addonId } = input
-          const caps = registry.listCapabilities()
-          const cap = caps.find((c) => c.name === capability)
-          if (!cap) throw new TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${capability}` })
-          if (cap.mode !== 'singleton') throw new TRPCError({ code: 'BAD_REQUEST', message: `"${capability}" is not a singleton` })
-          if (!cap.providers.includes(addonId)) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: `Provider "${addonId}" is not registered for "${capability}"` })
-          }
-
-          const requiresRestart = isInfraCapability(capability)
+      }
 
-          if (!requiresRestart) {
-            // Hot-swap at runtime
-            await registry.setActiveSingleton(capability, addonId)
-          }
+      // collection
+      const raw = configService.get<string>(collectionPreferenceKey(input.capability))
+      let disabled: string[] = []
+      if (raw) {
+        try {
+          const parsed = JSON.parse(raw) as { disabled?: string[] }
+          disabled = Array.isArray(parsed.disabled) ? parsed.disabled : []
+        } catch {
+          /* ignore malformed */
+        }
+      }
+      return {
+        capability: input.capability,
+        mode: mode as 'collection',
+        preference: { disabled },
+      }
+    }),
 
-          // Persist preference
-          configService.set(`capabilities.singleton.${capability}`, addonId)
-          logger.info('Singleton preference set', { tags: { addonId }, meta: { capability, requiresRestart } })
+    // ─── Set preference (singleton switch or collection toggle) ───────
 
-          return { success: true, requiresRestart }
-        }
+    setPreference: adminProcedure.input(setPreferenceInput).mutation(async ({ input }) => {
+      const registry = addonRegistry.getCapabilityRegistry()
 
-        // collection toggle
-        const { capability, addonId, enabled } = input
+      if (input.mode === 'singleton') {
+        const { capability, addonId } = input
         const caps = registry.listCapabilities()
         const cap = caps.find((c) => c.name === capability)
-        if (!cap) throw new TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${capability}` })
-        if (cap.mode !== 'collection') throw new TRPCError({ code: 'BAD_REQUEST', message: `"${capability}" is not a collection` })
+        if (!cap)
+          throw new TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${capability}` })
+        if (cap.mode !== 'singleton')
+          throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: `"${capability}" is not a singleton`,
+          })
         if (!cap.providers.includes(addonId)) {
-          throw new TRPCError({ code: 'BAD_REQUEST', message: `Provider "${addonId}" is not registered for "${capability}"` })
+          throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: `Provider "${addonId}" is not registered for "${capability}"`,
+          })
         }
 
-        if (enabled) {
-          registry.enableCollectionProvider(capability, addonId)
-        } else {
-          registry.disableCollectionProvider(capability, addonId)
+        const requiresRestart = isInfraCapability(capability)
+
+        if (!requiresRestart) {
+          // Hot-swap at runtime
+          await registry.setActiveSingleton(capability, addonId)
         }
 
-        // Persist disabled list via the shared canonical writer.
-        const updatedCap = registry.listCapabilities().find((c) => c.name === capability)
-        persistCollectionDisabled(configService, capability, updatedCap?.disabledProviders ?? [])
-        logger.info('Collection provider toggled', { tags: { addonId }, meta: { capability, enabled } })
+        // Persist preference
+        configService.set(`capabilities.singleton.${capability}`, addonId)
+        logger.info('Singleton preference set', {
+          tags: { addonId },
+          meta: { capability, requiresRestart },
+        })
 
-        return { success: true, requiresRestart: false }
-      }),
+        return { success: true, requiresRestart }
+      }
+
+      // collection toggle
+      const { capability, addonId, enabled } = input
+      const caps = registry.listCapabilities()
+      const cap = caps.find((c) => c.name === capability)
+      if (!cap)
+        throw new TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${capability}` })
+      if (cap.mode !== 'collection')
+        throw new TRPCError({ code: 'BAD_REQUEST', message: `"${capability}" is not a collection` })
+      if (!cap.providers.includes(addonId)) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: `Provider "${addonId}" is not registered for "${capability}"`,
+        })
+      }
+
+      if (enabled) {
+        registry.enableCollectionProvider(capability, addonId)
+      } else {
+        registry.disableCollectionProvider(capability, addonId)
+      }
+
+      // Persist disabled list via the shared canonical writer.
+      const updatedCap = registry.listCapabilities().find((c) => c.name === capability)
+      persistCollectionDisabled(configService, capability, updatedCap?.disabledProviders ?? [])
+      logger.info('Collection provider toggled', {
+        tags: { addonId },
+        meta: { capability, enabled },
+      })
+
+      return { success: true, requiresRestart: false }
+    }),
 
     // ─── Reset preference to default ──────────────────────────────────
 
@@ -154,11 +171,17 @@ export function createCapabilitiesRouter(
       .mutation(({ input }) => {
         const registry = addonRegistry.getCapabilityRegistry()
         const mode = registry.getMode(input.capability)
-        if (!mode) throw new TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${input.capability}` })
+        if (!mode)
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: `Unknown capability: ${input.capability}`,
+          })
 
         if (mode === 'singleton') {
           configService.set(`capabilities.singleton.${input.capability}`, null)
-          logger.info('Singleton preference reset (takes effect on restart)', { meta: { capability: input.capability } })
+          logger.info('Singleton preference reset (takes effect on restart)', {
+            meta: { capability: input.capability },
+          })
           return { success: true, requiresRestart: true }
         }
 
@@ -171,7 +194,9 @@ export function createCapabilitiesRouter(
           }
         }
         configService.set(`capabilities.collection.${input.capability}`, null)
-        logger.info('Collection preference reset (all providers re-enabled)', { meta: { capability: input.capability } })
+        logger.info('Collection preference reset (all providers re-enabled)', {
+          meta: { capability: input.capability },
+        })
         return { success: true, requiresRestart: false }
       }),
 
@@ -187,7 +212,10 @@ export function createCapabilitiesRouter(
       .mutation(({ input }) => {
         const registry = addonRegistry.getCapabilityRegistry()
         registry.setDeviceOverride(input.deviceId, input.capability, input.addonId)
-        logger.info('Device capability override set', { tags: { deviceId: Number(input.deviceId), addonId: input.addonId }, meta: { capability: input.capability } })
+        logger.info('Device capability override set', {
+          tags: { deviceId: Number(input.deviceId), addonId: input.addonId },
+          meta: { capability: input.capability },
+        })
       }),
 
     clearDeviceCapability: adminProcedure
@@ -195,7 +223,10 @@ export function createCapabilitiesRouter(
       .mutation(({ input }) => {
         const registry = addonRegistry.getCapabilityRegistry()
         registry.clearDeviceOverride(input.deviceId, input.capability)
-        logger.info('Device capability override cleared', { tags: { deviceId: Number(input.deviceId) }, meta: { capability: input.capability } })
+        logger.info('Device capability override cleared', {
+          tags: { deviceId: Number(input.deviceId) },
+          meta: { capability: input.capability },
+        })
       }),
 
     getDeviceCapabilities: adminProcedure
@@ -208,11 +239,16 @@ 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()) }),
+      )
       .mutation(({ input }) => {
         const registry = addonRegistry.getCapabilityRegistry()
         registry.setDeviceCollectionFilter(input.deviceId, input.capability, input.addonIds)
-        logger.info('Device collection filter set', { tags: { deviceId: Number(input.deviceId) }, meta: { capability: input.capability, addonIds: input.addonIds } })
+        logger.info('Device collection filter set', {
+          tags: { deviceId: Number(input.deviceId) },
+          meta: { capability: input.capability, addonIds: input.addonIds },
+        })
       }),
 
     clearDeviceCollectionFilter: adminProcedure
@@ -220,7 +256,10 @@ export function createCapabilitiesRouter(
       .mutation(({ input }) => {
         const registry = addonRegistry.getCapabilityRegistry()
         registry.clearDeviceCollectionFilter(input.deviceId, input.capability)
-        logger.info('Device collection filter cleared', { tags: { deviceId: Number(input.deviceId) }, meta: { capability: input.capability } })
+        logger.info('Device collection filter cleared', {
+          tags: { deviceId: Number(input.deviceId) },
+          meta: { capability: input.capability },
+        })
       }),
   })
 }

package/src/api/core/__tests__/auth-router-totp.spec.ts

@@ -57,22 +57,35 @@ function makeUserMgmt(overrides: Partial<MockUserManagement> = {}): MockUserMana
   }
 }
 
-function makeConfig(overrides: Record<string, unknown> = {}): { get<T>(p: string): T; update(s: string, d: Record<string, unknown>): void } {
+function makeConfig(overrides: Record<string, unknown> = {}): {
+  get<T>(p: string): T
+  update(s: string, d: Record<string, unknown>): void
+} {
   const store: Record<string, unknown> = { 'auth.jwtSecret': 'unit-test-secret', ...overrides }
   return {
-    get<T>(path: string): T { return store[path] as T },
-    update(_section: string, _data: Record<string, unknown>): void { /* no-op */ },
+    get<T>(path: string): T {
+      return store[path] as T
+    },
+    update(_section: string, _data: Record<string, unknown>): void {
+      /* no-op */
+    },
   }
 }
 
-function makeRegistry(userMgmt: MockUserManagement): { getSingleton: (name: string) => unknown | null } {
+function makeRegistry(userMgmt: MockUserManagement): {
+  getSingleton: (name: string) => unknown | null
+} {
   return {
     getSingleton: (name: string) => (name === 'user-management' ? userMgmt : null),
   }
 }
 
 /** Invoke a tRPC procedure directly via the router's internal API. */
-async function callProc(router: ReturnType<typeof createAuthRouter>, name: 'login' | 'loginVerifyTotp', input: unknown): Promise<unknown> {
+async function callProc(
+  router: ReturnType<typeof createAuthRouter>,
+  name: 'login' | 'loginVerifyTotp',
+  input: unknown,
+): Promise<unknown> {
   const caller = router.createCaller({} as never)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const fn = (caller as any)[name]
@@ -97,7 +110,7 @@ describe('auth.router — TOTP gate', () => {
       userMgmt.getTotpStatus.mockResolvedValueOnce({ enabled: false, confirmedAt: null })
 
       const router = createAuthRouter(auth, registry as never)
-      const result = await callProc(router, 'login', { username: 'alice', password: 'pw' }) as {
+      const result = (await callProc(router, 'login', { username: 'alice', password: 'pw' })) as {
         token: string
         user: { id: string; username: string; isAdmin: boolean }
         requiresTotp?: boolean
@@ -118,7 +131,7 @@ describe('auth.router — TOTP gate', () => {
       userMgmt.getTotpStatus.mockResolvedValueOnce({ enabled: true, confirmedAt: Date.now() })
 
       const router = createAuthRouter(auth, registry as never)
-      const result = await callProc(router, 'login', { username: 'alice', password: 'pw' }) as {
+      const result = (await callProc(router, 'login', { username: 'alice', password: 'pw' })) as {
         token: string
         user: { id: string; username: string; isAdmin: boolean }
         requiresTotp?: boolean
@@ -137,13 +150,17 @@ describe('auth.router — TOTP gate', () => {
     it('rejects invalid credentials', async () => {
       userMgmt.validateCredentials.mockResolvedValueOnce(null)
       const router = createAuthRouter(auth, registry as never)
-      await expect(callProc(router, 'login', { username: 'alice', password: 'wrong' })).rejects.toThrow('Invalid credentials')
+      await expect(
+        callProc(router, 'login', { username: 'alice', password: 'wrong' }),
+      ).rejects.toThrow('Invalid credentials')
     })
 
     it('throws when user-management cap is unregistered (boot failure)', async () => {
       const emptyRegistry = { getSingleton: () => null } as never
       const router = createAuthRouter(auth, emptyRegistry)
-      await expect(callProc(router, 'login', { username: 'alice', password: 'pw' })).rejects.toThrow(/user-management.*capability not registered/)
+      await expect(
+        callProc(router, 'login', { username: 'alice', password: 'pw' }),
+      ).rejects.toThrow(/user-management.*capability not registered/)
     })
 
     it('falls through to session-token branch when getTotpStatus method is absent (older user-mgmt builds)', async () => {
@@ -155,7 +172,9 @@ describe('auth.router — TOTP gate', () => {
         listUsers: vi.fn(),
       }
       const router = createAuthRouter(auth, makeRegistry(legacyMgmt as never) as never)
-      const result = await callProc(router, 'login', { username: 'alice', password: 'pw' }) as { requiresTotp?: boolean }
+      const result = (await callProc(router, 'login', { username: 'alice', password: 'pw' })) as {
+        requiresTotp?: boolean
+      }
       expect(result.requiresTotp).toBe(false)
     })
   })
@@ -173,7 +192,10 @@ describe('auth.router — TOTP gate', () => {
       })
 
       const router = createAuthRouter(auth, registry as never)
-      const result = await callProc(router, 'loginVerifyTotp', { challengeToken, code: '123456' }) as {
+      const result = (await callProc(router, 'loginVerifyTotp', {
+        challengeToken,
+        code: '123456',
+      })) as {
         token: string
         user: { id: string; username: string; isAdmin: boolean }
         requiresTotp?: boolean
@@ -195,7 +217,11 @@ describe('auth.router — TOTP gate', () => {
 
     it('rejects a forged challenge token (signed with wrong secret)', async () => {
       const other = new AuthService(makeConfig({ 'auth.jwtSecret': 'attacker-secret' }) as never)
-      const forged = other.signTotpChallengeToken({ userId: 'u-1', username: 'alice', isAdmin: true })
+      const forged = other.signTotpChallengeToken({
+        userId: 'u-1',
+        username: 'alice',
+        isAdmin: true,
+      })
       const router = createAuthRouter(auth, registry as never)
       await expect(
         callProc(router, 'loginVerifyTotp', { challengeToken: forged, code: '000000' }),
@@ -218,7 +244,11 @@ describe('auth.router — TOTP gate', () => {
 
     it('rejects a wrong 6-digit code', async () => {
       userMgmt.verifyTotp.mockResolvedValueOnce({ valid: false })
-      const challengeToken = auth.signTotpChallengeToken({ userId: 'u-1', username: 'alice', isAdmin: false })
+      const challengeToken = auth.signTotpChallengeToken({
+        userId: 'u-1',
+        username: 'alice',
+        isAdmin: false,
+      })
       const router = createAuthRouter(auth, registry as never)
       await expect(
         callProc(router, 'loginVerifyTotp', { challengeToken, code: '000000' }),
@@ -229,7 +259,11 @@ describe('auth.router — TOTP gate', () => {
       userMgmt.verifyTotp.mockResolvedValueOnce({ valid: true })
       // The fresh listUsers() call returns nothing — user was deleted.
       userMgmt.listUsers.mockResolvedValueOnce([])
-      const challengeToken = auth.signTotpChallengeToken({ userId: 'ghost', username: 'alice', isAdmin: false })
+      const challengeToken = auth.signTotpChallengeToken({
+        userId: 'ghost',
+        username: 'alice',
+        isAdmin: false,
+      })
       const router = createAuthRouter(auth, registry as never)
       await expect(
         callProc(router, 'loginVerifyTotp', { challengeToken, code: '123456' }),
@@ -238,14 +272,21 @@ describe('auth.router — TOTP gate', () => {
 
     it('uses the FRESHLY fetched user record (scope changes pick up immediately)', async () => {
       // Issue challenge for u-1 with empty scopes (the in-token snapshot).
-      const challengeToken = auth.signTotpChallengeToken({ userId: 'u-1', username: 'alice', isAdmin: false })
+      const challengeToken = auth.signTotpChallengeToken({
+        userId: 'u-1',
+        username: 'alice',
+        isAdmin: false,
+      })
       // Between the two legs, an admin granted u-1 a new scope.
       userMgmt.verifyTotp.mockResolvedValueOnce({ valid: true })
       userMgmt.listUsers.mockResolvedValueOnce([
         makeUser({ scopes: [{ type: 'category', target: 'addon', access: ['view'] }] }),
       ])
       const router = createAuthRouter(auth, registry as never)
-      const result = await callProc(router, 'loginVerifyTotp', { challengeToken, code: '123456' }) as { token: string }
+      const result = (await callProc(router, 'loginVerifyTotp', {
+        challengeToken,
+        code: '123456',
+      })) as { token: string }
       const decoded = auth.verifyToken(result.token)
       // The fresh scope is in the minted session JWT, not the snapshot
       // from the (potentially stale) password leg.

package/src/api/core/__tests__/integration-markers.spec.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest'
+import { INTEGRATION_CAP_MARKERS } from '../cap-providers.js'
+
+describe('integration cap markers', () => {
+  it('recognises device-adoption (not the old ha-discovery)', () => {
+    expect(INTEGRATION_CAP_MARKERS.has('device-adoption')).toBe(true)
+    expect(INTEGRATION_CAP_MARKERS.has('ha-discovery')).toBe(false)
+    expect(INTEGRATION_CAP_MARKERS.has('device-provider')).toBe(true)
+  })
+})

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

@@ -103,7 +103,10 @@ export function createAddonSettingsRouter(cfg: ConfigService) {
       .output(SuccessSchema)
       .mutation(({ input }) => {
         const current = cfg.getAddonDevice(input.addonId, input.deviceId)
-        cfg.setAddonDevice(input.addonId, input.deviceId, { ...current, [input.field]: input.value })
+        cfg.setAddonDevice(input.addonId, input.deviceId, {
+          ...current,
+          [input.field]: input.value,
+        })
         return { success: true as const }
       }),
 

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

@@ -9,51 +9,44 @@
 import { z } from 'zod'
 import type { AgentRegistryService } from '../../core/agent/agent-registry.service.js'
 import type { MoleculerService } from '../../core/moleculer/moleculer.service.js'
-import {
-  trpcRouter, adminProcedure,
-} from '../trpc/trpc.middleware.js'
+import { trpcRouter, adminProcedure } from '../trpc/trpc.middleware.js'
 
 const AgentRoleSchema = z.enum(['decoder', 'transcoder', 'detector', 'recorder'])
 
-export function createAgentsRouter(
-  ar: AgentRegistryService,
-  moleculer: MoleculerService,
-) {
+export function createAgentsRouter(ar: AgentRegistryService, moleculer: MoleculerService) {
   return trpcRouter({
     // ── Node listing (replaces listAgents / listConnected) ────────────
-    listNodes: adminProcedure
-      .input(z.void())
-      .query(async () => {
-        const items = await ar.listNodes()
-        // Spread to mutable copies: AgentListItem uses readonly arrays; Zod output schema uses mutable.
-        return items.map(a => ({
-          ...a,
-          info: {
-            ...a.info,
-            capabilities: [...a.info.capabilities],
-          },
-          status: {
-            ...a.status,
-            fps: { ...a.status.fps },
-            errors: [...a.status.errors],
-          },
-          subProcesses: [...a.subProcesses],
-        }))
-      }),
+    listNodes: adminProcedure.input(z.void()).query(async () => {
+      const items = await ar.listNodes()
+      // Spread to mutable copies: AgentListItem uses readonly arrays; Zod output schema uses mutable.
+      return items.map((a) => ({
+        ...a,
+        info: {
+          ...a.info,
+          capabilities: [...a.info.capabilities],
+        },
+        status: {
+          ...a.status,
+          fps: { ...a.status.fps },
+          errors: [...a.status.errors],
+        },
+        subProcesses: [...a.subProcesses],
+      }))
+    }),
 
     // ── Capability discovery (via Moleculer service list) ─────────────
-    getAgentCapabilities: adminProcedure
-      .input(z.void())
-      .query(async () => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access -- moleculer.broker.call typing chain unresolvable; runtime shape validated by the cast below
-        const services = await moleculer.broker.call('$node.services', {}) as Array<{ name: string }>
-        const capSet = new Set<string>()
-        for (const svc of services) {
-          if (svc.name.startsWith('$')) continue
-          capSet.add(svc.name)
-        }
-        return [...capSet].sort()
-      }),
+    getAgentCapabilities: adminProcedure.input(z.void()).query(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access -- moleculer.broker.call typing chain unresolvable; runtime shape validated by the cast below
+      const services = (await moleculer.broker.call('$node.services', {})) as Array<{
+        name: string
+      }>
+      const capSet = new Set<string>()
+      for (const svc of services) {
+        if (svc.name.startsWith('$')) continue
+        capSet.add(svc.name)
+      }
+      return [...capSet].toSorted()
+    }),
 
     // ── Role assignments ──────────────────────────────────────────────
     getAssignments: adminProcedure
@@ -61,27 +54,33 @@ export function createAgentsRouter(
       .query(({ input }) => ar.getAssignments(input.cameraId)),
 
     setAssignment: adminProcedure
-      .input(z.object({
-        cameraId: z.number(),
-        role: AgentRoleSchema,
-        agentId: z.string(),
-        priority: z.enum(['primary', 'backup', 'overflow']),
-        rtspUrl: z.string().optional(),
-      }))
+      .input(
+        z.object({
+          cameraId: z.number(),
+          role: AgentRoleSchema,
+          agentId: z.string(),
+          priority: z.enum(['primary', 'backup', 'overflow']),
+          rtspUrl: z.string().optional(),
+        }),
+      )
       .mutation(({ input }) => ar.setAssignment(input as never)),
 
     removeAssignment: adminProcedure
-      .input(z.object({
-        cameraId: z.number(),
-        role: AgentRoleSchema,
-      }))
+      .input(
+        z.object({
+          cameraId: z.number(),
+          role: AgentRoleSchema,
+        }),
+      )
       .mutation(({ input }) => ar.removeAssignment(input.cameraId, input.role as never)),
 
     activateBackup: adminProcedure
-      .input(z.object({
-        cameraId: z.number(),
-        role: AgentRoleSchema,
-      }))
+      .input(
+        z.object({
+          cameraId: z.number(),
+          role: AgentRoleSchema,
+        }),
+      )
       .mutation(({ input }) => ar.activateBackup(input.cameraId, input.role as never)),
   })
 }