@matterbridge/core 3.6.0-dev-20260302-e3a7eb0 → 3.6.0-dev-20260303-2f99eca

package/dist/matterbridge.js

@@ -8,10 +8,10 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { inspect } from 'node:util';
 import { Crypto, Environment, LogFormat as MatterLogFormat, Logger, LogLevel as MatterLogLevel, StorageService, UINT16_MAX, UINT32_MAX, } from '@matter/general';
-import { Endpoint, ServerNode } from '@matter/node';
-import { BasicInformationServer } from '@matter/node/behaviors/basic-information';
+import { Endpoint, NetworkClient, ServerNode } from '@matter/node';
+import { BasicInformationClient, BasicInformationServer } from '@matter/node/behaviors/basic-information';
 import { AggregatorEndpoint } from '@matter/node/endpoints';
-import { PaseClient } from '@matter/protocol';
+import { PaseClient, Read, Subscribe } from '@matter/protocol';
 import { DeviceTypeId, VendorId } from '@matter/types/datatype';
 import { BroadcastServer } from '@matterbridge/thread';
 import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, typ } from '@matterbridge/types';
@@ -1532,26 +1532,82 @@ export class Matterbridge extends EventEmitter {
                 reachable: true,
             },
         });
-        this.log.info(`Starting matter commissioning controller: ${this.controllerNode.peers.size} peer nodes...`);
+        this.log.info(`Loaded matter commissioning controller with ${this.controllerNode.peers.size} peer nodes.`);
+        const requestedNodeId = getIntParameter('node');
+        const nodeLabel = requestedNodeId !== undefined ? `Node ${requestedNodeId}` : undefined;
+        const peerId = requestedNodeId !== undefined ? `peer${requestedNodeId}` : undefined;
         if (hasParameter('pair')) {
             let options;
             if (hasParameter('pairingcode')) {
                 const pairingCode = getParameter('pairingcode');
-                this.log.info(`Pairing device with pairingcode: ${pairingCode}`);
+                this.log.info(`Pairing device ${nodeLabel} with pairingcode: ${pairingCode}`);
                 const pairingData = ManualPairingCodeCodec.decode(pairingCode);
-                this.log.info(`Data extracted from pairing code: ${Logger.toJSON(pairingData)}`);
-                options = { id: 'device', pairingCode };
+                this.log.info(`- passcode: ${pairingData.passcode}`);
+                this.log.info(`- shortDiscriminator: ${pairingData.shortDiscriminator ?? 'n/a (should never be n/a, short discriminator is encoded in the manual pairing code)'} `);
+                this.log.info(`- longDiscriminator: ${pairingData.discriminator ?? 'n/a (manual pairing code encodes short discriminator only)'}`);
+                this.log.info(`- vendorId: ${pairingData.vendorId ?? 'n/a'}`);
+                this.log.info(`- productId: ${pairingData.productId ?? 'n/a'}`);
+                options = {
+                    id: peerId,
+                    pairingCode,
+                    ...(pairingData.shortDiscriminator !== undefined ? { shortDiscriminator: pairingData.shortDiscriminator } : {}),
+                    ...(pairingData.vendorId !== undefined ? { vendorId: pairingData.vendorId } : {}),
+                    ...(pairingData.productId !== undefined ? { productId: pairingData.productId } : {}),
+                };
             }
             else {
                 const discriminator = getIntParameter('discriminator');
                 const passcode = getIntParameter('passcode') ?? 0;
-                options = { id: 'device', discriminator, passcode };
+                this.log.info(`Pairing device ${nodeLabel} with discriminator: ${discriminator}, passcode: ${passcode}`);
+                options = { id: peerId, discriminator, passcode };
+            }
+            this.log.notice(`Commissioning node ${nodeLabel} with options: ${debugStringify(options)}`);
+            try {
+                const commissionedNode = await this.controllerNode.peers.commission(options);
+                this.log.notice(`Commissioning successfully done for node ${commissionedNode.id}`);
+            }
+            catch (error) {
+                this.log.error(`Commissioning failed for node ${nodeLabel}: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+        else if (hasParameter('discover')) {
+            this.log.info('Discovering commissionable devices...');
+            const discovery = this.controllerNode.peers.discover();
+            discovery.discovered.on((node) => {
+                this.log.info(`Discovered commissionable device: ${node.id}`);
+            });
+        }
+        else if (hasParameter('peers')) {
+            await this.controllerNode.start();
+            const peers = this.controllerNode.peers;
+            this.log.info(`Matter commissioning controller paired nodes: ${peers.size}`);
+            for (const peer of peers) {
+                const match = /^peer(\d+)$/.exec(peer.id);
+                this.log.info(`- ${match ? `Node ${match[1]}` : peer.id}`);
+            }
+        }
+        else if (hasParameter('unpair')) {
+            await this.controllerNode.start();
+            const requestedNodeId = getIntParameter('node');
+            if (requestedNodeId === undefined) {
+                this.log.error('Missing parameter --node for --unpair');
+                return;
+            }
+            const nodeLabel = `Node ${requestedNodeId}`;
+            const peerId = `peer${requestedNodeId}`;
+            this.log.info(`Matter commissioning controller decommissioning node: ${nodeLabel}`);
+            const peers = this.controllerNode.peers;
+            for (const peer of peers) {
+                if (peer.id === peerId) {
+                    await peer.decommission();
+                    this.log.info(`Matter commissioning controller decommissioned node: ${nodeLabel}`);
+                    return;
+                }
             }
-            this.log.info('Commissioning with options:', options);
-            const nodeId = this.controllerNode.peers.commission(options);
-            this.log.info(`Commissioning successfully done with nodeId: ${nodeId}`);
+            this.log.warn(`Matter commissioning controller node not found: ${nodeLabel}`);
         }
-        if (hasParameter('unpairall')) {
+        else if (hasParameter('unpairall')) {
+            await this.controllerNode.start();
             this.log.info('Matter commissioning controller decommissioning all nodes...');
             const nodeIds = this.controllerNode.peers;
             for (const nodeId of nodeIds) {
@@ -1559,7 +1615,120 @@ export class Matterbridge extends EventEmitter {
                 await nodeId.decommission();
             }
             this.log.info('Matter commissioning controller decommissioned all nodes');
-            return;
+        }
+        else {
+            this.log.info('Starting matter commissioning controller...');
+            await this.controllerNode.start();
+            this.log.info(`Matter commissioning controller started with ${this.controllerNode.peers.size} paired nodes`);
+            const tracerSubscriptions = new Map();
+            const peersToStart = [];
+            if (peerId) {
+                const peer = this.controllerNode.peers.get(peerId);
+                if (!peer) {
+                    this.log.warn(`Matter commissioning controller peer not found: ${nodeLabel ?? peerId}`);
+                }
+                else {
+                    peersToStart.push(peer);
+                }
+            }
+            else {
+                for (const peer of this.controllerNode.peers) {
+                    peersToStart.push(peer);
+                }
+            }
+            for (const peer of peersToStart) {
+                const match = /^peer(\d+)$/.exec(peer.id);
+                const startedLabel = match ? `Node ${match[1]}` : peer.id;
+                peer.lifecycle.online.on(() => {
+                    this.log.notice(`Matter commissioning controller peer ${startedLabel} is online`);
+                    if (peer.stateOf(NetworkClient).autoSubscribe) {
+                        this.log.info(`Matter commissioning controller autoSubscribe is enabled for peer ${startedLabel}`);
+                    }
+                    else {
+                        this.log.info(`Matter commissioning controller setting autoSubscribe for peer ${startedLabel}`);
+                        peer.setStateOf(NetworkClient, { autoSubscribe: true }).catch((error) => {
+                            this.log.error(`Failed to set autoSubscribe for peer ${startedLabel}: ${error instanceof Error ? error.message : error}`);
+                        });
+                    }
+                    if (hasParameter('trace-peer') && !tracerSubscriptions.has(peer.id)) {
+                        this.log.info(`Matter commissioning controller enabling trace-peer for ${startedLabel}`);
+                        const subscribe = Subscribe({
+                            fabricFilter: true,
+                            keepSubscriptions: false,
+                            attributes: [{}],
+                            events: [{ isUrgent: true }],
+                        });
+                        const subscriptionPromise = peer.interaction.subscribe({
+                            ...subscribe,
+                            updated: async (update) => {
+                                for await (const chunk of update) {
+                                    for (const report of chunk) {
+                                        if (report.kind === 'attr-value') {
+                                            this.log.info(`Peer ${startedLabel} attr ${report.path.endpointId}/${report.path.clusterId}/${report.path.attributeId} v${report.version}: ${typeof report.value === 'object' ? debugStringify(report.value ?? { none: true }) : String(report.value)}`);
+                                        }
+                                        else if (report.kind === 'event-value') {
+                                            this.log.info(`Peer ${startedLabel} event ${report.path.endpointId}/${report.path.clusterId}/${report.path.eventId} #${report.number}: ${typeof report.value === 'object' ? debugStringify(report.value ?? { none: true }) : String(report.value)}`);
+                                        }
+                                        else if (report.kind === 'attr-status') {
+                                            this.log.warn(`Peer ${startedLabel} attr-status ${report.path.endpointId}/${report.path.clusterId}/${report.path.attributeId}: ${String(report.status)}`);
+                                        }
+                                        else if (report.kind === 'event-status') {
+                                            this.log.warn(`Peer ${startedLabel} event-status ${report.path.endpointId}/${report.path.clusterId}/${report.path.eventId}: ${String(report.status)}`);
+                                        }
+                                    }
+                                }
+                            },
+                            closed: () => {
+                                this.log.warn(`Matter commissioning controller trace-peer subscription closed for ${startedLabel}`);
+                                tracerSubscriptions.delete(peer.id);
+                            },
+                        });
+                        tracerSubscriptions.set(peer.id, subscriptionPromise);
+                        subscriptionPromise.catch((error) => {
+                            tracerSubscriptions.delete(peer.id);
+                            this.log.error(`Matter commissioning controller trace-peer subscription failed for ${startedLabel}: ${error instanceof Error ? error.message : error}`);
+                        });
+                    }
+                    if (hasParameter('dump-peer')) {
+                        void (async () => {
+                            try {
+                                for await (const _chunk of peer.interaction.read(Read({ fabricFilter: true, attributes: [{}] }))) {
+                                }
+                                const basicInfo = peer.stateOf(BasicInformationClient);
+                                Logger.get(`BasicInformation: ${startedLabel}`).info(basicInfo);
+                            }
+                            catch (error) {
+                                this.log.error(`Matter commissioning controller dump-peer failed for ${startedLabel}: ${error instanceof Error ? error.message : error}`);
+                            }
+                        })();
+                    }
+                });
+                peer.lifecycle.offline.on(() => {
+                    this.log.warn(`Matter commissioning controller peer ${startedLabel} is offline`);
+                });
+                peer.eventsOf(NetworkClient).autoSubscribe$Changed.on((value, oldValue) => {
+                    this.log.info(`Matter commissioning controller peer ${startedLabel} autoSubscribe changed from ${oldValue ? 'active' : 'inactive'} to ${value ? 'active' : 'inactive'}`);
+                });
+                peer.eventsOf(NetworkClient).defaultSubscription$Changed.on((value, oldValue) => {
+                    this.log.info(`Matter commissioning controller peer ${startedLabel} defaultSubscription changed from ${oldValue ? 'active' : 'inactive'} to ${value ? 'active' : 'inactive'}`);
+                });
+                peer.eventsOf(NetworkClient).subscriptionStatusChanged.on((isActive) => {
+                    this.log.info(`Matter commissioning controller peer ${startedLabel} subscription is ${isActive ? 'active' : 'inactive'}`);
+                });
+                peer.eventsOf(NetworkClient).subscriptionAlive.on(() => {
+                    this.log.info(`Matter commissioning controller peer ${startedLabel} subscription alive event received`);
+                });
+                this.log.notice(`Starting matter commissioning controller peer ${startedLabel}...`);
+                peer
+                    .start()
+                    .then(() => {
+                    this.log.notice(`Matter commissioning controller peer ${startedLabel} started successfully`);
+                    return;
+                })
+                    .catch((error) => {
+                    this.log.error(`Matter commissioning controller failed to start peer ${startedLabel}: ${error instanceof Error ? error.message : error}`);
+                });
+            }
         }
     }
     async startMatterStorage() {

package/dist/matterbridgeDeviceTypes.d.ts

@@ -93,3 +93,7 @@ export declare const waterHeater: DeviceTypeDefinition;
 export declare const solarPower: DeviceTypeDefinition;
 export declare const batteryStorage: DeviceTypeDefinition;
 export declare const heatPump: DeviceTypeDefinition;
+export declare const soilSensor: DeviceTypeDefinition;
+export declare const irrigationSystem: DeviceTypeDefinition;
+export declare const closure: DeviceTypeDefinition;
+export declare const closurePanel: DeviceTypeDefinition;

package/dist/matterbridgeDeviceTypes.js

@@ -86,6 +86,9 @@ import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-manag
 import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 import { DeviceTypeId } from '@matter/types/datatype';
+import { ClosureControl } from './clusters/closure-control.js';
+import { ClosureDimension } from './clusters/closure-dimension.js';
+import { SoilMeasurement } from './clusters/soil-measurement.js';
 export var DeviceClasses;
 (function (DeviceClasses) {
     DeviceClasses["Node"] = "Node";
@@ -643,3 +646,37 @@ export const heatPump = DeviceTypeDefinition({
     requiredServerClusters: [],
     optionalServerClusters: [Identify.Cluster.id, Thermostat.Cluster.id],
 });
+export const soilSensor = DeviceTypeDefinition({
+    name: 'MA-soilSensor',
+    code: 0x0045,
+    deviceClass: DeviceClasses.Simple,
+    revision: 1,
+    requiredServerClusters: [Identify.Cluster.id, SoilMeasurement.Cluster.id],
+    optionalServerClusters: [TemperatureMeasurement.Cluster.id],
+});
+export const irrigationSystem = DeviceTypeDefinition({
+    name: 'MA-irrigationSystem',
+    code: 0x0040,
+    deviceClass: DeviceClasses.Simple,
+    revision: 1,
+    requiredServerClusters: [],
+    optionalServerClusters: [Identify.Cluster.id, OperationalState.Cluster.id, FlowMeasurement.Cluster.id],
+    requiredClientClusters: [],
+    optionalClientClusters: [FlowMeasurement.Cluster.id],
+});
+export const closure = DeviceTypeDefinition({
+    name: 'MA-closure',
+    code: 0x0230,
+    deviceClass: DeviceClasses.Simple,
+    revision: 1,
+    requiredServerClusters: [Identify.Cluster.id, ClosureControl.Cluster.id],
+    optionalServerClusters: [],
+});
+export const closurePanel = DeviceTypeDefinition({
+    name: 'MA-closurePanel',
+    code: 0x0231,
+    deviceClass: DeviceClasses.Simple,
+    revision: 1,
+    requiredServerClusters: [ClosureDimension.Cluster.id],
+    optionalServerClusters: [],
+});

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -16,7 +16,7 @@ import { PressureMeasurement } from '@matter/types/clusters/pressure-measurement
 import { RelativeHumidityMeasurement } from '@matter/types/clusters/relative-humidity-measurement';
 import { TemperatureMeasurement } from '@matter/types/clusters/temperature-measurement';
 import { ClusterId } from '@matter/types/datatype';
-import { MeasurementType } from '@matter/types/globals';
+import { MeasurementType, Semtag } from '@matter/types/globals';
 import { AnsiLogger } from 'node-ansi-logger';
 import { MatterbridgeDeviceEnergyManagementModeServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer } from './matterbridgeBehaviors.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
@@ -26,6 +26,7 @@ export declare function lowercaseFirstLetter(name: string): string;
 export declare function checkNotLatinCharacters(deviceName: string): boolean;
 export declare function generateUniqueId(deviceName: string): string;
 export declare function createUniqueId(param1: string, param2: string, param3: string, param4: string): string;
+export declare function getSemtag(semtag: Semtag, label?: Semtag['label'], mfgCode?: Semtag['mfgCode']): Semtag;
 export declare function featuresFor(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Record<string, boolean | undefined>;
 export declare function getBehaviourTypesFromClusterServerIds(clusterServerList: ClusterId[]): Behavior.Type[];
 export declare function getBehaviourTypesFromClusterClientIds(clusterClientList: ClusterId[]): Behavior.Type[];

package/dist/matterbridgeEndpointHelpers.js

@@ -113,6 +113,11 @@ export function createUniqueId(param1, param2, param3, param4) {
     hash.update(param1 + param2 + param3 + param4);
     return hash.digest('hex');
 }
+export function getSemtag(semtag, label = null, mfgCode = null) {
+    if (label !== null && typeof label === 'string')
+        label = label.trim().slice(0, 64);
+    return { mfgCode, namespaceId: semtag.namespaceId, tag: semtag.tag, label };
+}
 export function featuresFor(endpoint, cluster) {
     const behaviorId = getBehavior(endpoint, cluster)?.id;
     if (!behaviorId) {

package/dist/matterbridgeEndpointTypes.d.ts

@@ -40,6 +40,8 @@ export interface MatterbridgeEndpointCommands {
     stopMotion: HandlerFunction;
     goToLiftPercentage: HandlerFunction;
     goToTiltPercentage: HandlerFunction;
+    moveTo: HandlerFunction;
+    setTarget: HandlerFunction;
     lockDoor: HandlerFunction;
     unlockDoor: HandlerFunction;
     setpointRaiseLower: HandlerFunction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.6.0-dev-20260302-e3a7eb0",
+  "version": "3.6.0-dev-20260303-2f99eca",
   "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.6.0-dev-20260302-e3a7eb0",
-    "@matterbridge/thread": "3.6.0-dev-20260302-e3a7eb0",
-    "@matterbridge/types": "3.6.0-dev-20260302-e3a7eb0",
-    "@matterbridge/utils": "3.6.0-dev-20260302-e3a7eb0",
+    "@matterbridge/dgram": "3.6.0-dev-20260303-2f99eca",
+    "@matterbridge/thread": "3.6.0-dev-20260303-2f99eca",
+    "@matterbridge/types": "3.6.0-dev-20260303-2f99eca",
+    "@matterbridge/utils": "3.6.0-dev-20260303-2f99eca",
     "archiver": "7.0.1",
     "express": "5.2.1",
     "glob": "13.0.6",