matterbridge 3.0.1-dev-20250507-a182295 → 3.0.2-dev-20250508-7214e17

package/CHANGELOG.md

@@ -13,6 +13,23 @@ If you like this project and find it useful, please consider giving it a star on
 If you want to run Matterbridge in Home Assistant please use the official add-on https://github.com/Luligu/matterbridge-home-assistant-addon that also has Ingress and side panel.
 It is also available the official Matterbridge Home Assistant plugin https://github.com/Luligu/matterbridge-hass.
 
+## [3.0.2] - 2025-05-??
+
+### Added
+
+### Changed
+
+- [package]: Updated dependencies.
+- [utils]: Refactor utils functions.
+- [utils]: Updated Jest tests on utils functions.
+- [devices]: Added RoboticVacuumCleaner class to create the Robotic Vacuum Cleaner device type.
+
+### Fixed
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [3.0.1] - 2025-05-06
 
 ### Added
@@ -39,6 +56,10 @@ It is also available the official Matterbridge Home Assistant plugin https://git
 - [BasicInformation]: Fixed vulnerability in BasicInformation and BridgedDeviceBasicInformation cluster initialization attributes.
 - [frontend]: Fixed refresh and postfix for select in HomeDevices.
 
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [3.0.0] - 2025-04-29
 
 ## Breaking changes
@@ -105,6 +126,10 @@ Modified clusters:
 - [matterbridge]: Fixed wrong message when advertising stops and the node has been paired.
 - [frontend]: Fixed download logs that broke with express v5.1.0.
 
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [2.2.9] - 2025-04-18
 
 ### Added

package/README.md

@@ -5,7 +5,7 @@
 [![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)
-![Coverage](https://img.shields.io/badge/Jest%20coverage-84%25-brightgreen)
+![Coverage](https://img.shields.io/badge/Jest%20coverage-85%25-brightgreen)
 
 [![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)

package/dist/index.js

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

package/dist/matterbridge.js

@@ -132,6 +132,7 @@ export class Matterbridge extends EventEmitter {
     port;
     passcode;
     discriminator;
+    certification;
     serverNode;
     aggregatorNode;
     aggregatorVendorId = VendorId(getIntParameter('vendorId') ?? 0xfff1);
@@ -267,6 +268,36 @@ export class Matterbridge extends EventEmitter {
         this.port = getIntParameter('port') ?? (await this.nodeContext.get('matterport', 5540)) ?? 5540;
         this.passcode = getIntParameter('passcode') ?? (await this.nodeContext.get('matterpasscode')) ?? PaseClient.generateRandomPasscode();
         this.discriminator = getIntParameter('discriminator') ?? (await this.nodeContext.get('matterdiscriminator')) ?? PaseClient.generateRandomDiscriminator();
+        const pairingFilePath = path.join(this.homeDirectory, '.mattercert', 'pairing.json');
+        try {
+            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) {
+                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}`);
+            }
+            if (pairingFileJson.privateKey && pairingFileJson.certificate && pairingFileJson.intermediateCertificate && pairingFileJson.declaration) {
+                const hexStringToUint8Array = (hexString) => {
+                    const matches = hexString.match(/.{1,2}/g);
+                    return matches ? new Uint8Array(matches.map((byte) => parseInt(byte, 16))) : new Uint8Array();
+                };
+                this.certification = {
+                    privateKey: hexStringToUint8Array(pairingFileJson.privateKey),
+                    certificate: hexStringToUint8Array(pairingFileJson.certificate),
+                    intermediateCertificate: hexStringToUint8Array(pairingFileJson.intermediateCertificate),
+                    declaration: hexStringToUint8Array(pairingFileJson.declaration),
+                };
+                this.log.info(`Pairing file ${CYAN}${pairingFilePath}${nf} found. Using privateKey, certificate, intermediateCertificate and declaration from pairing file.`);
+            }
+        }
+        catch (error) {
+            this.log.debug(`Pairing file ${CYAN}${pairingFilePath}${db} not found: ${error instanceof Error ? error.message : error}`);
+        }
+        await this.nodeContext.set('matterport', this.port);
+        await this.nodeContext.set('matterpasscode', this.passcode);
+        await this.nodeContext.set('matterdiscriminator', this.discriminator);
         this.log.debug(`Initializing server node for Matterbridge... on port ${this.port} with passcode ${this.passcode} and discriminator ${this.discriminator}`);
         if (hasParameter('logger')) {
             const level = getParameter('logger');
@@ -1438,6 +1469,9 @@ export class Matterbridge extends EventEmitter {
                 listeningAddressIpv6: this.ipv6address,
                 port,
             },
+            operationalCredentials: {
+                certification: this.certification,
+            },
             commissioning: {
                 passcode,
                 discriminator,

package/dist/matterbridgeBehaviors.js

@@ -8,6 +8,9 @@ import { ValveConfigurationAndControl } from '@matter/main/clusters/valve-config
 import { SmokeCoAlarm } from '@matter/main/clusters/smoke-co-alarm';
 import { BooleanStateConfigurationServer } from '@matter/main/behaviors/boolean-state-configuration';
 import { OperationalState } from '@matter/main/clusters/operational-state';
+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 { IdentifyServer } from '@matter/main/behaviors/identify';
 import { OnOffServer } from '@matter/main/behaviors/on-off';
 import { LevelControlServer } from '@matter/main/behaviors/level-control';
@@ -21,6 +24,11 @@ import { ModeSelectServer } from '@matter/main/behaviors/mode-select';
 import { SmokeCoAlarmServer } from '@matter/main/behaviors/smoke-co-alarm';
 import { SwitchServer } from '@matter/main/behaviors/switch';
 import { OperationalStateServer } from '@matter/main/behaviors/operational-state';
+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 { ServiceArea } from '@matter/main/clusters/service-area';
 export class MatterbridgeServerDevice {
     log;
     commandHandler;
@@ -158,6 +166,14 @@ export class MatterbridgeServerDevice {
         this.log.info(`Resume (endpoint ${this.endpointId}.${this.endpointNumber})`);
         this.commandHandler.executeHandler('resume', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
     }
+    goHome() {
+        this.log.info(`GoHome (endpoint ${this.endpointId}.${this.endpointNumber})`);
+        this.commandHandler.executeHandler('goHome', { request: {}, attributes: {}, endpoint: { number: this.endpointNumber, uniqueStorageKey: this.endpointId } });
+    }
+    selectAreas({ newAreas }) {
+        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 } });
+    }
 }
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
@@ -430,3 +446,95 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
         };
     }
 }
+export class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!supported) {
+            device.log.error(`MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Cleaning)) {
+            device.log.info('MatterbridgeRvcRunModeServer changeToMode called with newMode Cleaning => Running');
+            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Running' };
+        }
+        else if (supported.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Idle)) {
+            device.log.info('MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => Docked');
+            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Docked;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Docked' };
+        }
+        device.log.info(`MatterbridgeRvcRunModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}
+export class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!supported) {
+            device.log.error(`MatterbridgeRvcCleanModeServer changeToMode called with unsupported newMode: ${newMode}`);
+            return { status: ModeBase.ModeChangeStatus.UnsupportedMode, statusText: 'Unsupported mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        device.log.info(`MatterbridgeRvcCleanModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}
+export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
+    pause() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
+        device.pause();
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
+        this.state.operationalState = RvcOperationalState.OperationalState.Paused;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    resume() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
+        device.resume();
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
+        this.state.operationalState = RvcOperationalState.OperationalState.Running;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    goHome() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
+        device.goHome();
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
+        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}
+export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
+    selectAreas({ newAreas }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        for (const area of newAreas) {
+            const supportedArea = this.state.supportedAreas.find((supportedArea) => supportedArea.areaId === area);
+            if (!supportedArea) {
+                device.log.error(`MatterbridgeServiceAreaServer selectAreas called with unsupported area: ${area}`);
+                return { status: ServiceArea.SelectAreasStatus.UnsupportedArea, statusText: 'Unsupported areas' };
+            }
+        }
+        device.selectAreas({ newAreas });
+        this.state.selectedAreas = newAreas;
+        this.state.currentArea = newAreas[0];
+        device.log.info(`MatterbridgeServiceAreaServer selectAreas called with: ${newAreas.map((area) => area.toString()).join(', ')}`);
+        device.selectAreas({ newAreas });
+        return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
+    }
+}

package/dist/matterbridgeEndpoint.js

@@ -2,7 +2,7 @@ import { AnsiLogger, BLUE, CYAN, YELLOW, db, debugStringify, er, hk, or, zb } fr
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidNumber, isValidObject, isValidString } from './utils/export.js';
 import { MatterbridgeServer, MatterbridgeServerDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, } from './matterbridgeBehaviors.js';
-import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, capitalizeFirstLetter, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, } from './matterbridgeEndpointHelpers.js';
+import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, capitalizeFirstLetter, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultOperationalStateClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, } from './matterbridgeEndpointHelpers.js';
 import { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, UINT16_MAX, UINT32_MAX, VendorId } from '@matter/main';
 import { getClusterNameById, MeasurementType } from '@matter/main/types';
 import { Descriptor } from '@matter/main/clusters/descriptor';
@@ -986,18 +986,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return true;
     }
     createDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
-        this.behaviors.require(MatterbridgeOperationalStateServer, {
-            phaseList: [],
-            currentPhase: 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' },
-        });
+        this.behaviors.require(MatterbridgeOperationalStateServer, getDefaultOperationalStateClusterServer(operationalState));
         return this;
     }
     createDefaultBooleanStateClusterServer(contact) {

package/dist/matterbridgeEndpointHelpers.js

@@ -1,7 +1,3 @@
-import { createHash } from 'node:crypto';
-import { BLUE, CYAN, db, debugStringify, er, hk, or, YELLOW, zb } from './logger/export.js';
-import { deepCopy, deepEqual, isValidArray } from './utils/export.js';
-import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, } from './matterbridgeBehaviors.js';
 import { Lifecycle } from '@matter/main';
 import { getClusterNameById } from '@matter/main/types';
 import { PowerSource } from '@matter/main/clusters/power-source';
@@ -75,6 +71,10 @@ import { Pm25ConcentrationMeasurementServer } from '@matter/main/behaviors/pm25-
 import { Pm10ConcentrationMeasurementServer } from '@matter/main/behaviors/pm10-concentration-measurement';
 import { RadonConcentrationMeasurementServer } from '@matter/main/behaviors/radon-concentration-measurement';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@matter/main/behaviors/total-volatile-organic-compounds-concentration-measurement';
+import { createHash } from 'node:crypto';
+import { BLUE, CYAN, db, debugStringify, er, hk, or, YELLOW, zb } from 'node-ansi-logger';
+import { deepCopy, deepEqual, isValidArray } from './utils/export.js';
+import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, } from './matterbridgeBehaviors.js';
 export function capitalizeFirstLetter(name) {
     if (!name)
         return name;
@@ -115,7 +115,7 @@ export function getBehaviourTypesFromClusterServerIds(clusterServerList) {
 }
 export function getBehaviourTypesFromClusterClientIds(clusterClientList) {
     const behaviorTypes = [];
-    clusterClientList.forEach((clusterId) => {
+    clusterClientList.forEach((_clusterId) => {
     });
     return behaviorTypes;
 }
@@ -206,7 +206,7 @@ export function getBehaviourTypeFromClusterServerId(clusterId) {
         return TotalVolatileOrganicCompoundsConcentrationMeasurementServer.with('NumericMeasurement');
     return MatterbridgeIdentifyServer;
 }
-export function getBehaviourTypeFromClusterClientId(clusterId) {
+export function getBehaviourTypeFromClusterClientId(_clusterId) {
 }
 export function getBehavior(endpoint, cluster) {
     let behavior;
@@ -518,6 +518,20 @@ export async function subscribeAttribute(endpoint, cluster, attribute, listener,
     log?.info(`${db}Subscribed endpoint ${or}${endpoint.id}${db}:${or}${endpoint.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db}`);
     return true;
 }
+export function getDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+    return optionsFor(MatterbridgeOperationalStateServer, {
+        phaseList: [],
+        currentPhase: 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,

package/dist/roboticVacuumCleaner.js

@@ -0,0 +1,87 @@
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+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) {
+        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(currentMode, supportedModes) {
+        this.behaviors.require(MatterbridgeRvcRunModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'Idle', mode: 1, modeTags: [{ value: RvcRunMode.ModeTag.Idle }] },
+                { label: 'Cleaning', mode: 2, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }] },
+                { label: 'Mapping', mode: 3, modeTags: [{ value: RvcRunMode.ModeTag.Mapping }] },
+                { label: 'SpotCleaning', mode: 4, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }, { value: RvcRunMode.ModeTag.Max }] },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
+    createDefaultRvcCleanModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MatterbridgeRvcCleanModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'Vacuum', mode: 1, modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }] },
+                { label: 'Mop', mode: 2, modeTags: [{ value: RvcCleanMode.ModeTag.Mop }] },
+                { label: 'Clean', mode: 3, modeTags: [{ value: RvcCleanMode.ModeTag.DeepClean }] },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
+    createDefaultServiceAreaClusterServer(supportedAreas, selectedAreas, currentArea) {
+        this.behaviors.require(MatterbridgeServiceAreaServer, {
+            supportedAreas: supportedAreas ?? [
+                {
+                    areaId: 1,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Living', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 2,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Kitchen', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 3,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Bedroom', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 4,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Bathroom', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+            ],
+            selectedAreas: selectedAreas ?? [],
+            currentArea: currentArea ?? 1,
+            estimatedEndTime: null,
+        });
+        return this;
+    }
+    createDefaultRvcOperationalStateClusterServer(phaseList = null, currentPhase = null, operationalStateList, operationalState, operationalError) {
+        this.behaviors.require(MatterbridgeRvcOperationalStateServer, {
+            phaseList,
+            currentPhase,
+            operationalStateList: operationalStateList ?? [
+                { operationalStateId: RvcOperationalState.OperationalState.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: RvcOperationalState.OperationalState.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: RvcOperationalState.OperationalState.Paused, operationalStateLabel: 'Paused' },
+                { operationalStateId: RvcOperationalState.OperationalState.Error, operationalStateLabel: 'Error' },
+                { operationalStateId: RvcOperationalState.OperationalState.SeekingCharger, operationalStateLabel: 'SeekingCharger' },
+                { operationalStateId: RvcOperationalState.OperationalState.Charging, operationalStateLabel: 'Charging' },
+                { operationalStateId: RvcOperationalState.OperationalState.Docked, operationalStateLabel: 'Docked' },
+            ],
+            operationalState: operationalState ?? RvcOperationalState.OperationalState.Docked,
+            operationalError: operationalError ?? { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' },
+        });
+        return this;
+    }
+}

package/dist/update.js

@@ -1,7 +1,7 @@
 import { plg } from './matterbridgeTypes.js';
 import { db, nt, wr } from './logger/export.js';
 export async function checkUpdates(matterbridge) {
-    const { hasParameter } = await import('./utils/parameter.js');
+    const { hasParameter } = await import('./utils/commandLine.js');
     getMatterbridgeLatestVersion(matterbridge);
     getMatterbridgeDevVersion(matterbridge);
     for (const plugin of matterbridge.plugins) {

package/dist/utils/deepCopy.js

@@ -8,11 +8,16 @@ export function deepCopy(value) {
     else if (value instanceof Date) {
         return new Date(value.getTime());
     }
+    else if (value instanceof RegExp) {
+        return new RegExp(value.source, value.flags);
+    }
     else if (value instanceof Map) {
         const mapCopy = new Map();
-        value.forEach((val, key) => {
-            mapCopy.set(key, deepCopy(val));
-        });
+        for (const [origKey, origVal] of value.entries()) {
+            const clonedKey = deepCopy(origKey);
+            const clonedVal = deepCopy(origVal);
+            mapCopy.set(clonedKey, clonedVal);
+        }
         return mapCopy;
     }
     else if (value instanceof Set) {

package/dist/utils/deepEqual.js

@@ -1,9 +1,5 @@
 export function deepEqual(a, b, excludeProperties = []) {
-    const debug = false;
     const debugLog = (...messages) => {
-        if (debug) {
-            console.log(...messages);
-        }
     };
     if (a === b) {
         return true;
@@ -16,6 +12,12 @@ export function deepEqual(a, b, excludeProperties = []) {
         debugLog('deepEqual false for == null');
         return false;
     }
+    if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    if (a instanceof RegExp && b instanceof RegExp) {
+        return a.source === b.source && a.flags === b.flags;
+    }
     if (Array.isArray(a) && Array.isArray(b)) {
         if (a.length !== b.length) {
             debugLog(`deepEqual false for array a.length(${a.length}) !== b.length(${b.length})`);

package/dist/utils/export.js

@@ -1,5 +1,5 @@
 export * from './network.js';
-export * from './parameter.js';
+export * from './commandLine.js';
 export * from './isvalid.js';
 export * from './colorUtils.js';
 export * from './deepCopy.js';
@@ -7,3 +7,4 @@ export * from './deepEqual.js';
 export * from './copyDirectory.js';
 export * from './createZip.js';
 export * from './wait.js';
+export * from './hex.js';

package/dist/utils/hex.js

@@ -0,0 +1,27 @@
+export function bufferToHex(buffer) {
+    if (!(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer))) {
+        throw new TypeError('Expected input to be an ArrayBuffer or ArrayBufferView');
+    }
+    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    return Array.from(bytes)
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
+}
+export function hexToBuffer(hex) {
+    if (typeof hex !== 'string') {
+        throw new TypeError('Expected a string for hex input');
+    }
+    const cleaned = hex.trim();
+    if (cleaned.length % 2 !== 0) {
+        throw new Error('Invalid hex string length, must be even');
+    }
+    if (!/^[0-9a-fA-F]*$/.test(cleaned)) {
+        throw new Error('Invalid hex string, contains non-hex characters');
+    }
+    const length = cleaned.length / 2;
+    const result = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = parseInt(cleaned.substr(i * 2, 2), 16);
+    }
+    return result;
+}

package/dist/utils/isvalid.js

@@ -23,6 +23,9 @@ export function isValidString(value, minLength, maxLength) {
         return false;
     return true;
 }
+export function isValidRegExp(value) {
+    return value !== undefined && value !== null && value instanceof RegExp;
+}
 export function isValidObject(value, minLength, maxLength) {
     if (value === undefined || value === null || typeof value !== 'object' || Array.isArray(value))
         return false;

package/dist/utils/network.js

@@ -44,7 +44,7 @@ export function getMacAddress() {
             break;
         }
         for (const detail of interfaceDetails) {
-            if (detail.family === 'IPv6' && !detail.internal && macAddress === undefined) {
+            if (!detail.internal && macAddress === undefined) {
                 macAddress = detail.mac;
             }
         }
@@ -83,7 +83,7 @@ export async function resolveHostname(hostname, family = 4) {
     }
 }
 export async function getNpmPackageVersion(packageName, tag = 'latest', timeout = 10000) {
-    const https = await import('https');
+    const https = await import('node:https');
     return new Promise((resolve, reject) => {
         const url = `https://registry.npmjs.org/${packageName}`;
         const controller = new AbortController();

package/dist/utils/wait.js

@@ -1,5 +1,5 @@
 import { AnsiLogger } from '../logger/export.js';
-const log = new AnsiLogger({ logName: 'MatterbridgeUtils', logTimestampFormat: 4, logLevel: "info" });
+export const log = new AnsiLogger({ logName: 'MatterbridgeUtils', logTimestampFormat: 4, logLevel: "info" });
 export async function waiter(name, check, exitWithReject = false, resolveTimeout = 5000, resolveInterval = 500, debug = false) {
     if (check())
         return true;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.1-dev-20250507-a182295",
+  "version": "3.0.2-dev-20250508-7214e17",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.1-dev-20250507-a182295",
+      "version": "3.0.2-dev-20250508-7214e17",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.1-dev-20250507-a182295",
+  "version": "3.0.2-dev-20250508-7214e17",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",

package/dist/utils/{parameter.js → commandLine.js}

@@ -1,3 +1,4 @@
+import { isValidNumber } from './export.js';
 export function hasParameter(name) {
     const commandArguments = process.argv.slice(2);
     let markerIncluded = commandArguments.includes(`-${name}`);
@@ -5,7 +6,6 @@ export function hasParameter(name) {
         markerIncluded = commandArguments.includes(`--${name}`);
     return markerIncluded;
 }
-import { isValidNumber } from './export.js';
 export function getParameter(name) {
     const commandArguments = process.argv.slice(2);
     let markerIndex = commandArguments.indexOf(`-${name}`);