@matterbridge/core 3.10.13-dev-20261007-320f739 → 3.10.13-dev-20261008-55d98fb

package/dist/backendWsServer.js

@@ -0,0 +1,393 @@
+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/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();

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);

package/dist/matterbridge.js

@@ -170,6 +170,13 @@ export class Matterbridge extends EventEmitter {
         this.server.close();
     }
     getPlatformMatterbridge() {
+        this.systemInformation.totalMemory = formatBytes(os.totalmem());
+        this.systemInformation.freeMemory = formatBytes(os.freemem());
+        this.systemInformation.systemUptime = formatUptime(os.uptime());
+        this.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
+        this.systemInformation.rss = formatBytes(memoryFootprint());
+        this.systemInformation.heapTotal = formatBytes(process.memoryUsage().heapTotal);
+        this.systemInformation.heapUsed = formatBytes(process.memoryUsage().heapUsed);
         return {
             systemInformation: { ...this.systemInformation },
             uuid: this.uuid,
@@ -193,6 +200,13 @@ export class Matterbridge extends EventEmitter {
         };
     }
     getSharedMatterbridge() {
+        this.systemInformation.totalMemory = formatBytes(os.totalmem());
+        this.systemInformation.freeMemory = formatBytes(os.freemem());
+        this.systemInformation.systemUptime = formatUptime(os.uptime());
+        this.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
+        this.systemInformation.rss = formatBytes(memoryFootprint());
+        this.systemInformation.heapTotal = formatBytes(process.memoryUsage().heapTotal);
+        this.systemInformation.heapUsed = formatBytes(process.memoryUsage().heapUsed);
         return {
             systemInformation: { ...this.systemInformation },
             uuid: this.uuid,
@@ -318,6 +332,15 @@ export class Matterbridge extends EventEmitter {
                     await this.nodeContext?.set('globalModulesDirectory', msg.params.prefix);
                     this.server.respond({ ...msg, result: { success: true } });
                     break;
+                case 'matterbridge_matterdata':
+                    this.server.respond({ ...msg, result: { port: this.port, passcode: this.passcode, discriminator: this.discriminator } });
+                    if (this.port !== undefined)
+                        this.port++;
+                    if (this.passcode !== undefined)
+                        this.passcode++;
+                    if (this.discriminator !== undefined)
+                        this.discriminator++;
+                    break;
                 case 'matterbridge_platform':
                     this.server.respond({ ...msg, result: { data: this.getPlatformMatterbridge(), success: true } });
                     break;
@@ -750,6 +773,8 @@ export class Matterbridge extends EventEmitter {
         }
         else {
             this.globalModulesDirectory = await this.nodeContext.get('globalModulesDirectory', '');
+            if (this.globalModulesDirectory.includes('.bun'))
+                this.globalModulesDirectory = '';
         }
         if (this.globalModulesDirectory === '') {
             this.log.debug(`Getting global node_modules directory...`);
@@ -924,7 +949,7 @@ export class Matterbridge extends EventEmitter {
             this.shutdown = true;
             return;
         }
-        if (getIntParameter('frontend') !== 0 || getIntParameter('frontend') === undefined)
+        if ((getIntParameter('frontend') !== 0 || getIntParameter('frontend') === undefined) && !hasParameter('experimental-backend'))
             await this.frontend.start(getIntParameter('frontend'));
         try {
             await this.startMatterStorage();
@@ -1017,15 +1042,45 @@ export class Matterbridge extends EventEmitter {
             this.log.warn('Fixed delay switch found. Waiting for ' + delay + ' seconds before starting matterbridge...');
             await wait(delay * 1000, 'Fixed race condition delay', true);
         }
+        if (hasParameter('experimental-tracker')) {
+            this.log.notice('***Experimental tracker enabled for Threads');
+            for (let i = 0; i < 10; i++) {
+                this.server.request({ type: 'manager_run', src: 'matterbridge', dst: 'manager', params: { name: 'Tracker' } });
+            }
+        }
         if (hasParameter('bridge') || (!hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'bridge')) {
             this.bridgeMode = 'bridge';
             this.log.debug(`Starting matterbridge in mode ${this.bridgeMode}`);
+            if (hasParameter('experimental-node')) {
+                this.log.notice(`***Starting experimental MatterNode in ${this.bridgeMode} mode...`);
+                this.server.request({
+                    type: 'manager_run',
+                    src: 'matterbridge',
+                    dst: 'manager',
+                    params: { name: 'RootNode', workerData: { threadName: 'RootNode', sharedMatterbridge: this.getSharedMatterbridge() } },
+                });
+                this.log.notice(`***Started experimental MatterNode in ${this.bridgeMode} mode`);
+                return;
+            }
             await this.startBridge();
             return;
         }
         if (hasParameter('childbridge') || (!hasParameter('bridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'childbridge')) {
             this.bridgeMode = 'childbridge';
             this.log.debug(`Starting matterbridge in mode ${this.bridgeMode}`);
+            if (hasParameter('experimental-node')) {
+                this.log.notice(`***Starting experimental MatterNode in ${this.bridgeMode} mode...`);
+                for (const plugin of this.plugins.array().filter((p) => p.enabled)) {
+                    this.server.request({
+                        type: 'manager_run',
+                        src: 'matterbridge',
+                        dst: 'manager',
+                        params: { name: 'RootNode', workerData: { threadName: 'RootNode', sharedMatterbridge: this.getSharedMatterbridge(), pluginName: plugin.name } },
+                    });
+                }
+                this.log.notice(`***Started experimental MatterNode in ${this.bridgeMode} mode`);
+                return;
+            }
             await this.startChildbridge();
             return;
         }
@@ -1478,6 +1533,8 @@ export class Matterbridge extends EventEmitter {
             this.frontend.destroy();
             this.plugins.destroy();
             this.devices.destroy();
+            this.server.request({ type: 'manager_shutdown', src: 'matterbridge', dst: 'manager', params: {} });
+            await wait(100);
             this.server.close();
             if (this.nodeStorage && this.nodeContext) {
                 this.log.debug(`Closing node storage context for ${plg}Matterbridge${db}...`);

package/dist/runners/threadBackend.d.ts

@@ -0,0 +1,3 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+declare const _default: ThreadsWrapper;
+export default _default;

package/dist/runners/threadBackend.js

@@ -0,0 +1,24 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
+logModuleLoaded('Backend', '\u001B[35m');
+export default new ThreadsWrapper('Backend', async (worker) => {
+    worker.logger("info", 'Creating backend...');
+    try {
+        worker.logger("debug", 'Fetching shared Matterbridge state...');
+        const shared = (await worker.server.fetch({ type: 'matterbridge_shared', src: 'matterbridge', dst: 'matterbridge' }, 1000)).result.data;
+        worker.logger("debug", 'Shared Matterbridge state fetched; importing Backend...');
+        const { Backend } = await import('../backend.js');
+        worker.logger("debug", 'Backend imported; creating instance...');
+        const backend = new Backend(shared);
+        worker.logger("debug", 'Starting Backend...');
+        await backend.start();
+        worker.logger("debug", 'Backend started');
+        return true;
+    }
+    catch (error) {
+        const errorMessage = inspectError(worker.log, 'Failed to create backend', error);
+        worker.logger("error", errorMessage);
+        return false;
+    }
+});

package/dist/runners/threadRootNode.d.ts

@@ -0,0 +1,3 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+declare const _default: ThreadsWrapper;
+export default _default;