matterbridge 3.3.7-dev-20251109-a306ab9 → 3.3.8-dev-20251114-9b65e59

package/CHANGELOG.md

@@ -28,6 +28,42 @@ Advantages:
 - individual plugin isolation in childbridge mode;
 - ability to update the plugin in childbridge mode without restarting matterbridge;
 
+## [3.3.8] - 2025-11-15
+
+### Development Breaking Changes
+
+This will be the last release with 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).
+
+So please update your plugin.
+
+### Added
+
+- [endpoint]: Added matterbridgeEndpointTypes.
+- [devices]: Added tests for device types and their revision changes.
+- [clusters]: Added test for clusters and their revision changes.
+- [chip]: Added fetch script to download zcl data from connectedhomeip.
+- [endpoint]: Added createDefaultPowerSourceBatteryClusterServer(). Add Power Source cluster for a generic battery device.
+- [platform]: Added setSchema() to temporarly set the schema for the config editor.
+- [platform]: Added getSchema() to retrieve the schema from the Matterbridge plugin manager.
+- [platform]: Added return value to registerVirtualDevice().
+
+### Changed
+
+- [package]: Updated dependencies.
+- [package]: Bumped jestHelpers v.1.0.12.
+- [endpoint]: Changed long deprecated uniqueStorageKey with id in MatterbridgeEndpointOptions.
+- [endpoint]: Changed long deprecated endpointId with number in MatterbridgeEndpointOptions.
+- [endpoint]: Added property originalId in MatterbridgeEndpoint to store the original id passed in MatterbridgeEndpointOptions (since it can be changed for matter.js storage compatibility).
+- [endpoint]: Changed logger level of single device classes.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [3.3.7] - 2025-11-08
 
 ### Breaking Changes
@@ -41,6 +77,7 @@ Advantages:
 
 ### Changed
 
+- [package]: Updated dependencies.
 - [frontend]: Bumped `frontend` version to 3.3.1.
 - [PluginManager]: Bumped `PluginManager` version to 1.3.0.
 - [DeviceManager]: Bumped `DeviceManager` version to 1.1.0.

package/README-SERVICE-OPT.md

@@ -162,23 +162,23 @@ sudo systemctl stop matterbridge
 ### Show Matterbridge status
 
 ```bash
-sudo systemctl status matterbridge.service
+sudo systemctl status matterbridge
 ```
 
 ### Enable Matterbridge to start automatically on boot
 
 ```bash
-sudo systemctl enable matterbridge.service
+sudo systemctl enable matterbridge
 ```
 
 ### Disable Matterbridge from starting automatically on boot
 
 ```bash
-sudo systemctl disable matterbridge.service
+sudo systemctl disable matterbridge
 ```
 
 ### View the log of Matterbridge in real time (this will show the log with colors)
 
 ```bash
-sudo journalctl -u matterbridge.service -n 1000 -f --output cat
+sudo journalctl -u matterbridge -n 1000 -f --output cat
 ```

package/README.md

@@ -354,6 +354,10 @@ The plugin uses local connection to Daikin Wifi modules. The plugin does not wor
 
 Matterbridge Roborock Platform Plugin is a dynamic platform plugin for Matterbridge that integrates Roborock vacuums into the Matter ecosystem, enabling control via Apple Home and other Matter-compatible apps.
 
+### [Wyze Robot Vacuum](https://github.com/RMCob/matterbridge-wyze-robovac)
+
+Matterbridge plugin to control and report status of the Wyze S200 Robot Vacuum
+
 ## How to install and add a plugin with the frontend (best option)
 
 Just open the frontend on the link provided in the log, select a plugin and click install.

package/dist/devices/airConditioner.js

@@ -5,7 +5,7 @@ import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class AirConditioner extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
         const { localTemperature = 23, occupiedHeatingSetpoint = 21, occupiedCoolingSetpoint = 25, minSetpointDeadBand = 1, minHeatSetpointLimit = 0, maxHeatSetpointLimit = 50, minCoolSetpointLimit = 0, maxCoolSetpointLimit = 50, temperatureDisplayMode = ThermostatUserInterfaceConfiguration.TemperatureDisplayMode.Celsius, keypadLockout = ThermostatUserInterfaceConfiguration.KeypadLockout.NoLockout, scheduleProgrammingVisibility = ThermostatUserInterfaceConfiguration.ScheduleProgrammingVisibility.ScheduleProgrammingPermitted, fanMode = FanControl.FanMode.Off, fanModeSequence = FanControl.FanModeSequence.OffLowMedHighAuto, percentSetting = 0, percentCurrent = 0, } = options;
-        super([airConditioner, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([airConditioner, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Air Conditioner');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/batteryStorage.js

@@ -5,7 +5,7 @@ import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { deviceEnergyManagement, electricalSensor, batteryStorage, powerSource } from '../matterbridgeDeviceTypes.js';
 export class BatteryStorage extends MatterbridgeEndpoint {
     constructor(name, serial, batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, voltage = null, current = null, power = null, energyImported = null, energyExported = null, absMinPower = 0, absMaxPower = 0) {
-        super([batteryStorage, electricalSensor, deviceEnergyManagement], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([batteryStorage, electricalSensor, deviceEnergyManagement], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Solar Power')
             .createDefaultPowerTopologyClusterServer()

package/dist/devices/cooktop.js

@@ -3,7 +3,7 @@ import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { createLevelTemperatureControlClusterServer } from './temperatureControl.js';
 export class Cooktop extends MatterbridgeEndpoint {
     constructor(name, serial) {
-        super([cooktop, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([cooktop, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Cooktop');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/dishwasher.js

@@ -8,7 +8,7 @@ import { MatterbridgeOnOffServer, MatterbridgeServer } from '../matterbridgeBeha
 import { createLevelTemperatureControlClusterServer, createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class Dishwasher extends MatterbridgeEndpoint {
     constructor(name, serial, currentMode, supportedModes, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
-        super([dishwasher, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([dishwasher, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Dishwasher');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/evse.js

@@ -9,7 +9,7 @@ import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
 import { deviceEnergyManagement, electricalSensor, evse, powerSource } from '../matterbridgeDeviceTypes.js';
 export class Evse extends MatterbridgeEndpoint {
     constructor(name, serial, currentMode, supportedModes, state, supplyState, faultState, voltage = null, current = null, power = null, energy = null, absMinPower, absMaxPower) {
-        super([evse, powerSource, electricalSensor, deviceEnergyManagement], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([evse, powerSource, electricalSensor, deviceEnergyManagement], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Evse')
             .createDefaultPowerSourceWiredClusterServer()

package/dist/devices/extractorHood.js

@@ -3,7 +3,7 @@ import { extractorHood, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class ExtractorHood extends MatterbridgeEndpoint {
     constructor(name, serial, hepaCondition = 100, hepaChangeIndication = ResourceMonitoring.ChangeIndication.Ok, hepaInPlaceIndicator = true, hepaLastChangedTime = null, hepaReplacementProductList = [], activatedCarbonCondition = 100, activatedCarbonChangeIndication = ResourceMonitoring.ChangeIndication.Ok, activatedCarbonInPlaceIndicator = true, activatedCarbonLastChangedTime = null, activatedCarbonReplacementProductList = []) {
-        super([extractorHood, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([extractorHood, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Extractor Hood');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/heatPump.js

@@ -7,7 +7,7 @@ export class HeatPump extends MatterbridgeEndpoint {
         super([heatPump, powerSource, electricalSensor, deviceEnergyManagement], {
             tagList: [{ mfgCode: null, namespaceId: PowerSourceTag.Grid.namespaceId, tag: PowerSourceTag.Grid.tag, label: null }],
             id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
-        }, true);
+        });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Heat Pump')
             .createDefaultPowerSourceWiredClusterServer()

package/dist/devices/laundryDryer.js

@@ -7,7 +7,7 @@ import { MatterbridgeLaundryWasherModeServer } from './laundryWasher.js';
 import { createLevelTemperatureControlClusterServer, createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class LaundryDryer extends MatterbridgeEndpoint {
     constructor(name, serial, currentMode, supportedModes, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
-        super([laundryDryer, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([laundryDryer, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Laundry Dryer');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/laundryWasher.js

@@ -9,7 +9,7 @@ import { MatterbridgeOnOffServer, MatterbridgeServer } from '../matterbridgeBeha
 import { createLevelTemperatureControlClusterServer, createNumberTemperatureControlClusterServer } from './temperatureControl.js';
 export class LaundryWasher extends MatterbridgeEndpoint {
     constructor(name, serial, currentMode, supportedModes, spinSpeedCurrent, spinSpeeds, numberOfRinses, supportedRinses, selectedTemperatureLevel, supportedTemperatureLevels, temperatureSetpoint, minTemperature, maxTemperature, step, operationalState) {
-        super([laundryWasher, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([laundryWasher, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Laundry Washer');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/microwaveOven.js

@@ -16,7 +16,7 @@ export class MicrowaveOven extends MatterbridgeEndpoint {
         { label: 'Normal', mode: 6, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Normal }] },
         { label: 'Defrost', mode: 7, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Defrost }] },
     ], selectedWattIndex = 5, supportedWatts = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000], cookTime = 60, maxCookTime = 3600) {
-        super([microwaveOven, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([microwaveOven, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Microwave Oven');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/oven.js

@@ -9,7 +9,7 @@ import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
 import { createLevelTemperatureControlClusterServer } from './temperatureControl.js';
 export class Oven extends MatterbridgeEndpoint {
     constructor(name, serial) {
-        super([oven, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([oven, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Oven');
         this.createDefaultPowerSourceWiredClusterServer();

package/dist/devices/refrigerator.js

@@ -8,7 +8,7 @@ import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
 import { createLevelTemperatureControlClusterServer } from './temperatureControl.js';
 export class Refrigerator extends MatterbridgeEndpoint {
     constructor(name, serial) {
-        super([refrigerator, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([refrigerator, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
         this.createDefaultIdentifyClusterServer();
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Refrigerator');
         this.createDefaultPowerSourceWiredClusterServer();
@@ -19,7 +19,7 @@ export class Refrigerator extends MatterbridgeEndpoint {
         { label: 'RapidCool', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
         { label: 'RapidFreeze', mode: 3, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
     ], selectedTemperatureLevel = 2, supportedTemperatureLevels = ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5'], currentTemperature = 1000) {
-        const cabinet = this.addChildDeviceType(name, temperatureControlledCabinetCooler, { tagList }, true);
+        const cabinet = this.addChildDeviceType(name, temperatureControlledCabinetCooler, { tagList });
         cabinet.log.logName = name;
         cabinet.createDefaultIdentifyClusterServer();
         createLevelTemperatureControlClusterServer(cabinet, selectedTemperatureLevel, supportedTemperatureLevels);

package/dist/devices/roboticVacuumCleaner.js

@@ -14,7 +14,7 @@ import { powerSource, roboticVacuumCleaner } from '../matterbridgeDeviceTypes.js
 import { MatterbridgeServer, MatterbridgeServiceAreaServer } from '../matterbridgeBehaviors.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) {
-        super([roboticVacuumCleaner, powerSource], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, mode }, true);
+        super([roboticVacuumCleaner, powerSource], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, mode });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Robot Vacuum Cleaner')
             .createDefaultPowerSourceRechargeableBatteryClusterServer(80, PowerSource.BatChargeLevel.Ok, 5900)

package/dist/devices/solarPower.js

@@ -7,7 +7,7 @@ export class SolarPower extends MatterbridgeEndpoint {
         super([solarPower, powerSource, electricalSensor, deviceEnergyManagement], {
             tagList: [{ mfgCode: null, namespaceId: PowerSourceTag.Solar.namespaceId, tag: PowerSourceTag.Solar.tag, label: null }],
             id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
-        }, true);
+        });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Solar Power')
             .createDefaultPowerSourceWiredClusterServer()

package/dist/devices/speaker.js

@@ -10,7 +10,7 @@ export class Speaker extends MatterbridgeEndpoint {
             volume = 1;
         if (volume > 254)
             volume = 254;
-        super([speakerDevice], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([speakerDevice], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Speaker');
         this.createOnOffClusterServer(!muted);
         this.createLevelControlClusterServer(volume);

package/dist/devices/waterHeater.js

@@ -9,7 +9,7 @@ import { electricalSensor, powerSource, waterHeater } from '../matterbridgeDevic
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class WaterHeater extends MatterbridgeEndpoint {
     constructor(name, serial, waterTemperature = 50, targetWaterTemperature = 55, minHeatSetpointLimit = 20, maxHeatSetpointLimit = 80, heaterTypes = { immersionElement1: true }, tankPercentage = 90, voltage = null, current = null, power = null, energy = null, absMinPower = 0, absMaxPower = 0) {
-        super([waterHeater, powerSource, electricalSensor], { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        super([waterHeater, powerSource, electricalSensor], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Water Heater')
             .createDefaultPowerSourceWiredClusterServer()

package/dist/frontend.js

@@ -1453,7 +1453,11 @@ export class Frontend extends EventEmitter {
                     this.wssSendRefreshRequired('matter', { matter: { ...matter, advertiseTime: 0, advertising: false } });
                 }
                 if (data.params.advertise) {
-                    await serverNode.env.get(DeviceAdvertiser)?.advertise(true);
+                    const advertiser = serverNode.env.get(DeviceAdvertiser);
+                    if (advertiser && advertiser.advertise && typeof advertiser.advertise === 'function')
+                        await advertiser.advertise(true);
+                    if (advertiser && advertiser.restartAdvertisement && typeof advertiser.restartAdvertisement === 'function')
+                        advertiser.restartAdvertisement();
                     this.log.debug(`*Advertising has been sent for node ${data.params.id}`);
                     this.wssSendRefreshRequired('matter', { matter: { ...matter, advertising: true } });
                 }

package/dist/index.js

@@ -4,6 +4,7 @@ export * from './matterbridge.js';
 export * from './matterbridgeTypes.js';
 export * from './matterbridgeEndpoint.js';
 export * from './matterbridgeEndpointHelpers.js';
+export * from './matterbridgeEndpointTypes.js';
 export * from './matterbridgeBehaviors.js';
 export * from './matterbridgeDeviceTypes.js';
 export * from './matterbridgePlatform.js';

package/dist/jestutils/export.js

@@ -0,0 +1 @@
+export * from './jestHelpers.js';

package/dist/{utils → jestutils}/jestHelpers.js

@@ -1,26 +1,46 @@
 import { rmSync } from 'node:fs';
 import { inspect } from 'node:util';
 import path from 'node:path';
-import { jest } from '@jest/globals';
 import { AnsiLogger } from 'node-ansi-logger';
-import '@matter/nodejs';
-import { LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Environment, Lifecycle } from '@matter/general';
-import { DeviceTypeId, VendorId } from '@matter/types';
-import { MdnsService } from '@matter/protocol';
-import { ServerNode, Endpoint, ServerNodeStore } from '@matter/node';
-import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
-import { RootEndpoint } from '@matter/node/endpoints/root';
+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, RootEndpoint } from '@matter/node/endpoints';
+import { MdnsService } from '@matter/main/protocol';
+import { Matterbridge } from '../matterbridge.js';
+import { MATTER_STORAGE_NAME } from '../matterbridgeTypes.js';
 export let loggerLogSpy;
+export let loggerDebugSpy;
+export let loggerInfoSpy;
+export let loggerNoticeSpy;
+export let loggerWarnSpy;
+export let loggerErrorSpy;
+export let loggerFatalSpy;
 export let consoleLogSpy;
 export let consoleDebugSpy;
 export let consoleInfoSpy;
 export let consoleWarnSpy;
 export let consoleErrorSpy;
-export function setupTest(name, debug = false) {
+export let addBridgedEndpointSpy;
+export let removeBridgedEndpointSpy;
+export let removeAllBridgedEndpointsSpy;
+export let matterbridge;
+export let environment;
+export let server;
+export let aggregator;
+export let log;
+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 });
+    const { jest } = await import('@jest/globals');
+    loggerDebugSpy = jest.spyOn(AnsiLogger.prototype, 'debug');
+    loggerInfoSpy = jest.spyOn(AnsiLogger.prototype, 'info');
+    loggerNoticeSpy = jest.spyOn(AnsiLogger.prototype, 'notice');
+    loggerWarnSpy = jest.spyOn(AnsiLogger.prototype, 'warn');
+    loggerErrorSpy = jest.spyOn(AnsiLogger.prototype, 'error');
+    loggerFatalSpy = jest.spyOn(AnsiLogger.prototype, 'fatal');
     if (debug) {
         loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
         consoleLogSpy = jest.spyOn(console, 'log');
@@ -37,8 +57,12 @@ export function setupTest(name, debug = false) {
         consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
+    addBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'addBridgedEndpoint');
+    removeBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'removeBridgedEndpoint');
+    removeAllBridgedEndpointsSpy = jest.spyOn(Matterbridge.prototype, 'removeAllBridgedEndpoints');
 }
-export function setDebug(debug) {
+export async function setDebug(debug) {
+    const { jest } = await import('@jest/globals');
     if (debug) {
         loggerLogSpy.mockRestore();
         consoleLogSpy.mockRestore();
@@ -62,20 +86,133 @@ export function setDebug(debug) {
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
 }
-export function createTestEnvironment(homeDir) {
-    expect(homeDir).toBeDefined();
-    expect(typeof homeDir).toBe('string');
-    expect(homeDir.length).toBeGreaterThanOrEqual(4);
-    rmSync(homeDir, { recursive: true, force: true });
-    const environment = Environment.default;
+export async function createMatterbridgeEnvironment(name) {
+    matterbridge = await Matterbridge.loadInstance(false);
+    expect(matterbridge).toBeDefined();
+    expect(matterbridge).toBeInstanceOf(Matterbridge);
+    matterbridge.matterbridgeVersion = '3.3.0';
+    matterbridge.bridgeMode = 'bridge';
+    matterbridge.rootDirectory = path.join('jest', name);
+    matterbridge.homeDirectory = path.join('jest', name);
+    matterbridge.matterbridgeDirectory = path.join('jest', name, '.matterbridge');
+    matterbridge.matterbridgePluginDirectory = path.join('jest', name, 'Matterbridge');
+    matterbridge.matterbridgeCertDirectory = path.join('jest', name, '.mattercert');
+    matterbridge.log.logLevel = "debug";
+    log = new AnsiLogger({ logName: 'Plugin platform', logTimestampFormat: 4, logLevel: "debug" });
+    matterbridge.environment = createTestEnvironment(name);
+    expect(matterbridge.environment).toBeDefined();
+    expect(matterbridge.environment).toBeInstanceOf(Environment);
+    return matterbridge;
+}
+export async function startMatterbridgeEnvironment(port = 5540) {
+    await matterbridge.startMatterStorage();
+    expect(matterbridge.matterStorageService).toBeDefined();
+    expect(matterbridge.matterStorageManager).toBeDefined();
+    expect(matterbridge.matterbridgeContext).toBeDefined();
+    server = await matterbridge.createServerNode(matterbridge.matterbridgeContext, port);
+    expect(server).toBeDefined();
+    expect(server).toBeDefined();
+    expect(server.lifecycle.isReady).toBeTruthy();
+    matterbridge.serverNode = server;
+    aggregator = await matterbridge.createAggregatorNode(matterbridge.matterbridgeContext);
+    expect(aggregator).toBeDefined();
+    matterbridge.aggregatorNode = aggregator;
+    expect(await server.add(aggregator)).toBeDefined();
+    expect(server.parts.has(aggregator.id)).toBeTruthy();
+    expect(server.parts.has(aggregator)).toBeTruthy();
+    expect(aggregator.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeFalsy();
+    await new Promise((resolve) => {
+        server.lifecycle.online.on(async () => {
+            resolve();
+        });
+        server.start();
+    });
+    expect(server.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeTruthy();
+    expect(server.lifecycle.isCommissioned).toBeFalsy();
+    expect(server.lifecycle.isPartsReady).toBeTruthy();
+    expect(server.lifecycle.hasId).toBeTruthy();
+    expect(server.lifecycle.hasNumber).toBeTruthy();
+    expect(aggregator.lifecycle.isReady).toBeTruthy();
+    expect(aggregator.lifecycle.isInstalled).toBeTruthy();
+    expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
+    expect(aggregator.lifecycle.hasId).toBeTruthy();
+    expect(aggregator.lifecycle.hasNumber).toBeTruthy();
+    await flushAsync();
+    return [server, aggregator];
+}
+export function addMatterbridgePlatform(platform, name) {
+    if (name)
+        platform.config.name = name;
+    expect(platform).toBeDefined();
+    expect(platform.config.name).toBeDefined();
+    expect(platform.config.type).toBeDefined();
+    expect(platform.type).toBeDefined();
+    expect(platform.config.version).toBeDefined();
+    expect(platform.version).toBeDefined();
+    expect(platform.config.debug).toBeDefined();
+    expect(platform.config.unregisterOnShutdown).toBeDefined();
+    matterbridge.plugins._plugins.set(platform.config.name, {
+        name: platform.config.name,
+        path: './',
+        type: platform.type,
+        version: platform.version,
+        description: 'Plugin ' + platform.config.name,
+        author: 'Unknown',
+        enabled: true,
+    });
+    platform['name'] = platform.config.name;
+}
+export async function stopMatterbridgeEnvironment() {
+    expect(matterbridge).toBeDefined();
+    expect(server).toBeDefined();
+    expect(aggregator).toBeDefined();
+    await flushAllEndpointNumberPersistence(server);
+    await assertAllEndpointNumbersPersisted(server);
+    expect(server.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeTruthy();
+    await server.close();
+    expect(server.lifecycle.isReady).toBeTruthy();
+    expect(server.lifecycle.isOnline).toBeFalsy();
+    await matterbridge.stopMatterStorage();
+    expect(matterbridge.matterStorageService).not.toBeDefined();
+    expect(matterbridge.matterStorageManager).not.toBeDefined();
+    expect(matterbridge.matterbridgeContext).not.toBeDefined();
+    await flushAsync();
+}
+export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 250) {
+    await destroyInstance(matterbridge, cleanupPause, destroyPause);
+    await closeMdnsInstance(matterbridge);
+    Matterbridge.instance = undefined;
+}
+export async function destroyInstance(matterbridge, cleanupPause = 10, destroyPause = 250) {
+    await matterbridge.cleanup('destroying instance...', false, cleanupPause);
+    if (destroyPause > 0)
+        await flushAsync(undefined, undefined, destroyPause);
+}
+export async function closeMdnsInstance(matterbridge) {
+    const mdns = matterbridge.environment.get(MdnsService);
+    if (mdns && mdns[Symbol.asyncDispose] && typeof mdns[Symbol.asyncDispose] === 'function')
+        await mdns[Symbol.asyncDispose]();
+    if (mdns && mdns.close && typeof mdns.close === 'function')
+        await mdns.close();
+}
+export function createTestEnvironment(name) {
+    expect(name).toBeDefined();
+    expect(typeof name).toBe('string');
+    expect(name.length).toBeGreaterThanOrEqual(4);
+    rmSync(path.join('jest', name), { recursive: true, force: true });
+    environment = Environment.default;
     environment.vars.set('log.level', MatterLogLevel.DEBUG);
     environment.vars.set('log.format', MatterLogFormat.ANSI);
-    environment.vars.set('path.root', homeDir);
+    environment.vars.set('path.root', path.join('jest', name, '.matterbridge', MATTER_STORAGE_NAME));
     environment.vars.set('runtime.signals', false);
     environment.vars.set('runtime.exitcode', false);
+    new MdnsService(environment);
     return environment;
 }
-export async function flushAsync(ticks = 3, microTurns = 10, pause = 100) {
+export async function flushAsync(ticks = 3, microTurns = 10, pause = 250) {
     for (let i = 0; i < ticks; i++)
         await new Promise((resolve) => setImmediate(resolve));
     for (let i = 0; i < microTurns; i++)
@@ -119,8 +256,9 @@ export async function assertAllEndpointNumbersPersisted(targetServer) {
     return all.length;
 }
 export async function startServerNode(name, port) {
-    const server = await ServerNode.create({
+    server = await ServerNode.create({
         id: name + 'ServerNode',
+        environment,
         productDescription: {
             name: name + 'ServerNode',
             deviceType: DeviceTypeId(RootEndpoint.deviceType),
@@ -143,7 +281,7 @@ export async function startServerNode(name, port) {
     });
     expect(server).toBeDefined();
     expect(server.lifecycle.isReady).toBeTruthy();
-    const aggregator = new Endpoint(AggregatorEndpoint, {
+    aggregator = new Endpoint(AggregatorEndpoint, {
         id: name + 'AggregatorNode',
     });
     expect(aggregator).toBeDefined();
@@ -181,7 +319,11 @@ export async function stopServerNode(server) {
     await server.close();
     expect(server.lifecycle.isReady).toBeTruthy();
     expect(server.lifecycle.isOnline).toBeFalsy();
-    await server.env.get(MdnsService)[Symbol.asyncDispose]();
+    const mdns = environment.get(MdnsService);
+    if (mdns && typeof mdns[Symbol.asyncDispose] === 'function')
+        await mdns[Symbol.asyncDispose]();
+    if (mdns && typeof mdns.close === 'function')
+        await mdns.close();
     await flushAsync();
 }
 export async function addDevice(owner, device, pause = 10) {
@@ -206,7 +348,7 @@ export async function addDevice(owner, device, pause = 10) {
     expect(device.lifecycle.hasId).toBeTruthy();
     expect(device.lifecycle.hasNumber).toBeTruthy();
     expect(device.construction.status).toBe(Lifecycle.Status.Active);
-    await flushAsync(1, 1, pause);
+    await flushAsync(undefined, undefined, pause);
     return true;
 }
 export async function deleteDevice(owner, device, pause = 10) {
@@ -231,6 +373,6 @@ export async function deleteDevice(owner, device, pause = 10) {
     expect(device.lifecycle.hasId).toBeTruthy();
     expect(device.lifecycle.hasNumber).toBeTruthy();
     expect(device.construction.status).toBe(Lifecycle.Status.Destroyed);
-    await flushAsync(1, 1, pause);
+    await flushAsync(undefined, undefined, pause);
     return true;
 }

package/dist/matterbridge.js

@@ -171,12 +171,6 @@ export class Matterbridge extends EventEmitter {
         }
         return Matterbridge.instance;
     }
-    async destroyInstance(timeout = 1000, pause = 250) {
-        this.log.info(`Destroy instance...`);
-        await this.cleanup('destroying instance...', false, timeout);
-        if (pause)
-            await wait(pause, 'destroyInstance stop', true);
-    }
     async initialize() {
         this.emit('initialize_started');
         if (hasParameter('service'))
@@ -943,7 +937,7 @@ export class Matterbridge extends EventEmitter {
     async shutdownProcessAndFactoryReset() {
         await this.cleanup('shutting down with factory reset...', false);
     }
-    async cleanup(message, restart = false, timeout = 1000) {
+    async cleanup(message, restart = false, pause = 1000) {
         if (this.initialized && !this.hasCleanupStarted) {
             this.emit('cleanup_started');
             this.hasCleanupStarted = true;
@@ -984,9 +978,9 @@ export class Matterbridge extends EventEmitter {
                 }
             }
             this.log.notice(`Stopping matter server nodes in ${this.bridgeMode} mode...`);
-            if (timeout > 0) {
-                this.log.debug(`Waiting ${timeout}ms for the MessageExchange to finish...`);
-                await wait(timeout, `Waiting ${timeout}ms for the MessageExchange to finish...`, true);
+            if (pause > 0) {
+                this.log.debug(`Waiting ${pause}ms for the MessageExchange to finish...`);
+                await wait(pause, `Waiting ${pause}ms for the MessageExchange to finish...`, false);
             }
             if (this.bridgeMode === 'bridge') {
                 if (this.serverNode) {

package/dist/matterbridgeDeviceTypes.js

@@ -85,6 +85,7 @@ import { WakeOnLan } from '@matter/types/clusters/wake-on-lan';
 import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
 import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
+import { ScenesManagement } from '@matter/types/clusters/scenes-management';
 export var DeviceClasses;
 (function (DeviceClasses) {
     DeviceClasses["Node"] = "Node";
@@ -238,7 +239,7 @@ export const pumpDevice = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [OnOff.Cluster.id, PumpConfigurationAndControl.Cluster.id, Identify.Cluster.id],
-    optionalServerClusters: [LevelControl.Cluster.id, Groups.Cluster.id, TemperatureMeasurement.Cluster.id, PressureMeasurement.Cluster.id, FlowMeasurement.Cluster.id],
+    optionalServerClusters: [LevelControl.Cluster.id, Groups.Cluster.id, ScenesManagement.Cluster.id, TemperatureMeasurement.Cluster.id, PressureMeasurement.Cluster.id, FlowMeasurement.Cluster.id],
 });
 export const waterValve = DeviceTypeDefinition({
     name: 'MA-waterValve',
@@ -254,7 +255,7 @@ export const onOffSwitch = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
 });
 export const dimmableSwitch = DeviceTypeDefinition({
     name: 'MA-dimmableswitch',
@@ -262,15 +263,15 @@ export const dimmableSwitch = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, LevelControl.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
 });
 export const colorTemperatureSwitch = DeviceTypeDefinition({
     name: 'MA-colortemperatureswitch',
     code: 0x0105,
     deviceClass: DeviceClasses.Simple,
     revision: 3,
-    requiredServerClusters: [Identify.Cluster.id, Groups.Cluster.id, OnOff.Cluster.id, LevelControl.Cluster.id, ColorControl.Cluster.id],
-    optionalServerClusters: [Groups.Cluster.id],
+    requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, LevelControl.Cluster.id, ColorControl.Cluster.id],
+    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id],
 });
 export const genericSwitch = DeviceTypeDefinition({
     name: 'MA-genericswitch',
@@ -390,7 +391,7 @@ export const doorLockDevice = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 3,
     requiredServerClusters: [Identify.Cluster.id, DoorLock.Cluster.id],
-    optionalServerClusters: [],
+    optionalServerClusters: [ScenesManagement.Cluster.id, Groups.Cluster.id],
 });
 export const coverDevice = DeviceTypeDefinition({
     name: 'MA-windowCovering',
@@ -496,8 +497,8 @@ export const refrigerator = DeviceTypeDefinition({
     code: 0x70,
     deviceClass: DeviceClasses.Simple,
     revision: 2,
-    requiredServerClusters: [Identify.Cluster.id, RefrigeratorAndTemperatureControlledCabinetMode.Cluster.id, RefrigeratorAlarm.Cluster.id],
-    optionalServerClusters: [],
+    requiredServerClusters: [],
+    optionalServerClusters: [Identify.Cluster.id, RefrigeratorAndTemperatureControlledCabinetMode.Cluster.id, RefrigeratorAlarm.Cluster.id],
 });
 export const airConditioner = DeviceTypeDefinition({
     name: 'MA-airConditioner',
@@ -505,13 +506,7 @@ export const airConditioner = DeviceTypeDefinition({
     deviceClass: DeviceClasses.Simple,
     revision: 2,
     requiredServerClusters: [Identify.Cluster.id, OnOff.Cluster.id, Thermostat.Cluster.id],
-    optionalServerClusters: [
-        Groups.Cluster.id,
-        FanControl.Cluster.id,
-        ThermostatUserInterfaceConfiguration.Cluster.id,
-        TemperatureMeasurement.Cluster.id,
-        RelativeHumidityMeasurement.Cluster.id,
-    ],
+    optionalServerClusters: [Groups.Cluster.id, ScenesManagement.Cluster.id, FanControl.Cluster.id, ThermostatUserInterfaceConfiguration.Cluster.id, TemperatureMeasurement.Cluster.id, RelativeHumidityMeasurement.Cluster.id],
 });
 export const temperatureControlledCabinetCooler = DeviceTypeDefinition({
     name: 'MA-temperaturecontrolledcabinetcooler',
@@ -550,8 +545,8 @@ export const cookSurface = DeviceTypeDefinition({
     code: 0x77,
     deviceClass: DeviceClasses.Simple,
     revision: 1,
-    requiredServerClusters: [TemperatureControl.Cluster.id, TemperatureMeasurement.Cluster.id],
-    optionalServerClusters: [OnOff.Cluster.id],
+    requiredServerClusters: [],
+    optionalServerClusters: [TemperatureControl.Cluster.id, TemperatureMeasurement.Cluster.id, OnOff.Cluster.id],
 });
 export const cooktop = DeviceTypeDefinition({
     name: 'MA-cooktop',
@@ -566,8 +561,8 @@ export const oven = DeviceTypeDefinition({
     code: 0x7b,
     deviceClass: DeviceClasses.Simple,
     revision: 2,
-    requiredServerClusters: [Identify.Cluster.id],
-    optionalServerClusters: [],
+    requiredServerClusters: [],
+    optionalServerClusters: [Identify.Cluster.id],
 });
 export const extractorHood = DeviceTypeDefinition({
     name: 'MA-extractorhood',

package/dist/matterbridgeEndpoint.js

@@ -62,7 +62,7 @@ import { FanControlServer } from '@matter/node/behaviors/fan-control';
 import { ThermostatUserInterfaceConfigurationServer } from '@matter/node/behaviors/thermostat-user-interface-configuration';
 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, } from './matterbridgeEndpointHelpers.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';
 export class MatterbridgeEndpoint extends Endpoint {
     static logLevel = "info";
     mode = undefined;
@@ -82,14 +82,16 @@ export class MatterbridgeEndpoint extends Endpoint {
     hardwareVersion = undefined;
     hardwareVersionString = undefined;
     productUrl = 'https://www.npmjs.com/package/matterbridge';
+    tagList = undefined;
+    originalId = undefined;
+    uniqueStorageKey = undefined;
     name = undefined;
     deviceType = undefined;
-    uniqueStorageKey = undefined;
-    tagList = undefined;
     deviceTypes = new Map();
     commandHandler = new NamedHandler();
     constructor(definition, options = {}, debug = false) {
         let deviceTypeList = [];
+        const originalId = options.id;
         let firstDefinition;
         if (Array.isArray(definition)) {
             firstDefinition = definition[0];
@@ -127,19 +129,14 @@ export class MatterbridgeEndpoint extends Endpoint {
             options.id = generateUniqueId(options.id);
         }
         const optionsV8 = {
-            id: options.uniqueStorageKey?.replace(/[ .]/g, ''),
-            number: options.endpointId,
+            id: options.id?.replace(/[ .]/g, '') || options.uniqueStorageKey?.replace(/[ .]/g, ''),
+            number: options.number || options.endpointId,
             descriptor: options.tagList ? { tagList: options.tagList, deviceTypeList } : { deviceTypeList },
         };
-        if (options.id !== undefined) {
-            optionsV8.id = options.id.replace(/[ .]/g, '');
-        }
-        if (options.number !== undefined) {
-            optionsV8.number = options.number;
-        }
         super(endpointV8, optionsV8);
         this.mode = options.mode;
-        this.uniqueStorageKey = options.id ? options.id : options.uniqueStorageKey;
+        this.uniqueStorageKey = options.id ?? options.uniqueStorageKey;
+        this.originalId = originalId;
         this.name = firstDefinition.name;
         this.deviceType = firstDefinition.code;
         this.tagList = options.tagList;
@@ -150,7 +147,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         }
         else
             this.deviceTypes.set(firstDefinition.code, firstDefinition);
-        this.log = new AnsiLogger({ logName: options.uniqueStorageKey ?? 'MatterbridgeEndpoint', logTimestampFormat: 4, logLevel: debug === true ? "debug" : MatterbridgeEndpoint.logLevel });
+        this.log = new AnsiLogger({ logName: this.originalId ?? this.uniqueStorageKey ?? '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 });
     }
@@ -264,10 +261,10 @@ export class MatterbridgeEndpoint extends Endpoint {
                 for (const tag of options.tagList) {
                     this.log.debug(`- with tagList: mfgCode ${CYAN}${tag.mfgCode}${db} namespaceId ${CYAN}${tag.namespaceId}${db} tag ${CYAN}${tag.tag}${db} label ${CYAN}${tag.label}${db}`);
                 }
-                child = new MatterbridgeEndpoint(definition, { uniqueStorageKey: endpointName, endpointId: options.endpointId, tagList: options.tagList }, debug);
+                child = new MatterbridgeEndpoint(definition, { id: endpointName, number: options.number, tagList: options.tagList }, debug);
             }
             else {
-                child = new MatterbridgeEndpoint(definition, { uniqueStorageKey: endpointName, endpointId: options.endpointId }, debug);
+                child = new MatterbridgeEndpoint(definition, { id: endpointName, number: options.number }, debug);
             }
         }
         if (Array.isArray(definition)) {
@@ -303,10 +300,10 @@ export class MatterbridgeEndpoint extends Endpoint {
                 for (const tag of options.tagList) {
                     this.log.debug(`- with tagList: mfgCode ${CYAN}${tag.mfgCode}${db} namespaceId ${CYAN}${tag.namespaceId}${db} tag ${CYAN}${tag.tag}${db} label ${CYAN}${tag.label}${db}`);
                 }
-                child = new MatterbridgeEndpoint(definition, { uniqueStorageKey: endpointName, endpointId: options.endpointId, tagList: options.tagList }, debug);
+                child = new MatterbridgeEndpoint(definition, { id: endpointName, number: options.number, tagList: options.tagList }, debug);
             }
             else {
-                child = new MatterbridgeEndpoint(definition, { uniqueStorageKey: endpointName, endpointId: options.endpointId }, debug);
+                child = new MatterbridgeEndpoint(definition, { id: endpointName, number: options.number }, debug);
             }
         }
         if (Array.isArray(definition)) {
@@ -362,7 +359,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return Array.from(this.parts);
     }
     static serialize(device) {
-        if (!device.serialNumber || !device.deviceName || !device.uniqueId)
+        if (!device.serialNumber || !device.deviceName || !device.uniqueId || !device.maybeId || !device.maybeNumber)
             return;
         const serialized = {
             pluginName: device.plugin ?? '',
@@ -374,8 +371,8 @@ export class MatterbridgeEndpoint extends Endpoint {
             vendorId: device.vendorId,
             vendorName: device.vendorName,
             deviceTypes: Array.from(device.deviceTypes.values()),
-            endpoint: device.maybeNumber,
-            endpointName: device.maybeId ?? device.deviceName,
+            id: device.id,
+            number: device.number,
             clusterServersId: [],
         };
         Object.keys(device.behaviors.supported).forEach((behaviorName) => {
@@ -387,7 +384,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         return serialized;
     }
     static deserialize(serializedDevice) {
-        const device = new MatterbridgeEndpoint(serializedDevice.deviceTypes, { uniqueStorageKey: serializedDevice.endpointName, endpointId: serializedDevice.endpoint }, false);
+        const device = new MatterbridgeEndpoint(serializedDevice.deviceTypes, { id: serializedDevice.id, number: serializedDevice.number }, false);
         device.plugin = serializedDevice.pluginName;
         device.deviceName = serializedDevice.deviceName;
         device.serialNumber = serializedDevice.serialNumber;
@@ -408,6 +405,10 @@ export class MatterbridgeEndpoint extends Endpoint {
         this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Wired), getDefaultPowerSourceWiredClusterServer(wiredCurrentType));
         return this;
     }
+    createDefaultPowerSourceBatteryClusterServer(batPercentRemaining = null, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = null, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
+        this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery), getDefaultPowerSourceBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage, batReplaceability));
+        return this;
+    }
     createDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1, batReplaceability = PowerSource.BatReplaceability.UserReplaceable) {
         this.behaviors.require(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining, batChargeLevel, batVoltage, batReplacementDescription, batQuantity, batReplaceability));
         return this;
@@ -946,7 +947,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             actuatorEnabled: false,
             operatingMode: DoorLock.OperatingMode.Normal,
             supportedOperatingModes: { normal: false, vacation: true, privacy: true, noRemoteLockUnlock: true, passage: true, alwaysSet: 2047 },
-            alarmMask: { lockJammed: false, lockFactoryReset: false, lockRadioPowerCycled: false, wrongCodeEntryLimit: false, frontEscutcheonRemoved: false, doorForcedOpen: false },
         });
         return this;
     }

package/dist/matterbridgeEndpointHelpers.js

@@ -78,11 +78,10 @@ import { Pm25ConcentrationMeasurementServer } from '@matter/node/behaviors/pm25-
 import { Pm10ConcentrationMeasurementServer } from '@matter/node/behaviors/pm10-concentration-measurement';
 import { RadonConcentrationMeasurementServer } from '@matter/node/behaviors/radon-concentration-measurement';
 import { TotalVolatileOrganicCompoundsConcentrationMeasurementServer } from '@matter/node/behaviors/total-volatile-organic-compounds-concentration-measurement';
-import { DeviceEnergyManagementServer } from '@matter/node/behaviors/device-energy-management';
 import { deepCopy } from './utils/deepCopy.js';
 import { deepEqual } from './utils/deepEqual.js';
 import { isValidArray } from './utils/isvalid.js';
-import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, MatterbridgeDeviceEnergyManagementModeServer, MatterbridgePowerSourceServer, MatterbridgeDeviceEnergyManagementServer, } from './matterbridgeBehaviors.js';
+import { MatterbridgeIdentifyServer, MatterbridgeOnOffServer, MatterbridgeLevelControlServer, MatterbridgeColorControlServer, MatterbridgeLiftWindowCoveringServer, MatterbridgeThermostatServer, MatterbridgeFanControlServer, MatterbridgeDoorLockServer, MatterbridgeModeSelectServer, MatterbridgeValveConfigurationAndControlServer, MatterbridgeSmokeCoAlarmServer, MatterbridgeBooleanStateConfigurationServer, MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeDeviceEnergyManagementModeServer, } from './matterbridgeBehaviors.js';
 export function capitalizeFirstLetter(name) {
     if (!name)
         return name;
@@ -216,7 +215,7 @@ export function getBehaviourTypeFromClusterServerId(clusterId) {
     if (clusterId === TotalVolatileOrganicCompoundsConcentrationMeasurement.Cluster.id)
         return TotalVolatileOrganicCompoundsConcentrationMeasurementServer.with('NumericMeasurement');
     if (clusterId === DeviceEnergyManagement.Cluster.id)
-        return DeviceEnergyManagementServer.with('PowerForecastReporting');
+        return MatterbridgeDeviceEnergyManagementServer.with('PowerForecastReporting');
     if (clusterId === DeviceEnergyManagementMode.Cluster.id)
         return MatterbridgeDeviceEnergyManagementModeServer;
     return MatterbridgeIdentifyServer;
@@ -257,21 +256,21 @@ export async function invokeBehaviorCommand(endpoint, cluster, command, params)
 }
 export async function invokeSubscribeHandler(endpoint, cluster, attribute, newValue, oldValue) {
     const event = attribute + '$Changed';
-    const clusterName = getBehavior(endpoint, cluster)?.id;
-    if (!clusterName) {
+    const behaviorId = getBehavior(endpoint, cluster)?.id;
+    if (!behaviorId) {
         endpoint.log.error(`invokeSubscribeHandler ${hk}${event}${er} error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
         return false;
     }
     if (endpoint.construction.status !== Lifecycle.Status.Active) {
-        endpoint.log.error(`invokeSubscribeHandler ${hk}${clusterName}.${event}${er} error: Endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er} is in the ${BLUE}${endpoint.construction.status}${er} state`);
+        endpoint.log.error(`invokeSubscribeHandler ${hk}${behaviorId}.${event}${er} error: Endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er} is in the ${BLUE}${endpoint.construction.status}${er} state`);
         return false;
     }
     const events = endpoint.events;
-    if (!(clusterName in events) || !(event in events[clusterName])) {
-        endpoint.log.error(`invokeSubscribeHandler ${hk}${event}${er} error: cluster ${clusterName} not found on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
+    if (!(behaviorId in events) || !(event in events[behaviorId])) {
+        endpoint.log.error(`invokeSubscribeHandler ${hk}${event}${er} error: cluster ${behaviorId} not found on endpoint ${or}${endpoint.id}${er}:${or}${endpoint.number}${er}`);
         return false;
     }
-    await endpoint.act((agent) => agent[clusterName].events[event].emit(newValue, oldValue, { ...agent.context, offline: false }));
+    await endpoint.act((agent) => agent[behaviorId].events[event].emit(newValue, oldValue, { ...agent.context, offline: false }));
     return true;
 }
 export function addRequiredClusterServers(endpoint) {
@@ -549,6 +548,19 @@ export function getDefaultPowerSourceWiredClusterServer(wiredCurrentType = Power
         wiredCurrentType,
     });
 }
+export function getDefaultPowerSourceBatteryClusterServer(batPercentRemaining = null, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = null, batReplaceability = PowerSource.BatReplaceability.Unspecified) {
+    return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery), {
+        status: PowerSource.PowerSourceStatus.Active,
+        order: 0,
+        description: 'Primary battery',
+        endpointList: [],
+        batVoltage,
+        batPercentRemaining: batPercentRemaining !== null ? Math.min(Math.max(batPercentRemaining * 2, 0), 200) : null,
+        batChargeLevel,
+        batReplacementNeeded: false,
+        batReplaceability,
+    });
+}
 export function getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, batVoltage = 1500, batReplacementDescription = 'Battery type', batQuantity = 1, batReplaceability = PowerSource.BatReplaceability.UserReplaceable) {
     return optionsFor(MatterbridgePowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable), {
         status: PowerSource.PowerSourceStatus.Active,
@@ -690,7 +702,7 @@ export function getDefaultDeviceEnergyManagementClusterServer(esaType = DeviceEn
     });
 }
 export function getDefaultDeviceEnergyManagementModeClusterServer(currentMode, supportedModes) {
-    return optionsFor(MatterbridgeDeviceEnergyManagementModeServer, {
+    return optionsFor(MatterbridgeDeviceEnergyManagementModeServer.with(), {
         supportedModes: supportedModes ?? [
             { label: 'No Energy Management (Forecast reporting only)', mode: 1, modeTags: [{ value: DeviceEnergyManagementMode.ModeTag.NoOptimization }] },
             {
@@ -714,7 +726,7 @@ export function getDefaultDeviceEnergyManagementModeClusterServer(currentMode, s
     });
 }
 export function getDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
-    return optionsFor(MatterbridgeOperationalStateServer, {
+    return optionsFor(MatterbridgeOperationalStateServer.with(), {
         phaseList: [],
         currentPhase: null,
         countdownTime: null,

package/dist/matterbridgeEndpointTypes.js

@@ -0,0 +1,3 @@
+if (process.argv.includes('--loader') || process.argv.includes('-loader'))
+    console.log('\u001B[32mMatterbridgeEndpointTypes loaded.\u001B[40;0m');
+export {};

package/dist/matterbridgePlatform.js

@@ -104,6 +104,20 @@ export class MatterbridgePlatform {
         }
         this.matterbridge.plugins.saveConfigFromJson(plugin, config);
     }
+    getSchema() {
+        const plugin = this.matterbridge.plugins.get(this.name);
+        if (!plugin || !isValidObject(plugin.schemaJson)) {
+            throw new Error(`Plugin ${this.name} not found`);
+        }
+        return plugin.schemaJson;
+    }
+    setSchema(schema) {
+        const plugin = this.matterbridge.plugins.get(this.name);
+        if (!plugin) {
+            throw new Error(`Plugin ${this.name} not found`);
+        }
+        plugin.schemaJson = schema;
+    }
     wssSendRestartRequired(snackbar = true, fixed = false) {
         this.matterbridge.frontend.wssSendRestartRequired(snackbar, fixed);
     }
@@ -124,12 +138,15 @@ export class MatterbridgePlatform {
         if (aggregator) {
             if (aggregator.parts.has(name.replaceAll(' ', '') + ':' + type)) {
                 this.log.warn(`Virtual device ${name} already registered. Please use a different name.`);
+                return false;
             }
             else {
                 await addVirtualDevice(aggregator, name.slice(0, 32), type, callback);
                 this.log.info(`Virtual device ${name} created.`);
+                return true;
             }
         }
+        return false;
     }
     async registerDevice(device) {
         device.plugin = this.name;

package/dist/pluginManager.js

@@ -776,7 +776,7 @@ export class PluginManager extends EventEmitter {
             }
         }
         catch (err) {
-            logError(this.log, `Failed to load plugin ${plg}${plugin.name}${er}`, err);
+            inspectError(this.log, `Failed to load plugin ${plg}${plugin.name}${er}`, err);
             plugin.error = true;
         }
         return undefined;

package/dist/utils/error.js

@@ -1,10 +1,10 @@
 import { inspect } from 'node:util';
 import { RESET } from 'node-ansi-logger';
 export function logError(log, message, error) {
-    log.error(`${message}: ${error instanceof Error ? error.message + '\nStack:\n' + error.stack : error}`);
+    log.error(`${message}: ${error instanceof Error ? error.message + ' \nStack: \n' + error.stack : error}`);
 }
 export function inspectError(log, message, error) {
-    const errorMessage = error instanceof Error ? `${error.message}\n` : '';
+    const errorMessage = error instanceof Error ? `${error.message} \n` : '';
     const inspectedError = inspect(error, { depth: 10, colors: true, showHidden: false });
     log.error(`${message}: ${errorMessage}${RESET}${inspectedError}`);
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.3.7-dev-20251109-a306ab9",
+  "version": "3.3.8-dev-20251114-9b65e59",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.3.7-dev-20251109-a306ab9",
+      "version": "3.3.8-dev-20251114-9b65e59",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.6",
@@ -367,9 +367,9 @@
       "license": "MIT"
     },
     "node_modules/bare-events": {
-      "version": "2.8.1",
-      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.1.tgz",
-      "integrity": "sha512-oxSAxTS1hRfnyit2CL5QpAOS5ixfBjj6ex3yTNvXyY/kE719jQ/IjuESJBK2w5v4wwQRAHGseVJXx9QBYOtFGQ==",
+      "version": "2.8.2",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.2.tgz",
+      "integrity": "sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ==",
       "license": "Apache-2.0",
       "peerDependencies": {
         "bare-abort-controller": "*"
@@ -1507,9 +1507,9 @@
       }
     },
     "node_modules/path-scurry": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.0.tgz",
-      "integrity": "sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.1.tgz",
+      "integrity": "sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==",
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "lru-cache": "^11.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.3.7-dev-20251109-a306ab9",
+  "version": "3.3.8-dev-20251114-9b65e59",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",
@@ -65,6 +65,10 @@
       "import": "./dist/utils/export.js",
       "types": "./dist/utils/export.d.ts"
     },
+    "./jestutils": {
+      "import": "./dist/jestutils/export.js",
+      "types": "./dist/jestutils/export.d.ts"
+    },
     "./logger": {
       "import": "./dist/logger/export.js",
       "types": "./dist/logger/export.d.ts"

package/scripts/fetch-chip.mjs

@@ -0,0 +1,100 @@
+/* eslint-disable */
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join as pathJoin, sep as pathSep } from 'node:path';
+import https from 'node:https';
+
+/**
+ * Fetch the canonical Matter ZCL JSON file from the connectedhomeip repository
+ * and store it locally for offline / deterministic revision checks.
+ *
+ * Environment overrides:
+ *  - ZCL_OUT: output path for zcl.json (default: chip/zcl.json)
+ *  - ZCL_BRANCH: connectedhomeip branch to fetch from (default: v1.4-branch)
+ */
+const OUT_PATH = process.env.ZCL_OUT || 'chip/zcl.json';
+// Single branch strategy from online only
+const BRANCH = process.env.ZCL_BRANCH || 'v1.4-branch';
+const ZCL_BASE = `https://raw.githubusercontent.com/project-chip/connectedhomeip/${BRANCH}/src/app/zap-templates/zcl/`;
+const ZCL_JSON_URL = ZCL_BASE + 'zcl.json';
+const XML_BASE = ZCL_BASE + 'data-model/chip/';
+const MANUFACTURERS_URL = ZCL_BASE + 'data-model/manufacturers.xml';
+
+function fetchUrl(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        // Follow redirect
+        return resolve(fetchUrl(res.headers.location));
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Failed to fetch ${url}: ${res.statusCode}`));
+      }
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    }).on('error', reject);
+  });
+}
+
+async function main() {
+  await mkdir(dirname(OUT_PATH), { recursive: true });
+  // Always fetch online from the specified branch
+  const data = await fetchUrl(ZCL_JSON_URL);
+
+  // Structural sanity check: this is a ZAP ZCL properties file, expected to include xml roots and files
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch (e) {
+    throw new Error(`Downloaded content is not valid JSON: ${e.message}`);
+  }
+  if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.xmlFile)) {
+    process.stderr.write('Warning: zcl.json does not contain expected ZAP ZCL properties (xmlFile). Saving anyway for manual inspection.\n');
+  }
+
+  await writeFile(OUT_PATH, JSON.stringify(parsed, null, 2));
+  process.stderr.write(`Saved ${OUT_PATH}.\n`);
+
+  // Also fetch manufacturers.xml to chip/manufacturers.xml from the same branch
+  try {
+    const outManu = 'chip/manufacturers.xml';
+    const manuContent = await fetchUrl(MANUFACTURERS_URL);
+    await writeFile(outManu, manuContent);
+    process.stderr.write('Saved chip/manufacturers.xml.\n');
+  } catch (e) {
+    process.stderr.write(`Warning: failed to fetch manufacturers.xml (${e.message}).\n`);
+  }
+
+  // Always fetch XMLs referenced by zcl.json from the same branch under data-model/chip
+  const xmlFiles = Array.isArray(parsed.xmlFile) ? parsed.xmlFile : [];
+  if (xmlFiles.length === 0) {
+    process.stderr.write('No xmlFile entries found; skipping XML fetch.\n');
+  } else {
+    const outXmlBase = 'chip/xml';
+    await mkdir(outXmlBase, { recursive: true });
+    let ok = 0;
+    let fail = 0;
+    for (const fileName of xmlFiles) {
+      const relative = fileName.trim();
+      try {
+        const url = XML_BASE + relative;
+        const content = await fetchUrl(url);
+        const outPath = pathJoin(outXmlBase, relative.replaceAll('/', pathSep));
+        await mkdir(dirname(outPath), { recursive: true });
+        await writeFile(outPath, content);
+        ok++;
+      } catch (e) {
+        fail++;
+        process.stderr.write(`Failed XML: ${relative} (${e.message})\n`);
+      }
+    }
+    process.stderr.write(`Fetched XML files: ${ok} ok, ${fail} failed. Output under ${outXmlBase}. Branch=${BRANCH}\n`);
+  }
+  // Ensure success exit unless an unhandled error occurred
+  process.exit(0);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Error: ${err.message}\n`);
+  process.exitCode = 1;
+});