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

package/dist/matterbridge.js

@@ -9,9 +9,13 @@ import { DeviceTypeId, Endpoint, Logger, LogLevel as MatterLogLevel, LogFormat a
 import { FabricAction, MdnsService, PaseClient } from '@matter/main/protocol';
 import { AggregatorEndpoint } from '@matter/main/endpoints';
 import { BasicInformationServer } from '@matter/main/behaviors/basic-information';
-import { getParameter, getIntParameter, hasParameter, copyDirectory, isValidString, parseVersionString, isValidNumber, createDirectory } from './utils/export.js';
+import { getParameter, getIntParameter, hasParameter } from './utils/commandLine.js';
+import { copyDirectory } from './utils/copyDirectory.js';
+import { createDirectory } from './utils/createDirectory.js';
+import { isValidString, parseVersionString, isValidNumber } from './utils/isvalid.js';
+import { formatMemoryUsage, formatOsUpTime } from './utils/network.js';
 import { withTimeout, waiter, wait } from './utils/wait.js';
-import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, typ, } from './matterbridgeTypes.js';
+import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_NAME, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, typ } from './matterbridgeTypes.js';
 import { PluginManager } from './pluginManager.js';
 import { DeviceManager } from './deviceManager.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
@@ -40,38 +44,6 @@ export class Matterbridge extends EventEmitter {
         heapTotal: '',
         heapUsed: '',
     };
-    matterbridgeInformation = {
-        homeDirectory: '',
-        rootDirectory: '',
-        matterbridgeDirectory: '',
-        matterbridgePluginDirectory: '',
-        matterbridgeCertDirectory: '',
-        globalModulesDirectory: '',
-        matterbridgeVersion: '',
-        matterbridgeLatestVersion: '',
-        matterbridgeDevVersion: '',
-        bridgeMode: '',
-        restartMode: '',
-        virtualMode: 'outlet',
-        readOnly: hasParameter('readonly') || hasParameter('shelly'),
-        shellyBoard: hasParameter('shelly'),
-        shellySysUpdate: false,
-        shellyMainUpdate: false,
-        profile: getParameter('profile'),
-        loggerLevel: "info",
-        fileLogger: false,
-        matterLoggerLevel: MatterLogLevel.INFO,
-        matterFileLogger: false,
-        matterMdnsInterface: undefined,
-        matterIpv4Address: undefined,
-        matterIpv6Address: undefined,
-        matterPort: 5540,
-        matterDiscriminator: undefined,
-        matterPasscode: undefined,
-        restartRequired: false,
-        fixedRestartRequired: false,
-        updateRequired: false,
-    };
     homeDirectory = '';
     rootDirectory = '';
     matterbridgeDirectory = '';
@@ -81,18 +53,30 @@ export class Matterbridge extends EventEmitter {
     matterbridgeVersion = '';
     matterbridgeLatestVersion = '';
     matterbridgeDevVersion = '';
+    frontendVersion = '';
     bridgeMode = '';
     restartMode = '';
+    virtualMode = 'outlet';
     profile = getParameter('profile');
-    shutdown = false;
-    failCountLimit = hasParameter('shelly') ? 600 : 120;
     log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
+    fileLogger = false;
     matterLog = new AnsiLogger({ logName: 'Matter', logTimestampFormat: 4, logLevel: "debug" });
+    matterFileLogger = false;
+    readOnly = hasParameter('readonly') || hasParameter('shelly');
+    shellyBoard = hasParameter('shelly');
+    shellySysUpdate = false;
+    shellyMainUpdate = false;
+    restartRequired = false;
+    fixedRestartRequired = false;
+    updateRequired = false;
     plugins = new PluginManager(this);
-    devices = new DeviceManager(this);
+    devices = new DeviceManager();
     frontend = new Frontend(this);
     nodeStorage;
     nodeContext;
+    static instance;
+    shutdown = false;
+    failCountLimit = hasParameter('shelly') ? 600 : 120;
     hasCleanupStarted = false;
     initialized = false;
     startMatterInterval;
@@ -111,8 +95,8 @@ export class Matterbridge extends EventEmitter {
     matterbridgeContext;
     controllerContext;
     mdnsInterface;
-    ipv4address;
-    ipv6address;
+    ipv4Address;
+    ipv6Address;
     port;
     passcode;
     discriminator;
@@ -127,35 +111,10 @@ export class Matterbridge extends EventEmitter {
     aggregatorSerialNumber = getParameter('serialNumber');
     aggregatorUniqueId = getParameter('uniqueId');
     advertisingNodes = new Map();
-    static instance;
     constructor() {
         super();
         this.log.logNameColor = '\x1b[38;5;115m';
     }
-    async setLogLevel(logLevel) {
-        if (this.log)
-            this.log.logLevel = logLevel;
-        this.matterbridgeInformation.loggerLevel = logLevel;
-        this.frontend.logLevel = logLevel;
-        MatterbridgeEndpoint.logLevel = logLevel;
-        if (this.devices)
-            this.devices.logLevel = logLevel;
-        if (this.plugins)
-            this.plugins.logLevel = logLevel;
-        for (const plugin of this.plugins) {
-            if (!plugin.platform || !plugin.platform.log || !plugin.platform.config)
-                continue;
-            plugin.platform.log.logLevel = plugin.platform.config.debug === true ? "debug" : this.log.logLevel;
-            await plugin.platform.onChangeLoggerLevel(plugin.platform.config.debug === true ? "debug" : this.log.logLevel);
-        }
-        let callbackLogLevel = "notice";
-        if (this.matterbridgeInformation.loggerLevel === "info" || this.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.INFO)
-            callbackLogLevel = "info";
-        if (this.matterbridgeInformation.loggerLevel === "debug" || this.matterbridgeInformation.matterLoggerLevel === MatterLogLevel.DEBUG)
-            callbackLogLevel = "debug";
-        AnsiLogger.setGlobalCallback(this.frontend.wssSendLogMessage.bind(this.frontend), callbackLogLevel);
-        this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
-    }
     static async loadInstance(initialize = false) {
         if (!Matterbridge.instance) {
             if (hasParameter('debug'))
@@ -203,23 +162,18 @@ export class Matterbridge extends EventEmitter {
         if (hasParameter('docker'))
             this.restartMode = 'docker';
         this.homeDirectory = getParameter('homedir') ?? os.homedir();
-        this.matterbridgeInformation.homeDirectory = this.homeDirectory;
         await createDirectory(this.homeDirectory, 'Matterbridge Home Directory', this.log);
         this.matterbridgeDirectory = this.profile ? path.join(this.homeDirectory, '.matterbridge', 'profiles', this.profile) : path.join(this.homeDirectory, '.matterbridge');
-        this.matterbridgeInformation.matterbridgeDirectory = this.matterbridgeDirectory;
         await createDirectory(this.matterbridgeDirectory, 'Matterbridge Directory', this.log);
         await createDirectory(path.join(this.matterbridgeDirectory, 'certs'), 'Matterbridge Frontend Certificate Directory', this.log);
         await createDirectory(path.join(this.matterbridgeDirectory, 'uploads'), 'Matterbridge Frontend Uploads Directory', this.log);
         this.matterbridgePluginDirectory = this.profile ? path.join(this.homeDirectory, 'Matterbridge', 'profiles', this.profile) : path.join(this.homeDirectory, 'Matterbridge');
-        this.matterbridgeInformation.matterbridgePluginDirectory = this.matterbridgePluginDirectory;
         await createDirectory(this.matterbridgePluginDirectory, 'Matterbridge Plugin Directory', this.log);
         this.matterbridgeCertDirectory = this.profile ? path.join(this.homeDirectory, '.mattercert', 'profiles', this.profile) : path.join(this.homeDirectory, '.mattercert');
-        this.matterbridgeInformation.matterbridgeCertDirectory = this.matterbridgeCertDirectory;
         await createDirectory(this.matterbridgeCertDirectory, 'Matterbridge Matter Certificate Directory', this.log);
         const { fileURLToPath } = await import('node:url');
         const currentFileDirectory = path.dirname(fileURLToPath(import.meta.url));
         this.rootDirectory = path.resolve(currentFileDirectory, '../');
-        this.matterbridgeInformation.rootDirectory = this.rootDirectory;
         this.environment.vars.set('log.level', MatterLogLevel.INFO);
         this.environment.vars.set('log.format', MatterLogFormat.ANSI);
         this.environment.vars.set('path.root', path.join(this.matterbridgeDirectory, MATTER_STORAGE_NAME));
@@ -349,17 +303,16 @@ export class Matterbridge extends EventEmitter {
             }
         }
         else {
-            this.log.logLevel = await this.nodeContext.get('matterbridgeLogLevel', this.matterbridgeInformation.shellyBoard ? "notice" : "info");
+            this.log.logLevel = await this.nodeContext.get('matterbridgeLogLevel', this.shellyBoard ? "notice" : "info");
         }
         this.frontend.logLevel = this.log.logLevel;
         MatterbridgeEndpoint.logLevel = this.log.logLevel;
-        this.matterbridgeInformation.loggerLevel = this.log.logLevel;
         if (hasParameter('filelogger') || (await this.nodeContext.get('matterbridgeFileLog', false))) {
             AnsiLogger.setGlobalLogfile(path.join(this.matterbridgeDirectory, MATTERBRIDGE_LOGGER_FILE), this.log.logLevel, true);
-            this.matterbridgeInformation.fileLogger = true;
+            this.fileLogger = true;
         }
         this.log.notice('Matterbridge is starting...');
-        this.log.debug(`Matterbridge logLevel: ${this.log.logLevel} fileLoger: ${this.matterbridgeInformation.fileLogger}.`);
+        this.log.debug(`Matterbridge logLevel: ${this.log.logLevel} fileLoger: ${this.fileLogger}.`);
         if (this.profile !== undefined)
             this.log.debug(`Matterbridge profile: ${this.profile}.`);
         if (hasParameter('matterlogger')) {
@@ -388,18 +341,17 @@ export class Matterbridge extends EventEmitter {
             }
         }
         else {
-            Logger.level = (await this.nodeContext.get('matterLogLevel', this.matterbridgeInformation.shellyBoard ? MatterLogLevel.NOTICE : MatterLogLevel.INFO));
+            Logger.level = (await this.nodeContext.get('matterLogLevel', this.shellyBoard ? MatterLogLevel.NOTICE : MatterLogLevel.INFO));
         }
         Logger.format = MatterLogFormat.ANSI;
         if (hasParameter('matterfilelogger') || (await this.nodeContext.get('matterFileLog', false))) {
-            this.matterbridgeInformation.matterFileLogger = true;
+            this.matterFileLogger = true;
         }
-        Logger.destinations.default.write = this.createDestinationMatterLogger(this.matterbridgeInformation.matterFileLogger);
-        this.matterbridgeInformation.matterLoggerLevel = Logger.level;
-        this.log.debug(`Matter logLevel: ${Logger.level} fileLoger: ${this.matterbridgeInformation.matterFileLogger}.`);
+        Logger.destinations.default.write = this.createDestinationMatterLogger(this.matterFileLogger);
+        this.log.debug(`Matter logLevel: ${Logger.level} fileLoger: ${this.matterFileLogger}.`);
         const networkInterfaces = os.networkInterfaces();
         const availableAddresses = Object.entries(networkInterfaces);
-        const availableInterfaces = Object.keys(networkInterfaces);
+        const availableInterfaceNames = Object.keys(networkInterfaces);
         for (const [ifaceName, ifaces] of availableAddresses) {
             if (ifaces && ifaces.length > 0) {
                 this.log.debug(`Network interface ${BLUE}${ifaceName}${db}:`);
@@ -418,8 +370,8 @@ export class Matterbridge extends EventEmitter {
                 this.mdnsInterface = undefined;
         }
         if (this.mdnsInterface) {
-            if (!availableInterfaces.includes(this.mdnsInterface)) {
-                this.log.error(`Invalid mdnsinterface: ${this.mdnsInterface}. Available interfaces are: ${availableInterfaces.join(', ')}. Using all available interfaces.`);
+            if (!availableInterfaceNames.includes(this.mdnsInterface)) {
+                this.log.error(`Invalid mdnsinterface: ${this.mdnsInterface}. Available interfaces are: ${availableInterfaceNames.join(', ')}. Using all available interfaces.`);
                 this.mdnsInterface = undefined;
                 await this.nodeContext.remove('mattermdnsinterface');
             }
@@ -430,64 +382,64 @@ export class Matterbridge extends EventEmitter {
         if (this.mdnsInterface)
             this.environment.vars.set('mdns.networkInterface', this.mdnsInterface);
         if (hasParameter('ipv4address')) {
-            this.ipv4address = getParameter('ipv4address');
+            this.ipv4Address = getParameter('ipv4address');
         }
         else {
-            this.ipv4address = await this.nodeContext.get('matteripv4address', undefined);
-            if (this.ipv4address === '')
-                this.ipv4address = undefined;
+            this.ipv4Address = await this.nodeContext.get('matteripv4address', undefined);
+            if (this.ipv4Address === '')
+                this.ipv4Address = undefined;
         }
-        if (this.ipv4address) {
+        if (this.ipv4Address) {
             let isValid = false;
             for (const [ifaceName, ifaces] of availableAddresses) {
-                if (ifaces && ifaces.find((iface) => iface.address === this.ipv4address)) {
-                    this.log.info(`Using ipv4address ${CYAN}${this.ipv4address}${nf} on interface ${CYAN}${ifaceName}${nf} for the Matter server node.`);
+                if (ifaces && ifaces.find((iface) => iface.address === this.ipv4Address)) {
+                    this.log.info(`Using ipv4address ${CYAN}${this.ipv4Address}${nf} on interface ${CYAN}${ifaceName}${nf} for the Matter server node.`);
                     isValid = true;
                     break;
                 }
             }
             if (!isValid) {
-                this.log.error(`Invalid ipv4address: ${this.ipv4address}. Using all available addresses.`);
-                this.ipv4address = undefined;
+                this.log.error(`Invalid ipv4address: ${this.ipv4Address}. Using all available addresses.`);
+                this.ipv4Address = undefined;
                 await this.nodeContext.remove('matteripv4address');
             }
         }
         if (hasParameter('ipv6address')) {
-            this.ipv6address = getParameter('ipv6address');
+            this.ipv6Address = getParameter('ipv6address');
         }
         else {
-            this.ipv6address = await this.nodeContext?.get('matteripv6address', undefined);
-            if (this.ipv6address === '')
-                this.ipv6address = undefined;
+            this.ipv6Address = await this.nodeContext?.get('matteripv6address', undefined);
+            if (this.ipv6Address === '')
+                this.ipv6Address = undefined;
         }
-        if (this.ipv6address) {
+        if (this.ipv6Address) {
             let isValid = false;
             for (const [ifaceName, ifaces] of availableAddresses) {
-                if (ifaces && ifaces.find((iface) => (iface.scopeid === undefined || iface.scopeid === 0) && iface.address === this.ipv6address)) {
-                    this.log.info(`Using ipv6address ${CYAN}${this.ipv6address}${nf} on interface ${CYAN}${ifaceName}${nf} for the Matter server node.`);
+                if (ifaces && ifaces.find((iface) => (iface.scopeid === undefined || iface.scopeid === 0) && iface.address === this.ipv6Address)) {
+                    this.log.info(`Using ipv6address ${CYAN}${this.ipv6Address}${nf} on interface ${CYAN}${ifaceName}${nf} for the Matter server node.`);
                     isValid = true;
                     break;
                 }
-                if (ifaces && ifaces.find((iface) => iface.scopeid && iface.scopeid > 0 && iface.address + '%' + (process.platform === 'win32' ? iface.scopeid : ifaceName) === this.ipv6address)) {
-                    this.log.info(`Using ipv6address ${CYAN}${this.ipv6address}${nf} on interface ${CYAN}${ifaceName}${nf} for the Matter server node.`);
+                if (ifaces && ifaces.find((iface) => iface.scopeid && iface.scopeid > 0 && iface.address + '%' + (process.platform === 'win32' ? iface.scopeid : ifaceName) === this.ipv6Address)) {
+                    this.log.info(`Using ipv6address ${CYAN}${this.ipv6Address}${nf} on interface ${CYAN}${ifaceName}${nf} for the Matter server node.`);
                     isValid = true;
                     break;
                 }
             }
             if (!isValid) {
-                this.log.error(`Invalid ipv6address: ${this.ipv6address}. Using all available addresses.`);
-                this.ipv6address = undefined;
+                this.log.error(`Invalid ipv6address: ${this.ipv6Address}. Using all available addresses.`);
+                this.ipv6Address = undefined;
                 await this.nodeContext.remove('matteripv6address');
             }
         }
         if (hasParameter('novirtual')) {
-            this.matterbridgeInformation.virtualMode = 'disabled';
+            this.virtualMode = 'disabled';
             await this.nodeContext.set('virtualmode', 'disabled');
         }
         else {
-            this.matterbridgeInformation.virtualMode = (await this.nodeContext.get('virtualmode', 'outlet'));
+            this.virtualMode = (await this.nodeContext.get('virtualmode', 'outlet'));
         }
-        this.log.debug(`Virtual mode ${this.matterbridgeInformation.virtualMode}.`);
+        this.log.debug(`Virtual mode ${this.virtualMode}.`);
         this.plugins.logLevel = this.log.logLevel;
         await this.plugins.loadFromStorage();
         this.devices.logLevel = this.log.logLevel;
@@ -497,7 +449,7 @@ export class Matterbridge extends EventEmitter {
                 this.log.info(`Error parsing plugin ${plg}${plugin.name}${nf}. Trying to reinstall it from npm.`);
                 try {
                     const { spawnCommand } = await import('./utils/spawn.js');
-                    await spawnCommand(this, 'npm', ['install', '-g', plugin.name, '--omit=dev', '--verbose'], plugin.name);
+                    await spawnCommand(this, 'npm', ['install', '-g', plugin.name, '--omit=dev', '--verbose'], 'install', plugin.name);
                     this.log.info(`Plugin ${plg}${plugin.name}${nf} reinstalled.`);
                     plugin.error = false;
                 }
@@ -801,6 +753,7 @@ export class Matterbridge extends EventEmitter {
         this.systemInformation.interfaceName = '';
         this.systemInformation.ipv4Address = '';
         this.systemInformation.ipv6Address = '';
+        this.systemInformation.macAddress = '';
         for (const [interfaceName, interfaceDetails] of Object.entries(networkInterfaces)) {
             if (this.mdnsInterface && interfaceName !== this.mdnsInterface)
                 continue;
@@ -837,9 +790,14 @@ export class Matterbridge extends EventEmitter {
         this.systemInformation.osRelease = os.release();
         this.systemInformation.osPlatform = os.platform();
         this.systemInformation.osArch = os.arch();
-        this.systemInformation.totalMemory = (os.totalmem() / 1024 / 1024 / 1024).toFixed(2) + ' GB';
-        this.systemInformation.freeMemory = (os.freemem() / 1024 / 1024 / 1024).toFixed(2) + ' GB';
-        this.systemInformation.systemUptime = (os.uptime() / 60 / 60).toFixed(2) + ' hours';
+        this.systemInformation.totalMemory = formatMemoryUsage(os.totalmem());
+        this.systemInformation.freeMemory = formatMemoryUsage(os.freemem());
+        this.systemInformation.systemUptime = formatOsUpTime(os.uptime());
+        this.systemInformation.processUptime = formatOsUpTime(Math.floor(process.uptime()));
+        this.systemInformation.cpuUsage = '0.00 %';
+        this.systemInformation.rss = formatMemoryUsage(process.memoryUsage().rss);
+        this.systemInformation.heapTotal = formatMemoryUsage(process.memoryUsage().heapTotal);
+        this.systemInformation.heapUsed = formatMemoryUsage(process.memoryUsage().heapUsed);
         this.log.debug('Host System Information:');
         this.log.debug(`- Hostname: ${this.systemInformation.hostname}`);
         this.log.debug(`- User: ${this.systemInformation.user}`);
@@ -855,18 +813,22 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`- Total Memory: ${this.systemInformation.totalMemory}`);
         this.log.debug(`- Free Memory: ${this.systemInformation.freeMemory}`);
         this.log.debug(`- System Uptime: ${this.systemInformation.systemUptime}`);
+        this.log.debug(`- Process Uptime: ${this.systemInformation.processUptime}`);
+        this.log.debug(`- RSS: ${this.systemInformation.rss}`);
+        this.log.debug(`- Heap Total: ${this.systemInformation.heapTotal}`);
+        this.log.debug(`- Heap Used: ${this.systemInformation.heapUsed}`);
         this.log.debug(`Root Directory: ${this.rootDirectory}`);
         this.log.debug(`Home Directory: ${this.homeDirectory}`);
         this.log.debug(`Matterbridge Directory: ${this.matterbridgeDirectory}`);
         this.log.debug(`Matterbridge Plugin Directory: ${this.matterbridgePluginDirectory}`);
         this.log.debug(`Matterbridge Matter Certificate Directory: ${this.matterbridgeCertDirectory}`);
         if (this.nodeContext)
-            this.globalModulesDirectory = this.matterbridgeInformation.globalModulesDirectory = await this.nodeContext.get('globalModulesDirectory', '');
+            this.globalModulesDirectory = await this.nodeContext.get('globalModulesDirectory', '');
         if (this.globalModulesDirectory === '') {
             this.log.debug(`Getting global node_modules directory...`);
             try {
                 const { getGlobalNodeModules } = await import('./utils/network.js');
-                this.matterbridgeInformation.globalModulesDirectory = this.globalModulesDirectory = await getGlobalNodeModules();
+                this.globalModulesDirectory = await getGlobalNodeModules();
                 this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
                 await this.nodeContext?.set('globalModulesDirectory', this.globalModulesDirectory);
             }
@@ -878,7 +840,7 @@ export class Matterbridge extends EventEmitter {
             this.log.debug(`Checking global node_modules directory: ${this.globalModulesDirectory}`);
             try {
                 const { getGlobalNodeModules } = await import('./utils/network.js');
-                this.matterbridgeInformation.globalModulesDirectory = this.globalModulesDirectory = await getGlobalNodeModules();
+                this.globalModulesDirectory = await getGlobalNodeModules();
                 this.log.debug(`Global node_modules Directory: ${this.globalModulesDirectory}`);
                 await this.nodeContext?.set('globalModulesDirectory', this.globalModulesDirectory);
             }
@@ -886,21 +848,51 @@ export class Matterbridge extends EventEmitter {
                 this.log.error(`Error checking global node_modules directory: ${error}`);
             }
         }
+        this.log.debug(`Reading matterbridge package.json...`);
         const packageJson = JSON.parse(await fs.readFile(path.join(this.rootDirectory, 'package.json'), 'utf-8'));
         this.matterbridgeVersion = this.matterbridgeLatestVersion = this.matterbridgeDevVersion = packageJson.version;
-        this.matterbridgeInformation.matterbridgeVersion = this.matterbridgeInformation.matterbridgeLatestVersion = this.matterbridgeInformation.matterbridgeDevVersion = packageJson.version;
         this.log.debug(`Matterbridge Version: ${this.matterbridgeVersion}`);
         if (this.nodeContext)
-            this.matterbridgeLatestVersion = this.matterbridgeInformation.matterbridgeLatestVersion = await this.nodeContext.get('matterbridgeLatestVersion', this.matterbridgeVersion);
+            this.matterbridgeLatestVersion = await this.nodeContext.get('matterbridgeLatestVersion', this.matterbridgeVersion);
         this.log.debug(`Matterbridge Latest Version: ${this.matterbridgeLatestVersion}`);
         if (this.nodeContext)
-            this.matterbridgeDevVersion = this.matterbridgeInformation.matterbridgeDevVersion = await this.nodeContext.get('matterbridgeDevVersion', this.matterbridgeVersion);
+            this.matterbridgeDevVersion = await this.nodeContext.get('matterbridgeDevVersion', this.matterbridgeVersion);
         this.log.debug(`Matterbridge Dev Version: ${this.matterbridgeDevVersion}`);
+        this.log.debug(`Reading frontend package.json...`);
+        const frontendPackageJson = JSON.parse(await fs.readFile(path.join(this.rootDirectory, 'frontend/package.json'), 'utf8'));
+        this.frontendVersion = frontendPackageJson.version;
+        this.log.debug(`Frontend version ${CYAN}${this.frontendVersion}${db}`);
         const currentDir = process.cwd();
         this.log.debug(`Current Working Directory: ${currentDir}`);
         const cmdArgs = process.argv.slice(2).join(' ');
         this.log.debug(`Command Line Arguments: ${cmdArgs}`);
     }
+    async setLogLevel(logLevel) {
+        if (this.log)
+            this.log.logLevel = logLevel;
+        this.frontend.logLevel = logLevel;
+        MatterbridgeEndpoint.logLevel = logLevel;
+        if (this.devices)
+            this.devices.logLevel = logLevel;
+        if (this.plugins)
+            this.plugins.logLevel = logLevel;
+        for (const plugin of this.plugins) {
+            if (!plugin.platform || !plugin.platform.log || !plugin.platform.config)
+                continue;
+            plugin.platform.log.logLevel = plugin.platform.config.debug === true ? "debug" : this.log.logLevel;
+            await plugin.platform.onChangeLoggerLevel(plugin.platform.config.debug === true ? "debug" : this.log.logLevel);
+        }
+        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.frontend.wssSendLogMessage.bind(this.frontend), callbackLogLevel);
+        this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
+    }
+    getLogLevel() {
+        return this.log.logLevel;
+    }
     createDestinationMatterLogger(fileLogger) {
         this.matterLog.logNameColor = '\x1b[34m';
         if (fileLogger) {
@@ -942,7 +934,7 @@ export class Matterbridge extends EventEmitter {
         this.log.info('Updating matterbridge...');
         try {
             const { spawnCommand } = await import('./utils/spawn.js');
-            await spawnCommand(this, 'npm', ['install', '-g', 'matterbridge', '--omit=dev', '--verbose'], 'matterbridge');
+            await spawnCommand(this, 'npm', ['install', '-g', 'matterbridge', '--omit=dev', '--verbose'], 'install', 'matterbridge');
             this.log.info('Matterbridge has been updated. Full restart required.');
         }
         catch (error) {
@@ -1066,6 +1058,9 @@ export class Matterbridge extends EventEmitter {
             }
             await this.stopMatterStorage();
             await this.frontend.stop();
+            this.frontend.destroy();
+            this.plugins.destroy();
+            this.devices.destroy();
             if (this.nodeStorage && this.nodeContext) {
                 this.log.debug(`Closing node storage context for ${plg}Matterbridge${db}...`);
                 await this.nodeContext.close();
@@ -1400,8 +1395,8 @@ export class Matterbridge extends EventEmitter {
         const serverNode = await ServerNode.create({
             id: storeId,
             network: {
-                listeningAddressIpv4: this.ipv4address,
-                listeningAddressIpv6: this.ipv6address,
+                listeningAddressIpv4: this.ipv4Address,
+                listeningAddressIpv6: this.ipv6Address,
                 port,
             },
             operationalCredentials: {

package/dist/matterbridgePlatform.js

@@ -12,7 +12,7 @@ export class MatterbridgePlatform {
     log;
     config;
     name = '';
-    type = '';
+    type = 'AnyPlatform';
     version = '1.0.0';
     storage;
     context;

package/dist/pluginManager.js

@@ -1,16 +1,59 @@
 import EventEmitter from 'node:events';
-import { AnsiLogger, UNDERLINE, UNDERLINEOFF, BLUE, db, er, nf, nt, rs, wr } from 'node-ansi-logger';
+import { AnsiLogger, UNDERLINE, UNDERLINEOFF, BLUE, db, er, nf, nt, rs, wr, debugStringify, CYAN } from 'node-ansi-logger';
 import { plg, typ } from './matterbridgeTypes.js';
-import { logError } from './utils/error.js';
+import { inspectError, logError } from './utils/error.js';
+import { BroadcastServer } from './broadcastServer.js';
 export class PluginManager extends EventEmitter {
     _plugins = new Map();
     matterbridge;
     log;
+    server;
     constructor(matterbridge) {
         super();
         this.matterbridge = matterbridge;
         this.log = new AnsiLogger({ logName: 'PluginManager', logTimestampFormat: 4, logLevel: matterbridge.log.logLevel });
         this.log.debug('Matterbridge plugin manager starting...');
+        this.server = new BroadcastServer('plugins', this.log);
+        this.server.on('broadcast_message', this.msgHandler.bind(this));
+        this.log.debug('Matterbridge plugin manager started');
+    }
+    destroy() {
+        this.server.close();
+    }
+    async msgHandler(msg) {
+        if (!this.server.isWorkerRequest(msg, msg.type))
+            return;
+        if (!msg.id || (msg.dst !== 'all' && msg.dst !== 'plugins'))
+            return;
+        this.log.debug(`**Received request message ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
+        switch (msg.type) {
+            case 'plugins_length':
+                this.server.respond({ ...msg, id: msg.id, response: { length: this.length } });
+                break;
+            case 'plugins_size':
+                this.server.respond({ ...msg, id: msg.id, response: { size: this.size } });
+                break;
+            case 'plugins_has':
+                this.server.respond({ ...msg, id: msg.id, response: { has: this.has(msg.params.name) } });
+                break;
+            case 'plugins_get':
+                this.server.respond({ ...msg, id: msg.id, response: { plugin: this.get(msg.params.name) } });
+                break;
+            case 'plugins_set':
+                this.server.respond({ ...msg, id: msg.id, response: { plugin: this.set(msg.params.plugin) } });
+                break;
+            case 'plugins_baseArray':
+                this.server.respond({ ...msg, id: msg.id, response: { plugins: this.baseArray() } });
+                break;
+            case 'plugins_install':
+                this.server.respond({ ...msg, id: msg.id, response: { packageName: msg.params.packageName, success: await this.install(msg.params.packageName) } });
+                break;
+            case 'plugins_uninstall':
+                this.server.respond({ ...msg, id: msg.id, response: { packageName: msg.params.packageName, success: await this.uninstall(msg.params.packageName) } });
+                break;
+            default:
+                this.log.warn(`Unknown broadcast message ${CYAN}${msg.type}${wr} from ${CYAN}${msg.src}${wr}`);
+        }
     }
     get length() {
         return this._plugins.size;
@@ -34,6 +77,39 @@ export class PluginManager extends EventEmitter {
     array() {
         return Array.from(this._plugins.values());
     }
+    baseArray() {
+        const basePlugins = [];
+        for (const plugin of this._plugins.values()) {
+            basePlugins.push({
+                name: plugin.name,
+                version: plugin.version,
+                description: plugin.description,
+                author: plugin.author,
+                path: plugin.path,
+                type: plugin.type,
+                latestVersion: plugin.latestVersion,
+                devVersion: plugin.devVersion,
+                homepage: plugin.homepage,
+                help: plugin.help,
+                changelog: plugin.changelog,
+                funding: plugin.funding,
+                locked: plugin.locked,
+                error: plugin.error,
+                enabled: plugin.enabled,
+                loaded: plugin.loaded,
+                started: plugin.started,
+                configured: plugin.configured,
+                restartRequired: plugin.restartRequired,
+                registeredDevices: plugin.registeredDevices,
+                configJson: plugin.configJson,
+                schemaJson: plugin.schemaJson,
+                hasWhiteList: plugin.hasWhiteList,
+                hasBlackList: plugin.hasBlackList,
+                matter: plugin.serverNode ? this.matterbridge.getServerNodeData(plugin.serverNode) : undefined,
+            });
+        }
+        return basePlugins;
+    }
     [Symbol.iterator]() {
         return this._plugins.values();
     }
@@ -67,8 +143,7 @@ export class PluginManager extends EventEmitter {
             throw new Error('loadFromStorage: node context is not available.');
         }
         const plugins = [];
-        const pluginArrayFromMap = Array.from(this._plugins.values());
-        for (const plugin of pluginArrayFromMap) {
+        for (const plugin of this.array()) {
             plugins.push({
                 name: plugin.name,
                 path: plugin.path,
@@ -162,6 +237,52 @@ export class PluginManager extends EventEmitter {
             return null;
         }
     }
+    async install(packageName) {
+        const { spawnCommand } = await import('./utils/spawn.js');
+        try {
+            await spawnCommand(this.matterbridge, 'npm', ['install', '-g', packageName, '--omit=dev', '--verbose'], 'install', packageName);
+            this.matterbridge.restartRequired = true;
+            this.matterbridge.fixedRestartRequired = true;
+            packageName = packageName.replace(/@.*$/, '');
+            if (packageName !== 'matterbridge') {
+                if (!this.has(packageName))
+                    await this.add(packageName);
+                const plugin = this.get(packageName);
+                if (plugin && !plugin.loaded)
+                    await this.load(plugin);
+            }
+            else {
+                if (this.matterbridge.restartMode !== '') {
+                    await this.matterbridge.shutdownProcess();
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            inspectError(this.log, `Failed to install package ${plg}${packageName}${er}`, error);
+            return false;
+        }
+    }
+    async uninstall(packageName) {
+        const { spawnCommand } = await import('./utils/spawn.js');
+        packageName = packageName.replace(/@.*$/, '');
+        if (packageName === 'matterbridge')
+            return false;
+        try {
+            if (this.has(packageName)) {
+                const plugin = this.get(packageName);
+                if (plugin && plugin.loaded)
+                    await this.shutdown(plugin, 'Matterbridge is uninstalling the plugin');
+                await this.remove(packageName);
+            }
+            await spawnCommand(this.matterbridge, 'npm', ['uninstall', '-g', packageName, '--verbose'], 'uninstall', packageName);
+            return true;
+        }
+        catch (error) {
+            inspectError(this.log, `Failed to uninstall package ${plg}${packageName}${er}`, error);
+            return false;
+        }
+    }
     getAuthor(packageJson) {
         if (packageJson.author && typeof packageJson.author === 'string')
             return packageJson.author;
@@ -424,12 +545,16 @@ export class PluginManager extends EventEmitter {
                 version: packageJson.version,
                 description: packageJson.description,
                 author: this.getAuthor(packageJson),
+                homepage: this.getHomepage(packageJson),
+                help: this.getHelp(packageJson),
+                changelog: this.getChangelog(packageJson),
+                funding: this.getFunding(packageJson),
             });
             this.log.info(`Added plugin ${plg}${packageJson.name}${nf}`);
             await this.saveToStorage();
             const plugin = this._plugins.get(packageJson.name);
             this.emit('added', packageJson.name);
-            return plugin || null;
+            return plugin;
         }
         catch (err) {
             logError(this.log, `Failed to parse package.json of plugin ${plg}${nameOrPath}${er}`, err);