@matterbridge/core 3.10.10-dev-20260915-57739b4 → 3.10.10-dev-20260917-79954cd

package/dist/behaviors/cameraAvSettingsUserLevelManagementServer.d.ts

@@ -1,17 +1,36 @@
 import { CameraAvSettingsUserLevelManagementServer } from '@matter/node/behaviors/camera-av-settings-user-level-management';
+import { type Viewport } from '@matter/types';
 import { CameraAvSettingsUserLevelManagement } from '@matter/types/clusters/camera-av-settings-user-level-management';
+import type { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeCameraAvSettingsUserLevelManagementServer_base: import("@matter/node").ClusterBehavior.Type<typeof CameraAvSettingsUserLevelManagementServer, import("@matter/types").ClusterType.WithSupportedFeatures<CameraAvSettingsUserLevelManagement, {
-    digitalPtz: false;
+    digitalPtz: true;
     mechanicalPan: true;
-    mechanicalPresets: false;
+    mechanicalPresets: true;
     mechanicalTilt: true;
     mechanicalZoom: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "cameraAvSettingsUserLevelManagement">;
 export declare class MatterbridgeCameraAvSettingsUserLevelManagementServer extends MatterbridgeCameraAvSettingsUserLevelManagementServer_base {
     readonly endpoint: MatterbridgeEndpoint;
+    protected internal: MatterbridgeCameraAvSettingsUserLevelManagementServer.Internal;
+    initialize(): void;
+    protected syncDptzStreams(allocatedVideoStreams: CameraAvStreamManagement.VideoStream[]): void;
+    protected syncDptzViewport(viewport: Viewport): void;
     mptzSetPosition(request: CameraAvSettingsUserLevelManagement.MptzSetPositionRequest): void;
     mptzRelativeMove(request: CameraAvSettingsUserLevelManagement.MptzRelativeMoveRequest): void;
+    mptzMoveToPreset(request: CameraAvSettingsUserLevelManagement.MptzMoveToPresetRequest): void;
+    mptzSavePreset(request: CameraAvSettingsUserLevelManagement.MptzSavePresetRequest): void;
+    mptzRemovePreset(request: CameraAvSettingsUserLevelManagement.MptzRemovePresetRequest): void;
+    private generatePresetId;
+    private dptzStreamEntry;
+    private applyDptzViewport;
+    dptzSetViewport(request: CameraAvSettingsUserLevelManagement.DptzSetViewportRequest): void;
+    dptzRelativeMove(request: CameraAvSettingsUserLevelManagement.DptzRelativeMoveRequest): void;
+}
+export declare namespace MatterbridgeCameraAvSettingsUserLevelManagementServer {
+    class Internal {
+        lastGeneratedPresetId: number;
+    }
 }
 export interface CameraAvSettingsUserLevelManagementClusterOptions {
     panMin: number;
@@ -20,6 +39,7 @@ export interface CameraAvSettingsUserLevelManagementClusterOptions {
     tiltMax: number;
     zoomMax: number;
     mptzPosition: CameraAvSettingsUserLevelManagement.Mptz;
+    maxPresets: number;
 }
 export declare function createDefaultCameraAvSettingsUserLevelManagementClusterServer(endpoint: MatterbridgeEndpoint, options: CameraAvSettingsUserLevelManagementClusterOptions): MatterbridgeEndpoint;
 export {};

package/dist/behaviors/cameraAvSettingsUserLevelManagementServer.js

@@ -1,11 +1,45 @@
 import { CameraAvSettingsUserLevelManagementServer } from '@matter/node/behaviors/camera-av-settings-user-level-management';
 import { Status, StatusResponseError } from '@matter/types';
 import { CameraAvSettingsUserLevelManagement } from '@matter/types/clusters/camera-av-settings-user-level-management';
+import { MatterbridgeCameraAvStreamManagementServer } from './cameraAvStreamManagementServer.js';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 function clamp(value, min, max) {
     return Math.min(Math.max(value, min), max);
 }
-export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends CameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom) {
+function viewportWidth(viewport) {
+    return viewport.x2 - viewport.x1;
+}
+function viewportHeight(viewport) {
+    return viewport.y2 - viewport.y1;
+}
+function sameAspectRatio(width, height, referenceWidth, referenceHeight) {
+    return width * referenceHeight === referenceWidth * height;
+}
+function viewportAt(x1, y1, width, height, sensorWidth, sensorHeight) {
+    const left = clamp(x1, 0, sensorWidth - width);
+    const top = clamp(y1, 0, sensorHeight - height);
+    return { x1: left, y1: top, x2: left + width, y2: top + height };
+}
+export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends CameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom, CameraAvSettingsUserLevelManagement.Feature.MechanicalPresets, CameraAvSettingsUserLevelManagement.Feature.DigitalPtz) {
+    initialize() {
+        const streamManagement = this.agent.get(MatterbridgeCameraAvStreamManagementServer);
+        this.syncDptzStreams(streamManagement.state.allocatedVideoStreams);
+        this.reactTo(streamManagement.events.allocatedVideoStreams$Changed, this.syncDptzStreams);
+        this.reactTo(streamManagement.events.viewport$Changed, this.syncDptzViewport);
+    }
+    syncDptzStreams(allocatedVideoStreams) {
+        const allocatedIds = allocatedVideoStreams.map((stream) => stream.videoStreamId);
+        const currentIds = this.state.dptzStreams.map((entry) => entry.videoStreamId);
+        if (allocatedIds.length === currentIds.length && allocatedIds.every((id, index) => id === currentIds[index]))
+            return;
+        const viewport = this.agent.get(MatterbridgeCameraAvStreamManagementServer).state.viewport;
+        this.state.dptzStreams = allocatedIds.map((videoStreamId) => this.state.dptzStreams.find((entry) => entry.videoStreamId === videoStreamId) ?? { videoStreamId, viewport });
+    }
+    syncDptzViewport(viewport) {
+        if (this.state.dptzStreams.length === 0)
+            return;
+        this.state.dptzStreams = this.state.dptzStreams.map((entry) => ({ videoStreamId: entry.videoStreamId, viewport }));
+    }
     mptzSetPosition(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         const { pan, tilt, zoom } = request;
@@ -42,11 +76,147 @@ export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends Camer
         device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: moved mechanical PTZ position by pan ${request.panDelta ?? 0}°, tilt ${request.tiltDelta ?? 0}°, zoom ${request.zoomDelta ?? 0} to pan ${pan}°, tilt ${tilt}°, zoom ${zoom} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzRelativeMove', request, this.context);
     }
+    mptzMoveToPreset(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { presetId } = request;
+        if (presetId < 1 || presetId > this.state.maxPresets) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is outside of the supported range [1, ${this.state.maxPresets}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        const preset = this.state.mptzPresets.find((entry) => entry.presetId === presetId);
+        if (preset === undefined) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is not present in mptzPresets (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        this.state.mptzPosition = preset.settings;
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: moved mechanical PTZ position to preset ${presetId} "${preset.name}": pan ${preset.settings.pan}°, tilt ${preset.settings.tilt}°, zoom ${preset.settings.zoom} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzMoveToPreset', request, this.context);
+    }
+    mptzSavePreset(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { presetId, name } = request;
+        if (name.length > 32) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: name "${name}" exceeds the maximum length of 32 characters (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (presetId !== undefined && (presetId < 1 || presetId > this.state.maxPresets)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is outside of the supported range [1, ${this.state.maxPresets}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (presetId !== undefined && this.state.mptzPresets.some((entry) => entry.presetId === presetId)) {
+            this.state.mptzPresets = this.state.mptzPresets.map((entry) => (entry.presetId === presetId ? { presetId, name, settings: this.state.mptzPosition } : entry));
+            device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: updated preset ${presetId} "${name}" with the current mechanical PTZ position (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzSavePreset', request, this.context);
+            return;
+        }
+        if (this.state.mptzPresets.length >= this.state.maxPresets) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: mptzPresets already holds the maximum of ${this.state.maxPresets} presets (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ResourceExhausted);
+        }
+        const newPresetId = presetId ?? this.generatePresetId();
+        this.state.mptzPresets = [...this.state.mptzPresets, { presetId: newPresetId, name, settings: this.state.mptzPosition }];
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: saved preset ${newPresetId} "${name}" with the current mechanical PTZ position (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzSavePreset', request, this.context);
+    }
+    mptzRemovePreset(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { presetId } = request;
+        if (presetId < 1 || presetId > this.state.maxPresets) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is outside of the supported range [1, ${this.state.maxPresets}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (!this.state.mptzPresets.some((entry) => entry.presetId === presetId)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is not present in mptzPresets (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        this.state.mptzPresets = this.state.mptzPresets.filter((entry) => entry.presetId !== presetId);
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: removed preset ${presetId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzRemovePreset', request, this.context);
+    }
+    generatePresetId() {
+        let presetId = (this.internal.lastGeneratedPresetId % this.state.maxPresets) + 1;
+        while (this.state.mptzPresets.some((entry) => entry.presetId === presetId)) {
+            presetId = (presetId % this.state.maxPresets) + 1;
+        }
+        this.internal.lastGeneratedPresetId = presetId;
+        return presetId;
+    }
+    dptzStreamEntry(videoStreamId) {
+        const entry = this.state.dptzStreams.find((stream) => stream.videoStreamId === videoStreamId);
+        if (entry === undefined) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: video stream ${videoStreamId} is not present in dptzStreams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        return entry;
+    }
+    applyDptzViewport(videoStreamId, viewport) {
+        this.state.dptzStreams = this.state.dptzStreams.map((entry) => (entry.videoStreamId === videoStreamId ? { videoStreamId, viewport } : entry));
+    }
+    dptzSetViewport(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { videoStreamId, viewport } = request;
+        const entry = this.dptzStreamEntry(videoStreamId);
+        const { videoSensorParams, minViewportResolution } = this.agent.get(MatterbridgeCameraAvStreamManagementServer).state;
+        const width = viewportWidth(viewport);
+        const height = viewportHeight(viewport);
+        if (width < minViewportResolution.width || height < minViewportResolution.height) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: viewport ${width}x${height} is smaller than the minimum viewport resolution ${minViewportResolution.width}x${minViewportResolution.height} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        if (viewport.x2 > videoSensorParams.sensorWidth ||
+            viewport.y2 > videoSensorParams.sensorHeight ||
+            width > videoSensorParams.sensorWidth ||
+            height > videoSensorParams.sensorHeight) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: viewport ${width}x${height} at (${viewport.x1}, ${viewport.y1}) does not fit the sensor ${videoSensorParams.sensorWidth}x${videoSensorParams.sensorHeight} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        if (!sameAspectRatio(width, height, viewportWidth(entry.viewport), viewportHeight(entry.viewport))) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: viewport ${width}x${height} does not match the aspect ratio of video stream ${videoStreamId} (${viewportWidth(entry.viewport)}x${viewportHeight(entry.viewport)}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        this.applyDptzViewport(videoStreamId, viewport);
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: set the viewport of video stream ${videoStreamId} to (${viewport.x1}, ${viewport.y1})-(${viewport.x2}, ${viewport.y2}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'dptzSetViewport', request, this.context);
+    }
+    dptzRelativeMove(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { videoStreamId, deltaX, deltaY, zoomDelta } = request;
+        const entry = this.dptzStreamEntry(videoStreamId);
+        const { videoSensorParams, minViewportResolution } = this.agent.get(MatterbridgeCameraAvStreamManagementServer).state;
+        const { sensorWidth, sensorHeight } = videoSensorParams;
+        const current = entry.viewport;
+        let x1 = current.x1 + (deltaX ?? 0);
+        let y1 = current.y1 + (deltaY ?? 0);
+        let width = viewportWidth(current);
+        let height = viewportHeight(current);
+        if (zoomDelta !== undefined && zoomDelta !== 0) {
+            const scaledWidth = Math.round((width * (100 - zoomDelta)) / 100);
+            const scaledHeight = Math.round((height * (100 - zoomDelta)) / 100);
+            x1 += Math.round((width - scaledWidth) / 2);
+            y1 += Math.round((height - scaledHeight) / 2);
+            width = scaledWidth;
+            height = scaledHeight;
+        }
+        const streamWidth = viewportWidth(current);
+        const streamHeight = viewportHeight(current);
+        if (!sameAspectRatio(width, height, streamWidth, streamHeight)) {
+            const clippedHeight = Math.round((width * streamHeight) / streamWidth);
+            if (clippedHeight <= height)
+                height = clippedHeight;
+            else
+                width = Math.round((height * streamWidth) / streamHeight);
+        }
+        width = Math.max(width, minViewportResolution.width);
+        height = Math.max(height, minViewportResolution.height);
+        width = Math.min(width, sensorWidth);
+        height = Math.min(height, sensorHeight);
+        const viewport = viewportAt(x1, y1, width, height, sensorWidth, sensorHeight);
+        this.applyDptzViewport(videoStreamId, viewport);
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: moved the viewport of video stream ${videoStreamId} by deltaX ${deltaX ?? 0}, deltaY ${deltaY ?? 0}, zoomDelta ${zoomDelta ?? 0} to (${viewport.x1}, ${viewport.y1})-(${viewport.x2}, ${viewport.y2}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'dptzRelativeMove', request, this.context);
+    }
 }
+(function (MatterbridgeCameraAvSettingsUserLevelManagementServer) {
+    class Internal {
+        lastGeneratedPresetId = 0;
+    }
+    MatterbridgeCameraAvSettingsUserLevelManagementServer.Internal = Internal;
+})(MatterbridgeCameraAvSettingsUserLevelManagementServer || (MatterbridgeCameraAvSettingsUserLevelManagementServer = {}));
 export function createDefaultCameraAvSettingsUserLevelManagementClusterServer(endpoint, options) {
-    endpoint.behaviors.require(MatterbridgeCameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom), {
+    endpoint.behaviors.require(MatterbridgeCameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom, CameraAvSettingsUserLevelManagement.Feature.MechanicalPresets, CameraAvSettingsUserLevelManagement.Feature.DigitalPtz), {
         ...options,
         movementState: CameraAvSettingsUserLevelManagement.PhysicalMovement.Idle,
+        mptzPresets: [],
+        dptzStreams: [],
     });
     return endpoint;
 }

package/dist/behaviors/cameraAvStreamManagementServer.js

@@ -185,6 +185,9 @@ export class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCame
         if (!this.state.allocatedVideoStreams.some((stream) => stream.videoStreamId === request.videoStreamId)) {
             throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: video stream ${request.videoStreamId} is not present in allocatedVideoStreams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
         }
+        if (this.state.allocatedVideoStreams.some((stream) => stream.videoStreamId === request.videoStreamId && stream.referenceCount > 0)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: video stream ${request.videoStreamId} is in use (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
+        }
         this.state.allocatedVideoStreams = this.state.allocatedVideoStreams.filter((stream) => stream.videoStreamId !== request.videoStreamId);
         device.log.info(`MatterbridgeCameraAvStreamManagementServer: deallocated video stream ${request.videoStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.endpoint.emitCommand(CameraAvStreamManagement, 'videoStreamDeallocate', request, this.context);
@@ -248,6 +251,9 @@ export class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCame
         if (!this.state.allocatedAudioStreams.some((stream) => stream.audioStreamId === request.audioStreamId)) {
             throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: audio stream ${request.audioStreamId} is not present in allocatedAudioStreams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
         }
+        if (this.state.allocatedAudioStreams.some((stream) => stream.audioStreamId === request.audioStreamId && stream.referenceCount > 0)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: audio stream ${request.audioStreamId} is in use (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
+        }
         this.state.allocatedAudioStreams = this.state.allocatedAudioStreams.filter((stream) => stream.audioStreamId !== request.audioStreamId);
         device.log.info(`MatterbridgeCameraAvStreamManagementServer: deallocated audio stream ${request.audioStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.endpoint.emitCommand(CameraAvStreamManagement, 'audioStreamDeallocate', request, this.context);

package/dist/behaviors/colorControlServer.js

@@ -1,11 +1,25 @@
 import { ColorControlServer } from '@matter/node/behaviors/color-control';
 import { ColorControl } from '@matter/types/clusters/color-control';
-import { MatterbridgeServer } from './matterbridgeServer.js';
+import { isSoftwareUpdateBoot, MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature, ColorControl.Feature.EnhancedHue) {
     initialize() {
         if (process.env.MATTERBRIDGE_CHIP_TEST)
             this.state.managedTransitionTimeHandling = true;
-        return super.initialize();
+        const result = super.initialize();
+        if (this.features.colorTemperature && !isSoftwareUpdateBoot(this.env)) {
+            const startUpMireds = this.state.startUpColorTemperatureMireds ?? null;
+            if (startUpMireds !== null) {
+                const crop = (mireds) => Math.min(Math.max(mireds, this.minimumColorTemperatureMireds), this.maximumColorTemperatureMireds);
+                const currentMireds = crop(this.state.colorTemperatureMireds);
+                const targetMireds = crop(startUpMireds);
+                if (targetMireds !== currentMireds) {
+                    this.state.colorMode = ColorControl.ColorMode.ColorTemperatureMireds;
+                    this.state.enhancedColorMode = ColorControl.EnhancedColorMode.ColorTemperatureMireds;
+                    this.state.colorTemperatureMireds = targetMireds;
+                }
+            }
+        }
+        return result;
     }
     async moveToHue(request) {
         if (process.env.MATTERBRIDGE_CHIP_TEST) {

package/dist/behaviors/levelControlServer.js

@@ -1,11 +1,20 @@
 import { LevelControlServer } from '@matter/node/behaviors/level-control';
 import { LevelControl } from '@matter/types/clusters/level-control';
-import { MatterbridgeServer } from './matterbridgeServer.js';
+import { isSoftwareUpdateBoot, MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeLevelControlServer extends LevelControlServer {
     initialize() {
         if (process.env.MATTERBRIDGE_CHIP_TEST)
             this.state.managedTransitionTimeHandling = true;
-        return super.initialize();
+        const result = super.initialize();
+        if (this.features.lighting && !isSoftwareUpdateBoot(this.env)) {
+            const state = this.state;
+            const startUpCurrentLevel = state.startUpCurrentLevel ?? null;
+            const currentLevel = state.currentLevel;
+            const targetLevel = startUpCurrentLevel === 0 ? this.minLevel : (startUpCurrentLevel ?? currentLevel);
+            if (targetLevel !== currentLevel)
+                state.currentLevel = targetLevel;
+        }
+        return result;
     }
     async moveToLevel(request) {
         if (process.env.MATTERBRIDGE_CHIP_TEST) {

package/dist/behaviors/matterbridgeServer.d.ts

@@ -1,6 +1,8 @@
+import type { Environment } from '@matter/general';
 import { Behavior } from '@matter/node';
 import type { AnsiLogger } from 'node-ansi-logger';
 import type { CommandHandler } from '../matterbridgeEndpointCommandHandler.js';
+export declare function isSoftwareUpdateBoot(env: Environment): boolean;
 export declare class MatterbridgeServer extends Behavior {
     static readonly id = "matterbridge";
     state: MatterbridgeServer.State;

package/dist/behaviors/matterbridgeServer.js

@@ -1,4 +1,12 @@
-import { Behavior } from '@matter/node';
+import { Behavior, ServerNode } from '@matter/node';
+import { GeneralDiagnosticsBehavior } from '@matter/node/behaviors/general-diagnostics';
+import { GeneralDiagnostics } from '@matter/types/clusters/general-diagnostics';
+export function isSoftwareUpdateBoot(env) {
+    const rootEndpoint = env.get(ServerNode);
+    if (!rootEndpoint.behaviors.has(GeneralDiagnosticsBehavior))
+        return false;
+    return rootEndpoint.stateOf(GeneralDiagnosticsBehavior).bootReason === GeneralDiagnostics.BootReason.SoftwareUpdateCompleted;
+}
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
     initialize() {

package/dist/behaviors/onOffServer.d.ts

@@ -1,3 +1,4 @@
+import type { MaybePromise } from '@matter/general';
 import { OnOffServer } from '@matter/node/behaviors/on-off';
 import { OnOff } from '@matter/types/clusters/on-off';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
@@ -16,6 +17,7 @@ declare const MatterbridgeOnOffServer_base: import("@matter/node").ClusterBehavi
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/on-off").OnOffBaseServer.Internal, "onOff">;
 export declare class MatterbridgeOnOffServer extends MatterbridgeOnOffServer_base {
     readonly endpoint: MatterbridgeEndpoint;
+    initialize(): MaybePromise;
     on(): Promise<void>;
     off(): Promise<void>;
     toggle(): Promise<void>;

package/dist/behaviors/onOffServer.js

@@ -1,7 +1,20 @@
 import { OnOffServer } from '@matter/node/behaviors/on-off';
 import { OnOff } from '@matter/types/clusters/on-off';
-import { MatterbridgeServer } from './matterbridgeServer.js';
+import { isSoftwareUpdateBoot, MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Lighting) {
+    initialize() {
+        const result = super.initialize();
+        if (this.features.lighting && !isSoftwareUpdateBoot(this.env)) {
+            const startUpOnOff = this.state.startUpOnOff ?? null;
+            if (startUpOnOff !== null) {
+                const currentOnOff = this.state.onOff;
+                const targetOnOff = startUpOnOff === OnOff.StartUpOnOff.Toggle ? !currentOnOff : startUpOnOff === OnOff.StartUpOnOff.On;
+                if (targetOnOff !== currentOnOff)
+                    this.state.onOff = targetOnOff;
+            }
+        }
+        return result;
+    }
     async on() {
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.on();

package/dist/behaviors/webRtcTransportProviderServer.d.ts

@@ -24,6 +24,7 @@ export declare namespace MatterbridgeWebRtcTransportProviderServer {
     class Internal {
         nextWebRtcSessionId: number;
         sessions: Map<number, WeriftWebRtcSession>;
+        trickledSessions: Set<number>;
     }
 }
 export declare function createDefaultWebRtcTransportProviderClusterServer(endpoint: MatterbridgeEndpoint, weriftOfferOptions?: WeriftOfferOptions): MatterbridgeEndpoint;

package/dist/behaviors/webRtcTransportProviderServer.js

@@ -32,6 +32,15 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
             });
         }, DEFERRED_INVOKE_DELAY_MS);
     }
+    async #trickleLocalIceCandidates(requestorEndpoint, webRtcSessionId, webRtcPeer) {
+        const iceCandidates = webRtcPeer.localIceCandidates;
+        if (iceCandidates.length === 0)
+            return;
+        await requestorEndpoint.commandsOf(WebRtcTransportRequestorClient).iceCandidates({ webRtcSessionId, iceCandidates });
+        this.endpoint
+            .stateOf(MatterbridgeServer)
+            .log.info(`MatterbridgeWebRtcTransportProviderServer: invoked ICECandidates with ${iceCandidates.length} local candidate(s) for session ${webRtcSessionId} on the peer's WebRtcTransportRequestor`);
+    }
     async #resolvePeerRequestorEndpoint(peerNodeId, fabricIndex, peerEndpointId) {
         try {
             const serverNode = Node.forEndpoint(this.endpoint);
@@ -208,6 +217,19 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
         }
         return true;
     }
+    #updateStreamReferenceCounts(videoStreams, audioStreams, change) {
+        if (!this.endpoint.behaviors.has(MatterbridgeCameraAvStreamManagementServer))
+            return;
+        const state = this.agent.get(MatterbridgeCameraAvStreamManagementServer).state;
+        for (const stream of state.allocatedVideoStreams) {
+            if (videoStreams?.includes(stream.videoStreamId))
+                stream.referenceCount = Math.max(0, stream.referenceCount + change);
+        }
+        for (const stream of state.allocatedAudioStreams) {
+            if (audioStreams?.includes(stream.audioStreamId))
+                stream.referenceCount = Math.max(0, stream.referenceCount + change);
+        }
+    }
     async solicitOffer(request) {
         this.#validateNoConflictingStreamFields(request);
         let videoStreams;
@@ -252,6 +274,7 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
             this.endpoint.emitCommand(WebRtcTransportProvider, 'solicitOffer', request, this.context);
             return { webRtcSessionId, deferredOffer: false, ...this.#echoDeprecatedStreamIds(request, videoStreams, audioStreams) };
         }
+        this.#updateStreamReferenceCounts(videoStreams, audioStreams, 1);
         const webRtcPeer = new WeriftWebRtcSession(webRtcSessionId, this.state.weriftOfferOptions);
         this.internal.sessions.set(webRtcSessionId, webRtcPeer);
         const sdp = await webRtcPeer.createOffer({
@@ -309,11 +332,11 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
                     fabricIndex,
                 },
             ];
-            const requestorEndpointForCapacityCheck = await this.#resolvePeerRequestorEndpoint(peerNodeId, fabricIndex, request.originatingEndpointId ?? EndpointNumber(0));
-            if (this.#evictIfOverCapacity(webRtcSessionId, requestorEndpointForCapacityCheck)) {
-                this.endpoint.emitCommand(WebRtcTransportProvider, 'provideOffer', request, this.context);
-                return { webRtcSessionId, ...this.#echoDeprecatedStreamIds(request, videoStreams, audioStreams) };
+            if (this.state.currentSessions.length > MAX_CONCURRENT_SESSIONS) {
+                this.state.currentSessions = this.state.currentSessions.filter((session) => session.id !== webRtcSessionId);
+                throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.provideOffer: cannot sustain more than MAX_CONCURRENT_SESSIONS (${MAX_CONCURRENT_SESSIONS}) concurrent webRTC sessions (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ResourceExhausted);
             }
+            this.#updateStreamReferenceCounts(videoStreams, audioStreams, 1);
         }
         else if (!this.state.currentSessions.some((session) => session.id === webRtcSessionId)) {
             throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.provideOffer: webRTC session ${webRtcSessionId} is not present in currentSessions (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
@@ -387,15 +410,27 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
                         `with ${String(error)} (endpoint ${endpointLabel})`);
                 }
             }));
+            const session = this.state.currentSessions.find((candidateSession) => candidateSession.id === request.webRtcSessionId);
+            if (session && !this.internal.trickledSessions.has(request.webRtcSessionId)) {
+                this.internal.trickledSessions.add(request.webRtcSessionId);
+                this.#invokeDeferred(async () => {
+                    const requestorEndpoint = await this.#resolvePeerRequestorEndpoint(session.peerNodeId, session.fabricIndex, session.peerEndpointId);
+                    if (requestorEndpoint)
+                        await this.#trickleLocalIceCandidates(requestorEndpoint, request.webRtcSessionId, webRtcPeer);
+                }, `ICECandidates for session ${request.webRtcSessionId}`);
+            }
         }
         this.endpoint.emitCommand(WebRtcTransportProvider, 'provideIceCandidates', request, this.context);
     }
     async endSession(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        if (!this.state.currentSessions.some((session) => session.id === request.webRtcSessionId)) {
+        const session = this.state.currentSessions.find((session) => session.id === request.webRtcSessionId);
+        if (!session) {
             throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.endSession: webRTC session ${request.webRtcSessionId} is not present in currentSessions (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
         }
+        this.#updateStreamReferenceCounts(session.videoStreams, session.audioStreams, -1);
         this.state.currentSessions = this.state.currentSessions.filter((session) => session.id !== request.webRtcSessionId);
+        this.internal.trickledSessions.delete(request.webRtcSessionId);
         const webRtcPeer = this.internal.sessions.get(request.webRtcSessionId);
         if (webRtcPeer) {
             this.internal.sessions.delete(request.webRtcSessionId);
@@ -413,6 +448,7 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
     class Internal {
         nextWebRtcSessionId = 0;
         sessions = new Map();
+        trickledSessions = new Set();
     }
     MatterbridgeWebRtcTransportProviderServer.Internal = Internal;
 })(MatterbridgeWebRtcTransportProviderServer || (MatterbridgeWebRtcTransportProviderServer = {}));

package/dist/behaviors/weriftSession.d.ts

@@ -29,9 +29,15 @@ export declare class WeriftWebRtcSession {
     private static readonly DIAGNOSTICS_INTERVAL_MS;
     private lastDiagnosticsCounters?;
     private readonly dtlsTransportsWithStateLogging;
+    private readonly gatheredIceCandidates;
     private static parseIcePortRange;
     private static parseIceAdditionalHostAddresses;
     constructor(webRtcSessionId: number, options: WeriftOfferOptions);
+    get localIceCandidates(): {
+        candidate: string;
+        sdpMid: string | null;
+        sdpmLineIndex: number | null;
+    }[];
     private summarizeSdp;
     private getFreeUdpPort;
     private getPreferredInjectableVideoCodec;

package/dist/behaviors/weriftSession.js

@@ -21,6 +21,7 @@ export class WeriftWebRtcSession {
     static DIAGNOSTICS_INTERVAL_MS = 10_000;
     lastDiagnosticsCounters;
     dtlsTransportsWithStateLogging = new Set();
+    gatheredIceCandidates = [];
     static parseIcePortRange() {
         const raw = process.env.MATTERBRIDGE_ICE_PORT_RANGE?.trim();
         if (!raw)
@@ -55,6 +56,9 @@ export class WeriftWebRtcSession {
         });
         this.peerConnection.onIceCandidate.subscribe((candidate) => {
             this.log.debug(candidate ? `Gathered local ICE candidate: ${candidate.candidate}` : 'ICE candidate gathering completed');
+            if (candidate) {
+                this.gatheredIceCandidates.push({ candidate: candidate.candidate, sdpMid: candidate.sdpMid ?? null, sdpmLineIndex: candidate.sdpMLineIndex ?? null });
+            }
         });
         this.peerConnection.iceConnectionStateChange.subscribe((state) => {
             this.log.info(`ICE connection state: ${state}`);
@@ -89,6 +93,9 @@ export class WeriftWebRtcSession {
             });
         }
     }
+    get localIceCandidates() {
+        return [...this.gatheredIceCandidates];
+    }
     summarizeSdp(sdp) {
         const mediaKinds = sdp
             .split('\n')

package/dist/chipTests.d.ts

@@ -7,4 +7,5 @@ export declare class MatterbridgeGeneralDiagnosticsServer extends GeneralDiagnos
     testEventTrigger({ eventTrigger, enableKey }: GeneralDiagnostics.TestEventTriggerRequest): Promise<void>;
     payloadTestRequest(request: GeneralDiagnostics.PayloadTestRequest): ReturnType<GeneralDiagnosticsServer['payloadTestRequest']>;
 }
+export declare function createChipTestRestartFlag(matterbridge: Matterbridge): void;
 export declare function createChipTestAppPipe(matterbridge: Matterbridge): void;

package/dist/chipTests.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { closeSync, constants, existsSync, openSync, readSync, unlinkSync } from 'node:fs';
+import { closeSync, constants, existsSync, openSync, readFileSync, readSync, unlinkSync } from 'node:fs';
 import { Seconds, Time } from '@matter/general';
 import { BasicInformationServer } from '@matter/node/behaviors/basic-information';
 import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
@@ -30,6 +30,8 @@ import { MatterbridgeRvcOperationalStateServer, MatterbridgeRvcRunModeServer } f
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { featuresFor } from './matterbridgeEndpointHelpers.js';
 const chipTestAppPipePath = '/tmp/matterbridge-chip-test-app-pipe';
+const chipTestRestartFlagPath = '/tmp/matterbridge-chip-test-restart-flag';
+const chipTestRestartFlagText = 'restart';
 const chipTestValidEventTrigger = 0xfffffffffff10000n;
 const smokeCoAlarmWarningSmokeAlarmTrigger = 0x005c000000000090n;
 const smokeCoAlarmCriticalSmokeAlarmTrigger = 0x005c00000000009cn;
@@ -101,6 +103,9 @@ export const chipTestEnableKey = Uint8Array.from({ length: 16 }, (_, index) => i
 const smokeCoAlarmChipTestEnableKey = Uint8Array.from([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
 let chipTestMatterbridge;
 let closeChipTestAppPipe;
+let chipTestRestartFlagTimer;
+let chipTestRestartPending = false;
+let chipTestRestartFlagWarned = false;
 let electricalPowerMeasurementFakeLoadTimer;
 let chipTestActiveEndpointId;
 export class MatterbridgeGeneralDiagnosticsServer extends GeneralDiagnosticsServer {
@@ -130,6 +135,65 @@ export class MatterbridgeGeneralDiagnosticsServer extends GeneralDiagnosticsServ
         return super.payloadTestRequest(request);
     }
 }
+function removeChipTestRestartFlag(log) {
+    try {
+        if (existsSync(chipTestRestartFlagPath))
+            unlinkSync(chipTestRestartFlagPath);
+    }
+    catch (error) {
+        log.error(`Failed to remove CHIP test restart flag ${chipTestRestartFlagPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function createChipTestRestartFlag(matterbridge) {
+    if (chipTestRestartPending) {
+        const onOnline = (nodeId) => {
+            if (nodeId !== 'Matterbridge')
+                return;
+            matterbridge.off('online', onOnline);
+            removeChipTestRestartFlag(matterbridge.log);
+            chipTestRestartPending = false;
+            matterbridge.log.notice(`CHIP test restart completed, cleared restart flag ${chipTestRestartFlagPath}`);
+        };
+        matterbridge.on('online', onOnline);
+    }
+    if (chipTestRestartFlagTimer)
+        return;
+    matterbridge.log.notice(`CHIP test restart flag monitor watching ${chipTestRestartFlagPath}`);
+    chipTestRestartFlagTimer = setInterval(() => {
+        const instance = chipTestMatterbridge;
+        if (!instance || chipTestRestartPending || !existsSync(chipTestRestartFlagPath))
+            return;
+        let flagText;
+        try {
+            flagText = readFileSync(chipTestRestartFlagPath, 'utf8').trim();
+        }
+        catch (error) {
+            instance.log.error(`Failed to read CHIP test restart flag ${chipTestRestartFlagPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        if (flagText !== chipTestRestartFlagText) {
+            if (!chipTestRestartFlagWarned) {
+                chipTestRestartFlagWarned = true;
+                instance.log.warn(`Ignoring unsupported CHIP test restart flag content "${flagText}": only "${chipTestRestartFlagText}" is implemented`);
+            }
+            return;
+        }
+        chipTestRestartFlagWarned = false;
+        chipTestRestartPending = true;
+        instance.log.notice(`CHIP test restart requested via ${chipTestRestartFlagPath}, restarting Matterbridge...`);
+        instance.restartProcess().catch((error) => {
+            chipTestRestartPending = false;
+            instance.log.error(`Failed to restart Matterbridge for the CHIP test restart flag: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }, 250);
+    chipTestRestartFlagTimer.unref();
+    cliEmitter.once('shutdown', () => {
+        if (chipTestRestartFlagTimer)
+            clearInterval(chipTestRestartFlagTimer);
+        chipTestRestartFlagTimer = undefined;
+        removeChipTestRestartFlag(matterbridge.log);
+    });
+}
 function isChipTestEnableKey(keyData) {
     return equalsBytes(keyData, chipTestEnableKey) || equalsBytes(keyData, smokeCoAlarmChipTestEnableKey);
 }

package/dist/cli.js

@@ -180,6 +180,7 @@ function help() {
       --fixed_delay [seconds]: set a fixed delay in seconds before starting Matterbridge (default 120)
       --no-ansi:               disable ANSI color output in the logs
       --reset-sessions:        reset sessions and resumption records on shutdown (use only if your controller has issue reconnecting on restart)
+      --configuration-version: increment by one the configuration version of all the server nodes when they go online (add a value to set it instead, i.e. --configuration-version 5)
   `);
     process.exit(0);
 }

package/dist/demoDevices.js

@@ -160,6 +160,7 @@ export async function createDemoDevices(matterbridge) {
         author: 'https://github.com/Luligu',
         enabled: false,
         private: true,
+        configurationVersion: 1,
         registeredDevices: 0,
         configJson: demoPluginConfig,
         schemaJson: demoPluginSchema,

package/dist/devices/camera.d.ts

@@ -30,6 +30,7 @@ export interface CameraOptions extends MatterbridgeEndpointOptions {
     tiltMax?: number;
     zoomMax?: number;
     mptzPosition?: CameraAvSettingsUserLevelManagement.Mptz;
+    maxPresets?: number;
     weriftOfferOptions?: WeriftOfferOptions;
 }
 export declare class Camera extends MatterbridgeEndpoint {

package/dist/devices/camera.js

@@ -17,7 +17,7 @@ export class Camera extends MatterbridgeEndpoint {
             { resolution: { width: 640, height: 480 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
             { resolution: { width: 1280, height: 720 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
             { resolution: { width: 1920, height: 1080 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
-        ], panMin = -170, panMax = 170, tiltMin = -20, tiltMax = 90, zoomMax = 10, mptzPosition = { pan: 0, tilt: 0, zoom: 1 }, weriftOfferOptions, id, number, tagList, mode, } = options;
+        ], panMin = -170, panMax = 170, tiltMin = -20, tiltMax = 90, zoomMax = 10, mptzPosition = { pan: 0, tilt: 0, zoom: 1 }, maxPresets = 5, weriftOfferOptions, id, number, tagList, mode, } = options;
         super(powerSourceType === 'None' ? [camera] : [camera, powerSource], { id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, number, tagList, mode });
         if (identifyType !== Identify.IdentifyType.None) {
             this.createDefaultIdentifyClusterServer(identifyTime, identifyType);
@@ -56,7 +56,7 @@ export class Camera extends MatterbridgeEndpoint {
             snapshotCapabilities,
         });
         if (ptz)
-            createDefaultCameraAvSettingsUserLevelManagementClusterServer(this, { panMin, panMax, tiltMin, tiltMax, zoomMax, mptzPosition });
+            createDefaultCameraAvSettingsUserLevelManagementClusterServer(this, { panMin, panMax, tiltMin, tiltMax, zoomMax, mptzPosition, maxPresets });
         createDefaultWebRtcTransportProviderClusterServer(this, weriftOfferOptions);
         addWebRtcTransportRequestorClient(this);
         this.addRequiredClusters();

package/dist/frontend.js

@@ -1268,6 +1268,7 @@ export class Frontend extends EventEmitter {
                 name: plugin.name,
                 version: plugin.version,
                 private: plugin.private,
+                configurationVersion: plugin.configurationVersion,
                 description: plugin.description,
                 author: plugin.author,
                 homepage: plugin.homepage,

package/dist/matterNode.js

@@ -10,7 +10,7 @@ import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/brid
 import { PowerSourceServer } from '@matter/node/behaviors/power-source';
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
 import { MdnsService, PaseClient } from '@matter/protocol';
-import { DeviceTypeId, VendorId } from '@matter/types';
+import { DeviceTypeId, EndpointNumber, VendorId } from '@matter/types';
 import { PowerSource } from '@matter/types/clusters/power-source';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg } from '@matterbridge/types';
@@ -19,7 +19,7 @@ import { copyDirectory } from '@matterbridge/utils/copy-dir';
 import { getErrorMessage, inspectError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidInteger, isValidString, parseVersionString } from '@matterbridge/utils/validate';
-import { wait, withTimeout } from '@matterbridge/utils/wait';
+import { fireAndForget, wait, withTimeout } from '@matterbridge/utils/wait';
 import { AnsiLogger, BLUE, CYAN, db, debugStringify, er, nf, or, zb } from 'node-ansi-logger';
 import { NodeStorageManager } from 'node-persist-manager';
 import { toBaseDevice } from './deviceManager.js';
@@ -471,7 +471,7 @@ export class MatterNode extends EventEmitter {
                         status: PowerSource.PowerSourceStatus.Active,
                         order: 0,
                         description: 'AC Power',
-                        endpointList: [],
+                        endpointList: [EndpointNumber(0)],
                         wiredCurrentType: PowerSource.WiredCurrentType.Ac,
                     },
                 }
@@ -490,6 +490,13 @@ export class MatterNode extends EventEmitter {
         });
         serverNode.lifecycle.online.on(() => {
             this.log.notice(`Server node for ${storeId} is online`);
+            this.log.info(`Configuration version for server node ${storeId} is ${serverNode.state.basicInformation.configurationVersion}`);
+            if (hasParameter('configuration-version')) {
+                let configurationVersion = getIntParameter('configuration-version') ?? serverNode.state.basicInformation.configurationVersion + 1;
+                configurationVersion = Math.min(Math.max(configurationVersion, 1), UINT32_MAX);
+                fireAndForget(serverNode.setStateOf(BasicInformationServer, { configurationVersion }), this.log, `Failed to set configuration version for server node ${storeId}`);
+                this.log.notice(`Configuration version for server node ${storeId} is now ${configurationVersion}`);
+            }
             if (!serverNode.lifecycle.isCommissioned) {
                 this.log.notice(`Server node for ${storeId} is not commissioned. Pair to commission ...`);
                 this.advertisingNodes.set(storeId, Date.now());
@@ -640,7 +647,7 @@ export class MatterNode extends EventEmitter {
         if (!plugin.locked) {
             plugin.locked = true;
             this.log.debug(`Creating dynamic plugin ${plg}${plugin.name}${db} server node...`);
-            this.matterStorageContext = await this.createServerNodeContext(plugin.name, plugin.description, this.aggregatorDeviceType, this.aggregatorVendorId, this.aggregatorVendorName, this.aggregatorProductId, this.aggregatorProductName, undefined, undefined, parseVersionString(this.matterbridge.matterbridgeVersion), this.matterbridge.matterbridgeVersion, parseVersionString(this.matterbridge.systemInformation.osRelease), this.matterbridge.systemInformation.osRelease, plugin.description, plugin.homepage ?? 'https://matterbridge.io', 1);
+            this.matterStorageContext = await this.createServerNodeContext(plugin.name, plugin.description, this.aggregatorDeviceType, this.aggregatorVendorId, this.aggregatorVendorName, this.aggregatorProductId, this.aggregatorProductName, undefined, undefined, parseVersionString(this.matterbridge.matterbridgeVersion), this.matterbridge.matterbridgeVersion, parseVersionString(this.matterbridge.systemInformation.osRelease), this.matterbridge.systemInformation.osRelease, plugin.description, plugin.homepage ?? 'https://matterbridge.io', plugin.configurationVersion);
             this.serverNode = await this.createServerNode(this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
             this.log.debug(`Creating dynamic plugin ${plg}${plugin.name}${db} aggregator node...`);
             this.aggregatorNode = await this.createAggregatorNode();

package/dist/matterbridge.js

@@ -12,7 +12,7 @@ import { PowerSourceServer } from '@matter/node/behaviors/power-source';
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
 import { PaseClient } from '@matter/protocol';
 import { PowerSource } from '@matter/types/clusters/power-source';
-import { DeviceTypeId, VendorId } from '@matter/types/datatype';
+import { DeviceTypeId, EndpointNumber, VendorId } from '@matter/types/datatype';
 import { ManualPairingCodeCodec } from '@matter/types/schema';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, typ } from '@matterbridge/types';
@@ -1248,6 +1248,10 @@ export class Matterbridge extends EventEmitter {
         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 device of this.devices.array()) {
+            if (device.serverNode)
+                await device.serverNode.setStateOf(BasicInformationServer, { configurationVersion: device.serverNode.state.basicInformation.configurationVersion + 1 });
+        }
         for (const plugin of this.plugins.array()) {
             if (plugin.error || !plugin.enabled)
                 continue;
@@ -1570,8 +1574,9 @@ export class Matterbridge extends EventEmitter {
             this.log.warn(' ***********************************************************************************');
             this.log.warn(' * MATTERBRIDGE_CHIP_TEST environment variable is set. Running chip test app pipe. *');
             this.log.warn(' ***********************************************************************************');
-            const { createChipTestAppPipe } = await import('./chipTests.js');
+            const { createChipTestAppPipe, createChipTestRestartFlag } = await import('./chipTests.js');
             createChipTestAppPipe(this);
+            createChipTestRestartFlag(this);
         }
         await this.startPlugins(false, true);
         this.log.debug('Starting start matter interval in bridge mode...');
@@ -1943,7 +1948,7 @@ export class Matterbridge extends EventEmitter {
                         status: PowerSource.PowerSourceStatus.Active,
                         order: 0,
                         description: 'AC Power',
-                        endpointList: [],
+                        endpointList: [EndpointNumber(0)],
                         wiredCurrentType: PowerSource.WiredCurrentType.Ac,
                     },
                 }
@@ -1964,6 +1969,13 @@ export class Matterbridge extends EventEmitter {
         });
         serverNode.lifecycle.online.on(() => {
             this.log.notice(`Server node for ${storeId} is online`);
+            this.log.info(`Configuration version for server node ${storeId} is ${serverNode.state.basicInformation.configurationVersion}`);
+            if (hasParameter('configuration-version')) {
+                let configurationVersion = getIntParameter('configuration-version') ?? serverNode.state.basicInformation.configurationVersion + 1;
+                configurationVersion = Math.min(Math.max(configurationVersion, 1), UINT32_MAX);
+                fireAndForget(serverNode.setStateOf(BasicInformationServer, { configurationVersion }), this.log, `Failed to set configuration version for server node ${storeId}`);
+                this.log.notice(`Configuration version for server node ${storeId} is now ${configurationVersion}`);
+            }
             if (serverNode.lifecycle.isCommissioned) {
                 this.log.notice(`Server node for ${storeId} is already commissioned.`);
                 this.advertisingNodes.delete(storeId);
@@ -2075,7 +2087,7 @@ export class Matterbridge extends EventEmitter {
         if (!plugin.locked) {
             plugin.locked = true;
             this.log.debug(`Creating dynamic plugin ${plg}${plugin.name}${db} server node...`);
-            plugin.storageContext = await this.createServerNodeContext(plugin.name, plugin.description, this.aggregatorDeviceType, this.aggregatorVendorId, this.aggregatorVendorName, this.aggregatorProductId, this.aggregatorProductName, undefined, undefined, parseVersionString(this.matterbridgeVersion), this.matterbridgeVersion, parseVersionString(this.systemInformation.osRelease), this.systemInformation.osRelease, plugin.description, plugin.homepage ?? 'https://matterbridge.io', 1);
+            plugin.storageContext = await this.createServerNodeContext(plugin.name, plugin.description, this.aggregatorDeviceType, this.aggregatorVendorId, this.aggregatorVendorName, this.aggregatorProductId, this.aggregatorProductName, undefined, undefined, parseVersionString(this.matterbridgeVersion), this.matterbridgeVersion, parseVersionString(this.systemInformation.osRelease), this.systemInformation.osRelease, plugin.description, plugin.homepage ?? 'https://matterbridge.io', plugin.configurationVersion);
             plugin.serverNode = await this.createServerNode(plugin.storageContext, this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
             this.log.debug(`Creating dynamic plugin ${plg}${plugin.name}${db} aggregator node...`);
             plugin.aggregatorNode = await this.createAggregatorNode(plugin.storageContext);

package/dist/matterbridgeEndpoint.d.ts

@@ -172,11 +172,11 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     createOffOnlyOnOffClusterServer(onOff?: boolean): this;
     createDefaultLevelControlClusterServer(currentLevel?: number, minLevel?: number, maxLevel?: number, onLevel?: number | null, startUpCurrentLevel?: number | null): this;
     createLevelControlClusterServer(currentLevel?: number, onLevel?: number | null): this;
-    createDefaultColorControlClusterServer(currentX?: number, currentY?: number, currentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
-    createEnhancedColorControlClusterServer(currentX?: number, currentY?: number, enhancedCurrentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
-    createXyColorControlClusterServer(currentX?: number, currentY?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
-    createHsColorControlClusterServer(currentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
-    createCtColorControlClusterServer(colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
+    createDefaultColorControlClusterServer(currentX?: number, currentY?: number, currentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number, startUpColorTemperatureMireds?: number | null): this;
+    createEnhancedColorControlClusterServer(currentX?: number, currentY?: number, enhancedCurrentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number, startUpColorTemperatureMireds?: number | null): this;
+    createXyColorControlClusterServer(currentX?: number, currentY?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number, startUpColorTemperatureMireds?: number | null): this;
+    createHsColorControlClusterServer(currentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number, startUpColorTemperatureMireds?: number | null): this;
+    createCtColorControlClusterServer(colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number, startUpColorTemperatureMireds?: number | null): this;
     configureColorControlMode(colorMode: ColorControl.ColorMode): Promise<void>;
     configureEnhancedColorControlMode(colorMode: ColorControl.EnhancedColorMode): Promise<void>;
     createDefaultWindowCoveringClusterServer(positionPercent100ths?: number | null, type?: WindowCovering.WindowCoveringType, endProductType?: WindowCovering.EndProductType, movementDuration?: number): this;

package/dist/matterbridgeEndpoint.js

@@ -720,7 +720,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultColorControlClusterServer(currentX = 0, currentY = 0, currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+    createDefaultColorControlClusterServer(currentX = 0, currentY = 0, currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500, startUpColorTemperatureMireds = null) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
             enhancedColorMode: ColorControl.EnhancedColorMode.CurrentHueAndCurrentSaturation,
@@ -737,12 +737,12 @@ export class MatterbridgeEndpoint extends Endpoint {
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
             coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
-            startUpColorTemperatureMireds: null,
+            startUpColorTemperatureMireds,
             remainingTime: 0,
         });
         return this;
     }
-    createEnhancedColorControlClusterServer(currentX = 0, currentY = 0, enhancedCurrentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+    createEnhancedColorControlClusterServer(currentX = 0, currentY = 0, enhancedCurrentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500, startUpColorTemperatureMireds = null) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
             enhancedColorMode: ColorControl.EnhancedColorMode.EnhancedCurrentHueAndCurrentSaturation,
@@ -760,12 +760,12 @@ export class MatterbridgeEndpoint extends Endpoint {
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
             coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
-            startUpColorTemperatureMireds: null,
+            startUpColorTemperatureMireds,
             remainingTime: 0,
         });
         return this;
     }
-    createXyColorControlClusterServer(currentX = 0, currentY = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+    createXyColorControlClusterServer(currentX = 0, currentY = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500, startUpColorTemperatureMireds = null) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentXAndCurrentY,
             enhancedColorMode: ColorControl.EnhancedColorMode.CurrentXAndCurrentY,
@@ -780,12 +780,12 @@ export class MatterbridgeEndpoint extends Endpoint {
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
             coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
-            startUpColorTemperatureMireds: null,
+            startUpColorTemperatureMireds,
             remainingTime: 0,
         });
         return this;
     }
-    createHsColorControlClusterServer(currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+    createHsColorControlClusterServer(currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500, startUpColorTemperatureMireds = null) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
             enhancedColorMode: ColorControl.EnhancedColorMode.CurrentHueAndCurrentSaturation,
@@ -800,12 +800,12 @@ export class MatterbridgeEndpoint extends Endpoint {
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
             coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
-            startUpColorTemperatureMireds: null,
+            startUpColorTemperatureMireds,
             remainingTime: 0,
         });
         return this;
     }
-    createCtColorControlClusterServer(colorTemperatureMireds = 250, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+    createCtColorControlClusterServer(colorTemperatureMireds = 250, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500, startUpColorTemperatureMireds = null) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.ColorTemperatureMireds,
             enhancedColorMode: ColorControl.EnhancedColorMode.ColorTemperatureMireds,
@@ -818,7 +818,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
             coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
-            startUpColorTemperatureMireds: null,
+            startUpColorTemperatureMireds,
             remainingTime: 0,
         });
         return this;

package/dist/pluginManager.js

@@ -357,6 +357,7 @@ export class PluginManager extends EventEmitter {
             author: plugin.author,
             enabled: plugin.enabled,
             private: plugin.private,
+            configurationVersion: plugin.configurationVersion,
         };
     }
     toApiPlugin(plugin) {
@@ -368,6 +369,7 @@ export class PluginManager extends EventEmitter {
             path: plugin.path,
             type: plugin.type,
             private: plugin.private,
+            configurationVersion: plugin.configurationVersion,
             latestVersion: plugin.latestVersion,
             devVersion: plugin.devVersion,
             homepage: plugin.homepage,
@@ -432,7 +434,7 @@ export class PluginManager extends EventEmitter {
         }
         const pluginsArray = await this.matterbridge.nodeContext.get('plugins', []);
         for (const plugin of pluginsArray)
-            this._plugins.set(plugin.name, { ...plugin, private: plugin.private ?? false });
+            this._plugins.set(plugin.name, { ...plugin, private: plugin.private ?? false, configurationVersion: plugin.configurationVersion ?? 1 });
         this.log.debug(`Loaded ${BLUE}${pluginsArray.length}${db} plugins from storage`);
         return pluginsArray;
     }
@@ -454,6 +456,7 @@ export class PluginManager extends EventEmitter {
                 enabled: plugin.enabled,
                 private: plugin.private,
                 tarballPath: plugin.tarballPath,
+                configurationVersion: plugin.configurationVersion,
             });
         }
         await this.matterbridge.nodeContext.set('plugins', plugins);
@@ -823,6 +826,7 @@ export class PluginManager extends EventEmitter {
                 type: 'AnyPlatform',
                 version: packageJson.version,
                 private: packageJson.private || false,
+                configurationVersion: 1,
                 description: packageJson.description,
                 author: this.getAuthor(packageJson),
                 homepage: this.getHomepage(packageJson),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.10-dev-20260915-57739b4",
+  "version": "3.10.10-dev-20260917-79954cd",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -136,10 +136,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.10-dev-20260915-57739b4",
-    "@matterbridge/thread": "3.10.10-dev-20260915-57739b4",
-    "@matterbridge/types": "3.10.10-dev-20260915-57739b4",
-    "@matterbridge/utils": "3.10.10-dev-20260915-57739b4",
+    "@matterbridge/dgram": "3.10.10-dev-20260917-79954cd",
+    "@matterbridge/thread": "3.10.10-dev-20260917-79954cd",
+    "@matterbridge/types": "3.10.10-dev-20260917-79954cd",
+    "@matterbridge/utils": "3.10.10-dev-20260917-79954cd",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",