matterbridge 3.2.9-dev-20250924-9417698 → 3.2.9-dev-20250924-c639a33

package/CHANGELOG.md

@@ -21,6 +21,10 @@ If you like this project and find it useful, please consider giving it a star on
 - [frontend]: Use MbfTable for Plugins, Devices, Registered devices and Clusters tables.
 - [frontend]: Optimized WebSocker message handlers. Now, the handler targets the component.
 - [frontend]: Removed dangerouslySetInnerHTML from log rendering.
+- [frontend]: Added push update to Icon view and table view cluster panel.
+- [frontend]: Added install progress dialog when installing or uploading packages.
+- [endpoint]: Added occupancy feature to all Thermostat cluster helpers. When provided (either false or true) it will create a Thermostat with occupancy feature.
+- [endpoint]: Added outdoorTemperature to all Thermostat cluster helpers. Default is undefined (it will be ignored).
 
 ### Changed
 

package/dist/frontend.js

@@ -525,7 +525,7 @@ export class Frontend extends EventEmitter {
                 this.log.info(`File ${plg}${filename}${nf} uploaded successfully`);
                 if (filename.endsWith('.tgz')) {
                     const { spawnCommand } = await import('./utils/spawn.js');
-                    await spawnCommand(this.matterbridge, 'npm', ['install', '-g', filePath, '--omit=dev', '--verbose']);
+                    await spawnCommand(this.matterbridge, 'npm', ['install', '-g', filePath, '--omit=dev', '--verbose'], filename);
                     this.log.info(`Plugin package ${plg}${filename}${nf} installed successfully. Full restart required.`);
                     this.wssSendCloseSnackbarMessage(`Installing package ${filename}. Please wait...`);
                     this.wssSendSnackbarMessage(`Installed package ${filename}`, 10, 'success');
@@ -856,7 +856,7 @@ export class Frontend extends EventEmitter {
     }
     getClusters(pluginName, endpointNumber) {
         const endpoint = this.matterbridge.devices.array().find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber);
-        if (!endpoint || !endpoint.plugin || !endpoint.maybeNumber || !endpoint.deviceName || !endpoint.serialNumber) {
+        if (!endpoint || !endpoint.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber) {
             this.log.error(`getClusters: no device found for plugin ${pluginName} and endpoint number ${endpointNumber}`);
             return;
         }
@@ -872,6 +872,7 @@ export class Frontend extends EventEmitter {
                 return;
             clusters.push({
                 endpoint: endpoint.number.toString(),
+                number: endpoint.number,
                 id: 'main',
                 deviceTypes,
                 clusterName: capitalizeFirstLetter(clusterName),
@@ -899,7 +900,8 @@ export class Frontend extends EventEmitter {
                     return;
                 clusters.push({
                     endpoint: childEndpoint.number.toString(),
-                    id: childEndpoint.maybeId ?? 'null',
+                    number: childEndpoint.number,
+                    id: childEndpoint.id,
                     deviceTypes,
                     clusterName: capitalizeFirstLetter(clusterName),
                     clusterId: '0x' + clusterId.toString(16).padStart(2, '0'),
@@ -910,7 +912,7 @@ export class Frontend extends EventEmitter {
                 });
             });
         });
-        return { plugin: endpoint.plugin, deviceName: endpoint.deviceName, serialNumber: endpoint.serialNumber, endpoint: endpoint.maybeNumber, deviceTypes, clusters };
+        return { plugin: endpoint.plugin, deviceName: endpoint.deviceName, serialNumber: endpoint.serialNumber, number: endpoint.number, id: endpoint.id, deviceTypes, clusters };
     }
     async wsMessageHandler(client, message) {
         let data;
@@ -967,7 +969,7 @@ export class Frontend extends EventEmitter {
                 }
                 this.wssSendSnackbarMessage(`Installing package ${data.params.packageName}...`, 0);
                 const { spawnCommand } = await import('./utils/spawn.js');
-                spawnCommand(this.matterbridge, 'npm', ['install', '-g', data.params.packageName, '--omit=dev', '--verbose'])
+                spawnCommand(this.matterbridge, 'npm', ['install', '-g', data.params.packageName, '--omit=dev', '--verbose'], data.params.packageName)
                     .then((_response) => {
                     sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: data.src, success: true });
                     this.wssSendCloseSnackbarMessage(`Installing package ${localData.params.packageName}...`);
@@ -1035,7 +1037,7 @@ export class Frontend extends EventEmitter {
                 }
                 this.wssSendSnackbarMessage(`Uninstalling package ${data.params.packageName}...`, 0);
                 const { spawnCommand } = await import('./utils/spawn.js');
-                spawnCommand(this.matterbridge, 'npm', ['uninstall', '-g', data.params.packageName, '--verbose'])
+                spawnCommand(this.matterbridge, 'npm', ['uninstall', '-g', data.params.packageName, '--verbose'], data.params.packageName)
                     .then((_response) => {
                     sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: data.src, success: true });
                     this.wssSendCloseSnackbarMessage(`Uninstalling package ${localData.params.packageName}...`);
@@ -1765,9 +1767,9 @@ export class Frontend extends EventEmitter {
         this.log.debug('Sending a close snackbar message to all connected clients');
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'close_snackbar', success: true, response: { message } });
     }
-    wssSendAttributeChangedMessage(plugin, serialNumber, uniqueId, cluster, attribute, value) {
+    wssSendAttributeChangedMessage(plugin, serialNumber, uniqueId, number, id, cluster, attribute, value) {
         this.log.debug('Sending an attribute update message to all connected clients');
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'state_update', success: true, response: { plugin, serialNumber, uniqueId, cluster, attribute, value } });
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'state_update', success: true, response: { plugin, serialNumber, uniqueId, number, id, cluster, attribute, value } });
     }
     wssBroadcastMessage(msg) {
         const stringifiedMsg = JSON.stringify(msg);

package/dist/matterbridge.js

@@ -3,13 +3,12 @@ import path from 'node:path';
 import { promises as fs } from 'node:fs';
 import EventEmitter from 'node:events';
 import { inspect } from 'node:util';
-import { AnsiLogger, UNDERLINE, UNDERLINEOFF, db, debugStringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, CYAN, nt, BLUE } from 'node-ansi-logger';
+import { AnsiLogger, UNDERLINE, UNDERLINEOFF, db, debugStringify, BRIGHT, RESET, er, nf, rs, wr, RED, GREEN, zb, CYAN, nt, BLUE, or } from 'node-ansi-logger';
 import { NodeStorageManager } from 'node-persist-manager';
 import { DeviceTypeId, Endpoint, Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, VendorId, StorageService, Environment, ServerNode, UINT32_MAX, UINT16_MAX, Crypto, } from '@matter/main';
 import { FabricAction, MdnsService, PaseClient } from '@matter/main/protocol';
 import { AggregatorEndpoint } from '@matter/main/endpoints';
 import { BasicInformationServer } from '@matter/main/behaviors/basic-information';
-import { BridgedDeviceBasicInformationServer } from '@matter/main/behaviors/bridged-device-basic-information';
 import { getParameter, getIntParameter, hasParameter, copyDirectory, isValidString, parseVersionString, isValidNumber, createDirectory } from './utils/export.js';
 import { withTimeout, waiter, wait } from './utils/wait.js';
 import { dev, plg, typ } from './matterbridgeTypes.js';
@@ -508,7 +507,7 @@ export class Matterbridge extends EventEmitter {
                 this.log.info(`Error parsing plugin ${plg}${plugin.name}${nf}. Trying to reinstall it from npm.`);
                 try {
                     const { spawnCommand } = await import('./utils/spawn.js');
-                    await spawnCommand(this, 'npm', ['install', '-g', plugin.name, '--omit=dev', '--verbose']);
+                    await spawnCommand(this, 'npm', ['install', '-g', plugin.name, '--omit=dev', '--verbose'], plugin.name);
                     this.log.info(`Plugin ${plg}${plugin.name}${nf} reinstalled.`);
                     plugin.error = false;
                 }
@@ -950,7 +949,7 @@ export class Matterbridge extends EventEmitter {
         this.log.info('Updating matterbridge...');
         try {
             const { spawnCommand } = await import('./utils/spawn.js');
-            await spawnCommand(this, 'npm', ['install', '-g', 'matterbridge', '--omit=dev', '--verbose']);
+            await spawnCommand(this, 'npm', ['install', '-g', 'matterbridge', '--omit=dev', '--verbose'], 'matterbridge');
             this.log.info('Matterbridge has been updated. Full restart required.');
         }
         catch (error) {
@@ -1714,20 +1713,65 @@ export class Matterbridge extends EventEmitter {
             await wait(2000);
     }
     async subscribeAttributeChanged(plugin, device) {
-        if (!plugin || !device || !device.plugin || !device.serialNumber || !device.uniqueId)
+        if (!plugin || !device || !device.plugin || !device.serialNumber || !device.uniqueId || !device.maybeNumber)
             return;
         this.log.info(`Subscribing attributes for endpoint ${dev}${device.deviceName}${nf} (${dev}${device.id}${nf}) plugin ${plg}${plugin.name}${nf}`);
         if (this.bridgeMode === 'childbridge' && plugin.type === 'AccessoryPlatform' && plugin.serverNode) {
             plugin.serverNode.eventsOf(BasicInformationServer).reachable$Changed?.on((reachable) => {
                 this.log.info(`Accessory endpoint ${dev}${device.deviceName}${nf} (${dev}${device.id}${nf}) is ${reachable ? 'reachable' : 'unreachable'}`);
-                this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, 'BasicInformationServer', 'reachable', reachable);
+                this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, device.number, device.id, 'BasicInformation', 'reachable', reachable);
             });
         }
-        if (device.hasClusterServer(BridgedDeviceBasicInformationServer)) {
-            device.eventsOf(BridgedDeviceBasicInformationServer).reachable$Changed.on((reachable) => {
-                this.log.info(`Bridged endpoint ${dev}${device.deviceName}${nf} (${dev}${device.id}${nf}) is ${reachable ? 'reachable' : 'unreachable'}`);
-                this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, 'BridgedDeviceBasicInformationServer', 'reachable', reachable);
-            });
+        const subscriptions = [
+            { cluster: 'BridgedDeviceBasicInformation', attribute: 'reachable' },
+            { cluster: 'OnOff', attribute: 'onOff' },
+            { cluster: 'LevelControl', attribute: 'currentLevel' },
+            { cluster: 'ColorControl', attribute: 'colorMode' },
+            { cluster: 'ColorControl', attribute: 'currentHue' },
+            { cluster: 'ColorControl', attribute: 'currentSaturation' },
+            { cluster: 'ColorControl', attribute: 'currentX' },
+            { cluster: 'ColorControl', attribute: 'currentY' },
+            { cluster: 'ColorControl', attribute: 'colorTemperatureMireds' },
+            { cluster: 'Thermostat', attribute: 'localTemperature' },
+            { cluster: 'Thermostat', attribute: 'occupiedCoolingSetpoint' },
+            { cluster: 'Thermostat', attribute: 'occupiedHeatingSetpoint' },
+            { cluster: 'Thermostat', attribute: 'systemMode' },
+            { cluster: 'WindowCovering', attribute: 'operationalStatus' },
+            { cluster: 'WindowCovering', attribute: 'currentPositionLiftPercent100ths' },
+            { cluster: 'DoorLock', attribute: 'lockState' },
+            { cluster: 'PumpConfigurationAndControl', attribute: 'pumpStatus' },
+            { cluster: 'FanControl', attribute: 'fanMode' },
+            { cluster: 'FanControl', attribute: 'fanModeSequence' },
+            { cluster: 'FanControl', attribute: 'percentSetting' },
+            { cluster: 'AirQuality', attribute: 'airQuality' },
+            { cluster: 'TotalVolatileOrganicCompoundsConcentrationMeasurement', attribute: 'measuredValue' },
+            { cluster: 'BooleanState', attribute: 'stateValue' },
+            { cluster: 'OccupancySensing', attribute: 'occupancy' },
+            { cluster: 'IlluminanceMeasurement', attribute: 'measuredValue' },
+            { cluster: 'TemperatureMeasurement', attribute: 'measuredValue' },
+            { cluster: 'RelativeHumidityMeasurement', attribute: 'measuredValue' },
+            { cluster: 'PressureMeasurement', attribute: 'measuredValue' },
+            { cluster: 'FlowMeasurement', attribute: 'measuredValue' },
+        ];
+        for (const sub of subscriptions) {
+            if (device.hasAttributeServer(sub.cluster, sub.attribute)) {
+                this.log.debug(`Subscribing to endpoint ${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
+                await device.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
+                    this.log.debug(`Bridged endpoint ${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${value}${db}`);
+                    this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, device.number, device.id, sub.cluster, sub.attribute, value);
+                });
+            }
+            for (const child of device.getChildEndpoints()) {
+                for (const sub of subscriptions) {
+                    if (child.hasAttributeServer(sub.cluster, sub.attribute)) {
+                        this.log.debug(`Subscribing to child endpoint ${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
+                        await child.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
+                            this.log.debug(`Bridged child endpoint ${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${value}${db}`);
+                            this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, child.number, child.id, sub.cluster, sub.attribute, value);
+                        });
+                    }
+                }
+            }
         }
     }
     sanitizeFabricInformations(fabricInfo) {

package/dist/matterbridgeEndpoint.js

@@ -778,9 +778,10 @@ export class MatterbridgeEndpoint extends Endpoint {
             this.log.debug(`Set WindowCovering currentPositionTiltPercent100ths: ${tiltPosition} and targetPositionTiltPercent100ths: ${tiltPosition}.`);
         }
     }
-    createDefaultThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 1, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50) {
-        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode), {
+    createDefaultThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 1, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, unoccupiedHeatingSetpoint = undefined, unoccupiedCoolingSetpoint = undefined, occupied = undefined, outdoorTemperature = undefined) {
+        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, Thermostat.Feature.Cooling, Thermostat.Feature.AutoMode, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : [])), {
             localTemperature: localTemperature * 100,
+            ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
             systemMode: Thermostat.SystemMode.Auto,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingAndHeating,
             occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
@@ -795,12 +796,16 @@ export class MatterbridgeEndpoint extends Endpoint {
             absMaxCoolSetpointLimit: maxCoolSetpointLimit * 100,
             minSetpointDeadBand: minSetpointDeadBand * 100,
             thermostatRunningMode: Thermostat.ThermostatRunningMode.Off,
+            ...(occupied !== undefined ? { unoccupiedHeatingSetpoint: unoccupiedHeatingSetpoint !== undefined ? unoccupiedHeatingSetpoint * 100 : 1900 } : {}),
+            ...(occupied !== undefined ? { unoccupiedCoolingSetpoint: unoccupiedCoolingSetpoint !== undefined ? unoccupiedCoolingSetpoint * 100 : 2700 } : {}),
+            ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
         });
         return this;
     }
-    createDefaultHeatingThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50) {
-        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating), {
+    createDefaultHeatingThermostatClusterServer(localTemperature = 23, occupiedHeatingSetpoint = 21, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, unoccupiedHeatingSetpoint = undefined, occupied = undefined, outdoorTemperature = undefined) {
+        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Heating, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : [])), {
             localTemperature: localTemperature * 100,
+            ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
             systemMode: Thermostat.SystemMode.Heat,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.HeatingOnly,
             occupiedHeatingSetpoint: occupiedHeatingSetpoint * 100,
@@ -808,12 +813,15 @@ export class MatterbridgeEndpoint extends Endpoint {
             maxHeatSetpointLimit: maxHeatSetpointLimit * 100,
             absMinHeatSetpointLimit: minHeatSetpointLimit * 100,
             absMaxHeatSetpointLimit: maxHeatSetpointLimit * 100,
+            ...(occupied !== undefined ? { unoccupiedHeatingSetpoint: unoccupiedHeatingSetpoint !== undefined ? unoccupiedHeatingSetpoint * 100 : 1900 } : {}),
+            ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
         });
         return this;
     }
-    createDefaultCoolingThermostatClusterServer(localTemperature = 23, occupiedCoolingSetpoint = 25, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50) {
-        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Cooling), {
+    createDefaultCoolingThermostatClusterServer(localTemperature = 23, occupiedCoolingSetpoint = 25, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, unoccupiedCoolingSetpoint = undefined, occupied = undefined, outdoorTemperature = undefined) {
+        this.behaviors.require(MatterbridgeThermostatServer.with(Thermostat.Feature.Cooling, ...(occupied !== undefined ? [Thermostat.Feature.Occupancy] : [])), {
             localTemperature: localTemperature * 100,
+            ...(outdoorTemperature !== undefined ? { outdoorTemperature: outdoorTemperature !== null ? outdoorTemperature * 100 : outdoorTemperature } : {}),
             systemMode: Thermostat.SystemMode.Cool,
             controlSequenceOfOperation: Thermostat.ControlSequenceOfOperation.CoolingOnly,
             occupiedCoolingSetpoint: occupiedCoolingSetpoint * 100,
@@ -821,6 +829,8 @@ export class MatterbridgeEndpoint extends Endpoint {
             maxCoolSetpointLimit: maxCoolSetpointLimit * 100,
             absMinCoolSetpointLimit: minCoolSetpointLimit * 100,
             absMaxCoolSetpointLimit: maxCoolSetpointLimit * 100,
+            ...(occupied !== undefined ? { unoccupiedCoolingSetpoint: unoccupiedCoolingSetpoint !== undefined ? unoccupiedCoolingSetpoint * 100 : 2700 } : {}),
+            ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
         });
         return this;
     }

package/dist/utils/spawn.js

@@ -1,5 +1,5 @@
 import { hasParameter } from './commandLine.js';
-export async function spawnCommand(matterbridge, command, args) {
+export async function spawnCommand(matterbridge, command, args, packageName) {
     const { spawn } = await import('node:child_process');
     const cmdLine = command + ' ' + args.join(' ');
     if (process.platform === 'win32' && command === 'npm') {
@@ -13,6 +13,7 @@ export async function spawnCommand(matterbridge, command, args) {
     }
     matterbridge.log.debug(`Spawn command ${command} with ${args.join(' ')}`);
     return new Promise((resolve, reject) => {
+        matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn-init', packageName || `unknown-package`);
         const childProcess = spawn(command, args, {
             stdio: ['inherit', 'pipe', 'pipe'],
         });
@@ -22,6 +23,7 @@ export async function spawnCommand(matterbridge, command, args) {
         });
         childProcess.on('close', (code, signal) => {
             matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn', `child process closed with code ${code} and signal ${signal}`);
+            matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn-exit', 'Child process closed');
             if (code === 0) {
                 if (cmdLine.startsWith('npm install -g'))
                     matterbridge.log.notice(`Package ${cmdLine.replace('npm install -g ', '').replace('--verbose', '').replace('--omit=dev', '')} installed correctly`);
@@ -35,6 +37,7 @@ export async function spawnCommand(matterbridge, command, args) {
         });
         childProcess.on('exit', (code, signal) => {
             matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn', `child process exited with code ${code} and signal ${signal}`);
+            matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn-exit', 'Child process exited');
             if (code === 0) {
                 matterbridge.log.debug(`Child process "${cmdLine}" exited with code ${code} and signal ${signal}`);
                 resolve(true);