matterbridge 3.3.3-dev-20251015-19d1be8 → 3.3.3-dev-20251016-70a1c5b

package/CHANGELOG.md

@@ -29,6 +29,10 @@ Advantages:
 
 - [thread]: Added timestamp to WorkerMessage.
 - [macOS]: Added the [plist configuration guide](README-MACOS-PLIST.md).
+- [frontend]: Added download diagnostic and download history to Download menu.
+- [frontend]: Added icon to open the cpu and memory usage in System Information panel.
+- [thermostat]: Added thermostatRunningState attribute. Thanks Ludovic BOUÉ (https://github.com/Luligu/matterbridge/pull/410).
+- [ElectricalPowerMeasurement]: Added createApparentElectricalPowerMeasurementClusterServer cluster helper. Thanks Ludovic BOUÉ (https://github.com/Luligu/matterbridge/pull/411).
 
 ### Changed
 

package/README-MACOS-PLIST.md

@@ -195,12 +195,12 @@ sudo launchctl disable system/matterbridge
 sudo tail -n 1000 -f /var/log/matterbridge.log /var/log/matterbridge.err
 ```
 
-### Automatically rotate logs (every 5 days or at 100 MB, keep 5 compressed backups)
+### Optional: automatically rotate logs (every 5 days or at 100 MB, keep 5 compressed backups)
 
 ```bash
 sudo tee /etc/newsyslog.d/matterbridge.conf <<'EOF'
-/var/log/matterbridge.log  root:wheel 640  5  102400  5  Z
-/var/log/matterbridge.err  root:wheel 640  5  102400  5  Z
+/var/log/matterbridge.log  root:wheel 640  5  102400  5  ZC
+/var/log/matterbridge.err  root:wheel 640  5  102400  5  ZC
 EOF
 sudo newsyslog -v
 ```

package/dist/cliHistory.js

@@ -2,6 +2,7 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mCli history loaded.\u001B[40;0m');
 import { writeFileSync } from 'node:fs';
 import path from 'node:path';
+import os from 'node:os';
 export const historySize = 2880;
 export let historyIndex = 0;
 export function setHistoryIndex(index) {
@@ -32,6 +33,7 @@ export const history = Array.from({ length: historySize }, () => ({
 }));
 export function generateHistoryPage(options = {}) {
     const pageTitle = options.pageTitle ?? 'Matterbridge CPU & Memory History';
+    const hostname = options.hostname ?? os.hostname();
     const outputPath = path.resolve(options.outputPath ?? path.join(process.cwd(), 'history.html'));
     const bufferLength = history.length;
     if (bufferLength === 0) {
@@ -101,7 +103,7 @@ export function generateHistoryPage(options = {}) {
       }
       h1 {
         margin-top: 0;
-        font-size: clamp(1.6rem, 2.2vw, 2.3rem);
+        font-size: clamp(1.4rem, 1.8vw, 2.0rem);
         font-weight: 700;
         color: var(--accent);
       }
@@ -231,7 +233,8 @@ export function generateHistoryPage(options = {}) {
     <div class="container">
       <header>
         <h1>${escapeHtml(pageTitle)}</h1>
-        <p>Generated ${new Date().toLocaleString()}</p>
+        <p>Hostname: ${escapeHtml(hostname)}</p>
+        <p>Generated: ${new Date().toLocaleString()}</p>
       </header>
 
       <section class="card">

package/dist/frontend.js

@@ -405,41 +405,7 @@ export class Frontend extends EventEmitter {
         });
         this.expressApp.get('/api/view-diagnostic', async (req, res) => {
             this.log.debug('The frontend sent /api/view-diagnostic');
-            const serverNodes = [];
-            if (this.matterbridge.bridgeMode === 'bridge') {
-                if (this.matterbridge.serverNode)
-                    serverNodes.push(this.matterbridge.serverNode);
-            }
-            else if (this.matterbridge.bridgeMode === 'childbridge') {
-                for (const plugin of this.matterbridge.plugins.array()) {
-                    if (plugin.serverNode)
-                        serverNodes.push(plugin.serverNode);
-                }
-            }
-            for (const device of this.matterbridge.devices.array()) {
-                if (device.serverNode)
-                    serverNodes.push(device.serverNode);
-            }
-            const fs = await import('node:fs');
-            if (fs.existsSync(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE)))
-                fs.unlinkSync(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE));
-            const diagnosticDestination = LogDestination({ name: 'diagnostic', level: MatterLogLevel.INFO, format: MatterLogFormat.formats.plain });
-            diagnosticDestination.write = async (text, _message) => {
-                await fs.promises.appendFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), text + '\n', { encoding: 'utf8' });
-            };
-            Logger.destinations.diagnostic = diagnosticDestination;
-            if (!diagnosticDestination.context) {
-                diagnosticDestination.context = Diagnostic.Context();
-            }
-            diagnosticDestination.context.run(() => diagnosticDestination.add(Diagnostic.message({
-                now: Time.now(),
-                facility: 'Server nodes:',
-                level: MatterLogLevel.INFO,
-                prefix: Logger.nestingLevel ? '⎸'.padEnd(Logger.nestingLevel * 2) : '',
-                values: [...serverNodes],
-            })));
-            delete Logger.destinations.diagnostic;
-            await wait(500);
+            await this.generateDiagnostic();
             try {
                 const fs = await import('node:fs');
                 const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), 'utf8');
@@ -451,6 +417,26 @@ export class Frontend extends EventEmitter {
                 res.status(500).send('Error reading diagnostic log file.');
             }
         });
+        this.expressApp.get('/api/download-diagnostic', async (req, res) => {
+            this.log.debug(`The frontend sent /api/download-diagnostic`);
+            await this.generateDiagnostic();
+            try {
+                const fs = await import('node:fs');
+                await fs.promises.access(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), fs.constants.F_OK);
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), 'utf8');
+                await fs.promises.writeFile(path.join(os.tmpdir(), MATTERBRIDGE_DIAGNOSTIC_FILE), data, 'utf-8');
+            }
+            catch (error) {
+                this.log.debug(`Error in /api/download-diagnostic: ${error instanceof Error ? error.message : error}`);
+            }
+            res.type('text/plain');
+            res.download(path.join(os.tmpdir(), MATTERBRIDGE_DIAGNOSTIC_FILE), MATTERBRIDGE_DIAGNOSTIC_FILE, (error) => {
+                if (error) {
+                    this.log.error(`Error downloading file ${MATTERBRIDGE_DIAGNOSTIC_FILE}: ${error instanceof Error ? error.message : error}`);
+                    res.status(500).send('Error downloading the diagnostic log file');
+                }
+            });
+        });
         this.expressApp.get('/api/viewhistory', async (req, res) => {
             this.log.debug('The frontend sent /api/viewhistory');
             try {
@@ -460,8 +446,28 @@ export class Frontend extends EventEmitter {
                 res.send(data);
             }
             catch (error) {
-                this.log.error(`Error reading history log file ${MATTERBRIDGE_HISTORY_FILE}: ${error instanceof Error ? error.message : error}`);
-                res.status(500).send('Error reading history log file. Please create the history log before loading it.');
+                this.log.error(`Error in /api/viewhistory reading history file ${MATTERBRIDGE_HISTORY_FILE}: ${error instanceof Error ? error.message : error}`);
+                res.status(500).send('Error reading history file.');
+            }
+        });
+        this.expressApp.get('/api/downloadhistory', async (req, res) => {
+            this.log.debug(`The frontend sent /api/downloadhistory`);
+            try {
+                const fs = await import('node:fs');
+                await fs.promises.access(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), fs.constants.F_OK);
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), 'utf8');
+                await fs.promises.writeFile(path.join(os.tmpdir(), MATTERBRIDGE_HISTORY_FILE), data, 'utf-8');
+                res.type('text/plain');
+                res.download(path.join(os.tmpdir(), MATTERBRIDGE_HISTORY_FILE), MATTERBRIDGE_HISTORY_FILE, (error) => {
+                    if (error) {
+                        this.log.error(`Error in /api/downloadhistory downloading history file ${MATTERBRIDGE_HISTORY_FILE}: ${error instanceof Error ? error.message : error}`);
+                        res.status(500).send('Error downloading history file');
+                    }
+                });
+            }
+            catch (error) {
+                this.log.error(`Error in /api/downloadhistory reading history file ${MATTERBRIDGE_HISTORY_FILE}: ${error instanceof Error ? error.message : error}`);
+                res.status(500).send('Error reading history file.');
             }
         });
         this.expressApp.get('/api/shellyviewsystemlog', async (req, res) => {
@@ -999,6 +1005,44 @@ export class Frontend extends EventEmitter {
         });
         return { plugin: endpoint.plugin, deviceName: endpoint.deviceName, serialNumber: endpoint.serialNumber, number: endpoint.number, id: endpoint.id, deviceTypes, clusters };
     }
+    async generateDiagnostic() {
+        this.log.debug('Generating diagnostic...');
+        const serverNodes = [];
+        if (this.matterbridge.bridgeMode === 'bridge') {
+            if (this.matterbridge.serverNode)
+                serverNodes.push(this.matterbridge.serverNode);
+        }
+        else if (this.matterbridge.bridgeMode === 'childbridge') {
+            for (const plugin of this.matterbridge.plugins.array()) {
+                if (plugin.serverNode)
+                    serverNodes.push(plugin.serverNode);
+            }
+        }
+        for (const device of this.matterbridge.devices.array()) {
+            if (device.serverNode)
+                serverNodes.push(device.serverNode);
+        }
+        const fs = await import('node:fs');
+        if (fs.existsSync(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE)))
+            fs.unlinkSync(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE));
+        const diagnosticDestination = LogDestination({ name: 'diagnostic', level: MatterLogLevel.INFO, format: MatterLogFormat.formats.plain });
+        diagnosticDestination.write = async (text, _message) => {
+            await fs.promises.appendFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), text + '\n', { encoding: 'utf8' });
+        };
+        Logger.destinations.diagnostic = diagnosticDestination;
+        if (!diagnosticDestination.context) {
+            diagnosticDestination.context = Diagnostic.Context();
+        }
+        diagnosticDestination.context.run(() => diagnosticDestination.add(Diagnostic.message({
+            now: Time.now(),
+            facility: 'Server nodes:',
+            level: MatterLogLevel.INFO,
+            prefix: Logger.nestingLevel ? '⎸'.padEnd(Logger.nestingLevel * 2) : '',
+            values: [...serverNodes],
+        })));
+        delete Logger.destinations.diagnostic;
+        await wait(500);
+    }
     async wsMessageHandler(client, message) {
         let data;
         const sendResponse = (data) => {
@@ -1286,8 +1330,12 @@ export class Frontend extends EventEmitter {
                 await this.matterbridge.shutdownProcessAndFactoryReset();
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
-            else if (data.method === '/api/generatehistorypage') {
-                generateHistoryPage({ outputPath: path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), pageTitle: `Matterbridge on ${this.matterbridge.systemInformation.hostname} Cpu & Memory History` });
+            else if (data.method === '/api/viewhistorypage') {
+                generateHistoryPage({ outputPath: path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), pageTitle: `Matterbridge Cpu & Memory History` });
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+            }
+            else if (data.method === '/api/downloadhistorypage') {
+                generateHistoryPage({ outputPath: path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), pageTitle: `Matterbridge Cpu & Memory History` });
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
             }
             else if (data.method === '/api/matter') {

package/dist/matterbridge.js

@@ -14,7 +14,7 @@ import { BasicInformationServer } from '@matter/main/behaviors/basic-information
 import { getParameter, getIntParameter, hasParameter } from './utils/commandLine.js';
 import { copyDirectory } from './utils/copyDirectory.js';
 import { createDirectory } from './utils/createDirectory.js';
-import { isValidString, parseVersionString, isValidNumber } from './utils/isvalid.js';
+import { isValidString, parseVersionString, isValidNumber, isValidObject } from './utils/isvalid.js';
 import { formatMemoryUsage, formatOsUpTime } from './utils/network.js';
 import { withTimeout, waiter, wait } from './utils/wait.js';
 import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, typ } from './matterbridgeTypes.js';
@@ -1737,6 +1737,8 @@ export class Matterbridge extends EventEmitter {
             { cluster: 'Thermostat', attribute: 'occupiedCoolingSetpoint' },
             { cluster: 'Thermostat', attribute: 'occupiedHeatingSetpoint' },
             { cluster: 'Thermostat', attribute: 'systemMode' },
+            { cluster: 'Thermostat', attribute: 'thermostatRunningMode' },
+            { cluster: 'Thermostat', attribute: 'thermostatRunningState' },
             { cluster: 'WindowCovering', attribute: 'operationalStatus' },
             { cluster: 'WindowCovering', attribute: 'currentPositionLiftPercent100ths' },
             { cluster: 'DoorLock', attribute: 'lockState' },
@@ -1766,7 +1768,7 @@ export class Matterbridge extends EventEmitter {
             if (device.hasAttributeServer(sub.cluster, sub.attribute)) {
                 this.log.debug(`Subscribing to endpoint ${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
                 await device.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
-                    this.log.debug(`Bridged endpoint ${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${value}${db}`);
+                    this.log.debug(`Bridged endpoint ${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${isValidObject(value) ? debugStringify(value) : value}${db}`);
                     this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, device.number, device.id, sub.cluster, sub.attribute, value);
                 });
             }
@@ -1774,7 +1776,7 @@ export class Matterbridge extends EventEmitter {
                 if (child.hasAttributeServer(sub.cluster, sub.attribute)) {
                     this.log.debug(`Subscribing to child endpoint ${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
                     await child.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
-                        this.log.debug(`Bridged child endpoint ${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${value}${db}`);
+                        this.log.debug(`Bridged child endpoint ${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${isValidObject(value) ? debugStringify(value) : value}${db}`);
                         this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, child.number, child.id, sub.cluster, sub.attribute, value);
                     });
                 }

package/dist/matterbridgeEndpoint.js

@@ -1,5 +1,5 @@
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, UINT16_MAX, UINT32_MAX, VendorId } from '@matter/main';
-import { getClusterNameById, MeasurementType } from '@matter/main/types';
+import { getClusterNameById } from '@matter/main/types';
 import { Descriptor } from '@matter/main/clusters/descriptor';
 import { PowerSource } from '@matter/main/clusters/power-source';
 import { BridgedDeviceBasicInformation } from '@matter/main/clusters/bridged-device-basic-information';
@@ -60,7 +60,7 @@ import { ThermostatUserInterfaceConfigurationServer } from '@matter/main/behavio
 import { AnsiLogger, CYAN, YELLOW, db, debugStringify, hk, or, zb } from './logger/export.js';
 import { isValidNumber, isValidObject, isValidString } from './utils/export.js';
 import { MatterbridgeServer, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeEnhancedColorControlServer, } from './matterbridgeBehaviors.js';
-import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultOperationalStateClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, invokeBehaviorCommand, triggerEvent, featuresFor, } from './matterbridgeEndpointHelpers.js';
+import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultOperationalStateClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getApparentElectricalPowerMeasurementClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, invokeBehaviorCommand, triggerEvent, featuresFor, } from './matterbridgeEndpointHelpers.js';
 export class MatterbridgeEndpoint extends Endpoint {
     static logLevel = "info";
     mode = undefined;
@@ -782,8 +782,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : [])), {
             localTemperature: localTemperature * 100,
             ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
-            systemMode: Thermostat.SystemMode.Auto,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingAndHeating,
+            systemMode: Thermostat.SystemMode.Auto,
+            thermostatRunningState: {
+                heat: false,
+                cool: false,
+                fan: false,
+                heatStage2: false,
+                coolStage2: false,
+                fanStage2: false,
+                fanStage3: false,
+            },
             occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
             minHeatSetpointLimit: minHeatSetpointLimit * 100,
             maxHeatSetpointLimit: maxHeatSetpointLimit * 100,
@@ -806,8 +815,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : [])), {
             localTemperature: localTemperature * 100,
             ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
-            systemMode: Thermostat.SystemMode.Heat,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.HeatingOnly,
+            systemMode: Thermostat.SystemMode.Heat,
+            thermostatRunningState: {
+                heat: false,
+                cool: false,
+                fan: false,
+                heatStage2: false,
+                coolStage2: false,
+                fanStage2: false,
+                fanStage3: false,
+            },
             occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
             minHeatSetpointLimit: minHeatSetpointLimit * 100,
             maxHeatSetpointLimit: maxHeatSetpointLimit * 100,
@@ -822,8 +840,17 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Cooling, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : [])), {
             localTemperature: localTemperature * 100,
             ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
-            systemMode: Thermostat.SystemMode.Cool,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingOnly,
+            systemMode: Thermostat.SystemMode.Cool,
+            thermostatRunningState: {
+                heat: false,
+                cool: false,
+                fan: false,
+                heatStage2: false,
+                coolStage2: false,
+                fanStage2: false,
+                fanStage3: false,
+            },
             occupiedCoolingSetpoint: occupiedCoolingSetpoint * 100,
             minCoolSetpointLimit: minCoolSetpointLimit * 100,
             maxCoolSetpointLimit: maxCoolSetpointLimit * 100,
@@ -1170,59 +1197,15 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createDefaultElectricalEnergyMeasurementClusterServer(energyImported = null, energyExported = null) {
-        this.behaviors.require(ElectricalEnergyMeasurementServer.with(ElectricalEnergyMeasurement.Feature.ImportedEnergy, ElectricalEnergyMeasurement.Feature.ExportedEnergy, ElectricalEnergyMeasurement.Feature.CumulativeEnergy), {
-            accuracy: {
-                measurementType: MeasurementType.ElectricalEnergy,
-                measured: true,
-                minMeasuredValue: Number.MIN_SAFE_INTEGER,
-                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
-                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
-            },
-            cumulativeEnergyReset: null,
-            cumulativeEnergyImported: energyImported !== null && energyImported >= 0 ? { energy: energyImported } : null,
-            cumulativeEnergyExported: energyExported !== null && energyExported >= 0 ? { energy: energyExported } : null,
-        });
+        this.behaviors.require(ElectricalEnergyMeasurementServer.with(ElectricalEnergyMeasurement.Feature.ImportedEnergy, ElectricalEnergyMeasurement.Feature.ExportedEnergy, ElectricalEnergyMeasurement.Feature.CumulativeEnergy), getDefaultElectricalEnergyMeasurementClusterServer(energyImported, energyExported));
         return this;
     }
     createDefaultElectricalPowerMeasurementClusterServer(voltage = null, current = null, power = null, frequency = null) {
-        this.behaviors.require(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), {
-            powerMode: ElectricalPowerMeasurement.PowerMode.Ac,
-            numberOfMeasurementTypes: 4,
-            accuracy: [
-                {
-                    measurementType: MeasurementType.Voltage,
-                    measured: true,
-                    minMeasuredValue: Number.MIN_SAFE_INTEGER,
-                    maxMeasuredValue: Number.MAX_SAFE_INTEGER,
-                    accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
-                },
-                {
-                    measurementType: MeasurementType.ActiveCurrent,
-                    measured: true,
-                    minMeasuredValue: Number.MIN_SAFE_INTEGER,
-                    maxMeasuredValue: Number.MAX_SAFE_INTEGER,
-                    accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
-                },
-                {
-                    measurementType: MeasurementType.ActivePower,
-                    measured: true,
-                    minMeasuredValue: Number.MIN_SAFE_INTEGER,
-                    maxMeasuredValue: Number.MAX_SAFE_INTEGER,
-                    accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
-                },
-                {
-                    measurementType: MeasurementType.Frequency,
-                    measured: true,
-                    minMeasuredValue: Number.MIN_SAFE_INTEGER,
-                    maxMeasuredValue: Number.MAX_SAFE_INTEGER,
-                    accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
-                },
-            ],
-            voltage: voltage,
-            activeCurrent: current,
-            activePower: power,
-            frequency: frequency,
-        });
+        this.behaviors.require(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), getDefaultElectricalPowerMeasurementClusterServer(voltage, current, power, frequency));
+        return this;
+    }
+    createApparentElectricalPowerMeasurementClusterServer(voltage = null, apparentCurrent = null, apparentPower = null, frequency = null) {
+        this.behaviors.require(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), getApparentElectricalPowerMeasurementClusterServer(voltage, apparentCurrent, apparentPower, frequency));
         return this;
     }
     createDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {

package/dist/matterbridgeEndpointHelpers.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { BLUE, CYAN, db, debugStringify, er, hk, or, YELLOW, zb } from 'node-ansi-logger';
 import { Lifecycle } from '@matter/main';
-import { getClusterNameById } from '@matter/main/types';
+import { getClusterNameById, MeasurementType } from '@matter/main/types';
 import { PowerSource } from '@matter/main/clusters/power-source';
 import { UserLabel } from '@matter/main/clusters/user-label';
 import { FixedLabel } from '@matter/main/clusters/fixed-label';
@@ -601,3 +601,97 @@ export function getDefaultOccupancySensingClusterServer(occupied = false, holdTi
         holdTimeLimits: { holdTimeMin, holdTimeMax, holdTimeDefault: holdTime },
     });
 }
+export function getDefaultElectricalEnergyMeasurementClusterServer(energyImported = null, energyExported = null) {
+    return optionsFor(ElectricalEnergyMeasurementServer.with(ElectricalEnergyMeasurement.Feature.ImportedEnergy, ElectricalEnergyMeasurement.Feature.ExportedEnergy, ElectricalEnergyMeasurement.Feature.CumulativeEnergy), {
+        accuracy: {
+            measurementType: MeasurementType.ElectricalEnergy,
+            measured: true,
+            minMeasuredValue: Number.MIN_SAFE_INTEGER,
+            maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+            accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+        },
+        cumulativeEnergyReset: null,
+        cumulativeEnergyImported: energyImported !== null && energyImported >= 0 ? { energy: energyImported } : null,
+        cumulativeEnergyExported: energyExported !== null && energyExported >= 0 ? { energy: energyExported } : null,
+    });
+}
+export function getDefaultElectricalPowerMeasurementClusterServer(voltage = null, current = null, power = null, frequency = null) {
+    return optionsFor(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), {
+        powerMode: ElectricalPowerMeasurement.PowerMode.Ac,
+        numberOfMeasurementTypes: 4,
+        accuracy: [
+            {
+                measurementType: MeasurementType.Voltage,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+            {
+                measurementType: MeasurementType.ActiveCurrent,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+            {
+                measurementType: MeasurementType.ActivePower,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+            {
+                measurementType: MeasurementType.Frequency,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+        ],
+        voltage: voltage,
+        activeCurrent: current,
+        activePower: power,
+        frequency: frequency,
+    });
+}
+export function getApparentElectricalPowerMeasurementClusterServer(voltage = null, apparentCurrent = null, apparentPower = null, frequency = null) {
+    return optionsFor(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.AlternatingCurrent), {
+        powerMode: ElectricalPowerMeasurement.PowerMode.Ac,
+        numberOfMeasurementTypes: 4,
+        accuracy: [
+            {
+                measurementType: MeasurementType.Voltage,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+            {
+                measurementType: MeasurementType.ApparentCurrent,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+            {
+                measurementType: MeasurementType.ApparentPower,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+            {
+                measurementType: MeasurementType.Frequency,
+                measured: true,
+                minMeasuredValue: Number.MIN_SAFE_INTEGER,
+                maxMeasuredValue: Number.MAX_SAFE_INTEGER,
+                accuracyRanges: [{ rangeMin: Number.MIN_SAFE_INTEGER, rangeMax: Number.MAX_SAFE_INTEGER, fixedMax: 1 }],
+            },
+        ],
+        voltage: voltage,
+        apparentCurrent: apparentCurrent,
+        apparentPower: apparentPower,
+        frequency: frequency,
+    });
+}