@switchbot/homebridge-switchbot 5.2.3-beta.1 → 5.2.4

package/src/devices/genericDevice.ts

@@ -67,10 +67,19 @@ export class GenericDevice extends DeviceBase {
     if (!this.log) {
       throw new Error('Device requires a logger (Homebridge logger) in opts or cfg')
     }
-    // BLE encryption key (relay switches, locks, air purifiers, bulbs): the client applies it to the
-    // node-switchbot device when that device is discovered.
-    if (opts.encryptionKey && typeof this.client?.setDeviceKey === 'function') {
-      this.client.setDeviceKey(opts.id, { encryptionKey: opts.encryptionKey, keyId: opts.keyId || undefined })
+    // If BLE encryptionKey/keyId provided, set on node-switchbot device instance if possible
+    if (opts.encryptionKey && this.client && typeof this.client.devices?.get === 'function') {
+      try {
+        const dev = this.client.devices.get(opts.id)
+        if (dev && typeof dev.setKey === 'function') {
+          dev.setKey({
+            encryptionKey: opts.encryptionKey,
+            keyId: opts.keyId || undefined,
+          })
+        }
+      } catch (e) {
+        // ignore if device not found or setKey not available
+      }
     }
     // BLE polling config: allow override via opts.blePollingEnabled/blePollIntervalMs or cfg.blePollingEnabled/blePollIntervalMs
     this._blePollingEnabled = opts?.blePollingEnabled ?? cfg?.blePollingEnabled ?? true
@@ -616,6 +625,8 @@ export class CurtainDevice extends GenericDevice {
   private lastTargetPosition = 0
   private positionState = 2
   private preferLocalPositionUntil = 0
+  private lastAdvertisement?: object
+  private positionBeforeCommand?: number
 
   private clampHomeKitPosition(position: number): number {
     return Math.max(0, Math.min(100, Math.round(Number(position))))
@@ -630,6 +641,21 @@ export class CurtainDevice extends GenericDevice {
   }
 
   private async getPositionForHomeKit(): Promise<number> {
+    const device = this.client?.getCachedDevice?.(this.opts.id)
+    if (device?.hasBLE?.()) {
+      const advertisement = device.getInfo?.()?.bleServiceData
+      if (advertisement && advertisement !== this.lastAdvertisement) {
+        this.lastAdvertisement = advertisement
+        if (typeof advertisement.position === 'number' && Number.isFinite(advertisement.position)) {
+          const position = this.toHomeKitPosition(advertisement.position)
+          if (this.positionBeforeCommand === undefined || position !== this.positionBeforeCommand) {
+            this.lastKnownPosition = position
+            this.lastTargetPosition = position
+          }
+        }
+      }
+      return this.lastKnownPosition
+    }
     if (Date.now() < this.preferLocalPositionUntil) {
       return this.lastKnownPosition
     }
@@ -637,6 +663,9 @@ export class CurtainDevice extends GenericDevice {
       this.getState(),
       new Promise(resolve => setTimeout(resolve, 1000)),
     ])
+    if (Date.now() < this.preferLocalPositionUntil) {
+      return this.lastKnownPosition
+    }
     if (typeof state?.position === 'number') {
       this.lastKnownPosition = this.toHomeKitPosition(Number(state.position))
       this.lastTargetPosition = this.lastKnownPosition
@@ -652,7 +681,8 @@ export class CurtainDevice extends GenericDevice {
           characteristics: {
             CurrentPosition: {
               get: async () => {
-                return this.getPositionForHomeKit()
+                void this.getPositionForHomeKit().catch(() => {})
+                return this.lastKnownPosition
               },
             },
             PositionState: {
@@ -660,17 +690,34 @@ export class CurtainDevice extends GenericDevice {
             },
             TargetPosition: {
               get: async () => {
-                await this.getPositionForHomeKit()
+                void this.getPositionForHomeKit().catch(() => {})
                 return this.lastTargetPosition
               },
               set: async (v: any) => {
                 const position = this.clampHomeKitPosition(Number(v))
+                const bleDevice = this.client?.getCachedDevice?.(this.opts.id)
+                if (bleDevice?.hasBLE?.()) {
+                  await this.getPositionForHomeKit()
+                }
+                const previousPosition = this.lastKnownPosition
                 this.lastTargetPosition = position
                 this.positionState = position > this.lastKnownPosition ? 1 : position < this.lastKnownPosition ? 0 : 2
-                await this.setState({ position: this.toSwitchBotPosition(position) })
-                this.lastKnownPosition = position
-                this.preferLocalPositionUntil = Date.now() + 30000
-                this.positionState = 2
+                try {
+                  const result = await this.setState({ position: this.toSwitchBotPosition(position) })
+                  if (result === false || result?.success === false) {
+                    throw new Error(result?.reason ?? 'Curtain position command failed')
+                  }
+                  this.lastKnownPosition = position
+                  if (bleDevice?.hasBLE?.()) {
+                    this.positionBeforeCommand = previousPosition
+                  }
+                  this.preferLocalPositionUntil = Date.now() + 30000
+                } catch (error) {
+                  this.lastTargetPosition = this.lastKnownPosition
+                  throw error
+                } finally {
+                  this.positionState = 2
+                }
               },
               refreshAfterSet: ['CurrentPosition', 'TargetPosition', 'PositionState'],
             },

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

@@ -149,7 +149,7 @@ export async function importDiscoveredDevice(device: any): Promise<ImportDiscove
     ['auto', 'ble', 'openapi'].forEach((val) => {
       const opt = document.createElement('option')
       opt.value = val
-      opt.text = val.charAt(0).toUpperCase() + val.slice(1)
+      opt.text = val === 'ble' ? 'BLE' : val === 'openapi' ? 'OpenAPI' : 'Auto'
       opt.selected = (device.connectionPreference || 'auto') === val
       connectionPrefSelect.appendChild(opt)
     })
@@ -568,7 +568,7 @@ export async function editDevice(device: any): Promise<void> {
   ;['auto', 'ble', 'openapi'].forEach((val) => {
     const opt = document.createElement('option')
     opt.value = val
-    opt.text = val.charAt(0).toUpperCase() + val.slice(1)
+    opt.text = val === 'ble' ? 'BLE' : val === 'openapi' ? 'OpenAPI' : 'Auto'
     opt.selected = (device.connectionPreference || 'auto') === val
     connectionPrefSelect.appendChild(opt)
   })

package/src/switchbotClient.ts

@@ -12,28 +12,14 @@ export interface ISwitchBotClient {
   getDevice: (id: string) => Promise<any>
   getDevices: () => Promise<any[]>
   setDeviceState: (id: string, body: any) => Promise<any>
-  setDeviceKey?: (id: string, key: DeviceKey) => void
   destroy: () => Promise<void>
 }
 
-/** BLE encryption key for a device (relay switches, locks, air purifiers, bulbs...) */
-export interface DeviceKey {
-  encryptionKey: string
-  keyId?: string
-}
-
 /**
  * Thin wrapper around node-switchbot v4.0.0+
  * Leverages upstream resilience features (retry, circuit breaker, connection intelligence)
  * while maintaining plugin-specific features like write debouncing and OpenAPI fallback.
  */
-const APPLIED_KEY = Symbol('appliedDeviceKey')
-
-/** Compare ids case-insensitively and without MAC separators */
-function normalizeDeviceId(id: string): string {
-  return String(id).replace(/[:-]/g, '').toLowerCase()
-}
-
 export class SwitchBotClient implements ISwitchBotClient {
   private cfg: SwitchBotPluginConfig
   private client: SwitchBot | null = null
@@ -41,8 +27,6 @@ export class SwitchBotClient implements ISwitchBotClient {
   private discoveryCacheTtlMs = 30_000
   private lastDiscoveryAt = 0
   private discoveryInFlight?: Promise<any[]>
-  /** Keys by device id, applied to the node-switchbot device whenever it is looked up */
-  private deviceKeys = new Map<string, DeviceKey>()
   private logger: import('homebridge').Logger
   private pendingWrites: Map<string, { timer: any, body: any, resolvers: Array<{ resolve: (v: any) => void, reject: (e: any) => void }> }> = new Map()
 
@@ -90,41 +74,7 @@ export class SwitchBotClient implements ISwitchBotClient {
     }
   }
 
-  /**
-   * Set the BLE encryption key for a device. The node-switchbot device may not exist yet (it is
-   * created by discovery), so the key is kept and applied each time the device is looked up.
-   */
-  setDeviceKey(id: string, key: DeviceKey): void {
-    if (!id || !key?.encryptionKey) {
-      return
-    }
-    this.deviceKeys.set(normalizeDeviceId(id), key)
-    this.applyDeviceKey(this.getManagedDevice(id))
-  }
-
-  private applyDeviceKey(device: any): any {
-    if (!device || typeof device.setKey !== 'function' || this.deviceKeys.size === 0) {
-      return device
-    }
-    const info = typeof device.getInfo === 'function' ? device.getInfo() : device
-    const ids = [device.id, info?.id, info?.mac, info?.address, info?.deviceId].filter(Boolean).map(normalizeDeviceId)
-    const key = ids.map(i => this.deviceKeys.get(i)).find(Boolean)
-    if (key && device[APPLIED_KEY] !== key) {
-      try {
-        device.setKey({ encryptionKey: key.encryptionKey, keyId: key.keyId || undefined })
-        device[APPLIED_KEY] = key
-      } catch (e: any) {
-        this.logger?.warn?.(`[${device.id}] Invalid BLE encryption key: ${e?.message ?? e}`)
-      }
-    }
-    return device
-  }
-
   async getDevice(id: string): Promise<any> {
-    return this.applyDeviceKey(await this.findDevice(id))
-  }
-
-  private async findDevice(id: string): Promise<any> {
     if (this.client) {
       try {
         const fromManager = this.getManagedDevice(id)
@@ -159,12 +109,18 @@ export class SwitchBotClient implements ISwitchBotClient {
     throw new SwitchbotOperationError('No SwitchBot client available', 'no_client')
   }
 
+  getCachedDevice(id: string): any {
+    return this.getManagedDevice(id)
+  }
+
   async getDevices(): Promise<any[]> {
     if (this.client) {
       try {
         const fromManager = this.getManagedDevices()
-        const devices = fromManager.length > 0 ? fromManager : await this.ensureDiscovered(false)
-        return devices.map(device => this.applyDeviceKey(device))
+        if (fromManager.length > 0) {
+          return fromManager
+        }
+        return await this.ensureDiscovered(false)
       } catch (e) {
         this.logger?.warn?.('Client getDevices failed:', e)
         throw e

package/test/device/curtain-ble-position.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { CurtainDevice } from '../../src/devices/genericDevice'
+
+describe('curtain BLE position', () => {
+  it('keeps a commanded position when an old advertisement reappears', async () => {
+    let advertisement = { position: 39 }
+    const nodeDevice = {
+      hasBLE: () => true,
+      getInfo: () => ({ bleServiceData: advertisement }),
+    }
+    const client = { getCachedDevice: () => nodeDevice }
+    const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+    const curtain = new CurtainDevice({ id: 'curtain', type: 'Curtain', log, blePollingEnabled: false }, { _client: client, log } as any)
+    const getState = vi.spyOn(curtain, 'getState')
+    vi.spyOn(curtain, 'setState').mockResolvedValue(true)
+    const characteristics = curtain.createHAPAccessory({}).services[0].characteristics
+
+    expect(await characteristics.CurrentPosition.get()).toBe(61)
+    await characteristics.TargetPosition.set(69)
+    expect(await characteristics.CurrentPosition.get()).toBe(69)
+
+    advertisement = { position: 39 }
+    expect(await characteristics.CurrentPosition.get()).toBe(69)
+    expect(await characteristics.TargetPosition.get()).toBe(69)
+
+    advertisement = { position: 31 }
+    expect(await characteristics.CurrentPosition.get()).toBe(69)
+
+    advertisement = { position: 39 }
+    expect(await characteristics.CurrentPosition.get()).toBe(69)
+    expect(getState).not.toHaveBeenCalled()
+  })
+})

package/.github/npm-version-script-esm.js

@@ -1,103 +0,0 @@
-#!/bin/env node
-
-/**
- * This scripts queries the npm registry to pull out the latest version for a given tag.
- */
-
-import assert from 'node:assert'
-import child_process from 'node:child_process'
-import fs from 'node:fs'
-import process from 'node:process'
-
-const BRANCH_VERSION_PATTERN = /^([A-Z]+)-(\d+\.\d+\.\d+)$/i
-
-// Load the contents of the package.json file
-const packageJSON = JSON.parse(fs.readFileSync('package.json', 'utf8'))
-
-const refArgument = process.argv[2]
-const tagArgument = process.argv[3] || 'latest'
-
-if (!refArgument) {
-  console.error('ref argument is missing')
-  console.error('Usage: npm-version-script-esm.js <ref> [tag]')
-  process.exit(1)
-}
-
-/**
- * Queries the NPM registry for the latest version for the provided base version and tag.
- * If the tag is latest, then the base version is returned if it exists. For other tags, the latest
- * version found for that base version and tag is returned.
- * @param baseVersion The base version to query for, e.g. 2.0.0
- * @param tag The tag to query for, e.g. beta or latest
- * @returns {string} Returns the version, or '' if not found
- */
-function getTagVersionFromNpm(baseVersion, tag) {
-  try {
-    return JSON.parse(child_process.execSync(`npm info ${packageJSON.name} versions --json`).toString('utf8').trim())
-      // find all published versions for this base version and tag
-      .filter(v => tag === 'latest'
-        ? v === baseVersion
-        : v.startsWith(`${baseVersion}-${tag}.`))
-      .reduce((_, current) => current, '') // choose the last as they're sorted in ascending order, or '' if there are none
-  } catch (e) {
-    console.error(`Failed to query the npm registry for the latest version for tag: ${tag}`, e)
-    // throw e;
-    return ''
-  }
-}
-
-function desiredTargetVersion(ref) {
-  // ref is a GitHub action ref string
-  if (ref.startsWith('refs/pull/')) {
-    throw new Error('The version script was executed inside a PR!')
-  }
-
-  assert(ref.startsWith('refs/heads/'))
-  const branchName = ref.slice('refs/heads/'.length)
-
-  const results = branchName.match(BRANCH_VERSION_PATTERN)
-  if (results !== null) {
-    if (results[1] !== tagArgument) {
-      console.warn(`The base branch name (${results[1]}) differs from the tag name ${tagArgument}`)
-    }
-
-    return results[2]
-  }
-
-  throw new Error(`Malformed branch name for ref: ${ref}. Can't derive the base version. Use a branch name like: beta-x.x.x or alpha-x.x.x`)
-}
-
-// derive the base version from the branch ref
-const baseVersion = desiredTargetVersion(refArgument)
-
-// query the npm registry for the latest version of the provided tag name
-const latestReleasedVersion = getTagVersionFromNpm(baseVersion, tagArgument) // e.g. 0.7.0-beta.12
-
-let publishTag
-
-if (latestReleasedVersion) {
-  console.warn(`Latest published version for ${baseVersion} with tag ${tagArgument} is ${latestReleasedVersion}`)
-  publishTag = latestReleasedVersion // set this released beta or alpha to be incremented
-} else {
-  console.warn(`No published versions for ${baseVersion} with tag ${tagArgument}`)
-  publishTag = baseVersion // start off with a new beta or alpha version
-}
-
-if (packageJSON.version !== publishTag) {
-  // report the change for CI
-  console.warn(`Changing version in package.json from ${packageJSON.version} to ${publishTag}`)
-
-  // save the package.json
-  // JSON.stringify does not end with a newline, but npm writes both of these
-  // files with one. Leaving it off makes the file fail an eol-last lint rule,
-  // which breaks any repo whose prepublishOnly lints the whole tree.
-  packageJSON.version = publishTag
-  fs.writeFileSync('package.json', `${JSON.stringify(packageJSON, null, 2)}\n`)
-
-  // perform the same change to the package-lock.json
-  const packageLockJSON = JSON.parse(fs.readFileSync('package-lock.json', 'utf8'))
-  packageLockJSON.version = publishTag
-  fs.writeFileSync('package-lock.json', `${JSON.stringify(packageLockJSON, null, 2)}\n`)
-} else {
-  console.warn(`Leaving version in package.json at ${packageJSON.version}`)
-}

package/test/client/switchbot-client-keys.spec.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { SwitchBotClient } from '../../src/switchbotClient'
-
-const logger = { info: () => {}, warn: vi.fn(), error: () => {}, debug: () => {} }
-
-function client(devices: any[]) {
-  const c = new SwitchBotClient({ logger } as any)
-  ;(c as any).client = {
-    discover: vi.fn(async () => devices),
-    devices: { get: (id: string) => devices.find(d => d.id === id), list: () => devices },
-  }
-  return c
-}
-
-function device(id: string, mac?: string) {
-  return { id, setKey: vi.fn(), getInfo: () => ({ id, mac }) }
-}
-
-// genericDevice used to call client.devices.get(), which the plugin's client wrapper does not have,
-// so BLE encryption keys were never passed to node-switchbot.
-describe('switchBotClient device keys', () => {
-  it('applies a key set before the device is discovered', async () => {
-    const devices: any[] = []
-    const c = client(devices)
-    c.setDeviceKey('AA:BB:CC:DD:EE:FF', { encryptionKey: '0'.repeat(32), keyId: 'ab' })
-    const relay = device('aabbccddeeff', 'AA:BB:CC:DD:EE:FF')
-    devices.push(relay)
-    await c.getDevice('aabbccddeeff')
-    expect(relay.setKey).toHaveBeenCalledWith({ encryptionKey: '0'.repeat(32), keyId: 'ab' })
-  })
-
-  it('applies a key immediately when the device already exists, and only once', async () => {
-    const relay = device('relay-1')
-    const c = client([relay])
-    c.setDeviceKey('relay-1', { encryptionKey: '1'.repeat(32), keyId: '01' })
-    await c.getDevice('relay-1')
-    await c.getDevices()
-    expect(relay.setKey).toHaveBeenCalledOnce()
-  })
-
-  it('logs and continues when node-switchbot rejects the key', async () => {
-    const relay = device('relay-2')
-    relay.setKey.mockImplementation(() => {
-      throw new Error('bad key')
-    })
-    const c = client([relay])
-    c.setDeviceKey('relay-2', { encryptionKey: 'nope' })
-    await expect(c.getDevice('relay-2')).resolves.toBe(relay)
-    expect(logger.warn).toHaveBeenCalled()
-  })
-
-  it('leaves devices without setKey (node-switchbot 5.x) alone', async () => {
-    const plain = { id: 'plain' }
-    const c = client([plain])
-    c.setDeviceKey('plain', { encryptionKey: '2'.repeat(32) })
-    await expect(c.getDevice('plain')).resolves.toBe(plain)
-  })
-})

package/test/platform/matter-registration.spec.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { SwitchBotMatterPlatform } from '../../src/SwitchBotMatterPlatform.js'
-
-function makeApi(failFor?: string) {
-  const registered = new Set<string>()
-  const matter = {
-    uuid: { generate: (id: string) => `uuid-${id}` },
-    deviceTypes: {},
-    registerPlatformAccessories: vi.fn(async (_p: string, _n: string, accessories: any[]) => {
-      for (const a of accessories) {
-        if (a.UUID === failFor) {
-          throw new Error('boom')
-        }
-        if (registered.has(a.UUID)) {
-          throw new Error(`Matter accessory with UUID ${a.UUID} is already registered`)
-        }
-        registered.add(a.UUID)
-      }
-    }),
-    updatePlatformAccessories: vi.fn(async () => {}),
-    unregisterPlatformAccessories: vi.fn(async () => {}),
-  }
-  return { api: { matter, on: vi.fn() } as any, matter }
-}
-
-function created(name: string) {
-  return {
-    created: { createAccessory: async () => ({ name, clusters: { onOff: { onOff: false } } }) },
-    d: { id: name, name },
-    type: 'plug',
-    useMatter: true,
-    matterAvailable: true,
-  }
-}
-
-const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn(), success: vi.fn() } as any
-
-describe('matter accessory registration', () => {
-  it('updates instead of re-registering on a second load (config reload)', async () => {
-    const { api, matter } = makeApi()
-    const platform = new SwitchBotMatterPlatform(log, { platform: 'SwitchBot' } as any, api)
-    await platform.registerMatterAccessories([created('a')])
-    await platform.registerMatterAccessories([created('a')])
-    expect(matter.registerPlatformAccessories).toHaveBeenCalledTimes(1)
-    expect(matter.updatePlatformAccessories).toHaveBeenCalledTimes(1)
-  })
-
-  it('registers cache-restored accessories so handlers attach', async () => {
-    const { api, matter } = makeApi()
-    const platform = new SwitchBotMatterPlatform(log, { platform: 'SwitchBot' } as any, api)
-    platform.configureMatterAccessory({ UUID: 'uuid-a', displayName: 'a', context: { deviceId: 'a' }, _restoredFromCache: true })
-    await platform.registerMatterAccessories([created('a')])
-    expect(matter.registerPlatformAccessories).toHaveBeenCalledTimes(1)
-    expect(matter.registerPlatformAccessories.mock.calls[0][2][0].handlers).toBeDefined()
-  })
-
-  it('one failing accessory does not stop the others', async () => {
-    const { api, matter } = makeApi('uuid-a')
-    const platform = new SwitchBotMatterPlatform(log, { platform: 'SwitchBot' } as any, api)
-    await platform.registerMatterAccessories([created('a'), created('b')])
-    const uuids = matter.registerPlatformAccessories.mock.calls.map(c => c[2][0].UUID)
-    expect(uuids).toEqual(['uuid-a', 'uuid-b'])
-    // 'a' failed, so it is registered (not updated) on the next attempt
-    await platform.registerMatterAccessories([created('a')])
-    expect(matter.registerPlatformAccessories).toHaveBeenCalledTimes(3)
-  })
-})