@matterbridge/core 3.10.6-dev-20260816-34076cc → 3.10.6-dev-20260817-a8ee796

package/dist/behaviors/booleanStateConfigurationServer.d.ts

@@ -1,13 +1,17 @@
+import type { MaybePromise } from '@matter/general';
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
-declare const MatterbridgeBooleanStateConfigurationServer_base: import("@matter/node").ClusterBehavior.Type<typeof BooleanStateConfigurationServer, import("@matter/types").ClusterType.WithSupportedFeatures<BooleanStateConfiguration, {
-    alarmSuppress: false;
+declare const Base: import("@matter/node").ClusterBehavior.Type<typeof BooleanStateConfigurationServer, import("@matter/types").ClusterType.WithSupportedFeatures<BooleanStateConfiguration, {
+    alarmSuppress: true;
     audible: true;
-    faultEvents: false;
+    faultEvents: true;
     sensitivityLevel: true;
     visual: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "booleanStateConfiguration">;
-export declare class MatterbridgeBooleanStateConfigurationServer extends MatterbridgeBooleanStateConfigurationServer_base {
+export declare class MatterbridgeBooleanStateConfigurationServer extends Base {
+    #private;
+    initialize(): MaybePromise;
+    suppressAlarm(request: BooleanStateConfiguration.SuppressAlarmRequest): Promise<void>;
     enableDisableAlarm(request: BooleanStateConfiguration.EnableDisableAlarmRequest): Promise<void>;
 }
 export {};

package/dist/behaviors/booleanStateConfigurationServer.js

@@ -1,8 +1,77 @@
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
+import { Status, StatusResponseError } from '@matter/types';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
 import { debugStringify } from 'node-ansi-logger';
 import { MatterbridgeServer } from './matterbridgeServer.js';
-export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.SensitivityLevel) {
+const Base = BooleanStateConfigurationServer.with(BooleanStateConfiguration.Feature.Visual, BooleanStateConfiguration.Feature.Audible, BooleanStateConfiguration.Feature.AlarmSuppress, BooleanStateConfiguration.Feature.SensitivityLevel, BooleanStateConfiguration.Feature.FaultEvents);
+export class MatterbridgeBooleanStateConfigurationServer extends Base {
+    initialize() {
+        if (this.features.visual || this.features.audible) {
+            this.reactTo(this.events.alarmsActive$Changed, this.#emitAlarmsStateChanged);
+            this.reactTo(this.events.alarmsSuppressed$Changed, this.#emitAlarmsStateChanged);
+        }
+        if (this.features.faultEvents) {
+            const sensorFaultChanged = this.events.sensorFault$Changed;
+            if (sensorFaultChanged)
+                this.reactTo(sensorFaultChanged, this.#emitSensorFault);
+        }
+    }
+    #emitAlarmsStateChanged() {
+        this.events.alarmsStateChanged?.emit({ alarmsActive: this.state.alarmsActive, alarmsSuppressed: this.state.alarmsSuppressed }, this.context);
+    }
+    #emitSensorFault(sensorFault) {
+        this.events.sensorFault?.emit({ sensorFault }, this.context);
+    }
+    #mergeAlarmsSuppressed(alarmsToSuppress) {
+        return {
+            visual: [this.state.alarmsSuppressed.visual, alarmsToSuppress.visual].some(Boolean),
+            audible: [this.state.alarmsSuppressed.audible, alarmsToSuppress.audible].some(Boolean),
+        };
+    }
+    #applyAlarmsEnabled(alarmsToEnableDisable) {
+        const alarmsEnabled = {
+            visual: Boolean(alarmsToEnableDisable.visual),
+            audible: Boolean(alarmsToEnableDisable.audible),
+        };
+        this.state.alarmsEnabled = alarmsEnabled;
+        this.state.alarmsActive = {
+            visual: Boolean(this.state.alarmsActive.visual && alarmsEnabled.visual),
+            audible: Boolean(this.state.alarmsActive.audible && alarmsEnabled.audible),
+        };
+        this.state.alarmsSuppressed = {
+            visual: Boolean(this.state.alarmsSuppressed.visual && alarmsEnabled.visual),
+            audible: Boolean(this.state.alarmsSuppressed.audible && alarmsEnabled.audible),
+        };
+    }
+    #assertAlarmModesSupported(alarms) {
+        if ([Boolean(alarms.visual && !this.state.alarmsSupported.visual), Boolean(alarms.audible && !this.state.alarmsSupported.audible)].some(Boolean)) {
+            throw new StatusResponseError('Requested alarm mode is not supported', Status.ConstraintError);
+        }
+    }
+    #assertSuppressAlarmAllowed(alarmsToSuppress) {
+        if ([
+            Boolean(alarmsToSuppress.visual && (!this.state.alarmsActive.visual || !this.state.alarmsEnabled?.visual)),
+            Boolean(alarmsToSuppress.audible && (!this.state.alarmsActive.audible || !this.state.alarmsEnabled?.audible)),
+        ].some(Boolean)) {
+            throw new StatusResponseError('Requested alarm mode is not active', Status.InvalidInState);
+        }
+    }
+    async suppressAlarm(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Suppressing alarm ${debugStringify(request.alarmsToSuppress)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('BooleanStateConfiguration.suppressAlarm', {
+            command: 'suppressAlarm',
+            request,
+            cluster: BooleanStateConfigurationServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        this.#assertAlarmModesSupported(request.alarmsToSuppress);
+        this.#assertSuppressAlarmAllowed(request.alarmsToSuppress);
+        this.state.alarmsSuppressed = this.#mergeAlarmsSuppressed(request.alarmsToSuppress);
+        device.log.debug(`MatterbridgeBooleanStateConfigurationServer: suppressAlarm called`);
+    }
     async enableDisableAlarm(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Enabling/disabling alarm ${debugStringify(request.alarmsToEnableDisable)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -14,6 +83,8 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
             endpoint: this.endpoint,
             context: this.context,
         });
+        this.#assertAlarmModesSupported(request.alarmsToEnableDisable);
+        this.#applyAlarmsEnabled(request.alarmsToEnableDisable);
         device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called`);
     }
 }

package/dist/behaviors/export.d.ts

@@ -12,6 +12,7 @@ export * from './levelControlServer.js';
 export * from './matterbridgeServer.js';
 export * from './modeSelectServer.js';
 export * from './onOffServer.js';
+export * from './occupancySensingServer.js';
 export * from './operationalStateServer.js';
 export * from './powerSourceServer.js';
 export * from './serviceAreaServer.js';

package/dist/behaviors/export.js

@@ -12,6 +12,7 @@ export * from './levelControlServer.js';
 export * from './matterbridgeServer.js';
 export * from './modeSelectServer.js';
 export * from './onOffServer.js';
+export * from './occupancySensingServer.js';
 export * from './operationalStateServer.js';
 export * from './powerSourceServer.js';
 export * from './serviceAreaServer.js';

package/dist/behaviors/occupancySensingServer.d.ts

@@ -0,0 +1,19 @@
+import type { MaybePromise } from '@matter/general';
+import { OccupancySensingServer } from '@matter/node/behaviors/occupancy-sensing';
+import { OccupancySensing } from '@matter/types/clusters/occupancy-sensing';
+declare const MatterbridgeOccupancySensingServer_base: import("@matter/node").ClusterBehavior.Type<typeof OccupancySensingServer, import("@matter/types").ClusterType.WithSupportedFeatures<OccupancySensing, {
+    activeInfrared: false;
+    occupancyEvent: false;
+    other: false;
+    passiveInfrared: true;
+    physicalContact: false;
+    radar: false;
+    rfSensing: false;
+    ultrasonic: false;
+    vision: false;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "occupancySensing">;
+export declare class MatterbridgeOccupancySensingServer extends MatterbridgeOccupancySensingServer_base {
+    #private;
+    initialize(): MaybePromise;
+}
+export {};

package/dist/behaviors/occupancySensingServer.js

@@ -0,0 +1,29 @@
+import { OccupancySensingServer } from '@matter/node/behaviors/occupancy-sensing';
+import { OccupancySensing } from '@matter/types/clusters/occupancy-sensing';
+export class MatterbridgeOccupancySensingServer extends OccupancySensingServer.with(OccupancySensing.Feature.PassiveInfrared) {
+    #syncingHoldTime = false;
+    initialize() {
+        const result = super.initialize();
+        if (this.events.holdTime$Changing)
+            this.reactTo(this.events.holdTime$Changing, this.#syncPirOccupiedToUnoccupiedDelay);
+        if (this.events.pirOccupiedToUnoccupiedDelay$Changing)
+            this.reactTo(this.events.pirOccupiedToUnoccupiedDelay$Changing, this.#syncHoldTime);
+        return result;
+    }
+    #syncPirOccupiedToUnoccupiedDelay = (holdTime, _oldHoldTime, context) => {
+        const state = this.endpoint.agentFor(context).get(MatterbridgeOccupancySensingServer).state;
+        if (this.#syncingHoldTime || holdTime === undefined || state.pirOccupiedToUnoccupiedDelay === holdTime)
+            return;
+        this.#syncingHoldTime = true;
+        state.pirOccupiedToUnoccupiedDelay = holdTime;
+        this.#syncingHoldTime = false;
+    };
+    #syncHoldTime = (pirOccupiedToUnoccupiedDelay, _oldPirOccupiedToUnoccupiedDelay, context) => {
+        const state = this.endpoint.agentFor(context).get(MatterbridgeOccupancySensingServer).state;
+        if (this.#syncingHoldTime || pirOccupiedToUnoccupiedDelay === undefined || state.holdTime === pirOccupiedToUnoccupiedDelay)
+            return;
+        this.#syncingHoldTime = true;
+        state.holdTime = pirOccupiedToUnoccupiedDelay;
+        this.#syncingHoldTime = false;
+    };
+}

package/dist/behaviors/smokeCoAlarmServer.d.ts

@@ -1,3 +1,4 @@
+import { type Timer } from '@matter/general';
 import { SmokeCoAlarmServer } from '@matter/node/behaviors/smoke-co-alarm';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
 declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").ClusterBehavior.Type<typeof SmokeCoAlarmServer, import("@matter/types").ClusterType.WithSupportedFeatures<SmokeCoAlarm, {
@@ -5,6 +6,15 @@ declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").Cluste
     smokeAlarm: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "smokeCoAlarm">;
 export declare class MatterbridgeSmokeCoAlarmServer extends MatterbridgeSmokeCoAlarmServer_base {
+    #private;
+    protected internal: MatterbridgeSmokeCoAlarmServer.Internal;
+    static selfTestDurationSeconds: number;
     selfTestRequest(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare namespace MatterbridgeSmokeCoAlarmServer {
+    class Internal {
+        selfTestTimer?: Timer;
+    }
 }
 export {};

package/dist/behaviors/smokeCoAlarmServer.js

@@ -1,7 +1,10 @@
+import { Seconds, Time } from '@matter/general';
 import { SmokeCoAlarmServer } from '@matter/node/behaviors/smoke-co-alarm';
+import { Status, StatusResponseError } from '@matter/types';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm, SmokeCoAlarm.Feature.CoAlarm) {
+    static selfTestDurationSeconds = 5;
     async selfTestRequest() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Testing SmokeCOAlarm (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -13,6 +16,37 @@ export class MatterbridgeSmokeCoAlarmServer extends SmokeCoAlarmServer.with(Smok
             endpoint: this.endpoint,
             context: this.context,
         });
+        if (this.state.expressedState !== SmokeCoAlarm.ExpressedState.Normal || this.state.testInProgress) {
+            throw new StatusResponseError('SmokeCOAlarm self-test is busy', Status.Busy);
+        }
+        this.state.testInProgress = true;
+        this.state.expressedState = SmokeCoAlarm.ExpressedState.Testing;
+        this.#scheduleSelfTestComplete();
         device.log.debug(`MatterbridgeSmokeCoAlarmServer: selfTestRequest called`);
     }
+    #stopSelfTestTimer() {
+        this.internal.selfTestTimer?.stop();
+        this.internal.selfTestTimer = undefined;
+    }
+    #scheduleSelfTestComplete() {
+        this.#stopSelfTestTimer();
+        this.internal.selfTestTimer = Time.getTimer('SmokeCOAlarm self-test complete', Seconds(MatterbridgeSmokeCoAlarmServer.selfTestDurationSeconds), this.callback(this.#completeSelfTest, { lock: true })).start();
+    }
+    #completeSelfTest() {
+        this.internal.selfTestTimer = undefined;
+        this.state.testInProgress = false;
+        this.state.expressedState = SmokeCoAlarm.ExpressedState.Normal;
+        this.events.selfTestComplete.emit(undefined, this.context);
+        this.events.allClear.emit(undefined, this.context);
+    }
+    async [Symbol.asyncDispose]() {
+        this.#stopSelfTestTimer();
+        await super[Symbol.asyncDispose]?.();
+    }
 }
+(function (MatterbridgeSmokeCoAlarmServer) {
+    class Internal {
+        selfTestTimer;
+    }
+    MatterbridgeSmokeCoAlarmServer.Internal = Internal;
+})(MatterbridgeSmokeCoAlarmServer || (MatterbridgeSmokeCoAlarmServer = {}));

package/dist/behaviors/thermostatServer.d.ts

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

package/dist/behaviors/thermostatServer.js

@@ -4,6 +4,41 @@ 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, Thermostat.Feature.ThermostatSuggestions) {
+    async initialize() {
+        await super.initialize();
+        this.reactTo(this.events.presets$AtomicChanged, this.removeThermostatSuggestionsForRemovedPresets);
+    }
+    removeThermostatSuggestionsForRemovedPresets(newPresets, oldPresets) {
+        const remainingPresetHandles = new Set();
+        for (const preset of newPresets) {
+            if (preset.presetHandle !== null)
+                remainingPresetHandles.add(Bytes.toHex(preset.presetHandle));
+        }
+        const removedPresetHandles = new Set();
+        for (const preset of oldPresets) {
+            if (preset.presetHandle !== null && !remainingPresetHandles.has(Bytes.toHex(preset.presetHandle))) {
+                removedPresetHandles.add(Bytes.toHex(preset.presetHandle));
+            }
+        }
+        if (removedPresetHandles.size === 0)
+            return;
+        const currentSuggestions = [...this.state.thermostatSuggestions];
+        const remainingSuggestions = currentSuggestions.filter((s) => !removedPresetHandles.has(Bytes.toHex(s.presetHandle)));
+        const currentSuggestion = this.state.currentThermostatSuggestion;
+        const clearCurrentSuggestion = currentSuggestion !== null && removedPresetHandles.has(Bytes.toHex(currentSuggestion.presetHandle));
+        if (remainingSuggestions.length === currentSuggestions.length && !clearCurrentSuggestion)
+            return;
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (remainingSuggestions.length !== currentSuggestions.length) {
+            device.log.info(`Removing ${currentSuggestions.length - remainingSuggestions.length} thermostat suggestion(s) referencing removed preset(s) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            this.state.thermostatSuggestions = remainingSuggestions;
+        }
+        if (clearCurrentSuggestion) {
+            device.log.info(`Clearing current thermostat suggestion referencing a removed preset (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            this.state.currentThermostatSuggestion = null;
+            this.state.thermostatSuggestionNotFollowingReason = null;
+        }
+    }
     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,6 +90,25 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
         this.state.activeScheduleHandle = Uint8Array.from(request.scheduleHandle);
         device.log.debug(`MatterbridgeThermostatServer: setActiveScheduleRequest completed with activeScheduleHandle: ${scheduleHandle}`);
     }
+    removeExpiredThermostatSuggestions() {
+        const now = Math.floor(Date.now() / 1000);
+        this.state.thermostatSuggestions = this.state.thermostatSuggestions.filter((s) => s.expirationTime > now);
+    }
+    reEvaluateCurrentThermostatSuggestion() {
+        const now = Math.floor(Date.now() / 1000);
+        let current = null;
+        for (const s of this.state.thermostatSuggestions) {
+            if (s.effectiveTime <= now && (current === null || s.effectiveTime < current.effectiveTime))
+                current = s;
+        }
+        if (this.state.currentThermostatSuggestion?.uniqueId === current?.uniqueId)
+            return;
+        this.state.currentThermostatSuggestion = current;
+        this.state.thermostatSuggestionNotFollowingReason = null;
+        if (current !== null) {
+            this.state.activePresetHandle = Uint8Array.from(current.presetHandle);
+        }
+    }
     async addThermostatSuggestion(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         const presetHandle = `0x${Buffer.from(request.presetHandle).toString('hex')}`;
@@ -70,6 +124,8 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
         if (this.state.presets.find((p) => p.presetHandle !== null && Bytes.areEqual(p.presetHandle, request.presetHandle)) === undefined) {
             throw new StatusResponse.NotFoundError('Requested PresetHandle not found');
         }
+        this.removeExpiredThermostatSuggestions();
+        this.reEvaluateCurrentThermostatSuggestion();
         if (this.state.thermostatSuggestions.length >= this.state.maxThermostatSuggestions) {
             throw new StatusResponse.ResourceExhaustedError('Maximum number of thermostat suggestions reached');
         }
@@ -89,6 +145,7 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
             expirationTime: effectiveTime + request.expirationInMinutes * 60,
         };
         this.state.thermostatSuggestions = [...this.state.thermostatSuggestions, suggestion];
+        this.reEvaluateCurrentThermostatSuggestion();
         device.log.debug(`MatterbridgeThermostatServer: addThermostatSuggestion completed with uniqueId: ${uniqueId}`);
         return { uniqueId };
     }
@@ -108,10 +165,8 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
             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;
-        }
+        this.removeExpiredThermostatSuggestions();
+        this.reEvaluateCurrentThermostatSuggestion();
         device.log.debug(`MatterbridgeThermostatServer: removeThermostatSuggestion completed for uniqueId: ${request.uniqueId}`);
     }
 }

package/dist/chipTest.d.ts

@@ -0,0 +1,10 @@
+import { GeneralDiagnosticsServer } from '@matter/node/behaviors/general-diagnostics';
+import type { GeneralDiagnostics } from '@matter/types/clusters/general-diagnostics';
+import type { Matterbridge } from './matterbridge.js';
+export declare const chipTestEnableKey: Uint8Array<ArrayBuffer>;
+export declare class MatterbridgeGeneralDiagnosticsServer extends GeneralDiagnosticsServer {
+    initialize(): void;
+    testEventTrigger({ eventTrigger, enableKey }: GeneralDiagnostics.TestEventTriggerRequest): Promise<void>;
+}
+export declare function createChipTestDevices(matterbridge: Matterbridge): Promise<void>;
+export declare function createChipTestAppPipe(matterbridge: Matterbridge): void;