@matterbridge/core 3.9.0 → 3.9.1-dev-20260614-18d1a2e

package/dist/backend.js

@@ -110,7 +110,7 @@ export class Backend extends EventEmitter {
                         socket.destroy();
                     }
                 }
-                return undefined;
+                return;
             });
             this.httpServer.on('error', (error) => {
                 this.log.error(`Frontend http server error listening on ${this.port}`);
@@ -239,7 +239,7 @@ export class Backend extends EventEmitter {
                         socket.destroy();
                     }
                 }
-                return undefined;
+                return;
             });
             this.httpsServer.on('error', (error) => {
                 this.log.error(`Frontend https server error listening on ${this.port}`);

package/dist/backendExpress.d.ts

@@ -1,6 +1,6 @@
 import { type SharedMatterbridge } from '@matterbridge/types';
 import express from 'express';
-import { Backend } from './backend.js';
+import { type Backend } from './backend.js';
 export declare class BackendExpress {
     private debug;
     private verbose;

package/dist/backendWsServer.d.ts

@@ -1,7 +1,7 @@
 import type { EndpointNumber } from '@matter/types/datatype';
 import type { ApiMatter, RefreshRequiredChanged, SharedMatterbridge, WsMessageBroadcast } from '@matterbridge/types';
 import { WebSocketServer } from 'ws';
-import { Backend } from './backend.js';
+import { type Backend } from './backend.js';
 export declare class BackendWsServer {
     private debug;
     private verbose;

package/dist/behaviors/activatedCarbonFilterMonitoringServer.d.ts

@@ -1,5 +1,5 @@
 import { ActivatedCarbonFilterMonitoringServer } from '@matter/node/behaviors/activated-carbon-filter-monitoring';
-import { ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
+import { type ActivatedCarbonFilterMonitoring } from '@matter/types/clusters/activated-carbon-filter-monitoring';
 declare const MatterbridgeActivatedCarbonFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof ActivatedCarbonFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<ActivatedCarbonFilterMonitoring, {
     warning: false;
     condition: true;

package/dist/behaviors/bindingServer.d.ts

@@ -1,7 +1,7 @@
-import { Endpoint } from '@matter/main/node';
+import { type Endpoint } from '@matter/main/node';
 import { BindingBehavior, BindingServer } from '@matter/node/behaviors/binding';
-import { ClusterId } from '@matter/types';
-import { Binding } from '@matter/types/clusters/binding';
+import { type ClusterId } from '@matter/types';
+import { type Binding } from '@matter/types/clusters/binding';
 export declare class MatterbridgeBindingServer extends BindingServer {
     protected internal: MatterbridgeBindingServer.Internal;
     state: MatterbridgeBindingServer.State;

package/dist/behaviors/hepaFilterMonitoringServer.d.ts

@@ -1,5 +1,5 @@
 import { HepaFilterMonitoringServer } from '@matter/node/behaviors/hepa-filter-monitoring';
-import { HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
+import { type HepaFilterMonitoring } from '@matter/types/clusters/hepa-filter-monitoring';
 declare const MatterbridgeHepaFilterMonitoringServer_base: import("@matter/node").ClusterBehavior.Type<typeof HepaFilterMonitoringServer, import("@matter/types").ClusterType.WithSupportedFeatures<HepaFilterMonitoring, {
     warning: false;
     condition: true;

package/dist/behaviors/identifyServer.d.ts

@@ -1,5 +1,5 @@
 import { IdentifyServer } from '@matter/node/behaviors/identify';
-import { Identify } from '@matter/types/clusters/identify';
+import { type Identify } from '@matter/types/clusters/identify';
 export declare class MatterbridgeIdentifyServer extends IdentifyServer {
     identify(request: Identify.IdentifyRequest): Promise<void>;
     triggerEffect(request: Identify.TriggerEffectRequest): Promise<void>;

package/dist/behaviors/levelControlServer.d.ts

@@ -1,5 +1,5 @@
 import { LevelControlServer } from '@matter/node/behaviors/level-control';
-import { LevelControl } from '@matter/types/clusters/level-control';
+import { type LevelControl } from '@matter/types/clusters/level-control';
 export declare class MatterbridgeLevelControlServer extends LevelControlServer {
     moveToLevel(request: LevelControl.MoveToLevelRequest): Promise<void>;
     moveToLevelWithOnOff(request: LevelControl.MoveToLevelRequest): Promise<void>;

package/dist/behaviors/matterbridgeServer.d.ts

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

package/dist/behaviors/modeSelectServer.d.ts

@@ -1,5 +1,5 @@
 import { ModeSelectServer } from '@matter/node/behaviors/mode-select';
-import { ModeSelect } from '@matter/types/clusters/mode-select';
+import { type ModeSelect } from '@matter/types/clusters/mode-select';
 export declare class MatterbridgeModeSelectServer extends ModeSelectServer {
     changeToMode(request: ModeSelect.ChangeToModeRequest): Promise<void>;
 }

package/dist/behaviors/operationalStateServer.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from '@matter/general';
+import { type MaybePromise } from '@matter/general';
 import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 export declare class MatterbridgeOperationalStateServer extends OperationalStateServer {

package/dist/behaviors/serviceAreaServer.d.ts

@@ -1,5 +1,5 @@
 import { ServiceAreaServer } from '@matter/node/behaviors/service-area';
-import { ServiceArea } from '@matter/types/clusters/service-area';
+import { type ServiceArea } from '@matter/types/clusters/service-area';
 export declare class MatterbridgeServiceAreaServer extends ServiceAreaServer {
     selectAreas(request: ServiceArea.SelectAreasRequest): Promise<ServiceArea.SelectAreasResponse>;
 }

package/dist/behaviors/windowCoveringServer.d.ts

@@ -1,4 +1,4 @@
-import { WindowCoveringBaseServer, WindowCoveringServer } from '@matter/node/behaviors/window-covering';
+import { type WindowCoveringBaseServer, WindowCoveringServer } from '@matter/node/behaviors/window-covering';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 declare const MatterbridgeWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<typeof WindowCoveringServer, import("@matter/types").ClusterType.WithSupportedFeatures<WindowCovering, {
     lift: true;

package/dist/cli.js

@@ -50,14 +50,14 @@ function registerHandlers() {
     log.debug('Registering event handlers...');
     if (!instance)
         return;
-    instance.on('shutdown', () => shutdown());
-    instance.on('restart', () => restart());
-    instance.on('update', () => update());
+    instance.on('shutdown', async () => shutdown());
+    instance.on('restart', async () => restart());
+    instance.on('update', async () => update());
     instance.on('startmemorycheck', () => start());
     instance.on('stopmemorycheck', () => stop());
-    instance.on('startinspector', () => startInspector());
-    instance.on('stopinspector', () => stopInspector());
-    instance.on('takeheapsnapshot', () => takeHeapSnapshot());
+    instance.on('startinspector', async () => startInspector());
+    instance.on('stopinspector', async () => stopInspector());
+    instance.on('takeheapsnapshot', async () => takeHeapSnapshot());
     instance.on('triggergarbagecollection', () => triggerGarbageCollection());
     log.debug('Registered event handlers');
 }

package/dist/clusters/closure-control.d.ts

@@ -1,8 +1,8 @@
-import { type MaybePromise } from '@matter/general';
+import type { MaybePromise } from '@matter/general';
 import { ClusterElement, ClusterModel } from '@matter/main/model';
 import { ClusterType, type ClusterTyping } from '@matter/types/cluster';
-import { type ClusterId } from '@matter/types/datatype';
-import { type ThreeLevelAuto } from '@matter/types/globals';
+import type { ClusterId } from '@matter/types/datatype';
+import type { ThreeLevelAuto } from '@matter/types/globals';
 export declare const ClosureControlDefinition: ClusterElement;
 export declare const ClosureControlModel: ClusterModel;
 export declare namespace ClosureControl {

package/dist/clusters/closure-dimension.d.ts

@@ -1,8 +1,8 @@
-import { type MaybePromise } from '@matter/general';
+import type { MaybePromise } from '@matter/general';
 import { ClusterElement, ClusterModel } from '@matter/main/model';
 import { ClusterType, type ClusterTyping } from '@matter/types/cluster';
-import { type ClusterId } from '@matter/types/datatype';
-import { type ThreeLevelAuto } from '@matter/types/globals';
+import type { ClusterId } from '@matter/types/datatype';
+import type { ThreeLevelAuto } from '@matter/types/globals';
 export declare const ClosureDimensionDefinition: ClusterElement;
 export declare const ClosureDimensionModel: ClusterModel;
 export declare namespace ClosureDimension {

package/dist/clusters/soil-measurement.d.ts

@@ -1,7 +1,7 @@
 import { ClusterElement, ClusterModel } from '@matter/main/model';
 import { ClusterType, type ClusterTyping } from '@matter/types/cluster';
-import { type ClusterId } from '@matter/types/datatype';
-import { type MeasurementAccuracy } from '@matter/types/globals';
+import type { ClusterId } from '@matter/types/datatype';
+import type { MeasurementAccuracy } from '@matter/types/globals';
 export declare const SoilMeasurementDefinition: ClusterElement;
 export declare const SoilMeasurementModel: ClusterModel;
 export declare namespace SoilMeasurement {

package/dist/devices/basicVideoPlayer.js

@@ -48,7 +48,7 @@ export class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff === true)
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff)
             this.state.currentState = MediaPlayback.PlaybackState.Playing;
         return { status: MediaPlayback.Status.Success };
     }
@@ -62,7 +62,7 @@ export class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff === true)
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff)
             this.state.currentState = MediaPlayback.PlaybackState.Paused;
         return { status: MediaPlayback.Status.Success };
     }
@@ -76,7 +76,7 @@ export class MatterbridgeMediaPlaybackServer extends MediaPlaybackServer {
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff === true)
+        if (this.endpoint.stateOf(MatterbridgeOnOffServer).onOff)
             this.state.currentState = MediaPlayback.PlaybackState.NotPlaying;
         return { status: MediaPlayback.Status.Success };
     }

package/dist/devices/cooktop.d.ts

@@ -1,4 +1,4 @@
-import { Semtag } from '@matter/types';
+import { type Semtag } from '@matter/types';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class Cooktop extends MatterbridgeEndpoint {
     constructor(name: string, serial: string);

package/dist/devices/dishwasher.d.ts

@@ -1,7 +1,7 @@
 import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
 import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
-import { OperationalState } from '@matter/types/clusters/operational-state';
+import { type OperationalState } from '@matter/types/clusters/operational-state';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class Dishwasher extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: DishwasherMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);

package/dist/devices/dishwasher.js

@@ -51,7 +51,7 @@ export class MatterbridgeDishwasherModeServer extends DishwasherModeServer {
     }
     handleOnOffChange(onOff) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        if (onOff === false) {
+        if (!onOff) {
             device.log.info('OnOffServer changed to OFF: setting Dead Front state to Manufacturer Specific');
             this.state.currentMode = 2;
         }

package/dist/devices/evse.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from '@matter/general';
+import { type MaybePromise } from '@matter/general';
 import { EnergyEvseServer } from '@matter/node/behaviors/energy-evse';
 import { EnergyEvseModeServer } from '@matter/node/behaviors/energy-evse-mode';
 import { EnergyEvse } from '@matter/types/clusters/energy-evse';

package/dist/devices/irrigationSystem.d.ts

@@ -1,5 +1,5 @@
 import { OperationalState } from '@matter/types/clusters/operational-state';
-import { Semtag } from '@matter/types/globals';
+import { type Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export interface IrrigationSystemOptions {
     singleZone?: boolean;

package/dist/devices/laundryDryer.d.ts

@@ -1,6 +1,6 @@
 import { LaundryDryerControls } from '@matter/types/clusters/laundry-dryer-controls';
 import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
-import { OperationalState } from '@matter/types/clusters/operational-state';
+import { type OperationalState } from '@matter/types/clusters/operational-state';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class LaundryDryer extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);

package/dist/devices/laundryWasher.d.ts

@@ -2,7 +2,7 @@ import { LaundryWasherModeServer } from '@matter/node/behaviors/laundry-washer-m
 import { LaundryWasherControls } from '@matter/types/clusters/laundry-washer-controls';
 import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
 import { ModeBase } from '@matter/types/clusters/mode-base';
-import { OperationalState } from '@matter/types/clusters/operational-state';
+import { type OperationalState } from '@matter/types/clusters/operational-state';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class LaundryWasher extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[], spinSpeedCurrent?: number, spinSpeeds?: string[], numberOfRinses?: LaundryWasherControls.NumberOfRinses, supportedRinses?: LaundryWasherControls.NumberOfRinses[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);

package/dist/devices/laundryWasher.js

@@ -59,7 +59,7 @@ export class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer
     handleOnOffChange(onOff) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`HandleOnOffChange (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        if (onOff === false) {
+        if (!onOff) {
             device.log.notice('OnOffServer changed to OFF: setting Dead Front state to Manufacturer Specific');
             this.state.currentMode = 2;
         }

package/dist/devices/oven.d.ts

@@ -1,7 +1,7 @@
-import { MaybePromise } from '@matter/general';
+import { type MaybePromise } from '@matter/general';
 import { OvenCavityOperationalStateServer } from '@matter/node/behaviors/oven-cavity-operational-state';
 import { OvenModeServer } from '@matter/node/behaviors/oven-mode';
-import { Semtag } from '@matter/types';
+import { type Semtag } from '@matter/types';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 import { OvenMode } from '@matter/types/clusters/oven-mode';

package/dist/devices/refrigerator.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise } from '@matter/general';
+import { type MaybePromise } from '@matter/general';
 import { RefrigeratorAndTemperatureControlledCabinetModeServer } from '@matter/node/behaviors/refrigerator-and-temperature-controlled-cabinet-mode';
-import { Semtag } from '@matter/types';
+import { type Semtag } from '@matter/types';
 import { ModeBase } from '@matter/types/clusters/mode-base';
 import { RefrigeratorAndTemperatureControlledCabinetMode } from '@matter/types/clusters/refrigerator-and-temperature-controlled-cabinet-mode';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';

package/dist/devices/roboticVacuumCleaner.d.ts

@@ -9,7 +9,7 @@ import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { ServiceArea } from '@matter/types/clusters/service-area';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class RoboticVacuumCleaner extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, mode?: 'server' | 'matter' | undefined, currentRunMode?: number, supportedRunModes?: RvcRunMode.ModeOption[], currentCleanMode?: number, supportedCleanModes?: RvcCleanMode.ModeOption[], currentPhase?: number | null, phaseList?: string[] | null, operationalState?: RvcOperationalState.OperationalState, operationalStateList?: RvcOperationalState.OperationalStateStruct[], supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]);
+    constructor(name: string, serial: string, mode?: 'server' | 'matter', currentRunMode?: number, supportedRunModes?: RvcRunMode.ModeOption[], currentCleanMode?: number, supportedCleanModes?: RvcCleanMode.ModeOption[], currentPhase?: number | null, phaseList?: string[] | null, operationalState?: RvcOperationalState.OperationalState, operationalStateList?: RvcOperationalState.OperationalStateStruct[], supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]);
     createDefaultRvcRunModeClusterServer(currentMode?: number, supportedModes?: RvcRunMode.ModeOption[]): this;
     createDefaultRvcCleanModeClusterServer(currentMode?: number, supportedModes?: RvcCleanMode.ModeOption[]): this;
     createDefaultServiceAreaClusterServer(supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number | null, supportedMaps?: ServiceArea.Map[]): this;

package/dist/devices/roboticVacuumCleaner.js

@@ -14,7 +14,7 @@ import { MatterbridgeServiceAreaServer } from '../behaviors/serviceAreaServer.js
 import { powerSource, roboticVacuumCleaner } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class RoboticVacuumCleaner extends MatterbridgeEndpoint {
-    constructor(name, serial, mode = undefined, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea, supportedMaps) {
+    constructor(name, serial, mode, currentRunMode, supportedRunModes, currentCleanMode, supportedCleanModes, currentPhase = null, phaseList = null, operationalState, operationalStateList, supportedAreas, selectedAreas, currentArea, supportedMaps) {
         super([roboticVacuumCleaner, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, mode });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Robot Vacuum Cleaner')

package/dist/devices/soilSensor.d.ts

@@ -1,4 +1,4 @@
-import { type MeasurementAccuracy } from '@matter/types/globals';
+import type { MeasurementAccuracy } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export interface SoilSensorOptions {
     soilMoistureMeasurementLimits?: MeasurementAccuracy;

package/dist/devices/solarPower.d.ts

@@ -1,4 +1,4 @@
-import { Semtag } from '@matter/types/globals';
+import { type Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class SolarPower extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyExported?: number | bigint, absMinPower?: number, absMaxPower?: number);

package/dist/devices/temperatureControl.d.ts

@@ -1,6 +1,6 @@
 import { TemperatureControlServer } from '@matter/node/behaviors/temperature-control';
 import { TemperatureControl } from '@matter/types/clusters/temperature-control';
-import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare function createLevelTemperatureControlClusterServer(endpoint: MatterbridgeEndpoint, selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[]): MatterbridgeEndpoint;
 export declare function createNumberTemperatureControlClusterServer(endpoint: MatterbridgeEndpoint, temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number): MatterbridgeEndpoint;
 declare const MatterbridgeLevelTemperatureControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof TemperatureControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<TemperatureControl, {

package/dist/frontend.d.ts

@@ -1,5 +1,5 @@
 import EventEmitter from 'node:events';
-import { EndpointNumber } from '@matter/types/datatype';
+import { type EndpointNumber } from '@matter/types/datatype';
 import type { ApiClusters, ApiDevice, ApiMatter, ApiPlugin, ApiSettings, RefreshRequiredChanged, WsMessageBroadcast } from '@matterbridge/types';
 import { LogLevel } from 'node-ansi-logger';
 import type { Matterbridge } from './matterbridge.js';

package/dist/frontend.js

@@ -124,7 +124,7 @@ export class Frontend extends EventEmitter {
                 this.log.debug(`Received broadcast response ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
             switch (msg.type) {
                 case 'manager_spawn_response':
-                    if (msg.result && msg.result.packageCommand === 'install') {
+                    if (msg.result?.packageCommand === 'install') {
                         this.wssSendCloseSnackbarMessage(`Installing package ${msg.result.packageName}...`);
                         if (msg.result.success) {
                             this.restartRequired = true;
@@ -137,7 +137,7 @@ export class Frontend extends EventEmitter {
                             this.wssSendSnackbarMessage(`Package ${msg.result.packageName} not installed`, 10, 'error');
                         }
                     }
-                    if (msg.result && msg.result.packageCommand === 'uninstall') {
+                    if (msg.result?.packageCommand === 'uninstall') {
                         this.wssSendCloseSnackbarMessage(`Uninstalling package ${msg.result.packageName}...`);
                         if (msg.result.success) {
                             this.restartRequired = true;
@@ -152,8 +152,7 @@ export class Frontend extends EventEmitter {
                     }
                     break;
                 case 'manager_archive_response':
-                    if (msg.result &&
-                        msg.result.success &&
+                    if (msg.result?.success &&
                         isValidString(msg.result.command) &&
                         isValidString(msg.result.archivePath) &&
                         isValidArray(msg.result.sourcePaths) &&
@@ -706,7 +705,7 @@ export class Frontend extends EventEmitter {
             res.download(path.join(os.tmpdir(), `matterbridge.${NODE_STORAGE_DIR}.zip`), `matterbridge.${NODE_STORAGE_DIR}.zip`, (error) => {
                 this.wssSendCloseSnackbarMessage('Creating matterbridge storage backup...');
                 if (error) {
-                    this.log.error(`Error downloading file ${`matterbridge.${NODE_STORAGE_DIR}.zip`}: ${error instanceof Error ? error.message : error}`);
+                    this.log.error(`Error downloading file matterbridge.${NODE_STORAGE_DIR}.zip: ${error instanceof Error ? error.message : error}`);
                     res.status(500).send('Error downloading the matterbridge storage file');
                 }
                 else {
@@ -962,7 +961,7 @@ export class Frontend extends EventEmitter {
             return false;
         if (device.hasClusterServer(BridgedDeviceBasicInformation.id))
             return device.getAttribute(BridgedDeviceBasicInformation.id, 'reachable');
-        if (device.mode === 'server' && device.serverNode && device.serverNode.state.basicInformation.reachable !== undefined)
+        if (device.mode === 'server' && device.serverNode?.state.basicInformation.reachable !== undefined)
             return device.serverNode.state.basicInformation.reachable;
         if (this.matterbridge.bridgeMode === 'childbridge')
             return true;
@@ -1003,7 +1002,7 @@ export class Frontend extends EventEmitter {
                 const batChargeLevel = device.getAttribute(PowerSource.id, 'batPercentRemaining');
                 return isValidNumber(batChargeLevel) ? batChargeLevel / 2 : undefined;
             }
-            return undefined;
+            return;
         };
         if (endpoint.hasClusterServer(PowerSource.id))
             return batteryLevel(endpoint);
@@ -1054,11 +1053,11 @@ export class Frontend extends EventEmitter {
                 attributes += `Heat to: ${attributeValue / 100}°C `;
             if (clusterName === 'thermostat' && attributeName === 'occupiedCoolingSetpoint' && isValidNumber(attributeValue))
                 attributes += `Cool to: ${attributeValue / 100}°C `;
-            const modeClusters = ['modeSelect', 'rvcRunMode', 'rvcCleanMode', 'laundryWasherMode', 'ovenMode', 'microwaveOvenMode'];
-            if (modeClusters.includes(clusterName) && attributeName === 'supportedModes') {
+            const modeClusters = new Set(['modeSelect', 'rvcRunMode', 'rvcCleanMode', 'laundryWasherMode', 'ovenMode', 'microwaveOvenMode']);
+            if (modeClusters.has(clusterName) && attributeName === 'supportedModes') {
                 supportedModes = attributeValue;
             }
-            if (modeClusters.includes(clusterName) && attributeName === 'currentMode') {
+            if (modeClusters.has(clusterName) && attributeName === 'currentMode') {
                 const supportedMode = supportedModes.find((mode) => mode.mode === attributeValue);
                 if (supportedMode)
                     attributes += `Mode: ${supportedMode.label} `;
@@ -1199,7 +1198,7 @@ export class Frontend extends EventEmitter {
         const endpoint = this.matterbridge.devices
             .array()
             .find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber && (!serialNumber || d.serialNumber === serialNumber) && (!uniqueId || d.uniqueId === uniqueId));
-        if (!endpoint || !endpoint.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber) {
+        if (!endpoint?.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber) {
             this.log.error(`getClusters: no device found for plugin ${pluginName} and endpoint number ${endpointNumber} (serial: ${serialNumber ?? 'N/A'}, uniqueId: ${uniqueId ?? 'N/A'})`);
             return;
         }
@@ -1871,7 +1870,7 @@ export class Frontend extends EventEmitter {
                         }
                         break;
                     case 'setmatterport':
-                        const port = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
+                        const port = isValidString(data.params.value) ? Number.parseInt(data.params.value) : 0;
                         if (isValidNumber(port, 5540, 5600)) {
                             this.log.debug(`Set matter commissioning port to ${CYAN}${port}${db}`);
                             this.matterbridge.port = this.matterbridge.initialPort = port;
@@ -1890,7 +1889,7 @@ export class Frontend extends EventEmitter {
                         }
                         break;
                     case 'setmatterdiscriminator':
-                        const discriminator = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
+                        const discriminator = isValidString(data.params.value) ? Number.parseInt(data.params.value) : 0;
                         if (isValidNumber(discriminator, 0, 4095)) {
                             this.log.debug(`Set matter commissioning discriminator to ${CYAN}${discriminator}${db}`);
                             this.matterbridge.discriminator = this.matterbridge.initialDiscriminator = discriminator;
@@ -1915,8 +1914,8 @@ export class Frontend extends EventEmitter {
                         }
                         break;
                     case 'setmatterpasscode':
-                        const passcode = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
-                        if (isValidNumber(passcode, 1, 99999998) && CommissioningOptions.FORBIDDEN_PASSCODES.includes(passcode) === false) {
+                        const passcode = isValidString(data.params.value) ? Number.parseInt(data.params.value) : 0;
+                        if (isValidNumber(passcode, 1, 99999998) && !CommissioningOptions.FORBIDDEN_PASSCODES.includes(passcode)) {
                             this.matterbridge.passcode = this.matterbridge.initialPasscode = passcode;
                             this.log.debug(`Set matter commissioning passcode to ${CYAN}${passcode}${db}`);
                             await this.matterbridge.nodeContext?.set('matterpasscode', passcode);
@@ -2101,7 +2100,7 @@ export class Frontend extends EventEmitter {
         this.log.debug('Sending a restart required message to all connected clients');
         this.restartRequired = true;
         this.fixedRestartRequired = fixed;
-        if (snackbar === true)
+        if (snackbar)
             this.wssSendSnackbarMessage(`Restart required`, 0);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
     }
@@ -2110,7 +2109,7 @@ export class Frontend extends EventEmitter {
             return;
         this.log.debug('Sending a restart not required message to all connected clients');
         this.restartRequired = false;
-        if (snackbar === true)
+        if (snackbar)
             this.wssSendCloseSnackbarMessage(`Restart required`);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
     }

package/dist/helpers.d.ts

@@ -1,5 +1,5 @@
 import { Endpoint } from '@matter/node';
-import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
+import { type AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
 import type { Matterbridge } from './matterbridge.js';
 export declare function addVirtualDevice(aggregatorEndpoint: Endpoint<AggregatorEndpoint>, name: string, type: 'light' | 'outlet' | 'switch' | 'mounted_switch', callback: () => Promise<void>): Promise<Endpoint>;
 export declare function addVirtualDevices(matterbridge: Matterbridge, aggregatorEndpoint: Endpoint<AggregatorEndpoint>): Promise<void>;

package/dist/helpers.js

@@ -10,9 +10,6 @@ import { OnOffLightDevice } from '@matter/node/devices/on-off-light';
 import { OnOffLightSwitchDevice } from '@matter/node/devices/on-off-light-switch';
 import { OnOffPlugInUnitDevice } from '@matter/node/devices/on-off-plug-in-unit';
 import { VendorId } from '@matter/types/datatype';
-import { hasParameter } from '@matterbridge/utils/cli';
-import { doorLock } from './matterbridgeDeviceTypes.js';
-import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 export async function addVirtualDevice(aggregatorEndpoint, name, type, callback) {
     let deviceType;
     switch (type) {
@@ -59,13 +56,6 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
     return device;
 }
 export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
-    if (hasParameter('experimental') && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
-        const lockUserPin = new MatterbridgeEndpoint(doorLock, { id: 'door_lock_user_pin' });
-        lockUserPin.createDefaultBridgedDeviceBasicInformationClusterServer('Matterbridge User Pin Lock', 'sn_system_lock', 0xfff1, 'Matterbridge', 'Matterbridge Virtual Device', 20000, '2.0.0');
-        lockUserPin.createUserPinDoorLockClusterServer();
-        lockUserPin.addRequiredClusterServers();
-        await aggregatorEndpoint.add(lockUserPin);
-    }
     if (matterbridge.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
         matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);
         await addVirtualDevice(aggregatorEndpoint, 'Restart Matterbridge', matterbridge.virtualMode, async () => {

package/dist/jestutils/jestBroadcastServerSpy.d.ts

@@ -1,12 +1,13 @@
-export declare const closeBroadcastServerSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const getUniqueIdBroadcastServerSpy: import("jest-mock").SpiedFunction<() => number>;
-export declare const isWorkerRequestBroadcastServerSpy: import("jest-mock").SpiedFunction<(value: unknown) => value is import("@matterbridge/types").WorkerMessageRequest>;
-export declare const isWorkerRequestOfTypeBroadcastServerSpy: import("jest-mock").SpiedFunction<(<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(value: unknown, type: K) => value is import("@matterbridge/types").WorkerMessageRequest<K>)>;
-export declare const isWorkerResponseBroadcastServerSpy: import("jest-mock").SpiedFunction<(value: unknown) => value is import("@matterbridge/types").WorkerMessageResponse>;
-export declare const isWorkerResponseOfTypeBroadcastServerSpy: import("jest-mock").SpiedFunction<(<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(value: unknown, type: K) => value is import("@matterbridge/types").WorkerMessageResponse<K>)>;
-export declare const broadcastBroadcastServerSpy: import("jest-mock").SpiedFunction<(message: import("@matterbridge/types").WorkerMessage) => void>;
-export declare const requestBroadcastServerSpy: import("jest-mock").SpiedFunction<(<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(message: import("@matterbridge/types").WorkerMessageRequest<K>) => void)>;
-export declare const respondBroadcastServerSpy: import("jest-mock").SpiedFunction<(<K extends keyof import("@matterbridge/types").WorkerMessageTypes>(message: import("@matterbridge/types").WorkerMessageResponse<K>) => void)>;
-export declare const fetchBroadcastServerSpy: import("jest-mock").SpiedFunction<(<T extends import("@matterbridge/types").WorkerMessageRequestAny, K extends Extract<keyof import("@matterbridge/types").WorkerMessageTypes, T["type"]>>(message: T, timeout?: number) => Promise<import("@matterbridge/types").WorkerMessageResponseSuccess<K>>)>;
-export declare const broadcastMessageHandlerBroadcastServerSpy: import("jest-mock").SpiedGetter<import("@matterbridge/types").WorkerSrcType> | import("jest-mock").SpiedSetter<import("@matterbridge/types").WorkerSrcType>;
-export declare const broadcastMessageErrorHandlerBroadcastServerSpy: import("jest-mock").SpiedGetter<import("@matterbridge/types").WorkerSrcType> | import("jest-mock").SpiedSetter<import("@matterbridge/types").WorkerSrcType>;
+import { BroadcastServer } from '@matterbridge/thread/server';
+export declare const closeBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.close>;
+export declare const getUniqueIdBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.getUniqueId>;
+export declare const isWorkerRequestBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerRequest>;
+export declare const isWorkerRequestOfTypeBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerRequestOfType>;
+export declare const isWorkerResponseBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerResponse>;
+export declare const isWorkerResponseOfTypeBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.isWorkerResponseOfType>;
+export declare const broadcastBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.broadcast>;
+export declare const requestBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.request>;
+export declare const respondBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.respond>;
+export declare const fetchBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.fetch>;
+export declare const broadcastMessageHandlerBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.broadcastMessageHandler>;
+export declare const broadcastMessageErrorHandlerBroadcastServerSpy: jest.SpiedFunction<typeof BroadcastServer.prototype.broadcastMessageErrorHandler>;

package/dist/jestutils/jestBroadcastServerSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { BroadcastServer } from '@matterbridge/thread/server';
+const { jest } = await import('@jest/globals');
 export const closeBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'close');
 export const getUniqueIdBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'getUniqueId');
 export const isWorkerRequestBroadcastServerSpy = jest.spyOn(BroadcastServer.prototype, 'isWorkerRequest');

package/dist/jestutils/jestDeviceManagerSpy.d.ts

@@ -1,13 +1,14 @@
-export declare const destroyDeviceManagerSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const lengthDeviceManagerSpy: import("jest-mock").SpiedGetter<number>;
-export declare const sizeDeviceManagerSpy: import("jest-mock").SpiedGetter<number>;
-export declare const hasDeviceManagerSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => boolean>;
-export declare const getDeviceManagerSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const setDeviceManagerSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint>;
-export declare const removeDeviceManagerSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => boolean>;
-export declare const clearDeviceManagerSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const arrayDeviceManagerSpy: import("jest-mock").SpiedFunction<() => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint[]>;
-export declare const baseArrayDeviceManagerSpy: import("jest-mock").SpiedFunction<(pluginName?: string) => import("@matterbridge/types").BaseDevice[]>;
-export declare const iteratorDeviceManagerSpy: import("jest-mock").SpiedFunction<() => MapIterator<import("../matterbridgeEndpoint.js").MatterbridgeEndpoint>>;
-export declare const forEachDeviceManagerSpy: import("jest-mock").SpiedFunction<(callback: (device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>) => Promise<void>>;
-export declare const logLevelDeviceManagerSpy: import("jest-mock").SpiedSetter<import("node-ansi-logger").LogLevel>;
+import { DeviceManager } from '../deviceManager.js';
+export declare const destroyDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.destroy>;
+export declare const lengthDeviceManagerSpy: jest.SpiedGetter<typeof DeviceManager.prototype.length>;
+export declare const sizeDeviceManagerSpy: jest.SpiedGetter<typeof DeviceManager.prototype.size>;
+export declare const hasDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.has>;
+export declare const getDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.get>;
+export declare const setDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.set>;
+export declare const removeDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.remove>;
+export declare const clearDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.clear>;
+export declare const arrayDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.array>;
+export declare const baseArrayDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.baseArray>;
+export declare const iteratorDeviceManagerSpy: jest.SpiedFunction<(typeof DeviceManager.prototype)[typeof Symbol.iterator]>;
+export declare const forEachDeviceManagerSpy: jest.SpiedFunction<typeof DeviceManager.prototype.forEach>;
+export declare const logLevelDeviceManagerSpy: jest.SpiedSetter<typeof DeviceManager.prototype.logLevel>;