@matterbridge/core 3.5.6 → 3.6.0-dev-20260302-e3a7eb0

package/dist/devices/evse.d.ts

@@ -10,10 +10,15 @@ export declare class Evse extends MatterbridgeEndpoint {
     createDefaultEnergyEvseClusterServer(state?: EnergyEvse.State, supplyState?: EnergyEvse.SupplyState, faultState?: EnergyEvse.FaultState): this;
     createDefaultEnergyEvseModeClusterServer(currentMode?: number, supportedModes?: EnergyEvseMode.ModeOption[]): this;
 }
-export declare class MatterbridgeEnergyEvseServer extends EnergyEvseServer {
+declare const MatterbridgeEnergyEvseServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<EnergyEvse.Cluster, readonly [EnergyEvse.Feature.ChargingPreferences]>, typeof EnergyEvseServer, import("@matter/node/behaviors/energy-evse").EnergyEvseInterface>;
+export declare class MatterbridgeEnergyEvseServer extends MatterbridgeEnergyEvseServer_base {
     disable(): MaybePromise;
     enableCharging(request: EnergyEvse.EnableChargingRequest): MaybePromise;
+    setTargets(request: EnergyEvse.SetTargetsRequest): MaybePromise;
+    getTargets(): MaybePromise<EnergyEvse.GetTargetsResponse>;
+    clearTargets(): MaybePromise;
 }
 export declare class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
     changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
 }
+export {};

package/dist/devices/evse.js

@@ -9,21 +9,27 @@ import { deviceEnergyManagement, electricalSensor, evse, powerSource } from '../
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class Evse extends MatterbridgeEndpoint {
     constructor(name, serial, currentMode, supportedModes, state, supplyState, faultState, voltage = null, current = null, power = null, energy = null, absMinPower, absMaxPower) {
-        super([evse, powerSource, electricalSensor, deviceEnergyManagement], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        super([evse], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Evse')
-            .createDefaultPowerSourceWiredClusterServer()
+            .createDefaultEnergyEvseClusterServer(state, supplyState, faultState)
+            .createDefaultEnergyEvseModeClusterServer(currentMode, supportedModes)
+            .createDefaultTemperatureMeasurementClusterServer(24_00)
+            .addRequiredClusterServers();
+        this.addFixedLabel('composed', 'EVSE');
+        this.addChildDeviceType('PowerSource', powerSource).createDefaultPowerSourceWiredClusterServer().addRequiredClusterServers();
+        this.addChildDeviceType('ElectricalSensor', electricalSensor)
             .createDefaultPowerTopologyClusterServer()
             .createDefaultElectricalPowerMeasurementClusterServer(voltage, current, power)
             .createDefaultElectricalEnergyMeasurementClusterServer(energy, 0)
+            .addRequiredClusterServers();
+        this.addChildDeviceType('DeviceEnergyManagement', deviceEnergyManagement)
             .createDefaultDeviceEnergyManagementClusterServer(DeviceEnergyManagement.EsaType.Evse, false, DeviceEnergyManagement.EsaState.Online, absMinPower, absMaxPower)
             .createDefaultDeviceEnergyManagementModeClusterServer()
-            .createDefaultEnergyEvseClusterServer(state, supplyState, faultState)
-            .createDefaultEnergyEvseModeClusterServer(currentMode, supportedModes)
             .addRequiredClusterServers();
     }
     createDefaultEnergyEvseClusterServer(state, supplyState, faultState) {
-        this.behaviors.require(MatterbridgeEnergyEvseServer, {
+        this.behaviors.require(MatterbridgeEnergyEvseServer.with(EnergyEvse.Feature.ChargingPreferences), {
             state: state !== undefined ? state : EnergyEvse.State.NotPluggedIn,
             supplyState: supplyState !== undefined ? supplyState : EnergyEvse.SupplyState.ChargingEnabled,
             faultState: faultState !== undefined ? faultState : EnergyEvse.FaultState.NoError,
@@ -50,7 +56,7 @@ export class Evse extends MatterbridgeEndpoint {
         return this;
     }
 }
-export class MatterbridgeEnergyEvseServer extends EnergyEvseServer {
+export class MatterbridgeEnergyEvseServer extends EnergyEvseServer.with(EnergyEvse.Feature.ChargingPreferences) {
     disable() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Disable charging (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -74,6 +80,21 @@ export class MatterbridgeEnergyEvseServer extends EnergyEvseServer {
         this.state.minimumChargeCurrent = request.minimumChargeCurrent;
         this.state.maximumChargeCurrent = request.maximumChargeCurrent;
     }
+    setTargets(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`SetTargets request ${request.chargingTargetSchedules} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        return;
+    }
+    getTargets() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`GetTargets (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        return { chargingTargetSchedules: [] };
+    }
+    clearTargets() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`ClearTargets (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        return;
+    }
 }
 export class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
     changeToMode(request) {

package/dist/devices/oven.d.ts

@@ -8,7 +8,7 @@ import { OvenMode } from '@matter/types/clusters/oven-mode';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class Oven extends MatterbridgeEndpoint {
     constructor(name: string, serial: string);
-    addCabinet(name: string, tagList: Semtag[], currentMode?: number, supportedModes?: OvenMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], operationalState?: OperationalState.OperationalStateEnum, currentPhase?: number, phaseList?: string[]): MatterbridgeEndpoint;
+    addCabinet(name: string, tagList: Semtag[], currentMode?: number, supportedModes?: OvenMode.ModeOption[], targetTemperature?: number, minTemperature?: number, maxTemperature?: number, step?: number, currentTemperature?: number, operationalState?: OperationalState.OperationalStateEnum, currentPhase?: number, phaseList?: string[]): MatterbridgeEndpoint;
     createDefaultOvenModeClusterServer(endpoint: MatterbridgeEndpoint, currentMode: number, supportedModes: OvenMode.ModeOption[]): MatterbridgeEndpoint;
     createDefaultOvenCavityOperationalStateClusterServer(endpoint: MatterbridgeEndpoint, operationalState?: OperationalState.OperationalStateEnum, currentPhase?: number, phaseList?: string[]): MatterbridgeEndpoint;
 }

package/dist/devices/oven.js

@@ -6,7 +6,7 @@ import { OvenMode } from '@matter/types/clusters/oven-mode';
 import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
 import { oven, powerSource, temperatureControlledCabinetHeater } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-import { createLevelTemperatureControlClusterServer } from './temperatureControl.js';
+import { createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class Oven extends MatterbridgeEndpoint {
     constructor(name, serial) {
         super([oven, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
@@ -26,12 +26,11 @@ export class Oven extends MatterbridgeEndpoint {
         { label: 'Warming', mode: 8, modeTags: [{ value: OvenMode.ModeTag.Warming }] },
         { label: 'Proofing', mode: 9, modeTags: [{ value: OvenMode.ModeTag.Proofing }] },
         { label: 'Steam', mode: 10, modeTags: [{ value: OvenMode.ModeTag.Steam }] },
-    ], selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Defrost', '180°', '190°', '200°', '250°', '300°'], operationalState = OperationalState.OperationalStateEnum.Stopped, currentPhase, phaseList) {
+    ], targetTemperature = 180 * 100, minTemperature = 30 * 100, maxTemperature = 300 * 100, step = 10 * 100, currentTemperature = 20 * 100, operationalState = OperationalState.OperationalStateEnum.Stopped, currentPhase, phaseList) {
         const cabinet = this.addChildDeviceType(name, temperatureControlledCabinetHeater, { tagList }, true);
         cabinet.log.logName = name;
-        cabinet.createDefaultIdentifyClusterServer();
-        createLevelTemperatureControlClusterServer(cabinet, selectedTemperatureLevel, supportedTemperatureLevels);
-        cabinet.createDefaultTemperatureMeasurementClusterServer(2000);
+        createNumberTemperatureControlClusterServer(cabinet, targetTemperature, minTemperature, maxTemperature, step);
+        cabinet.createDefaultTemperatureMeasurementClusterServer(currentTemperature);
         this.createDefaultOvenModeClusterServer(cabinet, currentMode, supportedModes);
         this.createDefaultOvenCavityOperationalStateClusterServer(cabinet, operationalState, currentPhase, phaseList);
         return cabinet;

package/dist/devices/refrigerator.d.ts

@@ -5,12 +5,12 @@ import { ModeBase } from '@matter/types/clusters/mode-base';
 import { RefrigeratorAndTemperatureControlledCabinetMode } from '@matter/types/clusters/refrigerator-and-temperature-controlled-cabinet-mode';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class Refrigerator extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string);
-    addCabinet(name: string, tagList: Semtag[], currentMode?: number, supportedModes?: RefrigeratorAndTemperatureControlledCabinetMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], currentTemperature?: number): MatterbridgeEndpoint;
+    constructor(name: string, serial: string, currentMode?: number, supportedModes?: RefrigeratorAndTemperatureControlledCabinetMode.ModeOption[]);
+    addCabinet(name: string, tagList: Semtag[], targetTemperature?: number, minTemperature?: number, maxTemperature?: number, step?: number, currentTemperature?: number): MatterbridgeEndpoint;
     createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(endpoint: MatterbridgeEndpoint, currentMode: number, supportedModes: RefrigeratorAndTemperatureControlledCabinetMode.ModeOption[]): MatterbridgeEndpoint;
     createDefaultRefrigeratorAlarmClusterServer(endpoint: MatterbridgeEndpoint, doorOpen?: boolean): MatterbridgeEndpoint;
-    setDoorOpenState(cabinetName: string, doorOpen: boolean): Promise<MatterbridgeEndpoint | undefined>;
-    triggerDoorOpenState(cabinetName: string, doorOpen: boolean): Promise<MatterbridgeEndpoint | undefined>;
+    setDoorOpenState(doorOpen: boolean): Promise<MatterbridgeEndpoint>;
+    triggerDoorOpenState(doorOpen: boolean): Promise<MatterbridgeEndpoint>;
 }
 export declare class MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer extends RefrigeratorAndTemperatureControlledCabinetModeServer {
     initialize(): void;

package/dist/devices/refrigerator.js

@@ -5,26 +5,25 @@ import { RefrigeratorAndTemperatureControlledCabinetMode } from '@matter/types/c
 import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
 import { powerSource, refrigerator, temperatureControlledCabinetCooler } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-import { createLevelTemperatureControlClusterServer } from './temperatureControl.js';
+import { createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class Refrigerator extends MatterbridgeEndpoint {
-    constructor(name, serial) {
+    constructor(name, serial, currentMode = 1, supportedModes = [
+        { label: 'Auto', mode: 1, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.Auto }] },
+        { label: 'RapidCool', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
+        { label: 'RapidFreeze', mode: 3, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
+    ]) {
         super([refrigerator, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Refrigerator');
         this.createDefaultPowerSourceWiredClusterServer();
         this.addFixedLabel('composed', 'Refrigerator');
+        this.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(this, currentMode, supportedModes);
+        this.createDefaultRefrigeratorAlarmClusterServer(this, false);
     }
-    addCabinet(name, tagList, currentMode = 1, supportedModes = [
-        { label: 'Auto', mode: 1, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.Auto }] },
-        { label: 'RapidCool', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
-        { label: 'RapidFreeze', mode: 3, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
-    ], selectedTemperatureLevel = 2, supportedTemperatureLevels = ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5'], currentTemperature = 1000) {
+    addCabinet(name, tagList, targetTemperature = 10 * 100, minTemperature = -30 * 100, maxTemperature = 20 * 100, step = 1 * 100, currentTemperature = 10 * 100) {
         const cabinet = this.addChildDeviceType(name, temperatureControlledCabinetCooler, { tagList });
         cabinet.log.logName = name;
-        cabinet.createDefaultIdentifyClusterServer();
-        createLevelTemperatureControlClusterServer(cabinet, selectedTemperatureLevel, supportedTemperatureLevels);
-        this.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(cabinet, currentMode, supportedModes);
-        this.createDefaultRefrigeratorAlarmClusterServer(cabinet, false);
+        createNumberTemperatureControlClusterServer(cabinet, targetTemperature, minTemperature, maxTemperature, step);
         cabinet.createDefaultTemperatureMeasurementClusterServer(currentTemperature);
         return cabinet;
     }
@@ -43,24 +42,18 @@ export class Refrigerator extends MatterbridgeEndpoint {
         });
         return endpoint;
     }
-    async setDoorOpenState(cabinetName, doorOpen) {
-        const endpoint = this.getChildEndpointByName(cabinetName);
-        if (endpoint) {
-            await endpoint.setAttribute('RefrigeratorAlarm', 'state', { doorOpen }, endpoint.log);
-            return endpoint;
-        }
+    async setDoorOpenState(doorOpen) {
+        await this.setAttribute('RefrigeratorAlarm', 'state', { doorOpen }, this.log);
+        return this;
     }
-    async triggerDoorOpenState(cabinetName, doorOpen) {
-        const endpoint = this.getChildEndpointByName(cabinetName);
-        if (endpoint) {
-            if (doorOpen) {
-                await endpoint.triggerEvent('RefrigeratorAlarm', 'notify', { active: { doorOpen: true }, inactive: { doorOpen: false }, state: { doorOpen: true }, mask: { doorOpen: true } }, endpoint.log);
-            }
-            else {
-                await endpoint.triggerEvent('RefrigeratorAlarm', 'notify', { active: { doorOpen: false }, inactive: { doorOpen: true }, state: { doorOpen: false }, mask: { doorOpen: true } }, endpoint.log);
-            }
-            return endpoint;
+    async triggerDoorOpenState(doorOpen) {
+        if (doorOpen) {
+            await this.triggerEvent('RefrigeratorAlarm', 'notify', { active: { doorOpen: true }, inactive: { doorOpen: false }, state: { doorOpen: true }, mask: { doorOpen: true } }, this.log);
+        }
+        else {
+            await this.triggerEvent('RefrigeratorAlarm', 'notify', { active: { doorOpen: false }, inactive: { doorOpen: true }, state: { doorOpen: false }, mask: { doorOpen: true } }, this.log);
         }
+        return this;
     }
 }
 export class MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer extends RefrigeratorAndTemperatureControlledCabinetModeServer {

package/dist/devices/waterHeater.js

@@ -5,22 +5,27 @@ import { ModeBase } from '@matter/types/clusters/mode-base';
 import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
 import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
 import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
-import { electricalSensor, powerSource, waterHeater } from '../matterbridgeDeviceTypes.js';
+import { deviceEnergyManagement, electricalSensor, powerSource, waterHeater } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class WaterHeater extends MatterbridgeEndpoint {
     constructor(name, serial, waterTemperature = 50, targetWaterTemperature = 55, minHeatSetpointLimit = 20, maxHeatSetpointLimit = 80, heaterTypes = { immersionElement1: true }, tankPercentage = 90, voltage = null, current = null, power = null, energy = null, absMinPower = 0, absMaxPower = 0) {
-        super([waterHeater, powerSource, electricalSensor], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        super([waterHeater], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Water Heater')
-            .createDefaultPowerSourceWiredClusterServer()
             .createDefaultHeatingThermostatClusterServer(waterTemperature, targetWaterTemperature, minHeatSetpointLimit, maxHeatSetpointLimit)
             .createDefaultWaterHeaterManagementClusterServer(heaterTypes, {}, tankPercentage)
-            .createDefaultWaterHeaterModeClusterServer()
+            .createDefaultWaterHeaterModeClusterServer();
+        this.addFixedLabel('composed', 'Water Heater');
+        this.addChildDeviceType('PowerSource', powerSource).createDefaultPowerSourceWiredClusterServer().addRequiredClusterServers();
+        this.addChildDeviceType('ElectricalSensor', electricalSensor)
             .createDefaultPowerTopologyClusterServer()
             .createDefaultElectricalPowerMeasurementClusterServer(voltage, current, power)
-            .createDefaultElectricalEnergyMeasurementClusterServer(energy)
-            .createDefaultDeviceEnergyManagementClusterServer(DeviceEnergyManagement.EsaType.WaterHeating, true, DeviceEnergyManagement.EsaState.Online, absMinPower, absMaxPower)
-            .createDefaultDeviceEnergyManagementModeClusterServer();
+            .createDefaultElectricalEnergyMeasurementClusterServer(energy, 0)
+            .addRequiredClusterServers();
+        this.addChildDeviceType('DeviceEnergyManagement', deviceEnergyManagement)
+            .createDefaultDeviceEnergyManagementClusterServer(DeviceEnergyManagement.EsaType.WaterHeating, false, DeviceEnergyManagement.EsaState.Online, absMinPower, absMaxPower)
+            .createDefaultDeviceEnergyManagementModeClusterServer()
+            .addRequiredClusterServers();
     }
     createDefaultWaterHeaterManagementClusterServer(heaterTypes, heatDemand, tankPercentage, boostState) {
         this.behaviors.require(MatterbridgeWaterHeaterManagementServer.with(WaterHeaterManagement.Feature.TankPercent), {

package/dist/frontend.d.ts

@@ -43,7 +43,8 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     private wsMessageHandler;
     wssSendLogMessage(level: string, time: string, name: string, message: string): void;
     wssSendRefreshRequired(changed: RefreshRequiredChanged, params?: {
-        matter: ApiMatter;
+        matter?: ApiMatter;
+        lock?: string;
     }): void;
     wssSendRestartRequired(snackbar?: boolean, fixed?: boolean): void;
     wssSendRestartNotRequired(snackbar?: boolean): void;

package/dist/frontend.js

@@ -1891,6 +1891,7 @@ export class Frontend extends EventEmitter {
                         plugin.configJson = config;
                         await this.matterbridge.plugins.saveConfigFromPlugin(plugin, true);
                         this.wssSendRestartRequired(false);
+                        this.wssSendRefreshRequired('plugins', { lock: plugin.name });
                         sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                     }
                     else {
@@ -1938,6 +1939,7 @@ export class Frontend extends EventEmitter {
                         plugin.configJson = config;
                         await this.matterbridge.plugins.saveConfigFromPlugin(plugin, true);
                         this.wssSendRestartRequired(false);
+                        this.wssSendRefreshRequired('plugins', { lock: plugin.name });
                         sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                     }
                     else {
@@ -1986,7 +1988,7 @@ export class Frontend extends EventEmitter {
         if (!this.listening || this.webSocketServer?.clients.size === 0)
             return;
         this.log.debug('Sending a refresh required message to all connected clients');
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', success: true, response: { changed, ...params } });
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', success: true, response: { changed, lock: params?.lock, ...params } });
     }
     wssSendRestartRequired(snackbar = true, fixed = false) {
         if (!this.listening || this.webSocketServer?.clients.size === 0)

package/dist/jestutils/jestHelpers.js

@@ -255,7 +255,7 @@ export async function createMatterbridgeEnvironment(name, createOnly = false) {
     matterbridge = await Matterbridge.loadInstance(false);
     expect(matterbridge).toBeDefined();
     expect(matterbridge).toBeInstanceOf(Matterbridge);
-    matterbridge.matterbridgeVersion = '3.5.6';
+    matterbridge.matterbridgeVersion = '3.6.0';
     matterbridge.bridgeMode = 'bridge';
     matterbridge.rootDirectory = path.join('jest', name);
     matterbridge.homeDirectory = path.join('jest', name);

package/dist/matterbridge.js

@@ -1037,9 +1037,13 @@ export class Matterbridge extends EventEmitter {
     async unregisterAndShutdownProcess(timeout = 1000) {
         const { wait } = await import('@matterbridge/utils');
         this.log.info('Unregistering all devices and shutting down...');
+        if (this.serverNode)
+            await this.serverNode.setStateOf(BasicInformationServer, { configurationVersion: this.serverNode.state.basicInformation.configurationVersion + 1 });
         for (const plugin of this.plugins.array()) {
             if (plugin.error || !plugin.enabled)
                 continue;
+            if (plugin.serverNode)
+                await plugin.serverNode.setStateOf(BasicInformationServer, { configurationVersion: plugin.serverNode.state.basicInformation.configurationVersion + 1 });
             const registeredDevices = plugin.registeredDevices;
             await this.plugins.shutdown(plugin, 'unregistering all devices and shutting down...', false, true);
             plugin.registeredDevices = registeredDevices;

package/dist/matterbridgeBehaviors.d.ts

@@ -1615,6 +1615,7 @@ declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterB
     }];
 }>, readonly [Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode]>, typeof ThermostatServer, import("@matter/node/behaviors/thermostat").ThermostatInterface>;
 export declare class MatterbridgeThermostatServer extends MatterbridgeThermostatServer_base {
+    initialize(): Promise<void>;
     setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): MaybePromise;
 }
 declare const MatterbridgePresetThermostatServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{

package/dist/matterbridgeBehaviors.js

@@ -320,6 +320,17 @@ export class MatterbridgeFanControlServer extends FanControlServer.with(FanContr
     }
 }
 export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
+    async initialize() {
+        await super.initialize();
+        this.endpoint.construction.onSuccess(async () => {
+            const device = this.endpoint.stateOf(MatterbridgeServer);
+            device.log.debug(`Removing atomic commands (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            await this.endpoint.setStateOf(ThermostatServer, {
+                acceptedCommandList: [0],
+                generatedCommandList: [],
+            });
+        });
+    }
     setpointRaiseLower(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);

package/dist/matterbridgeEndpoint.js

@@ -61,7 +61,7 @@ import { WindowCovering } from '@matter/types/clusters/window-covering';
 import { VendorId } from '@matter/types/datatype';
 import { inspectError, isValidNumber, isValidObject, isValidString } from '@matterbridge/utils';
 import { AnsiLogger, CYAN, db, debugStringify, hk, or, YELLOW, zb } from 'node-ansi-logger';
-import { MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeColorControlServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeDoorLockServer, MatterbridgeEnhancedColorControlServer, MatterbridgeFanControlServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeIdentifyServer, MatterbridgeLevelControlServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeModeSelectServer, MatterbridgeOnOffServer, MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer, MatterbridgeServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeSwitchServer, MatterbridgeThermostatServer, MatterbridgeValveConfigurationAndControlServer, } from './matterbridgeBehaviors.js';
+import { MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeColorControlServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeDoorLockServer, MatterbridgeEnhancedColorControlServer, MatterbridgeFanControlServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeIdentifyServer, MatterbridgeLevelControlServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeModeSelectServer, MatterbridgeOnOffServer, MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer, MatterbridgePresetThermostatServer, MatterbridgeServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeSwitchServer, MatterbridgeThermostatServer, MatterbridgeValveConfigurationAndControlServer, } from './matterbridgeBehaviors.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, checkNotLatinCharacters, createUniqueId, featuresFor, generateUniqueId, getApparentElectricalPowerMeasurementClusterServer, getAttribute, getAttributeId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getClusterId, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultOperationalStateClusterServer, getDefaultPowerSourceBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceWiredClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, invokeBehaviorCommand, lowercaseFirstLetter, setAttribute, subscribeAttribute, triggerEvent, updateAttribute, } from './matterbridgeEndpointHelpers.js';
 const MATTERBRIDGE_ENDPOINT_BRAND = Symbol('MatterbridgeEndpoint.brand');
 export function isMatterbridgeEndpoint(value) {
@@ -881,7 +881,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createDefaultPresetsThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 2, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, unoccupiedHeatingSetpoint = undefined, unoccupiedCoolingSetpoint = undefined, occupied = undefined, outdoorTemperature = undefined, activePresetHandle = undefined, presetsList = undefined, presetTypes = undefined) {
-        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : []), Thermostat.Feature.Presets), {
+        this.behaviors.require(MatterbridgePresetThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : []), Thermostat.Feature.Presets), {
             localTemperature: localTemperature * 100,
             externalMeasuredIndoorTemperature: localTemperature * 100,
             ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),

package/dist/matterbridgeEndpointTypes.d.ts

@@ -67,6 +67,9 @@ export interface MatterbridgeEndpointCommands {
     cancelBoost: HandlerFunction;
     enableCharging: HandlerFunction;
     disable: HandlerFunction;
+    setTargets: HandlerFunction;
+    getTargets: HandlerFunction;
+    clearTargets: HandlerFunction;
     powerAdjustRequest: HandlerFunction;
     cancelPowerAdjustRequest: HandlerFunction;
     setTemperature: HandlerFunction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.5.6",
+  "version": "3.6.0-dev-20260302-e3a7eb0",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -122,14 +122,14 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.10",
-    "@matterbridge/dgram": "3.5.6",
-    "@matterbridge/thread": "3.5.6",
-    "@matterbridge/types": "3.5.6",
-    "@matterbridge/utils": "3.5.6",
+    "@matterbridge/dgram": "3.6.0-dev-20260302-e3a7eb0",
+    "@matterbridge/thread": "3.6.0-dev-20260302-e3a7eb0",
+    "@matterbridge/types": "3.6.0-dev-20260302-e3a7eb0",
+    "@matterbridge/utils": "3.6.0-dev-20260302-e3a7eb0",
     "archiver": "7.0.1",
     "express": "5.2.1",
     "glob": "13.0.6",
-    "multer": "2.0.2",
+    "multer": "2.1.0",
     "node-ansi-logger": "3.2.0",
     "node-persist-manager": "2.0.1",
     "ws": "8.19.0"