matterbridge 3.0.3-dev-20250518-e0f532c → 3.0.3-dev-20250519-6aad062

package/CHANGELOG.md

@@ -10,10 +10,22 @@ If you like this project and find it useful, please consider giving it a star on
 
 ## [3.0.3] - 2025-05-18
 
+### New plugins
+
+[Dyson robot](https://github.com/thoukydides/matterbridge-dyson-robot)
+
+A Matterbridge plugin that connects Dyson robot vacuums and air treatment devices.
+to the Matter smart home ecosystem via their local MQTT APIs.
+
+[Aeg robot](https://github.com/thoukydides/matterbridge-aeg-robot)
+
+AEG RX 9 / Electrolux Pure i9 robot vacuum plugin for Matterbridge.
+
 ### Added
 
 - [virtual] Added virtual devices configuration mode in the Matterbridge Settings: 'Disabled', 'Light', 'Outlet', 'Switch', 'Mounted_switch'. Switch is not supported by Alexa. Mounted Switch is not supported by Apple.
 - [deviceTypes] Added evse, waterHeater, solarPower, batteryStorage and heatPump device type.
+- [waterHeater] Added WaterHeater class to create a Water Heater Device Type in one line of code (thanks https://github.com/lboue).
 
 ### Changed
 
@@ -21,6 +33,7 @@ If you like this project and find it useful, please consider giving it a star on
 - [export]: Removed long deprecated Matter exports from matterbridge. Use matterbridge/matter.
 - [matterbridge]: Refactored initialize() and cleanup() methods.
 - [matterbridge]: Updated -help informations.
+- [rvc]: Added the parameters in the RoboticVacuumCleaner class constructor.
 
 ### Fixed
 

package/README.md

@@ -353,6 +353,15 @@ The Eve app only shows the history when the plugins run like an AccessoryPlatfor
 
 A matterbridge plugin that allows connecting Loxone devices to Matter.
 
+### [Dyson robot](https://github.com/thoukydides/matterbridge-dyson-robot)
+
+A Matterbridge plugin that connects Dyson robot vacuums and air treatment devices.
+to the Matter smart home ecosystem via their local MQTT APIs.
+
+### [Aeg robot](https://github.com/thoukydides/matterbridge-aeg-robot)
+
+AEG RX 9 / Electrolux Pure i9 robot vacuum plugin for Matterbridge.
+
 ## How to install and add a plugin with the frontend (best option)
 
 Just open the frontend on the link provided in the log, select a plugin and click install.

package/dist/index.js

@@ -11,6 +11,7 @@ export * from './matterbridgePlatform.js';
 export * from './matterbridgeAccessoryPlatform.js';
 export * from './matterbridgeDynamicPlatform.js';
 export * from './roboticVacuumCleaner.js';
+export * from './waterHeater.js';
 export { addVirtualDevice } from './helpers.js';
 const log = new AnsiLogger({ logName: 'Main', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
 async function main() {

package/dist/matterbridge.js

@@ -289,7 +289,15 @@ export class Matterbridge extends EventEmitter {
             await fs.access(pairingFilePath, fs.constants.R_OK);
             const pairingFileContent = await fs.readFile(pairingFilePath, 'utf8');
             const pairingFileJson = JSON.parse(pairingFileContent);
-            if (pairingFileJson.passcode && pairingFileJson.discriminator) {
+            if (isValidNumber(pairingFileJson.vendorId))
+                this.aggregatorVendorId = VendorId(pairingFileJson.vendorId);
+            if (isValidString(pairingFileJson.vendorName, 3))
+                this.aggregatorVendorName = pairingFileJson.vendorName;
+            if (isValidNumber(pairingFileJson.productId))
+                this.aggregatorProductId = VendorId(pairingFileJson.productId);
+            if (isValidString(pairingFileJson.productName, 3))
+                this.aggregatorProductName = pairingFileJson.productName;
+            if (isValidNumber(pairingFileJson.passcode) && isValidNumber(pairingFileJson.discriminator)) {
                 this.passcode = pairingFileJson.passcode;
                 this.discriminator = pairingFileJson.discriminator;
                 this.log.info(`Pairing file ${CYAN}${pairingFilePath}${nf} found. Using passcode ${CYAN}${this.passcode}${nf} and discriminator ${CYAN}${this.discriminator}${nf} from pairing file.`);
@@ -1072,8 +1080,8 @@ export class Matterbridge extends EventEmitter {
                 await this.matterbridgeContext?.clearAll();
                 this.log.info('Matter storage reset done! Remove the bridge from the controller.');
             }
-            await withTimeout(this.stopMatterStorage(), 10000, false);
-            await withTimeout(this.frontend.stop(), 10000, false);
+            await this.stopMatterStorage();
+            await this.frontend.stop();
             try {
                 Logger.removeLogger('matterfilelogger');
             }
@@ -1923,23 +1931,21 @@ export class Matterbridge extends EventEmitter {
     async createDirectory(path, name) {
         try {
             await fs.access(path);
+            this.log.debug(`Directory ${name} already exists at path: ${path}`);
         }
         catch (err) {
-            if (err instanceof Error) {
-                const nodeErr = err;
-                if (nodeErr.code === 'ENOENT') {
-                    try {
-                        await fs.mkdir(path, { recursive: true });
-                        this.log.info(`Created ${name}: ${path}`);
-                    }
-                    catch (err) {
-                        this.log.error(`Error creating dir ${name} path ${path}: ${err}`);
-                    }
+            if (err.code === 'ENOENT') {
+                try {
+                    await fs.mkdir(path, { recursive: true });
+                    this.log.info(`Created ${name}: ${path}`);
                 }
-                else {
-                    this.log.error(`Error accessing dir ${name} path ${path}: ${err}`);
+                catch (err) {
+                    this.log.error(`Error creating dir ${name} path ${path}: ${err}`);
                 }
             }
+            else {
+                this.log.error(`Error accessing dir ${name} path ${path}: ${err}`);
+            }
         }
     }
 }

package/dist/matterbridgeBehaviors.js

@@ -12,6 +12,7 @@ import { ModeBase } from '@matter/main/clusters/mode-base';
 import { RvcRunMode } from '@matter/main/clusters/rvc-run-mode';
 import { RvcOperationalState } from '@matter/main/clusters/rvc-operational-state';
 import { ServiceArea } from '@matter/main/clusters/service-area';
+import { WaterHeaterManagement } from '@matter/main/clusters/water-heater-management';
 import { IdentifyServer } from '@matter/main/behaviors/identify';
 import { OnOffServer } from '@matter/main/behaviors/on-off';
 import { LevelControlServer } from '@matter/main/behaviors/level-control';
@@ -29,6 +30,8 @@ import { RvcRunModeServer } from '@matter/main/behaviors/rvc-run-mode';
 import { RvcCleanModeServer } from '@matter/main/behaviors/rvc-clean-mode';
 import { RvcOperationalStateServer } from '@matter/main/behaviors/rvc-operational-state';
 import { ServiceAreaServer } from '@matter/main/behaviors/service-area';
+import { WaterHeaterModeServer } from '@matter/main/behaviors/water-heater-mode';
+import { WaterHeaterManagementServer } from '@matter/main/behaviors/water-heater-management';
 export class MatterbridgeServerDevice {
     log;
     commandHandler;
@@ -174,6 +177,14 @@ export class MatterbridgeServerDevice {
         this.log.info(`Selecting areas ${newAreas} (endpoint ${this.endpointId}.${this.endpointNumber})`);
         this.commandHandler.executeHandler('selectAreas', { request: { newAreas }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
     }
+    boost({ boostInfo }) {
+        this.log.info(`Boost (endpoint ${this.endpointId}.${this.endpointNumber})`);
+        this.commandHandler.executeHandler('boost', { request: { boostInfo }, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
+    }
+    cancelBoost() {
+        this.log.info(`Cancel boost (endpoint ${this.endpointId}.${this.endpointNumber})`);
+        this.commandHandler.executeHandler('cancelBoost', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
+    }
 }
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
@@ -538,3 +549,31 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
         return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
     }
 }
+export class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
+    boost({ boostInfo }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.boost({ boostInfo });
+        device.log.info(`MatterbridgeWaterHeaterManagementServer boost called with: ${JSON.stringify(boostInfo)}`);
+        this.state.boostState = WaterHeaterManagement.BoostState.Active;
+    }
+    cancelBoost() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.cancelBoost();
+        device.log.info(`MatterbridgeWaterHeaterManagementServer cancelBoost called`);
+        this.state.boostState = WaterHeaterManagement.BoostState.Inactive;
+    }
+}
+export class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!supported) {
+            device.log.error(`MatterbridgeWaterHeaterModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        device.log.info(`MatterbridgeWaterHeaterModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}

package/dist/roboticVacuumCleaner.js

@@ -3,15 +3,15 @@ import { roboticVacuumCleaner } from './matterbridgeDeviceTypes.js';
 import { MatterbridgeRvcCleanModeServer, MatterbridgeRvcOperationalStateServer, MatterbridgeRvcRunModeServer, MatterbridgeServiceAreaServer } from './matterbridgeBehaviors.js';
 import { PowerSource, RvcRunMode, RvcCleanMode, RvcOperationalState } from '@matter/main/clusters';
 export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
-    constructor(name, serial) {
+    constructor(name, serial, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea) {
         super(roboticVacuumCleaner, { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Robot Vacuum Cleaner')
             .createDefaultPowerSourceRechargeableBatteryClusterServer(80, PowerSource.BatChargeLevel.Ok, 5900)
-            .createDefaultRvcRunModeClusterServer()
-            .createDefaultRvcCleanModeClusterServer()
-            .createDefaultRvcOperationalStateClusterServer()
-            .createDefaultServiceAreaClusterServer();
+            .createDefaultRvcRunModeClusterServer(currentRunMode, supportedRunModes)
+            .createDefaultRvcCleanModeClusterServer(currentCleanMode, supportedCleanModes)
+            .createDefaultRvcOperationalStateClusterServer(phaseList, currentPhase, operationalStateList, operationalState)
+            .createDefaultServiceAreaClusterServer(supportedAreas, selectedAreas, currentArea);
     }
     createDefaultRvcRunModeClusterServer(currentMode, supportedModes) {
         this.behaviors.require(MatterbridgeRvcRunModeServer, {

package/dist/waterHeater.js

@@ -0,0 +1,45 @@
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { waterHeater } from './matterbridgeDeviceTypes.js';
+import { MatterbridgeWaterHeaterManagementServer, MatterbridgeWaterHeaterModeServer } from './matterbridgeBehaviors.js';
+import { WaterHeaterManagement, WaterHeaterMode } from '@matter/main/clusters';
+export class WaterHeater extends MatterbridgeEndpoint {
+    constructor(name, serial, waterTemperature = 50, minHeatSetpointLimit = 20, maxHeatSetpointLimit = 80, heaterTypes = { immersionElement1: true }) {
+        super(waterHeater, { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        this.createDefaultIdentifyClusterServer()
+            .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Water Heater')
+            .createDefaultPowerSourceWiredClusterServer()
+            .createDefaultHeatingThermostatClusterServer(waterTemperature, waterTemperature, minHeatSetpointLimit, maxHeatSetpointLimit)
+            .createDefaultWaterHeaterManagementClusterServer(heaterTypes)
+            .createDefaultWaterHeaterModeClusterServer();
+    }
+    createDefaultWaterHeaterManagementClusterServer(heaterTypes, heatDemand, tankPercentage, boostState) {
+        this.behaviors.require(MatterbridgeWaterHeaterManagementServer.with(WaterHeaterManagement.Feature.TankPercent), {
+            heaterTypes: heaterTypes ?? { immersionElement1: true },
+            heatDemand: heatDemand ?? {},
+            tankPercentage: tankPercentage ?? 100,
+            boostState: boostState ?? WaterHeaterManagement.BoostState.Inactive,
+        });
+        return this;
+    }
+    createDefaultWaterHeaterModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MatterbridgeWaterHeaterModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'Auto', mode: 1, modeTags: [{ value: WaterHeaterMode.ModeTag.Auto }] },
+                { label: 'Quick', mode: 2, modeTags: [{ value: WaterHeaterMode.ModeTag.Quick }] },
+                { label: 'Quiet', mode: 3, modeTags: [{ value: WaterHeaterMode.ModeTag.Quiet }] },
+                { label: 'LowNoise', mode: 4, modeTags: [{ value: WaterHeaterMode.ModeTag.LowNoise }] },
+                { label: 'LowEnergy', mode: 5, modeTags: [{ value: WaterHeaterMode.ModeTag.LowEnergy }] },
+                { label: 'Vacation', mode: 6, modeTags: [{ value: WaterHeaterMode.ModeTag.Vacation }] },
+                { label: 'Min', mode: 7, modeTags: [{ value: WaterHeaterMode.ModeTag.Min }] },
+                { label: 'Max', mode: 8, modeTags: [{ value: WaterHeaterMode.ModeTag.Max }] },
+                { label: 'Night', mode: 9, modeTags: [{ value: WaterHeaterMode.ModeTag.Night }] },
+                { label: 'Day', mode: 10, modeTags: [{ value: WaterHeaterMode.ModeTag.Day }] },
+                { label: 'Off', mode: 11, modeTags: [{ value: WaterHeaterMode.ModeTag.Off }] },
+                { label: 'Manual', mode: 12, modeTags: [{ value: WaterHeaterMode.ModeTag.Manual }] },
+                { label: 'Timed', mode: 13, modeTags: [{ value: WaterHeaterMode.ModeTag.Timed }] },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.3-dev-20250518-e0f532c",
+  "version": "3.0.3-dev-20250519-6aad062",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.3-dev-20250518-e0f532c",
+      "version": "3.0.3-dev-20250519-6aad062",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.3-dev-20250518-e0f532c",
+  "version": "3.0.3-dev-20250519-6aad062",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",