@matterbridge/core 3.10.13-dev-20261005-49e0dbd → 3.10.13-dev-20261008-55d98fb

package/dist/backend.d.ts

@@ -1,5 +1,5 @@
 import EventEmitter from 'node:events';
-import type { ApiDevice, ApiPlugin, ApiSettings, SharedMatterbridge } from '@matterbridge/types';
+import { type ApiClusters, type ApiDevice, type ApiPlugin, type ApiSettings, type SharedMatterbridge, type ApiMatter } from '@matterbridge/types';
 import type { BackendExpress } from './backendExpress.js';
 import type { BackendWsServer } from './backendWsServer.js';
 interface BackendEvents {
@@ -12,6 +12,7 @@ interface BackendEvents {
 export declare class Backend extends EventEmitter<BackendEvents> {
     private debug;
     private verbose;
+    private diagnostic;
     private log;
     private matterbridge;
     private readonly server;
@@ -19,6 +20,8 @@ export declare class Backend extends EventEmitter<BackendEvents> {
     private listening;
     private httpServer;
     private httpsServer;
+    readonly secure: boolean;
+    readonly requestCert: boolean;
     backendExpress: BackendExpress | undefined;
     backendWsServer: BackendWsServer | undefined;
     storedPassword: string | undefined;
@@ -32,6 +35,8 @@ export declare class Backend extends EventEmitter<BackendEvents> {
     getApiSettings(): Promise<ApiSettings>;
     getApiPlugins(): Promise<ApiPlugin[]>;
     getApiDevices(pluginName?: string): Promise<ApiDevice[]>;
+    getApiCluster(pluginName: string, endpointNumber: number, serialNumber?: string, uniqueId?: string): Promise<ApiClusters | undefined>;
     generateDiagnostic(): Promise<void>;
+    getApiMatter(id: string): Promise<ApiMatter | undefined>;
 }
 export {};

package/dist/backend.js

@@ -1,14 +1,19 @@
 import EventEmitter from 'node:events';
 import path from 'node:path';
-import { BroadcastServer } from '@matterbridge/thread';
-import { getParameter, hasParameter } from '@matterbridge/utils/cli';
+import { BroadcastServer } from '@matterbridge/thread/server';
+import { NODE_STORAGE_DIR, } from '@matterbridge/types';
+import { getParameter, hasAnyParameter, hasParameter } from '@matterbridge/utils/cli';
+import { writeDiagnostic } from '@matterbridge/utils/diagnostic';
 import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
+import { fireAndForget } from '@matterbridge/utils/wait';
 import { AnsiLogger, rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
+import { NodeStorageManager } from 'node-persist-manager';
 logModuleLoaded('Backend');
 export class Backend extends EventEmitter {
     debug;
     verbose;
+    diagnostic;
     log;
     matterbridge;
     server;
@@ -16,6 +21,8 @@ export class Backend extends EventEmitter {
     listening = false;
     httpServer;
     httpsServer;
+    secure;
+    requestCert;
     backendExpress;
     backendWsServer;
     storedPassword = undefined;
@@ -23,8 +30,11 @@ export class Backend extends EventEmitter {
     authClientsTimeout = undefined;
     constructor(matterbridge) {
         super();
-        this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-frontend') || hasParameter('verbose-frontend');
-        this.verbose = hasParameter('verbose') || hasParameter('verbose-frontend');
+        this.debug = hasAnyParameter('debug', 'verbose', 'debug-backend', 'verbose-backend');
+        this.verbose = hasAnyParameter('verbose', 'verbose-backend');
+        this.diagnostic = hasAnyParameter('diagnostic', 'diagnostic-backend');
+        this.secure = hasAnyParameter('ssl', 'tls', 'mtls');
+        this.requestCert = hasParameter('mtls');
         this.matterbridge = matterbridge;
         this.log = new AnsiLogger({
             logName: 'Backend',
@@ -33,7 +43,7 @@ export class Backend extends EventEmitter {
             logLevel: this.debug ? "debug" : "info",
         });
         this.server = new BroadcastServer('frontend', this.log);
-        this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
+        this.server.on('broadcast_message', (msg) => fireAndForget(this.broadcastMsgHandler(msg), this.log, 'Broadcast message handler'));
     }
     destroy() {
         this.server.close();
@@ -54,81 +64,32 @@ export class Backend extends EventEmitter {
     async start(port = 8283) {
         this.log.debug('Starting backend...');
         this.port = port;
-        const { BackendExpress } = await import('./backendExpress.js');
-        const { BackendWsServer } = await import('./backendWsServer.js');
-        this.backendExpress = new BackendExpress(this.matterbridge, this);
-        this.backendWsServer = new BackendWsServer(this.matterbridge, this);
-        if (!hasParameter('ssl')) {
-            const http = await import('node:http');
-            await this.backendExpress.start();
+        const start = performance.now();
+        const nodeStorage = new NodeStorageManager({
+            dir: path.join(this.matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR),
+            writeQueue: false,
+            expiredInterval: undefined,
+            logging: false,
+        });
+        try {
+            const nodeContext = await nodeStorage.createStorage('matterbridge');
             try {
-                this.log.debug(`Creating HTTP server...`);
-                this.httpServer = http.createServer(this.backendExpress.expressApp);
+                this.storedPassword = await nodeContext.get('password', '');
             }
-            catch (error) {
-                logError(this.log, `Failed to create HTTP server`, error);
-                this.emit('server_error', error);
-                await this.backendExpress.stop();
-                return;
+            finally {
+                await nodeContext.close();
             }
-            await this.backendWsServer.start();
-            this.httpServer.listen(this.port, getParameter('bind'), () => {
-                const addr = this.httpServer?.address();
-                if (addr && typeof addr !== 'string') {
-                    this.log.info(`The frontend http server is bound to ${addr.family} ${addr.address}:${addr.port}`);
-                }
-                if (this.matterbridge.systemInformation.ipv4Address !== '' && !getParameter('bind'))
-                    this.log.info(`The frontend http server is listening on ${UNDERLINE}http://${this.matterbridge.systemInformation.ipv4Address}:${this.port}${UNDERLINEOFF}${rs}`);
-                if (this.matterbridge.systemInformation.ipv6Address !== '' && !getParameter('bind'))
-                    this.log.info(`The frontend http server is listening on ${UNDERLINE}http://[${this.matterbridge.systemInformation.ipv6Address}]:${this.port}${UNDERLINEOFF}${rs}`);
-                this.listening = true;
-                this.emit('server_listening', 'http', this.port);
-            });
-            this.httpServer.on('upgrade', (req, socket, head) => {
-                try {
-                    if ((req.headers.upgrade || '').toLowerCase() !== 'websocket') {
-                        this.log.error(`WebSocket upgrade error: Invalid upgrade header ${req.headers.upgrade}`);
-                        socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
-                        return socket.destroy();
-                    }
-                    const url = new URL(req.url ?? '/', `http://${req.headers.host || 'localhost'}`);
-                    const password = url.searchParams.get('password') ?? '';
-                    if (password !== this.storedPassword) {
-                        this.log.error(`WebSocket upgrade error: Invalid password ${password ? '[redacted]' : '(empty)'}`);
-                        socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
-                        return socket.destroy();
-                    }
-                    this.log.debug(`WebSocket upgrade success host ${url.host} password ${password ? '[redacted]' : '(empty)'}`);
-                    if (req.socket.remoteAddress)
-                        this.authClients.add(req.socket.remoteAddress);
-                    this.backendWsServer?.webSocketServer?.handleUpgrade(req, socket, head, (ws) => {
-                        this.backendWsServer?.webSocketServer?.emit('connection', ws, req);
-                    });
-                }
-                catch (err) {
-                    {
-                        inspectError(this.log, 'WebSocket upgrade error:', err);
-                        socket.write('HTTP/1.1 500 Internal Server Error\r\nConnection: close\r\n\r\n');
-                        socket.destroy();
-                    }
-                }
-                return undefined;
-            });
-            this.httpServer.on('error', (error) => {
-                this.log.error(`Frontend http server error listening on ${this.port}`);
-                switch (error.code) {
-                    case 'EACCES':
-                        this.log.error(`Port ${this.port} requires elevated privileges`);
-                        break;
-                    case 'EADDRINUSE':
-                        this.log.error(`Port ${this.port} is already in use`);
-                        break;
-                }
-                this.emit('server_error', error);
-                return undefined;
-            });
         }
-        else {
+        finally {
+            await nodeStorage.close();
+            if (this.diagnostic)
+                writeDiagnostic('Backend', `Loading storedPassword took ${(performance.now() - start).toFixed(2)} ms`);
+        }
+        const { BackendExpress } = await import('./backendExpress.js');
+        const { BackendWsServer } = await import('./backendWsServer.js');
+        this.backendExpress = new BackendExpress(this.matterbridge, this);
+        this.backendWsServer = new BackendWsServer(this.matterbridge, this);
+        if (this.secure) {
             let cert;
             let key;
             let ca;
@@ -188,7 +149,7 @@ export class Backend extends EventEmitter {
                 }
                 httpsServerOptions = { cert: fullChain ?? cert, key, ca };
             }
-            if (hasParameter('mtls')) {
+            if (this.requestCert) {
                 httpsServerOptions.requestCert = true;
                 httpsServerOptions.rejectUnauthorized = true;
             }
@@ -219,16 +180,19 @@ export class Backend extends EventEmitter {
             });
             this.httpsServer.on('upgrade', (req, socket, head) => {
                 try {
-                    if ((req.headers.upgrade || '').toLowerCase() !== 'websocket') {
+                    const upgrade = (req.headers.upgrade || '').toLowerCase();
+                    if (upgrade !== 'websocket') {
                         socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
-                        return socket.destroy();
+                        socket.destroy();
+                        return;
                     }
                     const url = new URL(req.url ?? '/', `https://${req.headers.host || 'localhost'}`);
                     const password = url.searchParams.get('password') ?? '';
                     if (password !== this.storedPassword) {
                         this.log.error(`WebSocket upgrade error: Invalid password ${password ? '[redacted]' : '(empty)'}`);
                         socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
-                        return socket.destroy();
+                        socket.destroy();
+                        return;
                     }
                     this.log.debug(`WebSocket upgrade success host ${url.host} password ${password ? '[redacted]' : '(empty)'}`);
                     if (req.socket.remoteAddress)
@@ -244,7 +208,6 @@ export class Backend extends EventEmitter {
                         socket.destroy();
                     }
                 }
-                return undefined;
             });
             this.httpsServer.on('error', (error) => {
                 this.log.error(`Frontend https server error listening on ${this.port}`);
@@ -257,7 +220,78 @@ export class Backend extends EventEmitter {
                         break;
                 }
                 this.emit('server_error', error);
+            });
+        }
+        else {
+            const http = await import('node:http');
+            await this.backendExpress.start();
+            try {
+                this.log.debug(`Creating HTTP server...`);
+                this.httpServer = http.createServer(this.backendExpress.expressApp);
+            }
+            catch (error) {
+                logError(this.log, `Failed to create HTTP server`, error);
+                this.emit('server_error', error);
+                await this.backendExpress.stop();
                 return;
+            }
+            await this.backendWsServer.start();
+            this.httpServer.listen(this.port, getParameter('bind'), () => {
+                const addr = this.httpServer?.address();
+                if (addr && typeof addr !== 'string') {
+                    this.log.info(`The frontend http server is bound to ${addr.family} ${addr.address}:${addr.port}`);
+                }
+                if (this.matterbridge.systemInformation.ipv4Address !== '' && !getParameter('bind'))
+                    this.log.info(`The frontend http server is listening on ${UNDERLINE}http://${this.matterbridge.systemInformation.ipv4Address}:${this.port}${UNDERLINEOFF}${rs}`);
+                if (this.matterbridge.systemInformation.ipv6Address !== '' && !getParameter('bind'))
+                    this.log.info(`The frontend http server is listening on ${UNDERLINE}http://[${this.matterbridge.systemInformation.ipv6Address}]:${this.port}${UNDERLINEOFF}${rs}`);
+                this.listening = true;
+                this.emit('server_listening', 'http', this.port);
+            });
+            this.httpServer.on('upgrade', (req, socket, head) => {
+                try {
+                    const upgrade = (req.headers.upgrade || '').toLowerCase();
+                    if (upgrade !== 'websocket') {
+                        this.log.error(`WebSocket upgrade error: Invalid upgrade header ${req.headers.upgrade}`);
+                        socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+                        socket.destroy();
+                        return;
+                    }
+                    const url = new URL(req.url ?? '/', `http://${req.headers.host || 'localhost'}`);
+                    const password = url.searchParams.get('password') ?? '';
+                    if (password !== this.storedPassword) {
+                        this.log.error(`WebSocket upgrade error: Invalid password ${password ? '[redacted]' : '(empty)'}`);
+                        socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
+                        socket.destroy();
+                        return;
+                    }
+                    this.log.debug(`WebSocket upgrade success host ${url.host} password ${password ? '[redacted]' : '(empty)'}`);
+                    if (req.socket.remoteAddress)
+                        this.authClients.add(req.socket.remoteAddress);
+                    this.backendWsServer?.webSocketServer?.handleUpgrade(req, socket, head, (ws) => {
+                        this.backendWsServer?.webSocketServer?.emit('connection', ws, req);
+                    });
+                }
+                catch (err) {
+                    {
+                        inspectError(this.log, 'WebSocket upgrade error:', err);
+                        socket.write('HTTP/1.1 500 Internal Server Error\r\nConnection: close\r\n\r\n');
+                        socket.destroy();
+                    }
+                }
+                return;
+            });
+            this.httpServer.on('error', (error) => {
+                this.log.error(`Frontend http server error listening on ${this.port}`);
+                switch (error.code) {
+                    case 'EACCES':
+                        this.log.error(`Port ${this.port} requires elevated privileges`);
+                        break;
+                    case 'EADDRINUSE':
+                        this.log.error(`Port ${this.port} is already in use`);
+                        break;
+                }
+                this.emit('server_error', error);
             });
         }
         this.log.debug('Backend started');
@@ -293,16 +327,43 @@ export class Backend extends EventEmitter {
         this.log.debug('Backend stopped');
     }
     async getApiSettings() {
+        const start = performance.now();
         const response = await this.server.fetch({ type: 'matterbridge_apisettings', src: 'frontend', dst: 'matterbridge', params: undefined });
+        if (this.diagnostic)
+            writeDiagnostic('Backend', `getApiSettings() took ${(performance.now() - start).toFixed(2)} ms`);
         return response.result.data;
     }
     async getApiPlugins() {
+        const start = performance.now();
         const response = await this.server.fetch({ type: 'plugins_apipluginarray', src: 'frontend', dst: 'plugins', params: undefined });
+        if (this.diagnostic)
+            writeDiagnostic('Backend', `getApiPlugins() took ${(performance.now() - start).toFixed(2)} ms`);
         return response.result.plugins;
     }
     async getApiDevices(pluginName) {
-        const _response = await this.server.fetch({ type: 'devices_basearray', src: 'frontend', dst: 'devices', params: { pluginName } });
-        return [];
+        const start = performance.now();
+        const response = await this.server.fetch({ type: 'devices_apidevicearray', src: 'frontend', dst: 'devices', params: { pluginName } });
+        if (this.diagnostic)
+            writeDiagnostic('Backend', `getApiDevices() took ${(performance.now() - start).toFixed(2)} ms`);
+        return response.result.devices;
+    }
+    async getApiCluster(pluginName, endpointNumber, serialNumber, uniqueId) {
+        const start = performance.now();
+        this.log.debug(`Retrieving API cluster for plugin: ${pluginName}, endpoint: ${endpointNumber}, serial: ${serialNumber}, uniqueId: ${uniqueId}`);
+        if (this.diagnostic)
+            writeDiagnostic('Backend', `getApiCluster() took ${(performance.now() - start).toFixed(2)} ms`);
+        return undefined;
+    }
+    async generateDiagnostic() {
+        const start = performance.now();
+        if (this.diagnostic)
+            writeDiagnostic('Backend', `generateDiagnostic() took ${(performance.now() - start).toFixed(2)} ms`);
+    }
+    async getApiMatter(id) {
+        const start = performance.now();
+        const response = await this.server.fetch({ type: 'matter_apimatter', src: 'frontend', dst: 'matter', params: { id } });
+        if (this.diagnostic)
+            writeDiagnostic('Backend', `getApiMatter() took ${(performance.now() - start).toFixed(2)} ms`);
+        return response.result.matter;
     }
-    async generateDiagnostic() { }
 }

package/dist/backendExpress.d.ts

@@ -4,6 +4,7 @@ import type { Backend } from './backend.js';
 export declare class BackendExpress {
     private debug;
     private verbose;
+    private diagnostic;
     private log;
     private backend;
     private matterbridge;

package/dist/backendExpress.js

@@ -1,12 +1,13 @@
 import os from 'node:os';
 import path from 'node:path';
-import { BroadcastServer } from '@matterbridge/thread';
+import { BroadcastServer } from '@matterbridge/thread/server';
 import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_BACKUP_FILE, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, MATTERBRIDGE_PLUGIN_CONFIG_FILE, MATTERBRIDGE_PLUGIN_STORAGE_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
 import { isBun } from '@matterbridge/utils/bun';
-import { hasParameter } from '@matterbridge/utils/cli';
+import { hasAnyParameter } from '@matterbridge/utils/cli';
 import { getErrorMessage } from '@matterbridge/utils/error';
 import { formatBytes } from '@matterbridge/utils/format';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
+import { fireAndForget } from '@matterbridge/utils/wait';
 import escapeHtml from 'escape-html';
 import express from 'express';
 import { rateLimit } from 'express-rate-limit';
@@ -16,6 +17,7 @@ logModuleLoaded('BackendExpress');
 export class BackendExpress {
     debug;
     verbose;
+    diagnostic;
     log;
     backend;
     matterbridge;
@@ -27,8 +29,9 @@ export class BackendExpress {
     expressApp;
     serverFetchTimeout = 5000;
     constructor(matterbridge, backend) {
-        this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-frontend') || hasParameter('verbose-frontend');
-        this.verbose = hasParameter('verbose') || hasParameter('verbose-frontend');
+        this.debug = hasAnyParameter('debug', 'verbose', 'debug-backend', 'verbose-backend');
+        this.verbose = hasAnyParameter('verbose', 'verbose-backend');
+        this.diagnostic = hasAnyParameter('diagnostic', 'diagnostic-backend');
         this.backend = backend;
         this.matterbridge = matterbridge;
         this.log = new AnsiLogger({
@@ -38,7 +41,7 @@ export class BackendExpress {
             logLevel: this.debug ? "debug" : "info",
         });
         this.server = new BroadcastServer('frontend', this.log);
-        this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
+        this.server.on('broadcast_message', (msg) => fireAndForget(this.broadcastMsgHandler(msg), this.log, 'Broadcast message handler'));
     }
     destroy() {
         this.server.close();
@@ -53,7 +56,6 @@ export class BackendExpress {
                     this.log.logLevel = msg.params.logLevel;
                     this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
-                default:
             }
         }
     }

package/dist/backendWsServer.d.ts

@@ -5,6 +5,7 @@ import type { Backend } from './backend.js';
 export declare class BackendWsServer {
     private debug;
     private verbose;
+    private diagnostic;
     private log;
     private backend;
     private matterbridge;

package/dist/backendWsServer.js

@@ -1,6 +1,7 @@
 import { Logger, LogLevel as MatterLogLevel } from '@matter/general';
-import { BroadcastServer } from '@matterbridge/thread';
-import { hasParameter } from '@matterbridge/utils/cli';
+import { BroadcastServer } from '@matterbridge/thread/server';
+import { hasAnyParameter } from '@matterbridge/utils/cli';
+import { writeDiagnostic } from '@matterbridge/utils/diagnostic';
 import { inspectError } from '@matterbridge/utils/error';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidNumber, isValidString } from '@matterbridge/utils/validate';
@@ -11,14 +12,16 @@ logModuleLoaded('BackendWsServer');
 export class BackendWsServer {
     debug;
     verbose;
+    diagnostic;
     log;
     backend;
     matterbridge;
     server;
     webSocketServer;
     constructor(matterbridge, backend) {
-        this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-frontend') || hasParameter('verbose-frontend');
-        this.verbose = hasParameter('verbose') || hasParameter('verbose-frontend');
+        this.debug = hasAnyParameter('debug', 'verbose', 'debug-backend', 'verbose-backend');
+        this.verbose = hasAnyParameter('verbose', 'verbose-backend');
+        this.diagnostic = hasAnyParameter('diagnostic', 'diagnostic-backend');
         this.backend = backend;
         this.matterbridge = matterbridge;
         this.log = new AnsiLogger({
@@ -28,12 +31,12 @@ export class BackendWsServer {
             logLevel: this.debug ? "debug" : "info",
         });
         this.server = new BroadcastServer('frontend', this.log);
-        this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
+        this.server.on('broadcast_message', (msg) => fireAndForget(this.broadcastMsgHandler(msg), this.log, 'Broadcast message handler'));
     }
     destroy() {
         this.server.close();
     }
-    broadcastMsgHandler(msg) {
+    async broadcastMsgHandler(msg) {
         if (this.server.isWorkerRequest(msg)) {
             switch (msg.type) {
                 case 'get_log_level':
@@ -43,14 +46,13 @@ export class BackendWsServer {
                     this.log.logLevel = msg.params.logLevel;
                     this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
-                default:
             }
         }
     }
     async start() {
         this.log.debug(`Creating WebSocketServer...`);
         this.webSocketServer = new WebSocketServer({ noServer: true });
-        this.backend.emit('websocket_server_listening', hasParameter('ssl') ? 'wss' : 'ws');
+        this.backend.emit('websocket_server_listening', this.backend.secure ? 'wss' : 'ws');
         this.webSocketServer.on('connection', (websocket, request) => {
             const clientIp = request.socket.remoteAddress;
             this.log.info(`WebSocketServer client ${CYAN}${clientIp}${nf} connected to Matterbridge`);
@@ -139,7 +141,7 @@ export class BackendWsServer {
                     const { response, ...rest } = data;
                     this.log.debug(`Sending api response message: ${debugStringify(rest)}`);
                 }
-                else if ('error' in data) {
+                else {
                     this.log.debug(`Sending api error message: ${debugStringify(data)}`);
                 }
                 const bigintReplacer = (_, v) => (typeof v === 'bigint' ? `${v}n` : v);
@@ -158,6 +160,73 @@ export class BackendWsServer {
                 return;
             }
             this.log.debug(`Received message from websocket client: ${debugStringify(data)}`);
+            if (data.method === 'ping') {
+                sendResponse({ id: data.id, method: 'pong', src: 'Matterbridge', dst: data.src, success: true, response: 'pong' });
+            }
+            else if (data.method === '/api/restart') {
+                this.wssSendSnackbarMessage('Restarting matterbridge...', 0);
+                await this.server.fetch({ type: 'matterbridge_restart', src: 'frontend', dst: 'matterbridge', params: undefined });
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+            }
+            else if (data.method === '/api/shutdown') {
+                this.wssSendSnackbarMessage('Shutting down matterbridge...', 0);
+                await this.server.fetch({ type: 'matterbridge_shutdown', src: 'frontend', dst: 'matterbridge', params: undefined });
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+            }
+            else if (data.method === '/api/settings') {
+                const start = performance.now();
+                const settings = await this.backend.getApiSettings();
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiSettings() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: settings });
+            }
+            else if (data.method === '/api/plugins') {
+                const start = performance.now();
+                const plugins = await this.backend.getApiPlugins();
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiPlugins() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: plugins });
+            }
+            else if (data.method === '/api/devices') {
+                const start = performance.now();
+                const devices = await this.backend.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiDevices() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: devices });
+            }
+            else if (data.method === '/api/clusters') {
+                if (!isValidString(data.params.plugin, 10)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/clusters' });
+                    return;
+                }
+                if (!isValidNumber(data.params.endpoint, 1)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' });
+                    return;
+                }
+                const start = performance.now();
+                const clusters = await this.backend.getApiCluster(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiCluster() took ${(performance.now() - start).toFixed(2)} ms`);
+                if (clusters) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: clusters });
+                }
+                else {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Endpoint not found in /api/clusters' });
+                }
+            }
+            else if (data.method === '/api/matter') {
+                if (!isValidString(data.params.id)) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter id in /api/matter' });
+                    return;
+                }
+                const matter = await this.backend.getApiMatter(data.params.id);
+                if (!matter) {
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Unknown server node id ${data.params.id} in /api/matter` });
+                    return;
+                }
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: matter });
+                this.wssSendRefreshRequired('matter', { matter });
+            }
         }
         catch (error) {
             inspectError(this.log, `Error parsing message from websocket client`, error);
@@ -169,8 +238,6 @@ export class BackendWsServer {
             return;
         try {
             const stringifiedMsg = JSON.stringify(msg);
-            if (this.verbose)
-                this.log.debug(`Sending a broadcast message: ${debugStringify(msg)}`);
             this.webSocketServer?.clients.forEach((client) => {
                 if (client.readyState === client.OPEN) {
                     client.send(stringifiedMsg);

package/dist/cli.js

@@ -1,3 +1,5 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { ThreadsManager } from '@matterbridge/thread/manager';
 import { hasAnyParameter, hasParameter } from '@matterbridge/utils/cli';
 import { inspectError } from '@matterbridge/utils/error';
@@ -11,7 +13,7 @@ logModuleLoaded('Cli');
 export let instance;
 export const tracker = new Tracker('Cli', false, false);
 export const inspector = new Inspector('Cli', false, false);
-const manager = new ThreadsManager();
+const manager = new ThreadsManager(path.dirname(fileURLToPath(import.meta.url)));
 const colorEnabled = !process.env.NO_COLOR && process.env.TERM !== 'dumb' && process.env.FORCE_COLOR !== '0' && !hasParameter('no-ansi');
 if (!colorEnabled)
     process.env.NO_COLOR = '1';
@@ -100,6 +102,11 @@ async function main() {
     const { Matterbridge } = await import('./matterbridge.js');
     instance = await Matterbridge.loadInstance(true);
     log.debug(`***Matterbridge.loadInstance(true) exited`);
+    if (hasParameter('experimental-backend')) {
+        log.debug(`***Starting experimental Backend thread...`);
+        manager.runThread('Backend');
+        log.debug(`***Started experimental Backend thread`);
+    }
     if (!instance || instance.shutdown) {
         await shutdown();
     }

package/dist/deviceManager.d.ts

@@ -1,4 +1,4 @@
-import type { BaseDevice } from '@matterbridge/types';
+import type { ApiDevice, BaseDevice } from '@matterbridge/types';
 import { LogLevel } from 'node-ansi-logger';
 import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 export declare function toBaseDevice(device: MatterbridgeEndpoint | BaseDevice): BaseDevice;
@@ -21,6 +21,7 @@ export declare class DeviceManager {
     private toBaseDevice;
     array(): MatterbridgeEndpoint[];
     baseArray(pluginName?: string): BaseDevice[];
+    apiDeviceArray(pluginName?: string): ApiDevice[];
     [Symbol.iterator](): IterableIterator<MatterbridgeEndpoint>;
     forEach(callback: (device: MatterbridgeEndpoint) => Promise<void>): Promise<void>;
     set logLevel(logLevel: LogLevel);