homebridge-ge-ac 1.0.0 → 1.2.0

package/README.md

@@ -1,8 +1,31 @@
 # homebridge-ge-ac
 
-A [Homebridge](https://homebridge.io) plugin for **GE Profile / SmartHQ Wi‑Fi window air conditioners**
-(e.g. the GE Profile ClearView **AHTT06BC**), exposing them to HomeKit with **reliable** setpoint,
-mode, and fan control.
+A [Homebridge](https://homebridge.io) plugin for **GE SmartHQ Wi‑Fi window air conditioners**,
+exposing them to HomeKit with **reliable** setpoint, mode, and fan control over GE's realtime
+WebSocket channel.
+
+> **Compatibility — please read.** This was built and **tested on one unit**: the GE Profile
+> ClearView **AHTT06BC** (a *cooling‑only* window AC). The SmartHQ protocol and ERD codes are shared
+> across GE's smart window/room AC line, so it will **probably** work on similar GE Wi‑Fi window ACs —
+> but anything beyond the AHTT06BC is **unverified**. How it adapts:
+> - **Temperature range** is read from the unit (`0x7B06`) — no longer hard‑coded — falling back to
+>   64–86 °F if the unit doesn't report one.
+> - **Cooling-only units** (no heating setpoint reported) get a Cool thermostat + Cool/Fan/Energy‑Saver/Dry
+>   switches. This is the **tested** path.
+> - **Heat/cool units** — ⚠️ **experimental, untested.** If the unit reports a heating setpoint
+>   (`0x7002`), the plugin also exposes a Heat thermostat mode, a heating setpoint, and a Heat switch.
+>   No heat‑capable unit was available to test, and the heat setpoint encoding is assumed to match the
+>   (verified) cool one. **If you have a heat/cool GE smart AC, please test and
+>   [open an issue](https://github.com/fabricore-eng/homebridge-ge-ac/issues) with what works or breaks.**
+> - **Modes**: the per‑model "available modes" ERD (`0x7B00`) is **deliberately ignored** — GE window
+>   ACs report a value that doesn't match the documented bitmask. The standard four switches are always
+>   shown; an `Auto` operation mode (if a unit uses it) isn't represented in the thermostat.
+> - **Swing** isn't exposed; **portable** and **split / mini‑split** ACs use a different ERD layout
+>   and are **not** expected to work.
+>
+> Reports for any other model (works / doesn't + the model number) via a
+> [GitHub issue](https://github.com/fabricore-eng/homebridge-ge-ac/issues) are very welcome — that's
+> how this grows beyond one unit.
 
 ## Why this exists
 
@@ -25,7 +48,10 @@ the unit echoes the change back on `publish#erd`.
   Setpoint changes **stick**.
 - **Mode switches** with real names: Cool, Fan Only, Energy Saver, Dry. (No bogus "Heat" — these
   are cooling-only units. Each switch sets `ConfiguredName`, so HomeKit never shows "Switch 1–5".)
-- **Fan speed** via the rotation-speed slider (Auto / Low / Med / High).
+- **Fan speed** as a dedicated **Fan** accessory — an **Auto ⇄ Manual** toggle plus a Low/Med/High
+  speed slider, mirroring the GE app's Auto/Low/Med/High. (Apple's Home app won't render fan speed on
+  a thermostat tile, so it's exposed as its own Fan service on the same accessory — it groups with the
+  AC rather than appearing as the thermostat's rotation-speed slider.)
 - **Live updates** — state is pushed from the WebSocket subscription, so HomeKit reflects changes
   made in the GE app or on the unit, in real time.
 - Resilient: app‑level keepalive, OAuth token refresh ahead of expiry, and exponential‑backoff

package/lib/accessory.js

@@ -1,7 +1,10 @@
 'use strict';
 const C = require('./const');
 
-// Build a HeaterCooler + 4 mode switches for one GE AC, bound to the SmartHQ client.
+// Build a HeaterCooler + mode switches for one GE AC, bound to the SmartHQ client.
+// Capability-aware: temperature range comes from the unit (0x7B06), and Heat is exposed only
+// when the unit reports a heating setpoint ERD (0x7002). A cooling-only unit (e.g. AHTT06BC,
+// which reports neither heat nor a non-[64,86] range) behaves exactly as the cooling-only build.
 class ACAccessory {
   constructor(platform, accessory, client, mac) {
     this.platform = platform;
@@ -14,15 +17,26 @@ class ACAccessory {
     this.Ch = this.hap.Characteristic;
     const name = accessory.displayName;
 
+    // ---- capability detection (state is already populated when we get here) ----
+    // heatCapable enables an EXPERIMENTAL, UNTESTED heat path: no heat-capable unit was available to
+    // verify it, and 0x7002's encoding is assumed identical to the (verified) 0x7003 cool setpoint.
+    this.heatCapable = client.getState(mac, C.ERD.HEAT_TARGET_TEMP) != null;
+    this.range = C.decodeRange(client.getState(mac, C.ERD.TEMP_RANGE)); // {minF, maxF}, fallback {64,86}
+    this.minC = C.fToC(this.range.minF);
+    this.maxC = C.fToC(this.range.maxF);
+    this.log.info(`[${name}] ${this.heatCapable ? 'heat+cool' : 'cooling-only'}, range ${this.range.minF}-${this.range.maxF}F`);
+
     accessory.getService(this.S.AccessoryInformation)
       .setCharacteristic(this.Ch.Manufacturer, 'GE Appliances')
-      .setCharacteristic(this.Ch.Model, 'Smart Window AC')
+      .setCharacteristic(this.Ch.Model, this.heatCapable ? 'Smart AC (heat/cool)' : 'Smart Window AC')
       .setCharacteristic(this.Ch.SerialNumber, mac);
 
     // ---- HeaterCooler ----
     const hc = accessory.getService(this.S.HeaterCooler) || accessory.addService(this.S.HeaterCooler, name, 'GEAC_HC');
     this.hc = hc;
     this._configuredName(hc, name);
+    const CHCS = this.Ch.CurrentHeaterCoolerState;
+    const THCS = this.Ch.TargetHeaterCoolerState;
 
     hc.getCharacteristic(this.Ch.Active)
       .onGet(() => this._power() ? this.Ch.Active.ACTIVE : this.Ch.Active.INACTIVE)
@@ -32,47 +46,55 @@ class ACAccessory {
         } else if (this._power()) { await this.client.setErd(this.mac, C.ERD.POWER, C.POWER.OFF); }
       }));
 
-    hc.getCharacteristic(this.Ch.CurrentHeaterCoolerState)
-      .setProps({ validValues: [this.Ch.CurrentHeaterCoolerState.INACTIVE, this.Ch.CurrentHeaterCoolerState.IDLE, this.Ch.CurrentHeaterCoolerState.COOLING] })
+    hc.getCharacteristic(CHCS)
+      .setProps({ validValues: this.heatCapable ? [CHCS.INACTIVE, CHCS.IDLE, CHCS.HEATING, CHCS.COOLING] : [CHCS.INACTIVE, CHCS.IDLE, CHCS.COOLING] })
       .onGet(() => this._currentState());
 
-    hc.getCharacteristic(this.Ch.TargetHeaterCoolerState)
-      .setProps({ validValues: [this.Ch.TargetHeaterCoolerState.COOL] })
-      .onGet(() => this.Ch.TargetHeaterCoolerState.COOL)
-      .onSet(this._wrap(async () => {
+    hc.getCharacteristic(THCS)
+      .setProps({ validValues: this.heatCapable ? [THCS.HEAT, THCS.COOL] : [THCS.COOL] })
+      .onGet(() => this._targetState())
+      .onSet(this._wrap(async (v) => {
         if (!this._power()) await this.client.setErd(this.mac, C.ERD.POWER, C.POWER.ON);
-        await this.client.setErd(this.mac, C.ERD.OPERATION_MODE, C.MODE.COOL);
+        await this.client.setErd(this.mac, C.ERD.OPERATION_MODE, (this.heatCapable && v === THCS.HEAT) ? C.MODE.HEAT : C.MODE.COOL);
       }));
 
     hc.getCharacteristic(this.Ch.CurrentTemperature)
       .onGet(() => C.fToC(this._ambientF()));
 
-    // Step = exactly 1 degF (5/9 degC), anchored at 64F, so the HomeKit grid lands on whole
-    // Fahrenheit degrees (64,65,...,86). minValue/maxValue are COMPUTED (not rounded literals)
-    // so the pushed value at a boundary equals the prop exactly and HAP never rejects it.
+    // Step = exactly 1 degF (5/9 degC), anchored at the unit's min, so the HomeKit grid lands on
+    // whole Fahrenheit degrees. minValue/maxValue are COMPUTED so a pushed boundary value equals
+    // the prop exactly and HAP never rejects it (the 64F float-boundary lesson).
+    const tempProps = { minValue: this.minC, maxValue: this.maxC, minStep: 5 / 9 };
     hc.getCharacteristic(this.Ch.CoolingThresholdTemperature)
-      .setProps({ minValue: C.fToC(64), maxValue: C.fToC(86), minStep: 5 / 9 })
-      .onGet(() => this._coolThreshC())
-      .onSet(this._wrap(async (v) => {
-        let f = Math.round(C.cToF(v));
-        f = Math.max(64, Math.min(86, f));
-        await this.client.setErd(this.mac, C.ERD.TARGET_TEMP, C.encodeTempF(f));
-      }));
+      .setProps(tempProps)
+      .onGet(() => this._threshC(C.ERD.TARGET_TEMP))
+      .onSet(this._wrap(async (v) => { await this.client.setErd(this.mac, C.ERD.TARGET_TEMP, C.encodeTempF(this._clampF(v))); }));
+
+    if (this.heatCapable) {
+      hc.getCharacteristic(this.Ch.HeatingThresholdTemperature)
+        .setProps(tempProps)
+        .onGet(() => this._threshC(C.ERD.HEAT_TARGET_TEMP))
+        .onSet(this._wrap(async (v) => { await this.client.setErd(this.mac, C.ERD.HEAT_TARGET_TEMP, C.encodeTempF(this._clampF(v))); }));
+    }
 
-    hc.getCharacteristic(this.Ch.RotationSpeed)
-      .onGet(() => this._fanPct())
-      .onSet(this._wrap(async (pct) => { await this.client.setErd(this.mac, C.ERD.FAN, this._fanFromPct(pct)); }));
+    // Apple's Home app does NOT render RotationSpeed on a HeaterCooler, so fan speed lives on a
+    // dedicated Fanv2 service (below). Strip any stale cached RotationSpeed off the HeaterCooler.
+    if (hc.testCharacteristic(this.Ch.RotationSpeed)) hc.removeCharacteristic(hc.getCharacteristic(this.Ch.RotationSpeed));
 
     hc.getCharacteristic(this.Ch.TemperatureDisplayUnits)
       .onGet(() => (this.client.getState(this.mac, C.ERD.TEMP_UNIT) === '01') ? this.Ch.TemperatureDisplayUnits.CELSIUS : this.Ch.TemperatureDisplayUnits.FAHRENHEIT);
 
-    // ---- mode switches (no HEAT; cooling-only unit) ----
-    this.switches = [
+    // ---- mode switches ----
+    const defs = [
       ['Cool', 'GEAC_COOL', C.MODE.COOL],
       ['Fan Only', 'GEAC_FAN', C.MODE.FAN_ONLY],
       ['Energy Saver', 'GEAC_ECO', C.MODE.ENERGY_SAVER],
       ['Dry', 'GEAC_DRY', C.MODE.DRY],
-    ].map(([label, subtype, modeHex]) => {
+    ];
+    if (this.heatCapable) defs.push(['Heat', 'GEAC_HEAT', C.MODE.HEAT]);
+    else { const stale = accessory.getService('GEAC_HEAT'); if (stale) accessory.removeService(stale); } // drop a stale Heat switch on cooling-only units
+
+    this.switches = defs.map(([label, subtype, modeHex]) => {
       const sw = accessory.getService(subtype) || accessory.addService(this.S.Switch, label, subtype);
       this._configuredName(sw, label);
       sw.getCharacteristic(this.Ch.On)
@@ -84,13 +106,31 @@ class ACAccessory {
       return { sw, modeHex };
     });
 
-    // remove a stale HEAT switch if a previous version created one
-    const stale = accessory.getService('GEAC_HEAT');
-    if (stale) accessory.removeService(stale);
+    // ---- Fan (Fanv2): Auto/Manual toggle + Low/Med/High slider, bound to fan ERD 0x7A00 ----
+    // Apple Home renders this as a proper Fan tile (with an Auto switch), unlike a HeaterCooler's
+    // RotationSpeed. Same accessory, so it groups with the thermostat + mode switches.
+    const fan = accessory.getService(this.S.Fanv2) || accessory.addService(this.S.Fanv2, `${name} Fan`, 'GEAC_FANV2');
+    this.fan = fan;
+    this._configuredName(fan, 'Fan');
+    const TFS = this.Ch.TargetFanState, CFS = this.Ch.CurrentFanState, ACT = this.Ch.Active;
+    fan.getCharacteristic(ACT)
+      .onGet(() => this._power() ? ACT.ACTIVE : ACT.INACTIVE)
+      .onSet(this._wrap(async (v) => { await this.client.setErd(this.mac, C.ERD.POWER, v === ACT.ACTIVE ? C.POWER.ON : C.POWER.OFF); }));
+    fan.getCharacteristic(CFS)
+      .onGet(() => this._power() ? CFS.BLOWING_AIR : CFS.INACTIVE);
+    fan.getCharacteristic(TFS)
+      .onGet(() => this._fanIsAuto() ? TFS.AUTO : TFS.MANUAL)
+      .onSet(this._wrap(async (v) => {
+        await this.client.setErd(this.mac, C.ERD.FAN, v === TFS.AUTO ? C.FAN.AUTO : this._fanFromPct(this._fanSpeedPct()));
+      }));
+    fan.getCharacteristic(this.Ch.RotationSpeed) // continuous slider; onSet maps to Low(<=34)/Med(<=67)/High
+      .onGet(() => this._fanSpeedPct())
+      .onSet(this._wrap(async (pct) => { await this.client.setErd(this.mac, C.ERD.FAN, this._fanFromPct(pct)); }));
 
     // live updates
-    this._onErd = (mac) => { if (mac === this.mac) this._pushAll(); };
+    this._onErd = (m) => { if (m === this.mac) this._pushAll(); };
     client.on('erd', this._onErd);
+    this._pushAll(); // seed valid initial values to avoid HAP init warnings
   }
 
   _configuredName(svc, name) {
@@ -99,31 +139,45 @@ class ACAccessory {
     svc.getCharacteristic(this.Ch.ConfiguredName).onGet(() => name).updateValue(name);
   }
 
+  // ---- state helpers ----
   _power() { return this.client.getState(this.mac, C.ERD.POWER) === C.POWER.ON; }
   _mode() { return this.client.getState(this.mac, C.ERD.OPERATION_MODE); }
-  _targetF() { const v = C.decodeInt(this.client.getState(this.mac, C.ERD.TARGET_TEMP)); return (v != null && v >= 60 && v <= 90) ? v : 72; }
-  // cooling-threshold in Celsius, clamped to the characteristic's valid band so a boundary
-  // float (e.g. fToC(64)=17.7777 vs a 17.7778 min) can never be rejected by HAP
-  _coolThreshC() { return Math.max(C.fToC(64), Math.min(C.fToC(86), C.fToC(this._targetF()))); }
-  _ambientF() { const v = C.decodeInt(this.client.getState(this.mac, C.ERD.AMBIENT_TEMP)); return (v != null && v >= 32 && v <= 120) ? v : this._targetF(); }
+  _isHeatMode() { return this.heatCapable && this._mode() === C.MODE.HEAT; }
+  _setpointF(erd) { const v = C.decodeInt(this.client.getState(this.mac, erd)); return (v != null && v >= 45 && v <= 100) ? v : Math.round((this.range.minF + this.range.maxF) / 2); }
+  _threshC(erd) { return Math.max(this.minC, Math.min(this.maxC, C.fToC(this._setpointF(erd)))); }
+  _clampF(c) { return Math.max(this.range.minF, Math.min(this.range.maxF, Math.round(C.cToF(c)))); }
+  _ambientF() { const v = C.decodeInt(this.client.getState(this.mac, C.ERD.AMBIENT_TEMP)); return (v != null && v >= 32 && v <= 120) ? v : this._setpointF(C.ERD.TARGET_TEMP); }
+  _targetState() { return this._isHeatMode() ? this.Ch.TargetHeaterCoolerState.HEAT : this.Ch.TargetHeaterCoolerState.COOL; }
   _currentState() {
-    if (!this._power()) return this.Ch.CurrentHeaterCoolerState.INACTIVE;
-    return (this._ambientF() > this._targetF()) ? this.Ch.CurrentHeaterCoolerState.COOLING : this.Ch.CurrentHeaterCoolerState.IDLE;
+    const CHCS = this.Ch.CurrentHeaterCoolerState;
+    if (!this._power()) return CHCS.INACTIVE;
+    if (this._isHeatMode()) return (this._ambientF() < this._setpointF(C.ERD.HEAT_TARGET_TEMP)) ? CHCS.HEATING : CHCS.IDLE;
+    return (this._ambientF() > this._setpointF(C.ERD.TARGET_TEMP)) ? CHCS.COOLING : CHCS.IDLE;
   }
-  _fanPct() {
+  // GE fan enum: AUTO=1 LOW=2 LOW_AUTO=3 MED=4 MED_AUTO=5 HIGH=8 HIGH_AUTO=9. The low bit = "auto".
+  _fanIsAuto() { const n = C.decodeInt(this.client.getState(this.mac, C.ERD.FAN)); return n == null || (n & 1) === 1; }
+  _fanSpeedPct() {
     const n = C.decodeInt(this.client.getState(this.mac, C.ERD.FAN));
-    if (n == null) return 0;
-    if (n >= 8) return 100; if (n >= 4) return 66; if (n >= 2) return 33; return 0; // 0/1 => AUTO
+    if (n == null) return 33;
+    if (n & 8) return 100; if (n & 4) return 66; if (n & 2) return 33; return 33; // pure AUTO(1): default Low position
   }
-  _fanFromPct(p) { if (p <= 0) return C.FAN.AUTO; if (p <= 33) return C.FAN.LOW; if (p <= 66) return C.FAN.MED; return C.FAN.HIGH; }
+  _fanFromPct(p) { if (p <= 0) return C.FAN.AUTO; if (p <= 34) return C.FAN.LOW; if (p <= 67) return C.FAN.MED; return C.FAN.HIGH; }
 
   _pushAll() {
     const u = (c, v) => { try { this.hc.updateCharacteristic(c, v); } catch (e) { /* ignore */ } };
     u(this.Ch.Active, this._power() ? this.Ch.Active.ACTIVE : this.Ch.Active.INACTIVE);
+    u(this.Ch.TargetHeaterCoolerState, this._targetState());
     u(this.Ch.CurrentHeaterCoolerState, this._currentState());
     u(this.Ch.CurrentTemperature, C.fToC(this._ambientF()));
-    u(this.Ch.CoolingThresholdTemperature, this._coolThreshC());
-    u(this.Ch.RotationSpeed, this._fanPct());
+    u(this.Ch.CoolingThresholdTemperature, this._threshC(C.ERD.TARGET_TEMP));
+    if (this.heatCapable) u(this.Ch.HeatingThresholdTemperature, this._threshC(C.ERD.HEAT_TARGET_TEMP));
+    if (this.fan) {
+      const uf = (c, v) => { try { this.fan.updateCharacteristic(c, v); } catch (e) { /* ignore */ } };
+      uf(this.Ch.Active, this._power() ? this.Ch.Active.ACTIVE : this.Ch.Active.INACTIVE);
+      uf(this.Ch.CurrentFanState, this._power() ? this.Ch.CurrentFanState.BLOWING_AIR : this.Ch.CurrentFanState.INACTIVE);
+      uf(this.Ch.TargetFanState, this._fanIsAuto() ? this.Ch.TargetFanState.AUTO : this.Ch.TargetFanState.MANUAL);
+      uf(this.Ch.RotationSpeed, this._fanSpeedPct());
+    }
     for (const { sw, modeHex } of this.switches) {
       try { sw.updateCharacteristic(this.Ch.On, this._power() && this._mode() === modeHex); } catch (e) { /* ignore */ }
     }

package/lib/client.js

@@ -143,6 +143,7 @@ class SmartHQClient extends EventEmitter {
       // id is "{mac}-allErd"
       const mac = (m.id || '').replace(/-allErd$/, '');
       for (const it of (m.body.items || [])) this._apply(mac, it.erd, it.value);
+      this.emit('ready', mac); // full state for this appliance is now in this.state
       return;
     }
     if (kind === 'publish#erd' && m.item) {

package/lib/const.js

@@ -23,17 +23,25 @@ const SETERD_ACK_TIMEOUT_MS = 10000;
 
 // AC ERD codes (gehome canonical, normalized to "0x" + uppercase digits to match the wire)
 const ERD = {
-  TARGET_TEMP: '0x7003', // R/W 2-byte BE degrees F
+  TARGET_TEMP: '0x7003', // R/W 2-byte BE degrees F (cool setpoint)
+  HEAT_TARGET_TEMP: '0x7002', // R/W 2-byte BE degrees F (heat setpoint; only present on heat-capable units)
   OPERATION_MODE: '0x7A01', // R/W 1-byte enum
   AMBIENT_TEMP: '0x7A02', // R   1-byte degrees F
   POWER: '0x7A0F', // R/W "00"/"01"
   FAN: '0x7A00', // R/W enum
   TEMP_UNIT: '0x0007', // R   "00"=F "01"=C (panel only)
   FILTER: '0x7A04', // R   "00"=ok "01"=change
+  TEMP_RANGE: '0x7B06', // R   2-byte [minF, maxF] (unit-reported settable range)
+  AVAILABLE_FAN: '0x7B0B', // R   bitmask auto/high/med/low (reliable)
+  // NOTE: AVAILABLE_MODES (0x7B00) is intentionally NOT used to gate modes: window ACs report a
+  // value that does not match gehome's documented bitmask (the AHTT06BC reports 0x06 ~ {dry,eco}
+  // while clearly supporting cool/fan). Heat capability is detected via HEAT_TARGET_TEMP presence.
 };
 
 const POWER = { OFF: '00', ON: '01' };
+// ErdAcOperationMode (gehome): COOL=0 FAN_ONLY=1 ENERGY_SAVER=2 HEAT=3 DRY=4 AUTO=5 ...
 const MODE = { COOL: '00', FAN_ONLY: '01', ENERGY_SAVER: '02', HEAT: '03', DRY: '04' };
+// ErdAcFanSetting (gehome): AUTO=1 LOW=2 LOW_AUTO=3 MED=4 MED_AUTO=5 HIGH=8 HIGH_AUTO=9
 const FAN = { AUTO: '01', LOW: '02', MED: '04', HIGH: '08' };
 
 // encode/decode
@@ -44,6 +52,13 @@ const decodeInt = (v) => {
 const encodeTempF = (f) => Math.round(f).toString(16).padStart(4, '0').toLowerCase(); // 72 -> "0048"
 const fToC = (f) => (f - 32) * 5 / 9;
 const cToF = (c) => (c * 9 / 5) + 32;
+// decode TEMP_RANGE (0x7B06) "MMNN" -> {minF, maxF}; gehome: 0xFF sentinel -> [60,86] fallback
+const decodeRange = (v) => {
+  const min = decodeInt((v || '').slice(0, 2));
+  const max = decodeInt((v || '').slice(2, 4));
+  if (min == null || max == null || min === 255 || max === 255 || min >= max) return { minF: 64, maxF: 86 };
+  return { minF: min, maxF: max };
+};
 
 // normalize an erd code to the on-wire form "0x" + UPPER digits ("0x7A01")
 const normErd = (code) => code.toUpperCase().replace('0X', '0x');
@@ -53,5 +68,5 @@ module.exports = {
   LOGIN_URL, API_URL, API_HOST, CLIENT_ID, CLIENT_SECRET, REDIRECT_URI, REGION_COOKIE,
   KEEPALIVE_MS, RELIST_MS, REFRESH_SKEW_MS, RECONNECT_BASE_MS, RECONNECT_MAX_MS, SETERD_ACK_TIMEOUT_MS,
   ERD, POWER, MODE, FAN,
-  decodeInt, encodeTempF, fToC, cToF, normErd,
+  decodeInt, encodeTempF, fToC, cToF, normErd, decodeRange,
 };

package/lib/platform.js

@@ -18,8 +18,13 @@ class GEACPlatform {
       this.log.error('Missing SmartHQ username/password in config — plugin disabled.');
       return;
     }
+    this.acMac = null;
+    this.acName = null;
     this.client = new SmartHQClient(log, this.username, this.password);
-    this.client.on('appliances', (items) => this._setupAppliances(items));
+    // Pick the AC from the appliance list, but defer building until its full state arrives
+    // ('ready') so we can read capabilities (heat support, temp range) up front.
+    this.client.on('appliances', (items) => this._pickAc(items));
+    this.client.on('ready', (mac) => { if (mac === this.acMac) this._buildAc(mac); });
 
     this.api.on('didFinishLaunching', () => {
       this.log.info('Starting GE SmartHQ client…');
@@ -30,25 +35,29 @@ class GEACPlatform {
 
   configureAccessory(accessory) { this.accessories.push(accessory); }
 
-  _setupAppliances(items) {
+  _pickAc(items) {
+    if (this.acMac) return; // already chosen
     const wanted = (this.config.macAddress || '').toUpperCase().replace(/[^0-9A-F]/g, '');
     let ac;
     if (wanted) ac = items.find((i) => i.applianceId.toUpperCase().includes(wanted));
     if (!ac) ac = items.find((i) => /air|cond|\bac\b/i.test(`${i.type} ${i.nickname}`));
     if (!ac) ac = items[0];
     if (!ac) { this.log.warn('No appliances found on SmartHQ account.'); return; }
+    this.acMac = ac.applianceId;
+    this.acName = this.config.name || ac.nickname || 'Air Conditioner';
+  }
 
-    const mac = ac.applianceId;
+  _buildAc(mac) {
     if (this.configured.has(mac)) return;
     this.configured.add(mac);
-
-    const name = this.config.name || ac.nickname || 'Air Conditioner';
+    const name = this.acName || 'Air Conditioner';
     const uuid = this.api.hap.uuid.generate(`${C.PLUGIN_NAME}:${mac}`);
     let accessory = this.accessories.find((a) => a.UUID === uuid);
     if (accessory) {
       this.log.info(`Restoring AC "${name}" (${mac}) from cache`);
       accessory.context.mac = mac;
       new ACAccessory(this, accessory, this.client, mac);
+      this.api.updatePlatformAccessories([accessory]); // persist service changes (e.g. added Fan, removed stale chars)
     } else {
       this.log.info(`Adding AC "${name}" (${mac})`);
       accessory = new this.api.platformAccessory(name, uuid);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "homebridge-ge-ac",
   "displayName": "GE Profile AC (SmartHQ WebSocket)",
-  "version": "1.0.0",
-  "description": "Homebridge plugin for GE Profile / SmartHQ Wi-Fi window air conditioners, using the realtime WebSocket control channel for reliable setpoint/mode/fan control.",
+  "version": "1.2.0",
+  "description": "Homebridge plugin for GE SmartHQ Wi-Fi window air conditioners over GE's realtime WebSocket channel (reliable setpoint/mode/fan control). Built and tested on the cooling-only GE Profile AHTT06BC; likely works on similar GE Wi-Fi window ACs (unverified).",
   "author": "Fabricore",
   "license": "ISC",
   "homepage": "https://github.com/fabricore-eng/homebridge-ge-ac#readme",