@matterbridge/core 3.10.5-dev-20260809-ffe76d7 → 3.10.5-dev-20260809-30130bb

package/dist/behaviors/thermostatServer.d.ts

@@ -10,11 +10,13 @@ declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterB
     occupancy: false;
     presets: true;
     setback: false;
-    thermostatSuggestions: false;
+    thermostatSuggestions: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/thermostat").ThermostatBaseServer.Internal, "thermostat">;
 export declare class MatterbridgeThermostatServer extends MatterbridgeThermostatServer_base {
     setpointRaiseLower(request: Thermostat.SetpointRaiseLowerRequest): Promise<void>;
     setActivePresetRequest(request: Thermostat.SetActivePresetRequest): Promise<void>;
     setActiveScheduleRequest(request: Thermostat.SetActiveScheduleRequest): Promise<void>;
+    addThermostatSuggestion(request: Thermostat.AddThermostatSuggestionRequest): Promise<Thermostat.AddThermostatSuggestionResponse>;
+    removeThermostatSuggestion(request: Thermostat.RemoveThermostatSuggestionRequest): Promise<void>;
 }
 export {};

package/dist/behaviors/thermostatServer.js

@@ -3,7 +3,7 @@ import { ThermostatServer } from '@matter/node/behaviors/thermostat';
 import { StatusResponse } from '@matter/types';
 import { Thermostat } from '@matter/types/clusters/thermostat';
 import { MatterbridgeServer } from './matterbridgeServer.js';
-export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode, Thermostat.Feature.Presets, Thermostat.Feature.MatterScheduleConfiguration) {
+export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode, Thermostat.Feature.Presets, Thermostat.Feature.MatterScheduleConfiguration, Thermostat.Feature.ThermostatSuggestions) {
     async 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})`);
@@ -55,4 +55,63 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
         this.state.activeScheduleHandle = Uint8Array.from(request.scheduleHandle);
         device.log.debug(`MatterbridgeThermostatServer: setActiveScheduleRequest completed with activeScheduleHandle: ${scheduleHandle}`);
     }
+    async addThermostatSuggestion(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const presetHandle = `0x${Buffer.from(request.presetHandle).toString('hex')}`;
+        device.log.info(`Adding thermostat suggestion for preset ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('Thermostat.addThermostatSuggestion', {
+            command: 'addThermostatSuggestion',
+            request,
+            cluster: ThermostatServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        if (this.state.presets.find((p) => p.presetHandle !== null && Bytes.areEqual(p.presetHandle, request.presetHandle)) === undefined) {
+            throw new StatusResponse.NotFoundError('Requested PresetHandle not found');
+        }
+        if (this.state.thermostatSuggestions.length >= this.state.maxThermostatSuggestions) {
+            throw new StatusResponse.ResourceExhaustedError('Maximum number of thermostat suggestions reached');
+        }
+        const currentTime = Math.floor(Date.now() / 1000);
+        const effectiveTime = request.effectiveTime ?? currentTime;
+        if (effectiveTime > currentTime + 24 * 60 * 60) {
+            throw new StatusResponse.InvalidCommandError('EffectiveTime cannot be more than 24 hours in the future');
+        }
+        const usedUniqueIds = new Set(this.state.thermostatSuggestions.map((s) => s.uniqueId));
+        let uniqueId = 0;
+        while (usedUniqueIds.has(uniqueId))
+            uniqueId++;
+        const suggestion = {
+            uniqueId,
+            presetHandle: Uint8Array.from(request.presetHandle),
+            effectiveTime,
+            expirationTime: effectiveTime + request.expirationInMinutes * 60,
+        };
+        this.state.thermostatSuggestions = [...this.state.thermostatSuggestions, suggestion];
+        device.log.debug(`MatterbridgeThermostatServer: addThermostatSuggestion completed with uniqueId: ${uniqueId}`);
+        return { uniqueId };
+    }
+    async removeThermostatSuggestion(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Removing thermostat suggestion ${request.uniqueId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('Thermostat.removeThermostatSuggestion', {
+            command: 'removeThermostatSuggestion',
+            request,
+            cluster: ThermostatServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        const suggestion = this.state.thermostatSuggestions.find((s) => s.uniqueId === request.uniqueId);
+        if (suggestion === undefined) {
+            throw new StatusResponse.NotFoundError('Requested UniqueID not found');
+        }
+        this.state.thermostatSuggestions = this.state.thermostatSuggestions.filter((s) => s.uniqueId !== request.uniqueId);
+        if (this.state.currentThermostatSuggestion?.uniqueId === request.uniqueId) {
+            this.state.currentThermostatSuggestion = null;
+            this.state.thermostatSuggestionNotFollowingReason = null;
+        }
+        device.log.debug(`MatterbridgeThermostatServer: removeThermostatSuggestion completed for uniqueId: ${request.uniqueId}`);
+    }
 }

package/dist/matterbridgeEndpoint.d.ts

@@ -174,8 +174,9 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     setWindowCoveringTargetAndCurrentPosition(liftPosition: number, tiltPosition?: number): Promise<void>;
     createDefaultThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null): this;
     createDefaultHeatingThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null): this;
-    createDefaultPresetsThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null, activePresetHandle?: Uint8Array | null, presets?: Thermostat.Preset[], presetTypes?: Thermostat.PresetType[]): this;
+    createDefaultPresetsThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null, activePresetHandle?: Uint8Array | null, presets?: Thermostat.Preset[], presetTypes?: Thermostat.PresetType[] | null): this;
     createDefaultSchedulesThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null, activeScheduleHandle?: Uint8Array | null, schedules?: Thermostat.Schedule[], scheduleTypes?: Thermostat.ScheduleType[], numberOfScheduleTransitions?: number, numberOfScheduleTransitionPerDay?: number | null): this;
+    createDefaultThermostatSuggestionsClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null, activePresetHandle?: Uint8Array | null, presets?: Thermostat.Preset[], presetTypes?: Thermostat.PresetType[] | null, thermostatSuggestions?: Thermostat.ThermostatSuggestion[], currentThermostatSuggestion?: Thermostat.ThermostatSuggestion | null, thermostatSuggestionNotFollowingReason?: Thermostat.ThermostatSuggestionNotFollowingReason | null): this;
     createDefaultCoolingThermostatClusterServer(localTemperature?: number, occupiedCoolingSetpoint?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedCoolingSetpoint?: number, occupied?: boolean, outdoorTemperature?: number | null): this;
     createDefaultThermostatUserInterfaceConfigurationClusterServer(temperatureDisplayMode?: ThermostatUserInterfaceConfiguration.TemperatureDisplayMode, keypadLockout?: ThermostatUserInterfaceConfiguration.KeypadLockout, scheduleProgrammingVisibility?: ThermostatUserInterfaceConfiguration.ScheduleProgrammingVisibility): this;
     createDefaultFanControlClusterServer(fanMode?: FanControl.FanMode, fanModeSequence?: FanControl.FanModeSequence, percentSetting?: number, percentCurrent?: number): this;

package/dist/matterbridgeEndpoint.js

@@ -1059,6 +1059,66 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    createDefaultThermostatSuggestionsClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 0, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, unoccupiedHeatingSetpoint, unoccupiedCoolingSetpoint, occupied, outdoorTemperature, activePresetHandle = null, presets = [], presetTypes = [
+        { presetScenario: Thermostat.PresetScenario.Occupied, numberOfPresets: 2, presetTypeFeatures: { automatic: false, supportsNames: true } },
+        { presetScenario: Thermostat.PresetScenario.Unoccupied, numberOfPresets: 2, presetTypeFeatures: { automatic: false, supportsNames: true } },
+    ], thermostatSuggestions = [], currentThermostatSuggestion = null, thermostatSuggestionNotFollowingReason = null) {
+        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : []), Thermostat.Feature.Presets, Thermostat.Feature.ThermostatSuggestions), {
+            localTemperature: localTemperature * 100,
+            externalMeasuredIndoorTemperature: localTemperature * 100,
+            ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
+            systemMode: Thermostat.SystemMode.Auto,
+            controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingAndHeating,
+            occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
+            minHeatSetpointLimit: minHeatSetpointLimit * 100,
+            maxHeatSetpointLimit: maxHeatSetpointLimit * 100,
+            absMinHeatSetpointLimit: minHeatSetpointLimit * 100,
+            absMaxHeatSetpointLimit: maxHeatSetpointLimit * 100,
+            occupiedCoolingSetpoint: occupiedCoolingSetpoint * 100,
+            minCoolSetpointLimit: minCoolSetpointLimit * 100,
+            maxCoolSetpointLimit: maxCoolSetpointLimit * 100,
+            absMinCoolSetpointLimit: minCoolSetpointLimit * 100,
+            absMaxCoolSetpointLimit: maxCoolSetpointLimit * 100,
+            minSetpointDeadBand: minSetpointDeadBand * 10,
+            thermostatRunningMode: Thermostat.ThermostatRunningMode.Off,
+            ...(occupied !== undefined ? { unoccupiedHeatingSetpoint: unoccupiedHeatingSetpoint !== undefined ? unoccupiedHeatingSetpoint * 100 : 1900 } : {}),
+            ...(occupied !== undefined ? { unoccupiedCoolingSetpoint: unoccupiedCoolingSetpoint !== undefined ? unoccupiedCoolingSetpoint * 100 : 2700 } : {}),
+            ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
+            ...(occupied !== undefined ? { externallyMeasuredOccupancy: true } : {}),
+            numberOfPresets: Math.max(Array.isArray(presets) ? presets.length : 0, Array.isArray(presetTypes) ? Math.max(0, ...presetTypes.map((pt) => pt.numberOfPresets ?? 0)) : 0, 1),
+            activePresetHandle: activePresetHandle ? Uint8Array.from(activePresetHandle) : null,
+            presets: (presets ?? []).map((p) => ({
+                presetHandle: p.presetHandle ? Uint8Array.from(p.presetHandle) : null,
+                presetScenario: p.presetScenario,
+                name: p.name,
+                coolingSetpoint: p.coolingSetpoint,
+                heatingSetpoint: p.heatingSetpoint,
+                builtIn: p.builtIn ?? true,
+            })),
+            presetTypes: (presetTypes ?? []).map((pt) => ({
+                ...pt,
+                numberOfPresets: pt.numberOfPresets ?? 0,
+                presetTypeFeatures: pt.presetTypeFeatures ?? { automatic: false, supportsNames: true },
+            })),
+            maxThermostatSuggestions: Math.max(Array.isArray(thermostatSuggestions) ? thermostatSuggestions.length : 0, 5),
+            thermostatSuggestions: (thermostatSuggestions ?? []).map((s) => ({
+                uniqueId: s.uniqueId,
+                presetHandle: Uint8Array.from(s.presetHandle),
+                effectiveTime: s.effectiveTime,
+                expirationTime: s.expirationTime,
+            })),
+            currentThermostatSuggestion: currentThermostatSuggestion
+                ? {
+                    uniqueId: currentThermostatSuggestion.uniqueId,
+                    presetHandle: Uint8Array.from(currentThermostatSuggestion.presetHandle),
+                    effectiveTime: currentThermostatSuggestion.effectiveTime,
+                    expirationTime: currentThermostatSuggestion.expirationTime,
+                }
+                : null,
+            thermostatSuggestionNotFollowingReason: thermostatSuggestionNotFollowingReason ?? null,
+        });
+        return this;
+    }
     createDefaultCoolingThermostatClusterServer(localTemperature = 23, occupiedCoolingSetpoint = 25, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, unoccupiedCoolingSetpoint, occupied, outdoorTemperature) {
         this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Cooling, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : [])), {
             localTemperature: localTemperature * 100,

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -458,6 +458,8 @@ export type CommandHandlerDataMap = {
     'setpointRaiseLower': CommandHandlerData<'Thermostat.setpointRaiseLower'>;
     'setActivePresetRequest': CommandHandlerData<'Thermostat.setActivePresetRequest'>;
     'setActiveScheduleRequest': CommandHandlerData<'Thermostat.setActiveScheduleRequest'>;
+    'addThermostatSuggestion': CommandHandlerData<'Thermostat.addThermostatSuggestion'>;
+    'removeThermostatSuggestion': CommandHandlerData<'Thermostat.removeThermostatSuggestion'>;
     'Thermostat.setpointRaiseLower': {
         command: 'setpointRaiseLower';
         request: Thermostat.SetpointRaiseLowerRequest;
@@ -479,6 +481,20 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof Thermostat)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'Thermostat.addThermostatSuggestion': {
+        command: 'addThermostatSuggestion';
+        request: Thermostat.AddThermostatSuggestionRequest;
+        cluster: 'thermostat';
+        attributes: ClusterAttributeValues<(typeof Thermostat)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
+    'Thermostat.removeThermostatSuggestion': {
+        command: 'removeThermostatSuggestion';
+        request: Thermostat.RemoveThermostatSuggestionRequest;
+        cluster: 'thermostat';
+        attributes: ClusterAttributeValues<(typeof Thermostat)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'step': CommandHandlerData<'FanControl.step'>;
     'FanControl.step': {
         command: 'step';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.5-dev-20260809-ffe76d7",
+  "version": "3.10.5-dev-20260809-30130bb",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,10 +132,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.5-dev-20260809-ffe76d7",
-    "@matterbridge/thread": "3.10.5-dev-20260809-ffe76d7",
-    "@matterbridge/types": "3.10.5-dev-20260809-ffe76d7",
-    "@matterbridge/utils": "3.10.5-dev-20260809-ffe76d7",
+    "@matterbridge/dgram": "3.10.5-dev-20260809-30130bb",
+    "@matterbridge/thread": "3.10.5-dev-20260809-30130bb",
+    "@matterbridge/types": "3.10.5-dev-20260809-30130bb",
+    "@matterbridge/utils": "3.10.5-dev-20260809-30130bb",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.2",