@switchbot/homebridge-switchbot 5.1.0-beta.9 → 5.1.1

package/src/homebridge-ui/public/js/app.ts

@@ -1,56 +1,13 @@
-import { detectV4Config } from './api.js'
 import { loadCredentialStatus, saveCredentials } from './credentials.js'
 import { initRemoveAllButton, loadConfiguredDevices } from './devices.js'
-import { discoverDevices, initializeDiscoverySettings } from './discovery.js'
+import { discoverDevices, initializeDiscoverySettings } from './discovery.js';
 
-// Ensure SwitchBot config block exists before any UI actions
-async function ensureSwitchBotConfigBlock(): Promise<void> {
-  try {
-    if (typeof homebridge.getPluginConfig !== 'function' || typeof homebridge.updatePluginConfig !== 'function') {
-      return
-    }
-    let configArr = await homebridge.getPluginConfig()
-    if (!Array.isArray(configArr)) {
-      configArr = []
-    }
-    const idx = configArr.findIndex(c => (c.platform || c.name || '').toLowerCase().includes('switchbot'))
-    if (idx === -1) {
-      configArr.push({ platform: 'SwitchBot' })
-      await homebridge.updatePluginConfig(configArr)
-      if (typeof homebridge.savePluginConfig === 'function') {
-        await homebridge.savePluginConfig()
-      }
-    }
-  } catch (_e) {
-    // Ignore errors
-  }
-}
-
-;
-
-(window as any).loadCredentialStatus = loadCredentialStatus
-;(window as any).saveCredentials = saveCredentials
-;(window as any).discoverDevices = discoverDevices
-
-/**
- * Show or hide the v4 config incompatibility warning banner.
- */
-async function checkV4Config(): Promise<void> {
-  const banner = document.getElementById('v4ConfigWarning')
-  if (!banner) {
-    return
-  }
-  const isV4 = await detectV4Config()
-  if (isV4) {
-    banner.style.display = 'block'
-  }
-}
+(window as any).loadCredentialStatus = loadCredentialStatus;
+(window as any).saveCredentials = saveCredentials;
+(window as any).discoverDevices = discoverDevices
 
 // Initialize on page load
-
 async function init(): Promise<void> {
-  await ensureSwitchBotConfigBlock()
-  await checkV4Config()
   await loadCredentialStatus()
   await initializeDiscoverySettings()
   await loadConfiguredDevices()

package/src/homebridge-ui/public/js/credentials.ts

@@ -63,20 +63,14 @@ export async function saveCredentials(): Promise<void> {
     if (typeof homebridge.getPluginConfig !== 'function' || typeof homebridge.updatePluginConfig !== 'function') {
       throw new TypeError('Homebridge UI API not available')
     }
-    let configArr = await homebridge.getPluginConfig()
-    if (!Array.isArray(configArr)) {
-      configArr = []
-    }
-    let idx = configArr.findIndex(c => (c.platform || c.name || '').toLowerCase() === 'switchbot')
-    if (idx === -1) {
-      // Add new SwitchBot platform config
-      configArr.push({ platform: 'SwitchBot' })
-      idx = configArr.length - 1
+    const configArr = await homebridge.getPluginConfig()
+    if (!Array.isArray(configArr) || configArr.length === 0) {
+      throw new Error('No plugin config found')
     }
-    const config = configArr[idx]
+    const config = configArr[0]
     config.openApiToken = token
     config.openApiSecret = secret
-    await homebridge.updatePluginConfig(configArr)
+    await homebridge.updatePluginConfig([config])
     if (typeof homebridge.savePluginConfig === 'function') {
       await homebridge.savePluginConfig()
     }

package/src/homebridge-ui/public/js/devices.ts

@@ -26,14 +26,8 @@ export async function addDeviceToConfig(device: any, options: { refresh?: boolea
       address: importValues.address,
       model: device.model,
       rssi: device.rssi,
-      connectionPreference: importValues.connectionPreference,
-      externalPublishProtocol: importValues.externalPublishProtocol,
-      room: importValues.room,
       encryptionKey: importValues.encryptionKey,
       keyId: importValues.keyId,
-      refreshRate: importValues.refreshRate,
-      blePollingEnabled: importValues.blePollingEnabled,
-      blePollIntervalMs: importValues.blePollIntervalMs,
     })
     uiLog.info('Add device response:', resp)
 

package/src/homebridge-ui/public/js/modals.ts

@@ -6,7 +6,6 @@ export type ImportDiscoveredDeviceResult = {
   configDeviceType: string
   address?: string
   connectionPreference?: string
-  externalPublishProtocol?: string
   room?: string
   encryptionKey?: string
   keyId?: string
@@ -155,30 +154,6 @@ export async function importDiscoveredDevice(device: any): Promise<ImportDiscove
       connectionPrefSelect.appendChild(opt)
     })
 
-    // --- External Publish Protocol ---
-    const externalPublishLabel = document.createElement('label')
-    externalPublishLabel.textContent = 'Publish as External Device'
-    externalPublishLabel.style.display = 'block'
-    externalPublishLabel.style.marginBottom = '6px'
-    externalPublishLabel.style.fontWeight = '500'
-    externalPublishLabel.style.fontSize = '12px'
-    externalPublishLabel.style.color = '#6b7280'
-
-    const externalPublishSelect = document.createElement('select')
-    externalPublishSelect.style.width = '100%'
-    externalPublishSelect.style.marginBottom = '12px'
-    externalPublishSelect.style.padding = '8px 10px'
-    externalPublishSelect.style.borderRadius = '6px'
-    externalPublishSelect.style.fontSize = '14px'
-    externalPublishSelect.style.boxSizing = 'border-box'
-    ;['none', 'hap', 'matter'].forEach((val) => {
-      const opt = document.createElement('option')
-      opt.value = val
-      opt.text = val === 'none' ? 'None' : val.toUpperCase()
-      opt.selected = (device.externalPublishProtocol || 'none') === val
-      externalPublishSelect.appendChild(opt)
-    })
-
     // --- Room ---
     const roomLabel = document.createElement('label')
     roomLabel.textContent = 'Room'
@@ -333,7 +308,6 @@ export async function importDiscoveredDevice(device: any): Promise<ImportDiscove
         configDeviceType: typeSelect.value || device.type,
         address: macInput.value || undefined,
         connectionPreference: connectionPrefSelect.value || undefined,
-        externalPublishProtocol: externalPublishSelect.value || 'none',
         room: roomInput.value || undefined,
         encryptionKey: encryptionKeyInput.value || undefined,
         keyId: keyIdInput.value || undefined,
@@ -357,8 +331,6 @@ export async function importDiscoveredDevice(device: any): Promise<ImportDiscove
     contentDiv.appendChild(typeSelect)
     contentDiv.appendChild(connectionPrefLabel)
     contentDiv.appendChild(connectionPrefSelect)
-    contentDiv.appendChild(externalPublishLabel)
-    contentDiv.appendChild(externalPublishSelect)
     contentDiv.appendChild(roomLabel)
     contentDiv.appendChild(roomInput)
     contentDiv.appendChild(macLabel)
@@ -601,30 +573,6 @@ export async function editDevice(device: any): Promise<void> {
     connectionPrefSelect.appendChild(opt)
   })
 
-  // --- External Publish Protocol ---
-  const externalPublishLabel = document.createElement('label')
-  externalPublishLabel.textContent = 'Publish as External Device'
-  externalPublishLabel.style.display = 'block'
-  externalPublishLabel.style.marginBottom = '6px'
-  externalPublishLabel.style.fontWeight = '500'
-  externalPublishLabel.style.fontSize = '12px'
-  externalPublishLabel.style.color = '#6b7280'
-
-  const externalPublishSelect = document.createElement('select')
-  externalPublishSelect.style.width = '100%'
-  externalPublishSelect.style.marginBottom = '12px'
-  externalPublishSelect.style.padding = '8px 10px'
-  externalPublishSelect.style.borderRadius = '6px'
-  externalPublishSelect.style.fontSize = '14px'
-  externalPublishSelect.style.boxSizing = 'border-box'
-  ;['none', 'hap', 'matter'].forEach((val) => {
-    const opt = document.createElement('option')
-    opt.value = val
-    opt.text = val === 'none' ? 'None' : val.toUpperCase()
-    opt.selected = (device.externalPublishProtocol || 'none') === val
-    externalPublishSelect.appendChild(opt)
-  })
-
   // --- Room ---
   const roomLabel = document.createElement('label')
   roomLabel.textContent = 'Room'
@@ -726,7 +674,6 @@ export async function editDevice(device: any): Promise<void> {
         configDeviceName: nameInput.value || undefined,
         configDeviceType: typeSelect.value,
         connectionPreference: connectionPrefSelect.value,
-        externalPublishProtocol: externalPublishSelect.value,
         room: roomInput.value || undefined,
         encryptionKey: encryptionKeyInput.value || undefined,
         keyId: keyIdInput.value || undefined,
@@ -743,9 +690,6 @@ export async function editDevice(device: any): Promise<void> {
       if (params.room !== undefined) {
         options.room = params.room
       }
-      if (params.externalPublishProtocol !== undefined) {
-        options.externalPublishProtocol = params.externalPublishProtocol
-      }
       if (params.encryptionKey !== undefined) {
         options.encryptionKey = params.encryptionKey
       }
@@ -795,8 +739,6 @@ export async function editDevice(device: any): Promise<void> {
   contentDiv.appendChild(typeSelect)
   contentDiv.appendChild(connectionPrefLabel)
   contentDiv.appendChild(connectionPrefSelect)
-  contentDiv.appendChild(externalPublishLabel)
-  contentDiv.appendChild(externalPublishSelect)
   contentDiv.appendChild(roomLabel)
   contentDiv.appendChild(roomInput)
   contentDiv.appendChild(encryptionKeyLabel)

package/src/homebridge-ui/public/js/render.ts

@@ -1014,9 +1014,8 @@ export function renderDeviceList(list: any[]): void {
     const id = `ID: ${deviceIdentifier}`
     const typeText = d.configDeviceType || d.type ? `Type: ${d.configDeviceType || d.type}` : ''
     const connText = d.connectionPreference ? `Conn: ${d.connectionPreference}` : ''
-    const extText = d.externalPublishProtocol && d.externalPublishProtocol !== 'none' ? `external: ${d.externalPublishProtocol}` : ''
     const roomText = d.room ? `Room: ${d.room}` : ''
-    meta.textContent = [id, typeText, connText, extText, roomText].filter(Boolean).join(' | ')
+    meta.textContent = [id, typeText, connText, roomText].filter(Boolean).join(' | ')
 
     info.appendChild(nameContainer)
     info.appendChild(meta)

package/src/homebridge-ui/utils/config-parser.ts

@@ -57,15 +57,6 @@ export function getAllDevices(platform: any): any[] {
   })
 }
 
-/**
- * Detect whether a platform config block is in the legacy v4 format.
- *
- * v4 configs stored credentials under a `credentials` sub-object and devices
- * under `options.devices`.  v5+ flattened these to `openApiToken`,
- * `openApiSecret`, and a root-level `devices` array.
- */
-export { isV4Config } from './v4-detection.js'
-
 /**
  * Get credential from platform config
  */

package/src/index.ts

@@ -4,9 +4,9 @@
  */
 import type { API } from 'homebridge'
 
-import { SwitchBotHAPPlatform } from './Platform.HAP.js'
-import { SwitchBotMatterPlatform } from './Platform.Matter.js'
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
+import { SwitchBotHAPPlatform } from './SwitchBotHAPPlatform.js'
+import { SwitchBotMatterPlatform } from './SwitchBotMatterPlatform.js'
 import { createPlatformProxy } from './utils.js'
 
 /**

package/src/settings.ts

@@ -1,24 +1,12 @@
 export const PLUGIN_NAME = '@switchbot/homebridge-switchbot'
 export const PLATFORM_NAME = 'SwitchBot'
 
-export interface SwitchBotDeviceConfig {
-  deviceId?: string
-  id?: string
-  configDeviceName?: string
-  name?: string
-  configDeviceType?: string
-  type?: string
-  externalPublishProtocol?: 'none' | 'hap' | 'matter'
-  [key: string]: any
-}
-
 export interface SwitchBotPluginConfig {
   openApiToken?: string
   openApiSecret?: string
   preferMatter?: boolean
   enableMatter?: boolean
   enableBLE?: boolean // Enable or disable BLE support
-  devices?: SwitchBotDeviceConfig[]
   // other plugin-specific configuration
   [key: string]: any
 }

package/src/utils.ts

@@ -1137,37 +1137,6 @@ export function normalizeConfig(raw?: PlatformConfig): SwitchBotPluginConfig {
   return { ...(raw as any) } as SwitchBotPluginConfig
 }
 
-/**
- * Resolve the per-device external publish protocol from raw config.
- * Accepts canonical values (`none`, `hap`, `matter`) and common aliases.
- */
-export function resolveExternalPublishProtocol(rawDevice: any): 'none' | 'hap' | 'matter' {
-  const raw = String(
-    rawDevice?.externalPublishProtocol
-    ?? rawDevice?.externalDeviceProtocol
-    ?? rawDevice?.publishExternal
-    ?? rawDevice?.external
-    ?? 'none',
-  ).trim().toLowerCase()
-
-  if (raw === 'true') {
-    return 'hap'
-  }
-  if (raw === 'false') {
-    return 'none'
-  }
-  if (raw === 'homekit') {
-    return 'hap'
-  }
-  if (raw === 'none' || raw === 'off' || raw === 'disabled') {
-    return 'none'
-  }
-  if (raw === 'hap' || raw === 'matter') {
-    return raw
-  }
-  return 'none'
-}
-
 // Create a Proxy constructor that instantiates the right platform implementation at runtime.
 /**
  * Creates a proxy class that instantiates the correct platform implementation (HAP or Matter) at runtime.

package/test/device/deviceFactory.spec.ts

@@ -30,4 +30,13 @@ describe('createDevice', () => {
     const result = await createDevice({ id: 'xyz', type: 'UnknownType' }, dummyConfig as any, false)
     expect(result.instance.constructor.name).toBe('GenericDevice')
   })
+
+  it('should create a WaterDetectorDevice for normalized "waterdetector" type', async () => {
+    // normalizeTypeForMatter() returns 'waterdetector' (no space) for water detector variants.
+    // This regression test ensures the no-space key is mapped so devices aren't silently
+    // downgraded to GenericDevice (which would expose a bogus Switch service).
+    const result = await createDevice({ id: 'wd1', type: 'waterdetector' }, dummyConfig as any, false)
+    expect(result.instance).toBeDefined()
+    expect(result.instance.constructor.name).toBe('WaterDetectorDevice')
+  })
 })

package/test/device/getstate-cache.spec.ts

@@ -0,0 +1,62 @@
+/* Copyright(C) 2021-2026, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+ *
+ * getstate-cache.spec.ts: one fetch serves a burst of reads
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import { GenericDevice } from '../../src/devices/genericDevice.js'
+
+const log: any = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn(), success: vi.fn() }
+
+function device() {
+  const getDevice = vi.fn(async () => ({ getStatus: async () => ({ temperature: 22.7, humidity: 59 }) }))
+  const d = new GenericDevice({ id: 'B0E9FED044E3', type: 'meter', name: 'M', log }, { log, _client: { getDevice } } as any)
+  return { d, getDevice }
+}
+
+describe('genericDevice.getState caching', () => {
+  // HomeKit reads every characteristic of an accessory at once. Seven
+  // characteristics must not mean seven API requests.
+  it('fetches once for a burst of concurrent reads', async () => {
+    const { d, getDevice } = device()
+
+    const states = await Promise.all([d.getState(), d.getState(), d.getState(), d.getState()])
+
+    expect(getDevice).toHaveBeenCalledTimes(1)
+    expect(states.every(s => s.temperature === 22.7)).toBe(true)
+  })
+
+  it('reuses the value for sequential reads inside the window', async () => {
+    const { d, getDevice } = device()
+
+    await d.getState()
+    await d.getState()
+
+    expect(getDevice).toHaveBeenCalledTimes(1)
+  })
+
+  it('fetches again once the window has passed', async () => {
+    const { d, getDevice } = device()
+    await d.getState()
+
+    vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 20_000)
+    await d.getState()
+    vi.restoreAllMocks()
+
+    expect(getDevice).toHaveBeenCalledTimes(2)
+  })
+
+  it('marks an unreadable device and does not cache it', async () => {
+    const getDevice = vi.fn()
+      .mockRejectedValueOnce(new Error('offline'))
+      .mockResolvedValueOnce({ getStatus: async () => ({ temperature: 21 }) })
+    const d = new GenericDevice({ id: 'x', type: 'meter', name: 'M', log }, { log, _client: { getDevice } } as any)
+
+    const first = await d.getState()
+    const second = await d.getState()
+
+    expect(first).toEqual({ id: 'x', type: 'meter', unreadable: true })
+    expect(second.temperature).toBe(21)
+  })
+})

package/test/device/getstate-returns-status.spec.ts

@@ -0,0 +1,89 @@
+/* Copyright(C) 2021-2026, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+ *
+ * getstate-returns-status.spec.ts: getState() must yield readings, not the device
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import { createDevice } from '../../src/deviceFactory.js'
+import { GenericDevice, MeterDevice } from '../../src/devices/genericDevice.js'
+
+const log: any = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn(), success: vi.fn() }
+
+/** A node-switchbot style device: identity on the instance, readings via getStatus(). */
+function switchBotDevice(status: any) {
+  return {
+    id: 'B0E9FED044E3',
+    name: 'Meter Pro CO2 Monitor',
+    deviceType: 'MeterPro(CO2)',
+    mac: 'b0:e9:fe:d0:44:e3',
+    getStatus: async () => status,
+  }
+}
+
+const STATUS = { deviceId: 'B0E9FED044E3', temperature: 23.7, humidity: 59, battery: 100, connectionType: 'api' }
+
+function deviceWith(client: any) {
+  return new GenericDevice({ id: 'B0E9FED044E3', type: 'meter', name: 'Meter', log }, { log, _client: client } as any)
+}
+
+describe('genericDevice.getState', () => {
+  it('returns the status rather than the device instance', async () => {
+    const state = await deviceWith({ getDevice: async () => switchBotDevice(STATUS) }).getState()
+
+    expect(state).toEqual(STATUS)
+    expect(state.temperature).toBe(23.7)
+    expect(state.humidity).toBe(59)
+  })
+
+  it('passes through a plain status object unchanged', async () => {
+    const state = await deviceWith({ getDevice: async () => ({ temperature: 20, humidity: 40 }) }).getState()
+
+    expect(state).toEqual({ temperature: 20, humidity: 40 })
+  })
+
+  it('unwraps an API-shaped body', async () => {
+    const state = await deviceWith({ getDevice: async () => ({ body: { temperature: 19 } }) }).getState()
+
+    expect(state).toEqual({ temperature: 19 })
+  })
+
+  it.each([
+    ['throws', async () => { throw new Error('unreachable') }],
+    ['returns null', async () => null],
+  ])('reports minimal info when getStatus() %s', async (_label, getStatus) => {
+    const client = { getDevice: async () => ({ ...switchBotDevice(STATUS), getStatus }) }
+
+    const state = await deviceWith(client).getState()
+
+    // Not the device instance: that would look like a reading of every field.
+    expect(state).toEqual({ id: 'B0E9FED044E3', type: 'meter', unreadable: true })
+    expect(state.temperature).toBeUndefined()
+  })
+})
+
+describe('createDevice', () => {
+  it('does not replace the device getState with the raw client device', async () => {
+    const client = { init: async () => {}, getDevice: async () => switchBotDevice(STATUS) }
+    const created: any = await createDevice(
+      { id: 'B0E9FED044E3', type: 'meter', name: 'Meter', log } as any,
+      { log, _client: client } as any,
+      false,
+    )
+
+    const state = await created.instance.getState()
+
+    expect(state.temperature).toBe(23.7)
+    expect(state.getStatus).toBeUndefined()
+  })
+
+  it('lets a meter report a real temperature end to end', async () => {
+    const client = { init: async () => {}, getDevice: async () => switchBotDevice(STATUS) }
+    const device = new MeterDevice({ id: 'B0E9FED044E3', type: 'meter', name: 'Meter', log } as any, { log, _client: client } as any)
+
+    const services = device.createHAPAccessory(null).services
+    const temperature = services.find((s: any) => s.type === 'TemperatureSensor')
+
+    await expect(temperature.characteristics.CurrentTemperature.get()).resolves.toBe(23.7)
+  })
+})

package/test/device/model-identities.spec.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+
+import { normalizeDeviceType } from '../../src/device-types'
+import { createDevice } from '../../src/deviceFactory'
+
+// node-switchbot 5 reports product-specific identities (pySwitchbot 3.0.0 parity).
+// Every identity must reach the same accessory class as its canonical display name.
+describe('product-specific model identities', () => {
+  const mockLogger = { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} }
+  const dummyConfig = { logger: mockLogger, log: mockLogger }
+
+  it.each([
+    ['WoPlugUS', 'Plug Mini (US)'],
+    ['WoPlugJP', 'Plug Mini (JP)'],
+    ['WoCurtain3', 'Curtain3'],
+    ['WoMeterPlus', 'Meter Plus'],
+    ['WoTHPc', 'Meter Pro (CO2)'],
+    ['WoCeilingPro', 'Ceiling Light Pro'],
+    ['WoLinkMini', 'Hub Mini'],
+    ['WoIOSensorTH', 'WoIOSensor'],
+    ['Outdoor Meter', 'WoIOSensor'],
+    ['Indoor/Outdoor Thermo-Hygrometer', 'WoIOSensor'],
+  ])('normalizes %s to %s', (input, expected) => {
+    expect(normalizeDeviceType(input)).toBe(expected)
+  })
+
+  it.each([
+    ['WoPlugUS', 'PlugMiniDevice'],
+    ['Plug Mini (US)', 'PlugMiniDevice'],
+    ['WoPlugJP', 'PlugMiniDevice'],
+    ['Plug Mini (JP)', 'PlugMiniDevice'],
+    ['WoCurtain3', 'Curtain3Device'],
+    ['Curtain3', 'Curtain3Device'],
+    ['WoMeterPlus', 'MeterDevice'],
+    ['Meter Plus', 'MeterDevice'],
+    ['WoTHPc', 'MeterDevice'],
+    ['Meter Pro (CO2)', 'MeterDevice'],
+    ['Meter Pro', 'MeterDevice'],
+    ['WoCeilingPro', 'LightDevice'],
+    ['Ceiling Light Pro', 'LightDevice'],
+  ])('creates the right accessory for %s', async (type, className) => {
+    const result = await createDevice({ id: `id-${type}`, type } as any, dummyConfig as any, false)
+    expect(result.instance.constructor.name).toBe(className)
+  })
+})

package/test/device/water-detector-battery.spec.ts

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { WaterDetectorDevice } from '../../src/devices/genericDevice'
+
+const openApiMocks = vi.hoisted(() => {
+  const getStatus = vi.fn()
+  return {
+    getStatus,
+    // Use a function implementation so the mock is constructible with `new OpenAPIClient()`
+    // eslint-disable-next-line prefer-arrow-callback
+    OpenAPIClient: vi.fn().mockImplementation(function () { return { getStatus } }),
+
+  }
+})
+
+vi.mock('node-switchbot', () => ({
+  OpenAPIClient: openApiMocks.OpenAPIClient,
+}))
+
+const mockLogger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+
+const mockApi = {
+  hap: {
+    HapStatusError: class HapStatusError extends Error {
+      constructor(readonly status: number) {
+        super(`HAP ${status}`)
+      }
+    },
+    HAPStatus: {
+      SERVICE_COMMUNICATION_FAILURE: -70402,
+    },
+  },
+}
+
+function makeDevice(config: Record<string, unknown> = {}) {
+  return new WaterDetectorDevice(
+    { id: 'wd1', type: 'waterdetector', name: 'Fridge', log: mockLogger, blePollingEnabled: false },
+    { log: mockLogger, openApiToken: 'token', openApiSecret: 'secret', ...config } as any,
+  )
+}
+
+function getBatteryService(device: WaterDetectorDevice) {
+  const accessory = device.createHAPAccessory(mockApi)
+  return accessory.services.find((service: any) => service.type === 'Battery')
+}
+
+describe('water detector device battery service', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    openApiMocks.getStatus.mockResolvedValue({ battery: 87 })
+  })
+
+  it('adds a Battery service to the HAP accessory descriptor', () => {
+    const batteryService = getBatteryService(makeDevice())
+
+    expect(batteryService).toBeDefined()
+    expect(batteryService.characteristics.BatteryLevel).toBeDefined()
+    expect(batteryService.characteristics.StatusLowBattery).toBeDefined()
+    expect(batteryService.characteristics.ChargingState).toBeDefined()
+  })
+
+  it('warms the battery cache from direct OpenAPI status', async () => {
+    const device = makeDevice()
+
+    await device.init()
+
+    const batteryService = getBatteryService(device)
+    expect(openApiMocks.OpenAPIClient).toHaveBeenCalledWith('token', 'secret')
+    expect(openApiMocks.getStatus).toHaveBeenCalledWith('wd1')
+    expect(batteryService.characteristics.BatteryLevel.get()).toBe(87)
+    expect(batteryService.characteristics.StatusLowBattery.get()).toBe(0)
+    expect(batteryService.characteristics.ChargingState.get()).toBe(2)
+  })
+
+  it('does not fabricate a battery level before one is cached', () => {
+    const device = makeDevice({ openApiSecret: undefined })
+    const batteryService = getBatteryService(device)
+
+    expect(() => batteryService.characteristics.BatteryLevel.get()).toThrow('HAP -70402')
+  })
+})

package/test/device/water-detector-leak.spec.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+
+import { WaterDetectorDevice } from '../../src/devices/genericDevice'
+
+const mockLogger = { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} }
+
+const mockApi = {
+  hap: {
+    HapStatusError: class HapStatusError extends Error {
+      constructor(public status: number) {
+        super(`HAP status ${status}`)
+      }
+    },
+    HAPStatus: {
+      SERVICE_COMMUNICATION_FAILURE: -70402,
+    },
+  },
+}
+
+describe('water detector device leak state', () => {
+  it('warms leak state and serves LeakDetected synchronously from cache', async () => {
+    let reads = 0
+    const device = new WaterDetectorDevice({ id: 'wd1', type: 'waterdetector' }, { log: mockLogger })
+    device.getState = async () => {
+      reads += 1
+      return { waterLeakDetected: true }
+    }
+
+    await device.init()
+    const leakDetected = device.createHAPAccessory(mockApi).services[0].characteristics.LeakDetected.get()
+
+    expect(leakDetected).toBe(1)
+    expect(leakDetected).not.toBeInstanceOf(Promise)
+    expect(reads).toBe(1)
+  })
+
+  it('throws a HAP communication failure instead of blocking when no leak state is cached', () => {
+    const device = new WaterDetectorDevice({ id: 'wd1', type: 'waterdetector' }, { log: mockLogger })
+    device.getState = async () => ({ waterLeakDetected: false })
+
+    expect(() => device.createHAPAccessory(mockApi).services[0].characteristics.LeakDetected.get()).toThrow('HAP status -70402')
+  })
+})