@matterbridge/core 3.8.1-dev-20260606-d6bb335 → 3.8.1-dev-20260607-08cd4da

package/dist/devices/extractorHood.js

@@ -10,26 +10,26 @@ export class ExtractorHood extends MatterbridgeEndpoint {
         this.createBaseFanControlClusterServer();
         this.createDefaultHepaFilterMonitoringClusterServer(hepaCondition, hepaChangeIndication, hepaInPlaceIndicator, hepaLastChangedTime, hepaReplacementProductList);
         this.createDefaultActivatedCarbonFilterMonitoringClusterServer(activatedCarbonCondition, activatedCarbonChangeIndication, activatedCarbonInPlaceIndicator, activatedCarbonLastChangedTime, activatedCarbonReplacementProductList);
-        void this.subscribeAttribute('fanControl', 'fanMode', (newValue, oldValue, context) => {
+        this.subscribeAttribute('fanControl', 'fanMode', (newValue, oldValue, context) => {
             if (context.offline === true)
                 return;
             this.log.info(`Fan control fanMode attribute changed: ${newValue}`);
-        }).catch(() => { });
-        void this.subscribeAttribute('fanControl', 'percentSetting', (newValue, oldValue, context) => {
+        });
+        this.subscribeAttribute('fanControl', 'percentSetting', (newValue, oldValue, context) => {
             if (context.offline === true)
                 return;
             this.log.info(`Fan control percentSetting attribute changed: ${newValue}`);
             void this.setAttribute('fanControl', 'percentCurrent', newValue, this.log).catch(() => { });
-        }).catch(() => { });
-        void this.subscribeAttribute('hepaFilterMonitoring', 'lastChangedTime', (newValue, oldValue, context) => {
+        });
+        this.subscribeAttribute('hepaFilterMonitoring', 'lastChangedTime', (newValue, oldValue, context) => {
             if (context.offline === true)
                 return;
             this.log.info(`Hepa filter monitoring lastChangedTime attribute changed: ${newValue}`);
-        }).catch(() => { });
-        void this.subscribeAttribute('activatedCarbonFilterMonitoring', 'lastChangedTime', (newValue, oldValue, context) => {
+        });
+        this.subscribeAttribute('activatedCarbonFilterMonitoring', 'lastChangedTime', (newValue, oldValue, context) => {
             if (context.offline === true)
                 return;
             this.log.info(`Activated carbon filter monitoring lastChangedTime attribute changed: ${newValue}`);
-        }).catch(() => { });
+        });
     }
 }

package/dist/jestutils/jestMatterbridgeEndpointSpy.d.ts

@@ -1,8 +1,9 @@
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare const setClusterMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
     <T extends import("@matter/node").Behavior.Type>(cluster: T, value: import("@matter/node").Behavior.StateOf<T>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType>(cluster: T, value: T["Typing"] extends {
+    <T extends import("@matter/types").ClusterType>(cluster: T, value: Partial<T["Typing"] extends {
         Attributes: infer Attributes;
-    } ? Attributes : {}, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
+    } ? Attributes : {}>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
     (cluster: import("@matter/types").ClusterId | string, value: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
 }>;
 export declare const setAttributeMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
@@ -24,15 +25,15 @@ export declare const updateAttributeMatterbridgeEndpointSpy: import("jest-mock")
     (cluster: import("@matter/types").ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
 }>;
 export declare const subscribeAttributeMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(cluster: T, attribute: A, listener: (newValue: import("@matter/node").Behavior.StateOf<T>[A], oldValue: import("@matter/node").Behavior.StateOf<T>[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
+    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(cluster: T, attribute: A, listener: (newValue: import("@matter/node").Behavior.StateOf<T>[A], oldValue: import("@matter/node").Behavior.StateOf<T>[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): MatterbridgeEndpoint;
     <T extends import("@matter/types").ClusterType, A extends keyof (T["Typing"] extends {
         Attributes: infer Attributes;
     } ? Attributes : {})>(cluster: T, attribute: A, listener: (newValue: (T["Typing"] extends {
         Attributes: infer Attributes;
     } ? Attributes : {})[A], oldValue: (T["Typing"] extends {
         Attributes: infer Attributes;
-    } ? Attributes : {})[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    (cluster: import("@matter/types").ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
+    } ? Attributes : {})[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): MatterbridgeEndpoint;
+    (cluster: import("@matter/types").ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): MatterbridgeEndpoint;
 }>;
 export declare const triggerEventMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
     <T extends import("@matter/node").Behavior.Type, E extends keyof ((T extends {

package/dist/matterNode.js

@@ -13,7 +13,7 @@ import { BroadcastServer } from '@matterbridge/thread/server';
 import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg } from '@matterbridge/types';
 import { getIntParameter, getParameter, hasParameter } from '@matterbridge/utils/cli';
 import { copyDirectory } from '@matterbridge/utils/copy-dir';
-import { inspectError } from '@matterbridge/utils/error';
+import { getErrorMessage, inspectError } from '@matterbridge/utils/error';
 import { isValidNumber, isValidString, parseVersionString } from '@matterbridge/utils/validate';
 import { wait, withTimeout } from '@matterbridge/utils/wait';
 import { AnsiLogger, BLUE, CYAN, db, debugStringify, er, nf, or, zb } from 'node-ansi-logger';
@@ -22,7 +22,6 @@ import { toBaseDevice } from './deviceManager.js';
 import { addVirtualDevice } from './helpers.js';
 import { bridge } from './matterbridgeDeviceTypes.js';
 import { PluginManager } from './pluginManager.js';
-import { getErrorMessage } from './utils/export.js';
 export class MatterNode extends EventEmitter {
     matterbridge;
     pluginName;
@@ -852,7 +851,7 @@ export class MatterNode extends EventEmitter {
         for (const sub of subscriptions) {
             if (device.hasAttributeServer(sub.cluster, sub.attribute)) {
                 this.log.debug(`Subscribing to endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
-                await device.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
+                device.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
                     if (!device.plugin || !device.serialNumber || !device.uniqueId)
                         return;
                     this.log.debug(`Bridged endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${value}${db}`);
@@ -876,7 +875,7 @@ export class MatterNode extends EventEmitter {
             for (const child of device.getChildEndpoints()) {
                 if (child.hasAttributeServer(sub.cluster, sub.attribute)) {
                     this.log.debug(`Subscribing to child endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
-                    await child.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
+                    child.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
                         if (!device.plugin || !device.serialNumber || !device.uniqueId)
                             return;
                         this.log.debug(`Bridged child endpoint ${plg}${plugin.name}${db}:${dev}${device.deviceName}${db}:${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${value}${db}`);

package/dist/matterbridge.js

@@ -2105,7 +2105,7 @@ export class Matterbridge extends EventEmitter {
         for (const sub of subscriptions) {
             if (device.hasAttributeServer(sub.cluster, sub.attribute)) {
                 this.log.debug(`Subscribing to endpoint ${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
-                await device.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
+                device.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
                     this.log.debug(`Bridged endpoint ${or}${device.id}${db}:${or}${device.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${isValidObject(value) ? debugStringify(value) : value}${db}`);
                     this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, device.number, device.id, sub.cluster, sub.attribute, value);
                 });
@@ -2113,7 +2113,7 @@ export class Matterbridge extends EventEmitter {
             for (const child of device.getChildEndpoints()) {
                 if (child.hasAttributeServer(sub.cluster, sub.attribute)) {
                     this.log.debug(`Subscribing to child endpoint ${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changes...`);
-                    await child.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
+                    child.subscribeAttribute(sub.cluster, sub.attribute, (value) => {
                         this.log.debug(`Bridged child endpoint ${or}${child.id}${db}:${or}${child.number}${db} attribute ${dev}${sub.cluster}${db}.${dev}${sub.attribute}${db} changed to ${CYAN}${isValidObject(value) ? debugStringify(value) : value}${db}`);
                         this.frontend.wssSendAttributeChangedMessage(device.plugin, device.serialNumber, device.uniqueId, child.number, child.id, sub.cluster, sub.attribute, value);
                     });

package/dist/matterbridgeEndpoint.d.ts

@@ -96,11 +96,11 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     updateAttribute<T extends Behavior.Type, A extends keyof Behavior.StateOf<T>>(cluster: T, attribute: A, value: Behavior.StateOf<T>[A], log?: AnsiLogger): Promise<boolean>;
     updateAttribute<T extends ClusterType, A extends keyof ClusterAttributesOf<T>>(cluster: T, attribute: A, value: ClusterAttributesOf<T>[A], log?: AnsiLogger): Promise<boolean>;
     updateAttribute(cluster: ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
-    subscribeAttribute<T extends Behavior.Type, A extends keyof Behavior.StateOf<T>>(cluster: T, attribute: A, listener: (newValue: Behavior.StateOf<T>[A], oldValue: Behavior.StateOf<T>[A], context: ActionContext) => void, log?: AnsiLogger): Promise<boolean>;
-    subscribeAttribute<T extends ClusterType, A extends keyof ClusterAttributesOf<T>>(cluster: T, attribute: A, listener: (newValue: ClusterAttributesOf<T>[A], oldValue: ClusterAttributesOf<T>[A], context: ActionContext) => void, log?: AnsiLogger): Promise<boolean>;
-    subscribeAttribute(cluster: ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): Promise<boolean>;
+    subscribeAttribute<T extends Behavior.Type, A extends keyof Behavior.StateOf<T>>(cluster: T, attribute: A, listener: (newValue: Behavior.StateOf<T>[A], oldValue: Behavior.StateOf<T>[A], context: ActionContext) => void, log?: AnsiLogger): MatterbridgeEndpoint;
+    subscribeAttribute<T extends ClusterType, A extends keyof ClusterAttributesOf<T>>(cluster: T, attribute: A, listener: (newValue: ClusterAttributesOf<T>[A], oldValue: ClusterAttributesOf<T>[A], context: ActionContext) => void, log?: AnsiLogger): MatterbridgeEndpoint;
+    subscribeAttribute(cluster: ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): MatterbridgeEndpoint;
     setCluster<T extends Behavior.Type>(cluster: T, value: Behavior.StateOf<T>, log?: AnsiLogger): Promise<boolean>;
-    setCluster<T extends ClusterType>(cluster: T, value: ClusterAttributesOf<T>, log?: AnsiLogger): Promise<boolean>;
+    setCluster<T extends ClusterType>(cluster: T, value: Partial<ClusterAttributesOf<T>>, log?: AnsiLogger): Promise<boolean>;
     setCluster(cluster: ClusterId | string, value: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;
     getCluster<T extends Behavior.Type>(cluster: T, log?: AnsiLogger): Behavior.StateOf<T> | undefined;
     getCluster<T extends ClusterType>(cluster: T, log?: AnsiLogger): ClusterAttributesOf<T> | undefined;

package/dist/matterbridgeEndpoint.js

@@ -240,8 +240,8 @@ export class MatterbridgeEndpoint extends Endpoint {
     async updateAttribute(cluster, attribute, value, log) {
         return await updateAttribute(this, cluster, attribute, value, log);
     }
-    async subscribeAttribute(cluster, attribute, listener, log) {
-        return await subscribeAttribute(this, cluster, attribute, listener, log);
+    subscribeAttribute(cluster, attribute, listener, log) {
+        return subscribeAttribute(this, cluster, attribute, listener, log);
     }
     async setCluster(cluster, value, log) {
         return await setCluster(this, cluster, value, log);

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -56,7 +56,7 @@ export declare function getAttributeId(endpoint: Endpoint, cluster: string, attr
 export declare function getAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, log?: AnsiLogger): any;
 export declare function setAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
 export declare function updateAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
-export declare function subscribeAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): Promise<boolean>;
+export declare function subscribeAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): MatterbridgeEndpoint;
 export declare function setCluster(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, value: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;
 export declare function getCluster(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, log?: AnsiLogger): Record<string, boolean | number | bigint | string | object | undefined | null> | undefined;
 export declare function triggerEvent(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, event: string, payload: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;

package/dist/matterbridgeEndpointHelpers.js

@@ -719,25 +719,21 @@ export async function updateAttribute(endpoint, cluster, attribute, value, log)
         `to ${YELLOW}${value !== null && typeof value === 'object' ? debugStringify(value) : value}${db}`);
     return true;
 }
-export async function subscribeAttribute(endpoint, cluster, attribute, listener, log) {
+export function subscribeAttribute(endpoint, cluster, attribute, listener, log) {
     const clusterName = getBehavior(endpoint, cluster)?.id;
     if (!clusterName) {
         endpoint.log.error(`subscribeAttribute ${hk}${attribute}${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.debug(`subscribeAttribute ${hk}${clusterName}.${attribute}${db}: Endpoint ${or}${endpoint.maybeId}${db}:${or}${endpoint.maybeNumber}${db} is in the ${BLUE}${endpoint.construction.status}${db} state`);
-        await endpoint.construction.ready;
+        return endpoint;
     }
     const events = endpoint.events;
     attribute = lowercaseFirstLetter(attribute) + '$Changed';
     if (!(clusterName in events) || !(attribute in events[clusterName])) {
         endpoint.log.error(`subscribeAttribute error: Attribute ${hk}${attribute.replace('$Changed', '')}${er} not found on Cluster ${'0x' + getClusterId(endpoint, clusterName)?.toString(16).padStart(4, '0')}:${clusterName} on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
-        return false;
+        return endpoint;
     }
     events[clusterName][attribute].on(listener);
-    log?.info(`${db}Subscribed endpoint ${or}${endpoint.id}${db}:${or}${endpoint.number}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db}`);
-    return true;
+    log?.info(`${db}Subscribed endpoint ${or}${endpoint.maybeId}${db}:${or}${endpoint.maybeNumber}${db} attribute ${hk}${capitalizeFirstLetter(clusterName)}${db}.${hk}${attribute}${db}`);
+    return endpoint;
 }
 export async function setCluster(endpoint, cluster, value, log) {
     const clusterName = getBehavior(endpoint, cluster)?.id;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.8.1-dev-20260606-d6bb335",
+  "version": "3.8.1-dev-20260607-08cd4da",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -130,10 +130,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.17.1",
-    "@matterbridge/dgram": "3.8.1-dev-20260606-d6bb335",
-    "@matterbridge/thread": "3.8.1-dev-20260606-d6bb335",
-    "@matterbridge/types": "3.8.1-dev-20260606-d6bb335",
-    "@matterbridge/utils": "3.8.1-dev-20260606-d6bb335",
+    "@matterbridge/dgram": "3.8.1-dev-20260607-08cd4da",
+    "@matterbridge/thread": "3.8.1-dev-20260607-08cd4da",
+    "@matterbridge/types": "3.8.1-dev-20260607-08cd4da",
+    "@matterbridge/utils": "3.8.1-dev-20260607-08cd4da",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.5.2",