@camstack/server 0.2.2 → 1.0.1

package/src/api/trpc/trpc.router.ts

@@ -1,389 +0,0 @@
-import { trpcRouter } from './trpc.middleware'
-// All capability tRPC routers are auto-mounted via `mountAllCaps()` below.
-// Only the OVERRIDES (service-backed providers, custom collection
-// dispatch logic, hub-only remote-proxy caps) and the CORE (non-cap)
-// routers are wired manually in this file. Tracking comment for the
-// historical migration index (every `create<X>Router` that used to live
-// here has been replaced by its codegen'd cap-router counterpart):
-//   auth → auth (kept manual for AuthService DI), users/system →
-//   `userMgmt`/`system` caps, settings → `system-config` builtin,
-//   devices → `deviceManager` cap, integrations → `integrations` cap,
-//   streaming → `streamingManagement` cap, events → `eventQuery` cap,
-//   logs → kept manual, live → kept manual, processes → `processMgmt`
-//   cap, agents → `nodes` cap, sessions → `session` cap, trackMedia /
-//   trackTrail → caps, network →
-//   `networkQuality` cap, addons → `addons` cap, bridgePipeline removed
-//   (legacy), detection → `detectionConfig` cap, capabilities → kept
-//   manual, update → addons cap, addonPages → cap, notification →
-//   `notifications` (kept manual for NotificationService DI),
-//   scopedToken → `userManagement`, toast → `toast` cap, inference →
-//   `pipelineExecutor` cap, pipeline → `pipelineConfig` cap,
-//   systemEvents → kept manual.
-import type { CapabilityRegistry } from '@camstack/kernel'
-import type { InferProvider, BrokerConsumerAttribution } from '@camstack/types'
-import {
-  pipelineExecutorCapability,
-  pipelineRunnerCapability,
-  pipelineOrchestratorCapability,
-  audioAnalyzerCapability,
-  audioCodecCapability,
-  platformProbeCapability,
-  decoderCapability,
-  localNetworkCapability,
-  webrtcSessionCapability,
-} from '@camstack/types'
-import {
-  // The auto-mount covers ~75 caps. The handful re-imported below back
-  // the manual overrides that need service-backed providers or custom
-  // collection dispatch logic; the auto-mount entry is replaced by the
-  // override line via spread precedence.
-  createCapRouter_pipelineExecutor,
-  createCapRouter_pipelineRunner,
-  createCapRouter_pipelineOrchestrator,
-  createCapRouter_audioAnalyzer,
-  createCapRouter_audioCodec,
-  createCapRouter_decoder,
-  createCapRouter_platformProbe,
-  createCapRouter_localNetwork,
-  createCapRouter_snapshotProvider,
-  createCapRouter_networkQuality,
-  createCapRouter_system,
-  createCapRouter_toast,
-  createCapRouter_integrations,
-  createCapRouter_nodes,
-  createCapRouter_addons,
-  createCapRouter_webrtcSession,
-} from './generated-cap-routers'
-import { mountAllCaps } from './generated-cap-mounts.js'
-import {
-  buildSystemProvider,
-  buildNetworkQualityProvider,
-  buildToastProvider,
-  buildNodesProvider,
-  buildIntegrationsProvider,
-  buildAddonsProvider,
-} from '../core/cap-providers.js'
-import { createAuthRouter } from '../core/auth.router.js'
-import { createAddonSettingsRouter } from '../core/addon-settings.router.js'
-import { createSettingsBackendRouter } from '../core/settings-backend.router.js'
-import { createEventBusProxyRouter } from '../core/event-bus-proxy.router.js'
-import { createReplRouter } from '../core/repl.router.js'
-import { createNotificationsRouter } from '../core/notifications.router.js'
-import { createLogsRouter } from '../core/logs.router.js'
-import { createSystemEventsRouter } from '../core/system-events.router.js'
-import { createLiveEventsRouter } from '../core/live-events.router.js'
-import { createCapabilitiesRouter } from '../core/capabilities.router.js'
-import { createStreamProbeRouter } from '../core/stream-probe.router.js'
-import { createHwAccelRouter } from '../core/hwaccel.router.js'
-import { requireSingleton, firstSupported, anySupports } from './cap-mount-helpers.js'
-import { extractUserAgent } from './client-ip.js'
-import type { TrpcContext } from './trpc.context.js'
-import type { AuthService } from '../../core/auth/auth.service'
-import type { ConfigService } from '../../core/config/config.service'
-import type { FeatureService } from '../../core/feature/feature.service'
-import type { LoggingService } from '../../core/logging/logging.service'
-import type { EventBusService } from '../../core/events/event-bus.service'
-import type { AgentRegistryService } from '../../core/agent/agent-registry.service'
-import type { MoleculerService } from '../../core/moleculer/moleculer.service'
-import type { AddonRegistryService } from '../../core/addon/addon-registry.service'
-import type { AddonPackageService } from '../../core/addon/addon-package.service'
-import type { ReplEngineService } from '../../core/repl/repl-engine.service'
-import type { NetworkQualityService } from '../../core/network/network-quality.service'
-import type { AddonBridgeService } from '../../core/addon-bridge/addon-bridge.service'
-import type { NotificationService, ToastService } from '@camstack/core'
-import type { StreamProbeService } from '../../core/streaming/stream-probe.service'
-
-export interface RouterServices {
-  authService: AuthService
-  configService: ConfigService
-  featureService: FeatureService
-  loggingService: LoggingService
-  eventBus: EventBusService
-  agentRegistry: AgentRegistryService
-  moleculer: MoleculerService
-  addonRegistry: AddonRegistryService
-  replEngine: ReplEngineService
-  networkQualityService: NetworkQualityService
-  addonBridge: AddonBridgeService
-  addonPackageService: AddonPackageService
-  notificationService: NotificationService | null
-  toastService: ToastService | null
-  capabilityRegistry: CapabilityRegistry | null
-  streamProbe: StreamProbeService | null
-}
-
-type WebrtcSessionProvider = InferProvider<typeof webrtcSessionCapability>
-type CreateSessionInput = Parameters<WebrtcSessionProvider['createSession']>[0]
-type HandleOfferInput = Parameters<WebrtcSessionProvider['handleOffer']>[0]
-
-/**
- * Merge the server-read User-Agent into a signaling call's
- * `consumerAttribution`, building a NEW input object (immutable — never
- * mutates the caller's input). When `userAgent` is null (mesh-originated
- * call, or a client that omits the header) the input passes through
- * unchanged. Any client-supplied `userAgent` is OVERWRITTEN — the hub
- * trusts only the request context, never the client.
- */
-export function enrichInputWithUserAgent<
-  TInput extends { consumerAttribution?: BrokerConsumerAttribution },
->(input: TInput, userAgent: string | null): TInput {
-  if (userAgent === null) return input
-  const base: BrokerConsumerAttribution = input.consumerAttribution ?? { kind: 'webrtc-browser' }
-  return {
-    ...input,
-    consumerAttribution: { ...base, userAgent },
-  }
-}
-
-/**
- * Relay-only forcing for remote viewers is DISABLED (2026-05-26).
- *
- * It was meant to give CGNAT/4G viewers a clean relay↔relay path, but werift's
- * TURN media-forward is unreliable between two real TURN servers (relay↔relay
- * connects yet media never arrives → connected-but-black), and forcing relay
- * ALSO kills the direct LAN/Tailscale host pair — which carries full native
- * quality with no relay. We now offer ALL candidates (host incl. the hub's
- * advertised Tailscale address, srflx, relay) and let ICE nominate the best
- * reachable pair: direct when possible, relay only as a fallback. The
- * `relayOnly` cap field + broker support remain for when relay media-forward
- * is fixed.
- *
- * The wrapper additionally enriches the `createSession` / `handleOffer`
- * subscriber attribution with the originating client's User-Agent, read
- * from the tRPC request context (browser sessions). All OTHER methods
- * delegate straight through — auth, the remote-proxy factory and every
- * signaling behaviour are untouched.
- */
-export function wrapWebrtcSessionProviderWithRelay(
-  provider: WebrtcSessionProvider,
-  ctx: TrpcContext,
-): WebrtcSessionProvider {
-  const userAgent = extractUserAgent(ctx.req)
-  return {
-    ...provider,
-    createSession: (input: CreateSessionInput) =>
-      provider.createSession(enrichInputWithUserAgent(input, userAgent)),
-    handleOffer: (input: HandleOfferInput) =>
-      provider.handleOffer(enrichInputWithUserAgent(input, userAgent)),
-  }
-}
-
-/**
- * Build the AppRouter. Mounts every codegen'd cap router via the auto-
- * mount entrypoint and overrides the handful that need service-backed
- * providers or custom collection dispatch. Non-cap (core) routers ride
- * alongside in the same root object.
- *
- * Override-by-spread: spread `mountAllCaps(services)` first, then the
- * overrides AFTER — the later property wins. The drift guard in
- * `scripts/codegen.ts` ensures every codegen'd `createCapRouter_X` is
- * present in the auto-mount inventory (or explicitly in the legacy
- * skip-list), so the override list below NEVER needs to add a new entry
- * just to mount a new cap — only to swap in a custom provider.
- */
-function buildCapabilityRouters(services: RouterServices) {
-  return {
-    // ── Auto-mount: every codegen'd cap router with a canonical
-    //    provider shape. Everything below this line OVERRIDES the
-    //    auto-mount entry for caps with service-backed providers,
-    //    custom collection routing, or a hub-only `null` remote proxy.
-    ...mountAllCaps(services),
-
-    // ── Non-cap (core) routers — hand-written, single-impl ──────────
-    notifications: createNotificationsRouter(services.notificationService),
-    // Raw DB proxy for forked workers to read/write addon store.
-    // Workers use ctx.api.addonSettingsRaw.getGlobal.query({...}).
-    // NOT the three-level settings gateway — that's the codegen'd
-    // `addonSettings` cap router (mounted via auto-mount above).
-    addonSettingsRaw: createAddonSettingsRouter(services.configService),
-    settingsBackend: createSettingsBackendRouter(() => services.addonRegistry.getSettingsBackend()),
-    eventBusProxy: createEventBusProxyRouter(services.eventBus),
-    repl: createReplRouter(services.replEngine),
-    systemEvents: createSystemEventsRouter(services.eventBus),
-    capabilities: createCapabilitiesRouter(services.capabilityRegistry, services.configService),
-    logs: createLogsRouter(services.loggingService),
-    live: createLiveEventsRouter(services.eventBus, services.addonRegistry),
-    // stream-probe — fixed core API (ffprobe wrapper), not a cap.
-    streamProbe: createStreamProbeRouter(services.streamProbe),
-    // hwaccel — fixed core API, wraps the per-node `$hwaccel` Moleculer
-    // service. UI pipeline / NodeDetail pages query per-node to show
-    // which hardware backend each agent will use.
-    hwaccel: createHwAccelRouter(services.moleculer?.broker ?? null),
-    auth: createAuthRouter(services.authService, services.capabilityRegistry),
-
-    // ── Cap overrides: service-backed providers ─────────────────────
-    // These caps don't have an addon registering a provider in the
-    // CapabilityRegistry — the provider is built on-demand from
-    // backend services. `mountAllCaps` would return `null` for them
-    // (registry lookup miss), so we re-mount with `buildXProvider`.
-    networkQuality: createCapRouter_networkQuality((_ctx) =>
-      buildNetworkQualityProvider(services.networkQualityService),
-    ),
-    system: createCapRouter_system((_ctx) =>
-      buildSystemProvider(services.featureService, services.capabilityRegistry),
-    ),
-    toast: createCapRouter_toast((ctx) => buildToastProvider(services.toastService, ctx)),
-    integrations: createCapRouter_integrations((_ctx) =>
-      buildIntegrationsProvider(
-        services.addonRegistry,
-        services.eventBus,
-        services.loggingService,
-        services.capabilityRegistry,
-      ),
-    ),
-    nodes: createCapRouter_nodes((_ctx) =>
-      buildNodesProvider(services.agentRegistry, services.moleculer, services.addonRegistry),
-    ),
-    addons: createCapRouter_addons((ctx) =>
-      buildAddonsProvider(
-        services.addonRegistry,
-        services.addonPackageService,
-        services.loggingService,
-        services.moleculer,
-        services.configService,
-        ctx,
-        services.eventBus,
-      ),
-    ),
-
-    // ── Cap overrides: cross-node remote-proxy cast ─────────────────
-    // These caps' providers have manual interface types that pre-date
-    // `InferProvider<typeof xCap>` — structurally identical, nominally
-    // distinct. Casting at the override site is cheaper than reworking
-    // the provider declarations. Auto-mount can't infer the cast.
-    pipelineExecutor: createCapRouter_pipelineExecutor(
-      (_ctx) =>
-        requireSingleton(services.capabilityRegistry, 'pipeline-executor') as InferProvider<
-          typeof pipelineExecutorCapability
-        > | null,
-      (capName, nodeId) =>
-        services.moleculer.createCapabilityProxy(capName, nodeId) as InferProvider<
-          typeof pipelineExecutorCapability
-        > | null,
-    ),
-    pipelineRunner: createCapRouter_pipelineRunner(
-      (_ctx) =>
-        requireSingleton(services.capabilityRegistry, 'pipeline-runner') as InferProvider<
-          typeof pipelineRunnerCapability
-        > | null,
-      (capName, nodeId) =>
-        services.moleculer.createCapabilityProxy(capName, nodeId) as InferProvider<
-          typeof pipelineRunnerCapability
-        > | null,
-    ),
-    pipelineOrchestrator: createCapRouter_pipelineOrchestrator(
-      (_ctx) =>
-        requireSingleton(services.capabilityRegistry, 'pipeline-orchestrator') as InferProvider<
-          typeof pipelineOrchestratorCapability
-        > | null,
-      (capName, nodeId) =>
-        services.moleculer.createCapabilityProxy(capName, nodeId) as InferProvider<
-          typeof pipelineOrchestratorCapability
-        > | null,
-    ),
-    audioAnalyzer: createCapRouter_audioAnalyzer(
-      (_ctx) => requireSingleton(services.capabilityRegistry, 'audio-analyzer'),
-      (capName, nodeId) =>
-        services.moleculer.createCapabilityProxy(capName, nodeId) as InferProvider<
-          typeof audioAnalyzerCapability
-        > | null,
-    ),
-    audioCodec: createCapRouter_audioCodec(
-      (_ctx) =>
-        requireSingleton(services.capabilityRegistry, 'audio-codec') as InferProvider<
-          typeof audioCodecCapability
-        > | null,
-      (capName, nodeId) =>
-        services.moleculer.createCapabilityProxy(capName, nodeId) as InferProvider<
-          typeof audioCodecCapability
-        > | null,
-    ),
-    decoder: createCapRouter_decoder(
-      (_ctx) =>
-        requireSingleton(services.capabilityRegistry, 'decoder') as InferProvider<
-          typeof decoderCapability
-        > | null,
-      (capName, nodeId) =>
-        services.moleculer.createCapabilityProxy(capName, nodeId) as InferProvider<
-          typeof decoderCapability
-        > | null,
-    ),
-    platformProbe: createCapRouter_platformProbe(
-      (_ctx) => requireSingleton(services.capabilityRegistry, 'platform-probe'),
-      (capName, nodeId) =>
-        services.moleculer.createCapabilityProxy(capName, nodeId) as InferProvider<
-          typeof platformProbeCapability
-        > | null,
-    ),
-
-    // ── Cap overrides: hub-only, no remote fallback ─────────────────
-    // The cap is intentionally single-node; agents are not directly
-    // addressable. Auto-mount would still set up a proxy factory; we
-    // explicitly return `null` to short-circuit any cross-node attempt.
-    localNetwork: createCapRouter_localNetwork(
-      (_ctx) => requireSingleton(services.capabilityRegistry, 'local-network'),
-      (_capName, _nodeId) => null as InferProvider<typeof localNetworkCapability> | null,
-    ),
-
-    // ── Cap overrides: collection dispatch (contribution / probe) ──
-    // `turn-provider.getTurnServers` is now handled generically by the
-    // auto-mount: it's an array-output method on a `collection` cap, so
-    // `mountAllCaps` fans it across every enabled provider via
-    // `concatCollection` when no `addonId` is supplied. No hand-written
-    // override needed.
-    //
-    // `snapshot-provider.supportsDevice` is an OR across providers;
-    // `getSnapshot` picks the first one that claims the device. The
-    // generic first-provider resolver from the auto-mount can't model
-    // this — we hand-write the probe + fan-out logic.
-    snapshotProvider: createCapRouter_snapshotProvider((_ctx) => {
-      const reg = services.capabilityRegistry
-      if (!reg) return null
-      type SnapshotProviderInferred =
-        import('@camstack/types').CapabilityProviderMap['snapshot-provider']
-      const providers = reg.getCollection<SnapshotProviderInferred>('snapshot-provider')
-      if (!providers || providers.length === 0) return null
-      const supportsDevice = anySupports(providers, 'supportsDevice')
-      const getSnapshot = firstSupported(providers, 'supportsDevice', 'getSnapshot')
-      return { supportsDevice, getSnapshot }
-    }),
-
-    // ── Cap override: server-detected remote → relay-only ────────────
-    // The broker (a forked addon) can't see the HTTP request, so it
-    // can't tell a LAN viewer from a remote one. We override only the
-    // `getProvider` accessor to return a per-request provider whose
-    // `createSession` carries a server-computed `relayOnly` flag derived
-    // from the client IP in `ctx.req`. Remote (CGNAT/4G) viewers force
-    // TURN-relay-only ICE; LAN viewers keep the direct host/srflx path.
-    // All other methods delegate straight through, and the cross-node
-    // remote-proxy routing is preserved (forked/agent-hosted brokers).
-    webrtcSession: createCapRouter_webrtcSession(
-      (ctx) => {
-        const provider =
-          services.capabilityRegistry?.getSingleton<WebrtcSessionProvider>('webrtc-session') ?? null
-        return provider ? wrapWebrtcSessionProviderWithRelay(provider, ctx) : null
-      },
-      (capName, nodeId) =>
-        services.moleculer.createCapabilityProxy(capName, nodeId) as WebrtcSessionProvider | null,
-    ),
-
-    // NOT MOUNTED — legacy provider shapes (positional args / sync
-    // returns) that don't match the codegen routers' {input}-object +
-    // Promise<T> contract. Tracked by `LEGACY_SHAPE_SKIP` in
-    // `generated-cap-mounts.ts` until the provider refactor (task #195):
-    //   - addon-routes        (IAddonRouteProvider: getRoutes sync)
-    //   - auth-provider       (IAuthProvider: positional credentials)
-    //   - log-destination     (ILogDestination: positional + extra lifecycle)
-    //   - restreamer          (IRestreamer: registerDevice positional)
-    //   - streaming-engine    (IStreamingEngine: registerStream positional)
-    //   - webrtc              (IWebRtcProvider: missing hasAdaptiveBitrate)
-  }
-}
-
-export function buildAppRouter(services: RouterServices) {
-  return trpcRouter({
-    ...buildCapabilityRouters(services),
-  })
-}
-
-export type AppRouter = ReturnType<typeof buildAppRouter>

package/src/auth/session-cookie.ts

@@ -1,54 +0,0 @@
-/** Browser session cookie carrying the hub JWT. Set by POST /api/auth/session
- *  after a tRPC login; read by the addon-route catch-all for `authenticated`
- *  routes hit by a plain browser navigation. */
-export const SESSION_COOKIE = 'camstack_session'
-
-interface CookieSpec {
-  readonly name: string
-  readonly value: string
-  readonly options: {
-    httpOnly: boolean
-    sameSite: 'lax'
-    secure: boolean
-    path: string
-    maxAge: number
-  }
-}
-
-export function buildSessionCookie(token: string, ttlSec: number): CookieSpec {
-  return {
-    name: SESSION_COOKIE,
-    value: token,
-    options: { httpOnly: true, sameSite: 'lax', secure: true, path: '/', maxAge: ttlSec },
-  }
-}
-
-export function clearSessionCookie(): CookieSpec {
-  return {
-    name: SESSION_COOKIE,
-    value: '',
-    options: { httpOnly: true, sameSite: 'lax', secure: true, path: '/', maxAge: 0 },
-  }
-}
-
-/** A browser navigation we can bounce to the login page: a top-level GET
- *  that wants HTML. Anything else (API call, POST, non-HTML) keeps the
- *  401 behavior so programmatic clients get a clean error. */
-export function shouldRedirectToLogin(method: string, accept: string | undefined): boolean {
-  return method === 'GET' && typeof accept === 'string' && accept.includes('text/html')
-}
-
-/** Build the `/login?next=…` URL for an unauthenticated browser request. */
-export function loginRedirectUrl(originalUrl: string): string {
-  return `/login?next=${encodeURIComponent(originalUrl)}`
-}
-
-/** Allowed redirect target for `GET /api/embed-auth`: a same-origin RELATIVE
- *  path to a stream-broker embed page. Defeats open-redirects — the endpoint
- *  sets the session cookie from a Bearer token, so the `next` must be safe to
- *  bounce to. Rejects absolute/protocol-relative URLs, backslashes, and `..`. */
-export function isEmbedRedirectTarget(next: string): boolean {
-  if (!next.startsWith('/addon/stream-broker/embed/')) return false
-  if (next.includes('\\') || next.includes('://') || next.includes('..')) return false
-  return true
-}

package/src/boot/__tests__/integration-id-backfill.spec.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  planIntegrationIdBackfill,
-  planDeleteTimeStamps,
-  runIntegrationIdBackfill,
-} from '../integration-id-backfill'
-
-describe('planDeleteTimeStamps', () => {
-  it("claims an untagged top-level device of the deleted integration's single-integration addon", () => {
-    const stamps = planDeleteTimeStamps(
-      'int_rtsp',
-      [{ id: 'int_rtsp', addonId: 'provider-rtsp' }],
-      [
-        { id: 4, addonId: 'provider-rtsp', parentDeviceId: null },
-        { id: 6, addonId: 'provider-rtsp', parentDeviceId: null },
-      ],
-    )
-    expect(stamps).toEqual([
-      { deviceId: 4, integrationId: 'int_rtsp' },
-      { deviceId: 6, integrationId: 'int_rtsp' },
-    ])
-  })
-
-  it('returns no stamps for a multi-integration addon (ambiguous — never auto-claim)', () => {
-    const stamps = planDeleteTimeStamps(
-      'int_a',
-      [
-        { id: 'int_a', addonId: 'provider-ha' },
-        { id: 'int_b', addonId: 'provider-ha' },
-      ],
-      [{ id: 11, addonId: 'provider-ha', parentDeviceId: null }],
-    )
-    expect(stamps).toEqual([])
-  })
-
-  it('only returns stamps for the integration being deleted, not siblings of other addons', () => {
-    const stamps = planDeleteTimeStamps(
-      'int_rtsp',
-      [
-        { id: 'int_rtsp', addonId: 'provider-rtsp' },
-        { id: 'int_onvif', addonId: 'provider-onvif' },
-      ],
-      [
-        { id: 4, addonId: 'provider-rtsp', parentDeviceId: null },
-        { id: 5, addonId: 'provider-onvif', parentDeviceId: null },
-      ],
-    )
-    expect(stamps).toEqual([{ deviceId: 4, integrationId: 'int_rtsp' }])
-  })
-
-  it('skips devices already tagged with the deleted integration', () => {
-    const stamps = planDeleteTimeStamps(
-      'int_rtsp',
-      [{ id: 'int_rtsp', addonId: 'provider-rtsp' }],
-      [{ id: 4, addonId: 'provider-rtsp', parentDeviceId: null, integrationId: 'int_rtsp' }],
-    )
-    expect(stamps).toEqual([])
-  })
-})
-
-describe('planIntegrationIdBackfill', () => {
-  it('stamps a top-level untagged device whose addon has exactly one integration', () => {
-    const stamps = planIntegrationIdBackfill(
-      [{ id: 'int_1', addonId: 'provider-rtsp' }],
-      [{ id: 10, addonId: 'provider-rtsp', parentDeviceId: null }],
-    )
-    expect(stamps).toEqual([{ deviceId: 10, integrationId: 'int_1' }])
-  })
-
-  it('skips devices whose addon hosts multiple integrations (ambiguous)', () => {
-    const stamps = planIntegrationIdBackfill(
-      [
-        { id: 'int_a', addonId: 'provider-ha' },
-        { id: 'int_b', addonId: 'provider-ha' },
-      ],
-      [{ id: 11, addonId: 'provider-ha', parentDeviceId: null }],
-    )
-    expect(stamps).toEqual([])
-  })
-
-  it('skips already-tagged devices and child devices', () => {
-    const stamps = planIntegrationIdBackfill(
-      [{ id: 'int_1', addonId: 'provider-rtsp' }],
-      [
-        { id: 12, addonId: 'provider-rtsp', parentDeviceId: null, integrationId: 'int_1' },
-        { id: 13, addonId: 'provider-rtsp', parentDeviceId: 12 },
-      ],
-    )
-    expect(stamps).toEqual([])
-  })
-
-  it('skips devices whose addon has no integration', () => {
-    const stamps = planIntegrationIdBackfill(
-      [{ id: 'int_1', addonId: 'provider-rtsp' }],
-      [{ id: 14, addonId: 'provider-onvif', parentDeviceId: null }],
-    )
-    expect(stamps).toEqual([])
-  })
-})
-
-describe('runIntegrationIdBackfill', () => {
-  it('applies stamps and reports the count, skipping failures', async () => {
-    const stamped: Array<{ deviceId: number; integrationId: string }> = []
-    const result = await runIntegrationIdBackfill({
-      listIntegrations: async () => [{ id: 'int_1', addonId: 'provider-rtsp' }],
-      listDevices: async () => [
-        { id: 10, addonId: 'provider-rtsp', parentDeviceId: null },
-        { id: 11, addonId: 'provider-rtsp', parentDeviceId: null },
-      ],
-      setIntegrationId: async (deviceId, integrationId) => {
-        if (deviceId === 11) throw new Error('boom')
-        stamped.push({ deviceId, integrationId })
-      },
-      logger: { info: () => {}, warn: () => {} },
-    })
-    expect(result).toEqual({ stamped: 1 })
-    expect(stamped).toEqual([{ deviceId: 10, integrationId: 'int_1' }])
-  })
-
-  it('does nothing when there is nothing to stamp', async () => {
-    const result = await runIntegrationIdBackfill({
-      listIntegrations: async () => [],
-      listDevices: async () => [],
-      setIntegrationId: async () => {
-        throw new Error('should not be called')
-      },
-      logger: { info: () => {}, warn: () => {} },
-    })
-    expect(result).toEqual({ stamped: 0 })
-  })
-})