zigbee-herdsman 6.0.1 → 6.0.3

package/src/utils/queue.ts

@@ -1,76 +0,0 @@
-interface Job {
-    key?: string | number;
-    running: boolean;
-    start?: () => void;
-}
-
-export class Queue {
-    private jobs: Job[];
-    private readonly concurrent: number;
-
-    constructor(concurrent = 1) {
-        this.jobs = [];
-        this.concurrent = concurrent;
-    }
-
-    public async execute<T>(func: () => Promise<T>, key?: string | number): Promise<T> {
-        const job: Job = {key, running: false};
-        this.jobs.push(job);
-
-        // Minor optimization/workaround: various tests like the idea that a job that is immediately runnable is run without an event loop spin.
-        // This also helps with stack traces in some cases, so avoid an `await` if we can help it.
-        if (this.getNext() !== job) {
-            await new Promise<void>((resolve): void => {
-                job.start = (): void => {
-                    job.running = true;
-                    resolve();
-                };
-
-                this.executeNext();
-            });
-        } else {
-            job.running = true;
-        }
-
-        try {
-            return await func();
-        } finally {
-            this.jobs.splice(this.jobs.indexOf(job), 1);
-            this.executeNext();
-        }
-    }
-
-    private executeNext(): void {
-        const job = this.getNext();
-
-        if (job) {
-            // if we get here, start is always defined for job
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            job.start!();
-        }
-    }
-
-    private getNext(): Job | undefined {
-        if (this.jobs.filter((j) => j.running).length > this.concurrent - 1) {
-            return undefined;
-        }
-
-        for (let i = 0; i < this.jobs.length; i++) {
-            const job = this.jobs[i];
-
-            if (!job.running && (!job.key || !this.jobs.find((j) => j.key === job.key && j.running))) {
-                return job;
-            }
-        }
-
-        return undefined;
-    }
-
-    public clear(): void {
-        this.jobs = [];
-    }
-
-    public count(): number {
-        return this.jobs.length;
-    }
-}

package/src/utils/types.d.ts

@@ -1,3 +0,0 @@
-declare module "mixin-deep" {
-    export default function mixinDeep<T>(target: T, ...rest: object[]): T;
-}

package/src/utils/utils.ts

@@ -1,19 +0,0 @@
-export function isNumberArray(value: unknown): value is number[] {
-    return Array.isArray(value) && value.every((item) => typeof item === "number");
-}
-
-export function isNumberArrayOfLength(value: unknown, length: number): boolean {
-    return isNumberArray(value) && value.length === length;
-}
-
-export function assertString(input: unknown): asserts input is string {
-    if (typeof input !== "string") {
-        throw new Error("Input must be a string!");
-    }
-}
-
-export function isObjectEmpty(object: object): boolean {
-    // much faster than checking `Object.keys(object).length`
-    for (const _k in object) return false;
-    return true;
-}

package/src/utils/wait.ts

@@ -1,5 +0,0 @@
-export function wait(milliseconds: number): Promise<void> {
-    return new Promise((resolve): void => {
-        setTimeout((): void => resolve(), milliseconds);
-    });
-}

package/src/utils/waitress.ts

@@ -1,96 +0,0 @@
-interface Waiter<TPayload, TMatcher> {
-    ID: number;
-    resolve: (payload: TPayload) => void;
-    reject: (error: Error) => void;
-    timer?: NodeJS.Timeout;
-    resolved: boolean;
-    timedout: boolean;
-    matcher: TMatcher;
-}
-
-type Validator<TPayload, TMatcher> = (payload: TPayload, matcher: TMatcher) => boolean;
-type TimeoutFormatter<TMatcher> = (matcher: TMatcher, timeout: number) => string;
-
-export class Waitress<TPayload, TMatcher> {
-    private waiters: Map<number, Waiter<TPayload, TMatcher>>;
-    private readonly validator: Validator<TPayload, TMatcher>;
-    private readonly timeoutFormatter: TimeoutFormatter<TMatcher>;
-    private currentID: number;
-
-    public constructor(validator: Validator<TPayload, TMatcher>, timeoutFormatter: TimeoutFormatter<TMatcher>) {
-        this.waiters = new Map();
-        this.timeoutFormatter = timeoutFormatter;
-        this.validator = validator;
-        this.currentID = 0;
-    }
-
-    public clear(): void {
-        for (const [, waiter] of this.waiters) {
-            clearTimeout(waiter.timer);
-        }
-
-        this.waiters.clear();
-    }
-
-    public resolve(payload: TPayload): boolean {
-        return this.forEachMatching(payload, (waiter) => waiter.resolve(payload));
-    }
-
-    public reject(payload: TPayload, message: string): boolean {
-        return this.forEachMatching(payload, (waiter) => waiter.reject(new Error(message)));
-    }
-
-    public remove(id: number): void {
-        const waiter = this.waiters.get(id);
-        if (waiter) {
-            if (!waiter.timedout && waiter.timer) {
-                clearTimeout(waiter.timer);
-            }
-
-            this.waiters.delete(id);
-        }
-    }
-
-    public waitFor(matcher: TMatcher, timeout: number): {ID: number; start: () => {promise: Promise<TPayload>; ID: number}} {
-        this.currentID += 1;
-        const ID = this.currentID;
-
-        const promise: Promise<TPayload> = new Promise((resolve, reject): void => {
-            const object: Waiter<TPayload, TMatcher> = {matcher, resolve, reject, timedout: false, resolved: false, ID};
-            this.waiters.set(ID, object);
-        });
-
-        const start = (): {promise: Promise<TPayload>; ID: number} => {
-            const waiter = this.waiters.get(ID);
-            if (waiter && !waiter.resolved && !waiter.timer) {
-                // Capture the stack trace from the caller of start()
-                const error = new Error(this.timeoutFormatter(matcher, timeout));
-                Error.captureStackTrace(error);
-                waiter.timer = setTimeout((): void => {
-                    waiter.timedout = true;
-                    waiter.reject(error);
-                }, timeout);
-            }
-
-            return {promise, ID};
-        };
-
-        return {ID, start};
-    }
-
-    private forEachMatching(payload: TPayload, action: (waiter: Waiter<TPayload, TMatcher>) => void): boolean {
-        let foundMatching = false;
-        for (const [index, waiter] of this.waiters.entries()) {
-            if (waiter.timedout) {
-                this.waiters.delete(index);
-            } else if (this.validator(payload, waiter.matcher)) {
-                clearTimeout(waiter.timer);
-                waiter.resolved = true;
-                this.waiters.delete(index);
-                action(waiter);
-                foundMatching = true;
-            }
-        }
-        return foundMatching;
-    }
-}

package/src/zspec/consts.ts

@@ -1,84 +0,0 @@
-import type {ExtendedPanId} from "./tstypes";
-
-/** Current supported Zigbee revision: https://csa-iot.org/wp-content/uploads/2023/04/05-3474-23-csg-zigbee-specification-compressed.pdf */
-export const ZIGBEE_REVISION = 23;
-
-/** The network ID of the coordinator in a ZigBee network is 0x0000. */
-export const COORDINATOR_ADDRESS = 0x0000;
-
-/** Endpoint profile ID for Zigbee 3.0. "Home Automation" */
-export const HA_PROFILE_ID = 0x0104;
-/** Endpoint profile ID for Smart Energy */
-export const SE_PROFILE_ID = 0x0109;
-/** Endpoint profile ID for Green Power */
-export const GP_PROFILE_ID = 0xa1e0;
-/** The touchlink (ZigBee Light Link/ZLL) Profile ID. */
-export const TOUCHLINK_PROFILE_ID = 0xc05e;
-/** The profile ID used to address all the public profiles. */
-export const WILDCARD_PROFILE_ID = 0xffff;
-
-/** The default HA endpoint. */
-export const HA_ENDPOINT = 0x01;
-/** The GP endpoint, as defined in the ZigBee spec. */
-export const GP_ENDPOINT = 0xf2;
-
-export const GP_GROUP_ID = 0x0b84;
-
-/** The maximum 802.15.4 channel number is 26. */
-export const MAX_802_15_4_CHANNEL_NUMBER = 26;
-/** The minimum 2.4GHz 802.15.4 channel number is 11. */
-export const MIN_802_15_4_CHANNEL_NUMBER = 11;
-/** There are sixteen 802.15.4 channels. */
-export const NUM_802_15_4_CHANNELS = MAX_802_15_4_CHANNEL_NUMBER - MIN_802_15_4_CHANNEL_NUMBER + 1;
-/** A bitmask to scan all 2.4 GHz 802.15.4 channels. */
-export const ALL_802_15_4_CHANNELS_MASK = 0x07fff800;
-/** A bitmask of the preferred 2.4 GHz 802.15.4 channels to scan. */
-export const PREFERRED_802_15_4_CHANNELS_MASK = 0x0318c800;
-/** List of all Zigbee channels */
-export const ALL_802_15_4_CHANNELS = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26];
-/** List of preferred Zigbee channels */
-export const PREFERRED_802_15_4_CHANNELS = [11, 14, 15, 19, 20, 24, 25];
-
-/** A blank (also used as "wildcard") EUI64 hex string prefixed with 0x */
-export const BLANK_EUI64 = "0xFFFFFFFFFFFFFFFF";
-/** A blank extended PAN ID. (null/not present) */
-export const BLANK_EXTENDED_PAN_ID: Readonly<ExtendedPanId> = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
-
-/** An invalid profile ID. This is a reserved profileId. */
-export const INVALID_PROFILE_ID = 0xffff;
-/** An invalid cluster ID. */
-export const INVALID_CLUSTER_ID = 0xffff;
-/** An invalid PAN ID. */
-export const INVALID_PAN_ID = 0xffff;
-
-/** A distinguished network ID that will never be assigned to any node. It is used to indicate the absence of a node ID. */
-export const NULL_NODE_ID = 0xffff;
-/** A distinguished binding index used to indicate the absence of a binding. */
-export const NULL_BINDING = 0xff;
-
-/** This key is "ZigBeeAlliance09" */
-export const INTEROPERABILITY_LINK_KEY: readonly number[] = [
-    0x5a, 0x69, 0x67, 0x42, 0x65, 0x65, 0x41, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x30, 0x39,
-];
-
-export const PERMIT_JOIN_FOREVER = 0xff;
-export const PERMIT_JOIN_MAX_TIMEOUT = 0xfe;
-
-/** Size of EUI64 (an IEEE address) in bytes. */
-export const EUI64_SIZE = 8;
-/** Size of an PAN identifier in bytes. */
-export const PAN_ID_SIZE = 2;
-/** Size of an extended PAN identifier in bytes. */
-export const EXTENDED_PAN_ID_SIZE = 8;
-/** Size of an encryption key in bytes. */
-export const DEFAULT_ENCRYPTION_KEY_SIZE = 16;
-/** Size of a AES-128-MMO (Matyas-Meyer-Oseas) block in bytes. */
-export const AES_MMO_128_BLOCK_SIZE = 16;
-/**
- * Valid install code sizes, including `INSTALL_CODE_CRC_SIZE`.
- *
- * NOTE: 18 is now standard, first for iterations, order after is important (8 before 10)!
- */
-export const INSTALL_CODE_SIZES: ReadonlyArray<number> = [18, 8, 10, 14];
-/** Size of the CRC appended to install codes. */
-export const INSTALL_CODE_CRC_SIZE = 2;

package/src/zspec/enums.ts

@@ -1,22 +0,0 @@
-/**
- * ZigBee Broadcast Addresses
- *
- * ZigBee specifies three different broadcast addresses that reach different collections of nodes.
- * Broadcasts are normally sent only to routers.
- * Broadcasts can also be forwarded to end devices, either all of them or only those that do not sleep.
- * Broadcasting to end devices is both significantly more resource-intensive and significantly less reliable than broadcasting to routers.
- */
-export enum BroadcastAddress {
-    // Reserved = 0xfff8,
-    // Reserved = 0xfff9,
-    // Reserved = 0xfffa,
-    /** Low power routers only */
-    LOW_POWER_ROUTERS = 0xfffb,
-    /** All routers and coordinator */
-    DEFAULT = 0xfffc,
-    /** macRxOnWhenIdle = TRUE (all non-sleepy devices) */
-    RX_ON_WHEN_IDLE = 0xfffd,
-    // Reserved = 0xFFFE,
-    /** All devices in PAN (including sleepy end devices) */
-    SLEEPY = 0xffff,
-}

package/src/zspec/index.ts

@@ -1,3 +0,0 @@
-export * from "./consts";
-export * from "./enums";
-export * as Utils from "./utils";

package/src/zspec/tstypes.ts

@@ -1,18 +0,0 @@
-/**
- * EUI 64-bit ID (IEEE 802.15.4 long address). uint8[EUI64_SIZE]
- *
- * NOTE: Expected to contain `0x` prefix
- */
-export type Eui64 = `0x${string}`;
-/** IEEE 802.15.4 node ID. Also known as short address. uint16 */
-export type NodeId = number;
-/** IEEE 802.15.4 PAN ID. uint16 */
-export type PanId = number;
-/** PAN 64-bit ID (IEEE 802.15.4 long address). uint8[EXTENDED_PAN_ID_SIZE] */
-export type ExtendedPanId = number[];
-/** 16-bit ZigBee multicast group identifier. uint16 */
-export type MulticastId = number;
-/** Refer to the Zigbee application profile ID. uint16 */
-export type ProfileId = number;
-/** Refer to the ZCL cluster ID. uint16 */
-export type ClusterId = number;

package/src/zspec/utils.ts

@@ -1,247 +0,0 @@
-import {createCipheriv} from "node:crypto";
-import {AES_MMO_128_BLOCK_SIZE, ALL_802_15_4_CHANNELS} from "./consts";
-import {BroadcastAddress} from "./enums";
-import type {Eui64} from "./tstypes";
-
-/**
- * Convert a channels array to a uint32 channel mask.
- * @param channels
- * @returns
- */
-export const channelsToUInt32Mask = (channels: number[]): number => {
-    return channels.reduce((a, c) => a + (1 << c), 0);
-};
-
-/**
- * Convert a uint32 channel mask to a channels array.
- * @param mask
- * @returns
- */
-export const uint32MaskToChannels = (mask: number): number[] => {
-    const channels: number[] = [];
-
-    for (const channel of ALL_802_15_4_CHANNELS) {
-        if ((2 ** channel) & mask) {
-            channels.push(channel);
-        }
-    }
-
-    return channels;
-};
-
-export const isBroadcastAddress = (address: number): boolean => {
-    return (
-        address === BroadcastAddress.DEFAULT ||
-        address === BroadcastAddress.RX_ON_WHEN_IDLE ||
-        address === BroadcastAddress.SLEEPY ||
-        address === BroadcastAddress.LOW_POWER_ROUTERS
-    );
-};
-
-/**
- * Represent a little endian buffer in `0x...` form
- *
- * NOTE: the buffer is always copied to avoid reversal in reference
- */
-export const eui64LEBufferToHex = (eui64LEBuf: Buffer): Eui64 => `0x${Buffer.from(eui64LEBuf).reverse().toString("hex")}`;
-
-/**
- * Represent a big endian buffer in `0x...` form
- */
-export const eui64BEBufferToHex = (eui64BEBuf: Buffer): Eui64 => `0x${eui64BEBuf.toString("hex")}`;
-
-/**
- * Calculate the CRC 8, 16 or 32 for the given data.
- *
- * @see https://www.crccalc.com/
- *
- * @param data
- * @param length CRC Length
- * @param poly Polynomial
- * @param crc Initialization value
- * @param xorOut Final XOR value
- * @param refIn Reflected In
- * @param refOut Reflected Out
- * @returns The calculated CRC
- *
- * NOTE: This is not exported for test coverage reasons (large number of combinations possible, many unused).
- *       Specific, needed, algorithms should be defined as exported wrappers below, and coverage added for them.
- */
-function calcCRC(
-    data: number[] | Uint8Array | Buffer,
-    length: 8 | 16 | 32,
-    poly: number,
-    crc = 0,
-    xorOut = 0,
-    refIn = false,
-    refOut = false,
-): number {
-    // https://web.archive.org/web/20150226083354/http://leetcode.com/2011/08/reverse-bits.html
-    const reflect = (x: number, size: 8 | 16 | 32): number => {
-        if (size === 8) {
-            x = ((x & 0x55) << 1) | ((x & 0xaa) >> 1);
-            x = ((x & 0x33) << 2) | ((x & 0xcc) >> 2);
-            x = ((x & 0x0f) << 4) | ((x & 0xf0) >> 4);
-        } else if (size === 16) {
-            x = ((x & 0x5555) << 1) | ((x & 0xaaaa) >> 1);
-            x = ((x & 0x3333) << 2) | ((x & 0xcccc) >> 2);
-            x = ((x & 0x0f0f) << 4) | ((x & 0xf0f0) >> 4);
-            x = ((x & 0x00ff) << 8) | ((x & 0xff00) >> 8);
-            /* v8 ignore start */
-        } /* if (size === 32) */ else {
-            x = ((x & 0x55555555) << 1) | ((x & 0xaaaaaaaa) >> 1);
-            x = ((x & 0x33333333) << 2) | ((x & 0xcccccccc) >> 2);
-            x = ((x & 0x0f0f0f0f) << 4) | ((x & 0xf0f0f0f0) >> 4);
-            x = ((x & 0x00ff00ff) << 8) | ((x & 0xff00ff00) >> 8);
-            x = ((x & 0x0000ffff) << 16) | ((x & 0xffff0000) >> 16);
-        }
-        /* v8 ignore stop */
-
-        return x;
-    };
-
-    poly = (1 << length) | poly;
-
-    for (let byte of data) {
-        if (refIn) {
-            byte = reflect(byte, 8);
-        }
-
-        crc ^= byte << (length - 8);
-
-        for (let i = 0; i < 8; i++) {
-            crc <<= 1;
-
-            if (crc & (1 << length)) {
-                crc ^= poly;
-            }
-        }
-    }
-
-    if (refOut) {
-        crc = reflect(crc, length);
-    }
-
-    return crc ^ xorOut;
-}
-
-/**
- * CRC-16/X-25
- * aka CRC-16/IBM-SDLC
- * aka CRC-16/ISO-HDLC
- * aka CRC-16/ISO-IEC-14443-3-B
- * aka CRC-B
- * aka X-25
- *
- * Shortcut for `calcCRC(data, 16, 0x1021, 0xFFFF, 0xFFFF, true, true)`
- *
- * Used for Install Codes - see Document 13-0402-13 - 10.1
- */
-export function crc16X25(data: number[] | Uint8Array | Buffer): number {
-    return calcCRC(data, 16, 0x1021, 0xffff, 0xffff, true, true);
-}
-
-/**
- * CRC-16/XMODEM
- * aka CRC-16/ACORN
- * aka CRC-16/LTE
- * aka CRC-16/V-41-MSB
- * aka XMODEM
- * aka ZMODEM
- *
- * Shortcut for `calcCRC(data, 16, 0x1021)`
- *
- * Used for XMODEM transfers, often involved in ZigBee environments
- */
-export function crc16XMODEM(data: number[] | Uint8Array | Buffer): number {
-    return calcCRC(data, 16, 0x1021);
-}
-
-/**
- * CRC-16/CCITT
- * aka CRC-16/KERMIT
- * aka CRC-16/BLUETOOTH
- * aka CRC-16/CCITT-TRUE
- * aka CRC-16/V-41-LSB
- * aka CRC-CCITT
- * aka KERMIT
- *
- * Shortcut for `calcCRC(data, 16, 0x1021, 0x0000, 0x0000, true, true)`
- */
-export function crc16CCITT(data: number[] | Uint8Array | Buffer): number {
-    return calcCRC(data, 16, 0x1021, 0x0000, 0x0000, true, true);
-}
-
-/**
- * CRC-16/CCITT-FALSE
- * aka CRC-16/IBM-3740
- * aka CRC-16/AUTOSAR
- *
- * Shortcut for `calcCRC(data, 16, 0x1021, 0xffff)`
- */
-export function crc16CCITTFALSE(data: number[] | Uint8Array | Buffer): number {
-    return calcCRC(data, 16, 0x1021, 0xffff);
-}
-
-function aes128MmoHashUpdate(result: Buffer, data: Buffer, dataSize: number): void {
-    while (dataSize >= AES_MMO_128_BLOCK_SIZE) {
-        const cipher = createCipheriv("aes-128-ecb", result, null);
-        const block = data.subarray(0, AES_MMO_128_BLOCK_SIZE);
-        const encryptedBlock = Buffer.concat([cipher.update(block), cipher.final()]);
-
-        // XOR encrypted and plaintext
-        for (let i = 0; i < AES_MMO_128_BLOCK_SIZE; i++) {
-            result[i] = encryptedBlock[i] ^ block[i];
-        }
-
-        data = data.subarray(AES_MMO_128_BLOCK_SIZE);
-        dataSize -= AES_MMO_128_BLOCK_SIZE;
-    }
-}
-
-/**
- * AES-128-MMO (Matyas-Meyer-Oseas) hashing (using node 'crypto' built-in with 'aes-128-ecb')
- *
- * Used for Install Codes - see Document 13-0402-13 - 10.1
- */
-export function aes128MmoHash(data: Buffer): Buffer {
-    const hashResult = Buffer.alloc(AES_MMO_128_BLOCK_SIZE);
-    const temp = Buffer.alloc(AES_MMO_128_BLOCK_SIZE);
-    let remainingLength = data.length;
-    let position = 0;
-
-    for (position; remainingLength >= AES_MMO_128_BLOCK_SIZE; ) {
-        const chunk = data.subarray(position, position + AES_MMO_128_BLOCK_SIZE);
-
-        aes128MmoHashUpdate(hashResult, chunk, chunk.length);
-
-        position += AES_MMO_128_BLOCK_SIZE;
-        remainingLength -= AES_MMO_128_BLOCK_SIZE;
-    }
-
-    for (let i = 0; i < remainingLength; i++) {
-        temp[i] = data[position + i];
-    }
-
-    // per the spec, concatenate a 1 bit followed by all zero bits
-    temp[remainingLength] = 0x80;
-
-    // if appending the bit string will push us beyond the 16-byte boundary, hash that block and append another 16-byte block
-    if (AES_MMO_128_BLOCK_SIZE - remainingLength < 3) {
-        aes128MmoHashUpdate(hashResult, temp, AES_MMO_128_BLOCK_SIZE);
-        temp.fill(0);
-    }
-
-    temp[AES_MMO_128_BLOCK_SIZE - 2] = (data.length >> 5) & 0xff;
-    temp[AES_MMO_128_BLOCK_SIZE - 1] = (data.length << 3) & 0xff;
-
-    aes128MmoHashUpdate(hashResult, temp, AES_MMO_128_BLOCK_SIZE);
-
-    const result = Buffer.alloc(AES_MMO_128_BLOCK_SIZE);
-
-    for (let i = 0; i < AES_MMO_128_BLOCK_SIZE; i++) {
-        result[i] = hashResult[i];
-    }
-
-    return result;
-}