matterbridge 3.0.5-dev-20250526-422f029 → 3.0.5-dev-20250528-9314890

package/CHANGELOG.md

@@ -12,6 +12,9 @@ If you like this project and find it useful, please consider giving it a star on
 
 ### Added
 
+- [cli]: Added takeHeapSnapshot() and triggerGarbageCollection().
+- [LaundryWasher]: Add LaundryWasher class and Jest test.
+
 ### Changed
 
 ### Fixed

package/dist/cli.js

@@ -7,6 +7,7 @@ import { inspect } from 'node:util';
 export const cliEmitter = new EventEmitter();
 export let instance;
 let session;
+let snapshotInterval;
 let memoryCheckInterval;
 let prevCpus;
 export let lastCpuUsage = 0;
@@ -99,17 +100,26 @@ async function stopCpuMemoryCheck() {
 }
 async function startInspector() {
     const { Session } = await import('node:inspector');
-    log.debug(`Starting heap sampling...`);
+    const { mkdirSync } = await import('node:fs');
+    log.debug(`***Starting heap sampling...`);
+    mkdirSync('heap_profile', { recursive: true });
     try {
         session = new Session();
         session.connect();
         await new Promise((resolve, reject) => {
             session?.post('HeapProfiler.startSampling', (err) => (err ? reject(err) : resolve()));
         });
-        log.debug(`Started heap sampling`);
+        log.debug(`***Started heap sampling`);
+        const interval = getIntParameter('snapshotinterval');
+        if (interval && interval >= 30000) {
+            log.debug(`***Started heap snapshot interval of ${CYAN}${interval}${db} ms`);
+            snapshotInterval = setInterval(async () => {
+                await takeHeapSnapshot();
+            }, interval);
+        }
     }
     catch (err) {
-        log.error(`Failed to start heap sampling: ${err instanceof Error ? err.message : err}`);
+        log.error(`***Failed to start heap sampling: ${err instanceof Error ? err.message : err}`);
         session?.disconnect();
         session = undefined;
         return;
@@ -117,9 +127,15 @@ async function startInspector() {
 }
 async function stopInspector() {
     const { writeFileSync } = await import('node:fs');
-    log.debug(`Stopping heap sampling...`);
+    const path = await import('node:path');
+    log.debug(`***Stopping heap sampling...`);
+    if (snapshotInterval) {
+        log.debug(`***Clearing heap snapshot interval...`);
+        clearInterval(snapshotInterval);
+        await takeHeapSnapshot();
+    }
     if (!session) {
-        log.error('No active inspector session.');
+        log.error('***No active inspector session.');
         return;
     }
     try {
@@ -127,16 +143,56 @@ async function stopInspector() {
             session?.post('HeapProfiler.stopSampling', (err, result) => (err ? reject(err) : resolve(result)));
         });
         const profile = JSON.stringify(result.profile);
-        writeFileSync('Heap-sampling-profile.heapprofile', profile);
-        log.debug('Heap sampling profile saved to Heap-sampling-profile.heapprofile');
+        const filename = path.join('heap_profile', `Heap-profile-${new Date().toISOString().replace(/[:]/g, '-')}.heapprofile`);
+        writeFileSync(filename, profile);
+        log.debug(`***Heap sampling profile saved to ${CYAN}${filename}${db}`);
     }
     catch (err) {
-        log.error(`Failed to stop heap sampling: ${err instanceof Error ? err.message : err}`);
+        log.error(`***Failed to stop heap sampling: ${err instanceof Error ? err.message : err}`);
     }
     finally {
         session.disconnect();
         session = undefined;
-        log.debug(`Stopped heap sampling`);
+        log.debug(`***Stopped heap sampling`);
+    }
+}
+async function takeHeapSnapshot() {
+    const { writeFileSync } = await import('node:fs');
+    const path = await import('node:path');
+    const filename = path.join('heap_profile', `Heap-snapshot-${new Date().toISOString().replace(/[:]/g, '-')}.heapsnapshot`);
+    if (!session) {
+        log.error('No active inspector session.');
+        return;
+    }
+    const chunks = [];
+    const chunksListener = (notification) => {
+        chunks.push(Buffer.from(notification.params.chunk));
+    };
+    session.on('HeapProfiler.addHeapSnapshotChunk', chunksListener);
+    await new Promise((resolve) => {
+        session?.post('HeapProfiler.takeHeapSnapshot', (err) => {
+            if (!err) {
+                session?.off('HeapProfiler.addHeapSnapshotChunk', chunksListener);
+                writeFileSync(filename, Buffer.concat(chunks));
+                log.debug(`***Heap sampling snapshot saved to ${CYAN}${filename}${db}`);
+                triggerGarbageCollection();
+                resolve();
+            }
+            else {
+                session?.off('HeapProfiler.addHeapSnapshotChunk', chunksListener);
+                log.error(`***Failed to take heap snapshot: ${err instanceof Error ? err.message : err}`);
+                resolve();
+            }
+        });
+    });
+}
+function triggerGarbageCollection() {
+    if (typeof global.gc === 'function') {
+        global.gc();
+        log.debug('***Manual garbage collection triggered via global.gc().');
+    }
+    else {
+        log.debug('***Garbage collection is not exposed. Start Node.js with --expose-gc to enable manual GC.');
     }
 }
 function registerHandlers() {
@@ -172,11 +228,11 @@ async function update() {
 }
 async function start() {
     log.debug('Received start memory check event');
-    startCpuMemoryCheck();
+    await startCpuMemoryCheck();
 }
 async function stop() {
     log.debug('Received stop memory check event');
-    stopCpuMemoryCheck();
+    await stopCpuMemoryCheck();
 }
 async function main() {
     log.debug(`Cli main() started`);

package/dist/laundryWasher.js

@@ -1,4 +1,3 @@
-import { OperationalState } from '@matter/main/clusters/operational-state';
 import { LaundryWasherControls } from '@matter/main/clusters/laundry-washer-controls';
 import { LaundryWasherMode } from '@matter/main/clusters/laundry-washer-mode';
 import { TemperatureControl } from '@matter/main/clusters/temperature-control';
@@ -10,25 +9,19 @@ import { laundryWasher } from './matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { MatterbridgeOnOffServer, MatterbridgeServer } from './matterbridgeBehaviors.js';
 export class LaundryWasher extends MatterbridgeEndpoint {
-    constructor(name, serial) {
+    constructor(name, serial, currentMode, supportedModes, spinSpeedCurrent, spinSpeeds, numberOfRinses, supportedRinses, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
         super(laundryWasher, { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Laundry Washer');
         this.createDefaultPowerSourceWiredClusterServer();
-        this.createDeadFrontOnOffClusterServer();
-        this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
-        this.createDefaultLaundryWasherControlsClusterServer();
-        this.createDefaultLaundryWasherModeClusterServer();
-        this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
-    }
-    createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent = 3, spinSpeeds = ['400', '800', '1200', '1600'], numberOfRinses = LaundryWasherControls.NumberOfRinses.Normal, supportedRinses = [LaundryWasherControls.NumberOfRinses.None, LaundryWasherControls.NumberOfRinses.Normal, LaundryWasherControls.NumberOfRinses.Max, LaundryWasherControls.NumberOfRinses.Extra]) {
-        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin, LaundryWasherControls.Feature.Rinse), {
-            spinSpeeds,
-            spinSpeedCurrent,
-            supportedRinses,
-            numberOfRinses,
-        });
-        return this;
+        this.createDeadFrontOnOffClusterServer(true);
+        this.createDefaultLaundryWasherModeClusterServer(currentMode, supportedModes);
+        this.createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent, spinSpeeds, numberOfRinses, supportedRinses);
+        if (temperatureSetpoint)
+            this.createNumberTemperatureControlClusterServer(temperatureSetpoint, minTemperature, maxTemperature, step);
+        else
+            this.createLevelTemperatureControlClusterServer(selectedTemperatureLevel, supportedTemperatureLevels);
+        this.createDefaultOperationalStateClusterServer(operationalState);
     }
     createDefaultLaundryWasherModeClusterServer(currentMode = 2, supportedModes = [
         { label: 'Delicate', mode: 1, modeTags: [{ value: LaundryWasherMode.ModeTag.Delicate }] },
@@ -42,7 +35,16 @@ export class LaundryWasher extends MatterbridgeEndpoint {
         });
         return this;
     }
-    createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot']) {
+    createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent = 2, spinSpeeds = ['400', '800', '1200', '1600'], numberOfRinses = LaundryWasherControls.NumberOfRinses.Normal, supportedRinses = [LaundryWasherControls.NumberOfRinses.None, LaundryWasherControls.NumberOfRinses.Normal, LaundryWasherControls.NumberOfRinses.Max, LaundryWasherControls.NumberOfRinses.Extra]) {
+        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin, LaundryWasherControls.Feature.Rinse), {
+            spinSpeeds,
+            spinSpeedCurrent,
+            supportedRinses,
+            numberOfRinses,
+        });
+        return this;
+    }
+    createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot', '30°', '40°', '60°', '80°']) {
         this.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
             selectedTemperatureLevel,
             supportedTemperatureLevels,
@@ -59,11 +61,11 @@ export class LaundryWasher extends MatterbridgeEndpoint {
         return this;
     }
 }
-class MatterbridgeLevelTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel) {
+export class MatterbridgeLevelTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel) {
     initialize() {
         if (this.state.supportedTemperatureLevels.length >= 2) {
             const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-            device.log.info('MatterbridgeLevelTemperatureControlServer initialized');
+            device.log.info(`MatterbridgeLevelTemperatureControlServer initialized with selectedTemperatureLevel ${this.state.selectedTemperatureLevel} and supportedTemperatureLevels: ${this.state.supportedTemperatureLevels.join(', ')}`);
         }
     }
     setTemperature(request) {
@@ -77,10 +79,10 @@ class MatterbridgeLevelTemperatureControlServer extends TemperatureControlServer
         }
     }
 }
-class MatterbridgeNumberTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber) {
+export class MatterbridgeNumberTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep) {
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.log.info('MatterbridgeNumberTemperatureControlServer initialized');
+        device.log.info(`MatterbridgeNumberTemperatureControlServer initialized with temperatureSetpoint ${this.state.temperatureSetpoint} minTemperature ${this.state.minTemperature} maxTemperature ${this.state.maxTemperature} step ${this.state.step}`);
     }
     setTemperature(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
@@ -93,10 +95,10 @@ class MatterbridgeNumberTemperatureControlServer extends TemperatureControlServe
         }
     }
 }
-class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
+export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
-        device.log.info(`LaundryWasherModeServer initialized: currentMode is ${this.state.currentMode}`);
+        device.log.info(`MatterbridgeLaundryWasherModeServer initialized: currentMode is ${this.state.currentMode}`);
         this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
     }
     handleOnOffChange(onOff) {
@@ -110,12 +112,13 @@ class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
         const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
         const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
         if (supportedMode) {
-            device.log.info(`LaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
+            device.log.info(`MatterbridgeLaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} => ${supportedMode.label}`);
+            device.changeToMode({ newMode: request.newMode });
             this.state.currentMode = request.newMode;
             return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
         }
         else {
-            device.log.error(`LaundryWasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            device.log.error(`MatterbridgeLaundryWasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
             return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
         }
     }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.5-dev-20250526-422f029",
+  "version": "3.0.5-dev-20250528-9314890",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.5-dev-20250526-422f029",
+      "version": "3.0.5-dev-20250528-9314890",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.5-dev-20250526-422f029",
+  "version": "3.0.5-dev-20250528-9314890",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",