node-red-contrib-homebridge-automation 0.1.12-beta.19 → 0.1.12-beta.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-homebridge-automation",
-  "version": "0.1.12-beta.19",
+  "version": "0.1.12-beta.20",
   "description": "NodeRED Automation for HomeBridge",
   "main": "src/HAP-NodeRed.js",
   "scripts": {

package/src/hbBaseNode.js

@@ -2,425 +2,160 @@ const debug = require('debug')('hapNodeRed:hbBaseNode');
 
 class HbBaseNode {
   constructor(config, RED) {
-    debug("HbBaseNode - constructor", config);
-    // RED.nodes.createNode(this, config);
+    debug("Constructor:", config);
     RED.nodes.createNode(this, config);
+
     if (!config.conf) {
-      debug('Warning: %s @ %s.%s not connected to a HB Configuration Node', config.type, config.x, config.y);
+      this.error(`Warning: ${config.type} @ (${config.x}, ${config.y}) not connected to a HB Configuration Node`);
     }
-    this.hbConfigNode = RED.nodes.getNode(config.conf); // The configuration node
-    // console.log("HbBaseNode - conf", this.conf);
+
     this.config = config;
+    this.hbConfigNode = RED.nodes.getNode(config.conf);
     this.confId = config.conf;
     this.device = config.device;
     this.service = config.Service;
     this.name = config.name;
     this.fullName = `${config.name} - ${config.Service}`;
-
     this.hbDevice = null;
-    this.hbConfigNode.register(this);
+
+    this.hbConfigNode?.register(this);
+
     if (this.handleInput) {
       this.on('input', this.handleInput.bind(this));
     }
     this.on('close', this.handleClose.bind(this));
   }
 
-  /**
-   * Common logic for registering the node
-   */
   registerNode() {
-    debug("hbBaseNode Registered:", this.fullName);
-
+    debug("Registering node:", this.fullName);
     this.hbDevice = hbDevices.findDevice(this.device);
 
-    if (this.hbDevice) {
-      this.deviceType = this.hbDevice.deviceType;
+    if (!this.hbDevice) {
+      this.error(`Device not found: ${this.device}`);
     } else {
-      this.error(`437: Can't find device ${this.device}`, null);
+      this.deviceType = this.hbDevice.deviceType;
     }
   }
 
-  /**
-   * Common logic for handling the close event
-   * @param {Function} callback - Callback to be executed on close
-   */
   handleClose(callback) {
     callback();
   }
 
-  /**
-   * Convert a HB message to a node message
-   * @param {*} hbMessage 
-   * @param {*} node 
-   * @returns 
-   */
-  _convertHBcharactericToNode(hbMessage, node) {
-    // debug("_convertHBcharactericToNode", node.device);
-    var payload = {};
+  _convertHBcharacteristicToNode(hbMessage, node) {
+    let payload = {};
     if (!hbMessage.payload) {
-      var device = hbDevices.findDevice(node.device);
-      // debug("Device", device);
-
-      // characteristics = Object.assign(characteristics, characteristic.characteristic);
+      const device = hbDevices.findDevice(node.device);
       if (device) {
-        hbMessage.forEach(function (characteristic) {
-          // debug("Exists", (device.characteristics[characteristic.aid + '.' + characteristic.iid]));
-          if (device.characteristics[characteristic.aid + '.' + characteristic.iid]) {
-            payload = Object.assign(payload, {
-              [device.characteristics[characteristic.aid + '.' + characteristic.iid].characteristic]: characteristic.value
-            });
+        hbMessage.forEach(characteristic => {
+          const charKey = `${characteristic.aid}.${characteristic.iid}`;
+          if (device.characteristics[charKey]) {
+            payload[device.characteristics[charKey].characteristic] = characteristic.value;
           }
         });
       }
     } else {
       payload = hbMessage.payload;
     }
-    // debug("payload", payload);
-    return (payload);
+    return payload;
   }
 
-  /**
-   * Create a HB ontrol message for a device
-   * @param {*} payload 
-   * @param {*} node 
-   * @param {*} device 
-   * @returns 
-   */
   _createControlMessage(payload, node, device) {
-    // debug("_createControlMessage", payload, device);
-    // debug("Device", device, device.characteristics[event.aid + '.' + event.iid]);
-    var response = [];
-
-    for (var key in payload) {
-      // debug("IID", key, _getKey(device.characteristics, key));
-      if (this._getKey(device.characteristics, key)) {
+    const response = [];
+    for (const key in payload) {
+      const characteristic = this._getKey(device.characteristics, key);
+      if (characteristic) {
         response.push({
-          "aid": device.aid,
-          "iid": this._getKey(device.characteristics, key).iid,
-          "value": payload[key]
+          aid: device.aid,
+          iid: characteristic.iid,
+          value: payload[key],
         });
       } else {
-        this.warn("Characteristic '" + key + "' is not valid.\nTry one of these: " + device.descriptions);
-        node.status({
-          text: 'warn - Invalid Characteristic ' + key,
-          shape: 'ring',
-          fill: 'yellow'
-        });
+        this.warn(`Invalid characteristic: '${key}'. Available: ${device.descriptions}`);
+        node.status({ text: `Invalid characteristic: ${key}`, shape: 'ring', fill: 'yellow' });
       }
     }
-    return ({
-      "characteristics": response
-    });
+    return { characteristics: response };
   }
 
-
-  /**
-   * Return the status of a device
-   * @param {*} nrDevice 
-   * @param {*} node 
-   * @param {*} perms 
-   * @returns 
-   */
   async _status(nrDevice, node, perms) {
-    debug("_status", nrDevice);
-    let error;
     try {
-      if (!this.hbDevices) {
-        throw new Error('_status hbDevices not initialized');
-      }
-
       const device = hbDevices.findDevice(node.device, perms);
-      if (device) {
-        let status, message;
-        switch (device.type) {
-          case "00000110": // Camera RTPStream Management
-          case "00000111": // Camera Control
-            message = {
-              "resource-type": "image",
-              "image-width": 1920,
-              "image-height": 1080
-            };
-            debug("_status Control %s -> %s", device.id, JSON.stringify(message));
-
-            // Await the result of HAPresourceByDeviceIDAsync
-            status = await this.HAPresourceByDeviceIDAsync(device.id, JSON.stringify(message));
-
-            debug("_status Controlled %s:%s ->", device.host, device.port);
-            node.status({
-              text: 'sent',
-              shape: 'dot',
-              fill: 'green'
-            });
-
-            clearTimeout(node.timeout);
-            node.timeout = setTimeout(() => {
-              node.status({});
-            }, 30 * 1000);
-
-            return {
-              characteristics: {
-                payload: btoa(status)
-              }
-            };
-
-          default:
-            message = '?id=' + device.getCharacteristics;
-            debug("_status request: %s -> %s:%s ->", node.fullName, device.id, message);
-
-            // Await the result of HAPstatusByDeviceIDAsync
-            status = await this.HAPstatusByDeviceIDAsync(device.id, message);
+      if (!device) throw new Error(`Device not found: ${nrDevice}`);
 
-            node.status({
-              text: 'sent',
-              shape: 'dot',
-              fill: 'green'
-            });
+      const message = device.type === "00000110" || device.type === "00000111"
+        ? { "resource-type": "image", "image-width": 1920, "image-height": 1080 }
+        : `?id=${device.getCharacteristics}`;
 
-            clearTimeout(node.timeout);
-            node.timeout = setTimeout(() => {
-              node.status({});
-            }, 30 * 1000);
+      const status = device.type === "00000110" || device.type === "00000111"
+        ? await this.HAPresourceByDeviceIDAsync(device.id, JSON.stringify(message))
+        : await this.HAPstatusByDeviceIDAsync(device.id, message);
 
-            return status;
-        }
-      } else {
-        error = "Device not found: " + nrDevice;
-        node.status({
-          text: 'Device not found',
-          shape: 'ring',
-          fill: 'red'
-        });
-        throw new Error(error);
-      }
+      node.status({ text: 'Success', shape: 'dot', fill: 'green' });
+      return device.type === "00000110" || device.type === "00000111"
+        ? { characteristics: { payload: this.btoa(status) } }
+        : status;
     } catch (err) {
       debug("Error in _status:", err);
-      error = "Homebridge not initialized -2";
-      node.status({
-        text: error,
-        shape: 'ring',
-        fill: 'red'
-      });
-      // throw new Error(error);
+      node.status({ text: 'Error retrieving status', shape: 'ring', fill: 'red' });
+      throw err;
     }
   }
 
-  /**
-   * Control a HB Device
-   * @param {*} node 
-   * @param {*} payload 
-   * @returns 
-   */
   async _control(node, payload) {
-    debug("_control", node, payload);
     try {
-      if (!this.hbDevices) {
-        throw new Error('hbDevices not initialized');
-      }
-
-      const device = hbDevices.findDevice(node.device, {
-        perms: 'pw'
-      });
-
-      if (device) {
-        let message;
-        switch (device.type) {
-          case "00000110": // Camera RTPStream Management
-          case "00000111": // Camera Control
-            {
-              message = {
-                "resource-type": "image",
-                "image-width": 1920,
-                "image-height": 1080,
-                "aid": node.hbDevice.aid
-              };
-              debug("Control %s ->", device.id, node.fullName, JSON.stringify(message));
+      const device = hbDevices.findDevice(node.device, { perms: 'pw' });
+      if (!device) throw new Error('Device not available');
 
-              // Await the result of HAPresourceByDeviceIDAsync
-              const status = await this.HAPresourceByDeviceIDAsync(device.id, JSON.stringify(message));
+      const message = typeof payload === "object"
+        ? this._createControlMessage(payload, node, device)
+        : null;
 
-              node.status({
-                text: JSON.stringify(payload).slice(0, 30) + '...',
-                shape: 'dot',
-                fill: 'green'
-              });
-
-              clearTimeout(node.timeout);
-              node.timeout = setTimeout(() => {
-                node.status({});
-              }, 30 * 1000);
-
-              return status;
-            }
-          default:
-            if (typeof payload === "object") {
-              message = this._createControlMessage.call(this, payload, node, device);
-              debug("Control %s ->", device.id, JSON.stringify(message));
-
-              if (message.characteristics.length > 0) {
-                // Await the result of HAPcontrolByDeviceIDAsync
-                const status = await this.HAPcontrolByDeviceIDAsync(device.id, JSON.stringify(message));
-
-                if (status && status.characteristics[0].status === 0) {
-                  debug("Controlled %s ->", device.id, JSON.stringify(status));
-                  node.status({
-                    text: JSON.stringify(payload).slice(0, 30) + '...',
-                    shape: 'dot',
-                    fill: 'green'
-                  });
-
-                  clearTimeout(node.timeout);
-                  node.timeout = setTimeout(() => {
-                    node.status({});
-                  }, 10 * 1000);
-
-                  return; // Successful control, no error
-                } else {
-                  debug("Controlled %s ->", device.id, payload);
-                  node.status({
-                    text: JSON.stringify(payload).slice(0, 30) + '...',
-                    shape: 'dot',
-                    fill: 'green'
-                  });
-
-                  clearTimeout(node.timeout);
-                  node.timeout = setTimeout(() => {
-                    node.status({});
-                  }, 10 * 1000);
-
-                  return; // Status controlled, no error
-                }
-              } else {
-                throw new Error('Invalid payload');
-              }
-            } else {
-              throw new Error("Payload should be a JSON object containing device characteristics and values.");
-            }
-        }
+      if (message && message.characteristics.length > 0) {
+        const status = await this.HAPcontrolByDeviceIDAsync(device.id, JSON.stringify(message));
+        node.status({ text: 'Controlled', shape: 'dot', fill: 'green' });
+        return status;
       } else {
-        throw new Error('Device not available');
+        throw new Error('Invalid payload');
       }
     } catch (err) {
       debug("Error in _control:", err);
-      let error = err.message || "Homebridge not initialized - 3";
-      node.status({
-        text: error,
-        shape: 'ring',
-        fill: 'red'
-      });
-      // throw new Error(error);
+      node.status({ text: 'Control error', shape: 'ring', fill: 'red' });
+      throw err;
     }
   }
 
   async _register(node) {
-    debug("_register", node.device);
     try {
-      debug("_register", node.device);
       const device = hbDevices.findDevice(node.device, { perms: 'ev' });
-
-      if (node.type === 'hb-event' || node.type === 'hb-resume') {
-        const message = {
-          "characteristics": device.eventRegisters
-        };
-        debug("_register", node.fullName, device.id, message);
-
-        // Use the shared async function here
-        const status = await hapEventByDeviceIDAsync(device.id, JSON.stringify(message));
-
-        // Check the result of the operation
-        if (status === null) {
-          debug("%s registered: %s -> %s", node.type, node.fullName, device.id);
-        } else {
-          debug("%s registered: %s -> %s", node.type, node.fullName, device.id, JSON.stringify(status));
-        }
+      if (device) {
+        const message = { characteristics: device.eventRegisters };
+        await hapEventByDeviceIDAsync(device.id, JSON.stringify(message));
       }
     } catch (err) {
-      // Handle errors that occur in the async function
       debug("Error in _register:", err);
-      // You can handle errors here, like logging or setting the status
-      node.status({
-        text: 'error',
-        shape: 'ring',
-        fill: 'red'
-      });
+      node.status({ text: 'Register error', shape: 'ring', fill: 'red' });
     }
   }
 
-  _getObjectDiff(obj1, obj2) {
-    const diff = Object.keys(obj1).reduce((result, key) => {
-      if (!obj2.hasOwnProperty(key)) {
-        result.push(key);
-      } else if (obj1[key] === obj2[key]) {
-        const resultKeyIndex = result.indexOf(key);
-        result.splice(resultKeyIndex, 1);
-      }
-      return result;
-    }, Object.keys(obj2));
-
-    return diff;
-  }
-
   _getKey(obj, value) {
-    for (var key in obj) {
-      // debug("%s === %s", obj[key].characteristic, value);
-      // debug("%s === %s", obj[key].characteristic.toLowerCase(), value.toLowerCase());
-      if (obj[key].characteristic.toLowerCase() === value.toLowerCase()) {
-        return obj[key];
-      }
-    }
-    return null;
+    return Object.values(obj).find(char => char.characteristic.toLowerCase() === value.toLowerCase()) || null;
   }
 
   btoa(str) {
-    var buffer;
-
-    if (str instanceof Buffer) {
-      buffer = str;
-    } else {
-      buffer = Buffer.from(str.toString(), 'binary');
-    }
-
-    return buffer.toString('base64');
+    return Buffer.from(str.toString(), 'binary').toString('base64');
   }
 
-
-  // Helper function to promisify HAPresourceByDeviceID
   async HAPresourceByDeviceIDAsync(deviceId, message) {
     return new Promise((resolve, reject) => {
-      homebridge.HAPresourceByDeviceID(deviceId, message, (err, status) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(status);
-        }
-      });
+      homebridge.HAPresourceByDeviceID(deviceId, message, (err, status) => err ? reject(err) : resolve(status));
     });
   }
 
-  // Helper function to promisify HAPstatusByDeviceID
   async HAPstatusByDeviceIDAsync(deviceId, message) {
     return new Promise((resolve, reject) => {
-      homebridge.HAPstatusByDeviceID(deviceId, message, (err, status) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(status);
-        }
-      });
+      homebridge.HAPstatusByDeviceID(deviceId, message, (err, status) => err ? reject(err) : resolve(status));
     });
   }
-
-  async hapEventByDeviceIDAsync(deviceId, message) {
-    return new Promise((resolve, reject) => {
-      homebridge.HAPeventByDeviceID(deviceId, message, (err, status) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(status);
-        }
-      });
-    });
-  }
-
 }
 
 module.exports = HbBaseNode;

package/src/hbConfigNode.js

@@ -1,47 +1,32 @@
 const hbBaseNode = require('./hbBaseNode.js');
-// const HAPNodeJSClient = require('hap-node-client').HAPNodeJSClient;
 const { HapClient } = require('@homebridge/hap-client');
 const debug = require('debug')('hapNodeRed:hbConfigNode');
 const { Homebridges } = require('./lib/Homebridges.js');
 const { Log } = require('./lib/logger.js');
-var Queue = require('better-queue');
-const { manualSync } = require('rimraf');
+const Queue = require('better-queue');
 
 class HBConfigNode {
   constructor(config, RED) {
     if (!config.jest) {
       RED.nodes.createNode(this, config);
-      this.username = config.username;
-      this.macAddress = config.macAddress || '';
-      this.password = this.password;
-      this.on('close', function () {
-        this.hbConf.close(); // Close any open connections
-      });
 
-      // console.log('HBConfNode', config);
       this.username = config.username;
       this.macAddress = config.macAddress || '';
-      // this.password = config.credentials.password;
       this.users = {};
       this.homebridge = null;
       this.evDevices = [];
       this.ctDevices = [];
       this.hbDevices = [];
-
-      this.clientNodes = []; // An array of client nodes attached
-
+      this.clientNodes = [];
       this.log = new Log(console, true);
 
-      this.reqisterQueue = new Queue((clientNode, cb) => {
-        // debug('Queue execute', clientNode);
-        this._register(clientNode, cb);
-      }, {
+      this.reqisterQueue = new Queue(this._register.bind(this), {
         concurrent: 1,
         autoResume: false,
         maxRetries: 1000,
         retryDelay: 30000,
         batchDelay: 2000,
-        batchSize: 150
+        batchSize: 150,
       });
       this.reqisterQueue.pause();
 
@@ -52,33 +37,28 @@ class HBConfigNode {
       });
 
       this.waitForNoMoreDiscoveries();
-      this.hapClient.on('instance-discovered', () => this.waitForNoMoreDiscoveries);
+      this.hapClient.on('instance-discovered', this.waitForNoMoreDiscoveries);
+
+      this.on('close', () => {
+        this.close();
+      });
     }
   }
 
   waitForNoMoreDiscoveries = () => {
-    // Clear any existing timeout
     if (this.discoveryTimeout) {
       clearTimeout(this.discoveryTimeout);
     }
 
-    // Set up the timeout
     this.discoveryTimeout = setTimeout(() => {
       this.log.debug('No more instances discovered, publishing services');
       this.hapClient.removeListener('instance-discovered', this.waitForNoMoreDiscoveries);
-      // debug('waitfornomore', this);
       this.handleReady();
-      // this.requestSync();
-      // this.hapClient.on('instance-discovered', this.requestSync.bind(this));  // Request sync on new instance discovery
     }, 5000);
   };
 
-  // Handle Homebridge 'Ready' event
-  async handleReady(accessories) {
-    this.hbDevices = await this.hapClient.getAllServices(accessories);
-    // debug('handleReady', JSON.stringify(this.hbDevices, null, 2));
-    debug('Discovered %s new evDevices', this.toList({ perms: 'ev' }).length);
-
+  async handleReady() {
+    this.hbDevices = await this.hapClient.getAllServices();
     this.evDevices = this.toList({ perms: 'ev' });
     this.ctDevices = this.toList({ perms: 'pw' });
     this.handleDuplicates(this.evDevices);
@@ -86,75 +66,32 @@ class HBConfigNode {
     this.reqisterQueue.resume();
   }
 
-
-
   toList(perms) {
-
-    function supportedServiceType(service) {
-      switch (service.humanType) {
-        case 'Battery':
-        case 'Carbon Dioxide Sensor':
-        case 'Carbon Monoxide Sensor':
-        case 'Doorbell':
-        case 'Fan':
-        case 'Fanv2':
-        case 'Garage Door Opener':
-        case 'Humidity Sensor':
-        case 'Input Source':
-        case 'Leak Sensor':
-        case 'Lightbulb':
-        case 'Lock Mechanism':
-        case 'Motion Sensor':
-        case 'Occupancy Sensor':
-        case 'Outlet':
-        case 'Smoke Sensor':
-        case 'Speaker':
-        case 'Stateless Programmable Switch':
-        case 'Switch':
-        case 'Switch':
-        case 'Television':
-        case 'Temperature Sensor':
-        case 'Thermostat':
-        case 'Contact Sensor':
-          return true;
-        case 'Camera Operating Mode':
-        case 'Camera Rtp Stream Management':
-        case 'Protocol Information':
-
-          return false;
-        default:
-          debug('Unsupport HomeKit Service Type \'%s\':', service.humanType);
-      }
-    }
-
-    // debug('toList', this.hbDevices);
-    return this.hbDevices.filter(service => supportedServiceType(service)).map(service => ({
-      name: `${service.serviceName}`,
-      fullName: `${service.serviceName} - ${service.type}`,
-      sortName: `${service.serviceName}:${service.type}`,
-      uniqueId: `${service.instance.name}${service.instance.username}${service.accessoryInformation.Manufacturer}${service.serviceName}${service.uuid.slice(0, 8)}`, homebridge: `${service.instance.name}`,
-      service: `${service.type}`,
-      manufacturer: `${service.accessoryInformation.Manufacturer}`
-    })).sort((a, b) => (a.sortName > b.sortName) ? 1 : ((b.sortName > a.sortName) ? -1 : 0));;
-  }
-  /**
-  * Start processing
-  */
-  async start() {
-    this.services = await this.loadAccessories();
-    this.log.info(`Discovered ${this.services.length} accessories`);
-    this.ready = true;
-    await this.buildSyncResponse();
-    const evServices = this.services.filter(x => this.evTypes.some(uuid => x.serviceCharacteristics.find(c => c.uuid === uuid)));
-    this.log.debug(`Monitoring ${evServices.length} services for changes`);
-
-    const monitor = await this.hapClient.monitorCharacteristics(evServices);
-    monitor.on('service-update', (services) => {
-      this.reportStateSubject.next(services[0].uniqueId);
-    });
+    const supportedServiceType = (service) => {
+      const supportedTypes = [
+        'Battery', 'Carbon Dioxide Sensor', 'Carbon Monoxide Sensor', 'Doorbell',
+        'Fan', 'Fanv2', 'Garage Door Opener', 'Humidity Sensor', 'Input Source',
+        'Leak Sensor', 'Lightbulb', 'Lock Mechanism', 'Motion Sensor', 'Occupancy Sensor',
+        'Outlet', 'Smoke Sensor', 'Speaker', 'Stateless Programmable Switch', 'Switch',
+        'Television', 'Temperature Sensor', 'Thermostat', 'Contact Sensor',
+      ];
+      return supportedTypes.includes(service.humanType);
+    };
+
+    return this.hbDevices
+      .filter(service => supportedServiceType(service))
+      .map(service => ({
+        name: service.serviceName,
+        fullName: `${service.serviceName} - ${service.type}`,
+        sortName: `${service.serviceName}:${service.type}`,
+        uniqueId: `${service.instance.name}${service.instance.username}${service.accessoryInformation.Manufacturer}${service.serviceName}${service.uuid.slice(0, 8)}`,
+        homebridge: service.instance.name,
+        service: service.type,
+        manufacturer: service.accessoryInformation.Manufacturer,
+      }))
+      .sort((a, b) => a.sortName.localeCompare(b.sortName));
   }
 
-  // Handle duplicate devices
   handleDuplicates(list) {
     const seenFullNames = new Set();
     const seenUniqueIds = new Set();
@@ -165,9 +102,7 @@ class HBConfigNode {
       } else {
         seenFullNames.add(endpoint.fullName);
       }
-    }
 
-    for (const endpoint of list) {
       if (seenUniqueIds.has(endpoint.uniqueId)) {
         console.error('ERROR: Parsing failed, duplicate uniqueID.', endpoint.fullName);
       } else {
@@ -176,62 +111,41 @@ class HBConfigNode {
     }
   }
 
-  // Register a device node
   register(clientNode) {
-    // debug('hbConf.register', clientNode);
     debug('Register %s -> %s', clientNode.type, clientNode.name);
     this.clientNodes[clientNode.id] = clientNode;
-    this.reqisterQueue.push(
-      clientNode
-    );
+    this.reqisterQueue.push(clientNode);
+    clientNode.status({ fill: 'yellow', shape: 'ring', text: 'connecting' });
   }
 
-  /**
-   * Process batched event registration messages
-   */
   async _register(clientNodes, cb) {
-    // debug('_register', clientNodes);
-
-    // debug('clientNodes', this.clientNodes);
-
     for (const clientNode of clientNodes) {
       debug('_Register %s -> %s', clientNode.type, clientNode.name);
       clientNode.hbDevice = this.hbDevices.find(service => {
-
-        // console.log('clientNodeDevice', clientNode);
-        // debug('Testing:', { clientNodeDevice: clientNode.device, serviceName: service });
         const testValue = `${service.instance.name}${service.instance.username}${service.accessoryInformation.Manufacturer}${service.serviceName}${service.uuid.slice(0, 8)}`;
-        // debug('Testing - final:', { clientNodeDevice: clientNode.device, testValue });
+        clientNode.status({ fill: 'green', shape: 'dot', text: 'connected' });
         return clientNode.device === testValue;
       });
-      // debug('Updated clientNode', clientNode);
+
       if (!clientNode.hbDevice) {
-        console.log('ERROR: _register - HB Device Missing', clientNode.name);
+        console.error('ERROR: _register - HB Device Missing', clientNode.name);
       }
     }
-    // const monitor = await this.hapClient.monitorCharacteristics(clientNodes);
-    // monitor.on('service-update', (services) => {
-    //   debug('service-update', services);
-    // });
-
     cb(null);
   }
 
-  // Deregister a device node
-  deregister(deviceNode, callback) {
-    deviceNode.status({
+  deregister(clientNode) {
+    clientNode.status({
       text: 'disconnected',
       shape: 'ring',
       fill: 'red',
     });
-
-    this.clientNodes[clientNode.id] = {};
+    delete this.clientNodes[clientNode.id];
   }
 
-  // Clean up resources
   close() {
-    if (this.client && this.client.connected) {
-      this.client.end();
+    if (this.hapClient) {
+      this.hapClient.close();
     }
   }
 }

package/src/hbControlNode.js

@@ -4,75 +4,54 @@ const debug = require('debug')('hapNodeRed:hbControlNode');
 class HbControlNode extends hbBaseNode {
   constructor(config, RED) {
     super(config, RED);
-
-    // Register the node-specific input and close handlers
-    // this.on('input', this.handleInput.bind(this));
-    // Register the node with the configuration
   }
 
-  // Handle input messages
   async handleInput(message) {
-    debug('handleInput', message, this.hbDevice);
-    if (this.hbDevice) {
-      var results = [];
-      if (typeof message.payload === "object") {
-        var fill = 'green';
-        for (const key of Object.keys(message.payload)) {
-          const characteristic = this.hbDevice.serviceCharacteristics.find(
-            c => c.type === key
-          );
+    debug('handleInput', message.payload, this.name);
 
-          if (characteristic) {
-            const result = await characteristic.setValue(message.payload[key]);
-            results.push({ [result.type]: result.value })
-          } else {
-            console.log('Not Found', key);
-            this.error('Invalid Characteristic \'' + key + '\' found in the message ' + JSON.stringify(message));
-            results.push({ 'Invalid Key': key });
-            fill = 'red';
-          };
-        }
-        this.status({
-          text: JSON.stringify(Object.assign({}, ...results)),
-          shape: 'dot',
-          fill: fill
-        });
+    if (!this.hbDevice) {
+      this.error('HB not initialized');
+      this.status({ text: 'HB not initialized', shape: 'ring', fill: 'red' });
+      return;
+    }
 
-      } else {
-        // Improper object
-        const validNames = Object.keys(this.hbDevice.values)
-          .filter(key => key !== 'ConfiguredName')
-          .join(', ');
-        this.error("Payload should be an JSON object containing device characteristics and values, ie {\"On\":false, \"Brightness\":0 }\nValid values include: " + validNames);
-        this.status({
-          text: 'Invalid payload',
-          shape: 'ring',
-          fill: 'red'
-        });
+    if (typeof message.payload !== 'object') {
+      const validNames = Object.keys(this.hbDevice.values)
+        .filter(key => key !== 'ConfiguredName')
+        .join(', ');
+      this.error(`Payload should be a JSON object containing device characteristics and values, e.g. {"On":false, "Brightness":0}. Valid values: ${validNames}`);
+      this.status({ text: 'Invalid payload', shape: 'ring', fill: 'red' });
+      return;
+    }
 
-      }
-    } else {
-      this.error("HB not initialized");
-      this.status({
-        text: 'HB not initialized',
-        shape: 'ring',
-        fill: 'red',
-      });
+    const results = [];
+    let fill = 'green';
 
-    }
-    /*
-    this._control.call(this, this.node, msg.payload, (err, data) => {
-      if (!err && data && (this.deviceType === '00000110' || this.deviceType === '00000111')) {
-        const outputMsg = this.createOutputMessage(data);
-        this.send(outputMsg);
-      } else if (err) {
-        this.error(err, this.msg);
+    for (const key of Object.keys(message.payload)) {
+      const characteristic = this.hbDevice.serviceCharacteristics.find(c => c.type === key);
+
+      if (characteristic) {
+        try {
+          const result = await characteristic.setValue(message.payload[key]);
+          results.push({ [result.type]: result.value });
+        } catch (error) {
+          this.error(`Failed to set value for ${key}: ${error.message}`);
+          fill = 'red';
+        }
+      } else {
+        this.error(`Invalid characteristic '${key}' found in the message: ${JSON.stringify(message.payload)}`);
+        results.push({ 'Invalid Key': key });
+        fill = 'red';
       }
+    }
+
+    this.status({
+      text: JSON.stringify(Object.assign({}, ...results)),
+      shape: 'dot',
+      fill,
     });
-    */
   }
 
-  // Handle node closure
   handleClose(callback) {
     callback();
   }

package/test/node-red/flows.json

@@ -402,5 +402,22 @@
                 "6703815a8874b156"
             ]
         ]
+    },
+    {
+        "id": "ab3d4add7178f1f1",
+        "type": "hb-event",
+        "z": "caef1e7b5b399e80",
+        "name": "",
+        "Homebridge": "",
+        "Manufacturer": "",
+        "Service": "",
+        "device": "",
+        "conf": "",
+        "sendInitialState": false,
+        "x": 890,
+        "y": 800,
+        "wires": [
+            []
+        ]
     }
 ]