@homebridge-plugins/homebridge-meross 10.8.0

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/http.js

@@ -0,0 +1,345 @@
+import { Buffer } from 'node:buffer'
+import { createHash } from 'node:crypto'
+
+import axios from 'axios'
+
+import platformConsts from '../utils/constants.js'
+import {
+  encodeParams,
+  generateRandomString,
+  hasProperty,
+  parseError,
+  sleep,
+} from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+export default class {
+  constructor(platform) {
+    this.devLoginRetried = false
+    this.domain = platform.accountDetails.domain || platform.config.domain
+    this.ignoredDevices = platform.ignoredDevices
+    this.ignoreHKNative = platform.config.ignoreHKNative
+    this.ignoreMatter = platform.config.ignoreMatter
+    this.key = platform.accountDetails.key
+    this.log = platform.log
+    this.mfaCode = platform.config.mfaCode
+    this.password = platform.config.password
+    this.showUserKey = platform.config.showUserKey
+    this.storageData = platform.storageData
+    this.token = platform.accountDetails.token
+    this.userId = platform.accountDetails.userId
+    this.username = platform.config.username
+    this.userkey = platform.config.userkey
+
+    this.requestHeaders = {
+      'AppLanguage': 'en',
+      'AppType': 'iOS',
+      'AppVersion': '3.22.4',
+      'Vendor': 'meross',
+      'User-Agent': 'intellect_socket/3.22.4 (iPhone; iOS 17.2; Scale/2.00)',
+    }
+
+    // Common error codes
+    // https://github.com/Apollon77/meross-cloud/blob/master/lib/errorcodes.js
+    // 500: 'The selected timezone is not supported',
+    // 1001: 'Wrong or missing password',
+    // 1002: 'Account does not exist',
+    // 1003: 'This account has been disabled or deleted',
+    // 1004: 'Wrong email or password',
+    // 1005: 'Invalid email address',
+    // 1006: 'Bad password format',
+    // 1008: 'This email is not registered',
+    // 1019: 'Token expired',
+    // 1022: some issue with token
+    // 1030: wrong region
+    // 1032: missing mfa
+    // 1033: invalid mfa
+    // 1200: 'Token has expired',
+    // 1255: 'The number of remote control boards exceeded the limit',
+    // 1301: 'Too many tokens have been issued',
+    // 5000: 'Unknown or generic error',
+    // 5001: 'Unknown or generic error',
+    // 5002: 'Unknown or generic error',
+    // 5003: 'Unknown or generic error',
+    // 5004: 'Unknown or generic error',
+    // 5020: 'Infrared Remote device is busy',
+    // 5021: 'Infrared record timeout',
+    // 5022: 'Infrared record invalid'
+  }
+
+  async login() {
+    try {
+      const nonce = generateRandomString(16)
+      const timestampMillis = Date.now()
+      const loginParams = encodeParams({
+        email: this.username,
+        password: createHash('md5')
+          .update(this.password)
+          .digest('hex'),
+        encryption: 1,
+        accountCountryCode: '--',
+        mobileInfo: {
+          resolution: '--',
+          carrier: '--',
+          deviceModel: '--',
+          mobileOs: '--',
+          mobileOSVersion: '--',
+          uuid: '--',
+        },
+        agree: 1,
+        mfaCode: this.mfaCode || undefined,
+      })
+
+      // Generate the md5-hash (called signature)
+      const dataToSign = `23x17ahWarFH6w29${timestampMillis}${nonce}${loginParams}`
+      const md5hash = createHash('md5')
+        .update(dataToSign)
+        .digest('hex')
+
+      const res = await axios({
+        url: `https://${this.domain}/v1/Auth/signIn`,
+        method: 'post',
+        headers: {
+          Authorization: 'Basic ',
+          ...this.requestHeaders,
+        },
+        data: {
+          params: loginParams,
+          sign: md5hash,
+          timestamp: timestampMillis,
+          nonce,
+        },
+      })
+
+      // Check to see we got a response
+      if (!res.data || !res.data.data) {
+        throw new Error(platformLang.noResponse)
+      }
+
+      if (Object.keys(res.data.data).length === 0) {
+        // Sometimes returns 'Wrong password', sometimes 'Incorrect password'
+        if (res.data.info?.includes('password') || res.data.apiStatus === 1004) {
+          if (!this.base64Tried) {
+            this.base64Tried = true
+            this.password = Buffer.from(this.password, 'base64')
+              .toString('utf8')
+              .replace(/\r\n|\n|\r/g, '')
+              .trim()
+            return await this.login()
+          }
+        }
+
+        if ([1032, 1033].includes(res.data.apiStatus)) {
+          throw new Error(platformLang.mfaFail)
+        }
+
+        throw new Error(`${platformLang.loginFail} - ${JSON.stringify(res.data)}`)
+      }
+
+      // The iot-x.meross.com domain seems to work for most users, but not all
+      // If at this point the apiStatus is 1030 then the data object will include the correct region
+      // We can use this to update the domain and try again
+      if (res.data.apiStatus === 1030) {
+        this.domain = res.data.data.domain.replace(/^https?:\/\//, '')
+        this.log.warn('[HTTP] %s [%s].', platformLang.regionUpdate, this.domain)
+        return await this.login()
+      }
+
+      if (!res.data.data.token) {
+        // Now something unknown is happening
+        throw new Error(`${platformLang.loginFail} - ${JSON.stringify(res.data)}`)
+      }
+
+      this.key = res.data.data.key
+      this.token = res.data.data.token
+      this.userId = res.data.data.userid
+      if (this.showUserKey && !this.userkey) {
+        this.log.warn('%s: %s', platformLang.merossKey, this.key)
+      }
+      try {
+        await this.storageData.setItem(
+          'Meross_All_Devices_temp',
+          `${this.username}:::${this.key}:::${this.token}:::${this.userId}:::${this.domain}`,
+        )
+      } catch (e) {
+        this.log.warn('[HTTP] %s %s.', platformLang.accTokenStoreErr, parseError(e))
+      }
+
+      return {
+        key: this.key,
+        token: this.token,
+        userId: this.userId,
+      }
+    } 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 getDevices() {
+    try {
+      if (!this.token) {
+        throw new Error(platformLang.notAuth)
+      }
+
+      const nonce = generateRandomString(16)
+      const timestampMillis = Date.now()
+      const loginParams = encodeParams({})
+
+      // Generate the md5-hash (called signature)
+      const dataToSign = `23x17ahWarFH6w29${timestampMillis}${nonce}${loginParams}`
+      const md5hash = createHash('md5')
+        .update(dataToSign)
+        .digest('hex')
+
+      const res = await axios({
+        url: `https://${this.domain}/v1/Device/devList`,
+        method: 'post',
+        headers: {
+          Authorization: `Basic ${this.token}`,
+          ...this.requestHeaders,
+        },
+        data: {
+          params: loginParams,
+          sign: md5hash,
+          timestamp: timestampMillis,
+          nonce,
+        },
+      })
+
+      // Check to see we got a response
+      if (!res.data) {
+        throw new Error(platformLang.noResponse)
+      }
+
+      if (!hasProperty(res.data, 'data') || !Array.isArray(res.data.data)) {
+        // apiStatus 1022 denotes that the token is invalid or has expired
+        // we could try logging in again, just once, and only if the mfaCode is not set
+        if (res.data.apiStatus === 1022) {
+          if (!this.mfaCode && !this.devLoginRetried) {
+            this.devLoginRetried = true
+            this.log.warn('[HTTP] %s.', platformLang.loginRetry)
+            await this.login()
+            return this.getDevices()
+          }
+
+          await this.storageData.removeItem('Meross_All_Devices_temp')
+          throw new Error(platformLang.accTokenInvalid)
+        }
+        throw new Error(`${platformLang.invalidDevices} - ${JSON.stringify(res.data)}`)
+      }
+
+      // Don't return ignored devices or those that have been configured for local control
+      const toReturn = []
+      res.data.data.forEach((device) => {
+        // Don't initialise the device if ignored
+        if (this.ignoredDevices.includes(device.uuid)) {
+          this.log('[%s] %s.', device.devName, platformLang.noInitIgnore)
+          return
+        }
+
+        const model = device.deviceType.toUpperCase()
+
+        // Don't initialise the device if the 'ignore homekit native option' is enabled and hardware matches
+        if (
+          this.ignoreHKNative
+          && device.hdwareVersion
+          && Array.isArray(platformConsts.hkNativeHardware[model])
+          && platformConsts.hkNativeHardware[model].includes(device.hdwareVersion.charAt(0))
+        ) {
+          this.log('[%s] %s.', device.devName, platformLang.noInitHKIgnore)
+          return
+        }
+
+        // Don't initialise the device if the 'ignore matter option' is enabled and hardware matches
+        if (
+          this.ignoreMatter
+          && device.hdwareVersion
+          && Array.isArray(platformConsts.matterHardware[model])
+          && platformConsts.matterHardware[model].includes(device.hdwareVersion.charAt(0))
+        ) {
+          this.log('[%s] %s.', device.devName, platformLang.noInitMatterIgnore)
+          return
+        }
+
+        // Add the device to the return array for the plugin to initialise as a cloud device
+        toReturn.push(device)
+      })
+
+      // Return the amended device list
+      return toReturn
+    } catch (err) {
+      if (err.code && platformConsts.httpRetryCodes.includes(err.code)) {
+        // Retry if another attempt could be successful
+        this.log.warn('[HTTP] %s [getDevices() - %s].', platformLang.httpRetry, err.code)
+        await sleep(30000)
+        return this.getDevices()
+      }
+      throw err
+    }
+  }
+
+  async getSubDevices(device) {
+    try {
+      if (!this.token) {
+        throw new Error(platformLang.notAuth)
+      }
+
+      const nonce = generateRandomString(16)
+      const timestampMillis = Date.now()
+      const loginParams = encodeParams({
+        uuid: device.uuid,
+      })
+
+      // Generate the md5-hash (called signature)
+      const dataToSign = `23x17ahWarFH6w29${timestampMillis}${nonce}${loginParams}`
+      const md5hash = createHash('md5')
+        .update(dataToSign)
+        .digest('hex')
+
+      const res = await axios({
+        url: `https://${this.domain}/v1/Hub/getSubDevices`,
+        method: 'post',
+        headers: {
+          Authorization: `Basic ${this.token}`,
+          ...this.requestHeaders,
+        },
+        data: {
+          params: loginParams,
+          sign: md5hash,
+          timestamp: timestampMillis,
+          nonce,
+        },
+      })
+
+      // Check to see we got a response
+      if (!res.data) {
+        throw new Error(platformLang.noResponse)
+      }
+
+      if (
+        res.data.info !== 'Success'
+        || !hasProperty(res.data, 'data')
+        || !Array.isArray(res.data.data)
+      ) {
+        throw new Error(`${platformLang.invalidSubdevices} - ${JSON.stringify(res.data)}`)
+      }
+
+      // Return the subdevice list to the platform
+      return res.data.data
+    } catch (err) {
+      if (err.code && platformConsts.httpRetryCodes.includes(err.code)) {
+        // Retry if another attempt could be successful
+        this.log.warn('[HTTP] %s [getDevices() - %s].', platformLang.httpRetry, err.code)
+        await sleep(30000)
+        return this.getSubDevices()
+      }
+      throw err
+    }
+  }
+}

package/lib/connection/mqtt.js

@@ -0,0 +1,174 @@
+import { createHash } from 'node:crypto'
+
+import { connect as mqttConnect } from 'mqtt'
+import pTimeout from 'p-timeout'
+
+import { generateRandomString } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+export default class {
+  constructor(platform, accessory) {
+    this.accessory = accessory
+    this.clientResponseTopic = null
+    this.key = platform.accountDetails.key
+    this.platform = platform
+    this.queuedCommands = []
+    this.status = 'init'
+    this.userId = platform.accountDetails.userId
+    this.uuid = accessory.context.serialNumber
+    this.waitingMessageIds = {}
+  }
+
+  connect() {
+    const randomUUID = this.accessory.UUID.substring(0, this.accessory.UUID.length - 6) + generateRandomString(6)
+    const appId = createHash('md5')
+      .update(`API${randomUUID}`)
+      .digest('hex')
+    this.client = mqttConnect({
+      protocol: 'mqtts',
+      host: this.accessory.context.domain || 'eu-iotx.meross.com',
+      port: 2001,
+      clientId: `app:${appId}`,
+      username: this.userId,
+      password: createHash('md5')
+        .update(this.userId + this.key)
+        .digest('hex'),
+      rejectUnauthorized: true,
+      keepalive: 30,
+      reconnectPeriod: 5000,
+    })
+
+    this.client.on('connect', () => {
+      this.client.subscribe(`/app/${this.userId}/subscribe`, (err) => {
+        if (err) {
+          this.accessory.logWarn(`mqtt subscribe error - ${err}`)
+        }
+      })
+
+      this.clientResponseTopic = `/app/${this.userId}-${appId}/subscribe`
+      this.client.subscribe(this.clientResponseTopic, (err) => {
+        if (err) {
+          this.accessory.logWarn(`mqtt user-response subscribe error - ${err}`)
+        }
+        this.accessory.logDebug('mqtt subscribe complete')
+      })
+      this.status = 'online'
+      while (this.queuedCommands.length > 0) {
+        const resolveFn = this.queuedCommands.pop()
+        if (typeof resolveFn === 'function') {
+          resolveFn()
+        }
+      }
+    })
+
+    this.client.on('message', (topic, msg) => {
+      if (!msg) {
+        return
+      }
+
+      const msgStr = msg.toString()
+
+      let decMsg
+      try {
+        decMsg = JSON.parse(msgStr)
+      } catch (e) {
+        this.accessory.logWarn(`mqtt message error - [${e}] [${msgStr}]]`)
+        return
+      }
+      if (!decMsg.header?.from.includes(this.uuid)) {
+        return
+      }
+
+      // If message is the RESP for a previous action,
+      // process return the control to the 'stopped' method.
+      const resolveForThisMessage = this.waitingMessageIds[decMsg.header.messageId]
+      if (typeof resolveForThisMessage === 'function') {
+        resolveForThisMessage({ data: decMsg })
+        delete this.waitingMessageIds[decMsg.header.messageId]
+      } else if (decMsg.header.method === 'PUSH') {
+        // Otherwise, process it accordingly
+        if (this.accessory.control?.receiveUpdate && decMsg.payload) {
+          this.accessory.control.receiveUpdate(decMsg)
+        }
+      }
+    })
+    this.client.on('error', (error) => {
+      this.accessory.logWarn(`mqtt connection error${error ? ` [${error.toString()}]` : ''}`)
+    })
+    this.client.on('close', (error) => {
+      this.accessory.logWarn(`mqtt connection closed${error ? ` [${error.toString()}]` : ''}`)
+      this.status = 'offline'
+    })
+    this.client.on('reconnect', () => {
+      this.accessory.logWarn('mqtt connection reconnecting')
+      this.status = 'offline'
+    })
+  }
+
+  disconnect() {
+    this.client.end(true)
+  }
+
+  async sendUpdate(accessory, toSend) {
+    // Timeout shorter for get updates than set updates
+    const timeout = toSend.method === 'GET' ? 4000 : 9000
+    // Helper to queue commands before the device is connected
+    if (this.status !== 'online') {
+      let connectResolve
+
+      // We create a idle promise - connectPromise
+      const connectPromise = new Promise((resolve) => {
+        connectResolve = resolve
+      })
+
+      // connectPromise will get resolved when the device connects
+      this.queuedCommands.push(connectResolve)
+      // when the device is connected, the futureCommand will be executed
+      // that is exactly the same command issued now, but in the future
+      const futureCommand = () => this.sendUpdate(toSend)
+      // we return immediately an 'idle' promise, that when it gets resolved
+      // it will then execute the futureCommand
+      // IF the above takes too much time, the command will fail with a TimeoutError
+      return pTimeout(connectPromise.then(futureCommand), {
+        milliseconds: timeout,
+      })
+    }
+
+    let commandResolve
+    // create an awaiting promise, it will get (maybe) resolved if the device responds in time
+    const commandPromise = new Promise((resolve) => {
+      commandResolve = resolve
+    })
+
+    const messageId = createHash('md5')
+      .update(generateRandomString(16))
+      .digest('hex')
+    const timestamp = Math.round(new Date().getTime() / 1000)
+
+    const data = {
+      header: {
+        from: this.clientResponseTopic,
+        messageId,
+        method: toSend.method,
+        namespace: toSend.namespace,
+        payloadVersion: 1,
+        sign: createHash('md5')
+          .update(messageId + this.key + timestamp)
+          .digest('hex'),
+        timestamp,
+      },
+      payload: toSend.payload || {},
+    }
+
+    // Log to send
+    accessory.logDebug(`${platformLang.sendMQTT}: ${JSON.stringify(data)}`)
+
+    // Send the message
+    this.client.publish(`/appliance/${this.uuid}/subscribe`, JSON.stringify(data))
+    this.waitingMessageIds[messageId] = commandResolve
+    // the command returns with a timeout
+    return pTimeout(commandPromise, {
+      milliseconds: timeout,
+    })
+  }
+}