@willieee802/zigbee-herdsman 0.49.3 → 0.50.0

package/src/zspec/zcl/zclFrame.ts

@@ -1,17 +1,20 @@
+import assert from "node:assert";
 import "../../utils/patchBigIntSerialization";
 
 import {BuffaloZcl} from "./buffaloZcl";
 import type {TClusterPayload, TFoundationPayload} from "./definition/clusters-types";
-import {BuffaloZclDataType, DataType, Direction, FrameType, ParameterCondition} from "./definition/enums";
-import type {FoundationCommandName} from "./definition/foundation";
+import {BuffaloZclDataType, type DataType, Direction, FrameType, ParameterCondition} from "./definition/enums";
+import type {FoundationCommandName, FoundationDefinition} from "./definition/foundation";
+import {Status} from "./definition/status";
 import type {BuffaloZclOptions, Cluster, ClusterName, Command, CustomClusters, Parameter} from "./definition/tstype";
 import * as Utils from "./utils";
 import {ZclHeader} from "./zclHeader";
+import {ZclStatusError} from "./zclStatusError";
 
 // biome-ignore lint/suspicious/noExplicitAny: API
 type ZclPayload = any;
 
-const ListTypes: number[] = [
+const LIST_TYPES: readonly (DataType | BuffaloZclDataType)[] = [
     BuffaloZclDataType.LIST_UINT8,
     BuffaloZclDataType.LIST_UINT16,
     BuffaloZclDataType.LIST_UINT24,
@@ -23,9 +26,9 @@ export class ZclFrame {
     public readonly header: ZclHeader;
     public readonly payload: ZclPayload;
     public readonly cluster: Cluster;
-    public readonly command: Command;
+    public readonly command: Command | FoundationDefinition;
 
-    private constructor(header: ZclHeader, payload: ZclPayload, cluster: Cluster, command: Command) {
+    private constructor(header: ZclHeader, payload: ZclPayload, cluster: Cluster, command: Command | FoundationDefinition) {
         this.header = header;
         this.payload = payload;
         this.cluster = cluster;
@@ -45,21 +48,21 @@ export class ZclFrame {
         disableDefaultResponse: boolean,
         manufacturerCode: number | undefined,
         transactionSequenceNumber: number,
-        commandKey: number | string | Command,
+        commandKey: number | string | Command | FoundationDefinition,
         clusterKey: number | string | Cluster,
         payload: ZclPayload,
         customClusters: CustomClusters,
         reservedBits = 0,
     ): ZclFrame {
         const cluster = typeof clusterKey === "object" ? clusterKey : Utils.getCluster(clusterKey, manufacturerCode, customClusters);
-        const command: Command =
+        const command: Command | FoundationDefinition =
             typeof commandKey === "object"
                 ? commandKey
                 : frameType === FrameType.GLOBAL
                   ? Utils.getGlobalCommand(commandKey)
                   : direction === Direction.CLIENT_TO_SERVER
-                    ? cluster.getCommand(commandKey)
-                    : cluster.getCommandResponse(commandKey);
+                    ? Utils.getClusterCommand(cluster, commandKey)
+                    : Utils.getClusterCommandResponse(cluster, commandKey);
 
         const header = new ZclHeader(
             {reservedBits, frameType, direction, disableDefaultResponse, manufacturerSpecific: manufacturerCode != null},
@@ -87,45 +90,14 @@ export class ZclFrame {
     }
 
     private writePayloadGlobal(buffalo: BuffaloZcl): void {
-        const command = Utils.getFoundationCommand(this.command.ID);
+        assert("write" in this.command);
 
-        if (command.parseStrategy === "repetitive") {
-            for (const entry of this.payload) {
-                for (const parameter of command.parameters) {
-                    const options: BuffaloZclOptions = {};
-
-                    if (!ZclFrame.conditionsValid(parameter, entry, undefined)) {
-                        continue;
-                    }
-
-                    if (parameter.type === BuffaloZclDataType.USE_DATA_TYPE && typeof entry.dataType === "number") {
-                        // We need to grab the dataType to parse useDataType
-                        options.dataType = entry.dataType;
-                    }
-
-                    buffalo.write(parameter.type, entry[parameter.name], options);
-                }
-            }
-        } else if (command.parseStrategy === "flat") {
-            for (const parameter of command.parameters) {
-                buffalo.write(parameter.type, this.payload[parameter.name], {});
-            }
-        } else {
-            if (command.parseStrategy === "oneof") {
-                if (Utils.isFoundationDiscoverRsp(command.ID)) {
-                    buffalo.writeUInt8(this.payload.discComplete);
-
-                    for (const entry of this.payload.attrInfos) {
-                        for (const parameter of command.parameters) {
-                            buffalo.write(parameter.type, entry[parameter.name], {});
-                        }
-                    }
-                }
-            }
-        }
+        this.command.write(buffalo, this.payload);
     }
 
     private writePayloadCluster(buffalo: BuffaloZcl): void {
+        assert("parameters" in this.command);
+
         for (const parameter of this.command.parameters) {
             if (!ZclFrame.conditionsValid(parameter, this.payload, undefined)) {
                 continue;
@@ -159,11 +131,11 @@ export class ZclFrame {
 
         const buffalo = new BuffaloZcl(buffer, header.length);
         const cluster = Utils.getCluster(clusterID, header.manufacturerCode, customClusters);
-        const command: Command = header.isGlobal
+        const command: Command | FoundationDefinition = header.isGlobal
             ? Utils.getGlobalCommand(header.commandIdentifier)
             : header.frameControl.direction === Direction.CLIENT_TO_SERVER
-              ? cluster.getCommand(header.commandIdentifier)
-              : cluster.getCommandResponse(header.commandIdentifier);
+              ? Utils.getClusterCommand(cluster, header.commandIdentifier)
+              : Utils.getClusterCommandResponse(cluster, header.commandIdentifier);
         const payload = ZclFrame.parsePayload(header, cluster, buffalo);
 
         return new ZclFrame(header, payload, cluster, command);
@@ -184,8 +156,8 @@ export class ZclFrame {
     private static parsePayloadCluster(header: ZclHeader, cluster: Cluster, buffalo: BuffaloZcl): ZclPayload {
         const command =
             header.frameControl.direction === Direction.CLIENT_TO_SERVER
-                ? cluster.getCommand(header.commandIdentifier)
-                : cluster.getCommandResponse(header.commandIdentifier);
+                ? Utils.getClusterCommand(cluster, header.commandIdentifier)
+                : Utils.getClusterCommandResponse(cluster, header.commandIdentifier);
         const payload: ZclPayload = {};
 
         for (const parameter of command.parameters) {
@@ -195,7 +167,7 @@ export class ZclFrame {
                 continue;
             }
 
-            if (ListTypes.includes(parameter.type)) {
+            if (LIST_TYPES.includes(parameter.type)) {
                 const lengthParameter = command.parameters[command.parameters.indexOf(parameter) - 1];
                 const length = payload[lengthParameter.name];
 
@@ -208,7 +180,7 @@ export class ZclFrame {
                 const valueToProcess = buffalo.read(parameter.type, options);
                 payload[parameter.name] = Utils.processParameterRead(parameter, valueToProcess);
             } catch (error) {
-                throw new Error(`Cannot parse '${command.name}:${parameter.name}' (${(error as Error).message})`);
+                throw new ZclStatusError(Status.INVALID_FIELD, `${cluster.name}:${command.name}:${parameter.name} (${(error as Error).message})`);
             }
         }
 
@@ -218,78 +190,7 @@ export class ZclFrame {
     private static parsePayloadGlobal(header: ZclHeader, buffalo: BuffaloZcl): ZclPayload {
         const command = Utils.getFoundationCommand(header.commandIdentifier);
 
-        if (command.parseStrategy === "repetitive") {
-            const payload = [];
-
-            while (buffalo.isMore()) {
-                // biome-ignore lint/suspicious/noExplicitAny: API
-                const entry: {[s: string]: any} = {};
-
-                for (const parameter of command.parameters) {
-                    const options: BuffaloZclOptions = {};
-
-                    if (!ZclFrame.conditionsValid(parameter, entry, buffalo.getBuffer().length - buffalo.getPosition())) {
-                        continue;
-                    }
-
-                    if (parameter.type === BuffaloZclDataType.USE_DATA_TYPE && typeof entry.dataType === "number") {
-                        // We need to grab the dataType to parse useDataType
-                        options.dataType = entry.dataType;
-
-                        if (entry.dataType === DataType.CHAR_STR && entry.attrId === 65281) {
-                            // [workaround] parse char str as Xiaomi struct
-                            options.dataType = BuffaloZclDataType.MI_STRUCT;
-                        }
-                    }
-
-                    entry[parameter.name] = buffalo.read(parameter.type, options);
-
-                    // TODO: not needed, but temp workaroudn to make payload equal to that of zcl-packet
-                    // XXX: is this still needed?
-                    if (parameter.type === BuffaloZclDataType.USE_DATA_TYPE && entry.dataType === DataType.STRUCT) {
-                        entry.structElms = entry.attrData;
-                        entry.numElms = entry.attrData.length;
-                    }
-                }
-
-                payload.push(entry);
-            }
-
-            return payload;
-        }
-
-        if (command.parseStrategy === "flat") {
-            // biome-ignore lint/suspicious/noExplicitAny: API
-            const payload: {[s: string]: any} = {};
-
-            for (const parameter of command.parameters) {
-                payload[parameter.name] = buffalo.read(parameter.type, {});
-            }
-
-            return payload;
-        }
-
-        if (command.parseStrategy === "oneof") {
-            if (Utils.isFoundationDiscoverRsp(command.ID)) {
-                // biome-ignore lint/suspicious/noExplicitAny: API
-                const payload: {discComplete: number; attrInfos: {[k: string]: any}[]} = {
-                    discComplete: buffalo.readUInt8(),
-                    attrInfos: [],
-                };
-
-                while (buffalo.isMore()) {
-                    const entry: (typeof payload.attrInfos)[number] = {};
-
-                    for (const parameter of command.parameters) {
-                        entry[parameter.name] = buffalo.read(parameter.type, {});
-                    }
-
-                    payload.attrInfos.push(entry);
-                }
-
-                return payload;
-            }
-        }
+        return command.parse(buffalo);
     }
 
     /**
@@ -332,12 +233,6 @@ export class ZclFrame {
                         }
                         break;
                     }
-                    case ParameterCondition.DATA_TYPE_CLASS_EQUAL: {
-                        if (Utils.getDataTypeClass(entry.dataType) !== condition.value) {
-                            return false;
-                        }
-                        break;
-                    }
                     case ParameterCondition.FIELD_GT: {
                         /*if (condition.reversed) {
                             if (entry[condition.field] >= condition.value) {
@@ -379,5 +274,5 @@ export interface TFoundationZclFrame<Co extends string> {
     readonly header: ZclHeader;
     readonly payload: TFoundationPayload<Co>;
     readonly cluster: Cluster;
-    readonly command: Command;
+    readonly command: FoundationDefinition;
 }

package/src/zspec/zcl/zclStatusError.ts

@@ -3,8 +3,8 @@ import {Status} from "./definition/status";
 export class ZclStatusError extends Error {
     public code: Status;
 
-    constructor(code: Status) {
-        super(`Status '${Status[code]}'`);
+    constructor(code: Status, details?: string) {
+        super(`Status '${Status[code]}'${details ? ` ${details}` : ""}`);
         this.code = code;
     }
 }

package/test/adapter/ember/emberAdapter.test.ts

@@ -2284,7 +2284,7 @@ describe("Ember Adapter Layer", () => {
         });
 
         it("Adapter impl: waitFor", () => {
-            const waiter = adapter.waitFor(1234, 1, Zcl.FrameType.GLOBAL, Zcl.Direction.CLIENT_TO_SERVER, 10, 0, 1, 15000);
+            const waiter = adapter.waitFor(1234, 1, Zcl.FrameType.GLOBAL, Zcl.Direction.CLIENT_TO_SERVER, 10, 0, 1, undefined, 15000);
             const spyCancel = vi.spyOn(waiter, "cancel");
 
             expect(typeof waiter.cancel).toStrictEqual("function");
@@ -2295,6 +2295,80 @@ describe("Ember Adapter Layer", () => {
             expect(spyCancel).toHaveReturned();
         });
 
+        it("Adapter impl: waitFor resolves on cmd", async () => {
+            const waiter = adapter.waitFor(1234, 1, Zcl.FrameType.GLOBAL, Zcl.Direction.CLIENT_TO_SERVER, 10, 0, 1, undefined, 15000);
+            const spyCancel = vi.spyOn(waiter, "cancel");
+
+            expect(typeof waiter.cancel).toStrictEqual("function");
+            expect(waiter.promise).toBeDefined();
+
+            const messageContents = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.SERVER_TO_CLIENT,
+                true,
+                undefined,
+                10,
+                "readRsp",
+                "genBasic",
+                [{attrId: 0, status: 0, dataType: Zcl.DataType.UINT8, attrData: 8}],
+                {},
+            ).toBuffer();
+            const expected = {
+                clusterID: 0,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: 1234,
+                data: messageContents,
+                endpoint: 1,
+                linkquality: 243,
+                groupID: 0,
+                wasBroadcast: false,
+                destinationEndpoint: 1,
+            };
+
+            // @ts-expect-error private
+            adapter.oneWaitress.resolveZCL(expected);
+
+            await expect(waiter.promise).resolves.toStrictEqual(expected);
+            expect(spyCancel).toHaveBeenCalledTimes(0);
+        });
+
+        it("Adapter impl: waitFor resolves on specified default response", async () => {
+            const waiter = adapter.waitFor(1234, 1, Zcl.FrameType.SPECIFIC, Zcl.Direction.CLIENT_TO_SERVER, undefined, 0x0019, 3, 5, 15000);
+            const spyCancel = vi.spyOn(waiter, "cancel");
+
+            expect(typeof waiter.cancel).toStrictEqual("function");
+            expect(waiter.promise).toBeDefined();
+
+            const messageContents = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.SERVER_TO_CLIENT,
+                true,
+                undefined,
+                99,
+                "defaultRsp",
+                "genOta",
+                {cmdId: 5, statusCode: Zcl.Status.MALFORMED_COMMAND},
+                {},
+            ).toBuffer();
+            const expected = {
+                clusterID: 0x0019,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: 1234,
+                data: messageContents,
+                endpoint: 1,
+                linkquality: 243,
+                groupID: 0,
+                wasBroadcast: false,
+                destinationEndpoint: 1,
+            };
+
+            // @ts-expect-error private
+            adapter.oneWaitress.resolveZCL(expected);
+
+            await expect(waiter.promise).resolves.toStrictEqual(expected);
+            expect(spyCancel).toHaveBeenCalledTimes(0);
+        });
+
         it("Adapter impl: permitJoin on all", async () => {
             const spyResolveEvent = vi.spyOn(
                 // @ts-expect-error private
@@ -3062,7 +3136,7 @@ describe("Ember Adapter Layer", () => {
             ]);
         });
 
-        it("Adapter impl: sendZclFrameToEndpoint with default response", async () => {
+        it("Adapter impl: sendZclFrameToEndpoint with default response to global", async () => {
             const networkAddress: NodeId = 1234;
             const endpoint: number = 3;
             const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
@@ -3087,8 +3161,17 @@ describe("Ember Adapter Layer", () => {
                 sequence: 0, // set by stack
             };
             const lastHopLqi: number = 234;
-            // defaultRsp with cmdId=0, status=0
-            const messageContents = Buffer.from("18030b0000", "hex");
+            const messageContents = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.SERVER_TO_CLIENT,
+                true,
+                undefined,
+                3,
+                "defaultRsp",
+                "genBasic",
+                {cmdId: 0, statusCode: Zcl.Status.SUCCESS},
+                {},
+            ).toBuffer();
 
             mockEzspSend.mockImplementationOnce(() => {
                 setTimeout(async () => {
@@ -3123,6 +3206,76 @@ describe("Ember Adapter Layer", () => {
             expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
         });
 
+        it("Adapter impl: sendZclFrameToEndpoint with default response to specific", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 3;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.SPECIFIC,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                false,
+                undefined,
+                3,
+                "add",
+                "genGroups",
+                {groupid: 1, groupname: ""},
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+            const lastHopLqi: number = 234;
+            const messageContents = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.SERVER_TO_CLIENT,
+                true,
+                undefined,
+                3,
+                "defaultRsp",
+                "genGroups",
+                {cmdId: 0, statusCode: Zcl.Status.UNSUPPORTED_CLUSTER},
+                {},
+            ).toBuffer();
+
+            mockEzspSend.mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit(
+                        "incomingMessage",
+                        EmberIncomingMessageType.UNICAST,
+                        reverseApsFrame(apsFrame),
+                        lastHopLqi,
+                        networkAddress,
+                        messageContents,
+                    );
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            });
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, false, false, sourceEndpoint);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual({
+                clusterID: apsFrame.clusterId,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: networkAddress,
+                data: messageContents,
+                endpoint: apsFrame.destinationEndpoint,
+                linkquality: lastHopLqi,
+                groupID: apsFrame.groupId,
+                wasBroadcast: false,
+                destinationEndpoint: apsFrame.sourceEndpoint,
+            } as ZclPayload);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
         it("Adapter impl: sendZclFrameToEndpoint without response", async () => {
             const networkAddress: NodeId = 1234;
             const endpoint: number = 3;
@@ -3157,6 +3310,40 @@ describe("Ember Adapter Layer", () => {
             expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
         });
 
+        it("Adapter impl: sendZclFrameToEndpoint with encryption", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 232;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "zigbeeDirectConfiguration",
+                [{attrId: 0}],
+                {},
+            );
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, true, false, sourceEndpoint);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual(undefined);
+
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: (DEFAULT_APS_OPTIONS & ~EmberApsOption.RETRY) | EmberApsOption.ENCRYPTION,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
         it("Adapter impl: sendZclFrameToGroup with source endpoint", async () => {
             const groupId: number = 32;
             const zclFrame = Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {});

package/test/adapter/ezsp/uart.test.ts

@@ -110,18 +110,18 @@ describe("UART", () => {
     it("Send data", async () => {
         await serialDriver.connect("/dev/ttyACM0", {});
         // send 8 frames
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
         expect(writeBufferSpy).toHaveBeenCalledTimes(2);
         // send another 2 frame - not counted, until resolve 8 promices
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
+        void serialDriver.sendDATA(Buffer.from([1, 2, 3]));
         expect(writeBufferSpy).toHaveBeenCalledTimes(2);
     });