@matterbridge/core 3.6.2-dev-20260315-d23fd18 → 3.6.2-dev-20260316-21bfabd

package/dist/devices/temperatureControl.js

@@ -19,10 +19,8 @@ export function createNumberTemperatureControlClusterServer(endpoint, temperatur
 }
 export class MatterbridgeLevelTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel) {
     initialize() {
-        if (this.state.supportedTemperatureLevels.length >= 2) {
-            const device = this.endpoint.stateOf(MatterbridgeServer);
-            device.log.info(`MatterbridgeLevelTemperatureControlServer initialized with selectedTemperatureLevel ${this.state.selectedTemperatureLevel} and supportedTemperatureLevels: ${this.state.supportedTemperatureLevels.join(', ')}`);
-        }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MatterbridgeLevelTemperatureControlServer initialized with selectedTemperatureLevel ${this.state.selectedTemperatureLevel} and supportedTemperatureLevels: ${this.state.supportedTemperatureLevels.join(', ')}`);
     }
     setTemperature(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);

package/dist/frontend.d.ts

@@ -22,6 +22,7 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     private httpsServer;
     private webSocketServer;
     private readonly server;
+    private serverFetchTimeout;
     private readonly debug;
     private readonly verbose;
     constructor(matterbridge: Matterbridge);
@@ -56,6 +57,7 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     wssSendCloseSnackbarMessage(message: string): void;
     wssSendAttributeChangedMessage(plugin: string, serialNumber: string, uniqueId: string, number: EndpointNumber, id: string, cluster: string, attribute: string, value: number | string | boolean | null): void;
     wssBroadcastMessage(msg: WsMessageBroadcast): void;
+    spawn(command: 'install' | 'uninstall', packageName: string): void;
     zip(command: 'zip' | 'verify' | 'unzip', archivePath: string, sourcePaths: string[], destinationPath: string): void;
 }
 export {};

package/dist/frontend.js

@@ -32,6 +32,7 @@ export class Frontend extends EventEmitter {
     httpsServer;
     webSocketServer;
     server;
+    serverFetchTimeout = 2000;
     debug = hasParameter('debug') || hasParameter('verbose');
     verbose = hasParameter('verbose');
     constructor(matterbridge) {
@@ -1122,12 +1123,14 @@ export class Frontend extends EventEmitter {
         }
         return devices;
     }
-    getClusters(pluginName, endpointNumber) {
+    getClusters(pluginName, endpointNumber, serialNumber, uniqueId) {
         if (this.matterbridge.hasCleanupStarted)
             return;
-        const endpoint = this.matterbridge.devices.array().find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber);
+        const endpoint = this.matterbridge.devices
+            .array()
+            .find((d) => d.plugin === pluginName && d.maybeNumber === endpointNumber && (!serialNumber || d.serialNumber === serialNumber) && (!uniqueId || d.uniqueId === uniqueId));
         if (!endpoint || !endpoint.plugin || !endpoint.maybeNumber || !endpoint.maybeId || !endpoint.deviceName || !endpoint.serialNumber) {
-            this.log.error(`getClusters: no device found for plugin ${pluginName} and endpoint number ${endpointNumber}`);
+            this.log.error(`getClusters: no device found for plugin ${pluginName} and endpoint number ${endpointNumber} (serial: ${serialNumber ?? 'N/A'}, uniqueId: ${uniqueId ?? 'N/A'})`);
             return;
         }
         const deviceTypes = [];
@@ -1275,21 +1278,7 @@ export class Frontend extends EventEmitter {
             else if (data.method === '/api/install') {
                 if (isValidString(data.params.packageName, 12) && isValidBoolean(data.params.restart)) {
                     this.wssSendSnackbarMessage(`Installing package ${data.params.packageName}...`, 0);
-                    this.server.request({
-                        type: 'manager_run',
-                        src: 'frontend',
-                        dst: 'manager',
-                        params: {
-                            name: 'SpawnCommand',
-                            workerData: {
-                                threadName: 'SpawnCommand',
-                                command: 'npm',
-                                args: ['install', '-g', data.params.packageName, '--omit=dev', '--verbose'],
-                                packageCommand: 'install',
-                                packageName: data.params.packageName,
-                            },
-                        },
-                    });
+                    this.spawn('install', data.params.packageName);
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                 }
                 else {
@@ -1299,21 +1288,7 @@ export class Frontend extends EventEmitter {
             else if (data.method === '/api/uninstall') {
                 if (isValidString(data.params.packageName, 12)) {
                     this.wssSendSnackbarMessage(`Uninstalling package ${data.params.packageName}...`, 0);
-                    this.server.request({
-                        type: 'manager_run',
-                        src: 'frontend',
-                        dst: 'manager',
-                        params: {
-                            name: 'SpawnCommand',
-                            workerData: {
-                                threadName: 'SpawnCommand',
-                                command: 'npm',
-                                args: ['uninstall', '-g', data.params.packageName, '--omit=dev', '--verbose'],
-                                packageCommand: 'uninstall',
-                                packageName: data.params.packageName,
-                            },
-                        },
-                    });
+                    this.spawn('uninstall', data.params.packageName);
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                 }
                 else {
@@ -1327,26 +1302,24 @@ export class Frontend extends EventEmitter {
                     this.wssSendSnackbarMessage(`Plugin ${data.params.pluginNameOrPath} not added`, 10, 'error');
                     return;
                 }
-                this.wssSendSnackbarMessage(`Adding plugin ${data.params.pluginNameOrPath}...`, 5);
+                this.wssSendSnackbarMessage(`Adding plugin ${data.params.pluginNameOrPath}...`, 0);
                 this.log.debug(`Adding plugin ${data.params.pluginNameOrPath}...`);
                 data.params.pluginNameOrPath = data.params.pluginNameOrPath.replace(/@.*$/, '');
-                const plugin = await this.matterbridge.plugins.add(data.params.pluginNameOrPath);
+                const plugin = (await this.server.fetch({ type: 'plugins_add', src: this.server.name, dst: 'plugins', params: { nameOrPath: data.params.pluginNameOrPath } }, this.serverFetchTimeout)).result.plugin;
                 if (plugin) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                    this.wssSendCloseSnackbarMessage(`Adding plugin ${data.params.pluginNameOrPath}...`);
                     this.wssSendSnackbarMessage(`Added plugin ${data.params.pluginNameOrPath}`, 5, 'success');
-                    this.matterbridge.plugins
-                        .load(plugin)
-                        .then(() => {
-                        this.wssSendRefreshRequired('plugins');
-                        this.wssSendRefreshRequired('devices');
-                        this.wssSendSnackbarMessage(`Loaded plugin ${localData.params.pluginNameOrPath}`, 5, 'success');
-                        return;
-                    })
-                        .catch((_error) => { });
+                    await this.server.fetch({ type: 'plugins_load', src: this.server.name, dst: 'plugins', params: { plugin: plugin.name } }, this.serverFetchTimeout);
+                    this.wssSendRestartRequired();
+                    this.wssSendRefreshRequired('plugins');
+                    this.wssSendRefreshRequired('devices');
+                    this.wssSendSnackbarMessage(`Loaded plugin ${localData.params.pluginNameOrPath}`, 5, 'success');
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                 }
                 else {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Plugin ${data.params.pluginNameOrPath} not added` });
+                    this.wssSendCloseSnackbarMessage(`Adding plugin ${data.params.pluginNameOrPath}...`);
                     this.wssSendSnackbarMessage(`Plugin ${data.params.pluginNameOrPath} not added`, 10, 'error');
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Plugin ${data.params.pluginNameOrPath} not added` });
                 }
             }
             else if (data.method === '/api/removeplugin') {
@@ -1354,11 +1327,17 @@ export class Frontend extends EventEmitter {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/removeplugin' });
                     return;
                 }
-                this.wssSendSnackbarMessage(`Removing plugin ${data.params.pluginName}...`, 5);
+                this.wssSendSnackbarMessage(`Removing plugin ${data.params.pluginName}...`, 0);
                 this.log.debug(`Removing plugin ${data.params.pluginName}...`);
-                const plugin = this.matterbridge.plugins.get(data.params.pluginName);
-                await this.matterbridge.plugins.shutdown(plugin, 'The plugin has been removed.', true);
-                await this.matterbridge.plugins.remove(data.params.pluginName);
+                const devices = (await this.server.fetch({ type: 'devices_basearray', src: this.server.name, dst: 'devices', params: { pluginName: data.params.pluginName } }, this.serverFetchTimeout)).result.devices;
+                for (const device of devices.filter((d) => d.mode === 'server')) {
+                    if (device.uniqueId)
+                        await this.server.fetch({ type: 'matterbridge_stop_device_server', src: this.server.name, dst: 'matterbridge', params: { deviceUniqueId: device.uniqueId } }, this.serverFetchTimeout);
+                }
+                await this.server.fetch({ type: 'plugins_shutdown', src: this.server.name, dst: 'plugins', params: { plugin: data.params.pluginName, reason: 'The plugin has been removed.', removeAllDevices: true, force: true } }, this.serverFetchTimeout);
+                await this.server.fetch({ type: 'matterbridge_stop_plugin_server', src: this.server.name, dst: 'matterbridge', params: { pluginName: data.params.pluginName } }, this.serverFetchTimeout);
+                await this.server.fetch({ type: 'plugins_remove', src: this.server.name, dst: 'plugins', params: { nameOrPath: data.params.pluginName } }, this.serverFetchTimeout);
+                this.wssSendCloseSnackbarMessage(`Removing plugin ${data.params.pluginName}...`);
                 this.wssSendSnackbarMessage(`Removed plugin ${data.params.pluginName}`, 5, 'success');
                 this.wssSendRefreshRequired('plugins');
                 this.wssSendRefreshRequired('devices');
@@ -1370,44 +1349,35 @@ export class Frontend extends EventEmitter {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/enableplugin' });
                     return;
                 }
-                const plugin = this.matterbridge.plugins.get(data.params.pluginName);
-                plugin.locked = undefined;
-                plugin.error = undefined;
-                plugin.loaded = undefined;
-                plugin.started = undefined;
-                plugin.configured = undefined;
-                plugin.platform = undefined;
-                plugin.registeredDevices = undefined;
-                plugin.matter = undefined;
-                await this.matterbridge.plugins.enable(data.params.pluginName);
+                await this.server.fetch({ type: 'plugins_enable', src: this.server.name, dst: 'plugins', params: { nameOrPath: data.params.pluginName } }, this.serverFetchTimeout);
                 this.wssSendSnackbarMessage(`Enabled plugin ${data.params.pluginName}`, 5, 'success');
-                setImmediate(async () => {
-                    await this.matterbridge.plugins.load(plugin, true, 'The plugin has been enabled', true);
-                    if (plugin.serverNode)
-                        await this.matterbridge.startServerNode(plugin.serverNode);
-                    for (const device of this.matterbridge.devices.array().filter((d) => d.plugin === plugin.name && d.serverNode))
-                        await this.matterbridge.startServerNode(device.serverNode);
-                    this.wssSendSnackbarMessage(`Started plugin ${localData.params.pluginName}`, 5, 'success');
-                    this.wssSendRefreshRequired('plugins');
-                    this.wssSendRefreshRequired('devices');
-                    sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: localData.src, success: true });
-                });
+                await this.server.fetch({ type: 'plugins_load', src: this.server.name, dst: 'plugins', params: { plugin: data.params.pluginName } }, this.serverFetchTimeout * 10);
+                await this.server.fetch({ type: 'plugins_start', src: this.server.name, dst: 'plugins', params: { plugin: data.params.pluginName } }, this.serverFetchTimeout * 10);
+                await this.server.fetch({ type: 'plugins_configure', src: this.server.name, dst: 'plugins', params: { plugin: data.params.pluginName } }, this.serverFetchTimeout * 10);
+                await this.server.fetch({ type: 'matterbridge_start_plugin_server', src: this.server.name, dst: 'matterbridge', params: { pluginName: data.params.pluginName } }, this.serverFetchTimeout);
+                const devices = (await this.server.fetch({ type: 'devices_basearray', src: this.server.name, dst: 'devices', params: { pluginName: data.params.pluginName } }, this.serverFetchTimeout)).result.devices;
+                for (const device of devices.filter((d) => d.mode === 'server')) {
+                    if (device.uniqueId)
+                        await this.server.fetch({ type: 'matterbridge_start_device_server', src: this.server.name, dst: 'matterbridge', params: { deviceUniqueId: device.uniqueId } }, this.serverFetchTimeout);
+                }
+                this.wssSendSnackbarMessage(`Started plugin ${localData.params.pluginName}`, 5, 'success');
+                this.wssSendRefreshRequired('plugins');
+                this.wssSendRefreshRequired('devices');
+                sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: localData.src, success: true });
             }
             else if (data.method === '/api/disableplugin') {
                 if (!isValidString(data.params.pluginName, 10) || !this.matterbridge.plugins.has(data.params.pluginName)) {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter pluginName in /api/disableplugin' });
                     return;
                 }
-                const plugin = this.matterbridge.plugins.get(data.params.pluginName);
-                for (const device of this.matterbridge.devices.array().filter((d) => d.plugin === plugin.name && d.serverNode)) {
-                    await this.matterbridge.stopServerNode(device.serverNode);
-                    device.serverNode = undefined;
+                const devices = (await this.server.fetch({ type: 'devices_basearray', src: this.server.name, dst: 'devices', params: { pluginName: data.params.pluginName } }, this.serverFetchTimeout)).result.devices;
+                for (const device of devices.filter((d) => d.mode === 'server')) {
+                    if (device.uniqueId)
+                        await this.server.fetch({ type: 'matterbridge_stop_device_server', src: this.server.name, dst: 'matterbridge', params: { deviceUniqueId: device.uniqueId } }, this.serverFetchTimeout);
                 }
-                await this.matterbridge.plugins.shutdown(plugin, 'The plugin has been disabled.', true);
-                await this.matterbridge.plugins.disable(data.params.pluginName);
-                if (plugin.serverNode)
-                    await this.matterbridge.stopServerNode(plugin.serverNode);
-                plugin.serverNode = undefined;
+                await this.server.fetch({ type: 'plugins_shutdown', src: this.server.name, dst: 'plugins', params: { plugin: data.params.pluginName, reason: 'The plugin has been disabled.', removeAllDevices: true, force: true } }, this.serverFetchTimeout * 10);
+                await this.server.fetch({ type: 'matterbridge_stop_plugin_server', src: this.server.name, dst: 'matterbridge', params: { pluginName: data.params.pluginName } }, this.serverFetchTimeout);
+                await this.server.fetch({ type: 'plugins_disable', src: this.server.name, dst: 'plugins', params: { nameOrPath: data.params.pluginName } }, this.serverFetchTimeout);
                 this.wssSendSnackbarMessage(`Disabled plugin ${data.params.pluginName}`, 5, 'success');
                 this.wssSendRefreshRequired('plugins');
                 this.wssSendRefreshRequired('devices');
@@ -1525,7 +1495,7 @@ export class Frontend extends EventEmitter {
             else if (data.method === '/api/create-config-backup') {
                 this.wssSendSnackbarMessage('Creating config backup...', 0);
                 this.log.notice(`Creating config backup...`);
-                const plugins = (await this.server.fetch({ type: 'plugins_storagepluginarray', src: this.server.name, dst: 'plugins' }, 5000)).result.plugins || [];
+                const plugins = (await this.server.fetch({ type: 'plugins_storagepluginarray', src: this.server.name, dst: 'plugins' }, this.serverFetchTimeout)).result.plugins || [];
                 const pluginsPaths = plugins.map((p) => path.join(this.matterbridge.matterbridgeDirectory, p.name + '.config.json'));
                 this.zip('zip', path.join(os.tmpdir(), `matterbridge.pluginconfig.zip`), pluginsPaths, '');
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
@@ -1624,7 +1594,7 @@ export class Frontend extends EventEmitter {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' });
                     return;
                 }
-                const response = this.getClusters(data.params.plugin, data.params.endpoint);
+                const response = this.getClusters(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
                 if (response) {
                     sendResponse({
                         id: data.id,
@@ -2152,6 +2122,23 @@ export class Frontend extends EventEmitter {
             }
         });
     }
+    spawn(command, packageName) {
+        this.server.request({
+            type: 'manager_run',
+            src: 'frontend',
+            dst: 'manager',
+            params: {
+                name: 'SpawnCommand',
+                workerData: {
+                    threadName: 'SpawnCommand',
+                    command: 'npm',
+                    args: [command, '-g', packageName, '--omit=dev', '--verbose'],
+                    packageCommand: command,
+                    packageName: packageName,
+                },
+            },
+        });
+    }
     zip(command, archivePath, sourcePaths, destinationPath) {
         this.server.request({
             type: 'manager_run',

package/dist/matterbridge.js

@@ -238,6 +238,42 @@ export class Matterbridge extends EventEmitter {
                 case 'matterbridge_shared':
                     this.server.respond({ ...msg, result: { data: this.getSharedMatterbridge(), success: true } });
                     break;
+                case 'matterbridge_start_plugin_server':
+                    {
+                        const plugin = this.plugins.get(msg.params.pluginName);
+                        if (plugin && plugin.serverNode)
+                            await this.startServerNode(plugin.serverNode);
+                        this.server.respond({ ...msg, result: { success: true } });
+                    }
+                    break;
+                case 'matterbridge_stop_plugin_server':
+                    {
+                        const plugin = this.plugins.get(msg.params.pluginName);
+                        if (plugin && plugin.serverNode)
+                            await this.stopServerNode(plugin.serverNode);
+                        if (plugin && plugin.serverNode)
+                            plugin.serverNode = undefined;
+                        this.server.respond({ ...msg, result: { success: true } });
+                    }
+                    break;
+                case 'matterbridge_start_device_server':
+                    {
+                        const device = this.devices.get(msg.params.deviceUniqueId);
+                        if (device && device.serverNode)
+                            await this.startServerNode(device.serverNode);
+                        this.server.respond({ ...msg, result: { success: true } });
+                    }
+                    break;
+                case 'matterbridge_stop_device_server':
+                    {
+                        const device = this.devices.get(msg.params.deviceUniqueId);
+                        if (device && device.serverNode)
+                            await this.stopServerNode(device.serverNode);
+                        if (device && device.serverNode)
+                            device.serverNode = undefined;
+                        this.server.respond({ ...msg, result: { success: true } });
+                    }
+                    break;
                 default:
                     if (this.verbose)
                         this.log.debug(`Unknown broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);

package/dist/matterbridgeEndpoint.d.ts

@@ -25,6 +25,13 @@ import { Semtag } from '@matter/types/globals';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
 import { DeviceTypeDefinition } from './matterbridgeDeviceTypes.js';
 import { CommandHandlerFunction, MatterbridgeEndpointCommands, MatterbridgeEndpointOptions, SerializedMatterbridgeEndpoint } from './matterbridgeEndpointTypes.js';
+type BehaviorCommandName<T extends Behavior.Type> = {
+    [K in keyof CommandsOfBehavior<T>]: K;
+}[keyof CommandsOfBehavior<T>] & string;
+type CommandsOfBehavior<T extends Behavior.Type> = {
+    [K in keyof InstanceType<T> as InstanceType<T>[K] extends (...args: infer _P) => infer _R ? K : never]: InstanceType<T>[K] extends (...args: infer P) => infer R ? (input: P[0], context?: ActionContext) => Promise<Awaited<R>> : never;
+};
+type BehaviorCommandParams<T extends Behavior.Type, C extends BehaviorCommandName<T>> = CommandsOfBehavior<T>[C] extends (input: infer P, context?: ActionContext) => Promise<unknown> ? P : never;
 export declare function isMatterbridgeEndpoint(value: unknown): value is MatterbridgeEndpoint;
 export declare function assertMatterbridgeEndpoint(value: unknown, context?: string): asserts value is MatterbridgeEndpoint;
 export declare class MatterbridgeEndpoint extends Endpoint {
@@ -74,11 +81,7 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     addUserLabel(label: string, value: string): Promise<this>;
     addCommandHandler(command: keyof MatterbridgeEndpointCommands, handler: CommandHandlerFunction): this;
     executeCommandHandler(command: keyof MatterbridgeEndpointCommands, request?: Record<string, boolean | number | bigint | string | object | null>, cluster?: string, attributes?: Record<string, boolean | number | bigint | string | object | null>, endpoint?: MatterbridgeEndpoint): Promise<void>;
-    invokeBehaviorCommand<T extends Behavior.Type, C extends keyof {
-        [K in keyof InstanceType<T> as InstanceType<T>[K] extends (...args: unknown[]) => unknown ? K : never]: InstanceType<T>[K];
-    }>(cluster: T, command: C, params?: {
-        [K in keyof InstanceType<T> as InstanceType<T>[K] extends (...args: unknown[]) => unknown ? K : never]: InstanceType<T>[K];
-    }[C] extends (...args: infer P) => unknown ? P[0] : never): Promise<void>;
+    invokeBehaviorCommand<T extends Behavior.Type, C extends BehaviorCommandName<T>>(cluster: T, command: C, params?: BehaviorCommandParams<T, C>): Promise<void>;
     invokeBehaviorCommand<T extends ClusterType, C extends keyof ClusterType.CommandsOf<T>>(cluster: T, command: C, params?: ClusterType.CommandsOf<T>[C] extends {
         requestSchema: infer S extends import('@matter/types/tlv').TlvSchema<unknown>;
     } ? import('@matter/types/tlv').TypeFromSchema<S> : never): Promise<void>;
@@ -191,3 +194,4 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     createDefaultRadonConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
     createDefaultNitrogenDioxideConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
 }
+export {};

package/dist/pluginManager.js

@@ -132,10 +132,10 @@ export class PluginManager extends EventEmitter {
                     {
                         const plugin = await this.remove(msg.params.nameOrPath);
                         if (plugin) {
-                            this.server.respond({ ...msg, result: { plugin: this.toApiPlugin(plugin) } });
+                            this.server.respond({ ...msg, result: { success: true } });
                         }
                         else {
-                            this.server.respond({ ...msg, result: { plugin } });
+                            this.server.respond({ ...msg, result: { success: false } });
                         }
                     }
                     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.6.2-dev-20260315-d23fd18",
+  "version": "3.6.2-dev-20260316-21bfabd",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -112,7 +112,7 @@
     }
   },
   "engines": {
-    "node": ">=20.0.0 <21.0.0 || >=22.0.0 <23.0.0 || >=24.0.0 <25.0.0"
+    "node": ">=20.19.0 <21.0.0 || >=22.13.0 <23.0.0 || >=24.0.0 <25.0.0"
   },
   "files": [
     "bin",
@@ -122,10 +122,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.10",
-    "@matterbridge/dgram": "3.6.2-dev-20260315-d23fd18",
-    "@matterbridge/thread": "3.6.2-dev-20260315-d23fd18",
-    "@matterbridge/types": "3.6.2-dev-20260315-d23fd18",
-    "@matterbridge/utils": "3.6.2-dev-20260315-d23fd18",
+    "@matterbridge/dgram": "3.6.2-dev-20260316-21bfabd",
+    "@matterbridge/thread": "3.6.2-dev-20260316-21bfabd",
+    "@matterbridge/types": "3.6.2-dev-20260316-21bfabd",
+    "@matterbridge/utils": "3.6.2-dev-20260316-21bfabd",
     "express": "5.2.1",
     "multer": "2.1.1",
     "node-ansi-logger": "3.2.0",