@matterbridge/core 3.10.14-dev-20261013-e87a0c8 → 3.10.14-dev-20261014-2811fdc

package/dist/backend.d.ts

@@ -34,8 +34,8 @@ export declare class Backend extends EventEmitter<BackendEvents> {
     stop(): Promise<void>;
     getApiSettings(): Promise<ApiSettings>;
     getApiPlugins(): Promise<ApiPlugin[]>;
-    getApiDevices(pluginName?: string): Promise<ApiDevice[]>;
-    getApiCluster(pluginName: string, endpointNumber: number, serialNumber?: string, uniqueId?: string): Promise<ApiClusters | undefined>;
+    getApiDevices(pluginName?: string, extended?: boolean): Promise<ApiDevice[]>;
+    getApiCluster(pluginName: string, number: number, serialNumber: string, uniqueId: string): Promise<ApiClusters>;
     generateDiagnostic(): Promise<void>;
     getApiMatter(id: string): Promise<ApiMatter | undefined>;
 }

package/dist/backend.js

@@ -341,19 +341,25 @@ export class Backend extends EventEmitter {
             writeDiagnostic('Backend', `getApiPlugins() took ${(performance.now() - start).toFixed(2)} ms`);
         return response.result.plugins;
     }
-    async getApiDevices(pluginName) {
+    async getApiDevices(pluginName, extended = false) {
         const start = performance.now();
-        const response = await this.server.fetch({ type: 'devices_apidevicearray', src: 'frontend', dst: 'devices', params: { pluginName } });
+        const response = await this.server.fetch({ type: 'devices_apidevicearray', src: 'frontend', dst: 'devices', params: { pluginName, extended } });
         if (this.diagnostic)
             writeDiagnostic('Backend', `getApiDevices() took ${(performance.now() - start).toFixed(2)} ms`);
         return response.result.devices;
     }
-    async getApiCluster(pluginName, endpointNumber, serialNumber, uniqueId) {
+    async getApiCluster(pluginName, number, serialNumber, uniqueId) {
         const start = performance.now();
-        this.log.debug(`Retrieving API cluster for plugin: ${pluginName}, endpoint: ${endpointNumber}, serial: ${serialNumber}, uniqueId: ${uniqueId}`);
+        this.log.debug(`Retrieving API cluster for plugin: ${pluginName}, number: ${number}, serial: ${serialNumber}, uniqueId: ${uniqueId}`);
+        const response = await this.server.fetch({
+            type: 'platform_get_apiclusters',
+            src: 'frontend',
+            dst: 'platform',
+            params: { pluginName, number, serialNumber, uniqueId },
+        });
         if (this.diagnostic)
             writeDiagnostic('Backend', `getApiCluster() took ${(performance.now() - start).toFixed(2)} ms`);
-        return undefined;
+        return response.result.clusters;
     }
     async generateDiagnostic() {
         const start = performance.now();

package/dist/backendWsServer.js

@@ -209,22 +209,30 @@ export class BackendWsServer {
             }
             else if (data.method === '/api/devices') {
                 const start = performance.now();
-                const devices = await this.backend.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
+                const devices = await this.backend.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined, data.params.extended);
                 if (this.diagnostic)
                     writeDiagnostic(`Frontend:${data.sender}`, `getApiDevices() took ${(performance.now() - start).toFixed(2)} ms`);
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: devices });
             }
             else if (data.method === '/api/clusters') {
-                if (!isValidString(data.params.plugin, 10)) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/clusters' });
+                if (!isValidString(data.params.pluginName, 10)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/clusters' });
                     return;
                 }
-                if (!isValidNumber(data.params.endpoint, 1)) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' });
+                if (!isValidNumber(data.params.number, 1)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter number in /api/clusters' });
+                    return;
+                }
+                if (!isValidString(data.params.serialNumber, 1)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter serialNumber in /api/clusters' });
+                    return;
+                }
+                if (!isValidString(data.params.uniqueId, 1)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter uniqueId in /api/clusters' });
                     return;
                 }
                 const start = performance.now();
-                const clusters = await this.backend.getApiCluster(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
+                const clusters = await this.backend.getApiCluster(data.params.pluginName, data.params.number, data.params.serialNumber, data.params.uniqueId);
                 if (this.diagnostic)
                     writeDiagnostic(`Frontend:${data.sender}`, `getApiCluster() took ${(performance.now() - start).toFixed(2)} ms`);
                 if (clusters) {

package/dist/behaviors/weriftSession.d.ts

@@ -44,6 +44,9 @@ export declare class WeriftWebRtcSession {
     private getPreferredInjectableAudioCodec;
     private static readonly SUPPORTED_VIDEO_RESOLUTIONS;
     private static readonly DEFAULT_BITRATE_KBPS;
+    private static readonly DEFAULT_TEST_VIDEO_FPS;
+    private static readonly MAX_TEST_VIDEO_FPS;
+    private getTestVideoFps;
     private getConfiguredVideoBitrate;
     private getConfiguredVideoResolution;
     private getConfiguredVideoSource;

package/dist/behaviors/weriftSession.js

@@ -146,6 +146,19 @@ export class WeriftWebRtcSession {
     }
     static SUPPORTED_VIDEO_RESOLUTIONS = ['640x480', '1280x720', '1920x1080'];
     static DEFAULT_BITRATE_KBPS = 1000;
+    static DEFAULT_TEST_VIDEO_FPS = 30;
+    static MAX_TEST_VIDEO_FPS = 60;
+    getTestVideoFps() {
+        const raw = process.env.MATTERBRIDGE_TEST_VIDEO_FPS?.trim();
+        if (!raw)
+            return WeriftWebRtcSession.DEFAULT_TEST_VIDEO_FPS;
+        const fps = Number(raw);
+        if (!/^\d+$/.test(raw) || fps < 1 || fps > WeriftWebRtcSession.MAX_TEST_VIDEO_FPS) {
+            this.log.warn(`Invalid MATTERBRIDGE_TEST_VIDEO_FPS "${raw}" (supported: 1-${WeriftWebRtcSession.MAX_TEST_VIDEO_FPS}); falling back to ${WeriftWebRtcSession.DEFAULT_TEST_VIDEO_FPS}`);
+            return WeriftWebRtcSession.DEFAULT_TEST_VIDEO_FPS;
+        }
+        return fps;
+    }
     getConfiguredVideoBitrate() {
         const configured = this.options.videoBitrate;
         if (configured === undefined)
@@ -185,13 +198,12 @@ export class WeriftWebRtcSession {
     }
     buildFfmpegVideoInputArgs(videoSource) {
         if (videoSource === 'test') {
-            const testPatternInput = {
-                args: ['-re', '-f', 'lavfi', '-i', 'testsrc=size=640x480:rate=10'],
-                description: 'synthetic moving test pattern',
-                bitrateKbps: WeriftWebRtcSession.DEFAULT_BITRATE_KBPS,
-            };
-            this.log.debug(`Test pattern params: resolution=640x480, description="${testPatternInput.description}", bitrateKbps=${testPatternInput.bitrateKbps}`);
-            return testPatternInput;
+            const resolution = this.getConfiguredVideoResolution();
+            const bitrateKbps = this.getConfiguredVideoBitrate();
+            const fps = this.getTestVideoFps();
+            const description = `synthetic moving test pattern (${resolution}, ${fps}fps)`;
+            this.log.debug(`Test pattern params: resolution=${resolution}, fps=${fps}, description="${description}", bitrateKbps=${bitrateKbps}`);
+            return { args: ['-re', '-f', 'lavfi', '-i', `testsrc=size=${resolution}:rate=${fps}`], description, bitrateKbps, keyFrameInterval: fps * 2 };
         }
         const device = this.options.videoSourceDevice;
         if (!device) {
@@ -203,17 +215,17 @@ export class WeriftWebRtcSession {
         if (videoSource === 'rtsp') {
             const description = `RTSP camera (${device}, ${resolution})`;
             this.log.debug(`RTSP capture params: url=${device}, resolution=${resolution}, description="${description}", bitrateKbps=${bitrateKbps}`);
-            return { args: ['-rtsp_transport', 'tcp', '-i', device, '-vf', `scale=${resolution.replace('x', ':')}`], description, bitrateKbps };
+            return { args: ['-rtsp_transport', 'tcp', '-i', device, '-vf', `scale=${resolution.replace('x', ':')}`], description, bitrateKbps, keyFrameInterval: 20 };
         }
         const description = `local webcam (${device}, ${resolution})`;
         this.log.debug(`Webcam capture params: device=${device}, resolution=${resolution}, description="${description}", bitrateKbps=${bitrateKbps}`);
         switch (process.platform) {
             case 'linux':
-                return { args: ['-f', 'v4l2', '-video_size', resolution, '-framerate', '30', '-i', device], description, bitrateKbps };
+                return { args: ['-f', 'v4l2', '-video_size', resolution, '-framerate', '30', '-i', device], description, bitrateKbps, keyFrameInterval: 20 };
             case 'darwin':
-                return { args: ['-f', 'avfoundation', '-video_size', resolution, '-framerate', '30', '-i', device], description, bitrateKbps };
+                return { args: ['-f', 'avfoundation', '-video_size', resolution, '-framerate', '30', '-i', device], description, bitrateKbps, keyFrameInterval: 20 };
             case 'win32':
-                return { args: ['-f', 'dshow', '-video_size', resolution, '-framerate', '30', '-i', `video=${device}`], description, bitrateKbps };
+                return { args: ['-f', 'dshow', '-video_size', resolution, '-framerate', '30', '-i', `video=${device}`], description, bitrateKbps, keyFrameInterval: 20 };
             default:
                 this.log.error(`Webcam capture via ffmpeg is not supported on platform "${process.platform}"; not injecting a video track`);
                 return undefined;
@@ -252,9 +264,27 @@ export class WeriftWebRtcSession {
             });
             this.peerConnection.addTrack(track);
             const bitrate = `${videoInput.bitrateKbps}k`;
+            const keyFrameInterval = String(videoInput.keyFrameInterval);
             const encoderArgs = selectedMimeType === 'video/h264'
-                ? ['-c:v', 'libx264', '-preset', 'ultrafast', '-tune', 'zerolatency', '-pix_fmt', 'yuv420p', '-g', '20', '-b:v', bitrate, '-maxrate', bitrate, '-bufsize', bitrate]
-                : ['-c:v', 'libvpx', '-deadline', 'realtime', '-cpu-used', '4', '-pix_fmt', 'yuv420p', '-g', '20', '-b:v', bitrate, '-maxrate', bitrate, '-bufsize', bitrate];
+                ? [
+                    '-c:v',
+                    'libx264',
+                    '-preset',
+                    'ultrafast',
+                    '-tune',
+                    'zerolatency',
+                    '-pix_fmt',
+                    'yuv420p',
+                    '-g',
+                    keyFrameInterval,
+                    '-b:v',
+                    bitrate,
+                    '-maxrate',
+                    bitrate,
+                    '-bufsize',
+                    bitrate,
+                ]
+                : ['-c:v', 'libvpx', '-deadline', 'realtime', '-cpu-used', '4', '-pix_fmt', 'yuv420p', '-g', keyFrameInterval, '-b:v', bitrate, '-maxrate', bitrate, '-bufsize', bitrate];
             const ffmpegArgs = [
                 '-hide_banner',
                 '-loglevel',

package/dist/demoDevices.js

@@ -883,6 +883,7 @@ export async function createDemoDevices(matterbridge) {
         id: 'Intercom',
         number: EndpointNumber(16_04),
         identifyType: Identify.IdentifyType.VisibleIndicator,
+        switchOptions: { number: EndpointNumber(16_04_2) },
         weriftOfferOptions: { offerVideo: false, offerAudio: true, videoSource: 'none', audioSource: 'test' },
     });
     await registerDevice(ep, 'Intercom I', 'CAMERA-16-04');
@@ -890,6 +891,7 @@ export async function createDemoDevices(matterbridge) {
         id: 'IntercomII',
         number: EndpointNumber(16_04_1),
         identifyType: Identify.IdentifyType.VisibleIndicator,
+        switchOptions: { number: EndpointNumber(16_04_1_2) },
         weriftOfferOptions: { offerVideo: false, offerAudio: true, videoSource: 'none', audioSource: 'test' },
     });
     await registerDevice(ep, 'Intercom II', 'CAMERA-16-04-1');

package/dist/deviceManager.d.ts

@@ -20,7 +20,7 @@ export declare class DeviceManager {
     private toBaseDevice;
     array(): MatterbridgeEndpoint[];
     baseArray(pluginName?: string): BaseDevice[];
-    apiDeviceArray(pluginName?: string): ApiDevice[];
+    apiDeviceArray(pluginName?: string, extended?: boolean): ApiDevice[];
     [Symbol.iterator](): IterableIterator<MatterbridgeEndpoint>;
     forEach(callback: (device: MatterbridgeEndpoint) => Promise<void>): Promise<void>;
     set logLevel(logLevel: LogLevel);

package/dist/deviceManager.js

@@ -71,7 +71,7 @@ export class DeviceManager {
                     this.server.respond({ ...msg, result: { devices: this.baseArray(msg.params.pluginName) } });
                     break;
                 case 'devices_apidevicearray':
-                    this.server.respond({ ...msg, result: { devices: this.apiDeviceArray(msg.params.pluginName) } });
+                    this.server.respond({ ...msg, result: { devices: this.apiDeviceArray(msg.params.pluginName, msg.params.extended) } });
                     break;
                 default:
                     if (this.verbose)
@@ -124,12 +124,12 @@ export class DeviceManager {
         }
         return devices;
     }
-    apiDeviceArray(pluginName) {
+    apiDeviceArray(pluginName, extended) {
         const devices = [];
         for (const device of this._devices.values()) {
             if (pluginName && pluginName !== device.plugin)
                 continue;
-            const apiDevice = toApiDevice(device);
+            const apiDevice = toApiDevice(device, extended);
             if (apiDevice)
                 devices.push(apiDevice);
         }

package/dist/devices/batteryStorage.d.ts

@@ -9,6 +9,7 @@ export interface BatteryStorageOptions {
     tagList?: Semtag[];
     batPercentRemaining?: number;
     batChargeLevel?: PowerSource.BatChargeLevel;
+    batCapacity?: number;
     voltage?: number | bigint | null;
     current?: number | bigint | null;
     power?: number | bigint | null;

package/dist/devices/batteryStorage.js

@@ -31,7 +31,7 @@ export class BatteryStorage extends MatterbridgeEndpoint {
         const battery = this.addChildDeviceType('Battery', [powerSource, electricalSensor], {
             tagList: [getSemtag(PowerSourceTag.Battery)],
         })
-            .createDefaultPowerSourceRechargeableBatteryClusterServer(options.batPercentRemaining ?? 100, options.batChargeLevel ?? PowerSource.BatChargeLevel.Ok, 24_000)
+            .createDefaultPowerSourceRechargeableBatteryClusterServer(options.batPercentRemaining ?? 100, options.batChargeLevel ?? PowerSource.BatChargeLevel.Ok, 24_000, PowerSource.BatReplaceability.Unspecified, options.batCapacity ?? 200_000, null, null, [])
             .createDefaultPowerTopologyClusterServer()
             .createDefaultElectricalEnergyMeasurementClusterServer(options.energyImported ?? null, options.energyExported ?? null);
         battery.behaviors.require(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.DirectCurrent), getDefaultElectricalPowerMeasurementClusterServer(options.voltage ?? null, options.current ?? null, options.power ?? null));

package/dist/devices/intercom.d.ts

@@ -1,9 +1,17 @@
 import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
 import { Identify } from '@matter/types/clusters/identify';
-import { StreamUsage } from '@matter/types/globals';
+import type { EndpointNumber } from '@matter/types/datatype';
+import { type Semtag, StreamUsage } from '@matter/types/globals';
 import type { WeriftOfferOptions } from '../behaviors/weriftSession.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+export interface IntercomSwitchOptions {
+    name?: string;
+    tagList?: Semtag[];
+    number?: EndpointNumber;
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+}
 export interface IntercomOptions extends MatterbridgeEndpointOptions {
     identifyTime?: number;
     identifyType?: Identify.IdentifyType;
@@ -16,7 +24,9 @@ export interface IntercomOptions extends MatterbridgeEndpointOptions {
     speakerCapabilities?: CameraAvStreamManagement.AudioCapabilities;
     twoWayTalkSupport?: CameraAvStreamManagement.TwoWayTalkSupportType;
     weriftOfferOptions?: WeriftOfferOptions;
+    switchOptions?: IntercomSwitchOptions;
 }
 export declare class Intercom extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: IntercomOptions);
+    addSwitch(name: string, options?: IntercomSwitchOptions): MatterbridgeEndpoint;
 }

package/dist/devices/intercom.js

@@ -5,11 +5,11 @@ import { createDefaultIntercomCameraAvStreamManagementClusterServer } from '../b
 import { addChimeClient, addWebRtcTransportProviderClient, addWebRtcTransportRequestorClient } from '../behaviors/clients.js';
 import { createDefaultWebRtcTransportProviderClusterServer } from '../behaviors/webRtcTransportProviderServer.js';
 import { createDefaultWebRtcTransportRequestorClusterServer } from '../behaviors/webRtcTransportRequestorServer.js';
-import { intercom, powerSource } from '../matterbridgeDeviceTypes.js';
+import { genericSwitch, intercom, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class Intercom extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
-        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', maxContentBufferSize = 65_536, maxNetworkBandwidth = 128_000, supportedStreamUsages = [StreamUsage.LiveView], streamUsagePriorities = supportedStreamUsages, microphoneCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, speakerCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, twoWayTalkSupport = CameraAvStreamManagement.TwoWayTalkSupportType.FullDuplex, weriftOfferOptions, id, number, tagList, mode, } = options;
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', maxContentBufferSize = 65_536, maxNetworkBandwidth = 128_000, supportedStreamUsages = [StreamUsage.LiveView], streamUsagePriorities = supportedStreamUsages, microphoneCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, speakerCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, twoWayTalkSupport = CameraAvStreamManagement.TwoWayTalkSupportType.FullDuplex, weriftOfferOptions, switchOptions = {}, id, number, tagList, mode, } = options;
         super(powerSourceType === 'None' ? [intercom] : [intercom, powerSource], {
             id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
             number,
@@ -51,5 +51,16 @@ export class Intercom extends MatterbridgeEndpoint {
         addWebRtcTransportRequestorClient(this);
         addChimeClient(this);
         this.addRequiredClusters();
+        const { name: switchName = 'Switch', tagList: switchTagList = [], number: switchNumber, identifyTime: switchIdentifyTime = 0, identifyType: switchIdentifyType = Identify.IdentifyType.None, } = switchOptions;
+        this.addSwitch(switchName, { tagList: switchTagList, number: switchNumber, identifyTime: switchIdentifyTime, identifyType: switchIdentifyType });
+    }
+    addSwitch(name, options = {}) {
+        const { tagList = [], number, identifyTime = 0, identifyType = Identify.IdentifyType.None } = options;
+        const switchChild = this.addChildDeviceType(name, genericSwitch, { number, ...(tagList.length > 0 ? { tagList } : {}) });
+        switchChild.log.logName = name;
+        switchChild.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        switchChild.createDefaultMomentarySwitchClusterServer();
+        switchChild.addRequiredClusters();
+        return switchChild;
     }
 }

package/dist/frontend.d.ts

@@ -40,8 +40,8 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     stop(): Promise<void>;
     getApiSettings(): ApiSettings;
     getApiPlugins(): ApiPlugin[];
-    getApiDevices(pluginName?: string): ApiDevice[];
-    getApiCluster(pluginName: string, endpointNumber: number, serialNumber?: string, uniqueId?: string): ApiClusters | undefined;
+    getApiDevices(pluginName?: string, extended?: boolean): ApiDevice[];
+    getApiCluster(pluginName: string, endpointNumber: number, serialNumber: string, uniqueId: string): ApiClusters | undefined;
     generateDiagnostic(): Promise<void>;
     private wsMessageHandler;
     wssSendLogMessage(level: string, time: string, name: string, message: string): void;

package/dist/frontend.js

@@ -15,10 +15,9 @@ import { formatBytes, formatPercent, formatUptime } from '@matterbridge/utils/fo
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidArray, isValidBoolean, isValidNumber, isValidObject, isValidString } from '@matterbridge/utils/validate';
 import { fireAndForget, wait, withTimeout } from '@matterbridge/utils/wait';
-import { AnsiLogger, bgHex, CYAN, db, debugStringify, er, GREEN, nf, nt, rs, stringify, UNDERLINE, UNDERLINEOFF, wr, YELLOW } from 'node-ansi-logger';
+import { AnsiLogger, bgHex, CYAN, db, debugStringify, er, GREEN, nf, nt, rs, UNDERLINE, UNDERLINEOFF, wr, YELLOW } from 'node-ansi-logger';
 import { generateHistoryPage } from './cliHistory.js';
-import { capitalizeFirstLetter } from './matterbridgeEndpointHelpers.js';
-import { deleteAdvertisingNode, getBatteryLevel, getClusterTextFromDevice, getPowerSource, getReachability, getServerNodeData, setAdvertisingNode } from './matterNodeHelpers.js';
+import { deleteAdvertisingNode, getBatteryLevel, getClusterTextFromDevice, getPowerSource, getReachability, getServerNodeData, setAdvertisingNode, toApiClusters, } from './matterNodeHelpers.js';
 logModuleLoaded('Frontend');
 function sendDownloadError(res, error, message) {
     if (error.code === 'ECONNABORTED' || res.headersSent)
@@ -40,10 +39,10 @@ export class Frontend extends EventEmitter {
     webSocketServer;
     server;
     serverFetchTimeout = 2000;
-    debug = hasParameter('debug') || hasParameter('verbose');
-    verbose = hasParameter('verbose');
-    diagnostic = hasParameter('diagnostic');
-    readOnly = hasParameter('readonly') || hasParameter('shelly');
+    debug = hasAnyParameter('debug', 'debug-frontend', 'verbose', 'verbose-frontend');
+    verbose = hasAnyParameter('verbose', 'verbose-frontend');
+    diagnostic = hasAnyParameter('diagnostic', 'diagnostic-frontend');
+    readOnly = hasParameter('readonly');
     restartRequired = false;
     fixedRestartRequired = false;
     updateRequired = false;
@@ -531,7 +530,7 @@ export class Frontend extends EventEmitter {
             this.log.debug('The frontend sent /api/devices');
             if (!this.validateReq(req, res))
                 return;
-            res.json(this.getApiDevices());
+            res.json(this.getApiDevices(undefined, true));
         });
         this.expressApp.get('/api/view-mblog', async (req, res) => {
             this.log.debug('The frontend sent /api/view-mblog');
@@ -1007,7 +1006,7 @@ export class Frontend extends EventEmitter {
         }
         return plugins;
     }
-    getApiDevices(pluginName) {
+    getApiDevices(pluginName, extended = false) {
         if (this.matterbridge.hasCleanupStarted)
             return [];
         const devices = [];
@@ -1026,11 +1025,11 @@ export class Frontend extends EventEmitter {
                 productUrl: device.productUrl,
                 configUrl: device.configUrl,
                 uniqueId: device.uniqueId,
-                reachable: getReachability(device),
-                powerSource: getPowerSource(device),
-                batteryLevel: getBatteryLevel(device),
-                matter: device.mode === 'server' && device.serverNode ? getServerNodeData(device.serverNode) : undefined,
-                cluster: getClusterTextFromDevice(device),
+                reachable: extended ? getReachability(device) : true,
+                powerSource: extended ? getPowerSource(device) : undefined,
+                batteryLevel: extended ? getBatteryLevel(device) : undefined,
+                matter: extended && device.mode === 'server' && device.serverNode ? getServerNodeData(device.serverNode) : undefined,
+                cluster: extended ? getClusterTextFromDevice(device) : '',
             });
         }
         return devices;
@@ -1040,64 +1039,12 @@ export class Frontend extends EventEmitter {
             return;
         const endpoint = this.matterbridge.devices
             .array()
-            .find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber && (!serialNumber || d.serialNumber === serialNumber) && (!uniqueId || d.uniqueId === uniqueId));
-        if (!endpoint?.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber) {
-            this.log.error(`getApiCluster: no device found for plugin ${pluginName} and endpoint number ${endpointNumber} (serial: ${serialNumber ?? 'N/A'}, uniqueId: ${uniqueId ?? 'N/A'})`);
+            .find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber && d.serialNumber === serialNumber && d.uniqueId === uniqueId);
+        if (!endpoint?.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber || !endpoint.uniqueId) {
+            this.log.error(`getApiCluster: no device found for plugin ${pluginName} and endpoint number ${endpointNumber} (serial: ${serialNumber}, uniqueId: ${uniqueId})`);
             return;
         }
-        const deviceTypes = [];
-        const clusters = [];
-        endpoint.state.descriptor.deviceTypeList.forEach((d) => {
-            deviceTypes.push(d.deviceType);
-        });
-        endpoint.forEachAttribute((clusterName, clusterId, attributeName, attributeId, attributeValue) => {
-            if (typeof attributeValue === 'undefined' || attributeValue === undefined)
-                return;
-            if (clusterName === 'EveHistory' && ['configDataGet', 'configDataSet', 'historyStatus', 'historyEntries', 'historyRequest', 'historySetTime', 'rLoc'].includes(attributeName))
-                return;
-            clusters.push({
-                endpoint: endpoint.number.toString(),
-                number: endpoint.number,
-                id: 'main',
-                deviceTypes,
-                clusterName: capitalizeFirstLetter(clusterName),
-                clusterId: '0x' + clusterId.toString(16).padStart(2, '0'),
-                attributeName,
-                attributeId: '0x' + attributeId.toString(16).padStart(2, '0'),
-                attributeValue: typeof attributeValue === 'object' ? stringify(attributeValue) : attributeValue.toString(),
-                attributeLocalValue: attributeValue,
-            });
-        });
-        const childEndpoints = endpoint.getChildEndpoints();
-        childEndpoints.forEach((childEndpoint) => {
-            if (!childEndpoint.maybeId || !childEndpoint.maybeNumber) {
-                this.log.error(`getApiCluster: no child endpoint found for plugin ${pluginName} and endpoint number ${endpointNumber}`);
-                return;
-            }
-            const deviceTypes = [];
-            childEndpoint.state.descriptor.deviceTypeList.forEach((d) => {
-                deviceTypes.push(d.deviceType);
-            });
-            childEndpoint.forEachAttribute((clusterName, clusterId, attributeName, attributeId, attributeValue) => {
-                if (typeof attributeValue === 'undefined' || attributeValue === undefined)
-                    return;
-                if (clusterName === 'EveHistory' && ['configDataGet', 'configDataSet', 'historyStatus', 'historyEntries', 'historyRequest', 'historySetTime', 'rLoc'].includes(attributeName))
-                    return;
-                clusters.push({
-                    endpoint: childEndpoint.number.toString(),
-                    number: childEndpoint.number,
-                    id: childEndpoint.id,
-                    deviceTypes,
-                    clusterName: capitalizeFirstLetter(clusterName),
-                    clusterId: '0x' + clusterId.toString(16).padStart(2, '0'),
-                    attributeName,
-                    attributeId: '0x' + attributeId.toString(16).padStart(2, '0'),
-                    attributeValue: typeof attributeValue === 'object' ? stringify(attributeValue) : attributeValue.toString(),
-                    attributeLocalValue: attributeValue,
-                });
-            });
-        });
-        return { plugin: endpoint.plugin, deviceName: endpoint.deviceName, serialNumber: endpoint.serialNumber, number: endpoint.number, id: endpoint.id, deviceTypes, clusters };
+        return toApiClusters(endpoint, this.log);
     }
     async generateDiagnostic() {
         this.log.debug('Generating diagnostic...');
@@ -1493,24 +1440,32 @@ export class Frontend extends EventEmitter {
             }
             else if (data.method === '/api/devices') {
                 const start = performance.now();
-                const devices = this.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
+                const devices = this.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined, data.params.extended);
                 if (this.diagnostic)
                     writeDiagnostic(`Frontend:${data.sender}`, `getApiDevices() took ${(performance.now() - start).toFixed(2)} ms`);
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: devices });
             }
             else if (data.method === '/api/clusters') {
-                if (!isValidString(data.params.plugin, 10)) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/clusters' });
+                if (!isValidString(data.params.pluginName, 10)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/clusters' });
+                    return;
+                }
+                if (!isValidNumber(data.params.number, 1)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter number in /api/clusters' });
+                    return;
+                }
+                if (!isValidString(data.params.serialNumber, 1)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter serialNumber in /api/clusters' });
                     return;
                 }
-                if (!isValidNumber(data.params.endpoint, 1)) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' });
+                if (!isValidString(data.params.uniqueId, 1)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter uniqueId in /api/clusters' });
                     return;
                 }
                 const start = performance.now();
-                const clusters = this.getApiCluster(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
+                const clusters = this.getApiCluster(data.params.pluginName, data.params.number, data.params.serialNumber, data.params.uniqueId);
                 if (this.diagnostic)
-                    writeDiagnostic(`Frontend:${data.sender}`, `getApiCluster() took ${(performance.now() - start).toFixed(2)} ms`);
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiCluster(${data.params.pluginName}, ${data.params.number}, ${data.params.serialNumber}, ${data.params.uniqueId}) took ${(performance.now() - start).toFixed(2)} ms`);
                 if (clusters) {
                     sendResponse({
                         id: data.id,

package/dist/matterNode.js

@@ -97,7 +97,7 @@ export class MatterNode extends EventEmitter {
         this.environment.vars.set('path.root', path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR));
         this.environment.vars.set('runtime.signals', false);
         this.environment.vars.set('runtime.exitcode', false);
-        this.environment.vars.set('endpoint.validation', 'strict');
+        this.environment.vars.set('endpoint.validation', 'warn');
         if (this.mdnsInterface)
             this.environment.vars.set('mdns.networkInterface', this.mdnsInterface);
         if (this.verbose)

package/dist/matterNodeHelpers.d.ts

@@ -1,9 +1,11 @@
 import { ServerNode, type SessionsBehavior } from '@matter/node';
 import type { ExposedFabricInformation } from '@matter/protocol';
-import type { ApiDevice, ApiMatter, BaseDevice, SanitizedExposedFabricInformation, SanitizedSession } from '@matterbridge/types';
+import type { ApiClusters, ApiDevice, ApiMatter, BaseDevice, SanitizedExposedFabricInformation, SanitizedSession } from '@matterbridge/types';
+import { type AnsiLogger } from 'node-ansi-logger';
 import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+export declare function toApiClusters(endpoint: MatterbridgeEndpoint, log: AnsiLogger): ApiClusters | undefined;
 export declare function toBaseDevice(device: MatterbridgeEndpoint | BaseDevice): BaseDevice;
-export declare function toApiDevice(device: MatterbridgeEndpoint): ApiDevice | undefined;
+export declare function toApiDevice(device: MatterbridgeEndpoint, extended?: boolean): ApiDevice | undefined;
 export declare function getReachability(device: MatterbridgeEndpoint): boolean;
 export declare function getPowerSource(endpoint: MatterbridgeEndpoint): 'ac' | 'dc' | 'ok' | 'warning' | 'critical' | undefined;
 export declare function getBatteryLevel(endpoint: MatterbridgeEndpoint): number | undefined;

package/dist/matterNodeHelpers.js

@@ -11,15 +11,55 @@ import { OperationalState } from '@matter/types/clusters/operational-state';
 import { PowerSource } from '@matter/types/clusters/power-source';
 import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-state';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
-import { SoilMeasurement } from '@matter/types/clusters/soil-measurement';
 import { UserLabel } from '@matter/types/clusters/user-label';
 import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
 import { ThreeLevelAuto } from '@matter/types/globals';
 import { getEnumDescription } from '@matterbridge/utils/enum';
 import { isValidArray, isValidNumber, isValidObject } from '@matterbridge/utils/validate';
 import { stringify } from 'node-ansi-logger';
-import { featuresFor, getAttribute } from './matterbridgeEndpointHelpers.js';
+import { capitalizeFirstLetter, featuresFor, getAttribute, getSnapshot } from './matterbridgeEndpointHelpers.js';
 const advertisingNodes = new Map();
+export function toApiClusters(endpoint, log) {
+    if (!endpoint.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber || !endpoint.uniqueId)
+        return undefined;
+    const deviceTypes = getSnapshot(endpoint.state.descriptor.deviceTypeList).map((deviceType) => deviceType.deviceType);
+    const clusters = [];
+    for (const current of [endpoint, ...endpoint.getChildEndpoints()]) {
+        if (!current.maybeId || !current.maybeNumber) {
+            log.error(`getApiCluster: no child endpoint found for plugin ${endpoint.plugin} and endpoint number ${endpoint.number}`);
+            continue;
+        }
+        const currentDeviceTypes = current === endpoint ? deviceTypes : getSnapshot(current.state.descriptor.deviceTypeList).map((deviceType) => deviceType.deviceType);
+        current.forEachAttribute((clusterName, clusterId, attributeName, attributeId, attributeValue) => {
+            if (attributeValue === undefined)
+                return;
+            if (clusterName === 'EveHistory' && ['configDataGet', 'configDataSet', 'historyStatus', 'historyEntries', 'historyRequest', 'historySetTime', 'rLoc'].includes(attributeName))
+                return;
+            clusters.push({
+                endpoint: current.number.toString(),
+                number: current.number,
+                id: current === endpoint ? 'main' : current.id,
+                deviceTypes: currentDeviceTypes,
+                clusterName: capitalizeFirstLetter(clusterName),
+                clusterId: '0x' + clusterId.toString(16).padStart(2, '0'),
+                attributeName,
+                attributeId: '0x' + attributeId.toString(16).padStart(2, '0'),
+                attributeValue: typeof attributeValue === 'object' ? stringify(attributeValue) : attributeValue.toString(),
+                attributeLocalValue: getSnapshot(attributeValue),
+            });
+        });
+    }
+    return {
+        plugin: endpoint.plugin,
+        deviceName: endpoint.deviceName,
+        serialNumber: endpoint.serialNumber,
+        uniqueId: endpoint.uniqueId,
+        number: endpoint.number,
+        id: endpoint.id,
+        deviceTypes,
+        clusters,
+    };
+}
 export function toBaseDevice(device) {
     return {
         mode: device.mode,
@@ -48,7 +88,7 @@ export function toBaseDevice(device) {
         id: device.id,
     };
 }
-export function toApiDevice(device) {
+export function toApiDevice(device, extended = false) {
     if (!device.plugin || !device.deviceType || !device.name || !device.deviceName || !device.serialNumber || !device.uniqueId || !device.lifecycle.isReady)
         return undefined;
     return {
@@ -61,11 +101,11 @@ export function toApiDevice(device) {
         productUrl: device.productUrl,
         configUrl: device.configUrl,
         uniqueId: device.uniqueId,
-        reachable: getReachability(device),
-        powerSource: getPowerSource(device),
-        batteryLevel: getBatteryLevel(device),
-        matter: device.mode === 'server' && device.serverNode ? getServerNodeData(device.serverNode) : undefined,
-        cluster: getClusterTextFromDevice(device),
+        reachable: extended ? getReachability(device) : true,
+        powerSource: extended ? getPowerSource(device) : undefined,
+        batteryLevel: extended ? getBatteryLevel(device) : undefined,
+        matter: extended && device.mode === 'server' && device.serverNode ? getServerNodeData(device.serverNode) : undefined,
+        cluster: extended ? getClusterTextFromDevice(device) : '',
     };
 }
 export function getReachability(device) {
@@ -301,7 +341,7 @@ export function getClusterTextFromDevice(device) {
             appendMeasurement('Pressure', getMeasurementText(attributeValue, 1, ' hPa'));
         if (clusterName === 'flowMeasurement' && attributeName === 'measuredValue')
             appendMeasurement('Flow', getMeasurementText(attributeValue, 10, ' m³/h'));
-        if (clusterId === SoilMeasurement.id && attributeName === 'soilMoistureMeasuredValue')
+        if (clusterName === 'soilMeasurement' && attributeName === 'soilMoistureMeasuredValue')
             appendMeasurement('Soil moisture', getMeasurementText(attributeValue, 1, '%'));
         if (clusterName === 'electricalPowerMeasurement' && attributeName === 'voltage')
             appendMeasurement('Voltage', getMeasurementText(attributeValue, 1_000, 'V'));

package/dist/matterbridge.js

@@ -460,7 +460,7 @@ export class Matterbridge extends EventEmitter {
         this.environment.vars.set('path.root', path.join(this.matterbridgeDirectory, MATTER_STORAGE_DIR));
         this.environment.vars.set('runtime.signals', false);
         this.environment.vars.set('runtime.exitcode', false);
-        this.environment.vars.set('endpoint.validation', 'strict');
+        this.environment.vars.set('endpoint.validation', 'warn');
         this.registerProcessHandlers();
         try {
             this.log.debug(`Creating node storage manager: ${CYAN}${NODE_STORAGE_DIR}${db}`);

package/dist/matterbridgeEndpoint.d.ts

@@ -151,7 +151,7 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     createDefaultPowerSourceWiredClusterServer(wiredCurrentType?: PowerSource.WiredCurrentType): this;
     createDefaultPowerSourceBatteryClusterServer(batPercentRemaining?: null | number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: null | number, batReplaceability?: PowerSource.BatReplaceability): this;
     createDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining?: number | null, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number | null, batReplacementDescription?: string, batQuantity?: number, batReplaceability?: PowerSource.BatReplaceability): this;
-    createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining?: number | null, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number | null, batReplaceability?: PowerSource.BatReplaceability): this;
+    createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining?: number | null, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number | null, batReplaceability?: PowerSource.BatReplaceability, batCapacity?: number, batTimeToFullCharge?: number | null, batChargingCurrent?: number | null, activeBatChargeFaults?: PowerSource.BatChargeFault[]): this;
     createDefaultBasicInformationClusterServer(deviceName: string, serialNumber: string, vendorId?: number, vendorName?: string, productId?: number, productName?: string, softwareVersion?: number, softwareVersionString?: string, hardwareVersion?: number, hardwareVersionString?: string, productLabel?: string, productUrl?: string, configurationVersion?: number): this;
     createDefaultBridgedDeviceBasicInformationClusterServer(deviceName: string, serialNumber: string, vendorId?: number, vendorName?: string, productName?: string, softwareVersion?: number, softwareVersionString?: string, hardwareVersion?: number, hardwareVersionString?: string, productLabel?: string, productUrl?: string, configurationVersion?: number, productId?: number): this;
     createDefaultPowerTopologyClusterServer(feature?: PowerTopology.Feature, availableEndpoints?: EndpointNumber[], activeEndpoints?: EndpointNumber[]): this;

package/dist/matterbridgeEndpoint.js

@@ -539,8 +539,8 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage, batReplacementDescription, batQuantity, batReplaceability));
         return this;
     }
-    createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
-        this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage, batReplaceability));
+    createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplaceability = PowerSource.BatReplaceability.Unspecified, batCapacity, batTimeToFullCharge, batChargingCurrent, activeBatChargeFaults) {
+        this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage, batReplaceability, batCapacity, batTimeToFullCharge, batChargingCurrent, activeBatChargeFaults));
         return this;
     }
     createDefaultBasicInformationClusterServer(deviceName, serialNumber, vendorId = 0xfff1, vendorName = 'Matterbridge', productId = 0x8000, productName = 'Matterbridge device', softwareVersion = 1, softwareVersionString = '1.0.0', hardwareVersion = 1, hardwareVersionString = '1.0.0', productLabel = 'Matter Endpoint', productUrl = 'https://matterbridge.io', configurationVersion = 1) {

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -81,7 +81,7 @@ export declare function getDefaultPowerSourceReplaceableBatteryClusterServer(bat
     replaceable: true;
     wired: false;
 }>, typeof MatterbridgePowerSourceServer>>;
-export declare function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining?: number | null, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number | null, batReplaceability?: PowerSource.BatReplaceability): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<PowerSource, {
+export declare function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining?: number | null, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number | null, batReplaceability?: PowerSource.BatReplaceability, batCapacity?: number, batTimeToFullCharge?: number | null, batChargingCurrent?: number | null, activeBatChargeFaults?: PowerSource.BatChargeFault[]): Partial<import("@matter/node").ClusterState.Type<ClusterType.WithSupportedFeatures<PowerSource, {
     battery: true;
     rechargeable: true;
     replaceable: false;

package/dist/matterbridgeEndpointHelpers.js

@@ -927,7 +927,7 @@ export function getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentR
         batQuantity,
     });
 }
-export function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
+export function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplaceability = PowerSource.BatReplaceability.Unspecified, batCapacity, batTimeToFullCharge, batChargingCurrent, activeBatChargeFaults) {
     return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable), {
         status: PowerSource.PowerSourceStatus.Active,
         order: 0,
@@ -943,6 +943,10 @@ export function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercent
         activeBatFaults: [],
         batChargeState: PowerSource.BatChargeState.IsNotCharging,
         batFunctionalWhileCharging: true,
+        ...(batCapacity !== undefined ? { batCapacity } : {}),
+        ...(batTimeToFullCharge !== undefined ? { batTimeToFullCharge } : {}),
+        ...(batChargingCurrent !== undefined ? { batChargingCurrent } : {}),
+        ...(activeBatChargeFaults !== undefined ? { activeBatChargeFaults } : {}),
     });
 }
 export function getDefaultElectricalEnergyMeasurementClusterServer(energyImported = null, energyExported = null) {

package/dist/matterbridgePlatform.js

@@ -11,7 +11,7 @@ import { NodeStorageManager } from 'node-persist-manager';
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { assertMatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { checkNotLatinCharacters } from './matterbridgeEndpointHelpers.js';
-import { toApiDevice } from './matterNodeHelpers.js';
+import { toApiClusters, toApiDevice } from './matterNodeHelpers.js';
 logModuleLoaded('MatterbridgePlatform');
 const MATTERBRIDGE_PLATFORM_BRAND = Symbol('MatterbridgePlatform.brand');
 export function isMatterbridgePlatform(value) {
@@ -130,26 +130,41 @@ export class MatterbridgePlatform {
             this.log.debug(`Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
         switch (msg.type) {
             case 'platform_get_apidevices':
-                if (msg.params.plugin !== this.name)
+                if (msg.params.pluginName !== this.name)
                     return;
                 this.#server.respond({
                     ...msg,
                     result: {
                         devices: this.getDevices()
-                            .map(toApiDevice)
+                            .map((device) => toApiDevice(device, msg.params.extended))
                             .filter((device) => device !== undefined),
                     },
                 });
                 break;
+            case 'platform_get_apiclusters': {
+                if (msg.params.pluginName !== this.name)
+                    return;
+                const { number, serialNumber, uniqueId } = msg.params;
+                const endpoint = this.getDevices().find((device) => device.maybeNumber === number && device.serialNumber === serialNumber && device.uniqueId === uniqueId);
+                const clusters = endpoint ? toApiClusters(endpoint, this.log) : undefined;
+                if (!clusters) {
+                    const error = `getApiCluster: no device found for plugin ${this.name} and endpoint number ${number} (serial: ${serialNumber}, uniqueId: ${uniqueId})`;
+                    this.log.error(error);
+                    this.#server.respond({ ...msg, error });
+                    break;
+                }
+                this.#server.respond({ ...msg, result: { clusters } });
+                break;
+            }
             case 'platform_get_apiselectdevices':
-                if (msg.params.plugin !== this.name)
+                if (msg.params.pluginName !== this.name)
                     return;
-                this.#server.respond({ ...msg, result: { devices: this.getSelectDevices() } });
+                this.#server.respond({ ...msg, result: { devices: this.getSelectDevices().toSorted((keyA, keyB) => keyA.deviceName.localeCompare(keyB.deviceName)) } });
                 break;
             case 'platform_get_apiselectentities':
-                if (msg.params.plugin !== this.name)
+                if (msg.params.pluginName !== this.name)
                     return;
-                this.#server.respond({ ...msg, result: { entities: this.getSelectEntities() } });
+                this.#server.respond({ ...msg, result: { entities: this.getSelectEntities().toSorted((keyA, keyB) => keyA.name.localeCompare(keyB.name)) } });
                 break;
             default:
                 if (this.#verbose)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.14-dev-20261013-e87a0c8",
+  "version": "3.10.14-dev-20261014-2811fdc",
   "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.14-dev-20261013-e87a0c8",
-    "@matterbridge/thread": "3.10.14-dev-20261013-e87a0c8",
-    "@matterbridge/types": "3.10.14-dev-20261013-e87a0c8",
-    "@matterbridge/utils": "3.10.14-dev-20261013-e87a0c8",
+    "@matterbridge/dgram": "3.10.14-dev-20261014-2811fdc",
+    "@matterbridge/thread": "3.10.14-dev-20261014-2811fdc",
+    "@matterbridge/types": "3.10.14-dev-20261014-2811fdc",
+    "@matterbridge/utils": "3.10.14-dev-20261014-2811fdc",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.1",