@camstack/server 0.1.7 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "private": false,
   "exports": {
     "./package.json": "./package.json",
@@ -9,8 +9,8 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "dev": "npx concurrently -n server,ui -c blue,magenta \"tsx watch --env-file=.env --ignore=./camstack-data src/launcher.ts\" \"cd ../../packages/addon-admin-ui && npx vite --port 3001\"",
-    "serve": "tsx watch --env-file=.env --ignore=./camstack-data src/launcher.ts",
+    "dev": "npx concurrently -n server,ui -c blue,magenta \"CAMSTACK_RESTART_TOUCH_FILE=src/launcher.ts tsx watch --env-file=.env --ignore=./camstack-data --ignore=../../packages/core/dist --ignore=../../packages/sdk/dist --ignore=../../packages/ui-library/dist --ignore=../../packages/shm-ring/dist src/launcher.ts\" \"cd ../../packages/addon-admin-ui && npx vite --port 3001\"",
+    "serve": "CAMSTACK_RESTART_TOUCH_FILE=src/launcher.ts tsx watch --env-file=.env --ignore=./camstack-data --ignore=../../packages/core/dist --ignore=../../packages/sdk/dist --ignore=../../packages/ui-library/dist --ignore=../../packages/shm-ring/dist src/launcher.ts",
     "serve:once": "tsx --env-file=.env src/launcher.ts",
     "start": "node --env-file=.env dist/launcher.js",
     "typecheck": "tsc --noEmit",

package/src/__tests__/cap-providers/cap-providers-location-import.spec.ts

@@ -0,0 +1,186 @@
+/**
+ * cap-providers-location-import.spec.ts
+ *
+ * Verifies that `buildIntegrationsProvider().getAvailableTypes()` correctly
+ * surfaces the `supportsLocationImport` flag:
+ *   - A `device-adoption` addon whose manifest declares `supportsLocationImport: true`
+ *     → returned entry has `supportsLocationImport === true`.
+ *   - A `device-adoption` addon WITHOUT the flag
+ *     → returned entry has `supportsLocationImport === false`.
+ *   - A `device-provider` addon (non-adoption kind), regardless of the flag
+ *     → returned entry has `supportsLocationImport === false`.
+ *
+ * Harness mirrors integrations-delete-cascade.spec.ts in the same directory.
+ */
+import { describe, it, expect, vi } from 'vitest'
+import { buildIntegrationsProvider } from '../../api/core/cap-providers.js'
+
+// ── Minimal stubs ────────────────────────────────────────────────────────────
+
+function makeIntegrationRegistry() {
+  return {
+    listIntegrations: vi.fn(async () => []),
+    getIntegration: vi.fn(async (_id: string) => null),
+    deleteIntegration: vi.fn(async (_id: string) => undefined),
+    createIntegration: vi.fn(),
+    updateIntegration: vi.fn(),
+    getIntegrationByAddonId: vi.fn(),
+    getIntegrationSettings: vi.fn(),
+    setIntegrationSettings: vi.fn(),
+  }
+}
+
+type FakeAddonRow = {
+  manifest: {
+    id: string
+    name: string
+    description: string
+    capabilities: Array<{ name: string }>
+    supportsLocationImport?: boolean
+    brokerKind?: string
+    instanceMode?: string
+    icon?: string
+    color?: string
+  }
+  declaration?: {
+    supportsLocationImport?: boolean
+    brokerKind?: string
+    instanceMode?: string
+    icon?: string
+    color?: string
+  }
+  process?: { state: string }
+}
+
+function makeAddonRegistry(addons: FakeAddonRow[] = []) {
+  const integrationReg = makeIntegrationRegistry()
+  return {
+    getIntegrationRegistry: vi.fn(() => integrationReg),
+    listAddons: vi.fn(() => addons),
+    restartAddon: vi.fn(),
+    getCapabilityRegistry: vi.fn(() => ({
+      getProviderByAddon: vi.fn(() => null),
+    })),
+  }
+}
+
+function makeEventBus() {
+  return { emit: vi.fn() }
+}
+
+function makeLogger() {
+  return {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  }
+}
+
+function makeLoggingService() {
+  const log = makeLogger()
+  return { createLogger: vi.fn(() => log) }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('getAvailableTypes — supportsLocationImport flag', () => {
+  it('returns supportsLocationImport=true for a device-adoption addon that declares it in the manifest', async () => {
+    const addon: FakeAddonRow = {
+      manifest: {
+        id: 'provider-homeassistant',
+        name: 'Home Assistant Provider',
+        description: 'Adopt HA devices',
+        capabilities: [{ name: 'device-adoption' }],
+        supportsLocationImport: true,
+        brokerKind: 'home-assistant',
+        instanceMode: 'multiple',
+      },
+    }
+    const ar = makeAddonRegistry([addon])
+    const provider = buildIntegrationsProvider(ar as never, makeEventBus() as never, makeLoggingService() as never, null)
+    const types = await provider.getAvailableTypes()
+
+    expect(types).toHaveLength(1)
+    expect(types[0]).toMatchObject({
+      addonId: 'provider-homeassistant',
+      kind: 'device-adoption',
+      supportsLocationImport: true,
+    })
+  })
+
+  it('returns supportsLocationImport=false for a device-adoption addon that omits the flag', async () => {
+    const addon: FakeAddonRow = {
+      manifest: {
+        id: 'provider-test-adoption',
+        name: 'Test Adoption Provider',
+        description: 'Adoption without location import',
+        capabilities: [{ name: 'device-adoption' }],
+        brokerKind: 'test-broker',
+        instanceMode: 'multiple',
+      },
+    }
+    const ar = makeAddonRegistry([addon])
+    const provider = buildIntegrationsProvider(ar as never, makeEventBus() as never, makeLoggingService() as never, null)
+    const types = await provider.getAvailableTypes()
+
+    expect(types).toHaveLength(1)
+    expect(types[0]).toMatchObject({
+      addonId: 'provider-test-adoption',
+      kind: 'device-adoption',
+      supportsLocationImport: false,
+    })
+  })
+
+  it('returns supportsLocationImport=false for a device-provider addon even when the flag is set on manifest', async () => {
+    const addon: FakeAddonRow = {
+      manifest: {
+        id: 'provider-reolink',
+        name: 'Reolink Provider',
+        description: 'Classic device provider',
+        capabilities: [{ name: 'device-provider' }],
+        // Hypothetical: even if someone mistakenly sets this on a device-provider
+        supportsLocationImport: true,
+        instanceMode: 'single',
+      },
+    }
+    const ar = makeAddonRegistry([addon])
+    const provider = buildIntegrationsProvider(ar as never, makeEventBus() as never, makeLoggingService() as never, null)
+    const types = await provider.getAvailableTypes()
+
+    expect(types).toHaveLength(1)
+    expect(types[0]).toMatchObject({
+      addonId: 'provider-reolink',
+      kind: 'device-provider',
+      supportsLocationImport: false,
+    })
+  })
+
+  it('prefers declaration.supportsLocationImport over manifest when declaration is present', async () => {
+    const addon: FakeAddonRow = {
+      manifest: {
+        id: 'provider-homeassistant',
+        name: 'Home Assistant Provider',
+        description: 'Adopt HA devices',
+        capabilities: [{ name: 'device-adoption' }],
+        supportsLocationImport: false,
+        brokerKind: 'home-assistant',
+        instanceMode: 'multiple',
+      },
+      declaration: {
+        supportsLocationImport: true,
+        brokerKind: 'home-assistant',
+        instanceMode: 'multiple',
+      },
+    }
+    const ar = makeAddonRegistry([addon])
+    const provider = buildIntegrationsProvider(ar as never, makeEventBus() as never, makeLoggingService() as never, null)
+    const types = await provider.getAvailableTypes()
+
+    expect(types).toHaveLength(1)
+    expect(types[0]).toMatchObject({
+      addonId: 'provider-homeassistant',
+      kind: 'device-adoption',
+      supportsLocationImport: true,
+    })
+  })
+})

package/src/__tests__/cap-providers/integrations-delete-cascade.spec.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { buildIntegrationsProvider } from '../../api/core/cap-providers'
+import type { CapabilityRegistry } from '@camstack/kernel'
+import type { Integration } from '@camstack/types'
+
+// ── Minimal stubs ────────────────────────────────────────────────────────────
+
+const INTEGRATION_ID = 'integ-abc-123'
+const ADDON_ID = 'provider-test'
+
+function makeIntegration(id = INTEGRATION_ID): Integration {
+  return {
+    id,
+    addonId: ADDON_ID,
+    name: 'Test Integration',
+    enabled: true,
+    info: null,
+    settings: null,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as unknown as Integration
+}
+
+function makeIntegrationRegistry(integration: Integration | null = makeIntegration()) {
+  return {
+    getIntegration: vi.fn(async (_id: string) => integration),
+    deleteIntegration: vi.fn(async (_id: string) => undefined),
+    listIntegrations: vi.fn(async () => (integration ? [integration] : [])),
+    createIntegration: vi.fn(),
+    updateIntegration: vi.fn(),
+    getIntegrationByAddonId: vi.fn(),
+    getIntegrationSettings: vi.fn(),
+    setIntegrationSettings: vi.fn(),
+  }
+}
+
+function makeAddonRegistry(reg = makeIntegrationRegistry()) {
+  return {
+    getIntegrationRegistry: vi.fn(() => reg),
+    listAddons: vi.fn(() => []),
+    restartAddon: vi.fn(),
+    getCapabilityRegistry: vi.fn(() => ({
+      getProviderByAddon: vi.fn(() => null),
+    })),
+  }
+}
+
+function makeEventBus() {
+  return { emit: vi.fn() }
+}
+
+function makeLogger() {
+  return {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  }
+}
+
+function makeLoggingService(log = makeLogger()) {
+  return { createLogger: vi.fn(() => log) }
+}
+
+function makeCapabilityRegistry(
+  removeByIntegration: ((input: { integrationId: string }) => Promise<{ removed: number }>) | null = vi.fn(async () => ({ removed: 2 })),
+): CapabilityRegistry {
+  return {
+    getSingleton: vi.fn((_cap: string) =>
+      removeByIntegration ? { removeByIntegration } : null,
+    ),
+  } as unknown as CapabilityRegistry
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('integrations.delete cascade-removes devices via removeByIntegration', () => {
+  let integrationReg: ReturnType<typeof makeIntegrationRegistry>
+  let addonReg: ReturnType<typeof makeAddonRegistry>
+  let eb: ReturnType<typeof makeEventBus>
+  let log: ReturnType<typeof makeLogger>
+  let loggingService: ReturnType<typeof makeLoggingService>
+
+  beforeEach(() => {
+    integrationReg = makeIntegrationRegistry()
+    addonReg = makeAddonRegistry(integrationReg)
+    eb = makeEventBus()
+    log = makeLogger()
+    loggingService = makeLoggingService(log)
+  })
+
+  it('calls removeByIntegration with the integration id before deleteIntegration', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 3 }))
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(removeByIntegration).toHaveBeenCalledOnce()
+    expect(removeByIntegration).toHaveBeenCalledWith({ integrationId: INTEGRATION_ID })
+  })
+
+  it('still deletes the integration record and emits integration.deleted after the cascade', async () => {
+    const capReg = makeCapabilityRegistry()
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    const result = await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledWith(INTEGRATION_ID)
+
+    expect(eb.emit).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        category: 'integration.deleted',
+        data: expect.objectContaining({ integrationId: INTEGRATION_ID }),
+      }),
+    )
+
+    expect(result).toEqual({ success: true, deletedId: INTEGRATION_ID })
+  })
+
+  it('logs the removed count from removeByIntegration', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 5 }))
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(log.info).toHaveBeenCalledWith(
+      'cascade-removed devices',
+      expect.objectContaining({ meta: expect.objectContaining({ removed: 5 }) }),
+    )
+  })
+
+  it('does NOT abort the integration delete when removeByIntegration throws (best-effort)', async () => {
+    const removeByIntegration = vi.fn(async () => {
+      throw new Error('device-manager transient error')
+    })
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+
+    // Should NOT throw
+    await expect(provider.delete({ id: INTEGRATION_ID })).resolves.toEqual({
+      success: true,
+      deletedId: INTEGRATION_ID,
+    })
+
+    // Integration record deletion and event still fire
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledOnce()
+
+    // A warning is logged
+    expect(log.warn).toHaveBeenCalledWith(
+      'device cascade-remove failed (best-effort — continuing)',
+      expect.anything(),
+    )
+  })
+
+  it('warns and skips cascade when capabilityRegistry is null', async () => {
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, null)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'device-manager not available — skipping cascade device removal',
+      expect.anything(),
+    )
+  })
+
+  it('warns and skips cascade when device-manager singleton is not registered', async () => {
+    const capReg = makeCapabilityRegistry(null)
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'device-manager not available — skipping cascade device removal',
+      expect.anything(),
+    )
+  })
+
+  it('stamps legacy un-tagged devices of the addon BEFORE cascade so they are removed too', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 1 }))
+    const setIntegrationId = vi.fn(async (_input: { deviceId: number; integrationId: string }) => undefined)
+    // One un-tagged top-level device of the integration's addon (claimable),
+    // one already-tagged (skip), one child (skip), one other-addon (skip).
+    const listAll = vi.fn(async () => [
+      { id: 4, addonId: ADDON_ID, parentDeviceId: null },
+      { id: 5, addonId: ADDON_ID, parentDeviceId: null, integrationId: INTEGRATION_ID },
+      { id: 6, addonId: ADDON_ID, parentDeviceId: 4 },
+      { id: 7, addonId: 'provider-other', parentDeviceId: null },
+    ])
+    const capReg = {
+      getSingleton: vi.fn(() => ({ removeByIntegration, listAll, setIntegrationId })),
+    } as unknown as CapabilityRegistry
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    // Only device 4 is claimed (untagged, top-level, this addon's single integration).
+    expect(setIntegrationId).toHaveBeenCalledOnce()
+    expect(setIntegrationId).toHaveBeenCalledWith({ deviceId: 4, integrationId: INTEGRATION_ID })
+    // Cascade still runs after the claim.
+    expect(removeByIntegration).toHaveBeenCalledWith({ integrationId: INTEGRATION_ID })
+  })
+
+  it('claim failure does not abort the integration delete (best-effort)', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 0 }))
+    const setIntegrationId = vi.fn(async () => { throw new Error('stamp boom') })
+    const listAll = vi.fn(async () => [{ id: 4, addonId: ADDON_ID, parentDeviceId: null }])
+    const capReg = {
+      getSingleton: vi.fn(() => ({ removeByIntegration, listAll, setIntegrationId })),
+    } as unknown as CapabilityRegistry
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await expect(provider.delete({ id: INTEGRATION_ID })).resolves.toEqual({
+      success: true,
+      deletedId: INTEGRATION_ID,
+    })
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'legacy device claim failed (best-effort — continuing)',
+      expect.anything(),
+    )
+  })
+
+  it('throws when the integration is not found (guard still fires before cascade)', async () => {
+    integrationReg = makeIntegrationRegistry(null)
+    addonReg = makeAddonRegistry(integrationReg)
+    const capReg = makeCapabilityRegistry()
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+
+    await expect(provider.delete({ id: 'missing-id' })).rejects.toThrow('not found')
+
+    // Nothing should have been cleaned up
+    expect(integrationReg.deleteIntegration).not.toHaveBeenCalled()
+    expect(eb.emit).not.toHaveBeenCalled()
+  })
+})

package/src/__tests__/cap-routers/broker-routing.router.spec.ts

@@ -0,0 +1,169 @@
+
+/**
+ * Routing regression spec for the `broker` system-collection cap.
+ *
+ * The bug: `broker` is `scope:'system', mode:'collection'`. Two addons
+ * register a `broker` provider, each owning a DISJOINT id set
+ * (mqtt-broker owns `mqtt_*`, provider-homeassistant owns `ha_*`). The
+ * generated collection mount only fans out the array-output methods
+ * (`list` / `listProviders`); every id-keyed method (`get` / `getSettings`
+ * / `remove` / `testConnection` / …) falls through to `providers[0]`
+ * (the FIRST-registered provider = mqtt-broker). So operating on an HA
+ * broker `ha_1` hit mqtt-broker → "broker 'ha_1' not found".
+ *
+ * The fix: each broker carries its owning `addonId`; the admin UI threads
+ * it back as the `{ addonId }` system-collection selector so the call
+ * routes to the OWNING provider via `getProviderByAddonId`. Providers
+ * also return `null` (not throw) for ids they don't own, so the
+ * no-addonId fallback degrades gracefully.
+ *
+ * This spec exercises `createCapRouter_broker` with the SAME selector
+ * the generated mount builds (registry-backed: addonId → provider, else
+ * first-provider aggregate with array methods fanned out). It registers
+ * two mock providers and asserts:
+ *  - `list()` returns both, each tagged with its `addonId`.
+ *  - `get({id:'ha_1'}, addonId:'ha')` routes to the HA provider.
+ *  - `get({id:'ha_1'})` WITHOUT addonId returns null (graceful) — the
+ *    HA-owned id isn't in providers[0]'s registry, so it doesn't throw.
+ *  - `listProviders()` aggregates both providers' entries.
+ */
+import { describe, it, expect } from 'vitest'
+import { createCapRouter_broker } from '../../api/trpc/generated-cap-routers.js'
+import { type IBrokerProvider, type BrokerInfo, type BrokerProviderInfo } from '@camstack/types'
+import { concatCollection } from '../../api/trpc/cap-mount-helpers.js'
+import { makeCtx, invokeProcedure } from './harness.js'
+
+/**
+ * A self-contained mock `broker` provider that owns a fixed set of
+ * broker ids and self-tags every returned record with its `addonId`.
+ * Returns `null` / no-op for ids it does NOT own (never throws) — the
+ * exact graceful-degradation contract the real providers must honour.
+ */
+function makeProvider(addonId: string, ownedIds: readonly string[], kind: string): IBrokerProvider {
+  const owns = (id: string): boolean => ownedIds.includes(id)
+  const infoFor = (id: string): BrokerInfo => ({
+    id,
+    addonId,
+    name: `${kind}-${id}`,
+    kind,
+    status: 'connected',
+    info: {},
+    lastCheckedAt: null,
+    error: null,
+  })
+  return {
+    list: async () => ownedIds.map(infoFor),
+    get: async ({ id }) => (owns(id) ? infoFor(id) : null),
+    listProviders: async (): Promise<BrokerProviderInfo[]> => [
+      { addonId, kinds: [{ kind, label: kind }] },
+    ],
+    add: async () => ({ id: 'new' }),
+    remove: async () => {
+      // no-op for foreign ids (and owned ids in this mock)
+    },
+    testConnection: async ({ id }) =>
+      owns(id) ? { ok: true, latencyMs: 1 } : { ok: false, error: 'unknown broker' },
+    getSettings: async ({ id }) => (owns(id) ? { secret: id } : null),
+    setSettings: async () => {
+      // no-op
+    },
+    getBrokerConfig: async ({ id }) => (owns(id) ? { url: id } : null),
+    getSettingsSchema: async ({ kind: k }) => (k === kind ? { form: kind } : null),
+    testSettings: async () => ({ ok: true }),
+    publish: async () => null,
+    subscribe: async () => ({ subscriptionId: 's' }),
+    unsubscribe: async () => {
+      // no-op
+    },
+    getState: async () => null,
+    getStatus: async () => ({ brokerCount: ownedIds.length, connectedCount: ownedIds.length }),
+  }
+}
+
+/**
+ * Mirror of the generated collection mount selector for `broker`
+ * (`generated-cap-mounts.ts`): addonId → that provider directly; else a
+ * first-provider aggregate whose array-output methods are
+ * `concatCollection`-fanned. Two providers registered in order:
+ * mqtt (owns `mqtt_1`) first, ha (owns `ha_1`) second.
+ */
+function makeSelector(): (addonId?: string) => IBrokerProvider | null {
+  const mqtt = makeProvider('mqtt', ['mqtt_1'], 'mqtt')
+  const ha = makeProvider('ha', ['ha_1'], 'home-assistant')
+  const byAddonId: Record<string, IBrokerProvider> = { mqtt, ha }
+  const providers: readonly IBrokerProvider[] = [mqtt, ha]
+  return (addonId?: string): IBrokerProvider | null => {
+    if (addonId !== undefined) return byAddonId[addonId] ?? null
+    const first = providers[0]!
+    return {
+      ...first,
+      list: concatCollection(providers, 'list') as IBrokerProvider['list'],
+      listProviders: concatCollection(providers, 'listProviders') as IBrokerProvider['listProviders'],
+    }
+  }
+}
+
+describe('broker cap — addonId ownership routing', () => {
+  it('list() aggregates both providers, each broker tagged with its addonId', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'list', makeCtx('admin'), {})
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    const rows = outcome.value as BrokerInfo[]
+    const byId = new Map(rows.map(r => [r.id, r]))
+    expect(byId.get('mqtt_1')?.addonId).toBe('mqtt')
+    expect(byId.get('ha_1')?.addonId).toBe('ha')
+  })
+
+  it('get({id:ha_1}, addonId:ha) routes to the HA provider (not mqtt-broker)', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'get', makeCtx('admin'), { id: 'ha_1', addonId: 'ha' })
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    const row = outcome.value as BrokerInfo | null
+    expect(row).not.toBeNull()
+    expect(row?.id).toBe('ha_1')
+    expect(row?.addonId).toBe('ha')
+  })
+
+  it('get({id:ha_1}) WITHOUT addonId returns null gracefully (first provider does not own it)', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'get', makeCtx('admin'), { id: 'ha_1' })
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    expect(outcome.value).toBeNull()
+  })
+
+  it('testConnection({id:ha_1}, addonId:ha) routes to HA provider and succeeds', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'testConnection', makeCtx('admin'), { id: 'ha_1', addonId: 'ha' })
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    expect(outcome.value).toEqual({ ok: true, latencyMs: 1 })
+  })
+
+  it('listProviders() aggregates both providers entries', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'listProviders', makeCtx('admin'))
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    const entries = outcome.value as BrokerProviderInfo[]
+    const addonIds = entries.map(e => e.addonId).sort()
+    expect(addonIds).toEqual(['ha', 'mqtt'])
+  })
+})