@matterbridge/core 3.6.2-dev-20260315-d23fd18 → 3.6.2-dev-20260316-0b03ae0

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) {
@@ -1275,21 +1276,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 +1286,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 +1300,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 +1325,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 +1347,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 +1493,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 });
@@ -2152,6 +2120,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/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-0b03ae0",
   "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-0b03ae0",
+    "@matterbridge/thread": "3.6.2-dev-20260316-0b03ae0",
+    "@matterbridge/types": "3.6.2-dev-20260316-0b03ae0",
+    "@matterbridge/utils": "3.6.2-dev-20260316-0b03ae0",
     "express": "5.2.1",
     "multer": "2.1.1",
     "node-ansi-logger": "3.2.0",