@matterbridge/core 3.5.6-dev-20260226-42f2137 → 3.5.6-dev-20260227-3952eff

package/dist/helpers.js

@@ -1,13 +1,15 @@
 if (process.argv.includes('--loader') || process.argv.includes('-loader'))
     console.log('\u001B[32mMatterbridge helpers loaded.\u001B[40;0m');
 import { Endpoint } from '@matter/node';
+import { BindingServer } from '@matter/node/behaviors/binding';
 import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/bridged-device-basic-information';
 import { DescriptorServer } from '@matter/node/behaviors/descriptor';
-import { OnOffBaseServer } from '@matter/node/behaviors/on-off';
+import { OnOffBaseServer, OnOffServer } from '@matter/node/behaviors/on-off';
 import { MountedOnOffControlDevice } from '@matter/node/devices/mounted-on-off-control';
 import { OnOffLightDevice } from '@matter/node/devices/on-off-light';
 import { OnOffLightSwitchDevice } from '@matter/node/devices/on-off-light-switch';
 import { OnOffPlugInUnitDevice } from '@matter/node/devices/on-off-plug-in-unit';
+import { Identify } from '@matter/types/clusters/identify';
 import { OnOff } from '@matter/types/clusters/on-off';
 import { VendorId } from '@matter/types/datatype';
 import { hasParameter } from '@matterbridge/utils';
@@ -21,7 +23,7 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
             deviceType = OnOffPlugInUnitDevice.with(BridgedDeviceBasicInformationServer);
             break;
         case 'switch':
-            deviceType = OnOffLightSwitchDevice.with(BridgedDeviceBasicInformationServer, OnOffBaseServer);
+            deviceType = OnOffLightSwitchDevice.with(BridgedDeviceBasicInformationServer, OnOffServer.with(), BindingServer);
             break;
         case 'mounted_switch':
             deviceType = MountedOnOffControlDevice.with(BridgedDeviceBasicInformationServer);
@@ -29,15 +31,22 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
     }
     const device = new Endpoint(deviceType, {
         id: name.replaceAll(' ', '') + ':' + type,
-        bridgedDeviceBasicInformation: { vendorId: VendorId(0xfff1), vendorName: 'Matterbridge', productName: 'Matterbridge Virtual Device', nodeLabel: name.slice(0, 32) },
-        onOff: { onOff: false, startUpOnOff: OnOff.StartUpOnOff.Off },
+        bridgedDeviceBasicInformation: {
+            vendorId: VendorId(0xfff1),
+            vendorName: 'Matterbridge',
+            productName: 'Matterbridge Virtual Device',
+            nodeLabel: name.slice(0, 32),
+            softwareVersion: 2000,
+            softwareVersionString: '2.0.0',
+        },
+        onOff: { onOff: false },
     });
     device.events.onOff.onOff$Changed.on((value) => {
         if (value) {
             callback();
             process.nextTick(async () => {
                 try {
-                    await device.setStateOf(OnOffBaseServer, { onOff: false });
+                    await device.setStateOf(OnOffServer, { onOff: false });
                 }
                 catch (_error) {
                 }
@@ -46,6 +55,12 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
     });
     await aggregatorEndpoint.add(device);
     await device.construction.ready;
+    if (type === 'switch') {
+        await device.act(async (agent) => {
+            const descriptor = await agent.load(DescriptorServer);
+            descriptor.state.clientList.push(Identify.Cluster.id, OnOff.Cluster.id);
+        });
+    }
     if (type === 'mounted_switch') {
         await device.act(async (agent) => {
             const descriptor = await agent.load(DescriptorServer);

package/dist/jestutils/jestHelpers.d.ts

@@ -72,11 +72,11 @@ export declare function setupTest(name: string, debug?: boolean): Promise<void>;
 export declare function setDebug(debug: boolean): Promise<void>;
 export declare function startMatterbridge(bridgeMode?: 'bridge' | 'childbridge' | 'controller' | '', frontendPort?: number, matterPort?: number, passcode?: number, discriminator?: number, pluginSize?: number, devicesSize?: number): Promise<Matterbridge>;
 export declare function stopMatterbridge(cleanupPause?: number, destroyPause?: number): Promise<void>;
-export declare function createMatterbridgeEnvironment(name: string): Promise<Matterbridge>;
-export declare function startMatterbridgeEnvironment(port?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
+export declare function createMatterbridgeEnvironment(name: string, createOnly?: boolean): Promise<Matterbridge>;
+export declare function startMatterbridgeEnvironment(port?: number, createOnly?: boolean): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
 export declare function addMatterbridgePlatform(platform: MatterbridgePlatform, name?: string): void;
-export declare function stopMatterbridgeEnvironment(): Promise<void>;
-export declare function destroyMatterbridgeEnvironment(cleanupPause?: number, destroyPause?: number): Promise<void>;
+export declare function stopMatterbridgeEnvironment(createOnly?: boolean): Promise<void>;
+export declare function destroyMatterbridgeEnvironment(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean): Promise<void>;
 export declare function destroyInstance(matterbridge: Matterbridge, cleanupPause?: number, destroyPause?: number): Promise<void>;
 export declare function closeMdnsInstance(matterbridge: Matterbridge): Promise<void>;
 export declare function createTestEnvironment(name: string, createOnly?: boolean): Environment;

package/dist/jestutils/jestHelpers.js

@@ -250,7 +250,7 @@ export async function startMatterbridge(bridgeMode = 'bridge', frontendPort = 82
 export async function stopMatterbridge(cleanupPause = 10, destroyPause = 250) {
     await destroyMatterbridgeEnvironment(cleanupPause, destroyPause);
 }
-export async function createMatterbridgeEnvironment(name) {
+export async function createMatterbridgeEnvironment(name, createOnly = false) {
     log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
     matterbridge = await Matterbridge.loadInstance(false);
     expect(matterbridge).toBeDefined();
@@ -266,12 +266,12 @@ export async function createMatterbridgeEnvironment(name) {
     frontend = matterbridge.frontend;
     plugins = matterbridge.plugins;
     devices = matterbridge.devices;
-    matterbridge.environment = createTestEnvironment(name);
+    matterbridge.environment = createTestEnvironment(name, createOnly);
     expect(matterbridge.environment).toBeDefined();
     expect(matterbridge.environment).toBeInstanceOf(Environment);
     return matterbridge;
 }
-export async function startMatterbridgeEnvironment(port = 5540) {
+export async function startMatterbridgeEnvironment(port = 5540, createOnly = false) {
     matterbridge.nodeStorage = new NodeStorageManager({
         dir: path.join(matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR),
         writeQueue: false,
@@ -295,6 +295,10 @@ export async function startMatterbridgeEnvironment(port = 5540) {
     expect(server.parts.has(aggregator.id)).toBeTruthy();
     expect(server.parts.has(aggregator)).toBeTruthy();
     expect(aggregator.lifecycle.isReady).toBeTruthy();
+    if (createOnly) {
+        await flushAsync();
+        return [server, aggregator];
+    }
     expect(server.lifecycle.isOnline).toBeFalsy();
     await new Promise((resolve) => {
         server.lifecycle.online.on(async () => {
@@ -339,14 +343,16 @@ export function addMatterbridgePlatform(platform, name) {
     });
     platform['name'] = platform.config.name;
 }
-export async function stopMatterbridgeEnvironment() {
+export async function stopMatterbridgeEnvironment(createOnly = false) {
     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();
+    if (!createOnly) {
+        expect(server.lifecycle.isOnline).toBeTruthy();
+    }
     await server.close();
     expect(server.lifecycle.isReady).toBeFalsy();
     expect(server.lifecycle.isOnline).toBeFalsy();
@@ -360,9 +366,11 @@ export async function stopMatterbridgeEnvironment() {
     matterbridge.nodeStorage = undefined;
     await flushAsync();
 }
-export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 250) {
+export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 250, closeMdns = true) {
     await destroyInstance(matterbridge, cleanupPause, destroyPause);
-    await closeMdnsInstance(matterbridge);
+    if (closeMdns) {
+        await closeMdnsInstance(matterbridge);
+    }
     Matterbridge.instance = undefined;
 }
 export async function destroyInstance(matterbridge, cleanupPause = 10, destroyPause = 250) {

package/dist/matterbridge.js

@@ -218,11 +218,11 @@ export class Matterbridge extends EventEmitter {
                     await this.nodeContext?.set('globalModulesDirectory', msg.params.prefix);
                     this.server.respond({ ...msg, result: { success: true } });
                     break;
-                case 'matterbridge_sys_update':
+                case 'matterbridge_shelly_sys_update':
                     this.shellySysUpdate = true;
                     this.server.respond({ ...msg, result: { success: true } });
                     break;
-                case 'matterbridge_main_update':
+                case 'matterbridge_shelly_main_update':
                     this.shellyMainUpdate = true;
                     this.server.respond({ ...msg, result: { success: true } });
                     break;
@@ -1584,6 +1584,7 @@ export class Matterbridge extends EventEmitter {
         this.matterStorageService = undefined;
         this.matterStorageManager = undefined;
         this.matterbridgeContext = undefined;
+        this.controllerContext = undefined;
         this.log.info('Matter node storage closed');
     }
     async createServerNodeContext(storeId, deviceName, deviceType, vendorId, vendorName, productId, productName, serialNumber, uniqueId) {
@@ -1681,15 +1682,17 @@ export class Matterbridge extends EventEmitter {
             },
         });
         serverNode.lifecycle.commissioned.on(() => {
-            this.log.notice(`Server node for ${storeId} was initially commissioned successfully!`);
+            this.log.notice(`Server node for ${storeId} commissioned successfully!`);
             this.advertisingNodes.delete(storeId);
             this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
+            this.frontend.wssSendSnackbarMessage(`Server node for ${storeId} commissioned successfully!`, 5, 'success');
         });
         serverNode.lifecycle.decommissioned.on(() => {
-            this.log.notice(`Server node for ${storeId} was fully decommissioned successfully!`);
+            this.log.notice(`Server node for ${storeId} fully decommissioned successfully!`);
             this.advertisingNodes.delete(storeId);
             this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
             this.frontend.wssSendSnackbarMessage(`${storeId} is offline`, 5, 'warning');
+            this.frontend.wssSendSnackbarMessage(`Server node for ${storeId} fully decommissioned successfully!`, 5, 'success');
         });
         serverNode.lifecycle.online.on(async () => {
             this.log.notice(`Server node for ${storeId} is online`);

package/dist/matterbridgeBehaviorsClient.d.ts

@@ -0,0 +1,15 @@
+import { BindingBehavior } from '@matter/main/behaviors/binding';
+import { ClusterId } from '@matter/main/types';
+export declare class MatterbridgeBindingServer extends BindingBehavior {
+    protected internal: MatterbridgeBindingServer.Internal;
+    state: MatterbridgeBindingServer.State;
+    initialize(): Promise<void>;
+}
+export declare namespace MatterbridgeBindingServer {
+    class Internal {
+        bound: boolean;
+    }
+    class State extends BindingBehavior.State {
+        clientList: ClusterId[];
+    }
+}

package/dist/matterbridgeBehaviorsClient.js

@@ -0,0 +1,25 @@
+import { BindingBehavior } from '@matter/main/behaviors/binding';
+import { DescriptorServer } from '@matter/main/behaviors/descriptor';
+import { MatterbridgeServer } from './matterbridgeBehaviors.js';
+export class MatterbridgeBindingServer extends BindingBehavior {
+    async initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Initializing MatterbridgeBindingServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) with clientList: ${this.state.clientList.join(', ')}`);
+        (await this.agent.load(DescriptorServer)).state.clientList.push(...this.state.clientList);
+        this.reactTo(this.events.binding$Changed, (value) => {
+            this.internal.bound = value.length > 0;
+            device.log.notice(`MatterbridgeBindingServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber}) binding changed: ${value}, bound: ${this.internal.bound}`);
+        });
+        await super.initialize();
+    }
+}
+(function (MatterbridgeBindingServer) {
+    class Internal {
+        bound = false;
+    }
+    MatterbridgeBindingServer.Internal = Internal;
+    class State extends BindingBehavior.State {
+        clientList = [];
+    }
+    MatterbridgeBindingServer.State = State;
+})(MatterbridgeBindingServer || (MatterbridgeBindingServer = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.5.6-dev-20260226-42f2137",
+  "version": "3.5.6-dev-20260227-3952eff",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -122,10 +122,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.10",
-    "@matterbridge/dgram": "3.5.6-dev-20260226-42f2137",
-    "@matterbridge/thread": "3.5.6-dev-20260226-42f2137",
-    "@matterbridge/types": "3.5.6-dev-20260226-42f2137",
-    "@matterbridge/utils": "3.5.6-dev-20260226-42f2137",
+    "@matterbridge/dgram": "3.5.6-dev-20260227-3952eff",
+    "@matterbridge/thread": "3.5.6-dev-20260227-3952eff",
+    "@matterbridge/types": "3.5.6-dev-20260227-3952eff",
+    "@matterbridge/utils": "3.5.6-dev-20260227-3952eff",
     "archiver": "7.0.1",
     "express": "5.2.1",
     "glob": "13.0.6",