@matterbridge/core 3.10.13-dev-20261007-320f739 → 3.10.13-dev-20261009-7fc645a

package/dist/backendWsServer.js

@@ -0,0 +1,409 @@
+import { Logger, LogLevel as MatterLogLevel } from '@matter/general';
+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';
+import { fireAndForget, withTimeout } from '@matterbridge/utils/wait';
+import { AnsiLogger, CYAN, debugStringify, nf } from 'node-ansi-logger';
+import { WebSocket, WebSocketServer } from 'ws';
+logModuleLoaded('BackendWsServer');
+export class BackendWsServer {
+    debug;
+    verbose;
+    diagnostic;
+    log;
+    backend;
+    matterbridge;
+    server;
+    webSocketServer;
+    constructor(matterbridge, backend) {
+        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({
+            logName: 'BackendWsServer',
+            logNameColor: '\x1b[38;5;97m',
+            logTimestampFormat: 4,
+            logLevel: this.debug ? "debug" : "info",
+        });
+        this.server = new BroadcastServer('frontend', this.log);
+        this.server.on('broadcast_message', (msg) => fireAndForget(this.broadcastMsgHandler(msg), this.log, 'Broadcast message handler'));
+    }
+    destroy() {
+        this.server.close();
+    }
+    async broadcastMsgHandler(msg) {
+        if (this.server.isWorkerRequest(msg)) {
+            switch (msg.type) {
+                case 'get_log_level':
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+                case 'set_log_level':
+                    this.log.logLevel = msg.params.logLevel;
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+            }
+        }
+    }
+    async start() {
+        this.log.debug(`Creating WebSocketServer...`);
+        this.webSocketServer = new WebSocketServer({ noServer: true });
+        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`);
+            let callbackLogLevel = "notice";
+            if (this.log.logLevel === "info" || Logger.level === MatterLogLevel.INFO)
+                callbackLogLevel = "info";
+            if (this.log.logLevel === "debug" || Logger.level === MatterLogLevel.DEBUG)
+                callbackLogLevel = "debug";
+            AnsiLogger.setGlobalCallback(this.wssSendLogMessage.bind(this), callbackLogLevel);
+            this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
+            websocket.on('message', (data) => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} sent a message`);
+                fireAndForget(this.wsMessageHandler(websocket, data), this.log, `Error handling message from WebSocket client ${clientIp}`);
+            });
+            websocket.on('ping', () => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} ping received`);
+                websocket.pong();
+            });
+            websocket.on('pong', () => {
+                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} pong received`);
+            });
+            websocket.on('close', (code, reason) => {
+                this.log.info(`WebSocket client ${CYAN}${clientIp}${nf} disconnected code ${code} reason ${reason.toString()}`);
+                if (this.webSocketServer?.clients.size === 0) {
+                    AnsiLogger.setGlobalCallback(undefined);
+                    this.log.debug('All WebSocket clients disconnected. WebSocketServer logger global callback removed');
+                    setTimeout(() => {
+                        if (this.webSocketServer?.clients.size === 0) {
+                            this.log.debug('All WebSocket clients disconnected. Auth clients list cleared');
+                            this.backend.authClients.clear();
+                        }
+                    }, 1000).unref();
+                }
+                else {
+                    this.log.debug(`WebSocketServer still has ${this.webSocketServer?.clients.size} connected clients`);
+                }
+            });
+            websocket.on('error', (error) => {
+                inspectError(this.log, `WebSocket client error`, error);
+            });
+        });
+        this.webSocketServer.on('close', () => {
+            this.log.debug(`WebSocketServer closed`);
+        });
+        this.webSocketServer.on('error', (ws, error) => {
+            inspectError(this.log, `WebSocketServer error`, error);
+        });
+        return this.webSocketServer;
+    }
+    async stop() {
+        if (this.webSocketServer) {
+            this.log.debug('Closing WebSocket server...');
+            this.webSocketServer.clients.forEach((client) => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.close();
+                }
+            });
+            await withTimeout(new Promise((resolve) => {
+                this.webSocketServer?.close((error) => {
+                    if (error) {
+                        inspectError(this.log, `Error closing WebSocket server`, error);
+                    }
+                    else {
+                        this.log.debug('WebSocket server closed successfully');
+                        this.backend.emit('websocket_server_stopped');
+                    }
+                    resolve();
+                });
+            }), 10000, false);
+            this.webSocketServer.removeAllListeners();
+            this.webSocketServer = undefined;
+        }
+        else {
+            this.log.debug('WebSocket server is not running');
+        }
+        return this.webSocketServer;
+    }
+    hasActiveClients() {
+        return this.webSocketServer !== undefined && this.webSocketServer.clients.size > 0;
+    }
+    async wsMessageHandler(client, rawData) {
+        let data;
+        const sendResponse = (data) => {
+            if (client.readyState === client.OPEN) {
+                if ('response' in data) {
+                    const { response, ...rest } = data;
+                    this.log.debug(`Sending api response message: ${debugStringify(rest)}`);
+                }
+                else {
+                    this.log.debug(`Sending api error message: ${debugStringify(data)}`);
+                }
+                const bigintReplacer = (_, v) => (typeof v === 'bigint' ? `${v}n` : v);
+                client.send(JSON.stringify(data, bigintReplacer));
+            }
+            else {
+                this.log.error('Cannot send api response, client not connected');
+            }
+        };
+        try {
+            const raw = Array.isArray(rawData) ? Buffer.concat(rawData) : rawData instanceof ArrayBuffer ? Buffer.from(rawData) : rawData;
+            data = JSON.parse(raw.toString());
+            if (!isValidNumber(data.id) || !isValidString(data.dst) || !isValidString(data.src) || !isValidString(data.method) || data.dst !== 'Matterbridge') {
+                this.log.error(`Invalid message from websocket client: ${debugStringify(data)}`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid message' });
+                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/login') {
+                const storedPassword = this.backend.storedPassword;
+                if (storedPassword === undefined) {
+                    this.log.error('Login stored password not loaded');
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Internal error: stored password not loaded' });
+                    return;
+                }
+                if (storedPassword === '' || storedPassword === data.params.password) {
+                    this.log.debug('Login password valid');
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                }
+                else {
+                    this.log.debug('Error wrong password');
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong password' });
+                }
+            }
+            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);
+            return;
+        }
+    }
+    wssBroadcastMessage(msg) {
+        if (!this.hasActiveClients())
+            return;
+        try {
+            const stringifiedMsg = JSON.stringify(msg);
+            this.webSocketServer?.clients.forEach((client) => {
+                if (client.readyState === client.OPEN) {
+                    client.send(stringifiedMsg);
+                }
+            });
+        }
+        catch (error) {
+            inspectError(this.log, `Error broadcasting message to websocket clients`, error);
+        }
+    }
+    wssSendLogMessage(level, time, name, message) {
+        if (!this.hasActiveClients())
+            return;
+        if (!level || !time || !name || !message)
+            return;
+        message = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
+        message = message.replace(/^\*+/, '');
+        message = message.replace(/[\t\n]/g, '');
+        message = message.replace(/[\x00-\x1F\x7F]/g, '');
+        message = message.replace(/\\"/g, '"');
+        const maxContinuousLength = 100;
+        const keepStartLength = 20;
+        const keepEndLength = 20;
+        if (level !== 'spawn') {
+            message = message
+                .split(' ')
+                .map((word) => {
+                if (word.length > maxContinuousLength) {
+                    return word.slice(0, keepStartLength) + ' ... ' + word.slice(-keepEndLength);
+                }
+                return word;
+            })
+                .join(' ');
+        }
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'log', success: true, response: { level, time, name, message } });
+    }
+    wssSendRefreshRequired(changed, params) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a refresh required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', success: true, response: { changed, lock: params?.lock, ...params } });
+    }
+    wssSendRestartRequired(snackbar = true, fixed = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a restart required message to all connected clients');
+        if (snackbar)
+            this.wssSendSnackbarMessage(`Restart required`, 0);
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
+    }
+    wssSendRestartNotRequired(snackbar = true) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a restart not required message to all connected clients');
+        if (snackbar)
+            this.wssSendCloseSnackbarMessage(`Restart required`);
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
+    }
+    wssSendUpdateRequired(version, devVersion = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a matterbridge version update required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { version, devVersion } });
+    }
+    wssSendPluginUpdateRequired(plugin, version, devVersion = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a plugin version update required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_update_required', success: true, response: { plugin, version, devVersion } });
+    }
+    wssSendPluginStatusUpdate(plugin, status) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a plugin status update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_status_update', success: true, response: { plugin, status } });
+    }
+    wssSendMatterbridgeStatusUpdate(status) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a matterbridge status update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'matterbridge_status_update', success: true, response: { status } });
+    }
+    wssSendCpuUpdate(cpuUsage, processCpuUsage) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a cpu update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'cpu_update',
+            success: true,
+            response: { cpuUsage: Math.round(cpuUsage * 100) / 100, processCpuUsage: Math.round(processCpuUsage * 100) / 100 },
+        });
+    }
+    wssSendMemoryUpdate(totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a memory update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'memory_update',
+            success: true,
+            response: { totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers },
+        });
+    }
+    wssSendUptimeUpdate(systemUptime, processUptime) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a uptime update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'uptime_update', success: true, response: { systemUptime, processUptime } });
+    }
+    wssSendSnackbarMessage(message, timeout = 5, severity = 'info') {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a snackbar message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'snackbar', success: true, response: { message, timeout, severity } });
+    }
+    wssSendCloseSnackbarMessage(message) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a close snackbar message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'close_snackbar', success: true, response: { message } });
+    }
+    wssSendAttributeChangedMessage(plugin, serialNumber, uniqueId, number, id, cluster, attribute, value) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending an attribute update message to all connected clients');
+        this.wssBroadcastMessage({
+            id: 0,
+            src: 'Matterbridge',
+            dst: 'Frontend',
+            method: 'state_update',
+            success: true,
+            response: { plugin, serialNumber, uniqueId, number, id, cluster, attribute, value },
+        });
+    }
+}

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,10 +102,10 @@ async function main() {
     const { Matterbridge } = await import('./matterbridge.js');
     instance = await Matterbridge.loadInstance(true);
     log.debug(`***Matterbridge.loadInstance(true) exited`);
-    if (hasParameter('experimental')) {
-        log.debug(`***Starting Backend thread...`);
+    if (hasParameter('experimental-backend')) {
+        log.debug(`***Starting experimental Backend thread...`);
         manager.runThread('Backend');
-        log.debug(`***Started Backend thread`);
+        log.debug(`***Started experimental Backend thread`);
     }
     if (!instance || instance.shutdown) {
         await shutdown();
@@ -173,7 +175,7 @@ function help() {
       --novirtual:             disable the creation of the virtual devices Restart, Update and Reboot Matterbridge
       --root-power-source:     add a Power Source cluster for the mains power feed on the Root endpoint
       --ssl:                   enable SSL for the frontend and the WebSocketServer (the server will use the certificates and switch to https)
-      --mtls:                  enable mTLS for the frontend and the WebSocketServer (both server and client will use and require the certificates and switch to https)
+      --mtls:                  enable mTLS for the frontend and the WebSocketServer (both server and client will use and require the certificates and switch to https); it also enables https, so --ssl --tls is not needed
       --vendorId:              override the default vendorId 0xfff1
       --vendorName:            override the default vendorName "Matterbridge"
       --productId:             override the default productId 0x8000

package/dist/cliEmitter.d.ts

@@ -7,8 +7,4 @@ interface CliEvents {
     ready: [];
 }
 export declare const cliEmitter: EventEmitter<CliEvents>;
-export declare let lastOsCpuUsage: number;
-export declare let lastProcessCpuUsage: number;
-export declare function setLastOsCpuUsage(val: number): void;
-export declare function setLastProcessCpuUsage(val: number): void;
 export {};

package/dist/cliEmitter.js

@@ -2,11 +2,3 @@ import { EventEmitter } from 'node:events';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 logModuleLoaded('CliEmitter');
 export const cliEmitter = new EventEmitter();
-export let lastOsCpuUsage = 0;
-export let lastProcessCpuUsage = 0;
-export function setLastOsCpuUsage(val) {
-    lastOsCpuUsage = val;
-}
-export function setLastProcessCpuUsage(val) {
-    lastProcessCpuUsage = val;
-}

package/dist/frontend.js

@@ -8,7 +8,7 @@ import { FabricIndex } from '@matter/types/datatype';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
 import { isBun, memoryFootprint } from '@matterbridge/utils/bun';
-import { getParameter, hasParameter } from '@matterbridge/utils/cli';
+import { getParameter, hasAnyParameter, hasParameter } from '@matterbridge/utils/cli';
 import { writeDiagnostic } from '@matterbridge/utils/diagnostic';
 import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
 import { formatBytes, formatPercent, formatUptime } from '@matterbridge/utils/format';
@@ -16,7 +16,7 @@ import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidArray, isValidBoolean, isValidNumber, isValidObject, isValidString } from '@matterbridge/utils/validate';
 import { fireAndForget, wait, withTimeout } from '@matterbridge/utils/wait';
 import { AnsiLogger, bgHex, CYAN, db, debugStringify, er, GREEN, nf, nt, rs, stringify, UNDERLINE, UNDERLINEOFF, wr, YELLOW } from 'node-ansi-logger';
-import { cliEmitter, lastOsCpuUsage, lastProcessCpuUsage } from './cliEmitter.js';
+import { cliEmitter } from './cliEmitter.js';
 import { generateHistoryPage } from './cliHistory.js';
 import { capitalizeFirstLetter } from './matterbridgeEndpointHelpers.js';
 import { deleteAdvertisingNode, getBatteryLevel, getClusterTextFromDevice, getPowerSource, getReachability, getServerNodeData, setAdvertisingNode } from './matterNodeHelpers.js';
@@ -209,7 +209,8 @@ export class Frontend extends EventEmitter {
     async start(port = 8283) {
         this.port = port;
         this.storedPassword = await this.matterbridge.nodeContext?.get('password', '');
-        this.log.debug(`Initializing the frontend ${hasParameter('ssl') ? 'https' : 'http'} server on port ${YELLOW}${this.port}${db}`);
+        const secure = hasAnyParameter('ssl', 'tls', 'mtls');
+        this.log.debug(`Initializing the frontend ${secure ? 'https' : 'http'} server on port ${YELLOW}${this.port}${db}`);
         const multer = await import('multer');
         const uploadDir = path.join(this.matterbridge.matterbridgeDirectory, 'uploads');
         const upload = multer.default({ dest: uploadDir });
@@ -219,7 +220,7 @@ export class Frontend extends EventEmitter {
         this.log.debug(`Creating WebSocketServer...`);
         const ws = await import('ws');
         this.webSocketServer = new ws.WebSocketServer({ noServer: true });
-        this.emit('websocket_server_listening', hasParameter('ssl') ? 'wss' : 'ws');
+        this.emit('websocket_server_listening', secure ? 'wss' : 'ws');
         this.webSocketServer.on('connection', (ws, request) => {
             const clientIp = request.socket.remoteAddress;
             let callbackLogLevel = "notice";
@@ -264,7 +265,7 @@ export class Frontend extends EventEmitter {
         this.webSocketServer.on('error', (ws, error) => {
             this.log.error(`WebSocketServer error: ${error}`);
         });
-        if (!hasParameter('ssl')) {
+        if (!secure) {
             const http = await import('node:http');
             try {
                 this.log.debug(`Creating HTTP server...`);
@@ -929,8 +930,8 @@ export class Frontend extends EventEmitter {
         this.matterbridge.systemInformation.freeMemory = formatBytes(os.freemem());
         this.matterbridge.systemInformation.systemUptime = formatUptime(os.uptime());
         this.matterbridge.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
-        this.matterbridge.systemInformation.cpuUsage = formatPercent(lastOsCpuUsage);
-        this.matterbridge.systemInformation.processCpuUsage = formatPercent(lastProcessCpuUsage);
+        this.matterbridge.systemInformation.cpuUsage = formatPercent(0);
+        this.matterbridge.systemInformation.processCpuUsage = formatPercent(0);
         this.matterbridge.systemInformation.rss = formatBytes(memoryFootprint());
         this.matterbridge.systemInformation.heapTotal = formatBytes(process.memoryUsage().heapTotal);
         this.matterbridge.systemInformation.heapUsed = formatBytes(process.memoryUsage().heapUsed);

package/dist/matterNode.js

@@ -69,14 +69,15 @@ export class MatterNode extends EventEmitter {
         this.log.logNameColor = '\x1b[38;5;65m';
         if (this.debug)
             this.log.debug(`MatterNode ${this.pluginName ? 'for plugin ' + this.pluginName : 'bridge'} loading...`);
+        this.storeId = this.device?.deviceName ? this.device.deviceName.replace(/[ .]/g, '') : (this.pluginName ?? 'Matterbridge');
         this.port = matterbridge.port;
         this.passcode = matterbridge.passcode;
         this.discriminator = matterbridge.discriminator;
+        this.mdnsInterface = matterbridge.mdnsInterface;
         this.server = new BroadcastServer('matter', this.log);
         this.server.on('broadcast_message', this.msgHandler.bind(this));
         if (this.verbose)
             this.log.debug(`BroadcastServer is ready`);
-        fs.mkdirSync(matterbridge.matterbridgeDirectory, { recursive: true });
         this.pluginManager = new PluginManager(this.matterbridge);
         this.pluginManager.logLevel = this.debug ? "debug" : "info";
         this.pluginManager.server.close();
@@ -87,6 +88,8 @@ export class MatterNode extends EventEmitter {
         this.environment.vars.set('path.root', path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR));
         this.environment.vars.set('runtime.signals', false);
         this.environment.vars.set('runtime.exitcode', false);
+        if (this.mdnsInterface)
+            this.environment.vars.set('mdns.networkInterface', this.mdnsInterface);
         if (this.verbose)
             this.log.debug(`Matter Environment is ready`);
         this.matterMdnsService = new MdnsService(this.environment);
@@ -117,6 +120,34 @@ export class MatterNode extends EventEmitter {
                     this.log.logLevel = msg.params.logLevel;
                     this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
                     break;
+                case 'matter_start':
+                    if (this.device || msg.params.storeId !== this.storeId)
+                        break;
+                    try {
+                        await this.create();
+                        await this.start();
+                        this.server.respond({ ...msg, result: { storeId: this.storeId, success: true } });
+                    }
+                    catch (error) {
+                        inspectError(this.log, `Error starting MatterNode ${this.storeId}`, error);
+                    }
+                    break;
+                case 'matter_stop':
+                    if (this.device || msg.params.storeId !== this.storeId)
+                        break;
+                    try {
+                        await this.stop();
+                        this.server.respond({ ...msg, result: { storeId: this.storeId, success: true } });
+                        await this.destroy(!this.pluginName);
+                    }
+                    catch (error) {
+                        inspectError(this.log, `Error stopping MatterNode ${this.storeId}`, error);
+                    }
+                    break;
+                case 'matter_apimatter':
+                    if (this.serverNode?.id === msg.params.id)
+                        this.server.respond({ ...msg, result: { matter: getServerNodeData(this.serverNode) } });
+                    break;
                 default:
                     if (this.verbose)
                         this.log.debug(`Unknown broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
@@ -153,6 +184,10 @@ export class MatterNode extends EventEmitter {
     }
     async create() {
         this.log.info('Creating Matter node...');
+        const { result } = await this.server.fetch({ type: 'matterbridge_matterdata', src: this.server.name, dst: 'matterbridge' });
+        this.port = result.port;
+        this.passcode = result.passcode;
+        this.discriminator = result.discriminator;
         await this.startMatterStorage();
         this.pluginManager.matterbridge.nodeStorage = new NodeStorageManager({
             dir: path.join(this.matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR),
@@ -967,7 +1002,7 @@ export class MatterNode extends EventEmitter {
             child.act((agent) => child.eventsOf(BridgedDeviceBasicInformationServer).reachableChanged.emit({ reachableNewValue: true }, agent.context));
         }
     }
-    async yieldToNode(timeout = 100) {
+    async yieldToNode(timeout = 10) {
         await Promise.resolve();
         await new Promise((resolve) => {
             setImmediate(resolve);