matterbridge 3.2.7-dev-20250908-3bb699e → 3.2.7-dev-20250913-9d0d095

package/CHANGELOG.md

@@ -8,7 +8,7 @@ If you like this project and find it useful, please consider giving it a star on
   <img src="bmc-button.svg" alt="Buy me a coffee" width="120">
 </a>
 
-## [3.2.7] - 2025-09-??
+## [3.2.7] - 2025-09-12
 
 ### Breaking Changes
 
@@ -17,10 +17,16 @@ If you like this project and find it useful, please consider giving it a star on
 
 ### Added
 
+- [jest]: Added Jest helpers module.
+- [colorControl]: Added createEnhancedColorControlClusterServer (provisional to run compatibility tests on all controllers).
+- [frontend]: Bumped `frontend` version to 2.7.6.
+- [frontend]: Added api/view-diagnostic.
+- [frontend]: Refactored the QRCode component for device with mode='server' (e.g. the Rvcs): added turn on and off pairing mode, resend mDns advertise, remove single fabrics, formatted manual paring code, copy to clipboard the manual pairing code and is fully web socket based. The main QRCode panel will have the same features (bridge mode and childbridge mode) in the next release.
+
 ### Changed
 
 - [package]: Updated dependencies.
-- [matterbridge.io]: Updated site.
+- [matterbridge.io]: Updated web site [matterbridge.io](matterbridge.io).
 
 ### Fixed
 

package/dist/frontend.js

@@ -2,15 +2,17 @@ import { createServer } from 'node:http';
 import https from 'node:https';
 import os from 'node:os';
 import path from 'node:path';
-import { existsSync, promises as fs } from 'node:fs';
+import { existsSync, promises as fs, unlinkSync } from 'node:fs';
 import EventEmitter from 'node:events';
+import { appendFile } from 'node:fs/promises';
 import express from 'express';
 import WebSocket, { WebSocketServer } from 'ws';
 import multer from 'multer';
 import { AnsiLogger, stringify, debugStringify, CYAN, db, er, nf, rs, UNDERLINE, UNDERLINEOFF, YELLOW, nt } from 'node-ansi-logger';
-import { Logger, LogLevel as MatterLogLevel, Lifecycle } from '@matter/main';
+import { Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, Lifecycle, LogDestination, Diagnostic, Time, FabricIndex } from '@matter/main';
 import { BridgedDeviceBasicInformation, PowerSource } from '@matter/main/clusters';
-import { createZip, isValidArray, isValidNumber, isValidObject, isValidString, isValidBoolean, withTimeout, hasParameter } from './utils/export.js';
+import { DeviceAdvertiser, DeviceCommissioner, FabricManager } from '@matter/main/protocol';
+import { createZip, isValidArray, isValidNumber, isValidObject, isValidString, isValidBoolean, withTimeout, hasParameter, wait, inspectError } from './utils/export.js';
 import { plg } from './matterbridgeTypes.js';
 import { capitalizeFirstLetter, getAttribute } from './matterbridgeEndpointHelpers.js';
 import { cliEmitter, lastCpuUsage } from './cliEmitter.js';
@@ -354,6 +356,52 @@ export class Frontend extends EventEmitter {
                 res.status(500).send('Error reading matter log file. Please enable the matter log on file in the settings.');
             }
         });
+        this.expressApp.get('/api/view-diagnostic', async (req, res) => {
+            this.log.debug('The frontend sent /api/view-diagnostic');
+            const serverNodes = [];
+            if (this.matterbridge.bridgeMode === 'bridge') {
+                if (this.matterbridge.serverNode)
+                    serverNodes.push(this.matterbridge.serverNode);
+            }
+            else if (this.matterbridge.bridgeMode === 'childbridge') {
+                for (const plugin of this.matterbridge.getPlugins()) {
+                    if (plugin.serverNode)
+                        serverNodes.push(plugin.serverNode);
+                }
+            }
+            for (const device of this.matterbridge.getDevices()) {
+                if (device.serverNode)
+                    serverNodes.push(device.serverNode);
+            }
+            if (existsSync(path.join(this.matterbridge.matterbridgeDirectory, 'diagnostic.log')))
+                unlinkSync(path.join(this.matterbridge.matterbridgeDirectory, 'diagnostic.log'));
+            const diagnosticDestination = LogDestination({ name: 'diagnostic', level: MatterLogLevel.INFO, format: MatterLogFormat.formats.plain });
+            diagnosticDestination.write = async (text, _message) => {
+                await appendFile(path.join(this.matterbridge.matterbridgeDirectory, 'diagnostic.log'), text + '\n', { encoding: 'utf8' });
+            };
+            Logger.destinations.diagnostic = diagnosticDestination;
+            if (!diagnosticDestination.context) {
+                diagnosticDestination.context = Diagnostic.Context();
+            }
+            diagnosticDestination.context.run(() => diagnosticDestination.add(Diagnostic.message({
+                now: Time.now(),
+                facility: 'Server nodes:',
+                level: MatterLogLevel.INFO,
+                prefix: Logger.nestingLevel ? '⎸'.padEnd(Logger.nestingLevel * 2) : '',
+                values: [...serverNodes],
+            })));
+            delete Logger.destinations.diagnostic;
+            await wait(500);
+            try {
+                const data = await fs.readFile(path.join(this.matterbridge.matterbridgeDirectory, 'diagnostic.log'), 'utf8');
+                res.type('text/plain');
+                res.send(data.slice(29));
+            }
+            catch (error) {
+                this.log.error(`Error reading diagnostic log file ${this.matterbridge.matterLoggerFile}: ${error instanceof Error ? error.message : error}`);
+                res.status(500).send('Error reading diagnostic log file.');
+            }
+        });
         this.expressApp.get('/api/shellyviewsystemlog', async (req, res) => {
             this.log.debug('The frontend sent /api/shellyviewsystemlog');
             try {
@@ -667,14 +715,7 @@ export class Frontend extends EventEmitter {
     }
     getMatterDataFromDevice(device) {
         if (device.mode === 'server' && device.serverNode) {
-            return {
-                commissioned: device.serverNode.state.commissioning.commissioned,
-                qrPairingCode: device.serverNode.state.commissioning.pairingCodes.qrPairingCode,
-                manualPairingCode: device.serverNode.state.commissioning.pairingCodes.manualPairingCode,
-                fabricInformations: this.matterbridge.sanitizeFabricInformations(Object.values(device.serverNode.state.commissioning.fabrics)),
-                sessionInformations: this.matterbridge.sanitizeSessionInformation(Object.values(device.serverNode.state.sessions.sessions)),
-                serialNumber: device.serverNode.state.basicInformation.serialNumber,
-            };
+            return this.matterbridge.getServerNodeData(device.serverNode);
         }
     }
     getClusterTextFromDevice(device) {
@@ -1267,6 +1308,50 @@ export class Frontend extends EventEmitter {
                 this.wssSendSnackbarMessage(`Stopped fabrics share`, 0);
                 client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
             }
+            else if (data.method === '/api/matter') {
+                if (!isValidString(data.params.id)) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter id in /api/matter' }));
+                    return;
+                }
+                let serverNode;
+                if (data.params.id === 'Matterbridge')
+                    serverNode = this.matterbridge.serverNode;
+                else
+                    serverNode = this.matterbridge.getPlugins().find((p) => p.serverNode && p.serverNode.id === data.params.id)?.serverNode || this.matterbridge.getDevices().find((d) => d.serverNode && d.serverNode.id === data.params.id)?.serverNode;
+                if (!serverNode) {
+                    client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Unknown server node id in /api/matter' }));
+                    return;
+                }
+                this.log.debug(`*Server node ${serverNode.id}: commissioned ${serverNode.state.commissioning.commissioned} upTime ${serverNode.state.generalDiagnostics.upTime}.`);
+                if (data.params.server) {
+                    this.log.debug(`*Sending data for node ${data.params.id}`);
+                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode) } });
+                }
+                if (data.params.commission) {
+                    await serverNode.env.get(DeviceCommissioner)?.allowBasicCommissioning();
+                    this.matterbridge.advertisingNodes.set(serverNode.id, Date.now());
+                    this.log.debug(`*Commissioning has been sent for node ${data.params.id}`);
+                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode), advertising: true } });
+                }
+                if (data.params.stopCommission) {
+                    await serverNode.env.get(DeviceCommissioner)?.endCommissioning();
+                    this.matterbridge.advertisingNodes.delete(serverNode.id);
+                    this.log.debug(`*Stop commissioning has been sent for node ${data.params.id}`);
+                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode), advertising: false } });
+                }
+                if (data.params.advertise) {
+                    await serverNode.env.get(DeviceAdvertiser)?.advertise(true);
+                    this.log.debug(`*Advertising has been sent for node ${data.params.id}`);
+                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode), advertising: true } });
+                }
+                if (data.params.removeFabric) {
+                    if (serverNode.env.get(FabricManager).has(FabricIndex(data.params.removeFabric)))
+                        await serverNode.env.get(FabricManager).removeFabric(FabricIndex(data.params.removeFabric));
+                    this.log.debug(`*Removed fabric index ${data.params.removeFabric} for node ${data.params.id}`);
+                    this.wssSendRefreshRequired('matter', { matter: { ...this.matterbridge.getServerNodeData(serverNode) } });
+                }
+                client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true }));
+            }
             else if (data.method === '/api/settings') {
                 client.send(JSON.stringify({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, response: await this.getApiSettings() }));
             }
@@ -1651,7 +1736,7 @@ export class Frontend extends EventEmitter {
             }
         }
         catch (error) {
-            this.log.error(`Error parsing message "${message}" from websocket client:`, error instanceof Error ? error.message : error);
+            inspectError(this.log, `Error processing message "${message}" from websocket client`, error);
         }
     }
     wssSendMessage(level, time, name, message) {
@@ -1681,11 +1766,11 @@ export class Frontend extends EventEmitter {
             }
         });
     }
-    wssSendRefreshRequired(changed = null) {
+    wssSendRefreshRequired(changed = null, params = {}) {
         this.log.debug('Sending a refresh required message to all connected clients');
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({ id: WS_ID_REFRESH_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', params: { changed: changed } }));
+                client.send(JSON.stringify({ id: WS_ID_REFRESH_NEEDED, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', params: { changed: changed, ...params } }));
             }
         });
     }

package/dist/matterbridge.js

@@ -140,6 +140,7 @@ export class Matterbridge extends EventEmitter {
     aggregatorDeviceType = DeviceTypeId(getIntParameter('deviceType') ?? bridge.code);
     aggregatorSerialNumber = getParameter('serialNumber');
     aggregatorUniqueId = getParameter('uniqueId');
+    advertisingNodes = new Map();
     static instance;
     constructor() {
         super();
@@ -1394,15 +1395,15 @@ export class Matterbridge extends EventEmitter {
         this.matterbridgeContext = undefined;
         this.log.info('Matter node storage closed');
     }
-    async createServerNodeContext(pluginName, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber, uniqueId) {
+    async createServerNodeContext(storeId, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber, uniqueId) {
         const { randomBytes } = await import('node:crypto');
         if (!this.matterStorageService)
             throw new Error('No storage service initialized');
-        this.log.info(`Creating server node storage context "${pluginName}.persist" for ${pluginName}...`);
-        const storageManager = await this.matterStorageService.open(pluginName);
+        this.log.info(`Creating server node storage context "${storeId}.persist" for ${storeId}...`);
+        const storageManager = await this.matterStorageService.open(storeId);
         const storageContext = storageManager.createContext('persist');
         const random = randomBytes(8).toString('hex');
-        await storageContext.set('storeId', pluginName);
+        await storageContext.set('storeId', storeId);
         await storageContext.set('deviceName', deviceName);
         await storageContext.set('deviceType', deviceType);
         await storageContext.set('vendorId', vendorId);
@@ -1417,10 +1418,16 @@ export class Matterbridge extends EventEmitter {
         await storageContext.set('softwareVersionString', isValidString(this.matterbridgeVersion, 5, 64) ? this.matterbridgeVersion : '1.0.0');
         await storageContext.set('hardwareVersion', isValidNumber(parseVersionString(this.systemInformation.osRelease), 0, UINT16_MAX) ? parseVersionString(this.systemInformation.osRelease) : 1);
         await storageContext.set('hardwareVersionString', isValidString(this.systemInformation.osRelease, 5, 64) ? this.systemInformation.osRelease : '1.0.0');
-        this.log.debug(`Created server node storage context "${pluginName}.persist" for ${pluginName}:`);
+        this.log.debug(`Created server node storage context "${storeId}.persist" for ${storeId}:`);
         this.log.debug(`- storeId: ${await storageContext.get('storeId')}`);
         this.log.debug(`- deviceName: ${await storageContext.get('deviceName')}`);
         this.log.debug(`- deviceType: ${await storageContext.get('deviceType')}(0x${(await storageContext.get('deviceType'))?.toString(16).padStart(4, '0')})`);
+        this.log.debug(`- vendorId: ${await storageContext.get('vendorId')}`);
+        this.log.debug(`- vendorName: ${await storageContext.get('vendorName')}`);
+        this.log.debug(`- productId: ${await storageContext.get('productId')}`);
+        this.log.debug(`- productName: ${await storageContext.get('productName')}`);
+        this.log.debug(`- nodeLabel: ${await storageContext.get('nodeLabel')}`);
+        this.log.debug(`- productLabel: ${await storageContext.get('productLabel')}`);
         this.log.debug(`- serialNumber: ${await storageContext.get('serialNumber')}`);
         this.log.debug(`- uniqueId: ${await storageContext.get('uniqueId')}`);
         this.log.debug(`- softwareVersion: ${await storageContext.get('softwareVersion')} softwareVersionString: ${await storageContext.get('softwareVersionString')}`);
@@ -1486,12 +1493,15 @@ export class Matterbridge extends EventEmitter {
                 this.log.notice(`QR Code URL: https://project-chip.github.io/connectedhomeip/qrcode.html?data=${qrPairingCode}`);
                 this.log.notice(`Manual pairing code: ${manualPairingCode}`);
                 this.startEndAdvertiseTimer(serverNode);
+                this.advertisingNodes.set(storeId, Date.now());
             }
             else {
                 this.log.notice(`Server node for ${storeId} is already commissioned. Waiting for controllers to connect ...`);
+                this.advertisingNodes.delete(storeId);
             }
             this.frontend.wssSendRefreshRequired('plugins');
             this.frontend.wssSendRefreshRequired('settings');
+            this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
             this.frontend.wssSendSnackbarMessage(`${storeId} is online`, 5, 'success');
             this.emit('online', storeId);
         });
@@ -1500,6 +1510,7 @@ export class Matterbridge extends EventEmitter {
             this.matterbridgeInformation.matterbridgeEndAdvertise = true;
             this.frontend.wssSendRefreshRequired('plugins');
             this.frontend.wssSendRefreshRequired('settings');
+            this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
             this.frontend.wssSendSnackbarMessage(`${storeId} is offline`, 5, 'warning');
             this.emit('offline', storeId);
         });
@@ -1507,6 +1518,10 @@ export class Matterbridge extends EventEmitter {
             let action = '';
             switch (fabricAction) {
                 case FabricAction.Added:
+                    this.advertisingNodes.delete(storeId);
+                    clearTimeout(this.endAdvertiseTimeout);
+                    this.endAdvertiseTimeout = undefined;
+                    this.matterbridgeInformation.matterbridgeEndAdvertise = true;
                     action = 'added';
                     break;
                 case FabricAction.Removed:
@@ -1518,18 +1533,22 @@ export class Matterbridge extends EventEmitter {
             }
             this.log.notice(`Commissioned fabric index ${fabricIndex} ${action} on server node for ${storeId}: ${debugStringify(serverNode.state.commissioning.fabrics[fabricIndex])}`);
             this.frontend.wssSendRefreshRequired('fabrics');
+            this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
         });
         serverNode.events.sessions.opened.on((session) => {
             this.log.notice(`Session opened on server node for ${storeId}: ${debugStringify(session)}`);
             this.frontend.wssSendRefreshRequired('sessions');
+            this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
         });
         serverNode.events.sessions.closed.on((session) => {
             this.log.notice(`Session closed on server node for ${storeId}: ${debugStringify(session)}`);
             this.frontend.wssSendRefreshRequired('sessions');
+            this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
         });
         serverNode.events.sessions.subscriptionsChanged.on((session) => {
             this.log.notice(`Session subscriptions changed on server node for ${storeId}: ${debugStringify(session)}`);
             this.frontend.wssSendRefreshRequired('sessions');
+            this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
         });
         this.log.info(`Created server node for ${storeId}`);
         return serverNode;
@@ -1548,10 +1567,26 @@ export class Matterbridge extends EventEmitter {
             this.frontend.wssSendRefreshRequired('settings');
             this.frontend.wssSendRefreshRequired('fabrics');
             this.frontend.wssSendRefreshRequired('sessions');
-            this.frontend.wssSendSnackbarMessage(`Advertising stopped. Restart to commission again.`, 0);
-            this.log.notice(`Advertising stopped. Restart to commission again.`);
+            this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(matterServerNode) } });
+            this.frontend.wssSendSnackbarMessage(`Advertising stopped.`, 0);
+            this.log.notice(`Advertising stopped.`);
         }, 15 * 60 * 1000).unref();
     }
+    getServerNodeData(serverNode) {
+        const advertiseTime = this.advertisingNodes.get(serverNode.id) || 0;
+        return {
+            id: serverNode.id,
+            commissioned: serverNode.state.commissioning.commissioned,
+            advertising: advertiseTime > Date.now() - 15 * 60 * 1000,
+            advertiseTime,
+            windowStatus: serverNode.state.administratorCommissioning.windowStatus,
+            qrPairingCode: serverNode.state.commissioning.pairingCodes.qrPairingCode,
+            manualPairingCode: serverNode.state.commissioning.pairingCodes.manualPairingCode,
+            fabricInformations: this.sanitizeFabricInformations(Object.values(serverNode.state.commissioning.fabrics)),
+            sessionInformations: this.sanitizeSessionInformation(Object.values(serverNode.state.sessions.sessions)),
+            serialNumber: serverNode.state.basicInformation.serialNumber,
+        };
+    }
     async startServerNode(matterServerNode) {
         if (!matterServerNode)
             return;
@@ -1574,6 +1609,7 @@ export class Matterbridge extends EventEmitter {
         if (matterServerNode) {
             await matterServerNode.env.get(DeviceCommissioner)?.allowBasicCommissioning();
             const { qrPairingCode, manualPairingCode } = matterServerNode.state.commissioning.pairingCodes;
+            this.advertisingNodes.set(matterServerNode.id, Date.now());
             this.log.notice(`Started advertising for ${matterServerNode.id} with the following pairing codes: qrPairingCode ${qrPairingCode}, manualPairingCode ${manualPairingCode}`);
             return { qrPairingCode, manualPairingCode };
         }
@@ -1581,6 +1617,7 @@ export class Matterbridge extends EventEmitter {
     async stopAdvertiseServerNode(matterServerNode) {
         if (matterServerNode && matterServerNode.lifecycle.isOnline) {
             await matterServerNode.env.get(DeviceCommissioner)?.endCommissioning();
+            this.advertisingNodes.delete(matterServerNode.id);
             this.log.notice(`Stopped advertising for ${matterServerNode.id}`);
         }
     }

package/dist/matterbridgeBehaviors.js

@@ -135,6 +135,57 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
         super.moveToColorTemperature(request);
     }
 }
+export class MatterbridgeEnhancedColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature) {
+    moveToHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting hue to ${request.hue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToHue', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeColorControlServer: moveToHue called`);
+        super.moveToHue(request);
+    }
+    enhancedMoveToHue(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting enhanced hue to ${request.enhancedHue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('enhancedMoveToHue', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHue called`);
+        super.enhancedMoveToHue(request);
+    }
+    moveToSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeColorControlServer: moveToSaturation called`);
+        super.moveToSaturation(request);
+    }
+    moveToHueAndSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting hue to ${request.hue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToHueAndSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeColorControlServer: moveToHueAndSaturation called`);
+        super.moveToHueAndSaturation(request);
+    }
+    enhancedMoveToHueAndSaturation(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting enhanced hue to ${request.enhancedHue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('enhancedMoveToHueAndSaturation', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeColorControlServer: enhancedMoveToHueAndSaturation called`);
+        super.enhancedMoveToHueAndSaturation(request);
+    }
+    moveToColor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting color to ${request.colorX}, ${request.colorY} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToColor', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeColorControlServer: moveToColor called`);
+        super.moveToColor(request);
+    }
+    moveToColorTemperature(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting color temperature to ${request.colorTemperatureMireds} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveToColorTemperature', { request, cluster: ColorControlServer.id, attributes: this.state, endpoint: this.endpoint });
+        device.log.debug(`MatterbridgeColorControlServer: moveToColorTemperature called`);
+        super.moveToColorTemperature(request);
+    }
+}
 export class MatterbridgeLiftWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift) {
     upOrOpen() {
         const device = this.endpoint.stateOf(MatterbridgeServer);

package/dist/matterbridgeEndpoint.js

@@ -59,7 +59,7 @@ import { ResourceMonitoring } from '@matter/main/clusters/resource-monitoring';
 import { ThermostatUserInterfaceConfigurationServer } from '@matter/main/behaviors/thermostat-user-interface-configuration';
 import { AnsiLogger, CYAN, YELLOW, db, debugStringify, hk, or, zb } from './logger/export.js';
 import { isValidNumber, isValidObject, isValidString } from './utils/export.js';
-import { MatterbridgeServer, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeHepaFilterMonitoringServer, } from './matterbridgeBehaviors.js';
+import { MatterbridgeServer, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeEnhancedColorControlServer, } from './matterbridgeBehaviors.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultOperationalStateClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, invokeBehaviorCommand, triggerEvent, featuresFor, } from './matterbridgeEndpointHelpers.js';
 export class MatterbridgeEndpoint extends Endpoint {
     static logLevel = "info";
@@ -586,6 +586,29 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
+    createEnhancedColorControlClusterServer(currentX = 0, currentY = 0, enhancedCurrentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
+        this.behaviors.require(MatterbridgeEnhancedColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.EnhancedHue, ColorControl.Feature.ColorTemperature), {
+            colorMode: ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
+            enhancedColorMode: ColorControl.EnhancedColorMode.EnhancedCurrentHueAndCurrentSaturation,
+            colorCapabilities: { xy: true, hueSaturation: true, colorLoop: false, enhancedHue: true, colorTemperature: true },
+            options: {
+                executeIfOff: false,
+            },
+            numberOfPrimaries: null,
+            currentX,
+            currentY,
+            currentHue: Math.round((enhancedCurrentHue / 65535) * 254),
+            enhancedCurrentHue,
+            currentSaturation,
+            colorTemperatureMireds,
+            colorTempPhysicalMinMireds,
+            colorTempPhysicalMaxMireds,
+            coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
+            startUpColorTemperatureMireds: null,
+            remainingTime: 0,
+        });
+        return this;
+    }
     createXyColorControlClusterServer(currentX = 0, currentY = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         this.behaviors.require(MatterbridgeColorControlServer.with(ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature), {
             colorMode: ColorControl.ColorMode.CurrentXAndCurrentY,
@@ -645,8 +668,8 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     async configureColorControlMode(colorMode) {
-        if (isValidNumber(colorMode, ColorControl.ColorMode.CurrentHueAndCurrentSaturation, ColorControl.ColorMode.ColorTemperatureMireds)) {
-            await this.setAttribute(ColorControl.Cluster.id, 'colorMode', colorMode, this.log);
+        if (isValidNumber(colorMode, ColorControl.EnhancedColorMode.CurrentHueAndCurrentSaturation, ColorControl.EnhancedColorMode.EnhancedCurrentHueAndCurrentSaturation)) {
+            await this.setAttribute(ColorControl.Cluster.id, 'colorMode', colorMode === ColorControl.EnhancedColorMode.EnhancedCurrentHueAndCurrentSaturation ? ColorControl.ColorMode.CurrentHueAndCurrentSaturation : colorMode, this.log);
             await this.setAttribute(ColorControl.Cluster.id, 'enhancedColorMode', colorMode, this.log);
         }
     }

package/dist/{jest-utils → utils}/jestHelpers.js

@@ -1,8 +1,76 @@
 import { rmSync } from 'node:fs';
 import { inspect } from 'node:util';
+import path from 'node:path';
+import { jest } from '@jest/globals';
 import { DeviceTypeId, Endpoint, Environment, ServerNode, ServerNodeStore, VendorId, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Lifecycle } from '@matter/main';
 import { AggregatorEndpoint, RootEndpoint } from '@matter/main/endpoints';
 import { MdnsService } from '@matter/main/protocol';
+import { AnsiLogger } from 'node-ansi-logger';
+export let loggerLogSpy;
+export let consoleLogSpy;
+export let consoleDebugSpy;
+export let consoleInfoSpy;
+export let consoleWarnSpy;
+export let consoleErrorSpy;
+export function setupTest(name, debug = false) {
+    expect(name).toBeDefined();
+    expect(typeof name).toBe('string');
+    expect(name.length).toBeGreaterThanOrEqual(4);
+    rmSync(path.join('jest', name), { recursive: true, force: true });
+    if (debug) {
+        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
+        consoleLogSpy = jest.spyOn(console, 'log');
+        consoleDebugSpy = jest.spyOn(console, 'debug');
+        consoleInfoSpy = jest.spyOn(console, 'info');
+        consoleWarnSpy = jest.spyOn(console, 'warn');
+        consoleErrorSpy = jest.spyOn(console, 'error');
+    }
+    else {
+        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
+        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
+        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+    }
+}
+export function setDebug(debug) {
+    if (debug) {
+        loggerLogSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+        consoleDebugSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
+        consoleLogSpy = jest.spyOn(console, 'log');
+        consoleDebugSpy = jest.spyOn(console, 'debug');
+        consoleInfoSpy = jest.spyOn(console, 'info');
+        consoleWarnSpy = jest.spyOn(console, 'warn');
+        consoleErrorSpy = jest.spyOn(console, 'error');
+    }
+    else {
+        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
+        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
+        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+    }
+}
+export function createTestEnvironment(homeDir) {
+    expect(homeDir).toBeDefined();
+    expect(typeof homeDir).toBe('string');
+    expect(homeDir.length).toBeGreaterThanOrEqual(4);
+    rmSync(homeDir, { recursive: true, force: true });
+    const environment = Environment.default;
+    environment.vars.set('log.level', MatterLogLevel.DEBUG);
+    environment.vars.set('log.format', MatterLogFormat.ANSI);
+    environment.vars.set('path.root', homeDir);
+    environment.vars.set('runtime.signals', false);
+    environment.vars.set('runtime.exitcode', false);
+    return environment;
+}
 export async function flushAsync(ticks = 3, microTurns = 10, pause = 100) {
     for (let i = 0; i < ticks; i++)
         await new Promise((resolve) => setImmediate(resolve));
@@ -46,19 +114,6 @@ export async function assertAllEndpointNumbersPersisted(targetServer) {
     }
     return all.length;
 }
-export function createTestEnvironment(homeDir) {
-    expect(homeDir).toBeDefined();
-    expect(typeof homeDir).toBe('string');
-    expect(homeDir.length).toBeGreaterThan(5);
-    rmSync(homeDir, { recursive: true, force: true });
-    const environment = Environment.default;
-    environment.vars.set('log.level', MatterLogLevel.DEBUG);
-    environment.vars.set('log.format', MatterLogFormat.ANSI);
-    environment.vars.set('path.root', homeDir);
-    environment.vars.set('runtime.signals', false);
-    environment.vars.set('runtime.exitcode', false);
-    return environment;
-}
 export async function startServerNode(name, port) {
     const server = await ServerNode.create({
         id: name + 'ServerNode',
@@ -110,6 +165,7 @@ export async function startServerNode(name, port) {
     expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
     expect(aggregator.lifecycle.hasId).toBeTruthy();
     expect(aggregator.lifecycle.hasNumber).toBeTruthy();
+    await flushAsync();
     return [server, aggregator];
 }
 export async function stopServerNode(server) {
@@ -124,7 +180,7 @@ export async function stopServerNode(server) {
     await server.env.get(MdnsService)[Symbol.asyncDispose]();
     await flushAsync();
 }
-export async function addDevice(owner, device) {
+export async function addDevice(owner, device, pause = 10) {
     expect(owner).toBeDefined();
     expect(device).toBeDefined();
     expect(owner.lifecycle.isReady).toBeTruthy();
@@ -146,9 +202,10 @@ export async function addDevice(owner, device) {
     expect(device.lifecycle.hasId).toBeTruthy();
     expect(device.lifecycle.hasNumber).toBeTruthy();
     expect(device.construction.status).toBe(Lifecycle.Status.Active);
+    await flushAsync(1, 1, pause);
     return true;
 }
-export async function deleteDevice(owner, device) {
+export async function deleteDevice(owner, device, pause = 10) {
     expect(owner).toBeDefined();
     expect(device).toBeDefined();
     expect(owner.lifecycle.isReady).toBeTruthy();
@@ -170,5 +227,6 @@ export async function deleteDevice(owner, device) {
     expect(device.lifecycle.hasId).toBeTruthy();
     expect(device.lifecycle.hasNumber).toBeTruthy();
     expect(device.construction.status).toBe(Lifecycle.Status.Destroyed);
+    await flushAsync(1, 1, pause);
     return true;
 }

package/frontend/build/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.a2f4846a.css",
-    "main.js": "./static/js/main.e691e19f.js",
+    "main.js": "./static/js/main.ee68a4ae.js",
     "static/js/453.d855a71b.chunk.js": "./static/js/453.d855a71b.chunk.js",
     "static/media/roboto-latin-700-normal.woff2": "./static/media/roboto-latin-700-normal.c4d6cab43bec89049809.woff2",
     "static/media/roboto-latin-500-normal.woff2": "./static/media/roboto-latin-500-normal.599f66a60bdf974e578e.woff2",
@@ -77,11 +77,11 @@
     "static/media/roboto-greek-ext-300-normal.woff": "./static/media/roboto-greek-ext-300-normal.60729cafbded24073dfb.woff",
     "index.html": "./index.html",
     "main.a2f4846a.css.map": "./static/css/main.a2f4846a.css.map",
-    "main.e691e19f.js.map": "./static/js/main.e691e19f.js.map",
+    "main.ee68a4ae.js.map": "./static/js/main.ee68a4ae.js.map",
     "453.d855a71b.chunk.js.map": "./static/js/453.d855a71b.chunk.js.map"
   },
   "entrypoints": [
     "static/css/main.a2f4846a.css",
-    "static/js/main.e691e19f.js"
+    "static/js/main.ee68a4ae.js"
   ]
 }

package/frontend/build/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><base href="./"><link rel="icon" href="./matterbridge 32x32.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><title>Matterbridge</title><link rel="manifest" href="./manifest.json"/><script defer="defer" src="./static/js/main.e691e19f.js"></script><link href="./static/css/main.a2f4846a.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><base href="./"><link rel="icon" href="./matterbridge 32x32.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><title>Matterbridge</title><link rel="manifest" href="./manifest.json"/><script defer="defer" src="./static/js/main.ee68a4ae.js"></script><link href="./static/css/main.a2f4846a.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>