homebridge-midea-platform 1.2.10-beta.9 → 1.2.10

package/CHANGELOG.md

@@ -3,7 +3,10 @@
 # v1.2.10
 - fix: added logic to persist fan speed when toggling fan related modes (like sleep mode, boost mode, etc...) in `Air Conditioner` (fixes #158)
 - feat: added separate switch for setting `Air Conditioner` fan auto mode (fixes #152)
-- feat: added support for 0xCC `MDV WiFi Controller` (fixes #126)
+- feat: added basic/partial support for 0xCC `MDV WiFi Controller` (fixes #126)
+- fix: water tank sensors are cleaned up for `Dehumidifier` (fixes #160)
+- fix: authentication and connection logic fixes (by @Ben-Diehlci)
+- feat: added option to set Thermostat as the service type for AC devices (by @Ben-Diehlci)
 
 # v1.2.9
 - feat: added separate temperature sensor creation option for `Air Conditioner` (fixes #141)

package/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.0.6/schema.json",
   "vcs": {
     "enabled": false,
     "clientKind": "git",
@@ -7,20 +7,30 @@
   },
   "files": {
     "ignoreUnknown": false,
-    "ignore": ["dist/**", ".vscode/**", ".github/**", "node_modules/**"]
+    "includes": ["**", "!**/dist/**", "!**/.vscode/**", "!**/.github/**", "!**/node_modules/**"]
   },
   "formatter": {
     "enabled": true,
     "indentStyle": "space",
     "lineWidth": 160
   },
-  "organizeImports": {
-    "enabled": true
-  },
+  "assist": { "actions": { "source": { "organizeImports": "on" } } },
   "linter": {
     "enabled": true,
     "rules": {
-      "recommended": true
+      "recommended": true,
+      "style": {
+        "noParameterAssign": "error",
+        "useAsConstAssertion": "error",
+        "useDefaultParameterLast": "error",
+        "useEnumInitializers": "error",
+        "useSelfClosingElements": "error",
+        "useSingleVarDeclarator": "error",
+        "noUnusedTemplateLiteral": "error",
+        "useNumberNamespace": "error",
+        "noInferrableTypes": "error",
+        "noUselessElse": "error"
+      }
     }
   },
   "javascript": {

package/config.schema.json

@@ -169,6 +169,16 @@
                 "functionBody": "return model.devices && model.devices[arrayIndices].type === 'Air Conditioner';"
               },
               "properties": {
+                "serviceType": {
+                  "title": "HomeKit Service Type",
+                  "type": "string",
+                  "default": "HeaterCooler",
+                  "oneOf": [
+                    { "title": "Heater/Cooler (range slider)", "enum": ["HeaterCooler"] },
+                    { "title": "Thermostat (single temperature)", "enum": ["Thermostat"] }
+                  ],
+                  "description": "HeaterCooler shows a temperature range slider in AUTO mode. Thermostat shows a single target temperature. Thermostat is recommended for cooling-only units."
+                },
                 "swing": {
                   "type": "object",
                   "title": "Swing Options",
@@ -678,6 +688,7 @@
               "expandable": true,
               "expanded": false,
               "items": [
+                "devices[].AC_options.serviceType",
                 {
                   "key": "devices[].AC_options.swing",
                   "items": [

package/dist/accessory/AirConditionerAccessory.d.ts

@@ -39,6 +39,7 @@ export default class AirConditionerAccessory extends BaseAccessory<MideaACDevice
     private swingAngleMainControl;
     private heatingThresholdTemperature;
     private coolingThresholdTemperature;
+    private readonly useThermostat;
     /*********************************************************************
      * Constructor registers all the service types with Homebridge, registers
      * a callback function with the MideaDevice class, and requests device status.
@@ -50,17 +51,19 @@ export default class AirConditionerAccessory extends BaseAccessory<MideaACDevice
      * any attribute value.
      */
     protected updateCharacteristics(attributes: Partial<ACAttributes>): Promise<void>;
+    /*********************************************************************
+     * Unified state handlers — branch internally based on service type
+     */
+    getCurrentState(): CharacteristicValue;
+    getTargetState(): CharacteristicValue;
+    setTargetState(value: CharacteristicValue): Promise<void>;
     /*********************************************************************
      * Callback functions for each Homebridge/HomeKit service
-     *
      */
     getActive(): CharacteristicValue;
     setActive(value: CharacteristicValue): Promise<void>;
     getTemperatureDisplayUnits(): CharacteristicValue;
     setTemperatureDisplayUnits(value: CharacteristicValue): Promise<void>;
-    getCurrentHeaterCoolerState(): CharacteristicValue;
-    getTargetHeaterCoolerState(): CharacteristicValue;
-    setTargetHeaterCoolerState(value: CharacteristicValue): Promise<void>;
     getCurrentTemperature(): CharacteristicValue;
     getTargetTemperature(): CharacteristicValue;
     setTargetTemperature(value: CharacteristicValue): Promise<void>;

package/dist/accessory/AirConditionerAccessory.js

@@ -1,5 +1,5 @@
 import { AUTO_FAN_SPEED } from '../devices/ac/MideaACDevice.js';
-import { ACMode, SwingAngle, SwingMode } from '../platformUtils.js';
+import { ACMode, ACServiceType, SwingAngle, SwingMode } from '../platformUtils.js';
 import BaseAccessory, { limitValue } from './BaseAccessory.js';
 const outDoorTemperatureSubtype = 'outdoor';
 const displaySubtype = 'display';
@@ -44,6 +44,7 @@ export default class AirConditionerAccessory extends BaseAccessory {
     swingAngleMainControl;
     heatingThresholdTemperature;
     coolingThresholdTemperature;
+    useThermostat;
     /*********************************************************************
      * Constructor registers all the service types with Homebridge, registers
      * a callback function with the MideaDevice class, and requests device status.
@@ -52,50 +53,91 @@ export default class AirConditionerAccessory extends BaseAccessory {
         super(platform, accessory, device, configDev);
         this.device = device;
         this.configDev = configDev;
-        this.service = this.accessory.getService(this.platform.Service.HeaterCooler) || this.accessory.addService(this.platform.Service.HeaterCooler);
+        this.useThermostat = this.configDev.AC_options.serviceType === ACServiceType.THERMOSTAT;
+        // Remove old service if switching between service types
+        const oldService = this.useThermostat
+            ? this.accessory.getService(this.platform.Service.HeaterCooler)
+            : this.accessory.getService(this.platform.Service.Thermostat);
+        if (oldService) {
+            this.accessory.removeService(oldService);
+        }
+        // Create the appropriate service
+        this.service = this.useThermostat
+            ? (this.accessory.getService(this.platform.Service.Thermostat) || this.accessory.addService(this.platform.Service.Thermostat))
+            : (this.accessory.getService(this.platform.Service.HeaterCooler) || this.accessory.addService(this.platform.Service.HeaterCooler));
         this.service.setCharacteristic(this.platform.Characteristic.Name, this.device.name);
-        this.service.getCharacteristic(this.platform.Characteristic.Active).onGet(this.getActive.bind(this)).onSet(this.setActive.bind(this));
+        // Temperature display units — shared by both service types
         this.service
             .getCharacteristic(this.platform.Characteristic.TemperatureDisplayUnits)
             .onGet(this.getTemperatureDisplayUnits.bind(this))
             .onSet(this.setTemperatureDisplayUnits.bind(this));
-        this.service.getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState).onGet(this.getCurrentHeaterCoolerState.bind(this));
-        this.service
-            .getCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState)
-            .onGet(this.getTargetHeaterCoolerState.bind(this))
-            .onSet(this.setTargetHeaterCoolerState.bind(this))
-            .setProps({
-            validValues: this.configDev.AC_options.heatingCapable
-                ? [
-                    this.platform.Characteristic.TargetHeaterCoolerState.AUTO,
-                    this.platform.Characteristic.TargetHeaterCoolerState.HEAT,
-                    this.platform.Characteristic.TargetHeaterCoolerState.COOL,
-                ]
-                : [this.platform.Characteristic.TargetHeaterCoolerState.AUTO, this.platform.Characteristic.TargetHeaterCoolerState.COOL],
-        });
+        // Current temperature — shared by both service types
         this.service.getCharacteristic(this.platform.Characteristic.CurrentTemperature).onGet(this.getCurrentTemperature.bind(this));
+        // Service-specific characteristic registration
         this.service
-            .getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature)
-            .onGet(this.getCoolingThresholdTemperature.bind(this))
-            .onSet(this.setCoolingThresholdTemperature.bind(this))
-            .setProps({
-            minValue: this.configDev.AC_options.minTemp,
-            maxValue: this.configDev.AC_options.maxTemp,
-            minStep: this.configDev.AC_options.tempStep,
-        });
+            .getCharacteristic(this.useThermostat ? this.platform.Characteristic.CurrentHeatingCoolingState : this.platform.Characteristic.CurrentHeaterCoolerState)
+            .onGet(this.getCurrentState.bind(this));
+        const thermostatStateValues = this.configDev.AC_options.heatingCapable ? [
+            this.platform.Characteristic.TargetHeatingCoolingState.OFF,
+            this.platform.Characteristic.TargetHeatingCoolingState.HEAT,
+            this.platform.Characteristic.TargetHeatingCoolingState.COOL,
+            this.platform.Characteristic.TargetHeatingCoolingState.AUTO,
+        ]
+            : [
+                this.platform.Characteristic.TargetHeatingCoolingState.OFF,
+                this.platform.Characteristic.TargetHeatingCoolingState.COOL,
+                this.platform.Characteristic.TargetHeatingCoolingState.AUTO,
+            ];
+        const heaterCoolerStateValues = this.configDev.AC_options.heatingCapable
+            ? [
+                this.platform.Characteristic.TargetHeaterCoolerState.AUTO,
+                this.platform.Characteristic.TargetHeaterCoolerState.HEAT,
+                this.platform.Characteristic.TargetHeaterCoolerState.COOL,
+            ]
+            : [this.platform.Characteristic.TargetHeaterCoolerState.AUTO, this.platform.Characteristic.TargetHeaterCoolerState.COOL];
         this.service
-            .getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature)
-            .onGet(this.getHeatingThresholdTemperature.bind(this))
-            .onSet(this.setHeatingThresholdTemperature.bind(this))
+            .getCharacteristic(this.useThermostat ? this.platform.Characteristic.TargetHeatingCoolingState : this.platform.Characteristic.TargetHeaterCoolerState)
+            .onGet(this.getTargetState.bind(this))
+            .onSet(this.setTargetState.bind(this))
             .setProps({
-            minValue: this.configDev.AC_options.minTemp,
-            maxValue: this.configDev.AC_options.maxTemp,
-            minStep: this.configDev.AC_options.tempStep,
+            validValues: this.useThermostat ? thermostatStateValues : heaterCoolerStateValues
         });
-        this.service.getCharacteristic(this.platform.Characteristic.RotationSpeed).onGet(this.getRotationSpeed.bind(this)).onSet(this.setRotationSpeed.bind(this));
-        // Swing modes
-        if (this.configDev.AC_options.swing.mode !== SwingMode.NONE) {
-            this.service.getCharacteristic(this.platform.Characteristic.SwingMode).onGet(this.getSwingMode.bind(this)).onSet(this.setSwingMode.bind(this));
+        if (this.useThermostat) {
+            this.service
+                .getCharacteristic(this.platform.Characteristic.TargetTemperature)
+                .onGet(this.getTargetTemperature.bind(this))
+                .onSet(this.setTargetTemperature.bind(this))
+                .setProps({
+                minValue: this.configDev.AC_options.minTemp,
+                maxValue: this.configDev.AC_options.maxTemp,
+                minStep: this.configDev.AC_options.tempStep,
+            });
+        }
+        else {
+            this.service.getCharacteristic(this.platform.Characteristic.Active).onGet(this.getActive.bind(this)).onSet(this.setActive.bind(this));
+            this.service
+                .getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature)
+                .onGet(this.getCoolingThresholdTemperature.bind(this))
+                .onSet(this.setCoolingThresholdTemperature.bind(this))
+                .setProps({
+                minValue: this.configDev.AC_options.minTemp,
+                maxValue: this.configDev.AC_options.maxTemp,
+                minStep: this.configDev.AC_options.tempStep,
+            });
+            this.service
+                .getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature)
+                .onGet(this.getHeatingThresholdTemperature.bind(this))
+                .onSet(this.setHeatingThresholdTemperature.bind(this))
+                .setProps({
+                minValue: this.configDev.AC_options.minTemp,
+                maxValue: this.configDev.AC_options.maxTemp,
+                minStep: this.configDev.AC_options.tempStep,
+            });
+            this.service.getCharacteristic(this.platform.Characteristic.RotationSpeed).onGet(this.getRotationSpeed.bind(this)).onSet(this.setRotationSpeed.bind(this));
+            // Swing modes (HeaterCooler only — Thermostat uses the fan accessory for swing)
+            if (this.configDev.AC_options.swing.mode !== SwingMode.NONE) {
+                this.service.getCharacteristic(this.platform.Characteristic.SwingMode).onGet(this.getSwingMode.bind(this)).onSet(this.setSwingMode.bind(this));
+            }
         }
         // Outdoor temperature sensor
         this.outDoorTemperatureService = this.accessory.getServiceById(this.platform.Service.TemperatureSensor, outDoorTemperatureSubtype);
@@ -359,20 +401,19 @@ export default class AirConditionerAccessory extends BaseAccessory {
                     break;
                 case 'target_temperature': {
                     const target = Number(this.getTargetTemperature());
-                    /**
-                     * If the device is heating, we map the target temperature to the heating threshold, if cooling we map to the cooling
-                     * threshold and otherwise we assume an auto mode and only adjust the thresholds if the target value is outside their
-                     * range. This should only happen if the temperature is changed outside of HomeKit and in this case we collapse the
-                     * range to the target temperature set by the user.
-                     */
-                    if (this.device.attributes.MODE === ACMode.HEATING) {
-                        this.setHeatingCoolingTemperatureThresholds({ heating: target });
-                    }
-                    else if (this.device.attributes.MODE === ACMode.COOLING) {
-                        this.setHeatingCoolingTemperatureThresholds({ cooling: target });
+                    if (this.useThermostat) {
+                        this.service.updateCharacteristic(this.platform.Characteristic.TargetTemperature, target);
                     }
-                    else if (target < this.heatingThresholdTemperature || target > this.coolingThresholdTemperature) {
-                        this.setHeatingCoolingTemperatureThresholds({ heating: target, cooling: target });
+                    else {
+                        if (this.device.attributes.MODE === ACMode.HEATING) {
+                            this.setHeatingCoolingTemperatureThresholds({ heating: target });
+                        }
+                        else if (this.device.attributes.MODE === ACMode.COOLING) {
+                            this.setHeatingCoolingTemperatureThresholds({ cooling: target });
+                        }
+                        else if (target < this.heatingThresholdTemperature || target > this.coolingThresholdTemperature) {
+                            this.setHeatingCoolingTemperatureThresholds({ heating: target, cooling: target });
+                        }
                     }
                     updateState = true;
                     break;
@@ -381,7 +422,7 @@ export default class AirConditionerAccessory extends BaseAccessory {
                     const temperature = this.getCurrentTemperature();
                     this.service.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, temperature);
                     this.temperatureSensorService?.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, temperature);
-                    if (this.device.attributes.POWER && this.device.attributes.MODE === ACMode.AUTO) {
+                    if (!this.useThermostat && this.device.attributes.POWER && this.device.attributes.MODE === ACMode.AUTO) {
                         await this.withoutPromptTone(this.setTargetTemperatureWithinThresholds.bind(this));
                         updateState = true;
                     }
@@ -395,7 +436,9 @@ export default class AirConditionerAccessory extends BaseAccessory {
                     break;
                 case 'swing_vertical':
                 case 'swing_horizontal':
-                    this.service.updateCharacteristic(this.platform.Characteristic.SwingMode, this.getSwingMode());
+                    if (!this.useThermostat) {
+                        this.service.updateCharacteristic(this.platform.Characteristic.SwingMode, this.getSwingMode());
+                    }
                     break;
                 case 'mode':
                     updateState = true;
@@ -437,10 +480,12 @@ export default class AirConditionerAccessory extends BaseAccessory {
                     this.platform.log.debug(`[${this.device.name}] Attempt to set unsupported attribute ${k} to ${v}`);
             }
             if (updateState) {
-                this.service.updateCharacteristic(this.platform.Characteristic.Active, this.getActive());
-                this.service.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, this.getTargetHeaterCoolerState());
-                this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.getCurrentHeaterCoolerState());
-                this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed());
+                this.service.updateCharacteristic(this.useThermostat ? this.platform.Characteristic.CurrentHeatingCoolingState : this.platform.Characteristic.CurrentHeaterCoolerState, this.getCurrentState());
+                this.service.updateCharacteristic(this.useThermostat ? this.platform.Characteristic.TargetHeatingCoolingState : this.platform.Characteristic.TargetHeaterCoolerState, this.getTargetState());
+                if (!this.useThermostat) {
+                    this.service.updateCharacteristic(this.platform.Characteristic.Active, this.getActive());
+                    this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed());
+                }
                 this.fanOnlyService?.updateCharacteristic(this.platform.Characteristic.On, this.getFanOnlyMode());
                 this.fanService?.updateCharacteristic(this.platform.Characteristic.Active, this.getActive());
                 this.fanService?.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed());
@@ -455,32 +500,29 @@ export default class AirConditionerAccessory extends BaseAccessory {
         }
     }
     /*********************************************************************
-     * Callback functions for each Homebridge/HomeKit service
-     *
+     * Unified state handlers — branch internally based on service type
      */
-    getActive() {
-        // Show as inactive if device is off
-        return this.device.attributes.POWER ? this.platform.Characteristic.Active.ACTIVE : this.platform.Characteristic.Active.INACTIVE;
-    }
-    async setActive(value) {
-        await this.device.set_attribute({ POWER: !!value });
-        this.device.attributes.SCREEN_DISPLAY = !!value;
-        this.displayService?.updateCharacteristic(this.platform.Characteristic.On, !!value);
-    }
-    getTemperatureDisplayUnits() {
-        return this.device.attributes.TEMP_FAHRENHEIT
-            ? this.platform.Characteristic.TemperatureDisplayUnits.FAHRENHEIT
-            : this.platform.Characteristic.TemperatureDisplayUnits.CELSIUS;
-    }
-    async setTemperatureDisplayUnits(value) {
-        await this.device.set_attribute({
-            TEMP_FAHRENHEIT: value === this.platform.Characteristic.TemperatureDisplayUnits.FAHRENHEIT,
-        });
-    }
-    getCurrentHeaterCoolerState() {
-        const { CurrentHeaterCoolerState } = this.platform.Characteristic;
+    getCurrentState() {
+        if (this.useThermostat) {
+            if (!this.device.attributes.POWER) {
+                return this.platform.Characteristic.CurrentHeatingCoolingState.OFF;
+            }
+            const currentTemp = Number(this.getCurrentTemperature());
+            const targetTemp = Number(this.getTargetTemperature());
+            if ([ACMode.COOLING, ACMode.AUTO, ACMode.DRY].includes(this.device.attributes.MODE)) {
+                if (currentTemp > targetTemp) {
+                    return this.platform.Characteristic.CurrentHeatingCoolingState.COOL;
+                }
+            }
+            if ([ACMode.HEATING].includes(this.device.attributes.MODE) && this.configDev.AC_options.heatingCapable) {
+                if (currentTemp < targetTemp) {
+                    return this.platform.Characteristic.CurrentHeatingCoolingState.HEAT;
+                }
+            }
+            return this.platform.Characteristic.CurrentHeatingCoolingState.OFF;
+        }
         if (!this.device.attributes.POWER || !this.device.attributes.MODE) {
-            return CurrentHeaterCoolerState.INACTIVE;
+            return this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
         }
         const isPossiblyCooling = [ACMode.COOLING, ACMode.AUTO].includes(this.device.attributes.MODE);
         const isPossiblyHeating = [ACMode.HEATING, ACMode.AUTO].includes(this.device.attributes.MODE) && this.configDev.AC_options.heatingCapable;
@@ -488,14 +530,29 @@ export default class AirConditionerAccessory extends BaseAccessory {
         const heatingThresholdTemperature = Number(this.getHeatingThresholdTemperature());
         const coolingThresholdTemperature = Number(this.getCoolingThresholdTemperature());
         if (isPossiblyCooling && currentTemperature > coolingThresholdTemperature) {
-            return CurrentHeaterCoolerState.COOLING;
+            return this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
         }
         if (isPossiblyHeating && currentTemperature < heatingThresholdTemperature) {
-            return CurrentHeaterCoolerState.HEATING;
+            return this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
         }
-        return CurrentHeaterCoolerState.IDLE;
+        return this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
     }
-    getTargetHeaterCoolerState() {
+    getTargetState() {
+        if (this.useThermostat) {
+            if (!this.device.attributes.POWER) {
+                return this.platform.Characteristic.TargetHeatingCoolingState.OFF;
+            }
+            switch (this.device.attributes.MODE) {
+                case ACMode.COOLING:
+                    return this.platform.Characteristic.TargetHeatingCoolingState.COOL;
+                case ACMode.HEATING:
+                    return this.platform.Characteristic.TargetHeatingCoolingState.HEAT;
+                case ACMode.AUTO:
+                    return this.platform.Characteristic.TargetHeatingCoolingState.AUTO;
+                default:
+                    return this.platform.Characteristic.TargetHeatingCoolingState.AUTO;
+            }
+        }
         switch (this.device.attributes.MODE) {
             case ACMode.COOLING:
                 return this.platform.Characteristic.TargetHeaterCoolerState.COOL;
@@ -505,7 +562,24 @@ export default class AirConditionerAccessory extends BaseAccessory {
                 return this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
         }
     }
-    async setTargetHeaterCoolerState(value) {
+    async setTargetState(value) {
+        if (this.useThermostat) {
+            switch (value) {
+                case this.platform.Characteristic.TargetHeatingCoolingState.OFF:
+                    await this.device.set_attribute({ POWER: false });
+                    break;
+                case this.platform.Characteristic.TargetHeatingCoolingState.COOL:
+                    await this.device.set_attribute({ POWER: true, MODE: ACMode.COOLING });
+                    break;
+                case this.platform.Characteristic.TargetHeatingCoolingState.HEAT:
+                    await this.device.set_attribute({ POWER: true, MODE: ACMode.HEATING });
+                    break;
+                case this.platform.Characteristic.TargetHeatingCoolingState.AUTO:
+                    await this.device.set_attribute({ POWER: true, MODE: ACMode.AUTO });
+                    break;
+            }
+            return;
+        }
         switch (value) {
             case this.platform.Characteristic.TargetHeaterCoolerState.AUTO:
                 await this.device.set_attribute({ POWER: true, MODE: ACMode.AUTO });
@@ -519,6 +593,27 @@ export default class AirConditionerAccessory extends BaseAccessory {
         }
         await this.setTargetTemperatureWithinThresholds();
     }
+    /*********************************************************************
+     * Callback functions for each Homebridge/HomeKit service
+     */
+    getActive() {
+        return this.device.attributes.POWER ? this.platform.Characteristic.Active.ACTIVE : this.platform.Characteristic.Active.INACTIVE;
+    }
+    async setActive(value) {
+        await this.device.set_attribute({ POWER: !!value });
+        this.device.attributes.SCREEN_DISPLAY = !!value;
+        this.displayService?.updateCharacteristic(this.platform.Characteristic.On, !!value);
+    }
+    getTemperatureDisplayUnits() {
+        return this.device.attributes.TEMP_FAHRENHEIT
+            ? this.platform.Characteristic.TemperatureDisplayUnits.FAHRENHEIT
+            : this.platform.Characteristic.TemperatureDisplayUnits.CELSIUS;
+    }
+    async setTemperatureDisplayUnits(value) {
+        await this.device.set_attribute({
+            TEMP_FAHRENHEIT: value === this.platform.Characteristic.TemperatureDisplayUnits.FAHRENHEIT,
+        });
+    }
     getCurrentTemperature() {
         return this.device.attributes.INDOOR_TEMPERATURE ?? this.configDev.AC_options.minTemp;
     }
@@ -542,6 +637,11 @@ export default class AirConditionerAccessory extends BaseAccessory {
             await this.setTargetTemperature(this.getHeatingThresholdTemperature());
             return;
         }
+        // For cooling-only units in AUTO mode, treat like COOL
+        if (!this.configDev.AC_options.heatingCapable) {
+            await this.setTargetTemperature(this.getCoolingThresholdTemperature());
+            return;
+        }
         if (this.getCurrentTemperature() > this.getCoolingThresholdTemperature()) {
             await this.setTargetTemperature(this.getCoolingThresholdTemperature());
             return;