@homebridge-plugins/homebridge-govee 10.12.1

package/eslint.config.js

@@ -0,0 +1,49 @@
+import { antfu } from '@antfu/eslint-config'
+
+/** @type {typeof antfu} */
+export default antfu(
+  {
+    ignores: [],
+    jsx: false,
+    rules: {
+      'curly': ['error', 'multi-line'],
+      'new-cap': 'off',
+      'import/extensions': ['error', 'ignorePackages'],
+      'import/order': 0,
+      'jsdoc/check-alignment': 'warn',
+      'jsdoc/check-line-alignment': 'warn',
+      'jsdoc/require-returns-check': 0,
+      'jsdoc/require-returns-description': 0,
+      'no-undef': 'error',
+      'perfectionist/sort-exports': 'error',
+      'perfectionist/sort-imports': [
+        'error',
+        {
+          groups: [
+            'type',
+            'internal-type',
+            'builtin',
+            'external',
+            'internal',
+            ['parent-type', 'sibling-type', 'index-type'],
+            ['parent', 'sibling', 'index'],
+            'object',
+            'unknown',
+          ],
+          order: 'asc',
+          type: 'natural',
+        },
+      ],
+      'perfectionist/sort-named-exports': 'error',
+      'perfectionist/sort-named-imports': 'error',
+      'quotes': ['error', 'single'],
+      'sort-imports': 0,
+      'style/brace-style': ['error', '1tbs', { allowSingleLine: true }],
+      'style/quote-props': ['error', 'consistent-as-needed'],
+      'test/no-only-tests': 'error',
+      'unicorn/no-useless-spread': 'error',
+      'unused-imports/no-unused-vars': ['error', { caughtErrors: 'none' }],
+    },
+    typescript: false,
+  },
+)

package/lib/connection/aws.js

@@ -0,0 +1,174 @@
+import { Buffer } from 'node:buffer'
+import { resolve } from 'node:path'
+import url from 'node:url'
+
+import { device as iotDevice } from 'aws-iot-device-sdk'
+
+import { parseError } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+const dirname = url.fileURLToPath(new URL('.', import.meta.url))
+
+export default class {
+  constructor(platform, iotFile) {
+    this.accountTopic = platform.accountTopic
+
+    this.device = iotDevice({
+      privateKey: Buffer.from(iotFile.key, 'utf8'),
+      clientCert: Buffer.from(iotFile.cert, 'utf8'),
+      caPath: resolve(dirname, './cert/AmazonRootCA1.pem'),
+      clientId: `AP/${platform.accountId}/${platform.clientId}`,
+      host: platform.iotEndpoint,
+      enableMetrics: false,
+    })
+
+    // A listener event for if the connection closes
+    this.device.on('close', () => {
+      platform.log.debugWarn('[AWS] %s.', platformLang.awsEventClose)
+      this.connected = false
+    })
+
+    // A listener event for if the connection reconnects
+    this.device.on('reconnect', () => {
+      platform.log.debug('[AWS] %s.', platformLang.awsEventReconnect)
+      this.connected = true
+    })
+
+    // A listener event for if the connection goes offline
+    this.device.on('offline', () => {
+      platform.log.debugWarn('[AWS] %s.', platformLang.awsEventOffline)
+      this.connected = false
+    })
+
+    // A listener event for if the connection creates an error
+    this.device.on('error', (error) => {
+      platform.log.debugWarn('[AWS] %s [%s].', platformLang.awsEventError, parseError(error))
+      this.connected = false
+    })
+
+    // A listener event for receiving a message
+    this.device.on('message', (topic, payload) => {
+      const payloadString = Buffer.from(payload).toString()
+
+      // Parse the message to JSON
+      try {
+        payload = JSON.parse(payloadString)
+      } catch (error) {
+        platform.log.debugWarn('[AWS] %s [%s].', platformLang.invalidJson, payloadString)
+        return
+      }
+
+      // Older models may have the message in a msg property
+      if (payload.msg) {
+        try {
+          payload = JSON.parse(payload.msg)
+        } catch (error) {
+          platform.log.debugWarn('[AWS] %s [%s].', platformLang.invalidJson, payloadString)
+          return
+        }
+      }
+
+      // Also JSON parse any data property that may exist, do not throw on error
+      if (payload.data && typeof payload.data === 'string') {
+        try {
+          payload.data = JSON.parse(payload.data)
+        } catch (error) {
+          // Do nothing, leave as string
+        }
+      }
+
+      // Log the received message if debug is enabled
+      platform.log.debug('[AWS] %s [%s].', platformLang.awsEventMessage, payloadString)
+
+      // Send the update to the receiver function
+      platform.receiveUpdateAWS(payload)
+    })
+
+    // A listener event for when the connection is created
+    this.device.on('connect', () => {
+      platform.log.debug('[AWS] %s.', platformLang.awsEventConnect)
+      this.connected = true
+    })
+  }
+
+  async connect() {
+    return new Promise((res, rej) => {
+      this.device.subscribe(this.accountTopic, {}, (err) => {
+        if (err) {
+          rej(err)
+        } else {
+          res()
+        }
+      })
+    })
+  }
+
+  async requestUpdate(accessory) {
+    // Check if we are connected before attempting an update
+    if (!this.connected) {
+      throw new Error(platformLang.notAWSConn)
+    }
+
+    // Generate the AWS payload
+    const payload = {
+      msg: {
+        cmd: 'status',
+        cmdVersion: 2,
+        transaction: `v_${Date.now()}000`,
+        type: 0,
+      },
+    }
+
+    // Log the update if accessory debug is enabled
+    accessory.logDebug(`[AWS] ${platformLang.sendingUpdate} ${JSON.stringify(payload)}`)
+
+    // Add the account topic after logging
+    payload.msg.accountTopic = this.accountTopic
+
+    // Send the update over AWS
+    return new Promise((res, rej) => {
+      this.device.publish(accessory.context.awsTopic, JSON.stringify(payload), {}, (err) => {
+        if (err) {
+          rej(err)
+        } else {
+          res()
+        }
+      })
+    })
+  }
+
+  async updateDevice(accessory, params) {
+    // Check if we are connected before attempting an update
+    if (!this.connected) {
+      throw new Error(platformLang.notAWSConn)
+    }
+
+    // Generate the AWS payload
+    const payload = {
+      msg: {
+        cmd: params.cmd,
+        cmdVersion: 0,
+        data: params.data,
+        transaction: `v_${Date.now()}000`,
+        type: 1,
+      },
+    }
+
+    // Log the update if accessory debug is enabled
+    accessory.logDebug(`[AWS] ${platformLang.sendingUpdate} ${JSON.stringify(payload)}`)
+
+    // Add the account topic after logging
+    payload.msg.accountTopic = this.accountTopic
+
+    // Send the update over AWS
+    return new Promise((res, rej) => {
+      this.device.publish(accessory.context.awsTopic, JSON.stringify(payload), {}, (err) => {
+        if (err) {
+          rej(err)
+        } else {
+          res()
+        }
+      })
+    })
+  }
+}

package/lib/connection/ble.js

@@ -0,0 +1,208 @@
+import { Buffer } from 'node:buffer'
+
+import btClient from '@abandonware/noble'
+
+import {
+  base64ToHex,
+  generateCodeFromHexValues,
+  hexToTwoItems,
+  sleep,
+} from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+/*
+  The necessary commands to send and functions are taken from and credit to:
+  https://www.npmjs.com/package/govee-led-client
+*/
+
+export default class {
+  constructor(platform) {
+    this.connectedTo = false
+    this.log = platform.log
+    this.platform = platform
+    this.stateChange = false
+
+    // Can only scan/connect/send if the noble stateChange is 'poweredOn'
+    btClient.on('stateChange', (state) => {
+      this.stateChange = state
+      this.log.debug('[BLE] stateChange: %s.', state)
+    })
+
+    // Event listener for noble scanning start
+    btClient.on('scanStart', () => {
+      this.log.debug('[BLE] %s.', platformLang.bleStart)
+    })
+
+    // Event listener for noble scanning stop
+    btClient.on('scanStop', () => {
+      this.log.debug('[BLE] %s.', platformLang.bleStop)
+    })
+
+    // Event and log noble warnings
+    btClient.on('warning', (message) => {
+      this.log.debugWarn('[BLE] %s.', message)
+    })
+
+    // Event handler for discovering bluetooth devices
+    // This should only be each and every time a device update is sent
+    btClient.on('discover', (device) => {
+      // Log the address found can be useful for debugging what's working
+      this.log.debug('[BLE] found device [%s] [%s].', device.address, device.advertisement.localName)
+
+      // Look for the device to update at the time
+      if (!this.accessory || this.accessory.context.bleAddress !== device.address) {
+        return
+      }
+
+      // Found the device so stop scanning
+      btClient.stopScanning()
+
+      // Make the device global as needed in other functions
+      this.device = device
+
+      // Log that the device has been discovered
+      this.accessory.logDebug(platformLang.onlineBT)
+
+      // Remove previous listeners that may still be intact
+      this.device.removeAllListeners()
+
+      // Add a listener for device disconnect
+      this.device.on('disconnect', (reason) => {
+        // Log the disconnection
+        if (this.accessory) {
+          this.accessory.logDebug(`${platformLang.offlineBTConn} [${reason || 'unknown'}]`)
+        } else {
+          this.log.debug(
+            '[BLE] [%s] %s [%s].',
+            this.device ? this.device.address : 'unknown',
+            platformLang.offlineBTConn,
+            reason || 'unknown',
+          )
+        }
+
+        // Un-define the variables used within the class
+        this.device = undefined
+        this.connectedTo = false
+        this.controlChar = undefined
+        this.accessory = undefined
+      })
+
+      // Reset adapter
+      btClient.reset()
+
+      // Connect to the device
+      this.accessory.logDebug('attempting to connect')
+      this.device.connect((error) => {
+        if (error) {
+          this.accessory.logWarn(`could not connect as ${error}`)
+          return
+        }
+        // Update the currently-connect-to variable
+        this.connectedTo = this.accessory.context.bleAddress
+
+        // Log the connection
+        this.accessory.logDebug(platformLang.onlineBTConn)
+
+        // Find the noble characteristic we need for controlling the device
+        this.accessory.logDebug('finding device characteristics')
+        device.discoverAllServicesAndCharacteristics((error2, services, characteristics) => {
+          if (error2) {
+            this.accessory.logWarn(`could not find device characteristics as ${error2}`)
+            return
+          }
+          this.accessory.logDebug('found some device characteristics')
+          Object.values(characteristics).forEach((char) => {
+            // Make sure we found the characteristic and make it global for the sendUpdate function
+            const formattedChar = char.uuid.replace(/-/g, '')
+            if (formattedChar === '000102030405060708090a0b0c0d2b11') {
+              this.controlChar = char
+              this.accessory.logDebug(`found correct characteristic [${formattedChar}]`)
+            } else {
+              this.accessory.logDebug(`found different characteristic [${formattedChar}]`)
+            }
+          })
+          if (!this.controlChar) {
+            this.accessory.logWarn('could not find control characteristic')
+          }
+        })
+      })
+    })
+  }
+
+  async updateDevice(accessory, params) {
+    // This is called by the platform on sending a device update via bluetooth
+    accessory.logDebug(`starting update with params [${JSON.stringify(params)}]`)
+
+    // Check the noble state is ready for bluetooth action
+    if (this.stateChange !== 'poweredOn') {
+      throw new Error(`${platformLang.bleWrongState} [${this.stateChange}]`)
+    }
+
+    // This is used to time out the request later on if it's taking too much time
+    // 7 seconds, to take into account AWS control failing as well as the ~10 second HK limit
+    let doIt = true
+    accessory.logDebug('starting timer')
+    setTimeout(() => {
+      doIt = false
+    }, 7000)
+
+    // Check if we are already connected to a device - and disconnect
+    if (this.device) {
+      if (this.connectedTo && this.connectedTo !== accessory.context.bleAddress) {
+        accessory.logDebug(`disconnecting from [${this.connectedTo}] to connect to [${accessory.context.bleAddress}]`)
+        await this.device.disconnectAsync()
+        accessory.logDebug('disconnect successful')
+      }
+    }
+
+    // Make global the accessory in question which we are sending an update to
+    this.accessory = accessory
+
+    // Start the bluetooth scan to discover this accessory
+    // Service UUID for future reference 000102030405060708090a0b0c0d1910
+    accessory.logDebug('starting scan')
+    await btClient.startScanningAsync()
+    accessory.logDebug('scanning started')
+
+    // We want to wait for the .on('discover') function to find the accessory and the characteristic
+    accessory.logDebug('starting loop')
+
+    while (true) {
+      if (!doIt) {
+        accessory.logWarn(`could not find device [${accessory.context.bleAddress}]`)
+        throw new Error(platformLang.bleTimeout)
+      }
+
+      // Once the characteristic (this.controlChar) has been found then break the loop
+      if (this.connectedTo === accessory.context.bleAddress && this.controlChar) {
+        accessory.logDebug('found correct characteristic so breaking loop')
+        break
+      }
+
+      // Repeat this process every 200ms until the characteristic is available
+      await sleep(200)
+    }
+
+    // We can be sent either:
+    // - a base64 action code (with params.cmd === 'ptReal')
+    // - an array containing a varied amount of already-hex values
+    const finalBuffer = params.cmd === 'ptReal'
+      ? Buffer.from(hexToTwoItems(base64ToHex(params.data)).map(byte => `0x${byte}`))
+      : generateCodeFromHexValues([0x33, params.cmd, params.data], true)
+
+    // Log the request if in debug mode
+    accessory.logDebug(`[BLE] ${platformLang.sendingUpdate} [${finalBuffer.toString('hex')}]`)
+
+    // Send the data to the device
+    await this.controlChar.writeAsync(finalBuffer, true)
+
+    // Maybe a slight await here helps (for an unknown reason)
+    await sleep(100)
+
+    // Disconnect from device
+    await this.device.disconnectAsync()
+
+    // Maybe a slight await here helps (for an unknown reason)
+    await sleep(100)
+  }
+}

package/lib/connection/cert/AmazonRootCA1.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj
+ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM
+9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw
+IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6
+VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L
+93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm
+jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA
+A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI
+U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs
+N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv
+o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU
+5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy
+rqXRfboQnoZsG4q5WTP468SQvvG5
+-----END CERTIFICATE-----

package/lib/connection/http.js

@@ -0,0 +1,240 @@
+import { Buffer } from 'node:buffer'
+
+import axios from 'axios'
+
+import platformConsts from '../utils/constants.js'
+import { parseError, sleep } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+export default class {
+  constructor(platform) {
+    // Create variables usable by the class
+    this.log = platform.log
+    this.password = platform.config.password
+    this.token = platform.accountToken
+    this.tokenTTR = platform.accountTokenTTR
+    this.username = platform.config.username
+
+    // May need changing from time to time
+    this.appVersion = '5.6.01'
+    this.userAgent = `GoveeHome/${this.appVersion} (com.ihoment.GoVeeSensor; build:2; iOS 16.5.0) Alamofire/5.6.4`
+
+    // Create a client id generated from Govee username which should remain constant
+    let clientSuffix = platform.api.hap.uuid.generate(this.username).replace(/-/g, '') // 32 chars
+    clientSuffix = clientSuffix.substring(0, clientSuffix.length - 2) // 30 chars
+    this.clientId = `hb${clientSuffix}` // 32 chars
+  }
+
+  async login() {
+    try {
+      // Perform the HTTP request
+      const res = await axios({
+        url: 'https://app2.govee.com/account/rest/account/v1/login',
+        method: 'post',
+        data: {
+          email: this.username,
+          password: this.password,
+          client: this.clientId,
+        },
+        timeout: 30000,
+      })
+
+      // Check to see we got a response
+      if (!res.data) {
+        throw new Error(platformLang.noToken)
+      }
+
+      // Check to see we got a needed response
+      if (!res.data.client || !res.data.client.token) {
+        if (res.data.message && res.data.message.replace(/\s+/g, '') === 'Incorrectpassword') {
+          if (this.base64Tried) {
+            throw new Error(res.data.message || platformLang.noToken)
+          } else {
+            this.base64Tried = true
+            this.password = Buffer.from(this.password, 'base64')
+              .toString('utf8')
+              .replace(/\r\n|\n|\r/g, '')
+              .trim()
+            return await this.login()
+          }
+        }
+        throw new Error(res.data.message || platformLang.noToken)
+      }
+
+      // Also grab an access token specifically for the get tap to run endpoint
+      const ttrRes = await axios({
+        url: 'https://community-api.govee.com/os/v1/login',
+        method: 'post',
+        data: {
+          email: this.username,
+          password: this.password,
+        },
+        timeout: 30000,
+      })
+
+      // Make the token available in other functions
+      this.token = res.data.client.token
+      this.tokenTTR = ttrRes.data.data.token
+
+      // Mark this request complete if in debug mode
+      this.log.debug('[HTTP] %s.', platformLang.loginSuccess)
+
+      // Also grab the iot data
+      const iotRes = await axios({
+        url: 'https://app2.govee.com/app/v1/account/iot/key',
+        method: 'get',
+        headers: {
+          'Authorization': `Bearer ${this.token}`,
+          'appVersion': this.appVersion,
+          'clientId': this.clientId,
+          'clientType': 1,
+          'iotVersion': 0,
+          'timestamp': Date.now(),
+          'User-Agent': this.userAgent,
+        },
+      })
+
+      // Return the account token and topic for AWS
+      return {
+        accountId: res.data.client.accountId,
+        client: this.clientId,
+        endpoint: iotRes.data.data.endpoint,
+        iot: iotRes.data.data.p12,
+        iotPass: iotRes.data.data.p12Pass,
+        token: res.data.client.token,
+        tokenTTR: this.tokenTTR,
+        topic: res.data.client.topic,
+      }
+    } catch (err) {
+      if (err.code && platformConsts.httpRetryCodes.includes(err.code)) {
+        // Retry if another attempt could be successful
+        this.log.warn('[HTTP] %s [login() - %s].', platformLang.httpRetry, err.code)
+        await sleep(30000)
+        return this.login()
+      }
+      throw err
+    }
+  }
+
+  async logout() {
+    try {
+      await axios({
+        url: 'https://app2.govee.com/account/rest/account/v1/logout',
+        method: 'post',
+        headers: {
+          'Authorization': `Bearer ${this.token}`,
+          'appVersion': this.appVersion,
+          'clientId': this.clientId,
+          'clientType': 1,
+          'iotVersion': 0,
+          'timestamp': Date.now(),
+          'User-Agent': this.userAgent,
+        },
+      })
+    } catch (err) {
+      // Logout is only called on homebridge shutdown, so we can just log the error
+      this.log.warn('[HTTP] %s %s.', platformLang.logoutFail, parseError(err))
+    }
+  }
+
+  async getDevices(isSync = true) {
+    try {
+      // Make sure we do have the account token
+      if (!this.token) {
+        throw new Error(platformLang.noTokenExists)
+      }
+
+      // Use the token received to get a device list
+      const res = await axios({
+        url: 'https://app2.govee.com/device/rest/devices/v1/list',
+        method: 'post',
+        headers: {
+          'Authorization': `Bearer ${this.token}`,
+          'appVersion': this.appVersion,
+          'clientId': this.clientId,
+          'clientType': 1,
+          'iotVersion': 0,
+          'timestamp': Date.now(),
+          'User-Agent': this.userAgent,
+        },
+        timeout: 30000,
+      })
+
+      // Check to see we got a response
+      if (!res.data || !res.data.devices) {
+        throw new Error(platformLang.noDevices)
+      }
+
+      // Return the device list
+      return res.data.devices || []
+    } catch (err) {
+      if (!isSync && err.code && platformConsts.httpRetryCodes.includes(err.code)) {
+        // Retry if another attempt could be successful (only on init, not sync)
+        this.log.warn('[HTTP] %s [getDevices() - %s].', platformLang.httpRetry, err.code)
+        await sleep(30000)
+        return this.getDevices()
+      }
+      throw err
+    }
+  }
+
+  async getTapToRuns() {
+    // Build and send the request
+    const res = await axios({
+      url: 'https://app2.govee.com/bff-app/v1/exec-plat/home',
+      method: 'get',
+      headers: {
+        'Authorization': `Bearer ${this.tokenTTR}`,
+        'appVersion': this.appVersion,
+        'clientId': this.clientId,
+        'clientType': 1,
+        'iotVersion': 0,
+        'timestamp': Date.now(),
+        'User-Agent': this.userAgent,
+      },
+      timeout: 10000,
+    })
+
+    // Check to see we got a response
+    if (!res?.data?.data?.components) {
+      throw new Error('not a valid response')
+    }
+
+    return res.data.data.components
+  }
+
+  async getLeakDeviceWarning(deviceId, deviceSku) {
+    // Make sure we do have the account token
+    if (!this.token) {
+      throw new Error(platformLang.noTokenExists)
+    }
+
+    // Build and send the request
+    const res = await axios({
+      url: 'https://app2.govee.com/leak/rest/device/v1/warnMessage',
+      method: 'post',
+      headers: {
+        'Authorization': `Bearer ${this.token}`,
+        'appVersion': this.appVersion,
+        'clientId': this.clientId,
+        'clientType': 1,
+        'iotVersion': 0,
+        'timestamp': Date.now(),
+        'User-Agent': this.userAgent,
+      },
+      data: {
+        device: deviceId.replaceAll(':', ''),
+        limit: 50,
+        sku: deviceSku,
+      },
+      timeout: 10000,
+    })
+
+    // Check to see we got a response
+    if (!res?.data?.data) {
+      throw new Error(platformLang.noDevices)
+    }
+
+    return res.data.data
+  }
+}