matterbridge 3.3.0-dev-20251004-43d8106 → 3.3.1-dev-20251007-4e5eaac

package/dist/frontend.js

@@ -8,15 +8,17 @@ import { appendFile } from 'node:fs/promises';
 import express from 'express';
 import WebSocket, { WebSocketServer } from 'ws';
 import multer from 'multer';
-import { AnsiLogger, stringify, debugStringify, CYAN, db, er, nf, rs, UNDERLINE, UNDERLINEOFF, YELLOW, nt } from 'node-ansi-logger';
+import { AnsiLogger, stringify, debugStringify, CYAN, db, er, nf, rs, UNDERLINE, UNDERLINEOFF, YELLOW, nt, wr } from 'node-ansi-logger';
 import { Logger, LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, Lifecycle, LogDestination, Diagnostic, Time, FabricIndex } from '@matter/main';
 import { BridgedDeviceBasicInformation, PowerSource } from '@matter/main/clusters';
 import { DeviceAdvertiser, DeviceCommissioner, FabricManager } from '@matter/main/protocol';
 import { CommissioningOptions } from '@matter/main/types';
+import { MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg } from './matterbridgeTypes.js';
 import { createZip, isValidArray, isValidNumber, isValidObject, isValidString, isValidBoolean, withTimeout, hasParameter, wait, inspectError } from './utils/export.js';
-import { MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, } from './matterbridgeTypes.js';
+import { formatMemoryUsage, formatOsUpTime } from './utils/network.js';
 import { capitalizeFirstLetter, getAttribute } from './matterbridgeEndpointHelpers.js';
 import { cliEmitter, lastCpuUsage } from './cliEmitter.js';
+import { BroadcastServer } from './broadcastServer.js';
 export class Frontend extends EventEmitter {
     matterbridge;
     log;
@@ -26,11 +28,55 @@ export class Frontend extends EventEmitter {
     httpServer;
     httpsServer;
     webSocketServer;
+    server;
     constructor(matterbridge) {
         super();
         this.matterbridge = matterbridge;
         this.log = new AnsiLogger({ logName: 'Frontend', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
         this.log.logNameColor = '\x1b[38;5;97m';
+        this.server = new BroadcastServer('plugins', this.log);
+        this.server.on('broadcast_message', this.msgHandler.bind(this));
+    }
+    destroy() {
+        this.server.close();
+    }
+    async msgHandler(msg) {
+        if (this.server.isWorkerRequest(msg, msg.type)) {
+            this.log.debug(`**Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
+            switch (msg.type) {
+                default:
+                    this.log.warn(`Unknown broadcast request ${CYAN}${msg.type}${wr} from ${CYAN}${msg.src}${wr}`);
+            }
+        }
+        if (this.server.isWorkerResponse(msg, msg.type)) {
+            this.log.debug(`**Received broadcast response ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
+            switch (msg.type) {
+                case 'plugins_install':
+                    this.wssSendCloseSnackbarMessage(`Installing package ${msg.response.packageName}...`);
+                    if (msg.response.success) {
+                        this.wssSendRestartRequired(true, true);
+                        this.wssSendRefreshRequired('plugins');
+                        this.wssSendSnackbarMessage(`Installed package ${msg.response.packageName}`, 5, 'success');
+                    }
+                    else {
+                        this.wssSendSnackbarMessage(`Package ${msg.response.packageName} not installed`, 10, 'error');
+                    }
+                    break;
+                case 'plugins_uninstall':
+                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${msg.response.packageName}...`);
+                    if (msg.response.success) {
+                        this.wssSendRestartRequired(true, true);
+                        this.wssSendRefreshRequired('plugins');
+                        this.wssSendSnackbarMessage(`Uninstalled package ${msg.response.packageName}`, 5, 'success');
+                    }
+                    else {
+                        this.wssSendSnackbarMessage(`Package ${msg.response.packageName} not uninstalled`, 10, 'error');
+                    }
+                    break;
+                default:
+                    this.log.warn(`Unknown broadcast response ${CYAN}${msg.type}${wr} from ${CYAN}${msg.src}${wr}`);
+            }
+        }
     }
     set logLevel(logLevel) {
         this.log.logLevel = logLevel;
@@ -42,15 +88,6 @@ export class Frontend extends EventEmitter {
         const upload = multer({ dest: uploadDir });
         this.expressApp = express();
         this.expressApp.use(express.static(path.join(this.matterbridge.rootDirectory, 'frontend/build')));
-        try {
-            this.log.debug(`Reading frontend package.json...`);
-            const frontendJson = await fs.readFile(path.join(this.matterbridge.rootDirectory, 'frontend/package.json'), 'utf8');
-            this.matterbridge.matterbridgeInformation.frontendVersion = JSON.parse(frontendJson)?.version;
-            this.log.debug(`Frontend version ${CYAN}${this.matterbridge.matterbridgeInformation.frontendVersion}${db}`);
-        }
-        catch (error) {
-            this.log.error(`Failed to read frontend package.json: ${error instanceof Error ? error.message : String(error)}`);
-        }
         if (!hasParameter('ssl')) {
             try {
                 this.log.debug(`Creating HTTP server...`);
@@ -195,16 +232,14 @@ export class Frontend extends EventEmitter {
                 return;
             });
         }
-        const wssPort = this.port;
-        const wssHost = hasParameter('ssl') ? `wss://${this.matterbridge.systemInformation.ipv4Address}:${wssPort}` : `ws://${this.matterbridge.systemInformation.ipv4Address}:${wssPort}`;
-        this.log.debug(`Creating WebSocketServer on host ${CYAN}${wssHost}${db}...`);
+        this.log.debug(`Creating WebSocketServer...`);
         this.webSocketServer = new WebSocketServer(hasParameter('ssl') ? { server: this.httpsServer } : { server: this.httpServer });
         this.webSocketServer.on('connection', (ws, request) => {
             const clientIp = request.socket.remoteAddress;
             let callbackLogLevel = "notice";
-            if (this.matterbridge.matterbridgeInformation.loggerLevel === "info" || this.matterbridge.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.INFO)
+            if (this.matterbridge.getLogLevel() === "info" || Logger.level === MatterLogLevel.INFO)
                 callbackLogLevel = "info";
-            if (this.matterbridge.matterbridgeInformation.loggerLevel === "debug" || this.matterbridge.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.DEBUG)
+            if (this.matterbridge.getLogLevel() === "debug" || Logger.level === MatterLogLevel.DEBUG)
                 callbackLogLevel = "debug";
             AnsiLogger.setGlobalCallback(this.wssSendLogMessage.bind(this), callbackLogLevel);
             this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
@@ -234,8 +269,8 @@ export class Frontend extends EventEmitter {
             this.log.debug(`WebSocketServer closed`);
         });
         this.webSocketServer.on('listening', () => {
-            this.log.info(`The WebSocketServer is listening on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
-            this.emit('websocket_server_listening', wssHost);
+            this.log.info(`The WebSocketServer is listening`);
+            this.emit('websocket_server_listening', hasParameter('ssl') ? 'wss' : 'ws');
         });
         this.webSocketServer.on('error', (ws, error) => {
             this.log.error(`WebSocketServer error: ${error}`);
@@ -287,22 +322,22 @@ export class Frontend extends EventEmitter {
             this.log.debug('Express received /memory');
             const memoryUsageRaw = process.memoryUsage();
             const memoryUsage = {
-                rss: this.formatMemoryUsage(memoryUsageRaw.rss),
-                heapTotal: this.formatMemoryUsage(memoryUsageRaw.heapTotal),
-                heapUsed: this.formatMemoryUsage(memoryUsageRaw.heapUsed),
-                external: this.formatMemoryUsage(memoryUsageRaw.external),
-                arrayBuffers: this.formatMemoryUsage(memoryUsageRaw.arrayBuffers),
+                rss: formatMemoryUsage(memoryUsageRaw.rss),
+                heapTotal: formatMemoryUsage(memoryUsageRaw.heapTotal),
+                heapUsed: formatMemoryUsage(memoryUsageRaw.heapUsed),
+                external: formatMemoryUsage(memoryUsageRaw.external),
+                arrayBuffers: formatMemoryUsage(memoryUsageRaw.arrayBuffers),
             };
             const { default: v8 } = await import('node:v8');
             const heapStatsRaw = v8.getHeapStatistics();
             const heapSpacesRaw = v8.getHeapSpaceStatistics();
-            const heapStats = Object.fromEntries(Object.entries(heapStatsRaw).map(([key, value]) => [key, this.formatMemoryUsage(value)]));
+            const heapStats = Object.fromEntries(Object.entries(heapStatsRaw).map(([key, value]) => [key, formatMemoryUsage(value)]));
             const heapSpaces = heapSpacesRaw.map((space) => ({
                 ...space,
-                space_size: this.formatMemoryUsage(space.space_size),
-                space_used_size: this.formatMemoryUsage(space.space_used_size),
-                space_available_size: this.formatMemoryUsage(space.space_available_size),
-                physical_space_size: this.formatMemoryUsage(space.physical_space_size),
+                space_size: formatMemoryUsage(space.space_size),
+                space_used_size: formatMemoryUsage(space.space_used_size),
+                space_available_size: formatMemoryUsage(space.space_available_size),
+                physical_space_size: formatMemoryUsage(space.physical_space_size),
             }));
             const { createRequire } = await import('node:module');
             const require = createRequire(import.meta.url);
@@ -321,12 +356,11 @@ export class Frontend extends EventEmitter {
         });
         this.expressApp.get('/api/plugins', async (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
-            res.json(this.getPlugins());
+            res.json(this.matterbridge.hasCleanupStarted ? [] : this.getPlugins());
         });
         this.expressApp.get('/api/devices', async (req, res) => {
             this.log.debug('The frontend sent /api/devices');
-            const devices = this.getDevices();
-            res.json(devices);
+            res.json(this.matterbridge.hasCleanupStarted ? [] : this.getDevices());
         });
         this.expressApp.get('/api/view-mblog', async (req, res) => {
             this.log.debug('The frontend sent /api/view-mblog');
@@ -531,7 +565,7 @@ export class Frontend extends EventEmitter {
                 this.log.info(`File ${plg}${filename}${nf} uploaded successfully`);
                 if (filename.endsWith('.tgz')) {
                     const { spawnCommand } = await import('./utils/spawn.js');
-                    await spawnCommand(this.matterbridge, 'npm', ['install', '-g', filePath, '--omit=dev', '--verbose'], filename);
+                    await spawnCommand(this.matterbridge, 'npm', ['install', '-g', filePath, '--omit=dev', '--verbose'], 'install', filename);
                     this.log.info(`Plugin package ${plg}${filename}${nf} installed successfully. Full restart required.`);
                     this.wssSendCloseSnackbarMessage(`Installing package ${filename}. Please wait...`);
                     this.wssSendSnackbarMessage(`Installed package ${filename}`, 10, 'success');
@@ -605,53 +639,49 @@ export class Frontend extends EventEmitter {
         }
         this.log.debug('Frontend stopped successfully');
     }
-    formatMemoryUsage = (bytes) => {
-        if (bytes >= 1024 ** 3) {
-            return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
-        }
-        else if (bytes >= 1024 ** 2) {
-            return `${(bytes / 1024 ** 2).toFixed(2)} MB`;
-        }
-        else {
-            return `${(bytes / 1024).toFixed(2)} KB`;
-        }
-    };
-    formatOsUpTime = (seconds) => {
-        if (seconds >= 86400) {
-            const days = Math.floor(seconds / 86400);
-            return `${days} day${days !== 1 ? 's' : ''}`;
-        }
-        if (seconds >= 3600) {
-            const hours = Math.floor(seconds / 3600);
-            return `${hours} hour${hours !== 1 ? 's' : ''}`;
-        }
-        if (seconds >= 60) {
-            const minutes = Math.floor(seconds / 60);
-            return `${minutes} minute${minutes !== 1 ? 's' : ''}`;
-        }
-        return `${seconds} second${seconds !== 1 ? 's' : ''}`;
-    };
     async getApiSettings() {
-        this.matterbridge.systemInformation.totalMemory = this.formatMemoryUsage(os.totalmem());
-        this.matterbridge.systemInformation.freeMemory = this.formatMemoryUsage(os.freemem());
-        this.matterbridge.systemInformation.systemUptime = this.formatOsUpTime(os.uptime());
-        this.matterbridge.systemInformation.processUptime = this.formatOsUpTime(Math.floor(process.uptime()));
+        this.matterbridge.systemInformation.totalMemory = formatMemoryUsage(os.totalmem());
+        this.matterbridge.systemInformation.freeMemory = formatMemoryUsage(os.freemem());
+        this.matterbridge.systemInformation.systemUptime = formatOsUpTime(os.uptime());
+        this.matterbridge.systemInformation.processUptime = formatOsUpTime(Math.floor(process.uptime()));
         this.matterbridge.systemInformation.cpuUsage = lastCpuUsage.toFixed(2) + ' %';
-        this.matterbridge.systemInformation.rss = this.formatMemoryUsage(process.memoryUsage().rss);
-        this.matterbridge.systemInformation.heapTotal = this.formatMemoryUsage(process.memoryUsage().heapTotal);
-        this.matterbridge.systemInformation.heapUsed = this.formatMemoryUsage(process.memoryUsage().heapUsed);
-        this.matterbridge.matterbridgeInformation.bridgeMode = this.matterbridge.bridgeMode;
-        this.matterbridge.matterbridgeInformation.restartMode = this.matterbridge.restartMode;
-        this.matterbridge.matterbridgeInformation.profile = this.matterbridge.profile;
-        this.matterbridge.matterbridgeInformation.loggerLevel = this.matterbridge.log.logLevel;
-        this.matterbridge.matterbridgeInformation.matterLoggerLevel = Logger.level;
-        this.matterbridge.matterbridgeInformation.matterMdnsInterface = this.matterbridge.mdnsInterface;
-        this.matterbridge.matterbridgeInformation.matterIpv4Address = this.matterbridge.ipv4address;
-        this.matterbridge.matterbridgeInformation.matterIpv6Address = this.matterbridge.ipv6address;
-        this.matterbridge.matterbridgeInformation.matterPort = (await this.matterbridge.nodeContext?.get('matterport', 5540)) ?? 5540;
-        this.matterbridge.matterbridgeInformation.matterDiscriminator = await this.matterbridge.nodeContext?.get('matterdiscriminator');
-        this.matterbridge.matterbridgeInformation.matterPasscode = await this.matterbridge.nodeContext?.get('matterpasscode');
-        return { systemInformation: this.matterbridge.systemInformation, matterbridgeInformation: this.matterbridge.matterbridgeInformation };
+        this.matterbridge.systemInformation.rss = formatMemoryUsage(process.memoryUsage().rss);
+        this.matterbridge.systemInformation.heapTotal = formatMemoryUsage(process.memoryUsage().heapTotal);
+        this.matterbridge.systemInformation.heapUsed = formatMemoryUsage(process.memoryUsage().heapUsed);
+        const info = {
+            homeDirectory: this.matterbridge.homeDirectory,
+            rootDirectory: this.matterbridge.rootDirectory,
+            matterbridgeDirectory: this.matterbridge.matterbridgeDirectory,
+            matterbridgePluginDirectory: this.matterbridge.matterbridgePluginDirectory,
+            matterbridgeCertDirectory: this.matterbridge.matterbridgeCertDirectory,
+            globalModulesDirectory: this.matterbridge.globalModulesDirectory,
+            matterbridgeVersion: this.matterbridge.matterbridgeVersion,
+            matterbridgeLatestVersion: this.matterbridge.matterbridgeLatestVersion,
+            matterbridgeDevVersion: this.matterbridge.matterbridgeDevVersion,
+            frontendVersion: this.matterbridge.frontendVersion,
+            bridgeMode: this.matterbridge.bridgeMode,
+            restartMode: this.matterbridge.restartMode,
+            virtualMode: this.matterbridge.virtualMode,
+            profile: this.matterbridge.profile,
+            readOnly: this.matterbridge.readOnly,
+            shellyBoard: this.matterbridge.shellyBoard,
+            shellySysUpdate: this.matterbridge.shellySysUpdate,
+            shellyMainUpdate: this.matterbridge.shellyMainUpdate,
+            loggerLevel: await this.matterbridge.getLogLevel(),
+            fileLogger: this.matterbridge.fileLogger,
+            matterLoggerLevel: Logger.level,
+            matterFileLogger: this.matterbridge.matterFileLogger,
+            matterMdnsInterface: this.matterbridge.mdnsInterface,
+            matterIpv4Address: this.matterbridge.ipv4Address,
+            matterIpv6Address: this.matterbridge.ipv6Address,
+            matterPort: (await this.matterbridge.nodeContext?.get('matterport', 5540)) ?? 5540,
+            matterDiscriminator: await this.matterbridge.nodeContext?.get('matterdiscriminator'),
+            matterPasscode: await this.matterbridge.nodeContext?.get('matterpasscode'),
+            restartRequired: this.matterbridge.restartRequired,
+            fixedRestartRequired: this.matterbridge.fixedRestartRequired,
+            updateRequired: this.matterbridge.updateRequired,
+        };
+        return { systemInformation: this.matterbridge.systemInformation, matterbridgeInformation: info };
     }
     getReachability(device) {
         if (!device.lifecycle.isReady || device.construction.status !== Lifecycle.Status.Active)
@@ -802,11 +832,9 @@ export class Frontend extends EventEmitter {
         return attributes.trimStart().trimEnd();
     }
     getPlugins() {
-        if (this.matterbridge.hasCleanupStarted)
-            return [];
-        const baseRegisteredPlugins = [];
-        for (const plugin of this.matterbridge.plugins) {
-            baseRegisteredPlugins.push({
+        const plugins = [];
+        for (const plugin of this.matterbridge.plugins.array()) {
+            plugins.push({
                 path: plugin.path,
                 type: plugin.type,
                 name: plugin.name,
@@ -834,11 +862,9 @@ export class Frontend extends EventEmitter {
                 matter: plugin.serverNode ? this.matterbridge.getServerNodeData(plugin.serverNode) : undefined,
             });
         }
-        return baseRegisteredPlugins;
+        return plugins;
     }
     getDevices(pluginName) {
-        if (this.matterbridge.hasCleanupStarted)
-            return [];
         const devices = [];
         for (const device of this.matterbridge.devices.array()) {
             if (pluginName && pluginName !== device.plugin)
@@ -972,95 +998,24 @@ export class Frontend extends EventEmitter {
                 }
             }
             else if (data.method === '/api/install') {
-                const localData = data;
-                if (!isValidString(data.params.packageName, 10) || !isValidBoolean(data.params.restart)) {
+                if (isValidString(data.params.packageName, 14) && isValidBoolean(data.params.restart)) {
+                    this.wssSendSnackbarMessage(`Installing package ${data.params.packageName}...`, 0);
+                    this.server.request({ type: 'plugins_install', src: this.server.name, dst: 'plugins', params: { packageName: data.params.packageName } });
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                }
+                else {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter in /api/install' });
-                    return;
                 }
-                this.wssSendSnackbarMessage(`Installing package ${data.params.packageName}...`, 0);
-                const { spawnCommand } = await import('./utils/spawn.js');
-                spawnCommand(this.matterbridge, 'npm', ['install', '-g', data.params.packageName, '--omit=dev', '--verbose'], data.params.packageName)
-                    .then((_response) => {
-                    sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: data.src, success: true });
-                    this.wssSendCloseSnackbarMessage(`Installing package ${localData.params.packageName}...`);
-                    this.wssSendSnackbarMessage(`Installed package ${localData.params.packageName}`, 5, 'success');
-                    const packageName = localData.params.packageName.replace(/@.*$/, '');
-                    if (localData.params.restart === false && packageName !== 'matterbridge') {
-                        this.matterbridge.plugins
-                            .add(packageName)
-                            .then((plugin) => {
-                            if (plugin) {
-                                this.wssSendSnackbarMessage(`Added plugin ${packageName}`, 5, 'success');
-                                if (this.matterbridge.bridgeMode === 'childbridge')
-                                    this.wssSendRestartRequired(true, true);
-                                this.matterbridge.plugins
-                                    .load(plugin, true, 'The plugin has been added', true)
-                                    .then(() => {
-                                    this.wssSendSnackbarMessage(`Started plugin ${packageName}`, 5, 'success');
-                                    this.wssSendRefreshRequired('plugins');
-                                    this.wssSendRefreshRequired('devices');
-                                    return;
-                                })
-                                    .catch((_error) => {
-                                });
-                            }
-                            else {
-                                this.matterbridge.matterbridgeInformation.fixedRestartRequired = true;
-                                this.wssSendRefreshRequired('plugins');
-                                this.wssSendRestartRequired(true, true);
-                            }
-                            return;
-                        })
-                            .catch((_error) => {
-                        });
-                    }
-                    else {
-                        this.matterbridge.matterbridgeInformation.fixedRestartRequired = true;
-                        if (this.matterbridge.restartMode !== '') {
-                            this.wssSendSnackbarMessage(`Restarting matterbridge...`, 0);
-                            this.matterbridge.shutdownProcess();
-                        }
-                        else {
-                            this.wssSendRestartRequired(true, true);
-                        }
-                    }
-                    return;
-                })
-                    .catch((error) => {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error });
-                    this.wssSendCloseSnackbarMessage(`Installing package ${localData.params.packageName}...`);
-                    this.wssSendSnackbarMessage(`Package ${localData.params.packageName} not installed`, 10, 'error');
-                });
             }
             else if (data.method === '/api/uninstall') {
-                const localData = data;
-                if (!isValidString(data.params.packageName, 10)) {
+                if (isValidString(data.params.packageName, 14)) {
+                    this.wssSendSnackbarMessage(`Uninstalling package ${data.params.packageName}...`, 0);
+                    this.server.request({ type: 'plugins_uninstall', src: this.server.name, dst: 'plugins', params: { packageName: data.params.packageName } });
+                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                }
+                else {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter packageName in /api/uninstall' });
-                    return;
                 }
-                const plugin = this.matterbridge.plugins.get(data.params.packageName);
-                if (plugin) {
-                    await this.matterbridge.plugins.shutdown(plugin, 'The plugin has been removed.', true);
-                    await this.matterbridge.plugins.remove(data.params.packageName);
-                    this.wssSendSnackbarMessage(`Removed plugin ${data.params.packageName}`, 5, 'success');
-                    this.wssSendRefreshRequired('plugins');
-                    this.wssSendRefreshRequired('devices');
-                }
-                this.wssSendSnackbarMessage(`Uninstalling package ${data.params.packageName}...`, 0);
-                const { spawnCommand } = await import('./utils/spawn.js');
-                spawnCommand(this.matterbridge, 'npm', ['uninstall', '-g', data.params.packageName, '--verbose'], data.params.packageName)
-                    .then((_response) => {
-                    sendResponse({ id: localData.id, method: localData.method, src: 'Matterbridge', dst: data.src, success: true });
-                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${localData.params.packageName}...`);
-                    this.wssSendSnackbarMessage(`Uninstalled package ${localData.params.packageName}`, 5, 'success');
-                    return;
-                })
-                    .catch((error) => {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: error instanceof Error ? error.message : error });
-                    this.wssSendCloseSnackbarMessage(`Uninstalling package ${localData.params.packageName}...`);
-                    this.wssSendSnackbarMessage(`Package ${localData.params.packageName} not uninstalled`, 10, 'error');
-                    this.wssSendSnackbarMessage(`Restart required`, 0);
-                });
             }
             else if (data.method === '/api/addplugin') {
                 const localData = data;
@@ -1333,11 +1288,11 @@ export class Frontend extends EventEmitter {
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: await this.getApiSettings() });
             }
             else if (data.method === '/api/plugins') {
-                const plugins = this.getPlugins();
+                const plugins = this.matterbridge.hasCleanupStarted ? [] : this.getPlugins();
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: plugins });
             }
             else if (data.method === '/api/devices') {
-                const devices = this.getDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
+                const devices = this.matterbridge.hasCleanupStarted ? [] : this.getDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: devices });
             }
             else if (data.method === '/api/clusters') {
@@ -1461,10 +1416,10 @@ export class Frontend extends EventEmitter {
                     case 'setmblogfile':
                         if (isValidBoolean(data.params.value)) {
                             this.log.debug('Matterbridge file log:', data.params.value);
-                            this.matterbridge.matterbridgeInformation.fileLogger = data.params.value;
+                            this.matterbridge.fileLogger = data.params.value;
                             await this.matterbridge.nodeContext?.set('matterbridgeFileLog', data.params.value);
                             if (data.params.value)
-                                AnsiLogger.setGlobalLogfile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_LOGGER_FILE), this.matterbridge.matterbridgeInformation.loggerLevel, true);
+                                AnsiLogger.setGlobalLogfile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_LOGGER_FILE), await this.matterbridge.getLogLevel(), true);
                             else
                                 AnsiLogger.setGlobalLogfile(undefined);
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
@@ -1491,7 +1446,6 @@ export class Frontend extends EventEmitter {
                             else if (data.params.value === 'Fatal') {
                                 Logger.level = MatterLogLevel.FATAL;
                             }
-                            this.matterbridge.matterbridgeInformation.matterLoggerLevel = Logger.level;
                             await this.matterbridge.nodeContext?.set('matterLogLevel', Logger.level);
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
                         }
@@ -1499,7 +1453,7 @@ export class Frontend extends EventEmitter {
                     case 'setmjlogfile':
                         if (isValidBoolean(data.params.value)) {
                             this.log.debug('Matter file log:', data.params.value);
-                            this.matterbridge.matterbridgeInformation.matterFileLogger = data.params.value;
+                            this.matterbridge.fileLogger = data.params.value;
                             await this.matterbridge.nodeContext?.set('matterFileLog', data.params.value);
                             if (data.params.value) {
                                 this.matterbridge.matterLog.logFilePath = path.join(this.matterbridge.matterbridgeDirectory, MATTER_LOGGER_FILE);
@@ -1514,86 +1468,92 @@ export class Frontend extends EventEmitter {
                         if (isValidString(data.params.value)) {
                             this.log.debug(`Matter.js mdns interface: ${data.params.value === '' ? 'all interfaces' : data.params.value}`);
                             this.matterbridge.mdnsInterface = data.params.value === '' ? undefined : data.params.value;
-                            this.matterbridge.matterbridgeInformation.matterMdnsInterface = this.matterbridge.mdnsInterface;
                             await this.matterbridge.nodeContext?.set('mattermdnsinterface', data.params.value);
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                            this.wssSendSnackbarMessage(`Mdns interface changed to ${data.params.value === '' ? 'all interfaces' : data.params.value}`);
                         }
                         break;
                     case 'setipv4address':
                         if (isValidString(data.params.value)) {
                             this.log.debug(`Matter.js ipv4 address: ${data.params.value === '' ? 'all ipv4 addresses' : data.params.value}`);
-                            this.matterbridge.ipv4address = data.params.value === '' ? undefined : data.params.value;
-                            this.matterbridge.matterbridgeInformation.matterIpv4Address = this.matterbridge.ipv4address;
+                            this.matterbridge.ipv4Address = data.params.value === '' ? undefined : data.params.value;
                             await this.matterbridge.nodeContext?.set('matteripv4address', data.params.value);
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                            this.wssSendSnackbarMessage(`IPv4 address changed to ${data.params.value === '' ? 'all ipv4 addresses' : data.params.value}`);
                         }
                         break;
                     case 'setipv6address':
                         if (isValidString(data.params.value)) {
                             this.log.debug(`Matter.js ipv6 address: ${data.params.value === '' ? 'all ipv6 addresses' : data.params.value}`);
-                            this.matterbridge.ipv6address = data.params.value === '' ? undefined : data.params.value;
-                            this.matterbridge.matterbridgeInformation.matterIpv6Address = this.matterbridge.ipv6address;
+                            this.matterbridge.ipv6Address = data.params.value === '' ? undefined : data.params.value;
                             await this.matterbridge.nodeContext?.set('matteripv6address', data.params.value);
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                            this.wssSendSnackbarMessage(`IPv6 address changed to ${data.params.value === '' ? 'all ipv6 addresses' : data.params.value}`);
                         }
                         break;
                     case 'setmatterport':
                         const port = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
                         if (isValidNumber(port, 5540, 5600)) {
                             this.log.debug(`Set matter commissioning port to ${CYAN}${port}${db}`);
-                            this.matterbridge.matterbridgeInformation.matterPort = port;
+                            this.matterbridge.port = port;
                             await this.matterbridge.nodeContext?.set('matterport', port);
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                            this.wssSendSnackbarMessage(`Matter port changed to ${port}`);
                         }
                         else {
                             this.log.debug(`Reset matter commissioning port to ${CYAN}5540${db}`);
-                            this.matterbridge.matterbridgeInformation.matterPort = 5540;
+                            this.matterbridge.port = 5540;
                             await this.matterbridge.nodeContext?.set('matterport', 5540);
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid value: reset matter commissioning port to default 5540' });
+                            this.wssSendSnackbarMessage(`Matter port reset to default 5540`, undefined, 'error');
                         }
                         break;
                     case 'setmatterdiscriminator':
                         const discriminator = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
                         if (isValidNumber(discriminator, 0, 4095)) {
                             this.log.debug(`Set matter commissioning discriminator to ${CYAN}${discriminator}${db}`);
-                            this.matterbridge.matterbridgeInformation.matterDiscriminator = discriminator;
+                            this.matterbridge.discriminator = discriminator;
                             await this.matterbridge.nodeContext?.set('matterdiscriminator', discriminator);
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                            this.wssSendSnackbarMessage(`Matter discriminator changed to ${discriminator}`);
                         }
                         else {
                             this.log.debug(`Reset matter commissioning discriminator to ${CYAN}undefined${db}`);
-                            this.matterbridge.matterbridgeInformation.matterDiscriminator = undefined;
+                            this.matterbridge.discriminator = undefined;
                             await this.matterbridge.nodeContext?.remove('matterdiscriminator');
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid value: reset matter commissioning discriminator to default undefined' });
+                            this.wssSendSnackbarMessage(`Matter discriminator reset to default`, undefined, 'error');
                         }
                         break;
                     case 'setmatterpasscode':
                         const passcode = isValidString(data.params.value) ? parseInt(data.params.value) : 0;
                         if (isValidNumber(passcode, 1, 99999998) && CommissioningOptions.FORBIDDEN_PASSCODES.includes(passcode) === false) {
-                            this.matterbridge.matterbridgeInformation.matterPasscode = passcode;
+                            this.matterbridge.passcode = passcode;
                             this.log.debug(`Set matter commissioning passcode to ${CYAN}${passcode}${db}`);
                             await this.matterbridge.nodeContext?.set('matterpasscode', passcode);
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
+                            this.wssSendSnackbarMessage(`Matter passcode changed to ${passcode}`);
                         }
                         else {
                             this.log.debug(`Reset matter commissioning passcode to ${CYAN}undefined${db}`);
-                            this.matterbridge.matterbridgeInformation.matterPasscode = undefined;
+                            this.matterbridge.passcode = undefined;
                             await this.matterbridge.nodeContext?.remove('matterpasscode');
                             this.wssSendRestartRequired();
                             sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid value: reset matter commissioning passcode to default undefined' });
+                            this.wssSendSnackbarMessage(`Matter passcode reset to default`, undefined, 'error');
                         }
                         break;
                     case 'setvirtualmode':
                         if (isValidString(data.params.value, 1) && ['disabled', 'light', 'outlet', 'switch', 'mounted_switch'].includes(data.params.value)) {
-                            this.matterbridge.matterbridgeInformation.virtualMode = data.params.value;
+                            this.matterbridge.virtualMode = data.params.value;
                             this.log.debug(`Set matterbridge virtual mode to ${CYAN}${data.params.value}${db}`);
                             await this.matterbridge.nodeContext?.set('virtualmode', data.params.value);
                             this.wssSendRestartRequired();
@@ -1740,22 +1700,22 @@ export class Frontend extends EventEmitter {
     }
     wssSendRestartRequired(snackbar = true, fixed = false) {
         this.log.debug('Sending a restart required message to all connected clients');
-        this.matterbridge.matterbridgeInformation.restartRequired = true;
-        this.matterbridge.matterbridgeInformation.fixedRestartRequired = fixed;
+        this.matterbridge.restartRequired = true;
+        this.matterbridge.fixedRestartRequired = fixed;
         if (snackbar === true)
             this.wssSendSnackbarMessage(`Restart required`, 0);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
     }
     wssSendRestartNotRequired(snackbar = true) {
         this.log.debug('Sending a restart not required message to all connected clients');
-        this.matterbridge.matterbridgeInformation.restartRequired = false;
+        this.matterbridge.restartRequired = false;
         if (snackbar === true)
             this.wssSendCloseSnackbarMessage(`Restart required`);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
     }
     wssSendUpdateRequired(devVersion = false) {
         this.log.debug('Sending an update required message to all connected clients');
-        this.matterbridge.matterbridgeInformation.updateRequired = true;
+        this.matterbridge.updateRequired = true;
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { devVersion } });
     }
     wssSendCpuUpdate(cpuUsage) {

package/dist/helpers.js

@@ -45,15 +45,15 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
     return device;
 }
 export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
-    if (matterbridge.matterbridgeInformation.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
+    if (matterbridge.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
         matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);
-        await addVirtualDevice(aggregatorEndpoint, 'Restart Matterbridge', matterbridge.matterbridgeInformation.virtualMode, async () => {
+        await addVirtualDevice(aggregatorEndpoint, 'Restart Matterbridge', matterbridge.virtualMode, async () => {
             if (matterbridge.restartMode === '')
                 await matterbridge.restartProcess();
             else
                 await matterbridge.shutdownProcess();
         });
-        await addVirtualDevice(aggregatorEndpoint, 'Update Matterbridge', matterbridge.matterbridgeInformation.virtualMode, async () => {
+        await addVirtualDevice(aggregatorEndpoint, 'Update Matterbridge', matterbridge.virtualMode, async () => {
             if (hasParameter('shelly')) {
                 const { getShelly } = await import('./shelly.js');
                 getShelly('/api/updates/sys/perform', 10 * 1000)
@@ -78,7 +78,7 @@ export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
             }
         });
         if (hasParameter('shelly')) {
-            await addVirtualDevice(aggregatorEndpoint, 'Reboot Matterbridge', matterbridge.matterbridgeInformation.virtualMode, async () => {
+            await addVirtualDevice(aggregatorEndpoint, 'Reboot Matterbridge', matterbridge.virtualMode, async () => {
                 const { postShelly } = await import('./shelly.js');
                 postShelly('/api/system/reboot', {}, 60 * 1000)
                     .then(() => {

package/dist/index.js

@@ -1,6 +1,3 @@
-import { AnsiLogger } from 'node-ansi-logger';
-import { Matterbridge } from './matterbridge.js';
-import { hasParameter } from './utils/commandLine.js';
 export * from './matterbridge.js';
 export * from './matterbridgeTypes.js';
 export * from './matterbridgeEndpoint.js';
@@ -11,12 +8,3 @@ export * from './matterbridgePlatform.js';
 export * from './matterbridgeAccessoryPlatform.js';
 export * from './matterbridgeDynamicPlatform.js';
 export { addVirtualDevice } from './helpers.js';
-const log = new AnsiLogger({ logName: 'Main', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
-async function main() {
-    log.debug('***Matterbridge.loadInstance() called');
-    await Matterbridge.loadInstance();
-    log.debug('***Matterbridge.loadInstance() exited');
-}
-main().catch((error) => {
-    log.error(`Matterbridge.loadInstance() failed with error: ${error instanceof Error ? error.message : error}`);
-});