@camstack/server 0.1.3

package/src/__tests__/cap-routers/metrics-provider.router.spec.ts

@@ -0,0 +1,119 @@
+
+/**
+ * Example spec exercising the codegen'd metrics-provider router end-to-end:
+ *  - Wires a mock provider into `createCapRouter_metricsProvider`
+ *  - Verifies happy-path query dispatch + output validation for getCurrent()
+ *  - Verifies provider-missing → PRECONDITION_FAILED
+ */
+import { describe, it, expect } from 'vitest'
+import { createCapRouter_metricsProvider } from '../../api/trpc/generated-cap-routers.js'
+import { type IMetricsProvider } from '@camstack/types'
+import { makeCtx, invokeProcedure } from './harness.js'
+
+function makeMockProvider(overrides: Partial<IMetricsProvider> = {}): IMetricsProvider {
+  return {
+    collectSnapshot: async () => ({
+      cpu: { total: 0, user: 0, system: 0, irq: 0, nice: 0, loadAvg: [0, 0, 0], cores: 1 },
+      memory: { percent: 0, totalBytes: 0, usedBytes: 0, availableBytes: 0, swapUsedBytes: 0, swapTotalBytes: 0 },
+      gpu: null,
+      network: { rxBytes: 0, txBytes: 0, rxPackets: 0, txPackets: 0, rxErrors: 0, txErrors: 0, timestampMs: 0 },
+      disk: { readBytes: 0, writeBytes: 0, readOps: 0, writeOps: 0, timestampMs: 0 },
+      pressure: { cpu: null, memory: null, io: null },
+      process: { openFds: 0, threadCount: 0, activeHandles: 0, activeRequests: 0 },
+      cpuTemperature: null,
+      timestampMs: 0,
+    }),
+    getCached: async () => null,
+    getCurrent: async () => ({
+      cpuPercent: 42.5,
+      memoryPercent: 68.2,
+      memoryUsedMB: 8192,
+      memoryTotalMB: 16384,
+      diskPercent: 55.1,
+      temperature: 48.0,
+    }),
+    getDiskSpace: async ({ dirPath }) => ({
+      path: dirPath,
+      totalBytes: 0,
+      usedBytes: 0,
+      availableBytes: 0,
+      percent: 0,
+    }),
+    getGpuInfo: async () => null,
+    getCpuTemperature: async () => null,
+    getProcessStats: async () => [],
+    ...overrides,
+  }
+}
+
+describe('createCapRouter_metricsProvider', () => {
+  describe('happy path', () => {
+    it('dispatches getCurrent() to the provider and returns typed metrics', async () => {
+      const provider = makeMockProvider()
+      const router = createCapRouter_metricsProvider(() => provider)
+
+      const outcome = await invokeProcedure(router, 'getCurrent', makeCtx('admin'))
+
+      expect(outcome.ok).toBe(true)
+      if (outcome.ok) {
+        expect(outcome.value).toMatchObject({
+          cpuPercent: 42.5,
+          memoryPercent: 68.2,
+          memoryUsedMB: 8192,
+          memoryTotalMB: 16384,
+        })
+      }
+    })
+
+    it('propagates optional fields (temperature, gpuPercent)', async () => {
+      const router = createCapRouter_metricsProvider(() =>
+        makeMockProvider({
+          getCurrent: async () => ({
+            cpuPercent: 10,
+            memoryPercent: 20,
+            memoryUsedMB: 1024,
+            memoryTotalMB: 8192,
+            gpuPercent: 75,
+            gpuMemoryPercent: 60,
+          }),
+        }),
+      )
+
+      const outcome = await invokeProcedure(router, 'getCurrent', makeCtx('admin'))
+
+      expect(outcome.ok).toBe(true)
+      if (outcome.ok) {
+        const value = outcome.value as { gpuPercent?: number; gpuMemoryPercent?: number }
+        expect(value.gpuPercent).toBe(75)
+        expect(value.gpuMemoryPercent).toBe(60)
+      }
+    })
+  })
+
+  describe('auth', () => {
+    it('rejects anonymous (protected endpoint)', async () => {
+      const router = createCapRouter_metricsProvider(() => makeMockProvider())
+      const outcome = await invokeProcedure(router, 'getCurrent', makeCtx('anonymous'))
+      expect(outcome.ok).toBe(false)
+      if (!outcome.ok) expect(outcome.code).toBe('UNAUTHORIZED')
+    })
+
+    it('allows viewer (protected endpoint)', async () => {
+      const router = createCapRouter_metricsProvider(() => makeMockProvider())
+      const outcome = await invokeProcedure(router, 'getCurrent', makeCtx('user'))
+      expect(outcome.ok).toBe(true)
+    })
+  })
+
+  describe('missing provider', () => {
+    it('throws PRECONDITION_FAILED when getProvider returns null', async () => {
+      const router = createCapRouter_metricsProvider(() => null)
+      const outcome = await invokeProcedure(router, 'getCurrent', makeCtx('admin'))
+      expect(outcome.ok).toBe(false)
+      if (!outcome.ok) {
+        expect(outcome.code).toBe('PRECONDITION_FAILED')
+        expect(outcome.message).toContain('metrics-provider')
+      }
+    })
+  })
+})

package/src/__tests__/cap-routers/null-provider-guard.spec.ts

@@ -0,0 +1,66 @@
+/**
+ * Comprehensive null-provider spec — verifies that EVERY codegen'd cap
+ * router returns PRECONDITION_FAILED when the provider is null.
+ *
+ * This is a safety net: if a new cap is added and the codegen'd router
+ * doesn't guard against a null provider, this test catches it.
+ *
+ * NOTE: some caps have methods that require non-void input (z.object({...})).
+ * For those, Zod input validation may reject our empty input before the
+ * null-provider check runs — in which case we expect BAD_REQUEST or
+ * PRECONDITION_FAILED (both are acceptable: the point is that the call
+ * does NOT succeed and return garbage data).
+ */
+import { describe, it, expect } from 'vitest'
+import * as generatedModule from '../../api/trpc/generated-cap-routers.js'
+import { makeCtx, invokeProcedure } from './harness.js'
+
+// Discover all createCapRouter_* functions from the generated module
+const routerFactories: Array<{ name: string; factory: (getProvider: () => null) => unknown }> = []
+for (const [key, value] of Object.entries(generatedModule)) {
+  if (key.startsWith('createCapRouter_') && typeof value === 'function') {
+    routerFactories.push({
+      name: key.replace('createCapRouter_', ''),
+      factory: value as (getProvider: () => null) => unknown,
+    })
+  }
+}
+
+describe('null-provider guard — all capabilities', () => {
+  it(`discovers ${routerFactories.length} cap router factories`, () => {
+    expect(routerFactories.length).toBeGreaterThanOrEqual(30)
+  })
+
+  for (const { name, factory } of routerFactories) {
+    it(`${name}: null provider does not return success`, async () => {
+      const router = factory(() => null)
+
+      // Find the first method on the router's caller
+      const caller = (router as { createCaller: (ctx: unknown) => Record<string, unknown> })
+        .createCaller(makeCtx('admin'))
+
+      const methods = Object.keys(caller).filter(
+        k => typeof caller[k] === 'function' && !k.startsWith('_'),
+      )
+
+      if (methods.length === 0) return // No methods — skip
+
+      // Try the first method with no input (will work for void-input methods)
+      const firstMethod = methods[0]!
+      const result = await invokeProcedure(
+        router as { createCaller: (ctx: unknown) => Record<string, (input?: unknown) => unknown> },
+        firstMethod,
+        makeCtx('admin'),
+      )
+
+      // The call should NOT succeed — either PRECONDITION_FAILED (null provider
+      // caught by codegen guard) or BAD_REQUEST (input validation before guard)
+      // or INTERNAL_SERVER_ERROR (provider method call on null).
+      // Any of these is acceptable — the important thing is ok !== true.
+      expect(
+        result.ok,
+        `${name}.${firstMethod} returned success with null provider!`,
+      ).toBe(false)
+    })
+  }
+})

package/src/__tests__/cap-routers/pipeline-executor.router.spec.ts

@@ -0,0 +1,135 @@
+
+/**
+ * Router-level spec for `pipelineExecutor` — covers the reference-media
+ * and audio-capabilities endpoints that remain on the cap after the
+ * benchmark methods moved to `@camstack/addon-benchmark` (2026-04-14,
+ * dispatched via `api.addons.custom`). The full benchmark E2E surface
+ * is now tested inside the benchmark addon's own spec files.
+ */
+import { describe, it, expect } from 'vitest'
+import { createCapRouter_pipelineExecutor } from '../../api/trpc/generated-cap-routers.js'
+import type { IPipelineExecutorProvider } from '@camstack/types'
+import { makeCtx, invokeProcedure } from './harness.js'
+
+function makeMockProvider(overrides: Partial<IPipelineExecutorProvider> = {}): IPipelineExecutorProvider {
+  const defaultEngine = { runtime: 'node' as const, backend: 'cpu', format: 'onnx' as const }
+
+  return {
+    getAvailableEngines: () => [defaultEngine],
+    getSelectedEngine: () => defaultEngine,
+    setEngine: async () => ({ steps: [] }),
+    getDefaultSteps: async () => [],
+    getSchema: async () => ({
+      availableEngines: [{ engine: defaultEngine, devices: [{ id: 'cpu', label: 'CPU' }], defaultDevice: 'cpu' }],
+      selectedEngine: defaultEngine,
+      slots: [],
+    }),
+    getGlobalSteps: async () => null,
+    setGlobalSteps: () => {},
+    getGlobalPipelineConfig: () => null,
+    getOrchestratorConfigSchema: () => ({ sections: [] }),
+    getOrchestratorSettings: () => ({
+      motionFps: 4, detectionFps: 10, cooldownMs: 10000, maxConcurrentInferences: null,
+    }),
+    setOrchestratorSettings: () => {},
+    listTemplates: () => [],
+    saveTemplate: () => ({
+      id: 'tpl-1', name: 'x', createdAt: '', updatedAt: '', engine: defaultEngine, steps: [],
+    }),
+    updateTemplate: () => ({
+      id: 'tpl-1', name: 'x', createdAt: '', updatedAt: '', engine: defaultEngine, steps: [],
+    }),
+    deleteTemplate: () => {},
+    getCapabilities: async () => {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- test mock: `never` is uninhabitable so `as never` is the only option
+      const platform: never = { name: 'test', cpuCores: 4 } as never
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- test mock: `never` is uninhabitable so `as never` is the only option
+      const runtimes: never = {} as never
+      return { platform, addons: [], runtimes }
+    },
+    detect: async () => ({ detections: [], inferenceMs: 0, modelId: 'yolov9t' }),
+    downloadModel: async () => ({ filePath: '', sizeMB: 0, durationMs: 0 }),
+    deleteModel: async () => ({ success: true as const }),
+    runPipeline: async () => ({
+      detections: [],
+      stepTimings: [],
+      totalMs: 42,
+      imageWidth: 640,
+      imageHeight: 480,
+    }),
+    runFrame: async () => null,
+    listReferenceImages: () => [],
+    getReferenceImage: () => null,
+    getReferenceAudioFiles: () => [{ filename: 'car.wav', sizeKb: 12 }],
+    getReferenceAudio: () => ({ base64: 'AAAA' }),
+    getAudioCapabilities: () => ({
+      activeBackend: 'yamnet-onnx',
+      availableBackends: [{ id: 'yamnet-onnx', name: 'YAMNet ONNX', description: '', available: true }],
+      sampleRate: 16000,
+      chunkDurationMs: 500,
+    }),
+    getAddonResolver: () => ({ resolve: async () => { throw new Error('nop') }, shutdownAll: async () => {} }),
+    orchestratorStatus: () => null,
+    cameraDetectionStatus: () => null,
+    getDevicePipelineSteps: () => null,
+    setDevicePipelineSteps: async () => {},
+    clearDevicePipelineSteps: async () => {},
+    ...overrides,
+  }
+}
+
+describe('createCapRouter_pipelineExecutor — reference + audio endpoints', () => {
+  describe('listReferenceImages', () => {
+    it('delegates to provider.listReferenceImages', async () => {
+      const router = createCapRouter_pipelineExecutor(() =>
+        makeMockProvider({
+          listReferenceImages: () => [
+            { id: 'persons-cars-animal.jpg', filename: 'persons-cars-animal.jpg', sizeKB: 120 },
+          ] as never,
+        }),
+      )
+
+      const outcome = await invokeProcedure(router, 'listReferenceImages', makeCtx('admin'))
+      expect(outcome.ok).toBe(true)
+    })
+  })
+
+  describe('getAudioCapabilities', () => {
+    it('returns backend list from provider', async () => {
+      const router = createCapRouter_pipelineExecutor(() => makeMockProvider())
+      const outcome = await invokeProcedure(router, 'getAudioCapabilities', makeCtx('admin'))
+      expect(outcome.ok).toBe(true)
+      if (outcome.ok) {
+        const caps = outcome.value as { activeBackend: string; sampleRate: number }
+        expect(caps.activeBackend).toBe('yamnet-onnx')
+        expect(caps.sampleRate).toBe(16000)
+      }
+    })
+  })
+
+  describe('missing provider', () => {
+    it('throws PRECONDITION_FAILED when getProvider returns null', async () => {
+      const router = createCapRouter_pipelineExecutor(() => null)
+      const outcome = await invokeProcedure(router, 'listReferenceImages', makeCtx('admin'))
+      expect(outcome.ok).toBe(false)
+      if (!outcome.ok) {
+        expect(outcome.code).toBe('PRECONDITION_FAILED')
+      }
+    })
+  })
+
+  describe('auth', () => {
+    it('rejects anonymous on listReferenceImages (protected query)', async () => {
+      const router = createCapRouter_pipelineExecutor(() => makeMockProvider())
+      const outcome = await invokeProcedure(router, 'listReferenceImages', makeCtx('anonymous'))
+      expect(outcome.ok).toBe(false)
+      if (!outcome.ok) expect(outcome.code).toBe('UNAUTHORIZED')
+    })
+
+    it('allows viewer to read reference images (protected query)', async () => {
+      const router = createCapRouter_pipelineExecutor(() => makeMockProvider())
+      const outcome = await invokeProcedure(router, 'listReferenceImages', makeCtx('user'))
+      expect(outcome.ok).toBe(true)
+    })
+  })
+})

package/src/__tests__/cap-routers/settings-store.router.spec.ts

@@ -0,0 +1,247 @@
+ 
+/**
+ * Spec for the codegen'd `settings-store` capability router.
+ *
+ * Exercises:
+ *  - All 8 methods (get, set, query, insert, update, delete, count, isEmpty)
+ *  - Auth enforcement (all methods are protected)
+ *  - Missing provider → PRECONDITION_FAILED
+ *  - Namespace passthrough (optional namespace field)
+ */
+import { describe, it, expect, beforeEach } from 'vitest'
+import { createCapRouter_settingsStore } from '../../api/trpc/generated-cap-routers.js'
+import type { ISettingsStoreProvider } from '@camstack/types'
+import { makeCtx, invokeProcedure } from './harness.js'
+
+interface MockRecord {
+  readonly id: string
+  readonly data: Record<string, unknown>
+}
+
+interface MockStore {
+  records: Map<string, MockRecord>
+}
+
+function makeMockProvider(): ISettingsStoreProvider & { _store: MockStore } {
+  const store: MockStore = { records: new Map() }
+
+  return {
+    _store: store,
+
+    async get(input) {
+      const record = store.records.get(input.key)
+      return record?.data ?? null
+    },
+
+    async set(input) {
+      store.records.set(input.key, { id: input.key, data: input.value as Record<string, unknown> ?? {} })
+    },
+
+    async query(input) {
+      const results = [...store.records.values()]
+      if (input.filter?.limit) return results.slice(0, input.filter.limit)
+      return results
+    },
+
+    async insert(input) {
+      store.records.set(input.record.id, input.record)
+    },
+
+    async update(input) {
+      const existing = store.records.get(input.id)
+      if (existing) {
+        store.records.set(input.id, { id: input.id, data: { ...existing.data, ...input.data } })
+      }
+    },
+
+    async delete(input) {
+      store.records.delete(input.key)
+    },
+
+    async count() {
+      return store.records.size
+    },
+
+    async isEmpty() {
+      return store.records.size === 0
+    },
+  }
+}
+
+describe('createCapRouter_settingsStore', () => {
+  let provider: ReturnType<typeof makeMockProvider>
+
+  beforeEach(() => {
+    provider = makeMockProvider()
+  })
+
+  // ── Happy path: all 8 methods ──────────────────────────────────────
+
+  describe('get', () => {
+    it('returns stored value by key', async () => {
+      provider._store.records.set('myKey', { id: 'myKey', data: { foo: 'bar' } })
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'get', makeCtx('admin'), { collection: 'test', key: 'myKey' })
+      expect(result.ok).toBe(true)
+      if (result.ok) expect(result.value).toMatchObject({ foo: 'bar' })
+    })
+
+    it('returns null for missing key', async () => {
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'get', makeCtx('admin'), { collection: 'test', key: 'nope' })
+      expect(result.ok).toBe(true)
+      if (result.ok) expect(result.value).toBeNull()
+    })
+  })
+
+  describe('set', () => {
+    it('upserts a value', async () => {
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'set', makeCtx('admin'), { collection: 'test', key: 'k1', value: { x: 1 } })
+      expect(result.ok).toBe(true)
+      expect(provider._store.records.has('k1')).toBe(true)
+    })
+  })
+
+  describe('query', () => {
+    it('returns all records', async () => {
+      provider._store.records.set('a', { id: 'a', data: { v: 1 } })
+      provider._store.records.set('b', { id: 'b', data: { v: 2 } })
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'query', makeCtx('admin'), { collection: 'test' })
+      expect(result.ok).toBe(true)
+      if (result.ok) expect(result.value).toHaveLength(2)
+    })
+
+    it('respects filter.limit', async () => {
+      provider._store.records.set('a', { id: 'a', data: {} })
+      provider._store.records.set('b', { id: 'b', data: {} })
+      provider._store.records.set('c', { id: 'c', data: {} })
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'query', makeCtx('admin'), { collection: 'test', filter: { limit: 2 } })
+      expect(result.ok).toBe(true)
+      if (result.ok) expect(result.value).toHaveLength(2)
+    })
+  })
+
+  describe('insert', () => {
+    it('adds a record', async () => {
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'insert', makeCtx('admin'), {
+        collection: 'test',
+        record: { id: 'r1', data: { name: 'test' } },
+      })
+      expect(result.ok).toBe(true)
+      expect(provider._store.records.get('r1')?.data).toMatchObject({ name: 'test' })
+    })
+  })
+
+  describe('update', () => {
+    it('merges data into existing record', async () => {
+      provider._store.records.set('r1', { id: 'r1', data: { a: 1, b: 2 } })
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'update', makeCtx('admin'), {
+        collection: 'test',
+        id: 'r1',
+        data: { b: 99 },
+      })
+      expect(result.ok).toBe(true)
+      expect(provider._store.records.get('r1')?.data).toMatchObject({ a: 1, b: 99 })
+    })
+  })
+
+  describe('delete', () => {
+    it('removes a record', async () => {
+      provider._store.records.set('r1', { id: 'r1', data: {} })
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'delete', makeCtx('admin'), { collection: 'test', key: 'r1' })
+      expect(result.ok).toBe(true)
+      expect(provider._store.records.has('r1')).toBe(false)
+    })
+  })
+
+  describe('count', () => {
+    it('returns record count', async () => {
+      provider._store.records.set('a', { id: 'a', data: {} })
+      provider._store.records.set('b', { id: 'b', data: {} })
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'count', makeCtx('admin'), { collection: 'test' })
+      expect(result.ok).toBe(true)
+      if (result.ok) expect(result.value).toBe(2)
+    })
+  })
+
+  describe('isEmpty', () => {
+    it('returns true when empty', async () => {
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'isEmpty', makeCtx('admin'), { collection: 'test' })
+      expect(result.ok).toBe(true)
+      if (result.ok) expect(result.value).toBe(true)
+    })
+
+    it('returns false when records exist', async () => {
+      provider._store.records.set('x', { id: 'x', data: {} })
+      const router = createCapRouter_settingsStore(() => provider)
+      const result = await invokeProcedure(router, 'isEmpty', makeCtx('admin'), { collection: 'test' })
+      expect(result.ok).toBe(true)
+      if (result.ok) expect(result.value).toBe(false)
+    })
+  })
+
+  // ── Namespace passthrough ──────────────────────────────────────────
+
+  describe('namespace', () => {
+    it('passes namespace to provider (optional field)', async () => {
+      let capturedNamespace: string | undefined
+      const nsProvider = makeMockProvider()
+      const originalGet = nsProvider.get.bind(nsProvider)
+      nsProvider.get = async (input: { namespace?: string; collection: string; key: string }) => {
+        capturedNamespace = input.namespace
+        return originalGet(input)
+      }
+
+      const router = createCapRouter_settingsStore(() => nsProvider)
+      await invokeProcedure(router, 'get', makeCtx('admin'), {
+        namespace: 'events',
+        collection: 'detections',
+        key: 'k1',
+      })
+      expect(capturedNamespace).toBe('events')
+    })
+  })
+
+  // ── Auth enforcement ───────────────────────────────────────────────
+
+  describe('auth', () => {
+    it('rejects anonymous on all methods', async () => {
+      const router = createCapRouter_settingsStore(() => provider)
+      for (const method of ['get', 'set', 'query', 'insert', 'update', 'delete', 'count', 'isEmpty']) {
+        const result = await invokeProcedure(router, method, makeCtx('anonymous'), { collection: 'c', key: 'k' })
+        expect(result.ok).toBe(false)
+        if (!result.ok) expect(result.code).toBe('UNAUTHORIZED')
+      }
+    })
+
+    it('allows viewer on query methods (protected)', async () => {
+      const router = createCapRouter_settingsStore(() => provider)
+      for (const method of ['get', 'query', 'count', 'isEmpty']) {
+        const result = await invokeProcedure(router, method, makeCtx('user'), { collection: 'c', key: 'k' })
+        expect(result.ok).toBe(true)
+      }
+    })
+  })
+
+  // ── Missing provider ──────────────────────────────────────────────
+
+  describe('missing provider', () => {
+    it('throws PRECONDITION_FAILED when provider is null', async () => {
+      const router = createCapRouter_settingsStore(() => null)
+      const result = await invokeProcedure(router, 'get', makeCtx('admin'), { collection: 'c', key: 'k' })
+      expect(result.ok).toBe(false)
+      if (!result.ok) {
+        expect(result.code).toBe('PRECONDITION_FAILED')
+        expect(result.message).toContain('settings-store')
+      }
+    })
+  })
+})