matterbridge 3.0.0-edge.1 → 3.0.0-edge.11

package/CHANGELOG.md

@@ -47,26 +47,77 @@ Modified clusters:
 ### Added
 
 - [addEndpoint]: Added an error handler with deep stack on aggregatorNode.add() and serverNode.add() calls.
+- [endpoint]: Added createOffOnlyOnOffClusterServer().
+- [endpoint]: Added createBaseFanControlClusterServer().
+- [endpoint]: Added createDefaultHepaFilterMonitoringClusterServer().
+- [endpoint]: Added createDefaultActivatedCarbonFilterMonitoringClusterServer().
+- [deviceTypes]: Added Robotic device type.
+- [deviceTypes]: Added Appliances device types.
+- [frontend]: Added the matterbridge aggregator serialNumber in the QRDiv.
 
 ### Changed
 
-- [deviceTypes]: Updated device types to Matter 1.4
+- [package]: Updated package.
+- [package]: Updated express to v5.1.0.
+- [package]: Updated dependencies.
+- [package]: Added tsconfig.jest.json with "isolatedModules": true for ts-jest.
+- [deviceTypes]: Updated device types to Matter 1.4.
+- [clusters]: Updated cluster helpers to Matter 1.4.
 - [matter.js]: Update to 0.13.0-alpha.0-20250405-7fc7db48.
+- [matter.js]: Update to 0.13.0-alpha.0-20250408-c916c7e8.
+- [matter.js]: Update to 0.13.0-alpha.0-20250412-5fad64e7b.
+- [matter.js]: Update to 0.13.0-alpha.0-20250413-d5a27700d.
+- [matter.js]: Update to 0.13.0-alpha.0-20250415-475996bb5.
+- [matter.js]: Update to 0.13.0-alpha.0-20250418-8cfc0b832.
+- [matter.js]: Update to 0.13.0-alpha.0-20250420-9f45e4f77.
+- [help]: Updated cli help screen.
+- [logger]: Improved frontend logger cleaning.
 
 ### Fixed
 
 - [doorLock]: Fixed supportedOperatingModes inverted bitmap (Thanks Apollon).
+- [DevicesIcon]: Fixed rendering of leak freeze and rain sensors.
+- [QRCode]: Fixed rendering of QRCode panel when advertising stops.
+- [matterbridge]: Fixed wrong message when advertising stops and the node has been paired.
 
-## [2.2.8] - 2025-04-08
+## [2.2.9] - 2025-04-18
 
 ### Added
 
-- [platform]: Added stack to errors messages.
+- [deviceTypes]: Added extendedColorLight device type.
+
+### Changed
+
+- [package]: Update dependencies.
+
+### Fixed
+
+- [QRCode]: Fixed update when the server node is no more advertising.
+- [frontend]: Fixed wrong notification when the server node has been paired.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
+## [2.2.8] - 2025-04-10
+
+### Added
+
+- [platform]: Added stack to error messages.
+- [endpoint]: Added createLevelControlClusterServer()
 - [endpoint]: Added createLevelTvocMeasurementClusterServer()
+- [frontend]: Added a restart button on the QRCode panel when the advertising for a not paired node is expired.
 
 ### Changed
 
 - [package]: Update dependencies.
+- [package]: Use node:https.
+- [endpoint]: Modified createOnOffClusterServer().
+
+### Fixed
+
+- [homepage]: Fixed warning log for homepage property in package.json.
+- [DevicesIcon]: Fixed rendering of rain, freeze and leak sensors.
 
 <a href="https://www.buymeacoffee.com/luligugithub">
   <img src="bmc-button.svg" alt="Buy me a coffee" width="80">

package/README-DEV.md

@@ -80,6 +80,10 @@ Matterbridge must be linked to the plugin in development only.
     "dev:link": "npm link matterbridge",
     '''
 }
+
+On the machine you use for development you should also have matterbridge installed globally or built locally and linked (npm link from the package root).
+
+ Dev and edge branches of matterbridge are not suitable for developemnt cause they are published for production without types. If you want to develop a plugin using the dev or edge branch of matterbridge, you have to clone the dev or edge branch, build locally and link (npm run deepCleanBuild).
 ```
 
 # \***\*\*\*\*\***

package/README-DOCKER.md

@@ -141,6 +141,15 @@ docker restart matterbridge
 docker logs matterbridge
 ```
 
+### Shows the logs for a time interval
+
+```
+docker logs \
+  --since "2025-04-19T00:00:00" \
+  --until "2025-04-19T00:02:00" \
+  matterbridge
+```
+
 ### Shows the logs real time (tail)
 
 ```

package/dist/cli.js

@@ -3,6 +3,7 @@ import { Matterbridge } from './matterbridge.js';
 import { getIntParameter, hasParameter } from './utils/export.js';
 import { AnsiLogger, BRIGHT, CYAN, db, YELLOW } from './logger/export.js';
 import { EventEmitter } from 'node:events';
+import { inspect } from 'node:util';
 export const cliEmitter = new EventEmitter();
 export let instance;
 let session;
@@ -186,5 +187,7 @@ async function main() {
 }
 process.title = 'matterbridge';
 main().catch((error) => {
-    log.error(`Matterbridge.loadInstance() failed with error: ${error instanceof Error ? error.message : error}`);
+    const errorMessage = error instanceof Error ? error.message : error;
+    const errorInspect = inspect(error, { depth: 10 });
+    log.error(`Matterbridge.loadInstance() failed with error: ${errorMessage}\nstack: ${errorInspect}`);
 });

package/dist/frontend.js

@@ -1,9 +1,9 @@
 import { EndpointServer, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, Lifecycle } from '@matter/main';
 import { createServer } from 'node:http';
+import https from 'node:https';
 import os from 'node:os';
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
-import https from 'https';
 import express from 'express';
 import WebSocket, { WebSocketServer } from 'ws';
 import multer from 'multer';
@@ -814,9 +814,8 @@ export class Frontend {
                 res.status(500).send(`Error uploading or installing plugin package ${filename}`);
             }
         });
-        this.expressApp.get('*', (req, res) => {
+        this.expressApp.use((req, res) => {
             this.log.debug('The frontend sent:', req.url);
-            this.log.debug('Response send file:', path.join(this.matterbridge.rootDirectory, 'frontend/build/index.html'));
             res.sendFile(path.join(this.matterbridge.rootDirectory, 'frontend/build/index.html'));
         });
         this.log.debug(`Frontend initialized on port ${YELLOW}${this.port}${db} static ${UNDERLINE}${path.join(this.matterbridge.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
@@ -1503,6 +1502,7 @@ export class Frontend {
         message = message.replace(/[\t\n]/g, '');
         message = message.replace(/[\x00-\x1F\x7F]/g, '');
         message = message.replace(/\\"/g, '"');
+        message = message.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
         const maxContinuousLength = 100;
         const keepStartLength = 20;
         const keepEndLength = 20;

package/dist/matterbridge.js

@@ -15,8 +15,8 @@ import { Frontend } from './frontend.js';
 import { DeviceTypeId, Endpoint as EndpointNode, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, VendorId, StorageService, Environment, ServerNode } from '@matter/main';
 import { DeviceCommissioner, FabricAction, MdnsService, PaseClient } from '@matter/main/protocol';
 import { AggregatorEndpoint } from '@matter/main/endpoints';
-import { BridgedDeviceBasicInformationServer } from '@matter/main/behaviors/bridged-device-basic-information';
 import { BasicInformationServer } from '@matter/main/behaviors/basic-information';
+import { BridgedDeviceBasicInformationServer } from '@matter/main/behaviors/bridged-device-basic-information';
 const plg = '\u001B[38;5;33m';
 const dev = '\u001B[38;5;79m';
 const typ = '\u001B[38;5;207m';
@@ -51,6 +51,7 @@ export class Matterbridge extends EventEmitter {
         globalModulesDirectory: '',
         matterbridgeVersion: '',
         matterbridgeLatestVersion: '',
+        matterbridgeSerialNumber: '',
         matterbridgeQrPairingCode: undefined,
         matterbridgeManualPairingCode: undefined,
         matterbridgeFabricInformations: [],
@@ -122,7 +123,7 @@ export class Matterbridge extends EventEmitter {
     matterStorageService;
     matterStorageManager;
     matterbridgeContext;
-    mattercontrollerContext;
+    controllerContext;
     mdnsInterface;
     ipv4address;
     ipv6address;
@@ -491,6 +492,13 @@ export class Matterbridge extends EventEmitter {
       - nosudo:                force not to use sudo to install or update packages if the internal logic fails
       - norestore:             force not to automatically restore the matterbridge node storage and the matter storage from backup if it is corrupted
       - ssl:                   enable SSL for the frontend and WebSockerServer (certificates in .matterbridge/certs directory cert.pem, key.pem and ca.pem (optional))
+      - vendorId:              override the default vendorId 0xfff1
+      - vendorName:            override the default vendorName "Matterbridge"
+      - productId:             override the default productId 0x8000
+      - productName:           override the default productName "Matterbridge aggregator"
+      - service:               enable the service mode (used in the systemctl configuration file)
+      - docker:                enable the docker mode (used in the Dockerfile to build the docker image)
+      - homedir:               override the home directory (default: os.homedir())
       - add [plugin path]:     register the plugin from the given absolute or relative path
       - add [plugin name]:     register the globally installed plugin with the given name
       - remove [plugin path]:  remove the plugin from the given absolute or relative path
@@ -687,11 +695,15 @@ export class Matterbridge extends EventEmitter {
         process.removeAllListeners('uncaughtException');
         process.removeAllListeners('unhandledRejection');
         this.exceptionHandler = async (error) => {
-            this.log.error('Unhandled Exception detected at:', error.stack || error, rs);
+            const errorMessage = error instanceof Error ? error.message : error;
+            const errorInspect = inspect(error, { depth: 10 });
+            this.log.error(`Unhandled Exception detected: ${errorMessage}\nstack: ${errorInspect}}`);
         };
         process.on('uncaughtException', this.exceptionHandler);
         this.rejectionHandler = async (reason, promise) => {
-            this.log.error('Unhandled Rejection detected at:', promise, 'reason:', reason instanceof Error ? reason.stack : reason, rs);
+            const errorMessage = reason instanceof Error ? reason.message : reason;
+            const errorInspect = inspect(reason, { depth: 10 });
+            this.log.error(`Unhandled Rejection detected: ${promise}\nreason: ${errorMessage}\nstack: ${errorInspect}`);
         };
         process.on('unhandledRejection', this.rejectionHandler);
         this.log.debug(`Registering SIGINT and SIGTERM signal handlers...`);
@@ -1165,6 +1177,7 @@ export class Matterbridge extends EventEmitter {
             plugin.device = device;
             plugin.storageContext = await this.createServerNodeContext(plugin.name, device.deviceName, DeviceTypeId(device.deviceType), device.vendorId, device.vendorName, device.productId, device.productName);
             plugin.serverNode = await this.createServerNode(plugin.storageContext, this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
+            plugin.serialNumber = await plugin.storageContext.get('serialNumber', '');
             this.log.debug(`Adding ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db} to ${plg}${plugin.name}${db} server node`);
             await plugin.serverNode.add(device);
             if (start)
@@ -1177,6 +1190,7 @@ export class Matterbridge extends EventEmitter {
             plugin.storageContext = await this.createServerNodeContext(plugin.name, 'Matterbridge', bridge.code, this.aggregatorVendorId, 'Matterbridge', this.aggregatorProductId, plugin.description);
             plugin.serverNode = await this.createServerNode(plugin.storageContext, this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
             plugin.aggregatorNode = await this.createAggregatorNode(plugin.storageContext);
+            plugin.serialNumber = await plugin.storageContext.get('serialNumber', '');
             await plugin.serverNode.add(plugin.aggregatorNode);
             if (start)
                 await this.startServerNode(plugin.serverNode);
@@ -1337,6 +1351,19 @@ export class Matterbridge extends EventEmitter {
         }, 1000);
     }
     async startController() {
+        if (!this.matterStorageManager) {
+            this.log.error('No storage manager initialized');
+            await this.cleanup('No storage manager initialized');
+            return;
+        }
+        this.log.info('Creating context: mattercontrollerContext');
+        this.controllerContext = this.matterStorageManager.createContext('mattercontrollerContext');
+        if (!this.controllerContext) {
+            this.log.error('No storage context mattercontrollerContext initialized');
+            await this.cleanup('No storage context mattercontrollerContext initialized');
+            return;
+        }
+        this.log.debug('Starting matterbridge in mode', this.bridgeMode);
     }
     async startMatterStorage() {
         this.log.info(`Starting matter node storage...`);
@@ -1345,6 +1372,7 @@ export class Matterbridge extends EventEmitter {
         this.matterStorageManager = await this.matterStorageService.open('Matterbridge');
         this.log.info('Matter node storage manager "Matterbridge" created');
         this.matterbridgeContext = await this.createServerNodeContext('Matterbridge', 'Matterbridge', bridge.code, this.aggregatorVendorId, this.aggregatorVendorName, this.aggregatorProductId, this.aggregatorProductName);
+        this.matterbridgeInformation.matterbridgeSerialNumber = await this.matterbridgeContext.get('serialNumber', '');
         this.log.info('Matter node storage started');
         await this.backupMatterStorage(path.join(this.matterbridgeDirectory, this.matterStorageName), path.join(this.matterbridgeDirectory, this.matterStorageName + '.backup'));
     }
@@ -1355,7 +1383,7 @@ export class Matterbridge extends EventEmitter {
     }
     async stopMatterStorage() {
         this.log.info('Closing matter node storage...');
-        this.matterStorageManager?.close();
+        await this.matterStorageManager?.close();
         this.matterStorageService = undefined;
         this.matterStorageManager = undefined;
         this.matterbridgeContext = undefined;
@@ -1494,6 +1522,8 @@ export class Matterbridge extends EventEmitter {
                     }
                 }
                 setTimeout(() => {
+                    if (serverNode.lifecycle.isCommissioned)
+                        return;
                     if (this.bridgeMode === 'bridge') {
                         this.matterbridgeQrPairingCode = undefined;
                         this.matterbridgeManualPairingCode = undefined;
@@ -1503,10 +1533,12 @@ export class Matterbridge extends EventEmitter {
                         if (plugin) {
                             plugin.qrPairingCode = undefined;
                             plugin.manualPairingCode = undefined;
-                            this.frontend.wssSendRefreshRequired('plugins');
                         }
                     }
+                    this.frontend.wssSendRefreshRequired('plugins');
                     this.frontend.wssSendRefreshRequired('settings');
+                    this.frontend.wssSendRefreshRequired('fabrics');
+                    this.frontend.wssSendRefreshRequired('sessions');
                     this.frontend.wssSendSnackbarMessage(`Advertising on server node for ${storeId} stopped. Restart to commission.`, 0);
                     this.log.notice(`Advertising on server node for ${storeId} stopped. Restart to commission.`);
                 }, 15 * 60 * 1000).unref();
@@ -1644,10 +1676,9 @@ export class Matterbridge extends EventEmitter {
                 await this.aggregatorNode?.add(device);
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : '';
-                const errorStack = error instanceof Error ? error.stack : '';
-                const errorDebug = inspect(error, { depth: 10 });
-                this.log.error(`Error adding bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for plugin ${plg}${pluginName}${er}: ${error} ${errorMessage} ${errorStack} ${errorDebug}`);
+                const errorMessage = error instanceof Error ? error.message : error;
+                const errorInspect = inspect(error, { depth: 10 });
+                this.log.error(`Error adding bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for plugin ${plg}${pluginName}${er}: ${errorMessage}\nstack: ${errorInspect}`);
                 return;
             }
         }
@@ -1658,10 +1689,9 @@ export class Matterbridge extends EventEmitter {
                     await this.createAccessoryPlugin(plugin, device);
                 }
                 catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : '';
-                    const errorStack = error instanceof Error ? error.stack : '';
-                    const errorDebug = inspect(error, { depth: 10 });
-                    this.log.error(`Error creating endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for AccessoryPlatform plugin ${plg}${pluginName}${er} server node: ${error} ${errorMessage} ${errorStack} ${errorDebug}`);
+                    const errorMessage = error instanceof Error ? error.message : error;
+                    const errorInspect = inspect(error, { depth: 10 });
+                    this.log.error(`Error creating endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for AccessoryPlatform plugin ${plg}${pluginName}${er} server node: ${errorMessage}\nstack: ${errorInspect}`);
                     return;
                 }
             }
@@ -1674,10 +1704,9 @@ export class Matterbridge extends EventEmitter {
                     await plugin.aggregatorNode?.add(device);
                 }
                 catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : '';
-                    const errorStack = error instanceof Error ? error.stack : '';
-                    const errorDebug = inspect(error, { depth: 10 });
-                    this.log.error(`Error adding bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for DynamicPlatform plugin ${plg}${pluginName}${er} aggregator node: ${error} ${errorMessage} ${errorStack} ${errorDebug}`);
+                    const errorMessage = error instanceof Error ? error.message : error;
+                    const errorInspect = inspect(error, { depth: 10 });
+                    this.log.error(`Error adding bridged endpoint ${dev}${device.deviceName}${er} (${zb}${device.id}${er}) for DynamicPlatform plugin ${plg}${pluginName}${er} aggregator node: ${errorMessage}\nstack: ${errorInspect}`);
                     return;
                 }
             }
@@ -1728,12 +1757,14 @@ export class Matterbridge extends EventEmitter {
         this.devices.remove(device);
     }
     async removeAllBridgedEndpoints(pluginName, delay = 0) {
-        this.log.debug(`Removing all bridged endpoints for plugin ${plg}${pluginName}${db}`);
+        this.log.debug(`Removing all bridged endpoints for plugin ${plg}${pluginName}${db}${delay > 0 ? ` with delay ${delay} ms` : ''}`);
         for (const device of this.devices.array().filter((device) => device.plugin === pluginName)) {
             await this.removeBridgedEndpoint(pluginName, device);
             if (delay > 0)
                 await new Promise((resolve) => setTimeout(resolve, delay));
         }
+        if (delay > 0)
+            await new Promise((resolve) => setTimeout(resolve, 2000));
     }
     async subscribeAttributeChanged(plugin, device) {
         this.log.info(`Subscribing attributes for endpoint ${dev}${device.deviceName}${nf} (${dev}${device.id}${nf}) plugin ${plg}${plugin.name}${nf}`);

package/dist/matterbridgeBehaviors.js

@@ -19,7 +19,7 @@ import { ValveConfigurationAndControlBehavior } from '@matter/main/behaviors/val
 import { ModeSelectServer } from '@matter/main/behaviors/mode-select';
 import { SmokeCoAlarmServer } from '@matter/main/behaviors/smoke-co-alarm';
 import { SwitchServer } from '@matter/main/behaviors/switch';
-export class MatterbridgeBehaviorDevice {
+export class MatterbridgeServerDevice {
     log;
     commandHandler;
     device;
@@ -141,107 +141,107 @@ export class MatterbridgeBehaviorDevice {
         this.commandHandler.executeHandler('enableDisableAlarm', { request: { alarmsToEnableDisable }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
     }
 }
-export class MatterbridgeBehavior extends Behavior {
+export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
 }
-(function (MatterbridgeBehavior) {
+(function (MatterbridgeServer) {
     class State {
         deviceCommand;
     }
-    MatterbridgeBehavior.State = State;
-})(MatterbridgeBehavior || (MatterbridgeBehavior = {}));
+    MatterbridgeServer.State = State;
+})(MatterbridgeServer || (MatterbridgeServer = {}));
 export class MatterbridgeIdentifyServer extends IdentifyServer {
     initialize() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.setEndpointId(this.endpoint.maybeId);
         device.setEndpointNumber(this.endpoint.maybeNumber);
         super.initialize();
     }
     identify({ identifyTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.identify({ identifyTime });
         super.identify({ identifyTime });
     }
     triggerEffect({ effectIdentifier, effectVariant }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.triggerEffect({ effectIdentifier, effectVariant });
         super.triggerEffect({ effectIdentifier, effectVariant });
     }
 }
 export class MatterbridgeOnOffServer extends OnOffServer {
     async on() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.on();
         super.on();
     }
     async off() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.off();
         super.off();
     }
     async toggle() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.toggle();
         super.toggle();
     }
 }
 export class MatterbridgeLevelControlServer extends LevelControlServer {
     async moveToLevel({ level, transitionTime, optionsMask, optionsOverride }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToLevel({ level, transitionTime, optionsMask, optionsOverride });
         super.moveToLevel({ level, transitionTime, optionsMask, optionsOverride });
     }
     async moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride });
         super.moveToLevelWithOnOff({ level, transitionTime, optionsMask, optionsOverride });
     }
 }
 export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
     async moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime });
         super.moveToHue({ optionsMask, optionsOverride, hue, direction, transitionTime });
     }
     async moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime });
         super.moveToSaturation({ optionsMask, optionsOverride, saturation, transitionTime });
     }
     async moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime });
         super.moveToHueAndSaturation({ optionsOverride, optionsMask, saturation, hue, transitionTime });
     }
     async moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime });
         super.moveToColor({ optionsMask, optionsOverride, colorX, colorY, transitionTime });
     }
     async moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime });
         super.moveToColorTemperature({ optionsOverride, optionsMask, colorTemperatureMireds, transitionTime });
     }
 }
 export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift) {
     async upOrOpen() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.upOrOpen();
         super.upOrOpen();
     }
     async downOrClose() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.downOrClose();
         super.downOrClose();
     }
     stopMotion() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.stopMotion();
         super.stopMotion();
     }
     goToLiftPercentage({ liftPercent100thsValue }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.goToLiftPercentage({ liftPercent100thsValue });
         super.goToLiftPercentage({ liftPercent100thsValue });
     }
@@ -250,26 +250,26 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
 }
 export class MatterbridgeDoorLockServer extends DoorLockServer {
     async lockDoor() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.lockDoor();
         super.lockDoor();
     }
     async unlockDoor() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.unlockDoor();
         super.unlockDoor();
     }
 }
 export class MatterbridgeModeSelectServer extends ModeSelectServer {
     async changeToMode({ newMode }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.changeToMode({ newMode });
         super.changeToMode({ newMode });
     }
 }
 export class MatterbridgeFanControlServer extends FanControlServer.with(FanControl.Feature.MultiSpeed, FanControl.Feature.Auto, FanControl.Feature.Step) {
     async step({ direction, wrap, lowestOff }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.step({ direction, wrap, lowestOff });
         const lookupStepDirection = ['Increase', 'Decrease'];
         device.log.debug(`Command step called with direction: ${lookupStepDirection[direction]} wrap: ${wrap} lowestOff: ${lowestOff}`);
@@ -294,7 +294,7 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
 }
 export class MatterbridgeThermostatServer extends ThermostatBehavior.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
     async setpointRaiseLower({ mode, amount }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.setpointRaiseLower({ mode, amount });
         const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
         device.log.debug(`Command setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[mode]} amount: ${amount / 10}`);
@@ -316,14 +316,14 @@ export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigu
     initialize() {
     }
     open({ openDuration, targetLevel }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.log.debug(`Command open called with openDuration: ${openDuration} targetLevel: ${targetLevel}`);
         device.open({ openDuration, targetLevel });
         this.state.targetLevel = targetLevel ?? 100;
         this.state.currentLevel = targetLevel ?? 100;
     }
     close() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.log.debug(`Command close called`);
         device.close();
         this.state.targetLevel = 0;
@@ -332,14 +332,14 @@ export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigu
 }
 export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm) {
     async selfTestRequest() {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.selfTestRequest();
         super.selfTestRequest();
     }
 }
 export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
     async enableDisableAlarm({ alarmsToEnableDisable }) {
-        const device = this.agent.get(MatterbridgeBehavior).state.deviceCommand;
+        const device = this.agent.get(MatterbridgeServer).state.deviceCommand;
         device.enableDisableAlarm({ alarmsToEnableDisable });
         super.enableDisableAlarm({ alarmsToEnableDisable });
     }