@homebridge-plugins/homebridge-ewelink 12.6.2 → 12.7.1-beta.0

package/CHANGELOG.md

@@ -1,10 +1,27 @@
 # Change Log
 
-All notable changes to homebridge-ewelink will be documented in this file.
+All notable changes to `@homebridge-plugins/homebridge-ewelink` will be documented in this file.
+
+## v12.8.0 (2025-12-05)
+
+### Changes
+
+- feat: add support for Virtual Switch (UIID 264) and Virtual Button (UIID 265)
+- support more devices
+- update readme badges (use `shields.io`)
+- update workflows and npm publish via oidc
+- updated dependencies
+
+## v12.7.0 (2025-09-19)
+
+### Changes
+
+- dependency updates
+- added new devices
 
 ## v12.6.2 (2025-07-24)
 
-### Other Changes
+### Changes
 
 - dependency updates
 

package/CLAUDE.md

@@ -0,0 +1,144 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+### Development
+- **Lint code**: `npm run lint`
+- **Fix lint issues**: `npm run lint:fix`
+
+## Architecture
+
+### Core Structure
+This is a Homebridge plugin that integrates eWeLink devices into HomeKit. The main entry point is `lib/index.js` which registers the platform with Homebridge.
+
+### Key Components
+
+**Platform Layer** (`lib/platform.js`)
+- Main platform class that coordinates all plugin operations
+- Manages device discovery, initialization, and lifecycle
+- Handles configuration and storage via node-persist
+- Implements request queue with p-queue for rate limiting
+- Routes devices to appropriate handlers based on UIID and configuration
+
+**Connection Layer** (`lib/connection/`)
+- `api.js`: Internal HTTP API server for local control
+- `http.js`: eWeLink cloud API client
+- `lan.js`: Local network device control
+- `ws.js`: WebSocket client for real-time updates
+
+**Device Layer** (`lib/device/`)
+- Individual device type implementations (switches, lights, sensors, etc.)
+- Each device type extends base functionality with specific HomeKit characteristics
+- Supports various Sonoff/eWeLink device models
+- Device types include:
+  - Single/Multi switches with optional power monitoring
+  - RGB/CCT/Dimmable lights
+  - Sensors (ambient, contact, motion, water)
+  - Thermostats, fans, curtains
+  - RF Bridge devices
+  - Zigbee devices (via bridge)
+  - Groups and simulations
+
+**Utilities** (`lib/utils/`)
+- `constants.js`: Device configurations and UIID mappings
+- `functions.js`: Shared utility functions
+- `custom-chars.js`: Custom HomeKit characteristics
+- `eve-chars.js`: Eve Home app specific characteristics
+- Language files for internationalization
+
+### Device Identification (UIID)
+Every eWeLink device has a UIID (unique interface ID) that determines its capabilities:
+
+**Key UIID Categories** (defined in `lib/utils/constants.js`):
+- `switchSingle`: [1, 6, 14, 24, 27, etc.] - Basic on/off switches
+- `switchSinglePower`: [5, 32] - Switches with power monitoring
+- `switchMulti`: [2, 3, 4, 7, 8, 9, etc.] - Multi-channel switches
+- `lightRGB`: [22] - RGB color lights
+- `lightCCT`: [103] - Color temperature lights
+- `lightRGBCCT`: [33, 59, 104, etc.] - Full color + temperature lights
+- `lightDimmer`: [36, 44, 57] - Dimmable lights
+- `sensorContact`: [102, 154] - Door/window sensors
+- `sensorAmbient`: [15, 181] - Temperature/humidity sensors
+- `thermostat`: [127] - Smart thermostats
+- `rfBridge`: [28, 98] - RF 433MHz bridges
+- `zbBridge`: [66, 128, 168] - Zigbee bridges
+- Zigbee prefixed devices (1000-7000 range)
+
+**Device Routing Logic** (in `lib/platform.js:initialiseDevice()`):
+1. Checks device UIID against category arrays in constants
+2. Considers user configuration (showAs property for simulations)
+3. Creates appropriate device handler instance
+4. Special handling for:
+   - Power monitoring devices (different decimal places)
+   - Multi-channel devices (individual switches/outlets)
+   - Bridge devices (RF/Zigbee sub-devices)
+   - Simulated accessories (garage doors, valves, etc.)
+
+### Communication Flow
+1. Plugin authenticates with eWeLink cloud to fetch device list
+2. Attempts local (LAN) control first for supported devices
+3. Falls back to cloud control via HTTP/WebSocket if local fails
+4. Maintains real-time sync through WebSocket connection
+5. Exposes optional internal API for external control
+
+### Command & Payload Structure
+
+**HTTP Connection** (`lib/connection/http.js`)
+- **Login**: POST to `/v2/user/login`
+  - Request: `{email/phoneNumber, password, countryCode}`
+  - Response: Returns `at` (access token) and `apikey`
+  - Uses HMAC-SHA256 signature with app secret
+- **Get Homes**: GET to `/v2/family`
+  - Headers: Bearer token authentication
+- **Get Devices**: GET to `/v2/device` and `/v2/group`
+  - Fetches device list per home with full params
+
+**WebSocket Connection** (`lib/connection/ws.js`)
+- **Authentication**: Action `userOnline`
+  - Payload: `{action: 'userOnline', apikey, appid, at, nonce, sequence, ts, version: 8}`
+- **Device Update**: Action `update`
+  - Payload: `{action: 'update', apikey, deviceid, params, sequence, ts: 0, userAgent: 'app'}`
+  - Params vary by device type (see below)
+- **Query State**: Action `query`
+  - Payload: `{action: 'query', apikey, deviceid, params: [], sequence}`
+- **Heartbeat**: Sends `'ping'` at intervals to keep connection alive
+
+**LAN Connection** (`lib/connection/lan.js`)
+- Uses mDNS discovery for `_ewelink._tcp.local` services
+- **Encryption**: AES-128-CBC with MD5 hashed device key
+- **Update Request**: POST to `http://{device_ip}:8081/zeroconf/{suffix}`
+  - Suffixes: `switch`, `switches`, `dimmable`, `light`, `fan`, `transmit`, `location`, `monitor`
+  - Encrypted payload with IV
+  - Data structure: `{data, deviceid, encrypt: true, iv, selfApikey: '123', sequence}`
+- **DNS Monitoring**: Listens for TXT records with encrypted device updates
+
+**Common Device Parameters**
+- **Single Switch**: `{switch: 'on'/'off'}`
+- **Multi Switch**: `{switches: [{outlet: 0-3, switch: 'on'/'off'}]}`
+- **SCM Devices**: Uses switches array even for single switch (UIID 77/78/81/107/112/138/160)
+- **Dimmable**: `{brightness: 0-100, mode: 0}`
+- **RGB Light**: `{ltype: 'color'/'white', color: {br, r, g, b}, white: {br, ct}}`
+- **Power Monitor**: `{uiActive: 120}` to request power updates
+- **Curtain/Motor**: `{location: 0-100}` for position
+- **RF Bridge**: `{cmd: 'transmit', rfChl: channel}`
+- **TH10/16**: `{switch, mainSwitch, deviceType: 'normal'}`
+- **Fan (iFan)**: `{light: 'on'/'off', fan: 'on'/'off', speed: 1-3}`
+
+**Update Priority**
+1. Try LAN if device supports it (check `constants.devices.lan` array)
+2. Fall back to WebSocket if LAN fails
+3. Queue updates with 250ms intervals to prevent rate limiting
+4. Power monitoring devices poll every 120 seconds
+
+### State Management
+- Device states cached using node-persist
+- Queue system (p-queue) prevents API rate limiting
+- Fakegato history service for Eve Home app integration
+
+## Important Notes
+- ES modules with Node.js 20/22/24 support required
+- Uses @antfu/eslint-config for code style
+- No test suite - manual testing required
+- Verified Homebridge plugin following official standards

package/README.md

@@ -8,11 +8,9 @@
 Homebridge plugin to integrate eWeLink devices into HomeKit
 
 [![npm](https://img.shields.io/npm/v/@homebridge-plugins/homebridge-ewelink/latest?label=latest)](https://www.npmjs.com/package/@homebridge-plugins/homebridge-ewelink)
-[![npm](https://img.shields.io/npm/v/@homebridge-plugins/homebridge-ewelink/beta?label=beta)](https://github.com/homebridge-plugins/homebridge-ewelink/wiki/Beta-Version)
-
-[![verified-by-homebridge](https://badgen.net/badge/homebridge/verified/purple)](https://github.com/homebridge/homebridge/wiki/Verified-Plugins)
-[![hoobs-certified](https://badgen.net/badge/HOOBS/certified/yellow?label=hoobs)](https://plugins.hoobs.org/plugin/homebridge-ewelink)
-
+[![npm](https://img.shields.io/npm/v/@homebridge-plugins/homebridge-ewelink/beta?label=beta)](https://github.com/homebridge-plugins/homebridge-ewelink/wiki/Beta-Version)<br>
+[![verified-by-homebridge](https://img.shields.io/badge/homebridge-verified-blueviolet?color=%23491F59&style=flat)](https://github.com/homebridge/homebridge/wiki/Verified-Plugins)
+[![hoobs-certified](https://img.shields.io/badge/hoobs-certified-yellow)](https://plugins.hoobs.org/plugin/homebridge-ewelink)<br>
 [![npm](https://img.shields.io/npm/dt/@homebridge-plugins/homebridge-ewelink)](https://www.npmjs.com/package/@homebridge-plugins/homebridge-ewelink)
 [![Discord](https://img.shields.io/discord/432663330281226270?color=728ED5&logo=discord&label=hb-discord)](https://discord.com/channels/432663330281226270/742733745743855627)
 

package/lib/connection/lan.js

@@ -242,6 +242,9 @@ export default class {
       } else if (json.params.uiActive && deviceInfo.uiid === 32) {
         params.uiActive = json.params.uiActive
         suffix = 'monitor'
+      } else if (json.params.uiActive && [126, 165].includes(deviceInfo.uiid)) {
+        // DualR3 uses statistics endpoint in LAN mode
+        suffix = 'statistics'
       } else if (json.params.cmd) {
         params.cmd = 'transmit'
         params.rfChl = json.params.rfChl

package/lib/device/air-conditioner.js

@@ -0,0 +1,512 @@
+import platformConsts from '../utils/constants.js'
+import { hasProperty, parseError } from '../utils/functions.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapServ = platform.api.hap.Service
+    this.hapErr = platform.api.hap.HapStatusError
+    this.lang = platform.lang
+    this.log = platform.log
+    this.platform = platform
+
+    // Set up variables from the accessory
+    this.name = accessory.displayName
+    this.accessory = accessory
+
+    // Initially set the online flag as true (to be then updated as false if necessary)
+    this.isOnline = true
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.eweDeviceId] || {}
+    this.tempOffset = deviceConf.offset || platformConsts.defaultValues.offset
+    this.tempOffsetFactor = deviceConf.offsetFactor
+
+    // Set the correct logging variables for this accessory
+    switch (deviceConf.overrideLogging) {
+      case 'standard':
+        this.enableLogging = true
+        this.enableDebugLogging = false
+        break
+      case 'debug':
+        this.enableLogging = true
+        this.enableDebugLogging = true
+        break
+      case 'disable':
+        this.enableLogging = false
+        this.enableDebugLogging = false
+        break
+      default:
+        this.enableLogging = !platform.config.disableDeviceLogging
+        this.enableDebugLogging = platform.config.debug
+        break
+    }
+
+    // Add the heater cooler service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.HeaterCooler)
+      || this.accessory.addService(this.hapServ.HeaterCooler)
+
+    // Set custom properties of the current temperature characteristic
+    this.service.getCharacteristic(this.hapChar.CurrentTemperature).setProps({
+      minStep: 0.1,
+    })
+    this.cacheTemp = this.service.getCharacteristic(this.hapChar.CurrentTemperature).value
+
+    // Add the set handler to the active characteristic
+    this.service
+      .getCharacteristic(this.hapChar.Active)
+      .onSet(async value => this.internalActiveUpdate(value))
+
+    // Add the set handler to the target heater cooler state characteristic
+    this.service
+      .getCharacteristic(this.hapChar.TargetHeaterCoolerState)
+      .setProps({
+        minValue: 0,
+        maxValue: 2,
+        validValues: [0, 1, 2], // Auto, Heat, Cool
+      })
+      .onSet(async value => this.internalModeUpdate(value))
+
+    // Add the set handler to the cooling threshold temperature characteristic
+    this.service
+      .getCharacteristic(this.hapChar.CoolingThresholdTemperature)
+      .setProps({
+        minValue: 16,
+        maxValue: 32,
+        minStep: 1,
+      })
+      .onSet(async value => this.internalTempUpdate(value, 'cool'))
+
+    // Add the set handler to the heating threshold temperature characteristic
+    this.service
+      .getCharacteristic(this.hapChar.HeatingThresholdTemperature)
+      .setProps({
+        minValue: 16,
+        maxValue: 32,
+        minStep: 1,
+      })
+      .onSet(async value => this.internalTempUpdate(value, 'heat'))
+
+    // Add the set handler to the rotation speed characteristic (for fan speed)
+    this.service
+      .getCharacteristic(this.hapChar.RotationSpeed)
+      .setProps({
+        minValue: 0,
+        maxValue: 100,
+        minStep: 25,
+      })
+      .onSet(async value => this.internalSpeedUpdate(value))
+
+    // Add the get handlers only if the user hasn't disabled the disableNoResponse setting
+    if (!platform.config.disableNoResponse) {
+      this.service.getCharacteristic(this.hapChar.Active).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.Active).value
+      })
+      this.service.getCharacteristic(this.hapChar.TargetHeaterCoolerState).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.TargetHeaterCoolerState).value
+      })
+      this.service.getCharacteristic(this.hapChar.CurrentHeaterCoolerState).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.CurrentHeaterCoolerState).value
+      })
+      this.service.getCharacteristic(this.hapChar.CurrentTemperature).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.CurrentTemperature).value
+      })
+      this.service.getCharacteristic(this.hapChar.CoolingThresholdTemperature).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.CoolingThresholdTemperature).value
+      })
+      this.service.getCharacteristic(this.hapChar.HeatingThresholdTemperature).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.HeatingThresholdTemperature).value
+      })
+      this.service.getCharacteristic(this.hapChar.RotationSpeed).onGet(() => {
+        if (!this.isOnline) {
+          throw new this.hapErr(-70402)
+        }
+        return this.service.getCharacteristic(this.hapChar.RotationSpeed).value
+      })
+    }
+
+    // Initialise these caches now since they aren't determined by the initial externalUpdate()
+    this.cacheTarg = this.service.getCharacteristic(this.hapChar.CoolingThresholdTemperature).value
+    this.cacheMode = 'cool'
+    this.cacheSpeed = 50
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('custom', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const normalLogging = this.enableLogging ? 'standard' : 'disable'
+    const opts = JSON.stringify({
+      logging: this.enableDebugLogging ? 'debug' : normalLogging,
+      offset: this.tempOffset,
+      offsetFactor: this.tempOffsetFactor,
+    })
+    this.log('[%s] %s %s.', this.name, this.lang.devInitOpts, opts)
+  }
+
+  async internalActiveUpdate(value) {
+    try {
+      const newValue = value === 1 ? 'on' : 'off'
+
+      // Don't continue if the value is the same as before
+      const prevState = this.service.getCharacteristic(this.hapChar.Active).value === 1 ? 'on' : 'off'
+      if (prevState === newValue) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        power: newValue,
+      })
+
+      // Update the current state characteristic
+      this.service.updateCharacteristic(
+        this.hapChar.CurrentHeaterCoolerState,
+        value === 1
+          ? (this.cacheMode === 'heat'
+              ? this.hapChar.CurrentHeaterCoolerState.HEATING
+              : this.hapChar.CurrentHeaterCoolerState.COOLING)
+          : this.hapChar.CurrentHeaterCoolerState.INACTIVE,
+      )
+
+      // Cache the new state and log if appropriate
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s].', this.name, this.lang.curState, newValue)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      const prevStateValue = this.service.getCharacteristic(this.hapChar.Active).value
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.Active, prevStateValue)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalModeUpdate(value) {
+    try {
+      let newMode
+      switch (value) {
+        case 0: // Auto
+          newMode = 'auto'
+          break
+        case 1: // Heat
+          newMode = 'heat'
+          break
+        case 2: // Cool
+          newMode = 'cool'
+          break
+        default:
+          return
+      }
+
+      // Don't continue if the value is the same as before
+      if (this.cacheMode === newMode) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        mode: newMode,
+      })
+
+      // Update the current state characteristic if device is on
+      if (this.service.getCharacteristic(this.hapChar.Active).value === 1) {
+        this.service.updateCharacteristic(
+          this.hapChar.CurrentHeaterCoolerState,
+          value === 1
+            ? this.hapChar.CurrentHeaterCoolerState.HEATING
+            : value === 2
+              ? this.hapChar.CurrentHeaterCoolerState.COOLING
+              : this.hapChar.CurrentHeaterCoolerState.IDLE,
+        )
+      }
+
+      // Cache the new mode and log if appropriate
+      this.cacheMode = newMode
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s].', this.name, this.lang.curMode, newMode)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        const prevValue = this.cacheMode === 'heat' ? 1 : this.cacheMode === 'cool' ? 2 : 0
+        this.service.updateCharacteristic(this.hapChar.TargetHeaterCoolerState, prevValue)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalTempUpdate(value, mode) {
+    try {
+      // Only update if this is the active mode or auto mode
+      if (this.cacheMode !== mode && this.cacheMode !== 'auto') {
+        return
+      }
+
+      // Don't continue if the value is the same as before
+      if (this.cacheTarg === value) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        temperature: value,
+      })
+
+      // Cache the new target temperature and log if appropriate
+      this.cacheTarg = value
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s°C].', this.name, this.lang.tarTemp, value)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        if (mode === 'cool') {
+          this.service.updateCharacteristic(this.hapChar.CoolingThresholdTemperature, this.cacheTarg)
+        } else {
+          this.service.updateCharacteristic(this.hapChar.HeatingThresholdTemperature, this.cacheTarg)
+        }
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async internalSpeedUpdate(value) {
+    try {
+      // Map HomeKit 0-100 to eWeLink wind speed values
+      // Assuming 101 = low, 102 = medium, 103 = high
+      let windSpeed
+      if (value === 0) {
+        windSpeed = 0
+      } else if (value <= 33) {
+        windSpeed = 101
+      } else if (value <= 66) {
+        windSpeed = 102
+      } else {
+        windSpeed = 103
+      }
+
+      // Don't continue if the value is the same as before
+      if (this.cacheSpeed === windSpeed) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        wind_speed: windSpeed,
+      })
+
+      // Cache the new speed and log if appropriate
+      this.cacheSpeed = windSpeed
+      if (this.enableLogging) {
+        this.log('[%s] %s [%s].', this.name, this.lang.curSpeed, value)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Map cached speed back to HomeKit value
+      let prevValue = 50
+      if (this.cacheSpeed === 101) {
+        prevValue = 25
+      } else if (this.cacheSpeed === 102) {
+        prevValue = 50
+      } else if (this.cacheSpeed === 103) {
+        prevValue = 75
+      }
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.RotationSpeed, prevValue)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async externalUpdate(params) {
+    try {
+      // Check to see if the provided params are valid for this model
+      if (
+        !hasProperty(params, 'power')
+        && !hasProperty(params, 'mode')
+        && !hasProperty(params, 'temperature')
+        && !hasProperty(params, 'indoor_temperature')
+        && !hasProperty(params, 'wind_speed')
+      ) {
+        throw new Error(this.lang.paramsNotRecd)
+      }
+
+      // Update the active characteristic
+      if (hasProperty(params, 'power')) {
+        const newState = params.power === 'on' ? 1 : 0
+        this.service.updateCharacteristic(this.hapChar.Active, newState)
+
+        // Update the current state
+        this.service.updateCharacteristic(
+          this.hapChar.CurrentHeaterCoolerState,
+          newState === 1
+            ? (this.cacheMode === 'heat'
+                ? this.hapChar.CurrentHeaterCoolerState.HEATING
+                : this.hapChar.CurrentHeaterCoolerState.COOLING)
+            : this.hapChar.CurrentHeaterCoolerState.INACTIVE,
+        )
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s].', this.name, this.lang.curState, params.power)
+        }
+      }
+
+      // Update the mode characteristic
+      if (hasProperty(params, 'mode')) {
+        let targetState
+        switch (params.mode) {
+          case 'auto':
+            targetState = 0
+            break
+          case 'heat':
+            targetState = 1
+            break
+          case 'cool':
+            targetState = 2
+            break
+          default:
+            return
+        }
+
+        this.cacheMode = params.mode
+        this.service.updateCharacteristic(this.hapChar.TargetHeaterCoolerState, targetState)
+
+        // Update current state if device is on
+        if (this.service.getCharacteristic(this.hapChar.Active).value === 1) {
+          this.service.updateCharacteristic(
+            this.hapChar.CurrentHeaterCoolerState,
+            targetState === 1
+              ? this.hapChar.CurrentHeaterCoolerState.HEATING
+              : targetState === 2
+                ? this.hapChar.CurrentHeaterCoolerState.COOLING
+                : this.hapChar.CurrentHeaterCoolerState.IDLE,
+          )
+        }
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s].', this.name, this.lang.curMode, params.mode)
+        }
+      }
+
+      // Update the target temperature
+      if (hasProperty(params, 'temperature')) {
+        this.cacheTarg = params.temperature
+        this.service.updateCharacteristic(this.hapChar.CoolingThresholdTemperature, params.temperature)
+        this.service.updateCharacteristic(this.hapChar.HeatingThresholdTemperature, params.temperature)
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s°C].', this.name, this.lang.tarTemp, params.temperature)
+        }
+      }
+
+      // Update the current temperature
+      if (hasProperty(params, 'indoor_temperature')) {
+        let newTemp = Number(params.indoor_temperature)
+
+        // Apply any configured offset
+        if (this.tempOffsetFactor) {
+          newTemp *= this.tempOffsetFactor
+        }
+        newTemp += this.tempOffset
+        newTemp = Math.round(newTemp * 10) / 10
+
+        this.cacheTemp = newTemp
+        this.service.updateCharacteristic(this.hapChar.CurrentTemperature, newTemp)
+        this.accessory.eveService.addEntry({
+          time: Math.round(Date.now() / 1000),
+          temp: newTemp,
+        })
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s°C].', this.name, this.lang.curTemp, newTemp)
+        }
+      }
+
+      // Update the fan speed
+      if (hasProperty(params, 'wind_speed')) {
+        // Map eWeLink wind speed to HomeKit rotation speed
+        let rotationSpeed = 50
+        if (params.wind_speed === 0) {
+          rotationSpeed = 0
+        } else if (params.wind_speed === 101) {
+          rotationSpeed = 25
+        } else if (params.wind_speed === 102) {
+          rotationSpeed = 50
+        } else if (params.wind_speed === 103) {
+          rotationSpeed = 75
+        }
+
+        this.cacheSpeed = params.wind_speed
+        this.service.updateCharacteristic(this.hapChar.RotationSpeed, rotationSpeed)
+
+        // Log the change if appropriate
+        if (params.updateSource && this.enableLogging) {
+          this.log('[%s] %s [%s].', this.name, this.lang.curSpeed, rotationSpeed)
+        }
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantUpd, eText)
+    }
+  }
+
+  async currentState() {
+    const toReturn = {}
+    toReturn.services = ['heater-cooler']
+    toReturn.heater_cooler = {
+      state: this.service.getCharacteristic(this.hapChar.Active).value === 1 ? 'on' : 'off',
+      mode: this.cacheMode,
+      target_temp: this.cacheTarg,
+      current_temp: this.cacheTemp,
+    }
+    return toReturn
+  }
+
+  markStatus(isOnline) {
+    this.isOnline = isOnline
+  }
+}

package/lib/device/index.js

@@ -1,3 +1,4 @@
+import deviceAirConditioner from './air-conditioner.js'
 import deviceCurtain from './curtain.js'
 import deviceDiffuser from './diffuser.js'
 import deviceFan from './fan.js'
@@ -26,9 +27,11 @@ import deviceSwitchSingleInched from './switch-single-inched.js'
 import deviceSwitchSingle from './switch-single.js'
 import deviceTemplate from './template.js'
 import deviceThermostat from './thermostat.js'
+import deviceVirtual from './virtual.js'
 import zb from './zigbee/index.js'
 
 export default {
+  deviceAirConditioner,
   deviceCurtain,
   deviceDiffuser,
   deviceFan,
@@ -56,6 +59,7 @@ export default {
   deviceSwitchSingleInched,
   deviceTemplate,
   deviceThermostat,
+  deviceVirtual,
   sim,
   zb,
 }

package/lib/device/virtual.js

@@ -0,0 +1,270 @@
+import { hasProperty, parseError } from '../utils/functions.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapServ = platform.api.hap.Service
+    this.hapErr = platform.api.hap.HapStatusError
+    this.lang = platform.lang
+    this.log = platform.log
+    this.platform = platform
+
+    // Set up variables from the accessory
+    this.name = accessory.displayName
+    this.accessory = accessory
+
+    // Initially set the online flag as true (to be then updated as false if necessary)
+    this.isOnline = true
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.eweDeviceId] || {}
+
+    // Set the correct logging variables for this accessory
+    switch (deviceConf.overrideLogging) {
+      case 'standard':
+        this.enableLogging = true
+        this.enableDebugLogging = false
+        break
+      case 'debug':
+        this.enableLogging = true
+        this.enableDebugLogging = true
+        break
+      case 'disable':
+        this.enableLogging = false
+        this.enableDebugLogging = false
+        break
+      default:
+        this.enableLogging = !platform.config.disableDeviceLogging
+        this.enableDebugLogging = platform.config.debug
+        break
+    }
+
+    // Check device params to determine if it's a button or switch
+    this.isButton = hasProperty(accessory.context.eweParams, 'key')
+
+    if (this.isButton) {
+      // Virtual Button - use StatelessProgrammableSwitch
+      this.service = this.accessory.getService(this.hapServ.StatelessProgrammableSwitch)
+        || this.accessory.addService(this.hapServ.StatelessProgrammableSwitch)
+
+      // Set up the button with single, double, and long press
+      this.service.getCharacteristic(this.hapChar.ProgrammableSwitchEvent).setProps({
+        minValue: 0,
+        maxValue: 2,
+        validValues: [0, 1, 2], // Single, Double, Long press
+      })
+
+      // Remove switch service if it exists from previous setup
+      if (this.accessory.getService(this.hapServ.Switch)) {
+        this.accessory.removeService(this.accessory.getService(this.hapServ.Switch))
+      }
+    } else {
+      // Virtual Switch - use standard Switch service
+      this.service = this.accessory.getService(this.hapServ.Switch)
+        || this.accessory.addService(this.hapServ.Switch)
+
+      // Add the set handler to the switch on/off characteristic
+      this.service
+        .getCharacteristic(this.hapChar.On)
+        .onSet(async value => this.internalStateUpdate(value))
+
+      // Add the get handler only if the user hasn't disabled the disableNoResponse setting
+      if (!platform.config.disableNoResponse) {
+        this.service.getCharacteristic(this.hapChar.On).onGet(() => {
+          if (!this.isOnline) {
+            throw new this.hapErr(-70402)
+          }
+          return this.service.getCharacteristic(this.hapChar.On).value
+        })
+      }
+
+      // Remove button service if it exists from previous setup
+      if (this.accessory.getService(this.hapServ.StatelessProgrammableSwitch)) {
+        this.accessory.removeService(this.accessory.getService(this.hapServ.StatelessProgrammableSwitch))
+      }
+    }
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('switch', this.accessory, {
+      log: () => {},
+    })
+
+    // Output the customised options to the log
+    const normalLogging = this.enableLogging ? 'standard' : 'disable'
+    const opts = JSON.stringify({
+      logging: this.enableDebugLogging ? 'debug' : normalLogging,
+      type: this.isButton ? 'button' : 'switch',
+    })
+    this.log('[%s] %s %s.', this.name, this.lang.devInitOpts, opts)
+  }
+
+  async internalStateUpdate(value) {
+    try {
+      // This is only for virtual switches, not buttons
+      if (this.isButton) {
+        return
+      }
+
+      const newValue = value ? 'on' : 'off'
+
+      // Don't continue if the value is the same as before
+      const prevState = this.service.getCharacteristic(this.hapChar.On).value
+      if (prevState === value) {
+        return
+      }
+
+      // Send the request to the platform sender function
+      await this.platform.sendDeviceUpdate(this.accessory, {
+        switches: [
+          {
+            outlet: 0,
+            switch: newValue,
+          },
+        ],
+      })
+
+      // Cache the new state and log if appropriate
+      if (this.enableLogging) {
+        this.accessory.eveService.addEntry({
+          time: Math.round(Date.now() / 1000),
+          status: value ? 1 : 0,
+        })
+        this.log('[%s] %s [%s].', this.name, this.lang.curState, newValue)
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantCtl, eText)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.On, this.cacheState === 'on')
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  async externalUpdate(params) {
+    try {
+      if (this.isButton) {
+        // Handle button press events
+        if (hasProperty(params, 'key')) {
+          // Map key values to HomeKit button events
+          let buttonEvent
+          switch (params.key) {
+            case 0:
+              buttonEvent = this.hapChar.ProgrammableSwitchEvent.SINGLE_PRESS
+              break
+            case 1:
+              buttonEvent = this.hapChar.ProgrammableSwitchEvent.DOUBLE_PRESS
+              break
+            case 2:
+              buttonEvent = this.hapChar.ProgrammableSwitchEvent.LONG_PRESS
+              break
+            default:
+              // Unknown key value, default to single press
+              buttonEvent = this.hapChar.ProgrammableSwitchEvent.SINGLE_PRESS
+          }
+
+          // Update the button event characteristic
+          this.service.updateCharacteristic(this.hapChar.ProgrammableSwitchEvent, buttonEvent)
+
+          // Log the button press if appropriate
+          if (params.updateSource && this.enableLogging) {
+            const pressType = params.key === 0 ? 'single' : params.key === 1 ? 'double' : 'long'
+            this.log('[%s] %s [%s press].', this.name, this.lang.curState, pressType)
+          }
+        }
+
+        // Handle trigger time if provided
+        if (hasProperty(params, 'trigTime')) {
+          this.lastTriggerTime = params.trigTime
+          if (this.enableDebugLogging) {
+            this.log('[%s] Button triggered at %s.', this.name, new Date(Number.parseInt(params.trigTime)).toLocaleString())
+          }
+        }
+      } else {
+        // Handle virtual switch updates
+        if (hasProperty(params, 'switches') && Array.isArray(params.switches)) {
+          params.switches.forEach((outlet) => {
+            // Check this is the primary outlet
+            if (outlet.outlet !== 0) {
+              return
+            }
+
+            // Check we have a valid switch value
+            if (!hasProperty(outlet, 'switch')) {
+              return
+            }
+
+            const newState = outlet.switch === 'on'
+            const prevState = this.service.getCharacteristic(this.hapChar.On).value
+            if (prevState === newState) {
+              return
+            }
+
+            this.service.updateCharacteristic(this.hapChar.On, newState)
+            this.cacheState = outlet.switch
+
+            // Add Eve history entry
+            this.accessory.eveService.addEntry({
+              time: Math.round(Date.now() / 1000),
+              status: newState ? 1 : 0,
+            })
+
+            // Log the change if appropriate
+            if (params.updateSource && this.enableLogging) {
+              this.log('[%s] %s [%s].', this.name, this.lang.curState, outlet.switch)
+            }
+          })
+        }
+
+        // Also handle single switch param for compatibility
+        if (hasProperty(params, 'switch')) {
+          const newState = params.switch === 'on'
+          const prevState = this.service.getCharacteristic(this.hapChar.On).value
+          if (prevState !== newState) {
+            this.service.updateCharacteristic(this.hapChar.On, newState)
+            this.cacheState = params.switch
+
+            // Add Eve history entry
+            this.accessory.eveService.addEntry({
+              time: Math.round(Date.now() / 1000),
+              status: newState ? 1 : 0,
+            })
+
+            // Log the change if appropriate
+            if (params.updateSource && this.enableLogging) {
+              this.log('[%s] %s [%s].', this.name, this.lang.curState, params.switch)
+            }
+          }
+        }
+      }
+    } catch (err) {
+      // Catch any errors during the process
+      const eText = parseError(err)
+      this.log.warn('[%s] %s %s.', this.name, this.lang.cantUpd, eText)
+    }
+  }
+
+  async currentState() {
+    const toReturn = {}
+    if (this.isButton) {
+      toReturn.services = ['button']
+      toReturn.button = {
+        last_trigger: this.lastTriggerTime || 'none',
+      }
+    } else {
+      toReturn.services = ['switch']
+      toReturn.switch = {
+        state: this.cacheState || 'off',
+      }
+    }
+    return toReturn
+  }
+
+  markStatus(isOnline) {
+    this.isOnline = isOnline
+  }
+}

package/lib/platform.js

@@ -1106,6 +1106,26 @@ export default class {
         this.applyAccessoryLogging(accessory)
         accessory.control = new deviceTypes.deviceThermostat(this, accessory)
         /** */
+      } else if (platformConsts.devices.airConditioner.includes(uiid)) {
+        /**
+         ***************
+         AIR CONDITIONERS
+         ****************
+         */
+        accessory = devicesInHB.get(uuid) || this.addAccessory(device, `${device.deviceid}SWX`)
+        this.applyAccessoryLogging(accessory)
+        accessory.control = new deviceTypes.deviceAirConditioner(this, accessory)
+        /** */
+      } else if (platformConsts.devices.virtual.includes(uiid)) {
+        /**
+         ***************
+         VIRTUAL DEVICES
+         ****************
+         */
+        accessory = devicesInHB.get(uuid) || this.addAccessory(device, `${device.deviceid}SWX`)
+        this.applyAccessoryLogging(accessory)
+        accessory.control = new deviceTypes.deviceVirtual(this, accessory)
+        /** */
       } else if (
         device.showAs === 'thermostat'
         && platformConsts.devices.sensorAmbient.includes(uiid)

package/lib/utils/constants.js

@@ -284,8 +284,8 @@ export default {
       211,
       212,
     ],
-    switchSingle: [1, 6, 14, 24, 27, 226, 1009, 1256, 7004, 7005, 7010],
-    switchSCM: [77, 78, 81, 107, 112, 138, 160, 191, 209],
+    switchSingle: [1, 6, 14, 24, 27, 225, 226, 1009, 1256, 7004, 7005, 7010, 7032],
+    switchSCM: [77, 78, 81, 107, 112, 138, 160, 191, 209, 264],
     switchSCMPower: [182, 190],
     switchSinglePower: [5, 32],
     switchMulti: [
@@ -312,23 +312,26 @@ export default {
       210,
       211,
       212,
+      262,
       2256,
       3256,
       4256,
     ],
-    switchMultiPower: [126, 165],
+    switchMultiPower: [126, 165, 262],
     switchMate: [177],
     switchMan: [174],
     lightDimmer: [36, 44, 57],
     lightRGB: [22],
     lightCCT: [103],
     lightRGBCCT: [33, 59, 104, 135, 136, 137, 173],
-    curtain: [11, 67],
+    curtain: [11, 67, 91, 258],
     sensorContact: [102, 154],
     sensorAmbient: [15, 181],
     sensorTempHumi: [18],
     thermostat: [127],
+    airConditioner: [151],
     panel: [133, 195],
+    virtual: [265],
     fan: [34],
     humidifier: [19],
     diffuser: [25],
@@ -344,7 +347,7 @@ export default {
     zbSensorMotion: [2026, 7002],
     zbSensorOccupancy: [7016],
     zbSensorContact: [3026, 7003],
-    zbSensorWater: [4026],
+    zbSensorWater: [4026, 7019],
     zbSensorSmoke: [5026],
     zbThermostat: [7017],
     zbWaterValve: [7027],
@@ -468,6 +471,7 @@ export default {
     83: 3, // "GSM_SOCKET_3_NO_FLOW"
     84: 4, // "GSM_SOCKET_4_NO_FLOW"
     87: 1, // "EWELINK_IOT_CAMERA" (GK-200MP2B)
+    91: 1, // "ROLLING_DOOR" (Cover/Curtain device)
     98: 1, // "DOORBELL_RFBRIDGE"
     102: 1, // "DOOR_MAGNETIC" (OPL-DMA, DW2)
     103: 1, // "WOTEWODE_TEM_LIGHT" (B02-F)
@@ -506,8 +510,11 @@ export default {
     210: 2, // Sonoff Ultimate Switch T5-2C-86
     211: 3, // Sonoff Ultimate Switch T5-3C-86
     212: 4, // Sonoff Ultimate Switch T5-4C-86
+    225: 1, // CK-BL602-PCSW-01 (Single switch with power monitoring)
     226: 1, // https://github.com/homebridge-plugins/homebridge-ewelink/issues/636
     243: 1, // Zigbee Bridge Ultra
+    258: 1, // Additional Cover device
+    262: 4, // CK-BL602-SWP1-02 (4-channel switch with power monitoring)
     1000: 1, // "zigbee_ON_OFF_SWITCH_1000" (button device)
     1009: 1, // "" (Some sort of single switch device)
     1256: 1, // "ZIGBEE_SINGLE_SWITCH"
@@ -535,7 +542,9 @@ export default {
     7014: 1, // some sensor https://github.com/homebridge-plugins/homebridge-ewelink/issues/494
     7016: 1, // https://sonoff.tech/product/gateway-and-sensors/snzb-06p/
     7017: 1, // https://github.com/homebridge-plugins/homebridge-ewelink/issues/518
+    7019: 1, // Zigbee Water Sensor
     7027: 1, // Zigbee Smart Water Valve
+    7032: 1, // Zigbee Power Monitoring Switch
   },
 
   cannotSupportDevices: {
@@ -582,7 +591,6 @@ export default {
     88: 0, // "YK_INFRARED"
     89: 0, // "SMART_OPEN_MACHINE"
     90: 0, // "GSM_RFBridge"
-    91: 0, // "ROLLING_DOOR_91"
     93: 0, // "HTHD_AIR_CLEANER"
     94: 0, // "YIAN_ELECTRIC_PROTECT"
     109: 0, // "YK_INFRARED_2"

package/package.json

@@ -3,7 +3,7 @@
   "displayName": "Homebridge eWeLink",
   "alias": "eWeLink",
   "type": "module",
-  "version": "12.6.2",
+  "version": "12.7.1-beta.0",
   "description": "Homebridge plugin to integrate eWeLink devices into HomeKit.",
   "author": {
     "name": "bwp91",
@@ -61,14 +61,14 @@
     "lint:fix": "npm run lint -- --fix"
   },
   "dependencies": {
-    "@homebridge/plugin-ui-utils": "^2.1.0",
-    "axios": "^1.11.0",
+    "@homebridge/plugin-ui-utils": "^2.1.2",
+    "axios": "^1.13.2",
     "node-persist": "^4.0.4",
-    "p-queue": "^8.1.0",
+    "p-queue": "^9.0.1",
     "websocket-as-promised": "^3.0.1",
     "ws": "^8.18.3"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.19.0"
+    "@antfu/eslint-config": "^6.4.2"
   }
 }