matterbridge-bthome 0.0.1

package/dist/BTHome.js

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+import { hasParameter, isValidNumber, isValidString } from 'matterbridge/utils';
+import { AnsiLogger, nf, BLUE, GREEN, MAGENTA, YELLOW } from 'matterbridge/logger';
+import { EventEmitter } from 'node:events';
+import { decodeBTHome } from './BTHomeDecoder.js';
+import { decodeShellyManufacturerData } from './BTHomeShellyMdDecoder.js';
+import { CYAN } from 'node-ansi-logger';
+const _blushellies = [
+    '38:39:8f:8b:d2:29',
+    '28:68:47:fc:9a:6b',
+    '28:db:a7:b5:d1:ca',
+    '0c:ae:5f:5a:0b:fa',
+    '0c:ef:f6:01:8d:b8',
+    '0c:ef:f6:f1:d7:7b',
+    '7c:c6:b6:58:b9:a0',
+    '7c:c6:b6:65:2d:87',
+    '7c:c6:b6:bd:7a:9a',
+    '60:ef:ab:3f:c9:7b',
+    '38:39:8f:99:58:49',
+    '7c:c6:b6:2b:17:b6',
+    '38:39:8f:a0:9e:34',
+];
+const _shellies = [
+    '34:cd:b0:77:bc:d6',
+    'b0:b2:1c:fa:ad:1a',
+    'ec:62:60:8c:9c:02',
+    '8c:bf:ea:9d:e2:9e',
+    'cc:7b:5c:8a:ea:2e',
+    '34:b7:da:ca:c8:32',
+    '1c:69:20:44:f1:42',
+    '42:27:b3:f0:fc:29',
+];
+export class BTHome extends EventEmitter {
+    noble;
+    log;
+    isScanning = false;
+    filterBle = false;
+    filterBTHome = false;
+    filterShellyBle = false;
+    filterAddress = [];
+    bthomePeripherals = new Map();
+    blePeripherals = new Map();
+    constructor(filterBle = false, filterBTHome = true, filterShellyBle = false, filterAddress = [], logLevel = "debug") {
+        super();
+        this.log = new AnsiLogger({ logName: 'BTHome', logTimestampFormat: 4, logLevel });
+        this.filterBle = filterBle;
+        this.filterBTHome = filterBTHome;
+        this.filterShellyBle = filterShellyBle;
+        this.filterAddress = filterAddress;
+        for (const address of this.filterAddress)
+            address.toLowerCase().trim();
+        this.log.debug('BTHome constructor called with parameters:');
+        this.log.debug(`  - filterBTHome: ${filterBTHome}`);
+        this.log.debug(`  - filterShellyBle: ${filterShellyBle}`);
+        this.log.debug(`  - filterAddress: ${filterAddress.join(', ')}`);
+        this.handleDiscovery = this.handleDiscovery.bind(this);
+    }
+    isShellyBlePeripheral(peripheral) {
+        if (peripheral.advertisement.localName === undefined || peripheral.advertisement.localName === null || peripheral.advertisement.localName === '')
+            return false;
+        if (!peripheral.advertisement.localName.startsWith('Shelly') && peripheral.advertisement.localName !== 'WallDisplay')
+            return false;
+        return true;
+    }
+    isBTHomePeripheral(peripheral) {
+        if (Array.from(this.bthomePeripherals.values()).find((device) => device.mac === peripheral.address))
+            return true;
+        if (peripheral.advertisement.serviceData && peripheral.advertisement.serviceData.length) {
+            return peripheral.advertisement.serviceData.find((entry) => entry.uuid === 'fcd2') !== undefined;
+        }
+        return false;
+    }
+    async handleDiscovery(peripheral) {
+        if (this.filterBle) {
+            let assignedNumber = undefined;
+            let manufacturerData = undefined;
+            if (peripheral.advertisement.manufacturerData && peripheral.advertisement.manufacturerData.length >= 2) {
+                assignedNumber = '0x' + peripheral.advertisement.manufacturerData.readUInt16LE(0).toString(16).padStart(4, '0');
+                manufacturerData = '0x' + peripheral.advertisement.manufacturerData.toString('hex');
+            }
+            let bleDevice = this.blePeripherals.get(peripheral.id);
+            if (!bleDevice) {
+                bleDevice = {
+                    id: peripheral.id,
+                    address: peripheral.address,
+                    addressType: peripheral.addressType,
+                    connectable: peripheral.connectable,
+                    advertisement: peripheral.advertisement,
+                    rssi: peripheral.rssi,
+                    mtu: null,
+                    services: [],
+                    state: 'disconnected',
+                    localName: peripheral.advertisement.localName ?? '',
+                    lastSeen: new Date(),
+                };
+                this.blePeripherals.set(peripheral.id, bleDevice);
+                this.log.info(`[${GREEN}New${nf}] Device ${MAGENTA}${peripheral.address}${nf} Rssi: ${CYAN}${peripheral.rssi}${nf} Name: ${CYAN}${bleDevice.localName}${nf}`);
+                if (assignedNumber)
+                    this.log.debug(`                                         ManufacturerData Key: ${assignedNumber} Value: ${manufacturerData}`);
+            }
+            else {
+                bleDevice.address = peripheral.address;
+                bleDevice.addressType = peripheral.addressType;
+                bleDevice.connectable = peripheral.connectable;
+                bleDevice.advertisement = peripheral.advertisement;
+                bleDevice.rssi = peripheral.rssi;
+                bleDevice.mtu = peripheral.mtu;
+                bleDevice.services = peripheral.services;
+                bleDevice.state = peripheral.state;
+                bleDevice.localName = peripheral.advertisement.localName ?? '';
+                bleDevice.lastSeen = new Date();
+                this.log.info(`[${YELLOW}Chg${nf}] Device ${MAGENTA}${peripheral.address}${nf} Rssi: ${CYAN}${peripheral.rssi}${nf} Name: ${CYAN}${bleDevice.localName}${nf}`);
+                if (assignedNumber)
+                    this.log.debug(`                                         ManufacturerData Key: ${assignedNumber} Value: ${manufacturerData}`);
+            }
+        }
+        const isShelly = this.isShellyBlePeripheral(peripheral);
+        const isBTHome = this.isBTHomePeripheral(peripheral);
+        if (this.filterBTHome && !isBTHome)
+            return;
+        if (this.filterShellyBle && !isShelly)
+            return;
+        if (this.filterAddress.length > 0 && !this.filterAddress.includes(peripheral.address.toLowerCase().trim()))
+            return;
+        if (isBTHome) {
+            this.log.debug(`${BLUE}Message from Shelly BLU id ${peripheral.id}:`);
+        }
+        else if (isShelly) {
+            this.log.debug(`${GREEN}Message from Shelly device id ${peripheral.id}:`);
+        }
+        else {
+            this.log.debug(`Message from peripheral id ${peripheral.id}:`);
+        }
+        this.log.debug(`    - Address: ${peripheral.address} (${peripheral.addressType})`);
+        this.log.debug(`    - Connectable: ${peripheral.connectable}`);
+        this.log.debug(`    - RSSI: ${peripheral.rssi}`);
+        if (peripheral.advertisement.localName) {
+            this.log.debug(`    - Local Name: ${peripheral.advertisement.localName}`);
+        }
+        if (peripheral.advertisement.serviceUuids.length) {
+            this.log.debug(`    - Advertised Services: ${peripheral.advertisement.serviceUuids.join(', ')}`);
+        }
+        const serviceData = peripheral.advertisement.serviceData;
+        if (serviceData && serviceData.length) {
+            this.log.debug('    - Service Data:');
+            serviceData.forEach((entry) => {
+                if (entry.uuid === 'fcd2') {
+                    const bthome = decodeBTHome(entry.data);
+                    this.log.debug(`        BTHome Service Data (${entry.data.toString('hex')}): ${JSON.stringify(bthome)}`);
+                    let device;
+                    if (this.bthomePeripherals.has(peripheral.address)) {
+                        device = this.bthomePeripherals.get(peripheral.address);
+                        device.rssi = peripheral.rssi ?? device.rssi;
+                        device.localName = peripheral.advertisement.localName ?? device.localName;
+                        device.version = bthome.version ?? device.version;
+                        device.encrypted = bthome.encrypted ?? device.encrypted;
+                        device.trigger = bthome.trigger ?? device.trigger;
+                        device.data = Object.assign(device.data, bthome.readings);
+                        device.packetId = isValidNumber(bthome.readings.packetId, 0) ? bthome.readings.packetId : 0;
+                        device.lastSeen = new Date();
+                        this.emit('update', device);
+                    }
+                    else {
+                        device = {
+                            mac: peripheral.address,
+                            rssi: peripheral.rssi,
+                            localName: isValidString(peripheral.advertisement.localName, 3) ? peripheral.advertisement.localName : 'BTHome ' + peripheral.address,
+                            version: bthome.version,
+                            encrypted: bthome.encrypted,
+                            trigger: bthome.trigger,
+                            data: bthome.readings,
+                            packetId: isValidNumber(bthome.readings.packetId, 0) ? bthome.readings.packetId : 0,
+                            lastSeen: new Date(),
+                        };
+                        this.bthomePeripherals.set(peripheral.address, device);
+                        this.emit('discovered', device);
+                    }
+                }
+                else {
+                    this.log.debug(`        ${entry.uuid}: ${entry.data.toString('hex')}`);
+                }
+            });
+        }
+        if (peripheral.advertisement.manufacturerData && peripheral.advertisement.manufacturerData.length >= 2) {
+            const assignedNumber = peripheral.advertisement.manufacturerData.readUInt16LE(0);
+            if (assignedNumber === 0x0ba9) {
+                const data = decodeShellyManufacturerData(peripheral.advertisement.manufacturerData);
+                this.log.debug(`    - Shelly Manufacturer Data:`);
+                if (data) {
+                    this.log.debug(`        - Flags: ${JSON.stringify(data.flags)}`);
+                    this.log.debug(`        - Model ID: ${data.modelId} short name ${data.modelIdShortName ?? ''} long name ${data.modelIdLongName ?? ''}`);
+                    this.log.debug(`        - MAC: ${data.mac}`);
+                    if (this.bthomePeripherals.has(peripheral.address)) {
+                        const device = this.bthomePeripherals.get(peripheral.address);
+                        device.modelId = data.modelId;
+                        device.modelIdShortName = data.modelIdShortName;
+                        device.modelIdLongName = data.modelIdLongName;
+                        this.emit('update', device);
+                    }
+                }
+            }
+            else if (assignedNumber === 0x004c) {
+                this.log.debug(`    - Apple Manufacturer Data: ${peripheral.advertisement.manufacturerData.toString('hex')}`);
+            }
+            else {
+                this.log.debug(`    - Manufacturer Data: ${peripheral.advertisement.manufacturerData.toString('hex')}`);
+            }
+        }
+        if (peripheral.advertisement.txPowerLevel) {
+            this.log.debug(`    - TX Power Level: ${peripheral.advertisement.txPowerLevel}`);
+        }
+    }
+    async waitForPoweredOn() {
+        if (!this.noble)
+            throw new Error('Noble is not loaded');
+        if (this.noble.state === 'poweredOn')
+            return;
+        if (this.noble.state === 'unsupported' || this.noble.state === 'unauthorized')
+            throw new Error(`Bluetooth adapter not usable (state=${this.noble.state})`);
+        this.log.info(`Bluetooth adapter state is ${this.noble.state}`);
+        this.log.info('Waiting 30 seconds for the Bluetooth adapter state to be poweredOn…');
+        return new Promise((resolve, reject) => {
+            const onStateChange = (state) => {
+                this.log.info(`Bluetooth adapter changed state to ${state}`);
+                if (state === 'poweredOn') {
+                    clearTimeout(timeout);
+                    this.noble?.removeListener('stateChange', onStateChange);
+                    resolve();
+                }
+                else if (state === 'unsupported' || state === 'unauthorized') {
+                    clearTimeout(timeout);
+                    this.noble?.removeListener('stateChange', onStateChange);
+                    reject(new Error(`Bluetooth adapter is not usable (state=${state})`));
+                }
+            };
+            const timeout = setTimeout(() => {
+                this.noble?.removeListener('stateChange', onStateChange);
+                reject(new Error(`Timeout waiting for the Bluetooth adapter to be powered on (state=${this.noble?.state})`));
+            }, 30000);
+            this.noble?.on('stateChange', onStateChange);
+        });
+    }
+    async start() {
+        if (this.isScanning) {
+            this.log.warn('BLE scan already started');
+            return;
+        }
+        this.noble = await import('@stoprocent/noble')
+            .then((noble) => noble.default)
+            .catch((err) => {
+            this.log.error(`Error loading noble: ${err instanceof Error ? err.message : String(err)}`);
+            throw err;
+        });
+        this.log.info('Checking the Bluetooth adapter state…');
+        try {
+            await this.waitForPoweredOn();
+        }
+        catch (err) {
+            this.log.error(`Adapter error: ${err instanceof Error ? err.message : String(err)}`);
+            throw err;
+        }
+        this.log.info(`Bluetooth adapter state is ${this.noble.state}`);
+        this.log.info('Starting BLE scan…');
+        try {
+            await this.noble.startScanningAsync([], true);
+        }
+        catch (err) {
+            this.log.error(`Scan start failed: ${err instanceof Error ? err.message : String(err)}`);
+            throw err;
+        }
+        this.noble.on('discover', this.handleDiscovery);
+        this.isScanning = true;
+        this.log.info('BLE scan started');
+    }
+    async stop() {
+        if (!this.isScanning) {
+            this.log.warn('BLE scan already stopped');
+            return;
+        }
+        if (!this.noble) {
+            this.log.warn('Noble is not loaded');
+            return;
+        }
+        try {
+            this.log.info('Stopping BLE scan…');
+            this.noble.removeListener('discover', this.handleDiscovery);
+            await this.noble.stopScanningAsync();
+            this.isScanning = false;
+            this.log.info('BLE scan stopped');
+        }
+        catch (err) {
+            this.log.error(`Error stopping BLE scan: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        this.noble = undefined;
+        this.blePeripherals.clear();
+        this.bthomePeripherals.clear();
+    }
+    logDevices() {
+        this.log.debug(`Discovered ${this.bthomePeripherals.size} BTHome devices:`);
+        this.bthomePeripherals.forEach((device) => {
+            this.log.debug(`- ${device.mac}:`);
+            this.log.debug(`  - RSSI: ${device.rssi}`);
+            this.log.debug(`  - Local Name: ${device.localName}`);
+            this.log.debug(`  - Version: ${device.version}`);
+            this.log.debug(`  - Encrypted: ${device.encrypted}`);
+            this.log.debug(`  - Trigger: ${device.trigger}`);
+            this.log.debug(`  - Packet ID: ${device.packetId}`);
+            this.log.debug(`  - Last Seen: ${device.lastSeen.toLocaleString()}`);
+            this.log.debug(`  - Model ID: ${device.modelId} short name ${device.modelIdShortName} long name ${device.modelIdLongName}`);
+            this.log.debug(`  - Data: ${JSON.stringify(device.data, null, 2)}`);
+        });
+    }
+}
+function getStringArrayParameter(name) {
+    const args = process.argv.slice(2);
+    const idx = args.indexOf(`--${name}`) || args.indexOf(`-${name}`);
+    if (idx < 0)
+        return [];
+    const values = [];
+    for (let i = idx + 1; i < args.length && !args[i].startsWith('-'); i++) {
+        values.push(args[i]);
+    }
+    return values;
+}
+if (process.argv.includes('--scan')) {
+    const bthome = new BTHome(hasParameter('ble'), hasParameter('bthome'), hasParameter('shellyble'), hasParameter('address') ? getStringArrayParameter('address') : [], hasParameter('logger') ? process.argv[process.argv.indexOf('--logger') + 1] : "debug");
+    process.on('SIGINT', async () => {
+        bthome.logDevices();
+        await bthome.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        bthome.logDevices();
+        await bthome.stop();
+        process.exit(0);
+    });
+    process.on('uncaughtException', async (error) => {
+        bthome.log.error('BTHome uncaught Exception:', error);
+        await bthome.stop();
+    });
+    process.on('unhandledRejection', async (reason) => {
+        bthome.log.error('BTHome unhandled Rejection:', reason);
+        await bthome.stop();
+    });
+    bthome.start().catch((error) => {
+        bthome.log.error('BTHome error starting BTHome discovery:', error);
+        process.exit(1);
+    });
+}

package/dist/BTHomeDecoder.js

@@ -0,0 +1,52 @@
+import { BTHOME_SPEC } from './BTHomeSpec.js';
+export function decodeBTHome(buf) {
+    const info = buf.readUInt8(0);
+    const version = (info >> 5) & 0b00000111;
+    const encrypted = Boolean(info & 0b00000001);
+    const trigger = Boolean(info & 0b00000100);
+    const readings = {};
+    const unknown = [];
+    let offset = 1;
+    const ids = [];
+    while (offset < buf.length) {
+        const id = buf.readUInt8(offset++);
+        ids.push(id);
+        const spec = BTHOME_SPEC[id];
+        if (!spec) {
+            unknown.push(`0x${id.toString(16)} → 0x${buf.slice(offset - 1).toString('hex')}`);
+            break;
+        }
+        let value;
+        if (spec.parser) {
+            value = spec.parser(buf, offset);
+            if (spec.bytes != null) {
+                offset += spec.bytes;
+            }
+            else {
+                const len = buf.readUInt8(offset);
+                offset += 1 + len;
+            }
+        }
+        else {
+            if (spec.bytes == null) {
+                throw new Error(`BTHome spec for ${spec.name} is missing 'bytes'`);
+            }
+            const bytes = spec.bytes;
+            const factor = spec.factor ?? 1;
+            const raw = spec.signed ? buf.readIntLE(offset, bytes) : buf.readUIntLE(offset, bytes);
+            value = parseFloat((raw * factor).toFixed(Math.log10(1 / factor)));
+            offset += bytes;
+        }
+        const count = ids.filter((existingId) => existingId === id).length;
+        let name = spec.name;
+        if (count > 1) {
+            name = spec.name + `:${count}`;
+            if (spec.name in readings) {
+                readings[spec.name + ':1'] = readings[spec.name];
+                delete readings[spec.name];
+            }
+        }
+        readings[name] = value;
+    }
+    return { version, encrypted, trigger, readings, unknown };
+}

package/dist/BTHomeShellyMdDecoder.js

@@ -0,0 +1,70 @@
+const SHELLY_MODEL_LONG_NAMES = {
+    0x0001: 'Shelly BLU Button1',
+    0x0002: 'Shelly BLU DoorWindow',
+    0x0003: 'Shelly BLU HT',
+    0x0005: 'Shelly BLU Motion',
+    0x0006: 'Shelly BLU Wall Switch 4',
+    0x0007: 'Shelly BLU RC Button 4',
+    0x0008: 'Shelly BLU TRV',
+};
+const SHELLY_MODEL_SHORT_NAMES = {
+    0x0001: 'SBBT-002C',
+    0x0002: 'SBDW-002C',
+    0x0003: 'SBHT-003C',
+    0x0005: 'SBMO-003Z',
+    0x0006: 'SBBT-004CEU',
+    0x0007: 'SBBT-004CUS',
+    0x0008: 'SBTR-001AEU',
+};
+export function getShellyBluLongName(id) {
+    return SHELLY_MODEL_LONG_NAMES[id];
+}
+export function getShellyBluShortName(id) {
+    return SHELLY_MODEL_SHORT_NAMES[id];
+}
+export function decodeShellyManufacturerData(input) {
+    if (input.length < 10)
+        return null;
+    const buf = Buffer.isBuffer(input) ? input : Buffer.from(input.replace(/\s+/g, ''), 'hex');
+    let offset = 0;
+    const companyId = buf.readUInt16LE(offset);
+    if (companyId !== 0x0ba9)
+        return null;
+    offset += 2;
+    const result = { companyId };
+    while (offset < buf.length) {
+        const blockType = buf.readUInt8(offset++);
+        switch (blockType) {
+            case 0x01: {
+                const flagsRaw = buf.readUInt16LE(offset);
+                offset += 2;
+                result.flags = {
+                    discoverable: Boolean(flagsRaw & (1 << 0)),
+                    authEnabled: Boolean(flagsRaw & (1 << 1)),
+                    rpcEnabled: Boolean(flagsRaw & (1 << 2)),
+                    buzzerEnabled: Boolean(flagsRaw & (1 << 3)),
+                    inPairingMode: Boolean(flagsRaw & (1 << 4)),
+                };
+                break;
+            }
+            case 0x0b: {
+                const modelId = buf.readUInt16LE(offset);
+                offset += 2;
+                result.modelId = modelId;
+                result.modelIdShortName = getShellyBluShortName(modelId);
+                result.modelIdLongName = getShellyBluLongName(modelId);
+                break;
+            }
+            case 0x0a: {
+                const macBytes = buf.slice(offset, offset + 6);
+                offset += 6;
+                result.mac = macBytes.toString('hex').match(/.{2}/g)?.join(':');
+                break;
+            }
+            default:
+                offset = buf.length;
+                break;
+        }
+    }
+    return result;
+}

package/dist/BTHomeSpec.js

@@ -0,0 +1,154 @@
+export const BTHOME_SPEC = {
+    0x00: { name: 'packetId', bytes: 1, signed: false, factor: 1 },
+    0x01: { name: 'battery', bytes: 1, signed: false, factor: 1 },
+    0x02: { name: 'temperature', bytes: 2, signed: true, factor: 0.01 },
+    0x03: { name: 'humidity', bytes: 2, signed: false, factor: 0.01 },
+    0x04: { name: 'pressure', bytes: 3, signed: false, factor: 0.01 },
+    0x05: { name: 'illuminance', bytes: 3, signed: false, factor: 0.01 },
+    0x06: { name: 'massKilograms', bytes: 2, signed: false, factor: 0.01 },
+    0x07: { name: 'massPounds', bytes: 2, signed: false, factor: 0.01 },
+    0x08: { name: 'dewPoint', bytes: 2, signed: true, factor: 0.01 },
+    0x09: { name: 'countSmall', bytes: 1, signed: false, factor: 1 },
+    0x0a: { name: 'energy_kWh', bytes: 3, signed: false, factor: 0.001 },
+    0x0b: { name: 'power_W', bytes: 3, signed: false, factor: 0.01 },
+    0x0c: { name: 'voltage_V', bytes: 2, signed: false, factor: 0.001 },
+    0x0d: { name: 'pm2_5_ugm3', bytes: 2, signed: false, factor: 1 },
+    0x0e: { name: 'pm10_ugm3', bytes: 2, signed: false, factor: 1 },
+    0x13: { name: 'tvoc_ugm3', bytes: 2, signed: false, factor: 1 },
+    0x14: { name: 'moisture', bytes: 2, signed: false, factor: 0.01 },
+    0x2e: { name: 'humidity', bytes: 1, signed: false, factor: 1 },
+    0x2f: { name: 'moisture', bytes: 1, signed: false, factor: 1 },
+    0x40: { name: 'distance_mm', bytes: 2, signed: false, factor: 1 },
+    0x41: { name: 'distance_m', bytes: 2, signed: false, factor: 0.1 },
+    0x42: { name: 'duration_s', bytes: 3, signed: false, factor: 0.001 },
+    0x43: { name: 'current_A', bytes: 2, signed: false, factor: 0.001 },
+    0x44: { name: 'speed_ms', bytes: 2, signed: false, factor: 0.01 },
+    0x45: { name: 'temperature', bytes: 2, signed: true, factor: 0.1 },
+    0x46: { name: 'uvIndex', bytes: 1, signed: false, factor: 0.1 },
+    0x47: { name: 'volume_L', bytes: 2, signed: false, factor: 0.1 },
+    0x48: { name: 'volume_mL', bytes: 2, signed: false, factor: 1 },
+    0x49: { name: 'flowRate_m3ph', bytes: 2, signed: false, factor: 0.001 },
+    0x4a: { name: 'voltage_alt_V', bytes: 2, signed: false, factor: 0.1 },
+    0x4b: { name: 'gas_m3', bytes: 3, signed: false, factor: 0.001 },
+    0x4c: { name: 'gas_alt_m3', bytes: 4, signed: false, factor: 0.001 },
+    0x4d: { name: 'energy_alt_kWh', bytes: 4, signed: false, factor: 0.001 },
+    0x4e: { name: 'volume_alt_L', bytes: 4, signed: false, factor: 0.001 },
+    0x4f: { name: 'water_L', bytes: 4, signed: false, factor: 0.001 },
+    0x52: { name: 'gyroscope_dps', bytes: 2, signed: false, factor: 0.001 },
+    0x53: {
+        name: 'text',
+        parser(buf, off) {
+            return buf.slice(off + 1, off + 1 + buf[off]).toString('utf8');
+        },
+        bytes: null,
+    },
+    0x54: {
+        name: 'raw',
+        parser(buf, off) {
+            return buf.slice(off + 1, off + 1 + buf[off]).toString('hex');
+        },
+        bytes: null,
+    },
+    0x55: { name: 'volumeStorage_L', bytes: 4, signed: false, factor: 0.001 },
+    0x57: { name: 'temperature', bytes: 1, signed: true, factor: 1 },
+    0x58: { name: 'temperature', bytes: 1, signed: true, factor: 0.35 },
+    0x59: { name: 'count8', bytes: 1, signed: true, factor: 1 },
+    0x5a: { name: 'count16', bytes: 2, signed: true, factor: 1 },
+    0x5b: { name: 'count32', bytes: 4, signed: true, factor: 1 },
+    0x5c: { name: 'power_alt_W', bytes: 4, signed: true, factor: 0.01 },
+    0x5d: { name: 'current_alt_A', bytes: 2, signed: true, factor: 0.001 },
+    0x5e: { name: 'direction_deg', bytes: 2, signed: false, factor: 0.01 },
+    0x5f: { name: 'precipitation_mm', bytes: 2, signed: false, factor: 1 },
+    0x0f: { name: 'genericBoolean', bytes: 1, signed: false, factor: 1 },
+    0x10: { name: 'powerState', bytes: 1, signed: false, factor: 1 },
+    0x11: { name: 'openingState', bytes: 1, signed: false, factor: 1 },
+    0x15: { name: 'batteryState', bytes: 1, signed: false, factor: 1 },
+    0x16: { name: 'batteryChargingState', bytes: 1, signed: false, factor: 1 },
+    0x17: { name: 'carbonMonoxideState', bytes: 1, signed: false, factor: 1 },
+    0x18: { name: 'coldState', bytes: 1, signed: false, factor: 1 },
+    0x19: { name: 'connectivityState', bytes: 1, signed: false, factor: 1 },
+    0x1a: { name: 'doorState', bytes: 1, signed: false, factor: 1 },
+    0x1b: { name: 'garageDoorState', bytes: 1, signed: false, factor: 1 },
+    0x1c: { name: 'gasState', bytes: 1, signed: false, factor: 1 },
+    0x1d: { name: 'heatState', bytes: 1, signed: false, factor: 1 },
+    0x1e: { name: 'lightState', bytes: 1, signed: false, factor: 1 },
+    0x1f: { name: 'lockState', bytes: 1, signed: false, factor: 1 },
+    0x20: { name: 'moistureState', bytes: 1, signed: false, factor: 1 },
+    0x21: { name: 'motionState', bytes: 1, signed: false, factor: 1 },
+    0x22: { name: 'movingState', bytes: 1, signed: false, factor: 1 },
+    0x23: { name: 'occupancyState', bytes: 1, signed: false, factor: 1 },
+    0x24: { name: 'plugState', bytes: 1, signed: false, factor: 1 },
+    0x25: { name: 'presenceState', bytes: 1, signed: false, factor: 1 },
+    0x26: { name: 'problemState', bytes: 1, signed: false, factor: 1 },
+    0x27: { name: 'runningState', bytes: 1, signed: false, factor: 1 },
+    0x28: { name: 'safetyState', bytes: 1, signed: false, factor: 1 },
+    0x29: { name: 'smokeState', bytes: 1, signed: false, factor: 1 },
+    0x2a: { name: 'soundState', bytes: 1, signed: false, factor: 1 },
+    0x2b: { name: 'tamperState', bytes: 1, signed: false, factor: 1 },
+    0x2c: { name: 'vibrationState', bytes: 1, signed: false, factor: 1 },
+    0x2d: { name: 'windowState', bytes: 1, signed: false, factor: 1 },
+    0x3a: {
+        name: 'button',
+        bytes: 1,
+        signed: false,
+        factor: 1,
+        parser(buf, off) {
+            const code = buf.readUInt8(off);
+            const EVENT_MAP = {
+                0x00: 'none',
+                0x01: 'single_press',
+                0x02: 'double_press',
+                0x03: 'triple_press',
+                0x04: 'long_press',
+                0x05: 'long_double_press',
+                0x06: 'long_triple_press',
+                0x80: 'hold_press',
+                0xfe: 'hold_press',
+            };
+            return EVENT_MAP[code] ?? 'unknown';
+        },
+    },
+    0x3c: {
+        name: 'dimmerEvent',
+        bytes: 2,
+        signed: false,
+        factor: 1,
+        parser(buf, off) {
+            const evt = buf.readUInt8(off);
+            const steps = buf.readUInt8(off + 1);
+            const map = { 0x00: 'none', 0x01: 'rotateLeft', 0x02: 'rotateRight' };
+            return { event: map[evt] || `evt0x${evt.toString(16)}`, steps };
+        },
+    },
+    0x3f: { name: 'rotation_deg', bytes: 2, signed: true, factor: 0.1 },
+    0x50: {
+        name: 'timestamp',
+        bytes: 4,
+        signed: false,
+        factor: 1,
+        parser(buf, off) {
+            return new Date(buf.readUInt32LE(off) * 1000).toISOString();
+        },
+    },
+    0xf0: { name: 'deviceTypeId', bytes: 2, signed: false, factor: 1 },
+    0xf1: {
+        name: 'firmwareVersion',
+        bytes: 4,
+        signed: false,
+        factor: 1,
+        parser(buf, off) {
+            const [rc, patch, minor, major] = buf.slice(off, off + 4);
+            return `${major}.${minor}.${patch}.${rc}`;
+        },
+    },
+    0xf2: {
+        name: 'firmwareVersionShort',
+        bytes: 3,
+        signed: false,
+        factor: 1,
+        parser(buf, off) {
+            const [minor, patch, major] = buf.slice(off, off + 3);
+            return `${major}.${minor}.${patch}`;
+        },
+    },
+};

package/dist/index.js

@@ -0,0 +1,4 @@
+import { Platform } from './platform.js';
+export default function initializePlugin(matterbridge, log, config) {
+    return new Platform(matterbridge, log, config);
+}