@matterbridge/core 3.10.13-dev-20261004-0c9c4ee → 3.10.13-dev-20261007-320f739

package/dist/matterNode.js

@@ -25,6 +25,7 @@ import { NodeStorageManager } from 'node-persist-manager';
 import { toBaseDevice } from './deviceManager.js';
 import { addVirtualDevice } from './helpers.js';
 import { bridge } from './matterbridgeDeviceTypes.js';
+import { deleteAdvertisingNode, getServerNodeData, setAdvertisingNode } from './matterNodeHelpers.js';
 import { PluginManager } from './pluginManager.js';
 logModuleLoaded('MatterNode');
 export class MatterNode extends EventEmitter {
@@ -55,7 +56,6 @@ export class MatterNode extends EventEmitter {
     aggregatorDeviceType = DeviceTypeId(getIntParameter('deviceType') ?? bridge.code);
     aggregatorSerialNumber = getParameter('serialNumber');
     aggregatorUniqueId = getParameter('uniqueId');
-    advertisingNodes = new Map();
     pluginManager;
     dependantMatterNodes = new Map();
     server;
@@ -479,13 +479,13 @@ export class MatterNode extends EventEmitter {
         });
         serverNode.lifecycle.commissioned.on(() => {
             this.log.notice(`Server node for ${storeId} was initially commissioned successfully!`);
-            this.advertisingNodes.delete(storeId);
-            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            deleteAdvertisingNode(storeId);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...getServerNodeData(serverNode) } } });
         });
         serverNode.lifecycle.decommissioned.on(() => {
             this.log.notice(`Server node for ${storeId} was fully decommissioned successfully!`);
-            this.advertisingNodes.delete(storeId);
-            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            deleteAdvertisingNode(storeId);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...getServerNodeData(serverNode) } } });
             this.server.request({ type: 'frontend_snackbarmessage', src: 'matter', dst: 'frontend', params: { message: `${storeId} is offline`, timeout: 5, severity: 'warning' } });
         });
         serverNode.lifecycle.online.on(() => {
@@ -499,23 +499,23 @@ export class MatterNode extends EventEmitter {
             }
             if (!serverNode.lifecycle.isCommissioned) {
                 this.log.notice(`Server node for ${storeId} is not commissioned. Pair to commission ...`);
-                this.advertisingNodes.set(storeId, Date.now());
+                setAdvertisingNode(storeId, Date.now());
                 const { qrPairingCode, manualPairingCode } = serverNode.state.commissioning.pairingCodes;
                 this.log.notice(`QR Code URL: https://project-chip.github.io/connectedhomeip/qrcode.html?data=${qrPairingCode}`);
                 this.log.notice(`Manual pairing code: ${manualPairingCode}`);
             }
             else {
                 this.log.notice(`Server node for ${storeId} is already commissioned. Waiting for controllers to connect ...`);
-                this.advertisingNodes.delete(storeId);
+                deleteAdvertisingNode(storeId);
             }
-            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...getServerNodeData(serverNode) } } });
             this.server.request({ type: 'frontend_snackbarmessage', src: 'matter', dst: 'frontend', params: { message: `${storeId} is online`, timeout: 5, severity: 'success' } });
             this.emit('online', storeId);
         });
         serverNode.lifecycle.offline.on(() => {
             this.log.notice(`Server node for ${storeId} is offline`);
-            this.advertisingNodes.delete(storeId);
-            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            deleteAdvertisingNode(storeId);
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...getServerNodeData(serverNode) } } });
             this.server.request({ type: 'frontend_snackbarmessage', src: 'matter', dst: 'frontend', params: { message: `${storeId} is offline`, timeout: 5, severity: 'warning' } });
             this.emit('offline', storeId);
         });
@@ -523,7 +523,7 @@ export class MatterNode extends EventEmitter {
             let action = '';
             switch (fabricAction) {
                 case 'added':
-                    this.advertisingNodes.delete(storeId);
+                    deleteAdvertisingNode(storeId);
                     action = 'added';
                     break;
                 case 'deleted':
@@ -534,40 +534,24 @@ export class MatterNode extends EventEmitter {
                     break;
             }
             this.log.notice(`Commissioned fabric index ${fabricIndex} ${action} on server node for ${storeId}: ${debugStringify(serverNode.state.commissioning.fabrics[fabricIndex])}`);
-            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...getServerNodeData(serverNode) } } });
         });
         serverNode.events.sessions.opened.on((session) => {
             this.log.notice(`Session opened on server node for ${storeId}: ${debugStringify(session)}`);
-            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...getServerNodeData(serverNode) } } });
         });
         serverNode.events.sessions.closed.on((session) => {
             this.log.notice(`Session closed on server node for ${storeId}: ${debugStringify(session)}`);
-            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...getServerNodeData(serverNode) } } });
         });
         serverNode.events.sessions.subscriptionsChanged.on((session) => {
             this.log.notice(`Session subscriptions changed on server node for ${storeId}: ${debugStringify(session)}`);
-            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...this.getServerNodeData(serverNode) } } });
+            this.server.request({ type: 'frontend_refreshrequired', src: 'matter', dst: 'frontend', params: { changed: 'matter', matter: { ...getServerNodeData(serverNode) } } });
         });
         this.storeId = storeId;
         this.log.info(`Created server node for ${this.storeId}`);
         return serverNode;
     }
-    getServerNodeData(serverNode) {
-        const advertiseTime = this.advertisingNodes.get(serverNode.id) || 0;
-        return {
-            id: serverNode.id,
-            online: serverNode.lifecycle.isOnline,
-            commissioned: serverNode.state.commissioning.commissioned,
-            advertising: advertiseTime > Date.now() - 15 * 60 * 1000,
-            advertiseTime,
-            windowStatus: serverNode.state.administratorCommissioning.windowStatus,
-            qrPairingCode: serverNode.state.commissioning.pairingCodes.qrPairingCode,
-            manualPairingCode: serverNode.state.commissioning.pairingCodes.manualPairingCode,
-            fabricInformations: this.sanitizeFabricInformations(Object.values(serverNode.state.commissioning.fabrics)),
-            sessionInformations: this.sanitizeSessionInformation(Object.values(serverNode.state.sessions.sessions)),
-            serialNumber: serverNode.state.basicInformation.serialNumber,
-        };
-    }
     async startServerNode(timeout = 30000) {
         if (!this.serverNode) {
             throw new Error('Matter server node not created yet. Call create() first.');
@@ -593,6 +577,7 @@ export class MatterNode extends EventEmitter {
         catch (error) {
             this.log.error(`Failed to close ${this.serverNode.id} server node: ${getErrorMessage(error)}`);
         }
+        deleteAdvertisingNode(this.serverNode.id);
     }
     async createAggregatorNode() {
         if (!this.matterStorageContext) {
@@ -773,7 +758,15 @@ export class MatterNode extends EventEmitter {
         const plugin = this.pluginManager.get(pluginName);
         if (!plugin)
             throw new Error(`Error removing bridged endpoint ${plg}${pluginName}${er}:${dev}${device.deviceName}${er} (${zb}${device.name}${er}): plugin not found`);
-        if (device.serverNode) {
+        if (device.mode === 'server') {
+            const matterNode = this.dependantMatterNodes.get(device.id);
+            if (matterNode) {
+                this.log.debug(`Closing MatterNode for device ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})...`);
+                await matterNode.stop();
+                await matterNode.destroy(false);
+                this.dependantMatterNodes.delete(device.id);
+                this.log.debug(`Closed MatterNode for device ${plg}${pluginName}${db}:${dev}${device.deviceName}${db} (${zb}${device.name}${db})`);
+            }
         }
         else if (this.matterbridge.bridgeMode === 'bridge') {
             if (!this.aggregatorNode)
@@ -963,45 +956,6 @@ export class MatterNode extends EventEmitter {
             }
         }
     }
-    sanitizeFabricInformations(fabricInfo) {
-        return fabricInfo.map((info) => {
-            return {
-                fabricIndex: info.fabricIndex,
-                fabricId: info.fabricId.toString(),
-                nodeId: info.nodeId.toString(),
-                rootNodeId: info.rootNodeId.toString(),
-                rootVendorId: info.rootVendorId,
-                rootVendorName: this.getVendorIdName(info.rootVendorId),
-                label: info.label,
-            };
-        });
-    }
-    sanitizeSessionInformation(sessions) {
-        return sessions
-            .filter((session) => session.isPeerActive)
-            .map((session) => {
-            return {
-                name: session.name,
-                nodeId: session.nodeId.toString(),
-                peerNodeId: session.peerNodeId.toString(),
-                fabric: session.fabric
-                    ? {
-                        fabricIndex: session.fabric.fabricIndex,
-                        fabricId: session.fabric.fabricId.toString(),
-                        nodeId: session.fabric.nodeId.toString(),
-                        rootNodeId: session.fabric.rootNodeId.toString(),
-                        rootVendorId: session.fabric.rootVendorId,
-                        rootVendorName: this.getVendorIdName(session.fabric.rootVendorId),
-                        label: session.fabric.label,
-                    }
-                    : undefined,
-                isPeerActive: session.isPeerActive,
-                lastInteractionTimestamp: session.lastInteractionTimestamp?.toString(),
-                lastActiveTimestamp: session.lastActiveTimestamp?.toString(),
-                numberOfActiveSubscriptions: session.numberOfActiveSubscriptions,
-            };
-        });
-    }
     async setServerReachability(reachable) {
         await this.serverNode?.setStateOf(BasicInformationServer, { reachable });
         this.serverNode?.act((agent) => this.serverNode?.eventsOf(BasicInformationServer).reachableChanged?.emit({ reachableNewValue: reachable }, agent.context));
@@ -1013,50 +967,6 @@ export class MatterNode extends EventEmitter {
             child.act((agent) => child.eventsOf(BridgedDeviceBasicInformationServer).reachableChanged.emit({ reachableNewValue: true }, agent.context));
         }
     }
-    getVendorIdName = (vendorId) => {
-        if (!vendorId)
-            return '';
-        let vendorName = '(Unknown vendorId)';
-        switch (vendorId) {
-            case 4937:
-                vendorName = '(AppleHome)';
-                break;
-            case 4996:
-                vendorName = '(AppleKeyChain)';
-                break;
-            case 4362:
-                vendorName = '(SmartThings)';
-                break;
-            case 4939:
-                vendorName = '(HomeAssistant)';
-                break;
-            case 24582:
-                vendorName = '(GoogleHome)';
-                break;
-            case 4631:
-                vendorName = '(Alexa)';
-                break;
-            case 4701:
-                vendorName = '(Tuya)';
-                break;
-            case 4718:
-                vendorName = '(Xiaomi)';
-                break;
-            case 4742:
-                vendorName = '(eWeLink)';
-                break;
-            case 5264:
-                vendorName = '(Shelly)';
-                break;
-            case 0x1488:
-                vendorName = '(ShortcutLabsFlic)';
-                break;
-            case 65521:
-                vendorName = '(MatterTest)';
-                break;
-        }
-        return vendorName;
-    };
     async yieldToNode(timeout = 100) {
         await Promise.resolve();
         await new Promise((resolve) => {

package/dist/matterNodeHelpers.d.ts

@@ -0,0 +1,15 @@
+import { ServerNode, type SessionsBehavior } from '@matter/node';
+import type { ExposedFabricInformation } from '@matter/protocol';
+import type { ApiMatter, SanitizedExposedFabricInformation, SanitizedSession } from '@matterbridge/types';
+import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+export declare function getReachability(device: MatterbridgeEndpoint): boolean;
+export declare function getPowerSource(endpoint: MatterbridgeEndpoint): 'ac' | 'dc' | 'ok' | 'warning' | 'critical' | undefined;
+export declare function getBatteryLevel(endpoint: MatterbridgeEndpoint): number | undefined;
+export declare function getClusterTextFromDevice(device: MatterbridgeEndpoint): string;
+export declare function setAdvertisingNode(storeId: string, advertiseTime: number): void;
+export declare function deleteAdvertisingNode(storeId: string): void;
+export declare function clearAdvertisingNodes(): void;
+export declare function getServerNodeData(serverNode: ServerNode): ApiMatter;
+export declare function sanitizeFabricInformations(fabricInfo: ExposedFabricInformation[]): SanitizedExposedFabricInformation[];
+export declare function sanitizeSessionInformation(sessions: SessionsBehavior.Session[]): SanitizedSession[];
+export declare function getVendorIdName(vendorId: number | undefined): string;

package/dist/matterNodeHelpers.js

@@ -0,0 +1,393 @@
+import { Lifecycle } from '@matter/general';
+import { ServerNode } from '@matter/node';
+import { getClusterNameById } from '@matter/types/cluster';
+import { AirQuality } from '@matter/types/clusters/air-quality';
+import { BridgedDeviceBasicInformation } from '@matter/types/clusters/bridged-device-basic-information';
+import { ClosureControl } from '@matter/types/clusters/closure-control';
+import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+import { FanControl } from '@matter/types/clusters/fan-control';
+import { FixedLabel } from '@matter/types/clusters/fixed-label';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { PowerSource } from '@matter/types/clusters/power-source';
+import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-state';
+import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
+import { SoilMeasurement } from '@matter/types/clusters/soil-measurement';
+import { UserLabel } from '@matter/types/clusters/user-label';
+import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
+import { ThreeLevelAuto } from '@matter/types/globals';
+import { getEnumDescription } from '@matterbridge/utils/enum';
+import { isValidArray, isValidNumber, isValidObject } from '@matterbridge/utils/validate';
+import { stringify } from 'node-ansi-logger';
+import { featuresFor, getAttribute } from './matterbridgeEndpointHelpers.js';
+const advertisingNodes = new Map();
+export function getReachability(device) {
+    if (!device.lifecycle.isReady || device.construction.status !== Lifecycle.Status.Active)
+        return false;
+    if (device.hasClusterServer(BridgedDeviceBasicInformation.id))
+        return device.getAttribute(BridgedDeviceBasicInformation, 'reachable');
+    if (device.mode === 'server' && device.serverNode?.state.basicInformation.reachable !== undefined)
+        return device.serverNode.state.basicInformation.reachable;
+    const owner = device.ownerOfType(ServerNode.RootEndpoint);
+    if (owner?.state.basicInformation.reachable !== undefined)
+        return owner.state.basicInformation.reachable;
+    return false;
+}
+export function getPowerSource(endpoint) {
+    if (!endpoint.lifecycle.isReady || endpoint.construction.status !== Lifecycle.Status.Active)
+        return undefined;
+    const powerSource = (device) => {
+        const featureMap = featuresFor(device, PowerSource);
+        if (featureMap.wired) {
+            const wiredCurrentType = device.getAttribute(PowerSource.id, 'wiredCurrentType');
+            return ['ac', 'dc'][wiredCurrentType];
+        }
+        if (featureMap.battery) {
+            const batChargeLevel = device.getAttribute(PowerSource.id, 'batChargeLevel');
+            return ['ok', 'warning', 'critical'][batChargeLevel];
+        }
+        return undefined;
+    };
+    if (endpoint.hasClusterServer(PowerSource.id))
+        return powerSource(endpoint);
+    for (const child of endpoint.getChildEndpoints()) {
+        if (child.hasClusterServer(PowerSource.id))
+            return powerSource(child);
+    }
+    return undefined;
+}
+export function getBatteryLevel(endpoint) {
+    if (!endpoint.lifecycle.isReady || endpoint.construction.status !== Lifecycle.Status.Active)
+        return undefined;
+    const batteryLevel = (device) => {
+        const featureMap = featuresFor(device, PowerSource);
+        if (featureMap.battery) {
+            const batChargeLevel = device.getAttribute(PowerSource, 'batPercentRemaining');
+            return isValidNumber(batChargeLevel, 0, 200) ? batChargeLevel / 2 : undefined;
+        }
+        return undefined;
+    };
+    if (endpoint.hasClusterServer(PowerSource.id))
+        return batteryLevel(endpoint);
+    for (const child of endpoint.getChildEndpoints()) {
+        if (child.hasClusterServer(PowerSource.id))
+            return batteryLevel(child);
+    }
+    return undefined;
+}
+export function getClusterTextFromDevice(device) {
+    if (!device.lifecycle.isReady || device.construction.status !== Lifecycle.Status.Active)
+        return '';
+    let attributes = '';
+    const getUserLabel = (device) => {
+        const labelList = getAttribute(device, UserLabel, 'labelList');
+        if (labelList) {
+            const composed = labelList.find((entry) => entry.label === 'composed');
+            if (composed)
+                return 'Composed: ' + composed.value;
+        }
+        return '';
+    };
+    const getFixedLabel = (device) => {
+        const labelList = getAttribute(device, FixedLabel, 'labelList');
+        if (labelList) {
+            const composed = labelList.find((entry) => entry.label === 'composed');
+            if (composed)
+                return 'Composed: ' + composed.value;
+        }
+        return '';
+    };
+    const getMeasurementText = (value, scale, unit) => {
+        if (value === null)
+            return 'unknown';
+        if (isValidNumber(value) || typeof value === 'bigint')
+            return `${Number(value) / scale}${unit}`;
+        return '';
+    };
+    const getEnergyText = (value) => {
+        if (value === null)
+            return 'unknown';
+        if (isValidObject(value) && 'energy' in value && (isValidNumber(value.energy) || typeof value.energy === 'bigint'))
+            return `${Number(value.energy) / 1_000_000}kWh`;
+        return '';
+    };
+    const appendMeasurement = (label, value) => {
+        if (value)
+            attributes += `${label}: ${value} `;
+    };
+    device.forEachAttribute((clusterName, clusterId, attributeName, attributeId, attributeValue) => {
+        if (typeof attributeValue === 'undefined' || attributeValue === undefined)
+            return;
+        if (clusterName === 'descriptor' && attributeName === 'clientList' && isValidArray(attributeValue, 1))
+            attributes += `Client cluster(s): [${attributeValue.map((id) => getClusterNameById(id)).join(', ')}] `;
+        if (clusterName === 'binding' && attributeName === 'binding' && isValidArray(attributeValue)) {
+            if (attributeValue.length === 0)
+                attributes += `Bound cluster(s): none `;
+            else {
+                const targets = attributeValue;
+                const formatted = targets.map((target) => {
+                    const parts = [];
+                    if (target.node !== undefined)
+                        parts.push(`node: ${target.node}`);
+                    if (target.group !== undefined)
+                        parts.push(`group: ${target.group}`);
+                    if (target.endpoint !== undefined)
+                        parts.push(`endpoint: ${target.endpoint}`);
+                    if (target.cluster !== undefined)
+                        parts.push(`cluster: ${getClusterNameById(target.cluster)}`);
+                    if (target.fabricIndex !== undefined)
+                        parts.push(`fabricIndex: ${target.fabricIndex}`);
+                    return `[${parts.join(', ')}]`;
+                });
+                attributes += `Bound cluster(s): ${formatted.join(' ')} `;
+            }
+        }
+        if (clusterName === 'onOff' && attributeName === 'onOff')
+            attributes += `OnOff: ${attributeValue} `;
+        if (clusterName === 'switch' && attributeName === 'currentPosition')
+            attributes += `Position: ${attributeValue} `;
+        if (clusterName === 'windowCovering' && attributeName === 'currentPositionLiftPercent100ths' && isValidNumber(attributeValue, 0, 10000))
+            attributes += `Cover position: ${attributeValue / 100}% `;
+        if (clusterName === 'doorLock' && attributeName === 'lockState')
+            attributes += `State: ${attributeValue === 1 ? 'Locked' : 'Not locked'} `;
+        if (clusterName === 'closureControl' && attributeName === 'overallCurrentState' && attributeValue === null)
+            attributes += `Position: unknown Latch: unknown Speed: unknown SecureState: unknown `;
+        if (clusterName === 'closureControl' && attributeName === 'overallCurrentState' && isValidObject(attributeValue)) {
+            const overallCurrentState = attributeValue;
+            attributes += `Position: ${getEnumDescription(ClosureControl.CurrentPosition, overallCurrentState.position, { fallback: 'unknown' })} `;
+            if (overallCurrentState.latch !== undefined)
+                attributes += `Latch: ${overallCurrentState.latch} `;
+            if (overallCurrentState.speed !== undefined)
+                attributes += `Speed: ${getEnumDescription(ThreeLevelAuto, overallCurrentState.speed)} `;
+            attributes += `SecureState: ${overallCurrentState.secureState ?? 'unknown'} `;
+        }
+        if (clusterName === 'thermostat' && attributeName === 'localTemperature' && isValidNumber(attributeValue))
+            attributes += `Temperature: ${attributeValue / 100}°C `;
+        if (clusterName === 'thermostat' && attributeName === 'occupiedHeatingSetpoint' && isValidNumber(attributeValue))
+            attributes += `Heat to: ${attributeValue / 100}°C `;
+        if (clusterName === 'thermostat' && attributeName === 'occupiedCoolingSetpoint' && isValidNumber(attributeValue))
+            attributes += `Cool to: ${attributeValue / 100}°C `;
+        const modeClusters = new Set(['modeSelect', 'rvcRunMode', 'rvcCleanMode', 'laundryWasherMode', 'ovenMode', 'microwaveOvenMode', 'deviceEnergyManagementMode']);
+        if (modeClusters.has(clusterName) && attributeName === 'currentMode') {
+            const supportedModes = getAttribute(device, clusterName, 'supportedModes');
+            const supportedMode = supportedModes?.find((mode) => mode.mode === attributeValue);
+            if (supportedMode)
+                attributes += `Mode: ${supportedMode.label} `;
+        }
+        if (clusterName === 'operationalState' && attributeName === 'operationalState')
+            attributes += `OpState: ${getEnumDescription(OperationalState.OperationalStateEnum, attributeValue)} `;
+        if (clusterName === 'rvcOperationalState' && attributeName === 'operationalState')
+            attributes += `OpState: ${getEnumDescription(RvcOperationalState.OperationalState, attributeValue)} `;
+        if (clusterName === 'pumpConfigurationAndControl' && attributeName === 'operationMode')
+            attributes += `Mode: ${attributeValue} `;
+        if (clusterName === 'valveConfigurationAndControl' && attributeName === 'currentState')
+            attributes += `State: ${getEnumDescription(ValveConfigurationAndControl.ValveState, attributeValue, { fallback: 'unknown' })} `;
+        if (clusterName === 'levelControl' && attributeName === 'currentLevel')
+            attributes += `Level: ${attributeValue} `;
+        if (clusterName === 'applicationBasic' && attributeName === 'applicationName')
+            attributes += `App: ${attributeValue} `;
+        if (clusterName === 'colorControl' && attributeName === 'colorMode' && isValidNumber(attributeValue, 0, 2))
+            attributes += `Mode: ${['HS', 'XY', 'CT'][attributeValue]} `;
+        if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 0 && attributeName === 'currentHue' && isValidNumber(attributeValue))
+            attributes += `Hue: ${Math.round(attributeValue)} `;
+        if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 0 && attributeName === 'currentSaturation' && isValidNumber(attributeValue))
+            attributes += `Saturation: ${Math.round(attributeValue)} `;
+        if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 1 && attributeName === 'currentX' && isValidNumber(attributeValue))
+            attributes += `X: ${Math.round(attributeValue / 655.36) / 100} `;
+        if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 1 && attributeName === 'currentY' && isValidNumber(attributeValue))
+            attributes += `Y: ${Math.round(attributeValue / 655.36) / 100} `;
+        if (clusterName === 'colorControl' && getAttribute(device, 'colorControl', 'colorMode') === 2 && attributeName === 'colorTemperatureMireds' && isValidNumber(attributeValue))
+            attributes += `ColorTemp: ${Math.round(attributeValue)} `;
+        if (clusterName === 'booleanState' && attributeName === 'stateValue')
+            attributes += `Contact: ${attributeValue} `;
+        if (clusterName === 'booleanStateConfiguration' && attributeName === 'alarmsActive' && isValidObject(attributeValue))
+            attributes += `Active alarms: ${stringify(attributeValue)} `;
+        if (clusterName === 'smokeCoAlarm' && attributeName === 'smokeState')
+            attributes += `Smoke: ${getEnumDescription(SmokeCoAlarm.AlarmState, attributeValue)} `;
+        if (clusterName === 'smokeCoAlarm' && attributeName === 'coState')
+            attributes += `Co: ${getEnumDescription(SmokeCoAlarm.AlarmState, attributeValue)} `;
+        if (clusterName === 'fanControl' && attributeName === 'fanMode')
+            attributes += `Mode: ${getEnumDescription(FanControl.FanMode, attributeValue)} `;
+        if (clusterName === 'fanControl' && attributeName === 'percentCurrent')
+            attributes += `Percent: ${attributeValue}% `;
+        if (clusterName === 'fanControl' && attributeName === 'speedCurrent')
+            attributes += `Speed: ${attributeValue} `;
+        if (clusterName === 'fanControl' && attributeName === 'rockSetting' && isValidObject(attributeValue))
+            attributes += `Rock: ${stringify(attributeValue)} `;
+        if (clusterName === 'fanControl' && attributeName === 'windSetting' && isValidObject(attributeValue))
+            attributes += `Wind: ${stringify(attributeValue)} `;
+        if (clusterName === 'fanControl' && attributeName === 'airflowDirection')
+            attributes += `Direction: ${getEnumDescription(FanControl.AirflowDirection, attributeValue)} `;
+        if (clusterName === 'hepaFilterMonitoring' && attributeName === 'condition')
+            attributes += `Hepa filter: ${attributeValue}% `;
+        if (clusterName === 'activatedCarbonFilterMonitoring' && attributeName === 'condition')
+            attributes += `Carbon filter: ${attributeValue}% `;
+        if (clusterName === 'waterTankLevelMonitoring' && attributeName === 'condition')
+            attributes += `Water tank: ${attributeValue}% `;
+        if (clusterName === 'temperatureAlarm' && attributeName === 'state' && isValidObject(attributeValue))
+            attributes += `Temp alarm: ${stringify(attributeValue)} `;
+        if (clusterName === 'occupancySensing' && attributeName === 'occupancy' && isValidObject(attributeValue, 1))
+            attributes += `Occupancy: ${attributeValue.occupied} `;
+        if (clusterName === 'illuminanceMeasurement' && attributeName === 'measuredValue') {
+            if (attributeValue === null)
+                attributes += `Illuminance: unknown `;
+            else if (isValidNumber(attributeValue))
+                attributes += `Illuminance: ${Math.round(Math.max(Math.pow(10, attributeValue / 10000), 0))} lx `;
+        }
+        if (clusterName === 'airQuality' && attributeName === 'airQuality')
+            attributes += `Air quality: ${getEnumDescription(AirQuality.AirQualityEnum, attributeValue)} `;
+        if (clusterName === 'totalVolatileOrganicCompoundsConcentrationMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('Voc', getMeasurementText(attributeValue, 1, ''));
+        if (clusterName === 'pm1ConcentrationMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('Pm1', getMeasurementText(attributeValue, 1, ''));
+        if (clusterName === 'pm25ConcentrationMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('Pm2.5', getMeasurementText(attributeValue, 1, ''));
+        if (clusterName === 'pm10ConcentrationMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('Pm10', getMeasurementText(attributeValue, 1, ''));
+        if (clusterName === 'formaldehydeConcentrationMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('CH₂O', getMeasurementText(attributeValue, 1, ''));
+        if (clusterName === 'temperatureMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('Temperature', getMeasurementText(attributeValue, 100, ' °C'));
+        if (clusterName === 'relativeHumidityMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('Humidity', getMeasurementText(attributeValue, 100, '%'));
+        if (clusterName === 'pressureMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('Pressure', getMeasurementText(attributeValue, 1, ' hPa'));
+        if (clusterName === 'flowMeasurement' && attributeName === 'measuredValue')
+            appendMeasurement('Flow', getMeasurementText(attributeValue, 10, ' m³/h'));
+        if (clusterId === SoilMeasurement.id && attributeName === 'soilMoistureMeasuredValue')
+            appendMeasurement('Soil moisture', getMeasurementText(attributeValue, 1, '%'));
+        if (clusterName === 'electricalPowerMeasurement' && attributeName === 'voltage')
+            appendMeasurement('Voltage', getMeasurementText(attributeValue, 1_000, 'V'));
+        if (clusterName === 'electricalPowerMeasurement' && attributeName === 'activeCurrent')
+            appendMeasurement('Current', getMeasurementText(attributeValue, 1_000, 'A'));
+        if (clusterName === 'electricalPowerMeasurement' && attributeName === 'activePower')
+            appendMeasurement('Power', getMeasurementText(attributeValue, 1_000_000, 'kW'));
+        if (clusterName === 'electricalPowerMeasurement' && attributeName === 'frequency')
+            appendMeasurement('Frequency', getMeasurementText(attributeValue, 1_000, 'Hz'));
+        if (clusterName === 'electricalEnergyMeasurement' && attributeName === 'cumulativeEnergyImported')
+            appendMeasurement('Imported', getEnergyText(attributeValue));
+        if (clusterName === 'electricalEnergyMeasurement' && attributeName === 'cumulativeEnergyExported')
+            appendMeasurement('Exported', getEnergyText(attributeValue));
+        if (clusterName === 'deviceEnergyManagement' && attributeName === 'esaCanGenerate')
+            attributes += `ESA can generate: ${attributeValue} `;
+        if (clusterName === 'deviceEnergyManagement' && attributeName === 'esaState')
+            attributes += `ESA state: ${DeviceEnergyManagement.EsaState[attributeValue]} `;
+        if (clusterName === 'fixedLabel' && attributeName === 'labelList')
+            attributes += `${getFixedLabel(device)} `;
+        if (clusterName === 'userLabel' && attributeName === 'labelList')
+            attributes += `${getUserLabel(device)} `;
+    });
+    return attributes.trimStart().trimEnd();
+}
+export function setAdvertisingNode(storeId, advertiseTime) {
+    advertisingNodes.set(storeId, advertiseTime);
+}
+export function deleteAdvertisingNode(storeId) {
+    advertisingNodes.delete(storeId);
+}
+export function clearAdvertisingNodes() {
+    advertisingNodes.clear();
+}
+export function getServerNodeData(serverNode) {
+    const advertiseTime = advertisingNodes.get(serverNode.id) ?? 0;
+    return {
+        id: serverNode.id,
+        online: serverNode.lifecycle.isOnline,
+        commissioned: serverNode.state.commissioning.commissioned,
+        advertising: advertiseTime > 0,
+        advertiseTime,
+        windowStatus: serverNode.state.administratorCommissioning.windowStatus,
+        qrPairingCode: serverNode.state.commissioning.pairingCodes.qrPairingCode,
+        manualPairingCode: serverNode.state.commissioning.pairingCodes.manualPairingCode,
+        fabricInformations: sanitizeFabricInformations(Object.values(serverNode.state.commissioning.fabrics)),
+        sessionInformations: sanitizeSessionInformation(Object.values(serverNode.state.sessions.sessions)),
+        serialNumber: serverNode.state.basicInformation.serialNumber,
+    };
+}
+export function sanitizeFabricInformations(fabricInfo) {
+    return fabricInfo.map((info) => {
+        return {
+            fabricIndex: info.fabricIndex,
+            fabricId: info.fabricId.toString(),
+            nodeId: info.nodeId.toString(),
+            rootNodeId: info.rootNodeId.toString(),
+            rootVendorId: info.rootVendorId,
+            rootVendorName: getVendorIdName(info.rootVendorId),
+            label: info.label,
+        };
+    });
+}
+function toIsoTimestamp(timestamp) {
+    if (!isValidNumber(timestamp, 1) || Number.isNaN(new Date(timestamp).getTime()))
+        return '';
+    return new Date(timestamp).toISOString();
+}
+export function sanitizeSessionInformation(sessions) {
+    return sessions
+        .filter((session) => session.isPeerActive)
+        .map((session) => {
+        return {
+            name: session.name,
+            nodeId: session.nodeId.toString(),
+            peerNodeId: session.peerNodeId.toString(),
+            fabric: session.fabric
+                ? {
+                    fabricIndex: session.fabric.fabricIndex,
+                    fabricId: session.fabric.fabricId.toString(),
+                    nodeId: session.fabric.nodeId.toString(),
+                    rootNodeId: session.fabric.rootNodeId.toString(),
+                    rootVendorId: session.fabric.rootVendorId,
+                    rootVendorName: getVendorIdName(session.fabric.rootVendorId),
+                    label: session.fabric.label,
+                }
+                : undefined,
+            isPeerActive: session.isPeerActive,
+            lastInteractionTimestamp: toIsoTimestamp(session.lastInteractionTimestamp),
+            lastActiveTimestamp: toIsoTimestamp(session.lastActiveTimestamp),
+            numberOfActiveSubscriptions: session.numberOfActiveSubscriptions,
+        };
+    });
+}
+export function getVendorIdName(vendorId) {
+    if (!vendorId)
+        return '';
+    let vendorName = '(Unknown vendorId)';
+    switch (vendorId) {
+        case 4937:
+            vendorName = '(AppleHome)';
+            break;
+        case 4996:
+            vendorName = '(AppleKeyChain)';
+            break;
+        case 4362:
+            vendorName = '(SmartThings)';
+            break;
+        case 4939:
+            vendorName = '(HomeAssistant)';
+            break;
+        case 24582:
+            vendorName = '(GoogleHome)';
+            break;
+        case 4631:
+            vendorName = '(Alexa)';
+            break;
+        case 4701:
+            vendorName = '(Tuya)';
+            break;
+        case 4718:
+            vendorName = '(Xiaomi)';
+            break;
+        case 4742:
+            vendorName = '(eWeLink)';
+            break;
+        case 5264:
+            vendorName = '(Shelly)';
+            break;
+        case 0x1488:
+            vendorName = '(ShortcutLabsFlic)';
+            break;
+        case 65521:
+            vendorName = '(MatterTest)';
+            break;
+    }
+    return vendorName;
+}