@matterbridge/core 3.10.13-dev-20261005-49e0dbd → 3.10.13-dev-20261007-320f739

package/dist/cli.js

@@ -100,6 +100,11 @@ async function main() {
     const { Matterbridge } = await import('./matterbridge.js');
     instance = await Matterbridge.loadInstance(true);
     log.debug(`***Matterbridge.loadInstance(true) exited`);
+    if (hasParameter('experimental')) {
+        log.debug(`***Starting Backend thread...`);
+        manager.runThread('Backend');
+        log.debug(`***Started Backend thread`);
+    }
     if (!instance || instance.shutdown) {
         await shutdown();
     }

package/dist/deviceManager.d.ts

@@ -1,4 +1,4 @@
-import type { BaseDevice } from '@matterbridge/types';
+import type { ApiDevice, BaseDevice } from '@matterbridge/types';
 import { LogLevel } from 'node-ansi-logger';
 import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 export declare function toBaseDevice(device: MatterbridgeEndpoint | BaseDevice): BaseDevice;
@@ -21,6 +21,7 @@ export declare class DeviceManager {
     private toBaseDevice;
     array(): MatterbridgeEndpoint[];
     baseArray(pluginName?: string): BaseDevice[];
+    apiDeviceArray(pluginName?: string): ApiDevice[];
     [Symbol.iterator](): IterableIterator<MatterbridgeEndpoint>;
     forEach(callback: (device: MatterbridgeEndpoint) => Promise<void>): Promise<void>;
     set logLevel(logLevel: LogLevel);

package/dist/deviceManager.js

@@ -3,6 +3,7 @@ import { dev } from '@matterbridge/types';
 import { hasParameter } from '@matterbridge/utils/cli';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { AnsiLogger, BLUE, CYAN, db, debugStringify, er } from 'node-ansi-logger';
+import { getBatteryLevel, getClusterTextFromDevice, getPowerSource, getReachability, getServerNodeData } from './matterNodeHelpers.js';
 logModuleLoaded('Device Manager');
 export function toBaseDevice(device) {
     return {
@@ -87,6 +88,9 @@ export class DeviceManager {
                 case 'devices_basearray':
                     this.server.respond({ ...msg, result: { devices: this.baseArray(msg.params.pluginName) } });
                     break;
+                case 'devices_apidevicearray':
+                    this.server.respond({ ...msg, result: { devices: this.apiDeviceArray(msg.params.pluginName) } });
+                    break;
                 default:
                     if (this.verbose)
                         this.log.debug(`Unknown broadcast message ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
@@ -138,6 +142,31 @@ export class DeviceManager {
         }
         return devices;
     }
+    apiDeviceArray(pluginName) {
+        const devices = [];
+        for (const device of this._devices.values()) {
+            if (pluginName && pluginName !== device.plugin)
+                continue;
+            if (!device.plugin || !device.deviceType || !device.name || !device.deviceName || !device.serialNumber || !device.uniqueId || !device.lifecycle.isReady)
+                continue;
+            devices.push({
+                pluginName: device.plugin,
+                type: device.name + ' (0x' + device.deviceType.toString(16).padStart(4, '0') + ')',
+                endpoint: device.number,
+                name: device.deviceName,
+                serial: device.serialNumber,
+                productUrl: device.productUrl,
+                configUrl: device.configUrl,
+                uniqueId: device.uniqueId,
+                reachable: getReachability(device),
+                powerSource: getPowerSource(device),
+                batteryLevel: getBatteryLevel(device),
+                matter: device.mode === 'server' && device.serverNode ? getServerNodeData(device.serverNode) : undefined,
+                cluster: getClusterTextFromDevice(device),
+            });
+        }
+        return devices;
+    }
     [Symbol.iterator]() {
         return this._devices.values();
     }

package/dist/frontend.d.ts

@@ -43,13 +43,9 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     start(port?: number): Promise<void>;
     stop(): Promise<void>;
     getApiSettings(): ApiSettings;
-    private getReachability;
-    private getPowerSource;
-    private getBatteryLevel;
-    private getClusterTextFromDevice;
     getApiPlugins(): ApiPlugin[];
     getApiDevices(pluginName?: string): ApiDevice[];
-    getClusters(pluginName: string, endpointNumber: number, serialNumber?: string, uniqueId?: string): ApiClusters | undefined;
+    getApiCluster(pluginName: string, endpointNumber: number, serialNumber?: string, uniqueId?: string): ApiClusters | undefined;
     generateDiagnostic(): Promise<void>;
     private wsMessageHandler;
     wssSendLogMessage(level: string, time: string, name: string, message: string): void;

package/dist/frontend.js

@@ -1,29 +1,15 @@
 import EventEmitter from 'node:events';
 import os from 'node:os';
 import path from 'node:path';
-import { Diagnostic, Lifecycle, LogDestination, LogFormat as MatterLogFormat, Logger, LogLevel as MatterLogLevel } from '@matter/general';
+import { Diagnostic, LogDestination, LogFormat as MatterLogFormat, Logger, LogLevel as MatterLogLevel } from '@matter/general';
 import { DeviceAdvertiser, DeviceCommissioner, FabricManager } from '@matter/protocol';
-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 { 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 { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
 import { CommissioningOptions } from '@matter/types/commissioning';
 import { FabricIndex } from '@matter/types/datatype';
-import { ThreeLevelAuto } from '@matter/types/globals';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
-import { isBun } from '@matterbridge/utils/bun';
+import { isBun, memoryFootprint } from '@matterbridge/utils/bun';
 import { getParameter, hasParameter } from '@matterbridge/utils/cli';
 import { writeDiagnostic } from '@matterbridge/utils/diagnostic';
-import { getEnumDescription } from '@matterbridge/utils/enum';
 import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
 import { formatBytes, formatPercent, formatUptime } from '@matterbridge/utils/format';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
@@ -32,7 +18,8 @@ import { fireAndForget, wait, withTimeout } from '@matterbridge/utils/wait';
 import { AnsiLogger, bgHex, CYAN, db, debugStringify, er, GREEN, nf, nt, rs, stringify, UNDERLINE, UNDERLINEOFF, wr, YELLOW } from 'node-ansi-logger';
 import { cliEmitter, lastOsCpuUsage, lastProcessCpuUsage } from './cliEmitter.js';
 import { generateHistoryPage } from './cliHistory.js';
-import { capitalizeFirstLetter, getAttribute } from './matterbridgeEndpointHelpers.js';
+import { capitalizeFirstLetter } from './matterbridgeEndpointHelpers.js';
+import { deleteAdvertisingNode, getBatteryLevel, getClusterTextFromDevice, getPowerSource, getReachability, getServerNodeData, setAdvertisingNode } from './matterNodeHelpers.js';
 logModuleLoaded('Frontend');
 export class Frontend extends EventEmitter {
     matterbridge;
@@ -944,7 +931,7 @@ export class Frontend extends EventEmitter {
         this.matterbridge.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
         this.matterbridge.systemInformation.cpuUsage = formatPercent(lastOsCpuUsage);
         this.matterbridge.systemInformation.processCpuUsage = formatPercent(lastProcessCpuUsage);
-        this.matterbridge.systemInformation.rss = formatBytes(process.memoryUsage().rss);
+        this.matterbridge.systemInformation.rss = formatBytes(memoryFootprint());
         this.matterbridge.systemInformation.heapTotal = formatBytes(process.memoryUsage().heapTotal);
         this.matterbridge.systemInformation.heapUsed = formatBytes(process.memoryUsage().heapUsed);
         const info = {
@@ -991,274 +978,6 @@ export class Frontend extends EventEmitter {
         };
         return { systemInformation: this.matterbridge.systemInformation, matterbridgeInformation: info };
     }
-    getReachability(device) {
-        if (this.matterbridge.hasCleanupStarted)
-            return false;
-        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;
-        if (this.matterbridge.bridgeMode === 'childbridge')
-            return true;
-        return false;
-    }
-    getPowerSource(endpoint) {
-        if (this.matterbridge.hasCleanupStarted)
-            return undefined;
-        if (!endpoint.lifecycle.isReady || endpoint.construction.status !== Lifecycle.Status.Active)
-            return undefined;
-        const powerSource = (device) => {
-            const featureMap = device.getAttribute(PowerSource.id, 'featureMap');
-            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;
-    }
-    getBatteryLevel(endpoint) {
-        if (this.matterbridge.hasCleanupStarted)
-            return undefined;
-        if (!endpoint.lifecycle.isReady || endpoint.construction.status !== Lifecycle.Status.Active)
-            return undefined;
-        const batteryLevel = (device) => {
-            const featureMap = device.getAttribute(PowerSource.id, 'featureMap');
-            if (featureMap.battery) {
-                const batChargeLevel = device.getAttribute(PowerSource.id, 'batPercentRemaining');
-                return isValidNumber(batChargeLevel) ? 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;
-    }
-    getClusterTextFromDevice(device) {
-        if (this.matterbridge.hasCleanupStarted)
-            return '';
-        if (!device.lifecycle.isReady || device.construction.status !== Lifecycle.Status.Active)
-            return '';
-        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 '';
-        };
-        let attributes = '';
-        let supportedModes = [];
-        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 === 'supportedModes') {
-                supportedModes = attributeValue;
-            }
-            if (modeClusters.has(clusterName) && attributeName === 'currentMode') {
-                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();
-    }
     getApiPlugins() {
         if (this.matterbridge.hasCleanupStarted)
             return [];
@@ -1293,7 +1012,7 @@ export class Frontend extends EventEmitter {
                 hasWhiteList: plugin.configJson?.whiteList !== undefined,
                 hasBlackList: plugin.configJson?.blackList !== undefined,
                 frontendPath: plugin.frontendPath,
-                matter: plugin.serverNode ? this.matterbridge.getServerNodeData(plugin.serverNode) : undefined,
+                matter: plugin.serverNode ? getServerNodeData(plugin.serverNode) : undefined,
             });
         }
         return plugins;
@@ -1316,23 +1035,23 @@ export class Frontend extends EventEmitter {
                 productUrl: device.productUrl,
                 configUrl: device.configUrl,
                 uniqueId: device.uniqueId,
-                reachable: this.getReachability(device),
-                powerSource: this.getPowerSource(device),
-                batteryLevel: this.getBatteryLevel(device),
-                matter: device.mode === 'server' && device.serverNode ? this.matterbridge.getServerNodeData(device.serverNode) : undefined,
-                cluster: this.getClusterTextFromDevice(device),
+                reachable: getReachability(device),
+                powerSource: getPowerSource(device),
+                batteryLevel: getBatteryLevel(device),
+                matter: device.mode === 'server' && device.serverNode ? getServerNodeData(device.serverNode) : undefined,
+                cluster: getClusterTextFromDevice(device),
             });
         }
         return devices;
     }
-    getClusters(pluginName, endpointNumber, serialNumber, uniqueId) {
+    getApiCluster(pluginName, endpointNumber, serialNumber, uniqueId) {
         if (this.matterbridge.hasCleanupStarted)
             return;
         const endpoint = this.matterbridge.devices
             .array()
             .find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber && (!serialNumber || d.serialNumber === serialNumber) && (!uniqueId || d.uniqueId === uniqueId));
         if (!endpoint?.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber) {
-            this.log.error(`getClusters: no device found for plugin ${pluginName} and endpoint number ${endpointNumber} (serial: ${serialNumber ?? 'N/A'}, uniqueId: ${uniqueId ?? 'N/A'})`);
+            this.log.error(`getApiCluster: no device found for plugin ${pluginName} and endpoint number ${endpointNumber} (serial: ${serialNumber ?? 'N/A'}, uniqueId: ${uniqueId ?? 'N/A'})`);
             return;
         }
         const deviceTypes = [];
@@ -1361,7 +1080,7 @@ export class Frontend extends EventEmitter {
         const childEndpoints = endpoint.getChildEndpoints();
         childEndpoints.forEach((childEndpoint) => {
             if (!childEndpoint.maybeId || !childEndpoint.maybeNumber) {
-                this.log.error(`getClusters: no child endpoint found for plugin ${pluginName} and endpoint number ${endpointNumber}`);
+                this.log.error(`getApiCluster: no child endpoint found for plugin ${pluginName} and endpoint number ${endpointNumber}`);
                 return;
             }
             const deviceTypes = [];
@@ -1748,7 +1467,7 @@ export class Frontend extends EventEmitter {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Unknown server node id ${localData.params.id} in /api/matter` });
                     return;
                 }
-                const matter = this.matterbridge.getServerNodeData(serverNode);
+                const matter = getServerNodeData(serverNode);
                 this.log.debug(`*Server node ${serverNode.id}: commissioned ${serverNode.state.commissioning.commissioned} upTime ${serverNode.state.generalDiagnostics.upTime}.`);
                 if (data.params.server) {
                     this.log.debug(`*Sending data for node ${data.params.id}`);
@@ -1756,13 +1475,13 @@ export class Frontend extends EventEmitter {
                 }
                 if (data.params.startCommission) {
                     await serverNode.env.get(DeviceCommissioner)?.allowBasicCommissioning();
-                    this.matterbridge.advertisingNodes.set(serverNode.id, Date.now());
+                    setAdvertisingNode(serverNode.id, Date.now());
                     this.log.debug(`*Allow commissioning has been sent for node ${data.params.id}`);
                     this.wssSendRefreshRequired('matter', { matter: { ...matter, advertiseTime: Date.now(), advertising: true } });
                 }
                 if (data.params.stopCommission) {
                     await serverNode.env.get(DeviceCommissioner)?.endCommissioning();
-                    this.matterbridge.advertisingNodes.delete(serverNode.id);
+                    deleteAdvertisingNode(serverNode.id);
                     this.log.debug(`*End commissioning has been sent for node ${data.params.id}`);
                     this.wssSendRefreshRequired('matter', { matter: { ...matter, advertiseTime: 0, advertising: false } });
                 }
@@ -1812,9 +1531,9 @@ export class Frontend extends EventEmitter {
                     return;
                 }
                 const start = performance.now();
-                const clusters = this.getClusters(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
+                const clusters = this.getApiCluster(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
                 if (this.diagnostic)
-                    writeDiagnostic(`Frontend:${data.sender}`, `getClusters() took ${(performance.now() - start).toFixed(2)} ms`);
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiCluster() took ${(performance.now() - start).toFixed(2)} ms`);
                 if (clusters) {
                     sendResponse({
                         id: data.id,

package/dist/matterNode.d.ts

@@ -1,11 +1,11 @@
 import '@matter/nodejs';
 import EventEmitter from 'node:events';
 import { type Diagnostic, type StorageContext, type StorageManager, StorageService } from '@matter/general';
-import { Endpoint, ServerNode, type SessionsBehavior } from '@matter/node';
+import { Endpoint, ServerNode } from '@matter/node';
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
-import { type DeviceCertification, type ExposedFabricInformation, MdnsService } from '@matter/protocol';
+import { type DeviceCertification, MdnsService } from '@matter/protocol';
 import { DeviceTypeId, VendorId } from '@matter/types';
-import type { ApiMatter, PluginName, SanitizedExposedFabricInformation, SanitizedSession, SharedMatterbridge, WorkerMessage } from '@matterbridge/types';
+import type { PluginName, SharedMatterbridge, WorkerMessage } from '@matterbridge/types';
 import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { type Plugin, PluginManager } from './pluginManager.js';
 interface MatterEvents {
@@ -42,7 +42,6 @@ export declare class MatterNode extends EventEmitter<MatterEvents> {
     aggregatorDeviceType: DeviceTypeId;
     aggregatorSerialNumber: string | undefined;
     aggregatorUniqueId: string | undefined;
-    advertisingNodes: Map<string, number>;
     readonly pluginManager: PluginManager;
     readonly dependantMatterNodes: Map<string, MatterNode>;
     private readonly server;
@@ -60,7 +59,6 @@ export declare class MatterNode extends EventEmitter<MatterEvents> {
     stopMatterStorage(): Promise<void>;
     createServerNodeContext(storeId: string, deviceName: string, deviceType: DeviceTypeId, vendorId: VendorId, vendorName: string, productId: number, productName: string, serialNumber?: string, uniqueId?: string, softwareVersion?: number, softwareVersionString?: string, hardwareVersion?: number, hardwareVersionString?: string, productLabel?: string, productUrl?: string, configurationVersion?: number): Promise<StorageContext>;
     createServerNode(port?: number, passcode?: number, discriminator?: number): Promise<ServerNode>;
-    getServerNodeData(serverNode: ServerNode): ApiMatter;
     startServerNode(timeout?: number): Promise<void>;
     stopServerNode(timeout?: number): Promise<void>;
     createAggregatorNode(): Promise<Endpoint<AggregatorEndpoint>>;
@@ -73,11 +71,8 @@ export declare class MatterNode extends EventEmitter<MatterEvents> {
     removeAllBridgedEndpoints(pluginName: string, delay?: number): Promise<void>;
     addVirtualEndpoint(pluginName: string, name: string, type: 'light' | 'outlet' | 'switch' | 'mounted_switch', callback: () => Promise<void>): Promise<boolean>;
     subscribeAttributeChanged(plugin: Plugin, device: MatterbridgeEndpoint): Promise<void>;
-    sanitizeFabricInformations(fabricInfo: ExposedFabricInformation[]): SanitizedExposedFabricInformation[];
-    sanitizeSessionInformation(sessions: SessionsBehavior.Session[]): SanitizedSession[];
     setServerReachability(reachable: boolean): Promise<void>;
     setAggregatorReachability(aggregatorNode: Endpoint<AggregatorEndpoint>, reachable: boolean): Promise<void>;
-    getVendorIdName: (vendorId: number | undefined) => string;
     yieldToNode(timeout?: number): Promise<void>;
 }
 export {};