zigbee-clusters 2.4.1 → 2.5.0

package/index.d.ts

@@ -173,6 +173,12 @@ interface ZCLNodeCluster extends EventEmitter {
   discoverAttributesExtended(): Promise<any[]>;
 }
 
+interface BasicCluster extends ZCLNodeCluster {
+  factoryReset(): Promise<void>;
+}
+
+interface PowerConfigurationCluster extends ZCLNodeCluster {}
+
 interface OnOffCluster extends ZCLNodeCluster {
   setOn(): Promise<void>;
   setOff(): Promise<void>;
@@ -309,7 +315,9 @@ declare module "zigbee-clusters" {
     [key: string]: { ID: number; NAME: string; ATTRIBUTES: any; COMMANDS: any };
   };
   export var ZCLNodeCluster;
+  export var BasicCluster;
   export var OnOffCluster;
   export var LevelControlCluster;
   export var ColorControlCluster;
+  export var PowerConfigurationCluster;
 }

package/lib/Endpoint.js

@@ -104,43 +104,51 @@ class Endpoint extends EventEmitter {
    */
   async handleFrame(clusterId, frame, meta) {
     const rawFrame = frame;
+    frame = Endpoint.parseFrame(frame);
 
-    if (rawFrame[0] & 0x4) {
-      frame = ZCLMfgSpecificHeader.fromBuffer(rawFrame);
-    } else frame = ZCLStandardHeader.fromBuffer(rawFrame);
-
-    // NOTE: we do not respond with a default response if:
-    // 1. The frame we received is a default response (frame.cmdId = 11)
-    // 2. Another command is sent in response to the received frame
-    // 3. The frame has the disableDefaultResponse flag set
-    // See ZCL specification 2.5.12.2.
-    const response = (
-      frame.frameControl.disableDefaultResponse
-      || (meta && meta.groupId)
-      || frame.cmdId === 11
-    ) ? null : this._makeErrorResponse(frame);
-
+    let clusterSpecificResponse = null;
+    let clusterSpecificError = null;
     try {
-      const result = await this.handleZCLFrame(clusterId, frame, meta, rawFrame);
-      if (!response) return;
-      if (result) {
-        const [cmdId, data] = result;
-        response.data = data.toBuffer();
-        response.cmdId = cmdId;
-      } else {
-        // Set status to success
-        response.data[1] = 0;
-      }
-    } catch (e) {
-      debug(`${this.getLogId(clusterId)}, error while handling frame`, e.message, { meta, frame });
+      clusterSpecificResponse = await this.handleZCLFrame(clusterId, frame, meta, rawFrame);
+    } catch (err) {
+      clusterSpecificError = err;
+      debug(`${this.getLogId(clusterId)}, error while handling frame`, err.message, { meta, frame });
     }
-    // If desired (disableDefaultResponse: false) try to respond to the incoming frame
-    if (response) {
-      try {
-        await this.sendFrame(clusterId, response.toBuffer());
-      } catch (err) {
-        debug(`${this.getLogId(clusterId)}, error while responding with \`send frame\` to \`handle frame\``, err, { response });
-      }
+
+    // Don't respond to this frame if it is a default response or a group cast (ZCL spec 2.5.12.2)
+    if (frame.cmdId === 11 || (meta && typeof meta.groupId === 'number')) return;
+
+    // If cluster specific error, respond with a default response error frame
+    if (clusterSpecificError) {
+      const defaultResponseErrorFrame = this.makeDefaultResponseFrame(frame, false);
+      this.sendFrame(clusterId, defaultResponseErrorFrame.toBuffer()).catch(err => {
+        debug(`${this.getLogId(clusterId)}, error while sending default error response`, err, { response: defaultResponseErrorFrame });
+      });
+
+      // No further handling for this frame
+      return;
+    }
+
+    // Create response frame and set status to success
+    const responseFrame = this.makeDefaultResponseFrame(frame, true);
+
+    // If a cluster specific response was generated, set the response data
+    // and cmdId in the response frame.
+    if (clusterSpecificResponse) {
+      const [cmdId, data] = clusterSpecificResponse;
+      responseFrame.data = data.toBuffer();
+      responseFrame.cmdId = cmdId;
+    }
+
+    // If there was no cluster specific response and the default response is disabled, don't
+    // send a response.
+    if (!clusterSpecificResponse && frame.frameControl.disableDefaultResponse) return;
+
+    // Send either cluster specific, or default response frame
+    try {
+      await this.sendFrame(clusterId, responseFrame.toBuffer());
+    } catch (err) {
+      debug(`${this.getLogId(clusterId)}, error while sending cluster specific or default success response`, err, { response: responseFrame });
     }
   }
 
@@ -173,25 +181,38 @@ class Endpoint extends EventEmitter {
     return response;
   }
 
-  _makeErrorResponse(frame) {
-    let result;
-    if (frame instanceof ZCLStandardHeader) {
-      result = new ZCLStandardHeader();
+  /**
+   * Returns a default response frame with an error status code.
+   * @param {*} receivedFrame
+   * @param {boolean} success
+   * @returns {ZCLStandardHeader|ZCLMfgSpecificHeader}
+   */
+  makeDefaultResponseFrame(receivedFrame, success) {
+    let responseFrame;
+    if (receivedFrame instanceof ZCLStandardHeader) {
+      responseFrame = new ZCLStandardHeader();
     } else {
-      result = new ZCLMfgSpecificHeader();
-      result.manufacturerId = frame.manufacturerId;
+      responseFrame = new ZCLMfgSpecificHeader();
+      responseFrame.manufacturerId = receivedFrame.manufacturerId;
     }
     // TODO: flip proper bits
-    result.frameControl = frame.frameControl.copy();
+    responseFrame.frameControl = receivedFrame.frameControl.copy();
+
+    responseFrame.frameControl.disableDefaultResponse = true;
+    responseFrame.frameControl.clusterSpecific = false;
+    responseFrame.frameControl.directionToClient = !receivedFrame.frameControl.directionToClient;
 
-    result.frameControl.disableDefaultResponse = true;
-    result.frameControl.clusterSpecific = false;
-    result.frameControl.directionToClient = !frame.frameControl.directionToClient;
+    responseFrame.trxSequenceNumber = receivedFrame.trxSequenceNumber;
+    responseFrame.cmdId = 0x0B;
+    responseFrame.data = Buffer.from([receivedFrame.cmdId, success ? 0 : 1]);
+    return responseFrame;
+  }
 
-    result.trxSequenceNumber = frame.trxSequenceNumber;
-    result.cmdId = 0x0B;
-    result.data = Buffer.from([frame.cmdId, 0x01]);
-    return result;
+  static parseFrame(frame) {
+    if (frame[0] & 0x4) {
+      return ZCLMfgSpecificHeader.fromBuffer(frame);
+    }
+    return ZCLStandardHeader.fromBuffer(frame);
   }
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-clusters",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "Zigbee Cluster Library for Node.js",
   "main": "index.js",
   "types": "index.d.ts",
@@ -32,6 +32,7 @@
   "homepage": "https://github.com/athombv/node-zigbee-clusters#readme",
   "devDependencies": {
     "@athombv/jsdoc-template": "^1.6.1",
+    "@types/sinon": "^17.0.3",
     "concurrently": "^5.2.0",
     "eslint": "^6.8.0",
     "eslint-config-athom": "^2.1.0",
@@ -39,6 +40,7 @@
     "jsdoc-ts-utils": "^2.0.0",
     "mocha": "^10.1.0",
     "serve": "^14.0.1",
+    "sinon": "^19.0.2",
     "watch": "^1.0.2"
   },
   "dependencies": {