matterbridge 3.3.8-dev-20251117-e3fb774 → 3.3.9-dev-20251118-930cfdb

package/CHANGELOG.md

@@ -28,6 +28,24 @@ Advantages:
 - individual plugin isolation in childbridge mode;
 - ability to update the plugin in childbridge mode without restarting matterbridge;
 
+## [3.3.9] - Not published
+
+### Development Breaking Changes
+
+Removed the following long deprecated elements:
+
+- [platform]: Matterbridge instead of PlatformMatterbridge in the platform constructor (deprecated since 3.0.0).
+- [endpoint]: uniqueStorageKey instead of id in MatterbridgeEndpointOptions (deprecated since months).
+- [endpoint]: endpointId instead of number in MatterbridgeEndpointOptions (deprecated since months).
+
+### Changed
+
+- [package]: Updated dependencies.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [3.3.8] - 2025-11-15
 
 ### Development Breaking Changes

package/README-DEV.md

@@ -199,7 +199,7 @@ The plugin platform type.
 The plugin config (loaded before the platform constructor is called and saved after onShutdown() is called).
 Here you can store your plugin configuration (see matterbridge-zigbee2mqtt for example)
 
-### constructor(matterbridge: Matterbridge, log: AnsiLogger, config: PlatformConfig)
+### constructor(matterbridge: PlatformMatterbridge, log: AnsiLogger, config: PlatformConfig)
 
 The contructor is called when is plugin is loaded.
 
@@ -282,7 +282,7 @@ You create a Matter device with a new instance of MatterbridgeEndpoint(definitio
 
 In the above example we create a contact sensor device type with also a power source device type feature replaceble battery.
 
-All device types are defined in src\matterbridgeDeviceTypes.ts and taken from the 'Matter-1.4-Device-Library-Specification.pdf'.
+All device types are defined in src\matterbridgeDeviceTypes.ts and taken from the 'Matter-1.4.1-Device-Library-Specification.pdf'.
 
 All default cluster helpers are available as methods of MatterbridgeEndpoint.
 
@@ -293,12 +293,6 @@ All default cluster helpers are available as methods of MatterbridgeEndpoint.
 - @param {string} [id] - The unique storage key for the endpoint. If not provided, a default key will be used.
 - @param {EndpointNumber} [number] - The endpoint number for the endpoint. If not provided, the endpoint will be created with the next available endpoint number.
 
-```typescript
-    const robot = new RoboticVacuumCleaner('Robot Vacuum', 'RVC1238777820', 'server');
-```
-
-In the above example we create a Rvc device type with its own server node.
-
 The mode=`server` property of MatterbridgeEndpointOptions, allows to create an independent (not bridged) Matter device with its server node. In this case the bridge mode is not relevant.
 
 The mode=`matter` property of MatterbridgeEndpointOptions, allows to create a (not bridged) Matter device that is added to the Matterbridge server node alongside the aggregator.
@@ -318,50 +312,50 @@ const robot = new RoboticVacuumCleaner('Robot Vacuum', 'RVC1238777820', 'server'
 ### Chapter 13. Appliances Device Types - Single class device types
 
 ```typescript
-    this.laundryWasher = new LaundryWasher('Laundry Washer', 'LW1234567890');
+const laundryWasher = new LaundryWasher('Laundry Washer', 'LW1234567890');
 ```
 
 ```typescript
-    this.laundryDryer = new LaundryDryer('Laundry Dryer', 'LDW1235227890');
+const laundryDryer = new LaundryDryer('Laundry Dryer', 'LDW1235227890');
 ```
 
 ```typescript
-    this.dishwasher = new Dishwasher('Dishwasher', 'DW1234567890');
+const dishwasher = new Dishwasher('Dishwasher', 'DW1234567890');
 ```
 
 ```typescript
-    this.extractorHood = new ExtractorHood('Extractor Hood', 'EH1234567893');
+const extractorHood = new ExtractorHood('Extractor Hood', 'EH1234567893');
 ```
 
 ```typescript
-    this.microwaveOven = new MicrowaveOven('Microwave Oven', 'MO1234567893');
+const microwaveOven = new MicrowaveOven('Microwave Oven', 'MO1234567893');
 ```
 
 The Oven is always a composed device. You create the Oven and add one or more cabinet.
 
 ```typescript
-    this.oven = new Oven('Oven', 'OV1234567890');
-    this.oven.addCabinet('Upper Cabinet', [{ mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: PositionTag.Top.label }]);
+const oven = new Oven('Oven', 'OV1234567890');
+oven.addCabinet('Upper Cabinet', [{ mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: PositionTag.Top.label }]);
 ```
 
 The Cooktop is always a composed device. You create the Cooktop and add one or more surface.
 
 ```typescript
-    this.cooktop = new Cooktop('Cooktop', 'CT1234567890');
-    this.cooktop.addSurface('Surface Top Left', [
-      { mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: PositionTag.Top.label },
-      { mfgCode: null, namespaceId: PositionTag.Left.namespaceId, tag: PositionTag.Left.tag, label: PositionTag.Left.label },
-    ]);
+const cooktop = new Cooktop('Cooktop', 'CT1234567890');
+cooktop.addSurface('Surface Top Left', [
+  { mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: PositionTag.Top.label },
+  { mfgCode: null, namespaceId: PositionTag.Left.namespaceId, tag: PositionTag.Left.tag, label: PositionTag.Left.label },
+]);
 ```
 
 The Refrigerator is always a composed device. You create the Refrigerator and add one or more cabinet.
 
 ```typescript
-    const refrigerator = new Refrigerator('Refrigerator', 'RE1234567890');
-    refrigerator.addCabinet('Refrigerator Top', [
-      { mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: 'Refrigerator Top' },
-      { mfgCode: null, namespaceId: RefrigeratorTag.Refrigerator.namespaceId, tag: RefrigeratorTag.Refrigerator.tag, label: RefrigeratorTag.Refrigerator.label },
-    ]);
+const refrigerator = new Refrigerator('Refrigerator', 'RE1234567890');
+refrigerator.addCabinet('Refrigerator Top', [
+  { mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: 'Refrigerator Top' },
+  { mfgCode: null, namespaceId: RefrigeratorTag.Refrigerator.namespaceId, tag: RefrigeratorTag.Refrigerator.tag, label: RefrigeratorTag.Refrigerator.label },
+]);
 ```
 
 ### Chapter 14. Energy Device Types - Single class device types
@@ -394,6 +388,7 @@ Each plugin has a minimal default config file injected by Matterbridge when it i
 {
   name: plugin.name, // i.e. matterbridge-test
   type: plugin.type, // i.e. AccessoryPlatform or DynamicPlatform (on the first run is AnyPlatform cause it is still unknown)
+  version: plugin.version,
   debug: false,
   unregisterOnShutdown: false
 }

package/dist/frontend.js

@@ -214,6 +214,7 @@ export class Frontend extends EventEmitter {
             this.httpServer.on('upgrade', async (req, socket, head) => {
                 try {
                     if ((req.headers.upgrade || '').toLowerCase() !== 'websocket') {
+                        this.log.error(`WebSocket upgrade error: Invalid upgrade header ${req.headers.upgrade}`);
                         socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
                         return socket.destroy();
                     }
@@ -1140,6 +1141,9 @@ export class Frontend extends EventEmitter {
                 }
                 client.send(JSON.stringify(data));
             }
+            else {
+                this.log.error('Cannot send api response, client not connected');
+            }
         };
         try {
             data = JSON.parse(message.toString());

package/dist/jestutils/jestHelpers.js

@@ -1,15 +1,18 @@
 import { rmSync } from 'node:fs';
 import { inspect } from 'node:util';
 import path from 'node:path';
-import { AnsiLogger, er, rs } from 'node-ansi-logger';
+import { AnsiLogger, er, rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
 import { LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, Environment, Lifecycle } from '@matter/general';
 import { Endpoint, ServerNode, ServerNodeStore } from '@matter/node';
 import { DeviceTypeId, VendorId } from '@matter/types/datatype';
 import { AggregatorEndpoint } from '@matter/node/endpoints';
 import { MdnsService } from '@matter/main/protocol';
+import { NodeStorageManager } from 'node-persist-manager';
 import { Matterbridge } from '../matterbridge.js';
-import { MATTER_STORAGE_NAME } from '../matterbridgeTypes.js';
+import { MATTER_STORAGE_NAME, NODE_STORAGE_DIR } from '../matterbridgeTypes.js';
 import { bridge } from '../matterbridgeDeviceTypes.js';
+export const originalProcessArgv = Object.freeze([...process.argv]);
+export const originalProcessEnv = Object.freeze({ ...process.env });
 export let loggerLogSpy;
 export let loggerDebugSpy;
 export let loggerInfoSpy;
@@ -25,7 +28,12 @@ export let consoleErrorSpy;
 export let addBridgedEndpointSpy;
 export let removeBridgedEndpointSpy;
 export let removeAllBridgedEndpointsSpy;
+export let NAME;
+export let HOMEDIR;
 export let matterbridge;
+export let frontend;
+export let plugins;
+export let devices;
 export let environment;
 export let server;
 export let aggregator;
@@ -34,7 +42,9 @@ export async 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 });
+    NAME = name;
+    HOMEDIR = path.join('jest', name);
+    rmSync(HOMEDIR, { recursive: true, force: true });
     const { jest } = await import('@jest/globals');
     loggerDebugSpy = jest.spyOn(AnsiLogger.prototype, 'debug');
     loggerInfoSpy = jest.spyOn(AnsiLogger.prototype, 'info');
@@ -87,6 +97,89 @@ export async function setDebug(debug) {
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
 }
+export async function startMatterbridge(bridgeMode = 'bridge', frontendPort = 8283, matterPort = 5540, passcode = 20252026, discriminator = 3840, pluginSize = 0, devicesSize = 0) {
+    process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS'] = '100';
+    process.env['MATTERBRIDGE_PAUSE_MATTER_INTERVAL_MS'] = '100';
+    process.argv.length = 0;
+    process.argv.push(...originalProcessArgv, '-novirtual', '-debug', '-verbose', '-logger', 'debug', '-matterlogger', 'debug', bridgeMode === '' ? '-test' : '-' + bridgeMode, '-homedir', HOMEDIR, '-frontend', frontendPort.toString(), '-port', matterPort.toString(), '-passcode', passcode.toString(), '-discriminator', discriminator.toString());
+    matterbridge = await Matterbridge.loadInstance(true);
+    expect(matterbridge).toBeDefined();
+    expect(matterbridge.profile).toBeUndefined();
+    expect(matterbridge.bridgeMode).toBe(bridgeMode);
+    frontend = matterbridge.frontend;
+    plugins = matterbridge.plugins;
+    devices = matterbridge.devices;
+    expect(matterbridge.initialized).toBeTruthy();
+    expect(matterbridge.log).toBeDefined();
+    expect(matterbridge.rootDirectory).toBe(path.resolve('./'));
+    expect(matterbridge.homeDirectory).toBe(path.join('jest', NAME));
+    expect(matterbridge.matterbridgeDirectory).toBe(path.join('jest', NAME, '.matterbridge'));
+    expect(matterbridge.matterbridgePluginDirectory).toBe(path.join('jest', NAME, 'Matterbridge'));
+    expect(matterbridge.matterbridgeCertDirectory).toBe(path.join('jest', NAME, '.mattercert'));
+    expect(plugins).toBeDefined();
+    expect(plugins.size).toBe(pluginSize);
+    expect(devices).toBeDefined();
+    expect(devices.size).toBe(devicesSize);
+    expect(frontend).toBeDefined();
+    expect(frontend.listening).toBeTruthy();
+    expect(frontend.httpServer).toBeDefined();
+    expect(frontend.httpsServer).toBeUndefined();
+    expect(frontend.expressApp).toBeDefined();
+    expect(frontend.webSocketServer).toBeDefined();
+    expect(matterbridge.nodeStorage).toBeDefined();
+    expect(matterbridge.nodeContext).toBeDefined();
+    expect(Environment.default.vars.get('path.root')).toBe(path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_NAME));
+    expect(matterbridge.matterStorageService).toBeDefined();
+    expect(matterbridge.matterStorageManager).toBeDefined();
+    expect(matterbridge.matterbridgeContext).toBeDefined();
+    expect(matterbridge.controllerContext).toBeUndefined();
+    if (bridgeMode === 'bridge') {
+        expect(matterbridge.serverNode).toBeDefined();
+        expect(matterbridge.aggregatorNode).toBeDefined();
+    }
+    expect(matterbridge.mdnsInterface).toBe(undefined);
+    expect(matterbridge.port).toBe(matterPort + (bridgeMode === 'bridge' ? 1 : 0));
+    expect(matterbridge.passcode).toBe(passcode + (bridgeMode === 'bridge' ? 1 : 0));
+    expect(matterbridge.discriminator).toBe(discriminator + (bridgeMode === 'bridge' ? 1 : 0));
+    if (bridgeMode === 'bridge') {
+        const started = new Promise((resolve) => {
+            matterbridge.once('bridge_started', () => {
+                resolve();
+            });
+        });
+        const online = new Promise((resolve) => {
+            matterbridge.once('online', (name) => {
+                if (name === 'Matterbridge')
+                    resolve();
+            });
+        });
+        await Promise.all([started, online]);
+    }
+    else if (bridgeMode === 'childbridge') {
+        await new Promise((resolve) => {
+            matterbridge.once('childbridge_started', () => {
+                resolve();
+            });
+        });
+    }
+    expect(loggerLogSpy).toHaveBeenCalledWith("info", `The frontend http server is listening on ${UNDERLINE}http://${matterbridge.systemInformation.ipv4Address}:${frontendPort}${UNDERLINEOFF}${rs}`);
+    if (bridgeMode === 'bridge') {
+        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Starting Matterbridge server node`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Server node for Matterbridge is online`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in bridge mode...`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in bridge mode`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge bridge started successfully`);
+    }
+    else if (bridgeMode === 'childbridge') {
+        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in childbridge mode...`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in childbridge mode`);
+        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge childbridge started successfully`);
+    }
+    return matterbridge;
+}
+export async function stopMatterbridge(cleanupPause = 10, destroyPause = 250) {
+    await destroyMatterbridgeEnvironment(cleanupPause, destroyPause);
+}
 export async function createMatterbridgeEnvironment(name) {
     matterbridge = await Matterbridge.loadInstance(false);
     expect(matterbridge).toBeDefined();
@@ -106,6 +199,8 @@ export async function createMatterbridgeEnvironment(name) {
     return matterbridge;
 }
 export async function startMatterbridgeEnvironment(port = 5540) {
+    matterbridge.nodeStorage = new NodeStorageManager({ dir: path.join(matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR), writeQueue: false, expiredInterval: undefined, logging: false });
+    matterbridge.nodeContext = await matterbridge.nodeStorage.createStorage('matterbridge');
     await matterbridge.startMatterStorage();
     expect(matterbridge.matterStorageService).toBeDefined();
     expect(matterbridge.matterStorageManager).toBeDefined();
@@ -180,6 +275,8 @@ export async function stopMatterbridgeEnvironment() {
     expect(matterbridge.matterStorageService).not.toBeDefined();
     expect(matterbridge.matterStorageManager).not.toBeDefined();
     expect(matterbridge.matterbridgeContext).not.toBeDefined();
+    await matterbridge.nodeContext?.close();
+    await matterbridge.nodeStorage?.close();
     await flushAsync();
 }
 export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 250) {

package/dist/matterbridge.js

@@ -1128,7 +1128,7 @@ export class Matterbridge extends EventEmitter {
         await this.serverNode.add(this.aggregatorNode);
         await addVirtualDevices(this, this.aggregatorNode);
         await this.startPlugins();
-        this.log.debug('Starting start matter interval in bridge mode');
+        this.log.debug('Starting start matter interval in bridge mode...');
         let failCount = 0;
         this.startMatterInterval = setInterval(async () => {
             for (const plugin of this.plugins) {
@@ -1156,7 +1156,7 @@ export class Matterbridge extends EventEmitter {
             }
             clearInterval(this.startMatterInterval);
             this.startMatterInterval = undefined;
-            this.log.debug('Cleared startMatterInterval interval for Matterbridge');
+            this.log.debug('Cleared startMatterInterval interval in bridge mode');
             this.startServerNode(this.serverNode);
             for (const device of this.devices.array()) {
                 if (device.mode === 'server' && device.serverNode) {
@@ -1190,7 +1190,7 @@ export class Matterbridge extends EventEmitter {
             this.log.notice('Matterbridge bridge started successfully');
             this.frontend.wssSendRefreshRequired('settings');
             this.frontend.wssSendRefreshRequired('plugins');
-        }, this.startMatterIntervalMs);
+        }, Number(process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS']) || this.startMatterIntervalMs);
     }
     async startChildbridge(delay = 1000) {
         if (!this.matterStorageManager)
@@ -1236,7 +1236,7 @@ export class Matterbridge extends EventEmitter {
             clearInterval(this.startMatterInterval);
             this.startMatterInterval = undefined;
             if (delay > 0)
-                await wait(delay);
+                await wait(Number(process.env['MATTERBRIDGE_PAUSE_MATTER_INTERVAL_MS']) || delay);
             this.log.debug('Cleared startMatterInterval interval in childbridge mode');
             this.configureTimeout = setTimeout(async () => {
                 for (const plugin of this.plugins.array()) {
@@ -1291,7 +1291,7 @@ export class Matterbridge extends EventEmitter {
             this.log.notice('Matterbridge childbridge started successfully');
             this.frontend.wssSendRefreshRequired('settings');
             this.frontend.wssSendRefreshRequired('plugins');
-        }, this.startMatterIntervalMs);
+        }, Number(process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS']) || this.startMatterIntervalMs);
     }
     async startController() {
     }
@@ -1373,6 +1373,7 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`- hardwareVersion: ${await storageContext.get('hardwareVersion')} hardwareVersionString: ${await storageContext.get('hardwareVersionString')}`);
         const serverNode = await ServerNode.create({
             id: storeId,
+            environment: this.environment,
             network: {
                 listeningAddressIpv4: this.ipv4Address,
                 listeningAddressIpv6: this.ipv6Address,

package/dist/matterbridgeEndpoint.js

@@ -63,6 +63,7 @@ import { ThermostatUserInterfaceConfigurationServer } from '@matter/node/behavio
 import { isValidNumber, isValidObject, isValidString } from './utils/isvalid.js';
 import { MatterbridgeServer, MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeLiftTiltWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeSwitchServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeActivatedCarbonFilterMonitoringServer, MatterbridgeHepaFilterMonitoringServer, MatterbridgeEnhancedColorControlServer, MatterbridgePowerSourceServer, } from './matterbridgeBehaviors.js';
 import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, createUniqueId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getDefaultOperationalStateClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getApparentElectricalPowerMeasurementClusterServer, lowercaseFirstLetter, updateAttribute, getClusterId, getAttributeId, setAttribute, getAttribute, checkNotLatinCharacters, generateUniqueId, subscribeAttribute, invokeBehaviorCommand, triggerEvent, featuresFor, getDefaultPowerSourceWiredClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, getDefaultPowerSourceBatteryClusterServer, } from './matterbridgeEndpointHelpers.js';
+import { inspectError } from './utils/error.js';
 export class MatterbridgeEndpoint extends Endpoint {
     static logLevel = "info";
     mode = undefined;
@@ -84,7 +85,6 @@ export class MatterbridgeEndpoint extends Endpoint {
     productUrl = 'https://www.npmjs.com/package/matterbridge';
     tagList = undefined;
     originalId = undefined;
-    uniqueStorageKey = undefined;
     name = undefined;
     deviceType = undefined;
     deviceTypes = new Map();
@@ -122,20 +122,16 @@ export class MatterbridgeEndpoint extends Endpoint {
             behaviors: options.tagList ? SupportedBehaviors(DescriptorServer.with(Descriptor.Feature.TagList)) : SupportedBehaviors(DescriptorServer),
         };
         const endpointV8 = MutableEndpoint(deviceTypeDefinitionV8);
-        if (options.uniqueStorageKey && checkNotLatinCharacters(options.uniqueStorageKey)) {
-            options.uniqueStorageKey = generateUniqueId(options.uniqueStorageKey);
-        }
         if (options.id && checkNotLatinCharacters(options.id)) {
             options.id = generateUniqueId(options.id);
         }
         const optionsV8 = {
-            id: options.id?.replace(/[ .]/g, '') || options.uniqueStorageKey?.replace(/[ .]/g, ''),
-            number: options.number || options.endpointId,
+            id: options.id?.replace(/[ .]/g, ''),
+            number: options.number,
             descriptor: options.tagList ? { tagList: options.tagList, deviceTypeList } : { deviceTypeList },
         };
         super(endpointV8, optionsV8);
         this.mode = options.mode;
-        this.uniqueStorageKey = options.id ?? options.uniqueStorageKey;
         this.originalId = originalId;
         this.name = firstDefinition.name;
         this.deviceType = firstDefinition.code;
@@ -147,7 +143,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         else
             this.deviceTypes.set(firstDefinition.code, firstDefinition);
-        this.log = new AnsiLogger({ logName: this.originalId ?? this.uniqueStorageKey ?? 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
+        this.log = new AnsiLogger({ logName: this.originalId ?? 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
         this.log.debug(`${YELLOW}new${db} MatterbridgeEndpoint: ${zb}${'0x' + firstDefinition.code.toString(16).padStart(4, '0')}${db}-${zb}${firstDefinition.name}${db} mode: ${CYAN}${this.mode}${db} id: ${CYAN}${optionsV8.id}${db} number: ${CYAN}${optionsV8.number}${db} taglist: ${CYAN}${options.tagList ? debugStringify(options.tagList) : 'undefined'}${db}`);
         this.behaviors.require(MatterbridgeServer, { log: this.log, commandHandler: this.commandHandler });
     }
@@ -279,11 +275,21 @@ export class MatterbridgeEndpoint extends Endpoint {
             return child;
         if (this.lifecycle.isInstalled) {
             this.log.debug(`- with lifecycle installed`);
-            this.add(child);
+            try {
+                this.add(child);
+            }
+            catch (error) {
+                inspectError(this.log, `addChildDeviceType: error adding (with lifecycle installed) child endpoint ${CYAN}${endpointName}${db}`, error);
+            }
         }
         else {
             this.log.debug(`- with lifecycle NOT installed`);
-            this.parts.add(child);
+            try {
+                this.parts.add(child);
+            }
+            catch (error) {
+                inspectError(this.log, `addChildDeviceType: error adding (with lifecycle NOT installed) child endpoint ${CYAN}${endpointName}${db}`, error);
+            }
         }
         return child;
     }
@@ -341,11 +347,21 @@ export class MatterbridgeEndpoint extends Endpoint {
             return child;
         if (this.lifecycle.isInstalled) {
             this.log.debug(`- with lifecycle installed`);
-            this.add(child);
+            try {
+                this.add(child);
+            }
+            catch (error) {
+                inspectError(this.log, `addChildDeviceType: error adding (with lifecycle installed) child endpoint ${CYAN}${endpointName}${db}`, error);
+            }
         }
         else {
             this.log.debug(`- with lifecycle NOT installed`);
-            this.parts.add(child);
+            try {
+                this.parts.add(child);
+            }
+            catch (error) {
+                inspectError(this.log, `addChildDeviceType: error adding (with lifecycle NOT installed) child endpoint ${CYAN}${endpointName}${db}`, error);
+            }
         }
         return child;
     }
@@ -1007,7 +1023,7 @@ export class MatterbridgeEndpoint extends Endpoint {
     }
     createSmokeOnlySmokeCOAlarmClusterServer(smokeState = SmokeCoAlarm.AlarmState.Normal) {
         this.behaviors.require(MatterbridgeSmokeCoAlarmServer.with(SmokeCoAlarm.Feature.SmokeAlarm).enable({
-            events: { smokeAlarm: true, interconnectSmokeAlarm: false, coAlarm: false, interconnectCoAlarm: false, lowBattery: true, hardwareFault: true, endOfService: true, selfTestComplete: true, alarmMuted: true, muteEnded: true, allClear: true },
+            events: { smokeAlarm: true, interconnectSmokeAlarm: false, lowBattery: true, hardwareFault: true, endOfService: true, selfTestComplete: true, alarmMuted: true, muteEnded: true, allClear: true },
         }), {
             smokeState,
             expressedState: SmokeCoAlarm.ExpressedState.Normal,
@@ -1021,7 +1037,7 @@ export class MatterbridgeEndpoint extends Endpoint {
     }
     createCoOnlySmokeCOAlarmClusterServer(coState = SmokeCoAlarm.AlarmState.Normal) {
         this.behaviors.require(MatterbridgeSmokeCoAlarmServer.with(SmokeCoAlarm.Feature.CoAlarm).enable({
-            events: { smokeAlarm: false, interconnectSmokeAlarm: false, coAlarm: true, interconnectCoAlarm: false, lowBattery: true, hardwareFault: true, endOfService: true, selfTestComplete: true, alarmMuted: true, muteEnded: true, allClear: true },
+            events: { coAlarm: true, interconnectCoAlarm: false, lowBattery: true, hardwareFault: true, endOfService: true, selfTestComplete: true, alarmMuted: true, muteEnded: true, allClear: true },
         }), {
             coState,
             expressedState: SmokeCoAlarm.ExpressedState.Normal,

package/dist/matterbridgeEndpointHelpers.js

@@ -792,6 +792,7 @@ export function getDefaultOccupancySensingClusterServer(occupied = false, holdTi
         occupancySensorTypeBitmap: { pir: true, ultrasonic: false, physicalContact: false },
         pirOccupiedToUnoccupiedDelay: holdTime,
         pirUnoccupiedToOccupiedDelay: holdTime,
+        pirUnoccupiedToOccupiedThreshold: 1,
         holdTime,
         holdTimeLimits: { holdTimeMin, holdTimeMax, holdTimeDefault: holdTime },
     });

package/dist/pluginManager.js

@@ -288,19 +288,19 @@ export class PluginManager extends EventEmitter {
         this.log.debug(`Saved ${BLUE}${plugins.length}${db} plugins to storage`);
         return plugins.length;
     }
-    async resolve(pluginPath) {
+    async resolve(nameOrPath) {
         const { default: path } = await import('node:path');
         const { promises } = await import('node:fs');
-        if (!pluginPath.endsWith('package.json'))
-            pluginPath = path.join(pluginPath, 'package.json');
-        let packageJsonPath = path.resolve(pluginPath);
+        if (!nameOrPath.endsWith('package.json'))
+            nameOrPath = path.join(nameOrPath, 'package.json');
+        let packageJsonPath = path.resolve(nameOrPath);
         this.log.debug(`Resolving plugin path ${plg}${packageJsonPath}${db}`);
         try {
             await promises.access(packageJsonPath);
         }
         catch {
             this.log.debug(`Package.json not found at ${plg}${packageJsonPath}${db}`);
-            packageJsonPath = path.join(this.matterbridge.globalModulesDirectory, pluginPath);
+            packageJsonPath = path.join(this.matterbridge.globalModulesDirectory, nameOrPath);
             this.log.debug(`Trying at ${plg}${packageJsonPath}${db}`);
         }
         try {
@@ -359,11 +359,11 @@ export class PluginManager extends EventEmitter {
                 this.log.error(`Please open an issue on the plugin repository to remove them.`);
                 return null;
             }
-            this.log.debug(`Resolved plugin path ${plg}${pluginPath}${db}: ${packageJsonPath}`);
+            this.log.debug(`Resolved plugin path ${plg}${nameOrPath}${db}: ${packageJsonPath}`);
             return packageJsonPath;
         }
         catch (err) {
-            logError(this.log, `Failed to resolve plugin path ${plg}${pluginPath}${er}`, err);
+            logError(this.log, `Failed to resolve plugin path ${plg}${nameOrPath}${er}`, err);
             return null;
         }
     }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.3.8-dev-20251117-e3fb774",
+  "version": "3.3.9-dev-20251118-930cfdb",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.3.8-dev-20251117-e3fb774",
+      "version": "3.3.9-dev-20251118-930cfdb",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.3.8-dev-20251117-e3fb774",
+  "version": "3.3.9-dev-20251118-930cfdb",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",