matterbridge 3.3.4-dev-20251020-df40d12 → 3.3.4-dev-20251022-681420c

package/CHANGELOG.md

@@ -14,6 +14,10 @@ The project will evolve to a multi-threaded architecture (the CLI will become th
 
 - matterbridge;
 - frontend;
+- plugins;
+- devices;
+- check_updates;
+- npm_install;
 - all plugins in bridge mode;
 - each plugin in childbridge mode;
 
@@ -33,13 +37,18 @@ Advantages:
 
 - [frontend]: Added debounce to MatterSettings.
 - [cli]: Bumped `cli` version to 3.0.0 with backport of Traker and Inspector from thread module.
+- [powerSource]: Added MatterbridgePowerSourceServer. It initializes the enpointList of the PowerSource cluster.
+- [thread]: Added BroadcastServer to Matterbridge.
+- [service]: Added configuration [guide](README-SERVICE-LOCAL.md) to run matterbridge as a daemon with systemctl (Linux only) and with local global node_modules (no sudo required).
 
 ### Changed
 
 - [package]: Updated dependencies.
 - [package]: Optimized @matter imports.
+- [endpoint]: Optimized memory requirements.
 - [matter]: Bumped `matter.js` version to 0.15.6. Thanks matter.js!
 - [frontend]: Bumped `frontend` version to 3.2.3.
+- [thread]: Bumped `BroadcastServer` version to 1.0.1.
 
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="bmc-button.svg" alt="Buy me a coffee" width="80">

package/README-DOCKER.md

@@ -53,7 +53,8 @@ This will create the required directories in your home directory if they don't e
 cd ~
 mkdir -p ~/Matterbridge
 mkdir -p ~/.matterbridge
-sudo chown -R $USER:$USER ~/Matterbridge ~/.matterbridge
+mkdir -p ~/.mattercert
+sudo chown -R $USER:$USER ~/Matterbridge ~/.matterbridge ~/.mattercert
 ```
 
 You may need to adapt the script to your setup.
@@ -77,6 +78,7 @@ The container must have full access to the host network (needed for mdns and Mat
 sudo docker run --name matterbridge \
   -v ~/Matterbridge:/root/Matterbridge \
   -v ~/.matterbridge:/root/.matterbridge \
+  -v ~/.mattercert:/root/.mattercert \
   --network host --restart always -d luligu/matterbridge:latest
 ```
 
@@ -96,6 +98,7 @@ services:
     volumes:
       - "${HOME}/Matterbridge:/root/Matterbridge"             # Mounts the Matterbridge plugin directory
       - "${HOME}/.matterbridge:/root/.matterbridge"           # Mounts the Matterbridge storage directory
+      - "${HOME}/.mattercert:/root/.mattercert"               # Mounts the Matterbridge certificate directory
 ```
 
 Copy it in the home directory or edit the existing one to add the matterbridge service.

package/README-SERVICE-LOCAL.md

@@ -0,0 +1,226 @@
+# <img src="frontend/public/matterbridge.svg" alt="Matterbridge Logo" width="64px" height="64px">&nbsp;&nbsp;&nbsp;Matterbridge systemd configuration with local global node_modules
+
+[![npm version](https://img.shields.io/npm/v/matterbridge.svg)](https://www.npmjs.com/package/matterbridge)
+[![npm downloads](https://img.shields.io/npm/dt/matterbridge.svg)](https://www.npmjs.com/package/matterbridge)
+[![Docker Version](https://img.shields.io/docker/v/luligu/matterbridge?label=docker%20version&sort=semver)](https://hub.docker.com/r/luligu/matterbridge)
+[![Docker Pulls](https://img.shields.io/docker/pulls/luligu/matterbridge.svg)](https://hub.docker.com/r/luligu/matterbridge)
+![Node.js CI](https://github.com/Luligu/matterbridge/actions/workflows/build.yml/badge.svg)
+![CodeQL](https://github.com/Luligu/matterbridge/actions/workflows/codeql.yml/badge.svg)
+[![codecov](https://codecov.io/gh/Luligu/matterbridge/branch/main/graph/badge.svg)](https://codecov.io/gh/Luligu/matterbridge)
+
+[![power by](https://img.shields.io/badge/powered%20by-matter--history-blue)](https://www.npmjs.com/package/matter-history)
+[![power by](https://img.shields.io/badge/powered%20by-node--ansi--logger-blue)](https://www.npmjs.com/package/node-ansi-logger)
+[![power by](https://img.shields.io/badge/powered%20by-node--persist--manager-blue)](https://www.npmjs.com/package/node-persist-manager)
+
+---
+
+# Advanced configuration
+
+## Run matterbridge as a daemon with systemctl (Linux only) with local global node_modules
+
+The easiest way to add systemctl is to use [Matterbridge service cli for linux](https://github.com/Luligu/mb-service-linux).
+
+If your setup is too complex or you prefer to do it manually follow this method. You can still use mb-service to manage systemd after.
+
+### First create the Matterbridge directories and set the correct permissions
+
+This will create the required directories if they don't exist
+
+```bash
+cd ~
+sudo systemctl stop matterbridge                                                        # ✅ Safe precaution
+mkdir -p ~/Matterbridge ~/.matterbridge ~/.mattercert ~/.npm-global                     # ✅ Creates all needed dirs
+chown -R $USER:$USER ~/Matterbridge ~/.matterbridge ~/.mattercert ~/.npm-global         # ✅ Ensures ownership
+chmod -R 755 ~/Matterbridge ~/.matterbridge ~/.mattercert ~/.npm-global                 # ✅ Secure permissions
+NPM_CONFIG_PREFIX=~/.npm-global npm install matterbridge --omit=dev --verbose --global  # ✅ Install, no sudo
+```
+
+### Then create a system-wide symlink
+
+```bash
+sudo ln -sf /home/$USER/.npm-global/bin/matterbridge /usr/local/bin/matterbridge
+which matterbridge
+matterbridge --version
+```
+
+### Then create a systemctl configuration file for Matterbridge
+
+Create a systemctl configuration file for Matterbridge
+
+```bash
+sudo nano /etc/systemd/system/matterbridge.service
+```
+
+Add the following to this file, replacing 5 times (!) USER with your user name (e.g. WorkingDirectory=/home/pi/Matterbridge, User=pi and Group=pi and Environment="NPM_CONFIG_PREFIX=/home/pi/.npm-global"):
+
+```
+[Unit]
+Description=matterbridge
+After=network.target
+Wants=network.target
+
+[Service]
+Type=simple
+Environment="NPM_CONFIG_PREFIX=/home/<USER>/.npm-global"
+ExecStart=matterbridge --service --nosudo
+WorkingDirectory=/home/<USER>/Matterbridge
+StandardOutput=inherit
+StandardError=inherit
+Restart=always
+User=<USER>
+Group=<USER>
+
+[Install]
+WantedBy=multi-user.target
+```
+
+If you use the frontend with **-ssl** -frontend 443 and get an error message: "Port 443 requires elevated privileges",
+add this:
+
+```
+[Service]
+AmbientCapabilities=CAP_NET_BIND_SERVICE
+```
+
+If you use the **matterbridge-bthome** plugin add this:
+
+```
+[Service]
+AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_NET_RAW CAP_NET_ADMIN
+```
+
+Now and if you modify matterbridge.service after, run:
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl restart matterbridge.service
+```
+
+### Start Matterbridge
+
+```bash
+sudo systemctl start matterbridge
+```
+
+### Stop Matterbridge
+
+```bash
+sudo systemctl stop matterbridge
+```
+
+### Show Matterbridge status
+
+```bash
+sudo systemctl status matterbridge.service
+```
+
+### Enable Matterbridge to start automatically on boot
+
+```bash
+sudo systemctl enable matterbridge.service
+```
+
+### Disable Matterbridge from starting automatically on boot
+
+```bash
+sudo systemctl disable matterbridge.service
+```
+
+### View the log of Matterbridge in real time (this will show the log with colors)
+
+```bash
+sudo journalctl -u matterbridge.service -n 1000 -f --output cat
+```
+
+### Delete the logs older then 3 days (all of them not only the ones of Matterbridge!)
+
+Check the space used
+
+```bash
+sudo journalctl --disk-usage
+```
+
+remove all log older then 3 days
+
+```bash
+sudo journalctl --rotate
+sudo journalctl --vacuum-time=3d
+```
+
+## Prevent the journal logs to grow
+
+If you want to make the setting permanent to prevent the journal logs to grow too much, run
+
+```bash
+sudo nano /etc/systemd/journald.conf
+```
+
+add
+
+```bash
+Compress=yes            # Compress logs
+MaxRetentionSec=3days   # Keep logs for a maximum of 3 days.
+MaxFileSec=1day         # Rotate logs daily within the 3-day retention period.
+ForwardToSyslog=no      # Disable forwarding to syslog to prevent duplicate logging.
+SystemMaxUse=100M       # Limit persistent logs in /var/log/journal to 100 MB.
+RuntimeMaxUse=100M      # Limit runtime logs in /run/log/journal to 100 MB.
+```
+
+save it and run
+
+```bash
+sudo systemctl restart systemd-journald
+```
+
+## Verify that with your distro you can run sudo npm install -g matterbridge without the password
+
+Run the following command to verify if you can install Matterbridge globally without being prompted for a password:
+
+```bash
+sudo npm install -g matterbridge --omit=dev
+```
+
+If you are not prompted for a password, no further action is required.
+
+If that is not the case, open the sudoers file for editing using visudo
+
+```bash
+sudo visudo
+```
+
+verify the presence of of a line
+
+```
+@includedir /etc/sudoers.d
+```
+
+exit and create a configuration file for sudoers
+
+```bash
+sudo nano /etc/sudoers.d/matterbridge
+```
+
+add this line replacing USER with your user name (e.g. radxa ALL=(ALL) NOPASSWD: ALL)
+
+```
+<USER> ALL=(ALL) NOPASSWD: ALL
+```
+
+or if you prefers to only give access to npm without password try with (e.g. radxa ALL=(ALL) NOPASSWD: /usr/bin/npm)
+
+```
+<USER> ALL=(ALL) NOPASSWD: /usr/bin/npm
+```
+
+save the file and reload the settings with:
+
+```bash
+sudo chmod 0440 /etc/sudoers.d/matterbridge
+sudo visudo -c
+```
+
+Verify if you can install Matterbridge globally without being prompted for a password:
+
+```bash
+sudo npm install -g matterbridge --omit=dev
+```

package/README-SERVICE.md

@@ -28,9 +28,10 @@ This will create the required directories if they don't exist
 
 ```bash
 cd ~
-mkdir -p ./Matterbridge
-mkdir -p ./.matterbridge
-sudo chown -R $USER:$USER ./Matterbridge ./.matterbridge
+mkdir -p ~/Matterbridge
+mkdir -p ~/.matterbridge
+mkdir -p ~/.mattercert
+sudo chown -R $USER:$USER ~/Matterbridge ~/.matterbridge ~/.mattercert
 ```
 
 ### Then create a systemctl configuration file for Matterbridge

package/dist/broadcastServer.js

@@ -34,6 +34,9 @@ export class BroadcastServer extends EventEmitter {
         this.log.debug(`*Received broadcast message: ${debugStringify(data)}`);
         this.emit('broadcast_message', data);
     }
+    broadcast(message) {
+        this.broadcastChannel.postMessage(message);
+    }
     request(message) {
         if (message.id === undefined) {
             message.id = this.getUniqueId();

package/dist/cli.js

@@ -2,7 +2,6 @@ if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mCli loaded.\u001B[40;0m');
 import { AnsiLogger } from 'node-ansi-logger';
 import { cliEmitter } from './cliEmitter.js';
-import { Matterbridge } from './matterbridge.js';
 import { hasParameter, hasAnyParameter } from './utils/commandLine.js';
 import { inspectError } from './utils/error.js';
 import { Tracker } from './utils/tracker.js';
@@ -67,11 +66,13 @@ async function shutdown() {
 }
 async function restart() {
     log.debug('Received restart event, loading...');
+    const { Matterbridge } = await import('./matterbridge.js');
     instance = await Matterbridge.loadInstance(true);
     registerHandlers();
 }
 async function update() {
     log.debug('Received update event, updating...');
+    const { Matterbridge } = await import('./matterbridge.js');
     instance = await Matterbridge.loadInstance(true);
     registerHandlers();
 }
@@ -89,6 +90,7 @@ async function main() {
     if (hasParameter('inspect'))
         await startInspector();
     log.debug(`***Matterbridge.loadInstance(true) called`);
+    const { Matterbridge } = await import('./matterbridge.js');
     instance = await Matterbridge.loadInstance(true);
     log.debug(`***Matterbridge.loadInstance(true) exited`);
     if (!instance || instance.shutdown) {

package/dist/matterbridge.js

@@ -8,10 +8,10 @@ import { inspect } from 'node:util';
 import { AnsiLogger, UNDERLINE, UNDERLINEOFF, db, debugStringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, CYAN, nt, BLUE, or } from 'node-ansi-logger';
 import { NodeStorageManager } from 'node-persist-manager';
 import '@matter/nodejs';
-import { Endpoint, ServerNode } from '@matter/node';
 import { Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, UINT32_MAX, UINT16_MAX, Crypto, Environment, StorageService } from '@matter/general';
-import { DeviceTypeId, VendorId } from '@matter/types';
 import { FabricAction, PaseClient } from '@matter/protocol';
+import { Endpoint, ServerNode } from '@matter/node';
+import { DeviceTypeId, VendorId } from '@matter/types/datatype';
 import { AggregatorEndpoint } from '@matter/node/endpoints';
 import { BasicInformationServer } from '@matter/node/behaviors/basic-information';
 import { getParameter, getIntParameter, hasParameter } from './utils/commandLine.js';
@@ -27,6 +27,7 @@ import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { bridge } from './matterbridgeDeviceTypes.js';
 import { Frontend } from './frontend.js';
 import { addVirtualDevices } from './helpers.js';
+import { BroadcastServer } from './broadcastServer.js';
 export class Matterbridge extends EventEmitter {
     systemInformation = {
         interfaceName: '',
@@ -117,9 +118,35 @@ export class Matterbridge extends EventEmitter {
     aggregatorSerialNumber = getParameter('serialNumber');
     aggregatorUniqueId = getParameter('uniqueId');
     advertisingNodes = new Map();
+    server;
     constructor() {
         super();
         this.log.logNameColor = '\x1b[38;5;115m';
+        this.server = new BroadcastServer('matterbridge', this.log);
+        this.server.on('broadcast_message', this.msgHandler.bind(this));
+    }
+    async msgHandler(msg) {
+        if (this.server.isWorkerRequest(msg, msg.type) && (msg.dst === 'all' || msg.dst === 'matterbridge')) {
+            this.log.debug(`**Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
+            switch (msg.type) {
+                case 'get_log_level':
+                    this.server.respond({ ...msg, response: { success: true, logLevel: this.log.logLevel } });
+                    break;
+                case 'set_log_level':
+                    this.log.logLevel = msg.params.logLevel;
+                    this.server.respond({ ...msg, response: { success: true, logLevel: this.log.logLevel } });
+                    break;
+                default:
+                    this.log.warn(`Unknown broadcast request ${CYAN}${msg.type}${wr} from ${CYAN}${msg.src}${wr}`);
+            }
+        }
+        if (this.server.isWorkerResponse(msg, msg.type)) {
+            this.log.debug(`**Received broadcast response ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
+            switch (msg.type) {
+                default:
+                    this.log.warn(`Unknown broadcast response ${CYAN}${msg.type}${wr} from ${CYAN}${msg.src}${wr}`);
+            }
+        }
     }
     static async loadInstance(initialize = false) {
         if (!Matterbridge.instance) {
@@ -821,6 +848,7 @@ export class Matterbridge extends EventEmitter {
             callbackLogLevel = "debug";
         AnsiLogger.setGlobalCallbackLevel(callbackLogLevel);
         this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
+        return logLevel;
     }
     getLogLevel() {
         return this.log.logLevel;
@@ -993,6 +1021,7 @@ export class Matterbridge extends EventEmitter {
             this.frontend.destroy();
             this.plugins.destroy();
             this.devices.destroy();
+            this.server.close();
             if (this.nodeStorage && this.nodeContext) {
                 this.log.debug(`Closing node storage context for ${plg}Matterbridge${db}...`);
                 await this.nodeContext.close();

package/dist/matterbridgeBehaviors.js

@@ -31,6 +31,7 @@ import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-ener
 import { DeviceEnergyManagementModeServer } from '@matter/node/behaviors/device-energy-management-mode';
 import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
+import { PowerSourceServer } from '@matter/node/behaviors/power-source';
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
     initialize() {
@@ -45,6 +46,24 @@ export class MatterbridgeServer extends Behavior {
     }
     MatterbridgeServer.State = State;
 })(MatterbridgeServer || (MatterbridgeServer = {}));
+export class MatterbridgePowerSourceServer extends PowerSourceServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Initializing MatterbridgePowerSourceServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.state.endpointList = [this.endpoint.number];
+        this.endpoint.construction.onSuccess(() => {
+            device.log.debug(`MatterbridgePowerSourceServer: endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber} construction completed`);
+            const endpointList = [this.endpoint.number];
+            for (const endpoint of this.endpoint.parts) {
+                if (endpoint.lifecycle.isReady) {
+                    endpointList.push(endpoint.number);
+                }
+            }
+            this.endpoint.setStateOf(PowerSourceServer, { endpointList });
+            device.log.debug(`MatterbridgePowerSourceServer: endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber} construction completed with endpointList: ${endpointList.join(', ')}`);
+        });
+    }
+}
 export class MatterbridgeIdentifyServer extends IdentifyServer {
     identify(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);

package/dist/matterbridgeDeviceTypes.js

@@ -1,4 +1,6 @@
-import { DeviceTypeId } from '@matter/types';
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mMatterbridgeDeviceTypes loaded.\u001B[40;0m');
+import { DeviceTypeId } from '@matter/types/datatype';
 import { AccountLogin } from '@matter/types/clusters/account-login';
 import { Actions } from '@matter/types/clusters/actions';
 import { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
@@ -90,9 +92,9 @@ export var DeviceClasses;
     DeviceClasses["Utility"] = "Utility";
     DeviceClasses["Simple"] = "Simple";
     DeviceClasses["Dynamic"] = "Dynamic";
+    DeviceClasses["Composed"] = "Composed";
     DeviceClasses["Client"] = "Client";
     DeviceClasses["Server"] = "Server";
-    DeviceClasses["Composed"] = "Composed";
     DeviceClasses["Duplicate"] = "Duplicate";
     DeviceClasses["BridgedPowerSourceInfo"] = "BridgedPowerSourceInfo";
 })(DeviceClasses || (DeviceClasses = {}));

package/dist/matterbridgeEndpoint.js

@@ -1,9 +1,10 @@
 if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mMatterbridgeEndpoint loaded.\u001B[40;0m');
 import { AnsiLogger, CYAN, YELLOW, db, debugStringify, hk, or, zb } from 'node-ansi-logger';
-import { Endpoint, MutableEndpoint, SupportedBehaviors } from '@matter/node';
 import { Lifecycle, NamedHandler, UINT16_MAX, UINT32_MAX } from '@matter/general';
-import { getClusterNameById, VendorId } from '@matter/types';
+import { Endpoint, MutableEndpoint, SupportedBehaviors } from '@matter/node';
+import { getClusterNameById } from '@matter/types/cluster';
+import { VendorId } from '@matter/types/datatype';
 import { Descriptor } from '@matter/types/clusters/descriptor';
 import { PowerSource } from '@matter/types/clusters/power-source';
 import { BridgedDeviceBasicInformation } from '@matter/types/clusters/bridged-device-basic-information';
@@ -29,10 +30,8 @@ import { OccupancySensing } from '@matter/types/clusters/occupancy-sensing';
 import { ThermostatUserInterfaceConfiguration } from '@matter/types/clusters/thermostat-user-interface-configuration';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
-import { DeviceEnergyManagementMode } from '@matter/types/clusters/device-energy-management-mode';
 import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
 import { DescriptorServer } from '@matter/node/behaviors/descriptor';
-import { PowerSourceServer } from '@matter/node/behaviors/power-source';
 import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
 import { GroupsServer } from '@matter/node/behaviors/groups';
 import { ScenesManagementServer } from '@matter/node/behaviors/scenes-management';
@@ -62,8 +61,8 @@ import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@ma
 import { FanControlServer } from '@matter/node/behaviors/fan-control';
 import { ThermostatUserInterfaceConfigurationServer } from '@matter/node/behaviors/thermostat-user-interface-configuration';
 import { isValidNumber, isValidObject, isValidString } from './utils/isvalid.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, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getApparentElectricalPowerMeasurementClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, invokeBehaviorCommand, triggerEvent, featuresFor, } from './matterbridgeEndpointHelpers.js';
+import { MatterbridgeServer, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeEnhancedColorControlServer, MatterbridgePowerSourceServer, } from './matterbridgeBehaviors.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, getDefaultPowerSourceWiredClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, } from './matterbridgeEndpointHelpers.js';
 export class MatterbridgeEndpoint extends Endpoint {
     static logLevel = "info";
     mode = undefined;
@@ -406,49 +405,15 @@ export class MatterbridgeEndpoint extends Endpoint {
         return device;
     }
     createDefaultPowerSourceWiredClusterServer(wiredCurrentType = PowerSource.WiredCurrentType.Ac) {
-        this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Wired), {
-            status: PowerSource.PowerSourceStatus.Active,
-            order: 0,
-            description: wiredCurrentType === PowerSource.WiredCurrentType.Ac ? 'AC Power' : 'DC Power',
-            endpointList: [],
-            wiredCurrentType,
-        });
+        this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Wired), getDefaultPowerSourceWiredClusterServer(wiredCurrentType));
         return this;
     }
     createDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1, batReplaceability = PowerSource.BatReplaceability.UserReplaceable) {
-        this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), {
-            status: PowerSource.PowerSourceStatus.Active,
-            order: 0,
-            description: 'Primary battery',
-            endpointList: [],
-            batVoltage,
-            batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
-            batChargeLevel,
-            batReplacementNeeded: false,
-            batReplaceability,
-            activeBatFaults: undefined,
-            batReplacementDescription,
-            batQuantity,
-        });
+        this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage, batReplacementDescription, batQuantity, batReplaceability));
         return this;
     }
     createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
-        this.behaviors.require(PowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), {
-            status: PowerSource.PowerSourceStatus.Active,
-            order: 0,
-            description: 'Primary battery',
-            endpointList: [],
-            batVoltage,
-            batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
-            batTimeRemaining: null,
-            batChargeLevel,
-            batReplacementNeeded: false,
-            batReplaceability,
-            batPresent: true,
-            activeBatFaults: [],
-            batChargeState: PowerSource.BatChargeState.IsNotCharging,
-            batFunctionalWhileCharging: true,
-        });
+        this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage, batReplaceability));
         return this;
     }
     createDefaultBasicInformationClusterServer(deviceName, serialNumber, vendorId = 0xfff1, vendorName = 'Matterbridge', productId = 0x8000, productName = 'Matterbridge device', softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0') {
@@ -498,6 +463,30 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    createDefaultPowerTopologyClusterServer() {
+        this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.TreeTopology));
+        return this;
+    }
+    createDefaultElectricalEnergyMeasurementClusterServer(energyImported = null, 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), 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;
+    }
+    createDefaultDeviceEnergyManagementClusterServer(esaType = DeviceEnergyManagement.EsaType.Other, esaCanGenerate = false, esaState = DeviceEnergyManagement.EsaState.Online, absMinPower = 0, absMaxPower = 0) {
+        this.behaviors.require(MatterbridgeDeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment), getDefaultDeviceEnergyManagementClusterServer(esaType, esaCanGenerate, esaState, absMinPower, absMaxPower));
+        return this;
+    }
+    createDefaultDeviceEnergyManagementModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MatterbridgeDeviceEnergyManagementModeServer, getDefaultDeviceEnergyManagementModeClusterServer(currentMode, supportedModes));
+        return this;
+    }
     createDefaultIdentifyClusterServer(identifyTime = 0, identifyType = Identify.IdentifyType.None) {
         this.behaviors.require(MatterbridgeIdentifyServer, {
             identifyTime,
@@ -1158,60 +1147,6 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultDeviceEnergyManagementClusterServer(esaType = DeviceEnergyManagement.EsaType.Other, esaCanGenerate = false, esaState = DeviceEnergyManagement.EsaState.Online, absMinPower = 0, absMaxPower = 0) {
-        this.behaviors.require(MatterbridgeDeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment), {
-            esaType,
-            esaCanGenerate,
-            esaState,
-            absMinPower,
-            absMaxPower,
-            powerAdjustmentCapability: null,
-            optOutState: DeviceEnergyManagement.OptOutState.NoOptOut,
-            forecast: null,
-        });
-        return this;
-    }
-    createDefaultDeviceEnergyManagementModeClusterServer(currentMode, supportedModes) {
-        this.behaviors.require(MatterbridgeDeviceEnergyManagementModeServer, {
-            supportedModes: supportedModes ?? [
-                { label: 'No Energy Management (Forecast reporting only)', mode: 1, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.NoOptimization }] },
-                {
-                    label: 'Device Energy Management',
-                    mode: 2,
-                    modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.DeviceOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }],
-                },
-                {
-                    label: 'Home Energy Management',
-                    mode: 3,
-                    modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.GridOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }],
-                },
-                { label: 'Grid Energy Managemen', mode: 4, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.GridOptimization }] },
-                {
-                    label: 'Full Energy Management',
-                    mode: 5,
-                    modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.DeviceOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }, { value: DeviceEnergyManagementMode.ModeTag.GridOptimization }],
-                },
-            ],
-            currentMode: currentMode ?? 1,
-        });
-        return this;
-    }
-    createDefaultPowerTopologyClusterServer() {
-        this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.TreeTopology));
-        return this;
-    }
-    createDefaultElectricalEnergyMeasurementClusterServer(energyImported = null, 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), 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) {
         this.behaviors.require(TemperatureMeasurementServer, getDefaultTemperatureMeasurementClusterServer(measuredValue, minMeasuredValue, maxMeasuredValue));
         return this;

package/dist/matterbridgeEndpointHelpers.js

@@ -79,8 +79,10 @@ import { Pm10ConcentrationMeasurementServer } from '@matter/node/behaviors/pm10-
 import { RadonConcentrationMeasurementServer } from '@matter/node/behaviors/radon-concentration-measurement';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@matter/node/behaviors/total-volatile-organic-compounds-concentration-measurement';
 import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
-import { deepCopy, deepEqual, isValidArray } from './utils/export.js';
-import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, } from './matterbridgeBehaviors.js';
+import { deepCopy } from './utils/deepCopy.js';
+import { deepEqual } from './utils/deepEqual.js';
+import { isValidArray } from './utils/isvalid.js';
+import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgePowerSourceServer, MatterbridgeDeviceEnergyManagementServer, } from './matterbridgeBehaviors.js';
 export function capitalizeFirstLetter(name) {
     if (!name)
         return name;
@@ -538,70 +540,47 @@ export async function triggerEvent(endpoint, cluster, event, payload, log) {
     log?.info(`${db}Trigger event ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${event}${db} with ${debugStringify(payload)}${db} on endpoint ${or}${endpoint.id}${db}:${or}${endpoint.number}${db} `);
     return true;
 }
-export function getDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
-    return optionsFor(MatterbridgeOperationalStateServer, {
-        phaseList: [],
-        currentPhase: null,
-        countdownTime: null,
-        operationalStateList: [
-            { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
-            { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
-            { operationalStateId: OperationalState.OperationalStateEnum.Paused, operationalStateLabel: 'Paused' },
-            { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
-        ],
-        operationalState,
-        operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+export function getDefaultPowerSourceWiredClusterServer(wiredCurrentType = PowerSource.WiredCurrentType.Ac) {
+    return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Wired), {
+        status: PowerSource.PowerSourceStatus.Active,
+        order: 0,
+        description: wiredCurrentType === PowerSource.WiredCurrentType.Ac ? 'AC Power' : 'DC Power',
+        endpointList: [],
+        wiredCurrentType,
     });
 }
-export function getDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-    return optionsFor(TemperatureMeasurementServer, {
-        measuredValue,
-        minMeasuredValue,
-        maxMeasuredValue,
-        tolerance: 0,
+export function getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1, batReplaceability = PowerSource.BatReplaceability.UserReplaceable) {
+    return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), {
+        status: PowerSource.PowerSourceStatus.Active,
+        order: 0,
+        description: 'Primary battery',
+        endpointList: [],
+        batVoltage,
+        batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
+        batChargeLevel,
+        batReplacementNeeded: false,
+        batReplaceability,
+        activeBatFaults: undefined,
+        batReplacementDescription,
+        batQuantity,
     });
 }
-export function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-    return optionsFor(RelativeHumidityMeasurementServer, {
-        measuredValue,
-        minMeasuredValue,
-        maxMeasuredValue,
-        tolerance: 0,
-    });
-}
-export function getDefaultPressureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-    return optionsFor(PressureMeasurementServer, {
-        measuredValue,
-        minMeasuredValue,
-        maxMeasuredValue,
-        tolerance: 0,
-    });
-}
-export function getDefaultIlluminanceMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-    return optionsFor(IlluminanceMeasurementServer, {
-        measuredValue,
-        minMeasuredValue,
-        maxMeasuredValue,
-        tolerance: 0,
-    });
-}
-export function getDefaultFlowMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
-    return optionsFor(FlowMeasurementServer, {
-        measuredValue,
-        minMeasuredValue,
-        maxMeasuredValue,
-        tolerance: 0,
-    });
-}
-export function getDefaultOccupancySensingClusterServer(occupied = false, holdTime = 30, holdTimeMin = 1, holdTimeMax = 300) {
-    return optionsFor(OccupancySensingServer.with(OccupancySensing.Feature.PassiveInfrared), {
-        occupancy: { occupied },
-        occupancySensorType: OccupancySensing.OccupancySensorType.Pir,
-        occupancySensorTypeBitmap: { pir: true, ultrasonic: false, physicalContact: false },
-        pirOccupiedToUnoccupiedDelay: holdTime,
-        pirUnoccupiedToOccupiedDelay: holdTime,
-        holdTime,
-        holdTimeLimits: { holdTimeMin, holdTimeMax, holdTimeDefault: holdTime },
+export function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
+    return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), {
+        status: PowerSource.PowerSourceStatus.Active,
+        order: 0,
+        description: 'Primary battery',
+        endpointList: [],
+        batVoltage,
+        batPercentRemaining: Math.min(Math.max(batPercentRemaining * 2, 0), 200),
+        batTimeRemaining: null,
+        batChargeLevel,
+        batReplacementNeeded: false,
+        batReplaceability,
+        batPresent: true,
+        activeBatFaults: [],
+        batChargeState: PowerSource.BatChargeState.IsNotCharging,
+        batFunctionalWhileCharging: true,
     });
 }
 export function getDefaultElectricalEnergyMeasurementClusterServer(energyImported = null, energyExported = null) {
@@ -698,3 +677,105 @@ export function getApparentElectricalPowerMeasurementClusterServer(voltage = nul
         frequency: frequency,
     });
 }
+export function getDefaultDeviceEnergyManagementClusterServer(esaType = DeviceEnergyManagement.EsaType.Other, esaCanGenerate = false, esaState = DeviceEnergyManagement.EsaState.Online, absMinPower = 0, absMaxPower = 0) {
+    return optionsFor(MatterbridgeDeviceEnergyManagementServer.with(DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment), {
+        esaType,
+        esaCanGenerate,
+        esaState,
+        absMinPower,
+        absMaxPower,
+        powerAdjustmentCapability: null,
+        optOutState: DeviceEnergyManagement.OptOutState.NoOptOut,
+        forecast: null,
+    });
+}
+export function getDefaultDeviceEnergyManagementModeClusterServer(currentMode, supportedModes) {
+    return optionsFor(MatterbridgeDeviceEnergyManagementModeServer, {
+        supportedModes: supportedModes ?? [
+            { label: 'No Energy Management (Forecast reporting only)', mode: 1, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.NoOptimization }] },
+            {
+                label: 'Device Energy Management',
+                mode: 2,
+                modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.DeviceOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }],
+            },
+            {
+                label: 'Home Energy Management',
+                mode: 3,
+                modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.GridOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }],
+            },
+            { label: 'Grid Energy Managemen', mode: 4, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.GridOptimization }] },
+            {
+                label: 'Full Energy Management',
+                mode: 5,
+                modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.DeviceOptimization }, { value: DeviceEnergyManagementMode.ModeTag.LocalOptimization }, { value: DeviceEnergyManagementMode.ModeTag.GridOptimization }],
+            },
+        ],
+        currentMode: currentMode ?? 1,
+    });
+}
+export function getDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+    return optionsFor(MatterbridgeOperationalStateServer, {
+        phaseList: [],
+        currentPhase: null,
+        countdownTime: null,
+        operationalStateList: [
+            { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+            { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+            { operationalStateId: OperationalState.OperationalStateEnum.Paused, operationalStateLabel: 'Paused' },
+            { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+        ],
+        operationalState,
+        operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+    });
+}
+export function getDefaultTemperatureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+    return optionsFor(TemperatureMeasurementServer, {
+        measuredValue,
+        minMeasuredValue,
+        maxMeasuredValue,
+        tolerance: 0,
+    });
+}
+export function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+    return optionsFor(RelativeHumidityMeasurementServer, {
+        measuredValue,
+        minMeasuredValue,
+        maxMeasuredValue,
+        tolerance: 0,
+    });
+}
+export function getDefaultPressureMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+    return optionsFor(PressureMeasurementServer, {
+        measuredValue,
+        minMeasuredValue,
+        maxMeasuredValue,
+        tolerance: 0,
+    });
+}
+export function getDefaultIlluminanceMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+    return optionsFor(IlluminanceMeasurementServer, {
+        measuredValue,
+        minMeasuredValue,
+        maxMeasuredValue,
+        tolerance: 0,
+    });
+}
+export function getDefaultFlowMeasurementClusterServer(measuredValue = null, minMeasuredValue = null, maxMeasuredValue = null) {
+    return optionsFor(FlowMeasurementServer, {
+        measuredValue,
+        minMeasuredValue,
+        maxMeasuredValue,
+        tolerance: 0,
+    });
+}
+export function getDefaultOccupancySensingClusterServer(occupied = false, holdTime = 30, holdTimeMin = 1, holdTimeMax = 300) {
+    return optionsFor(OccupancySensingServer.with(OccupancySensing.Feature.PassiveInfrared), {
+        occupancy: { occupied },
+        occupancySensorType: OccupancySensing.OccupancySensorType.Pir,
+        occupancySensorTypeBitmap: { pir: true, ultrasonic: false, physicalContact: false },
+        pirOccupiedToUnoccupiedDelay: holdTime,
+        pirUnoccupiedToOccupiedDelay: holdTime,
+        holdTime,
+        holdTimeLimits: { holdTimeMin, holdTimeMax, holdTimeDefault: holdTime },
+    });
+}

package/dist/matterbridgePlatform.js

@@ -1,10 +1,10 @@
 if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mMatterbridgePlatform loaded.\u001B[40;0m');
 import path from 'node:path';
-import { Descriptor } from '@matter/types/clusters/descriptor';
-import { BridgedDeviceBasicInformation } from '@matter/types/clusters/bridged-device-basic-information';
 import { CYAN, db, er, nf, wr } from 'node-ansi-logger';
 import { NodeStorageManager } from 'node-persist-manager';
+import { Descriptor } from '@matter/types/clusters/descriptor';
+import { BridgedDeviceBasicInformation } from '@matter/types/clusters/bridged-device-basic-information';
 import { checkNotLatinCharacters } from './matterbridgeEndpointHelpers.js';
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidArray, isValidObject, isValidString } from './utils/isvalid.js';

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.3.4-dev-20251020-df40d12",
+  "version": "3.3.4-dev-20251022-681420c",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.3.4-dev-20251020-df40d12",
+      "version": "3.3.4-dev-20251022-681420c",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.6",
@@ -367,9 +367,9 @@
       "license": "MIT"
     },
     "node_modules/bare-events": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.0.tgz",
-      "integrity": "sha512-AOhh6Bg5QmFIXdViHbMc2tLDsBIRxdkIaIddPslJF9Z5De3APBScuqGP2uThXnIpqFrgoxMNC6km7uXNIMLHXA==",
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.1.tgz",
+      "integrity": "sha512-oxSAxTS1hRfnyit2CL5QpAOS5ixfBjj6ex3yTNvXyY/kE719jQ/IjuESJBK2w5v4wwQRAHGseVJXx9QBYOtFGQ==",
       "license": "Apache-2.0",
       "peerDependencies": {
         "bare-abort-controller": "*"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.3.4-dev-20251020-df40d12",
+  "version": "3.3.4-dev-20251022-681420c",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",