@camstack/server 0.2.2 → 1.0.1

package/src/__tests__/streaming-scale.test.ts

@@ -1,314 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument -- test file, mock typing */
-/**
- * Scale test — how many sub-streams can we decode for motion analysis?
- * Run: FRIGATE_HOST=192.168.1.128 npx vitest run server/backend/src/__tests__/streaming-scale.test.ts --reporter verbose
- */
-import { describe, it, expect, afterAll } from 'vitest'
-import http from 'node:http'
-import { StreamBrokerManager, FfmpegDecoderProvider } from '@camstack/addon-pipeline/stream-broker'
-import type { FrameHandle, IStreamBroker } from '@camstack/types'
-import type { IScopedLogger } from '@camstack/types'
-
-const FRIGATE = process.env.FRIGATE_HOST ?? ''
-
-const mockLogger: IScopedLogger = {
-  debug: () => {},
-  info: () => {},
-  warn: console.warn,
-  error: console.error,
-  child: () => mockLogger,
-}
-const mockLoggingService = { createLogger: () => mockLogger }
-
-function wait(ms: number) {
-  return new Promise((r) => setTimeout(r, ms))
-}
-
-/**
- * Poll-based replacement for the removed `IStreamBroker.onDecodedFrame`
- * callback (Phase 5 / D9 — decoded frames now travel as shm `FrameHandle`s).
- * Opens a frame-handle subscription, drains `pullFrameHandles` on a 50ms
- * timer, and invokes `onHandle` once per decoded frame. The returned
- * function tears the subscription down. `byteLength` stands in for the old
- * `DecodedFrame.data.length`.
- */
-async function subscribeDecodedFrames(
-  broker: IStreamBroker,
-  maxFps: number,
-  onHandle: (handle: FrameHandle) => void,
-): Promise<() => Promise<void>> {
-  const { subscriptionId } = await broker.subscribeFrameHandles({ format: 'rgb', maxFps })
-  const iv = setInterval(() => {
-    for (const handle of broker.pullFrameHandles(subscriptionId, 8)) {
-      onHandle(handle)
-    }
-  }, 50)
-  return async () => {
-    clearInterval(iv)
-    await broker.unsubscribeFrameHandles(subscriptionId)
-  }
-}
-
-/** Fetch detect sub-stream URLs from Frigate config */
-async function discoverSubStreams(): Promise<Array<{ name: string; url: string }>> {
-  return new Promise((resolve, reject) => {
-    const req = http.get(`http://${FRIGATE}:5000/api/config`, (res) => {
-      let data = ''
-      res.on('data', (chunk: Buffer) => {
-        data += chunk
-      })
-      res.on('end', () => {
-        try {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment --
-          const config = JSON.parse(data)
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access --
-          const cameras = config.cameras || {}
-          const streams: Array<{ name: string; url: string }> = []
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any --
-          for (const [name, cam] of Object.entries(cameras) as [string, any][]) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access --
-            if (!cam.enabled && cam.enabled !== undefined) continue
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access --
-            const inputs = cam?.ffmpeg?.inputs || []
-            for (const inp of inputs) {
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-              if (inp.roles?.includes('detect') && inp.path) {
-                let streamName: string
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-                if (inp.path.includes('8554/')) {
-                  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-                  streamName = inp.path.split('8554/').pop()!
-                } else {
-                  streamName = `${name}_sub`
-                }
-                streams.push({ name, url: `rtsp://${FRIGATE}:8554/${streamName}` })
-              }
-            }
-          }
-          resolve(streams)
-        } catch (e) {
-          reject(e)
-        }
-      })
-    })
-    req.on('error', reject)
-    req.setTimeout(5000, () => {
-      req.destroy()
-      reject(new Error('Timeout'))
-    })
-  })
-}
-
-describe.skipIf(!FRIGATE)('Streaming Scale Test (requires Frigate)', () => {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call -- @camstack/addon-stream-broker types resolve as any in this test context
-  const manager = new StreamBrokerManager([new FfmpegDecoderProvider()], mockLogger)
-
-  afterAll(async () => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-    await manager.destroyAll()
-    // Wait for ffmpeg processes to exit
-    await wait(2000)
-  })
-
-  it('progressive scale: 5 → 10 → 20 → 30 sub-streams @ 2fps for motion', async () => {
-    // Discover real streams, then duplicate to simulate more cameras
-    const realStreams = await discoverSubStreams()
-
-    // Test which streams actually respond (filter out 404s)
-    const workingStreams: typeof realStreams = []
-    for (const s of realStreams.slice(0, 5)) {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-        const broker = await manager.createBroker(`probe-${s.name}`, {
-          type: 'rtsp',
-          url: s.url,
-          videoCodec: 'h264',
-        })
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-        await (broker as any).start({ type: 'rtsp', url: s.url, videoCodec: 'h264' })
-        const ok = await new Promise<boolean>((resolve) => {
-          const timeout = setTimeout(() => resolve(false), 5000)
-          let unsub: (() => Promise<void>) | undefined
-          subscribeDecodedFrames(broker, 2, () => {
-            clearTimeout(timeout)
-            void unsub?.()
-            resolve(true)
-          })
-            .then((fn) => {
-              unsub = fn
-            })
-            .catch(() => resolve(false))
-        })
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-        await broker.stop()
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-        await manager.destroyBroker(`probe-${s.name}`)
-        if (ok) workingStreams.push(s)
-      } catch {
-        /* skip */
-      }
-    }
-
-    console.log(
-      `\nDiscovered ${realStreams.length} sub-streams, ${workingStreams.length} responding`,
-    )
-    if (workingStreams.length === 0) {
-      console.log('  No working sub-streams, skipping')
-      return
-    }
-
-    // Generate virtual streams by duplicating working ones (same RTSP URL, different broker ID)
-    function generateStreams(count: number) {
-      const streams: Array<{ name: string; url: string }> = []
-      for (let i = 0; i < count; i++) {
-        const real = workingStreams[i % workingStreams.length]!
-        streams.push({ name: `cam-${String(i).padStart(2, '0')}-${real.name}`, url: real.url })
-      }
-      return streams
-    }
-
-    const scaleLevels = [5, 10, 20, 30]
-
-    for (const targetCount of scaleLevels) {
-      console.log(`\n=== Scale: ${targetCount} sub-streams @ 2fps ===`)
-
-      const memBefore = process.memoryUsage()
-      const cpuBefore = process.cpuUsage()
-      const brokerIds: string[] = []
-      const unsubs: Array<() => Promise<void>> = []
-      const perCamera: Record<string, { frames: number; totalBytes: number }> = {}
-      let connectFailures = 0
-
-      // Start N brokers IN PARALLEL (using duplicated working streams)
-      const streams = generateStreams(targetCount)
-      const startTime = Date.now()
-
-      // Launch all brokers concurrently — don't wait for keyframe sequentially
-      const connectPromises = streams.map(async (s) => {
-        const brokerId = `scale-${s.name}`
-        brokerIds.push(brokerId)
-        perCamera[s.name] = { frames: 0, totalBytes: 0 }
-
-        try {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-          const broker = await manager.createBroker(brokerId, {
-            type: 'rtsp',
-            url: s.url,
-            videoCodec: 'h264',
-          })
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-          await (broker as any).start({ type: 'rtsp', url: s.url, videoCodec: 'h264' })
-
-          // Wait for first frame with tight timeout
-          await new Promise<void>((resolve) => {
-            const timeout = setTimeout(() => {
-              connectFailures++
-              resolve()
-            }, 10000)
-            let unsub: (() => Promise<void>) | undefined
-            subscribeDecodedFrames(broker, 2, () => {
-              clearTimeout(timeout)
-              void unsub?.()
-              resolve()
-            })
-              .then((fn) => {
-                unsub = fn
-              })
-              .catch(() => resolve())
-          })
-
-          // Subscribe for motion analysis
-          const unsub = await subscribeDecodedFrames(broker, 2, (handle: FrameHandle) => {
-            perCamera[s.name]!.frames++
-            perCamera[s.name]!.totalBytes += handle.byteLength
-          })
-          unsubs.push(unsub)
-        } catch (err) {
-          connectFailures++
-        }
-      })
-
-      await Promise.all(connectPromises)
-
-      const connectTime = Date.now() - startTime
-      console.log(
-        `  Connected ${targetCount - connectFailures}/${targetCount} in ${(connectTime / 1000).toFixed(1)}s`,
-      )
-
-      // Run for 5 seconds of actual streaming
-      const measureStart = Date.now()
-      const cpuMeasureStart = process.cpuUsage()
-      await wait(5000)
-      const cpuMeasure = process.cpuUsage(cpuMeasureStart)
-      const measureDuration = (Date.now() - measureStart) / 1000
-
-      // Unsubscribe
-      for (const unsub of unsubs) await unsub()
-
-      // Calculate metrics
-      const cpuAfter = process.cpuUsage(cpuBefore)
-      const memAfter = process.memoryUsage()
-
-      let totalFrames = 0
-      let totalBytes = 0
-      let activeCameras = 0
-      let starvingCameras = 0
-
-      for (const [name, data] of Object.entries(perCamera)) {
-        totalFrames += data.frames
-        totalBytes += data.totalBytes
-        if (data.frames > 0) activeCameras++
-        if (data.frames < 3) starvingCameras++ // less than 3 frames in 5s = starving
-      }
-
-      const cpuPct = (
-        ((cpuMeasure.user + cpuMeasure.system) / (measureDuration * 1_000_000)) *
-        100
-      ).toFixed(1)
-      const rssMB = (memAfter.rss / 1024 / 1024).toFixed(0)
-      const heapMB = (memAfter.heapUsed / 1024 / 1024).toFixed(0)
-      const combinedFps = (totalFrames / measureDuration).toFixed(1)
-      const avgFrameKB = totalFrames > 0 ? (totalBytes / totalFrames / 1024).toFixed(0) : '0'
-      const bwMBs = (totalBytes / 1024 / 1024 / measureDuration).toFixed(1)
-
-      console.log(`  Active: ${activeCameras}/${targetCount} cameras producing frames`)
-      console.log(`  Starving: ${starvingCameras} cameras (<3 frames in 5s)`)
-      console.log(`  Total frames: ${totalFrames} (${combinedFps} fps combined)`)
-      console.log(`  Avg frame: ${avgFrameKB} KB`)
-      console.log(`  Decode BW: ${bwMBs} MB/s`)
-      console.log(`  CPU: ${cpuPct}%`)
-      console.log(`  RSS: ${rssMB} MB | Heap: ${heapMB} MB`)
-
-      // Per-camera breakdown
-      console.log(`  ---`)
-      const sorted = Object.entries(perCamera).toSorted((a, b) => b[1].frames - a[1].frames)
-      for (const [name, data] of sorted) {
-        const fps = (data.frames / measureDuration).toFixed(1)
-        const avgKB = data.frames > 0 ? (data.totalBytes / data.frames / 1024).toFixed(0) : '-'
-        const status = data.frames >= 3 ? '✓' : data.frames > 0 ? '⚠' : '✗'
-        console.log(
-          `  ${status} ${name.padEnd(35)} ${fps.padStart(4)} fps  ${avgKB.padStart(5)} KB/f  (${data.frames} frames)`,
-        )
-      }
-
-      // Cleanup for next scale level
-      for (const id of brokerIds) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-        const b = manager.getBroker(id)
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-        if (b) await b.stop()
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access --
-        await manager.destroyBroker(id)
-      }
-      brokerIds.length = 0
-      unsubs.length = 0
-      Object.keys(perCamera).forEach((k) => delete perCamera[k])
-
-      // Expect at least 80% of cameras producing
-      expect(activeCameras).toBeGreaterThanOrEqual(Math.floor(targetCount * 0.8))
-
-      // Pause between levels for cleanup
-      await wait(2000)
-    }
-  }, 300000) // 5 min timeout for the full progressive test
-})

package/src/__tests__/uds-addon-call-wiring.spec.ts

@@ -1,242 +0,0 @@
-/**
- * F3 backend wiring — forked-addon routes + custom actions over UDS.
- *
- * Verifies the production wiring `AddonRegistryService` builds, end-to-end over
- * a REAL LocalChildRegistry + LocalChildClient pair, with the child running the
- * REAL addon-runner-side dispatcher (`createChildAddonCallDispatch`):
- *
- *   - Custom actions: a `CustomActionRegistry` whose dispatcher is the F3
- *     `callAddonOnChild({target:'custom', action, args})` reaches the child's
- *     real custom-action handler and returns its result (the path
- *     `registerForkedAddonCustomActions` builds via `dispatchForkedCustomAction`).
- *   - Routes: `callAddonOnChild({target:'routes'})` returns handler-stripped
- *     descriptors; the per-route bridge handler dispatches through the
- *     `addon-routes` `invoke()` cap method (the path `mountForkedAddonRoutes`
- *     builds), and the captured envelope round-trips.
- *
- * The child-side `onAddonCall` handler is a faithful inline of the addon-runner
- * dispatcher (resolve route provider / custom registry; strip route handlers).
- */
-
-import { describe, it, expect, afterEach } from 'vitest'
-import { z } from 'zod'
-import {
-  LocalChildRegistry,
-  LocalChildClient,
-  CustomActionRegistry,
-  createLocalTransport,
-} from '@camstack/kernel'
-import type { AddonCallInput } from '@camstack/kernel'
-import { buildAddonRouteProvider, customAction, defineCustomActions } from '@camstack/types'
-import type { IAddonHttpRoute, CustomActionsSpec } from '@camstack/types'
-
-const nid = (): string => `f3-wiring-${process.pid}-${Math.random().toString(36).slice(2)}`
-
-describe('F3 — forked-addon routes + custom actions over UDS (backend wiring)', () => {
-  let registry: LocalChildRegistry | null = null
-  const clients: LocalChildClient[] = []
-
-  afterEach(async () => {
-    for (const c of clients) await c.close().catch(() => {})
-    clients.length = 0
-    await registry?.close().catch(() => {})
-    registry = null
-  })
-
-  /** Stand up a hub-side registry + a child running the real addon-call dispatcher. */
-  async function standUp(opts: {
-    addonId: string
-    routes?: readonly IAddonHttpRoute[]
-    catalog?: CustomActionsSpec
-    handlers?: Record<string, (input: unknown) => Promise<unknown>>
-  }): Promise<{ childCustomActions: CustomActionRegistry }> {
-    const nodeId = nid()
-    registry = new LocalChildRegistry(createLocalTransport().createServer(nodeId))
-    await registry.start()
-
-    // The runner-side custom-action registry — populated as the addon-runner does.
-    const childCustomActions = new CustomActionRegistry()
-    if (opts.catalog && opts.handlers) {
-      const handlers = opts.handlers
-      childCustomActions.registerAddon(opts.addonId, opts.catalog, (action, input) => {
-        const fn = handlers[action]
-        if (!fn) throw new Error(`no handler for ${action}`)
-        return fn(input)
-      })
-    }
-
-    const routeProvider = opts.routes ? buildAddonRouteProvider(opts.addonId, opts.routes) : null
-
-    const child = new LocalChildClient({
-      nodeId,
-      childId: opts.addonId,
-      caps: [{ capName: 'addon-routes', mode: 'collection' }],
-      // Cap dispatch — resolve the `addon-routes` cap's `invoke`/`getRoutes`
-      // method on the live route provider (mirrors the runner's
-      // createChildCapDispatch resolving allSingletonProviders['addon-routes']).
-      dispatch: async (call) => {
-        if (call.capName === 'addon-routes' && routeProvider !== null) {
-          const fn = Reflect.get(routeProvider, call.method)
-          if (typeof fn === 'function') return fn.call(routeProvider, call.args)
-        }
-        return null
-      },
-    })
-    // Inline addon-runner dispatcher: routes → handler-stripped descriptors,
-    // custom → the child custom-action registry. Mirrors
-    // `createChildAddonCallDispatch` in the kernel.
-    child.onAddonCall(async (call: AddonCallInput) => {
-      if (call.target === 'routes') {
-        if (routeProvider === null) throw new Error(`addon "${call.addonId}" has no routes`)
-        const live = routeProvider.getRoutes()
-        return live.map((r) => ({
-          method: r.method,
-          path: r.path,
-          ...(r.access !== undefined ? { access: r.access } : {}),
-          ...(r.description !== undefined ? { description: r.description } : {}),
-        }))
-      }
-      const action = call.action
-      if (typeof action !== 'string') throw new Error('missing action')
-      const entry = childCustomActions.resolve(call.addonId, action)
-      if (entry === null) throw new Error(`no custom action "${action}"`)
-      return entry.handler(call.args)
-    })
-    clients.push(child)
-    await child.start()
-
-    return { childCustomActions }
-  }
-
-  it('custom action: the registerForkedAddonCustomActions dispatch path reaches the child handler', async () => {
-    const catalog = defineCustomActions({
-      runBenchmark: customAction(
-        z.object({ iterations: z.number() }),
-        z.object({ ran: z.number() }),
-        { kind: 'mutation' },
-      ),
-    })
-    await standUp({
-      addonId: 'benchmark',
-      catalog,
-      handlers: {
-        runBenchmark: async (input) => {
-          const args = input as { iterations: number }
-          return { ran: args.iterations }
-        },
-      },
-    })
-
-    // Hub-side registry — the dispatcher mirrors `dispatchForkedCustomAction`.
-    const hubRegistry = new CustomActionRegistry()
-    hubRegistry.registerAddon('benchmark', catalog, (action, input) =>
-      registry!.callAddonOnChild('benchmark', {
-        addonId: 'benchmark',
-        target: 'custom',
-        action,
-        args: input,
-      }),
-    )
-
-    const entry = hubRegistry.resolve('benchmark', 'runBenchmark')
-    expect(entry).not.toBeNull()
-    const result = await entry!.handler({ iterations: 9 })
-    expect(result).toEqual({ ran: 9 })
-  })
-
-  it('routes: callAddonOnChild(routes) returns stripped descriptors and invoke() round-trips', async () => {
-    const routes: IAddonHttpRoute[] = [
-      {
-        method: 'GET',
-        path: '/hello/:name',
-        access: 'public',
-        handler: async (req, reply) => {
-          reply.code(200)
-          reply.send({ greeting: `hi ${req.params.name}` })
-        },
-      },
-    ]
-    await standUp({ addonId: 'export-alexa', routes })
-
-    // (a) routes come back handler-stripped (the `mountForkedAddonRoutes` fetch).
-    const rawRoutes = await registry!.callAddonOnChild('export-alexa', {
-      addonId: 'export-alexa',
-      target: 'routes',
-    })
-    expect(rawRoutes).toEqual([{ method: 'GET', path: '/hello/:name', access: 'public' }])
-
-    // (b) dispatch through the addon-routes cap proxy's `invoke` cap method —
-    // the bridge handler `mountForkedAddonRoutes` synthesizes calls this.
-    const routesCapProxy = {
-      invoke: (input: unknown) =>
-        registry!.callCapOnChild('export-alexa', {
-          capName: 'addon-routes',
-          method: 'invoke',
-          args: input,
-        }),
-    }
-    const envelope = await routesCapProxy.invoke({
-      method: 'GET',
-      path: '/hello/world',
-      params: { name: 'world' },
-      query: {},
-      body: undefined,
-      headers: {},
-    })
-    expect(envelope).toMatchObject({ status: 200, body: { greeting: 'hi world' } })
-  })
-
-  it('auth-oidc shape: a forked addon with a SYNC array getRoutes + async handlers mounts via the strip path without serializing a function', async () => {
-    // Reproduces the regression: `auth-oidc` declares a manual route provider
-    // `{ id, getRoutes: () => routes }` (NO `buildAddonRouteProvider`, NO
-    // `invoke`). It forks like every non-core addon, so the hub resolves an
-    // async UDS cap proxy whose `getRoutes()` returns a Promise. The mount path
-    // MUST NOT register that proxy directly (→ `getRoutes(...).map is not a
-    // function`) nor dispatch its `getRoutes` cap method over UDS (the child's
-    // `getRoutes()` returns the live array WITH async `handler` functions →
-    // MsgPack "Unrecognized object: [object AsyncFunction]"). It uses the
-    // handler-stripped `callAddonOnChild(target:'routes')` bridge instead.
-    const routes: IAddonHttpRoute[] = [
-      {
-        method: 'GET',
-        path: '/:providerId/start',
-        access: 'public',
-        description: 'Begin OIDC redirect login flow',
-        handler: async (req, reply) => {
-          reply.code(302)
-          reply.send('')
-        },
-      },
-      {
-        method: 'GET',
-        path: '/:providerId/callback',
-        access: 'public',
-        handler: async (req, reply) => {
-          reply.code(200)
-          reply.send('ok')
-        },
-      },
-    ]
-    await standUp({ addonId: 'auth-oidc', routes })
-
-    // The handler-stripped descriptors cross the real UDS pair. If the strip
-    // path leaked a `handler` function, MsgPack `encodeFrame` would throw
-    // "Unrecognized object: [object AsyncFunction]" before this resolves.
-    const rawRoutes = await registry!.callAddonOnChild('auth-oidc', {
-      addonId: 'auth-oidc',
-      target: 'routes',
-    })
-    expect(rawRoutes).toEqual([
-      {
-        method: 'GET',
-        path: '/:providerId/start',
-        access: 'public',
-        description: 'Begin OIDC redirect login flow',
-      },
-      { method: 'GET', path: '/:providerId/callback', access: 'public' },
-    ])
-    // Coarse reachability gate the route-mount fallback uses: the child is
-    // connected even though we only checked the addon-call surface.
-    expect(registry!.isChildKnown('auth-oidc')).toBe(true)
-  })
-})