homebridge-texecom-full 4.2.8 → 4.3.0-beta.1

package/index.js

@@ -1,6 +1,3 @@
-var Service;
-var Characteristic;
-var Accessory;
 var debug = require("debug")("TexecomAccessory");
 var serialport = require("serialport");
 var zpad = require("zpad");
@@ -14,67 +11,74 @@ const responseEmitter = new ResponseEmitter();
 
 const LogUtil = require('./util/logutil');
 
-var areas_armed = [];  // Creates an empty array, which can later grow dynamically
-
-
+var areas_armed = [];
 var setByAlarm = false;
 
+// ─── Homebridge v2 entry point ──────────────────────────────────────────────
+module.exports = (api) => {
+    api.registerPlatform("Texecom", TexecomPlatform);
+};
 
-module.exports = function (homebridge) {
-    Accessory = homebridge.platformAccessory;
-    Service = homebridge.hap.Service;
-    Characteristic = homebridge.hap.Characteristic;
+// ─── Platform ────────────────────────────────────────────────────────────────
+class TexecomPlatform {
+    constructor(log, config, api) {
+        this.log = new LogUtil(config.debug, config.name, log);
+        this.api = api;
+        this.hap = api.hap;
+
+        this.serial_device = config["serial_device"];
+        this.baud_rate = config["baud_rate"];
+        this.zones = config["zones"] || [];
+        this.areas = config["areas"] || [];
+        this.ip_address = config["ip_address"];
+        this.ip_port = config["ip_port"];
+        this.udl = config["udl"];
+
+        this.api.on('didFinishLaunching', () => {
+            this._setupAccessories();
+        });
+    }
 
-    homebridge.registerAccessory("homebridge-texecom-full", "Texecom", TexecomAccessory);
-    homebridge.registerPlatform("homebridge-texecom-full", "Texecom", TexecomPlatform);
-}
+    // Required by v2 — called for each cached accessory; we don't cache, so no-op
+    configureAccessory(accessory) { }
 
-function TexecomPlatform(log, config) {
-    this.log = new LogUtil(
-        config.debug,
-        config.name,
-        log
-    );
-
-    this.serial_device = config["serial_device"];
-    this.baud_rate = config["baud_rate"];
-    this.zones = config["zones"] || [];
-    this.areas = config["areas"] || [];
-    this.ip_address = config["ip_address"];
-    this.ip_port = config["ip_port"];
-    this.udl = config["udl"];
-}
+    _setupAccessories() {
+        const platform = this;
+        const { hap, api } = this;
 
-TexecomPlatform.prototype = {
+        const zoneAccessories = this.zones.map(z => new TexecomAccessory(this.log, z, hap));
+        const areaAccessories = this.areas.map(a => new TexecomAccessory(this.log, a, hap));
+        const zoneCount = zoneAccessories.length;
+        const areaCount = areaAccessories.length;
 
-    accessories: function (callback) {
-        var zoneAccessories = [];
-        for (var i = 0; i < this.zones.length; i++) {
-            var zone = new TexecomAccessory(this.log, this.zones[i]);
-            zoneAccessories.push(zone);
-        }
-        var zoneCount = zoneAccessories.length;
+        // Publish all accessories as external accessories (no cache needed)
+        // UUID is namespaced with type prefix to prevent collisions between a zone
+        // and an area that share the same zone_number / SN.
+        const publishAccessory = (acc, typePrefix) => {
+            acc._platform = platform; // inject platform ref for onSet handler
+            const uuid = hap.uuid.generate(`${typePrefix}:${acc.sn}`);
+            const hapAcc = new api.platformAccessory(acc.name, uuid);
 
+            const [, mainSvc] = acc.getServices();
 
-        var areaAccessories = [];
-        for (var i = 0; i < this.areas.length; i++) {
-            var area = new TexecomAccessory(this.log, this.areas[i]);
-            areaAccessories.push(area);
-        }
-        var areaCount = areaAccessories.length;
+            // Populate the built-in AccessoryInformation service
+            hapAcc.getService(hap.Service.AccessoryInformation)
+                .setCharacteristic(hap.Characteristic.Manufacturer, "Homebridge")
+                .setCharacteristic(hap.Characteristic.Model, `Texecom ${typePrefix === "area" ? "Area" : "Zone"}`)
+                .setCharacteristic(hap.Characteristic.SerialNumber, acc.sn);
 
-        callback(zoneAccessories.concat(areaAccessories));
+            hapAcc.addService(mainSvc);
+            api.publishExternalAccessories("homebridge-texecom-full", [hapAcc]);
+        };
 
-        platform = this;
+        zoneAccessories.forEach(acc => publishAccessory(acc, "zone"));
+        areaAccessories.forEach(acc => publishAccessory(acc, "area"));
 
+        // ── Data processing ──────────────────────────────────────────────────
         function processData(data) {
-            // Received data is a zone update
             if (S(data).startsWith('"Z')) {
-                // Extract the data from the serial line received
                 var zone_data = Number(S(S(data).between('Z')).left(4).s);
-                // Extract the zone number that is being updated
                 var updated_zone = Number(S(S(data).between('Z')).left(3).s);
-                // Is the zone active?
                 var zone_active = S(zone_data).endsWith('1');
 
                 platform.log.debug(`Zone update received for zone ${updated_zone} active: ${zone_active}`);
@@ -89,106 +93,81 @@ TexecomPlatform.prototype = {
                                 try {
                                     areaAccessories[a].zones.forEach(zone => {
                                         if (zone == zpad(updated_zone, 3) && is_armed(areaAccessories[a].zone_number)) {
-
-                                            // Set the security system state to "ALARM_TRIGGERED"
-                                            stateValue = Characteristic.SecuritySystemCurrentState.ALARM_TRIGGERED;
+                                            var stateValue = hap.Characteristic.SecuritySystemCurrentState.ALARM_TRIGGERED;
                                             platform.log.log(`Area ${areaAccessories[a].zone_number} manual triggered`);
-
-                                            // Log the state change
-                                            platform.log.debug(`Area match found, updating area status in HomeKit to ${stateValue}`);
                                             setByAlarm = true;
                                             areaAccessories[a].changeHandler(stateValue);
-
                                         }
                                     });
-                                }
-                                catch (e) {
-                                    console.debug(`Error processing zones for area ${a} Please add zones under area.`);
+                                } catch (e) {
+                                    console.debug(`Error processing zones for area ${a}: Please add zones under area.`);
                                 }
                             }
                         }
                         break;
                     }
                 }
-            }
-            else if (S(data).startsWith('"A') || S(data).startsWith('"D') || S(data).startsWith('"L')) {
 
-                // Extract the area number that is being updated
+            } else if (S(data).startsWith('"A') || S(data).startsWith('"D') || S(data).startsWith('"L')) {
+                const Characteristic = hap.Characteristic;
                 var updated_area = Number(S(S(data).substring(2, 5)));
                 var status = S(data).substring(1, 2);
                 var user = S(data).substring(5, 7);
                 var stateValue;
-
-                let armedByUser = user;
+                const armedByUser = user;
 
                 switch (String(status)) {
                     case "L":
                         stateValue = Characteristic.SecuritySystemCurrentState.ALARM_TRIGGERED;
                         platform.log.log(`Area ${updated_area} triggered`);
                         break;
+
                     case "D":
                         stateValue = Characteristic.SecuritySystemCurrentState.DISARMED;
                         platform.log.log(`Area ${updated_area} disarmed by User ${user}`);
-                        areas_armed = areas_armed.filter(value => value !== zpad(updated_area, 3));
+                        areas_armed = areas_armed.filter(v => v !== zpad(updated_area, 3));
                         break;
-                    case "A":
-                        //user is for my setup
-                        //my user 17 is full armed (remote)
-                        //my user on app is 254
-                        //all the rest is night armed
 
+                    case "A":
                         if (user == "17") {
                             stateValue = Characteristic.SecuritySystemCurrentState.AWAY_ARM;
                             platform.log.log(`Area ${updated_area} armed (away) by User ${user}`);
-                        }
-                        else if (user == "25" || user == "254") {
-                            // Read the target state
+                        } else if (user == "25" || user == "254") {
                             const targetState = areaAccessories[updated_area - 1].target_State;
-
-                            // Map the targetState to the corresponding current state value
                             switch (targetState) {
                                 case Characteristic.SecuritySystemTargetState.AWAY_ARM:
-                                    stateValue = Characteristic.SecuritySystemCurrentState.AWAY_ARM;
-                                    break;
+                                    stateValue = Characteristic.SecuritySystemCurrentState.AWAY_ARM; break;
                                 case Characteristic.SecuritySystemTargetState.STAY_ARM:
-                                    stateValue = Characteristic.SecuritySystemCurrentState.STAY_ARM;
-                                    break;
+                                    stateValue = Characteristic.SecuritySystemCurrentState.STAY_ARM; break;
                                 case Characteristic.SecuritySystemTargetState.NIGHT_ARM:
-                                    stateValue = Characteristic.SecuritySystemCurrentState.NIGHT_ARM;
-                                    break;
+                                    stateValue = Characteristic.SecuritySystemCurrentState.NIGHT_ARM; break;
                                 case Characteristic.SecuritySystemTargetState.DISARM:
-                                    stateValue = Characteristic.SecuritySystemCurrentState.DISARMED;
-                                    break;
+                                    stateValue = Characteristic.SecuritySystemCurrentState.DISARMED; break;
                                 default:
                                     platform.log.error(`Unknown target state: ${targetState}`);
                                     return;
                             }
-
-                            platform.log.log(`User ${user}: Target state is ${targetState}, updated stateValue is ${stateValue}`);
-
-                        }
-                        else {
+                            platform.log.log(`User ${user}: Target state ${targetState} → stateValue ${stateValue}`);
+                        } else {
                             stateValue = Characteristic.SecuritySystemCurrentState.NIGHT_ARM;
                             platform.log.log(`Area ${updated_area} armed (night) by User ${user}`);
                         }
 
                         if (stateValue == Characteristic.SecuritySystemCurrentState.AWAY_ARM) {
-                            // Find the index of the first null or undefined value
-                            const index = areas_armed.findIndex(value => value === null || value === undefined);
-
-                            if (index !== -1) {
-                                // Replace the value at that index
-                                areas_armed[index] = zpad(updated_area, 3);
+                            const idx = areas_armed.findIndex(v => v === null || v === undefined);
+                            if (idx !== -1) {
+                                areas_armed[idx] = zpad(updated_area, 3);
                             } else {
-                                // If no open slot, append to the end
                                 areas_armed.push(zpad(updated_area, 3));
                             }
                         }
                         break;
+
                     default:
                         platform.log.log(`Unknown status letter ${status}`);
                         return;
                 }
+
                 for (var i = 0; i < areaCount; i++) {
                     if (areaAccessories[i].zone_number == updated_area) {
                         platform.log.debug(`Area match found, updating area status in HomeKit to ${stateValue}`);
@@ -197,21 +176,20 @@ TexecomPlatform.prototype = {
                         break;
                     }
                 }
+
             } else {
                 platform.log.debug(`Unknown string from Texecom: ${S(data)}`);
             }
         }
 
+        // ── IP connection with auto-reconnect ────────────────────────────────
         function setupConnection() {
             platform.log.log('Attempting connection to Texecom...');
 
-            connection = net.createConnection(platform.ip_port, platform.ip_address);
-
+            var connection = net.createConnection(platform.ip_port, platform.ip_address);
             connection.setNoDelay(true);
 
-            connection.on('connect', () => {
-                platform.log.log('Connected via IP');
-            });
+            connection.on('connect', () => platform.log.log('Connected via IP'));
 
             connection.on('data', function (data) {
                 platform.log.debug(`IP data received: ${data}`);
@@ -221,117 +199,75 @@ TexecomPlatform.prototype = {
 
             connection.on('error', (err) => {
                 platform.log.error('IP connection error:', err.message);
-                // We'll reconnect on 'close'
             });
 
             connection.on('close', () => {
-                platform.log.error('IP connection closed. Will attempt to reconnect in 10s.');
-                setTimeout(() => {
-                    setupConnection();  // try again
-                }, 10000);
+                platform.log.error('IP connection closed. Reconnecting in 10s...');
+                setTimeout(() => setupConnection(), 10000);
             });
 
-            connection.on('end', () => {
-                platform.log.log('IP connection ended');
-            });
+            connection.on('end', () => platform.log.log('IP connection ended'));
 
             platform.texecomConnection = connection;
         }
 
+        // ── Connect via serial or IP ─────────────────────────────────────────
         if (this.serial_device) {
-            var SerialPort = serialport.SerialPort;
-
-            serialPort = new SerialPort(this.serial_device, {
-                baudrate: this.baud_rate,
-                parser: serialport.parsers.readline("\n")
-            });
+            // serialport v12: baudRate (camelCase) + separate ReadlineParser
+            const { SerialPort } = require('serialport');
+            const { ReadlineParser } = require('@serialport/parser-readline');
 
-            serialPort.on("open", function () {
-                platform.log.log("Serial port opened");
-                serialPort.on('data', function (data) {
-                    platform.log.debug(`Serial data received: ${data}`);
-                    responseEmitter.emit('data', data);
-                    processData(data);
-                });
-            });
-            this.texecomConnection = serialPort;
-        } else if (this.ip_address) {
-
-            setupConnection();
+            const sp = new SerialPort({ path: this.serial_device, baudRate: this.baud_rate });
+            const parser = sp.pipe(new ReadlineParser({ delimiter: '\n' }));
 
+            sp.on("open", () => platform.log.log("Serial port opened"));
+            sp.on("error", (err) => platform.log.error("Serial port error:", err.message));
 
-            /*try {
-                connection = net.createConnection(platform.ip_port, platform.ip_address, function () {
-                    platform.log.log('Connected via IP');
-                });
-            } catch (err) {
-                platform.log.error(err);
-            }
-            connection.setNoDelay(true);
-
-            connection.on('data', function (data) {
-                platform.log.debug(`IP data received: ${data}`);
+            parser.on('data', function (data) {
+                platform.log.debug(`Serial data received: ${data}`);
                 responseEmitter.emit('data', data);
                 processData(data);
             });
 
+            platform.texecomConnection = sp;
 
-            connection.on('error', function (err) {
-                platform.log.error(`IP connection error: ${err}`);
-
-            });
-
-            connection.on('end', function () {
-                platform.log.log('IP connection ended');
-            });
+        } else if (this.ip_address) {
+            setupConnection();
 
-            connection.on('close', function () {
-                platform.log.log('IP connection closed');
-                try {
-                    connection = net.createConnection(platform.ip_port, platform.ip_address, function () {
-                        platform.log.log('Re-connected after loss of connection');
-                    });
-                } catch (err) {
-                    platform.log.error(err);
-                }
-            });
-            this.texecomConnection = connection;*/
         } else {
             this.log.log("Must set either serial_device or ip_address in configuration.");
         }
     }
 }
 
-
-function TexecomAccessory(log, config) {
+// ─── Accessory ───────────────────────────────────────────────────────────────
+function TexecomAccessory(log, config, hap) {
     this.log = log;
+    this.hap = hap;
 
     this.zone_number = zpad(config["zone_number"] || config["area_number"], 3);
     this.name = config["name"];
     this.zone_type = config["zone_type"] || config["area_type"] || "motion";
     this.dwell_time = config["dwell"] || 0;
+    this.dwell_timer = null;
 
     if (config["area_type"] == "securitysystem") {
-        this.target_State = Characteristic.SecuritySystemTargetState.DISARM;
+        this.target_State = hap.Characteristic.SecuritySystemTargetState.DISARM;
     }
+
     try {
         if (Array.isArray(config["zones"])) {
-            // If it's an array, apply zpad to each element
             this.zones = config["zones"].map(zone => zpad(zone, 3));
         } else {
-            // Otherwise, treat it as a single value
             this.zones = zpad(config["zones"], 3);
         }
-    } catch (e) {
-        //log.error('Error processing zones: ', e);
-    }
+    } catch (e) { /* no zones */ }
 
     if (config["sn"]) {
         this.sn = config["sn"];
     } else {
-        var shasum = crypto.createHash('sha1');
-        shasum.update(this.zone_number/* || this.area_number*/);
-
+        const shasum = crypto.createHash('sha1');
+        shasum.update(this.zone_number);
         this.sn = shasum.digest('base64');
         log.log(`Computed SN: ${this.sn}`);
     }
@@ -340,212 +276,183 @@ function TexecomAccessory(log, config) {
 TexecomAccessory.prototype = {
 
     getServices: function () {
-
+        const { Service, Characteristic } = this.hap;
         const me = this;
 
         var service, changeAction;
 
+        // informationService is returned but the platform populates the
+        // built-in one on the platformAccessory; this keeps the shape identical
         var informationService = new Service.AccessoryInformation();
-
         informationService
-            .setCharacteristic(Characteristic.Name, this.name)
             .setCharacteristic(Characteristic.Manufacturer, "Homebridge")
-            .setCharacteristic(Characteristic.Model, `Texecom ${(this.accessoryType === "zone" ? "Zone" : "Area")}`)
+            .setCharacteristic(Characteristic.Model, `Texecom ${this.zone_type === "securitysystem" ? "Area" : "Zone"}`)
             .setCharacteristic(Characteristic.SerialNumber, this.sn);
 
-
         switch (this.zone_type) {
             case "contact":
                 service = new Service.ContactSensor();
                 changeAction = function (newState) {
                     service.getCharacteristic(Characteristic.ContactSensorState)
-                        .setValue(newState ? Characteristic.ContactSensorState.CONTACT_NOT_DETECTED : Characteristic.ContactSensorState.CONTACT_DETECTED);
-                };
-                break;
-            case "motion":
-                service = new Service.MotionSensor();
-                changeAction = function (newState) {
-                    service.getCharacteristic(Characteristic.MotionDetected)
-                        .setValue(newState);
+                        .updateValue(newState
+                            ? Characteristic.ContactSensorState.CONTACT_NOT_DETECTED
+                            : Characteristic.ContactSensorState.CONTACT_DETECTED);
                 };
                 break;
+
             case "smoke":
                 service = new Service.SmokeSensor();
                 changeAction = function (newState) {
                     service.getCharacteristic(Characteristic.SmokeDetected)
-                        .setValue(newState ? Characteristic.ContactSensorState.SMOKE_DETECTED : Characteristic.ContactSensorState.SMOKE_NOT_DETECTED);
+                        .updateValue(newState
+                            ? Characteristic.SmokeDetected.SMOKE_DETECTED
+                            : Characteristic.SmokeDetected.SMOKE_NOT_DETECTED);
                 };
                 break;
+
             case "carbonmonoxide":
                 service = new Service.CarbonMonoxideSensor();
                 changeAction = function (newState) {
                     service.getCharacteristic(Characteristic.CarbonMonoxideDetected)
-                        .setValue(newState ? Characteristic.CarbonMonoxideDetected.CO_LEVELS_ABNORMAL : Characteristic.CarbonMonoxideDetected.CO_LEVELS_NORMAL);
+                        .updateValue(newState
+                            ? Characteristic.CarbonMonoxideDetected.CO_LEVELS_ABNORMAL
+                            : Characteristic.CarbonMonoxideDetected.CO_LEVELS_NORMAL);
                 };
                 break;
 
             case "securitysystem":
                 service = new Service.SecuritySystem();
 
-                changeAction = function (newState, user = "unknown") {
+                changeAction = function (newState) {
                     var targetState;
                     switch (newState) {
                         case Characteristic.SecuritySystemCurrentState.NIGHT_ARM:
-                            targetState = Characteristic.SecuritySystemTargetState.NIGHT_ARM;
-                            break;
+                            targetState = Characteristic.SecuritySystemTargetState.NIGHT_ARM; break;
                         case Characteristic.SecuritySystemCurrentState.AWAY_ARM:
-                            targetState = Characteristic.SecuritySystemTargetState.AWAY_ARM;
-                            break;
+                            targetState = Characteristic.SecuritySystemTargetState.AWAY_ARM; break;
                         case Characteristic.SecuritySystemCurrentState.STAY_ARM:
-                            targetState = Characteristic.SecuritySystemTargetState.STAY_ARM;
-                            break;
+                            targetState = Characteristic.SecuritySystemTargetState.STAY_ARM; break;
                         case Characteristic.SecuritySystemCurrentState.DISARMED:
-                            targetState = Characteristic.SecuritySystemTargetState.DISARM;
-                            break;
+                            targetState = Characteristic.SecuritySystemTargetState.DISARM; break;
                         default:
-                            targetState = null; // alarm triggered has no corresponding target state
-                            break;
+                            targetState = null; break;
                     }
-                    service.getCharacteristic(Characteristic.SecuritySystemCurrentState).setValue(newState);
-
                     if (targetState != null) {
-                        service.getCharacteristic(Characteristic.SecuritySystemTargetState).setValue(targetState);
                         service.getCharacteristic(Characteristic.SecuritySystemTargetState).updateValue(targetState);
                     }
                     service.getCharacteristic(Characteristic.SecuritySystemCurrentState).updateValue(newState);
-                    me.log.debug(`Set target state ${targetState} and current state ${newState} in response to notification from alarm`);
+                    me.log.debug(`Set target state ${targetState} and current state ${newState}`);
                 };
 
-                // we don't know the alarm's state at startup, safer to assume disarmed:
+                // Safe default on startup
                 changeAction(Characteristic.SecuritySystemCurrentState.DISARMED);
+
                 var area = this;
 
+                // v2: onSet returns a Promise; deprecated on('set', cb) removed
                 service.getCharacteristic(Characteristic.SecuritySystemTargetState)
-                    .on('set', function (value, callback) {
-                        if (setByAlarm) {
-                            platform.log.debug(`Not sending command to alarm for change to state ${value} because the state change appears to have come from the alarm itself.`);
-                            setByAlarm = false;
-                            return;
-                        }
-                        if (platform.udl != null) {
-                            areaTargetSecurityStateSet(platform, area, service, value, callback);
-                        } else {
-                            platform.log.debug("No UDL configured. Add your UDL to enable arm/disarm from HomeKit.");
-                            callback(new Error("No UDL configured"));
-                        }
+                    .onSet(function (value) {
+                        return new Promise((resolve, reject) => {
+                            if (setByAlarm) {
+                                me.log.debug(`Ignoring set — state change came from alarm itself.`);
+                                setByAlarm = false;
+                                resolve();
+                                return;
+                            }
+                            // platform reference is injected after construction
+                            const platform = me._platform;
+                            if (platform && platform.udl != null) {
+                                areaTargetSecurityStateSet(platform, area, service, value,
+                                    (err) => err ? reject(err) : resolve());
+                            } else {
+                                me.log.debug("No UDL configured. Add UDL to enable arm/disarm from HomeKit.");
+                                reject(new Error("No UDL configured"));
+                            }
+                        });
                     });
                 break;
 
-
-            default:
+            default: // motion (and fallback)
                 service = new Service.MotionSensor();
                 changeAction = function (newState) {
-                    service.getCharacteristic(Characteristic.MotionDetected)
-                        .setValue(newState);
+                    service.getCharacteristic(Characteristic.MotionDetected).updateValue(newState);
                 };
                 break;
         }
 
-        this.changeHandler = function (status, user = "unknown") {
-            var newState = status;
-            platform.log.debug(`Dwell = ${this.dwell_time}`);
-
-            if (!newState && this.dwell_time > 0) {
-                this.dwell_timer = setTimeout(function () { changeAction(newState); }.bind(this), this.dwell_time);
+        this.changeHandler = function (status) {
+            const newState = status;
+            me.log.debug(`Dwell = ${me.dwell_time}`);
+            if (!newState && me.dwell_time > 0) {
+                me.dwell_timer = setTimeout(() => changeAction(newState), me.dwell_time);
             } else {
-                if (this.dwell_timer) {
-                    clearTimeout(this.dwell_timer);
-                }
+                if (me.dwell_timer) clearTimeout(me.dwell_timer);
                 changeAction(newState);
             }
-
-            if (user == "unknown") {
-                platform.log.debug(`Changing state with changeHandler to ${newState}`);
-            }
-            else {
-                platform.log.debug(`Changing state with changeHandler to ${newState} by User ${user}`);
-            }
-
-        }.bind(this);
+        };
 
         return [informationService, service];
     }
 };
 
+// ─── Arm/disarm command ───────────────────────────────────────────────────────
 function areaTargetSecurityStateSet(platform, accessory, service, value, callback) {
+    const { Characteristic } = platform.hap;
 
     const hexMapping = {
-        '1': 0x01,
-        '2': 0x02,
-        '3': 0x04,
-        '4': 0x08,
-        '5': 0x10,
-        '6': 0x20,
-        '7': 0x40,
-        '8': 0x80
+        '1': 0x01, '2': 0x02, '3': 0x04, '4': 0x08,
+        '5': 0x10, '6': 0x20, '7': 0x40, '8': 0x80
     };
 
     var area_number = String.fromCharCode(parseInt(hexMapping[parseInt(accessory.zone_number, 10)], 16));
 
-
     var command;
     switch (value) {
         case Characteristic.SecuritySystemTargetState.NIGHT_ARM:
         case Characteristic.SecuritySystemTargetState.STAY_ARM:
-            command = `Y${area_number}`;  // Home
-            break;
+            command = `Y${area_number}`; break;
         case Characteristic.SecuritySystemTargetState.AWAY_ARM:
-            command = `A${area_number}`; // Away arm
-            break;
+            command = `A${area_number}`; break;
         case Characteristic.SecuritySystemTargetState.DISARM:
-            command = `D${area_number}`; // Disarm
-            break;
+            command = `D${area_number}`; break;
         default:
-            this.log.debug(`Unknown target state: ${value}`);
+            platform.log.debug(`Unknown target state: ${value}`);
             callback(new Error("Unknown target state"));
             return;
     }
 
-    platform.log.debug(`Sending arm/disarm command ${value} to area ${accessory.zone_number}`);
-
-
-
+    platform.log.debug(`Sending command ${value} to area ${accessory.zone_number}`);
 
     writeCommandAndWaitForOK(platform.texecomConnection, `W${platform.udl}`)
         .then(() => writeCommandAndWaitForOK(platform.texecomConnection, command, 0))
         .then(() => {
-            // OK response from alarm is only indication that the target state has been reached
             var currentState;
             switch (value) {
                 case Characteristic.SecuritySystemTargetState.NIGHT_ARM:
-                    currentState = Characteristic.SecuritySystemCurrentState.NIGHT_ARM;
-                    break;
+                    currentState = Characteristic.SecuritySystemCurrentState.NIGHT_ARM; break;
                 case Characteristic.SecuritySystemTargetState.AWAY_ARM:
-                    currentState = Characteristic.SecuritySystemCurrentState.AWAY_ARM;
-                    break;
+                    currentState = Characteristic.SecuritySystemCurrentState.AWAY_ARM; break;
                 case Characteristic.SecuritySystemTargetState.STAY_ARM:
-                    currentState = Characteristic.SecuritySystemCurrentState.STAY_ARM;
-                    break;
+                    currentState = Characteristic.SecuritySystemCurrentState.STAY_ARM; break;
                 case Characteristic.SecuritySystemTargetState.DISARM:
-                    currentState = Characteristic.SecuritySystemCurrentState.DISARMED;
-                    break;
+                    currentState = Characteristic.SecuritySystemCurrentState.DISARMED; break;
                 default:
                     platform.log.debug(`Unknown target alarm state ${value}`);
                     callback(new Error("Unknown target state"));
                     return;
             }
-            platform.log.debug(`Setting current status of area ${accessory.zone_number} to ${currentState} because alarm responded OK`);
-            service.getCharacteristic(Characteristic.SecuritySystemCurrentState)
-                .updateValue(currentState);
+            platform.log.debug(`Area ${accessory.zone_number} → state ${currentState}`);
+            service.getCharacteristic(Characteristic.SecuritySystemCurrentState).updateValue(currentState);
             accessory.target_State = currentState;
             callback();
         })
-        .catch((err) => {
-            platform.log.debug(`Callback with error ${err}`);
-            callback(err); // Handle errors
+        .catch(err => {
+            platform.log.debug(`Command error: ${err}`);
+            callback(err);
         });
 }
 
+// ─── Command writer ───────────────────────────────────────────────────────────
 function writeCommandAndWaitForOK(connection, command, retryCount = 1) {
     return new Promise((resolve, reject) => {
         function handleData(data) {
@@ -559,18 +466,16 @@ function writeCommandAndWaitForOK(connection, command, retryCount = 1) {
 
         connection.write(`\\${command}/`, function (err) {
             if (err) {
-                platform.log.debug(`Error writing to connection: ${err}`);
+                responseEmitter.removeListener('data', handleData);
                 reject(err);
-            } else {
-                platform.log.debug(`Command sent: ${command}`);
             }
         });
 
         setTimeout(() => {
             responseEmitter.removeListener('data', handleData);
             if (retryCount > 0) {
-                platform.log.debug(`Retrying command due to timeout, retries left: ${retryCount}`);
-                writeCommandAndWaitForOK(connection, command, retryCount - 1).then(resolve).catch(reject);
+                writeCommandAndWaitForOK(connection, command, retryCount - 1)
+                    .then(resolve).catch(reject);
             } else {
                 reject(new Error("Timeout after retries"));
             }
@@ -578,8 +483,7 @@ function writeCommandAndWaitForOK(connection, command, retryCount = 1) {
     });
 }
 
+// ─── Helpers ──────────────────────────────────────────────────────────────────
 function is_armed(area_number) {
-    let isAreaArmed = areas_armed.some(value => value === area_number);
-
-    return isAreaArmed;
+    return areas_armed.some(v => v === area_number);
 }

package/package.json

@@ -2,7 +2,7 @@
   "displayName": "Homebridge Texecom",
   "name": "homebridge-texecom-full",
   "description": "A plugin for homebridge to integrate Texecom Premier Elite alarm systems into HomeKit",
-  "version": "4.2.8",
+  "version": "4.3.0-beta.1",
   "author": {
     "name": "Chris Posthumus",
     "email": "chris.posthumus@gmail.com"
@@ -13,7 +13,7 @@
     "url": "https://github.com/K1LL3R234/homebridge-texecom.git"
   },
   "bugs": {
-    "url": "https://https://github.com/K1LL3R234/homebridge-texecom/issues"
+    "url": "https://github.com/K1LL3R234/homebridge-texecom/issues"
   },
   "funding": [
     {
@@ -39,9 +39,8 @@
     "Texecom"
   ],
   "engines": {
-    "homebridge": "^1.6.0 || ^2.0.0-beta.0",
-    "node": ">=18.20.4",
-    "python": ">=3.6.0"
+    "homebridge": ">=2.0.0",
+    "node": ">=18.20.4"
   },
   "homebridge": {
     "platforms": [
@@ -49,9 +48,11 @@
     ]
   },
   "dependencies": {
+    "@serialport/parser-readline": "^12.0.0",
+    "crypto-js": "^4.2.0",
     "debug": "^4.2.0",
     "serialport": "^12.0.0",
     "string": ">=3.3.3",
     "zpad": "^0.5.0"
   }
-}
+}