matterbridge 3.0.0-edge.3 → 3.0.0-edge.4

package/dist/matterbridge.js

@@ -1728,12 +1728,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, delay * 2));
     }
     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 });
     }

package/dist/matterbridgeDeviceTypes.js

@@ -44,13 +44,11 @@ import { EnergyPreference } from '@matter/main/clusters/energy-preference';
 import { RvcRunMode } from '@matter/main/clusters/rvc-run-mode';
 import { RvcOperationalState } from '@matter/main/clusters/rvc-operational-state';
 import { RvcCleanMode } from '@matter/main/clusters/rvc-clean-mode';
-import { ScenesManagement } from '@matter/main/clusters/scenes-management';
 import { HepaFilterMonitoring } from '@matter/main/clusters/hepa-filter-monitoring';
 import { ActivatedCarbonFilterMonitoring } from '@matter/main/clusters/activated-carbon-filter-monitoring';
 import { DeviceEnergyManagementMode } from '@matter/main/clusters/device-energy-management-mode';
 import { AdministratorCommissioning } from '@matter/main/clusters/administrator-commissioning';
 import { EcosystemInformation } from '@matter/main/clusters/ecosystem-information';
-import { AccessControl } from '@matter/main/clusters/access-control';
 import { CommissionerControl } from '@matter/main/clusters/commissioner-control';
 import { ServiceArea } from '@matter/main/clusters';
 export var DeviceClasses;
@@ -178,7 +176,7 @@ export const pumpDevice = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [OnOff.Cluster.id, PumpConfigurationAndControl.Cluster.id, Identify.Cluster.id],
-    optionalServerClusters: [LevelControl.Cluster.id, Groups.Cluster.id, ScenesManagement.Cluster.id, TemperatureMeasurement.Cluster.id, PressureMeasurement.Cluster.id, FlowMeasurement.Cluster.id],
+    optionalServerClusters: [LevelControl.Cluster.id, Groups.Cluster.id, TemperatureMeasurement.Cluster.id, PressureMeasurement.Cluster.id, FlowMeasurement.Cluster.id],
 });
 export const waterValve = DeviceTypeDefinition({
     name: 'MA-waterValve',
@@ -194,7 +192,7 @@ export const onOffSwitch = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id],
 });
 export const dimmableSwitch = DeviceTypeDefinition({
     name: 'MA-dimmableswitch',
@@ -202,7 +200,7 @@ export const dimmableSwitch = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, LevelControl.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id],
 });
 export const colorTemperatureSwitch = DeviceTypeDefinition({
     name: 'MA-colortemperatureswitch',
@@ -210,7 +208,7 @@ export const colorTemperatureSwitch = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, Groups.Cluster.id, OnOff.Cluster.id, LevelControl.Cluster.id, ColorControl.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id],
 });
 export const genericSwitch = DeviceTypeDefinition({
     name: 'MA-genericswitch',
@@ -329,7 +327,7 @@ export const doorLockDevice = DeviceTypeDefinition({
     code: 0xa,
     deviceClass: DeviceClasses.Simple,
     revision: 3,
-    requiredServerClusters: [Identify.Cluster.id, DoorLock.Cluster.id, AccessControl.Cluster.id],
+    requiredServerClusters: [Identify.Cluster.id, DoorLock.Cluster.id],
     optionalServerClusters: [],
 });
 export const coverDevice = DeviceTypeDefinition({
@@ -394,5 +392,5 @@ export const airConditioner = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 2,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, Thermostat.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id, FanControl.Cluster.id, ThermostatUserInterfaceConfiguration.Cluster.id, TemperatureMeasurement.Cluster.id, RelativeHumidityMeasurement.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id, FanControl.Cluster.id, ThermostatUserInterfaceConfiguration.Cluster.id, TemperatureMeasurement.Cluster.id, RelativeHumidityMeasurement.Cluster.id],
 });

package/dist/matterbridgeEndpoint.js

@@ -1,7 +1,7 @@
 import { AnsiLogger, BLUE, CYAN, YELLOW, db, debugStringify, er, hk, or, zb } from './logger/export.js';
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { isValidNumber, isValidObject } from './utils/export.js';
-import { MatterbridgeBehavior, MatterbridgeBehaviorDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, } from './matterbridgeBehaviors.js';
+import { MatterbridgeServer, MatterbridgeServerDevice, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, } 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 { Endpoint, Lifecycle, MutableEndpoint, NamedHandler, SupportedBehaviors, VendorId } from '@matter/main';
 import { getClusterNameById, MeasurementType } from '@matter/main/types';
@@ -134,7 +134,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.log = new AnsiLogger({ logName: options.uniqueStorageKey ?? 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
         this.log.debug(`${YELLOW}new${db} MatterbridgeEndpoint: ${zb}${'0x' + firstDefinition.code.toString(16).padStart(4, '0')}${db}-${zb}${firstDefinition.name}${db} ` +
             `id: ${CYAN}${options.uniqueStorageKey}${db} number: ${CYAN}${options.endpointId}${db} taglist: ${CYAN}${options.tagList ? debugStringify(options.tagList) : 'undefined'}${db}`);
-        this.behaviors.require(MatterbridgeBehavior, { deviceCommand: new MatterbridgeBehaviorDevice(this.log, this.commandHandler, undefined) });
+        this.behaviors.require(MatterbridgeServer, { deviceCommand: new MatterbridgeServerDevice(this.log, this.commandHandler, undefined) });
     }
     static async loadInstance(definition, options = {}, debug = false) {
         return new MatterbridgeEndpoint(definition, options, debug);

package/dist/matterbridgePlatform.js

@@ -115,8 +115,8 @@ export class MatterbridgePlatform {
         if (device.deviceName)
             this._registeredEndpointsByName.delete(device.deviceName);
     }
-    async unregisterAllDevices() {
-        await this.matterbridge.removeAllBridgedEndpoints(this.name);
+    async unregisterAllDevices(delay = 0) {
+        await this.matterbridge.removeAllBridgedEndpoints(this.name, delay);
         this._registeredEndpoints.clear();
         this._registeredEndpointsByName.clear();
     }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.0-edge.3",
+  "version": "3.0.0-edge.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.0-edge.3",
+      "version": "3.0.0-edge.4",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "^0.13.0-alpha.0-20250408-c916c7e8",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.0-edge.3",
+  "version": "3.0.0-edge.4",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",