matterbridge 1.3.5 → 1.3.7

package/dist/matterbridge.js

@@ -25,6 +25,7 @@ import { AnsiLogger, BRIGHT, RESET, UNDERLINE, UNDERLINEOFF, YELLOW, db, debugSt
 import { fileURLToPath, pathToFileURL } from 'url';
 import { promises as fs } from 'fs';
 import { exec, spawn } from 'child_process';
+import { createServer } from 'http';
 import https from 'https';
 import EventEmitter from 'events';
 import express from 'express';
@@ -99,17 +100,20 @@ export class Matterbridge extends EventEmitter {
     bridgeMode = '';
     restartMode = '';
     debugEnabled = false;
-    port = 5540;
+    mdnsInterface; // matter server mdnsInterface: 'eth0' or 'wlan0' or 'WiFi'
+    port = 5540; // first commissioning server port
     log;
     hasCleanupStarted = false;
-    plugins = new Map();
-    devices = new Map();
+    // private plugins = new Map<string, RegisteredPlugin>();
+    // private devices = new Map<string, RegisteredDevice>();
     registeredPlugins = [];
     registeredDevices = [];
     nodeStorage;
     nodeContext;
     expressApp;
     expressServer;
+    httpServer;
+    httpsServer;
     webSocketServer;
     storageManager;
     matterbridgeContext;
@@ -259,12 +263,17 @@ export class Matterbridge extends EventEmitter {
       - help:                  show the help
       - bridge:                start Matterbridge in bridge mode
       - childbridge:           start Matterbridge in childbridge mode
+      - port [port]:           start the commissioning server on the given port (default 5540)
+      - mdnsinterface [name]:  set the interface to use for the matter server mdnsInterface (default all interfaces)
       - frontend [port]:       start the frontend on the given port (default 8283)
       - debug:                 enable the Matterbridge debug mode (default false)
       - matterlogger:          set the matter.js logger level: debug | info | notice | warn | error | fatal (default info)
       - reset:                 remove the commissioning for Matterbridge (bridge mode). Shutdown Matterbridge before using it!
       - factoryreset:          remove all commissioning information and reset all internal storages. Shutdown Matterbridge before using it!
       - list:                  list the registered plugins
+      - loginterfaces:         log the network interfaces
+      - logstorage:            log the node storage
+      - ssl:                   enable SSL for the frontend and WebSockerServer (certificates in .matterbridge/certs directory cert.pem, key.pem and ca.pem (optional))
       - add [plugin path]:     register the plugin from the given absolute or relative path
       - add [plugin name]:     register the globally installed plugin with the given name
       - remove [plugin path]:  remove the plugin from the given absolute or relative path
@@ -277,7 +286,9 @@ export class Matterbridge extends EventEmitter {
       - reset [plugin name]:   remove the commissioning for the globally installed plugin (childbridge mode). Shutdown Matterbridge before using it!\n`);
             process.exit(0);
         }
-        // Set the first port to use
+        // Set the interface to use for the matter server mdnsInterface
+        this.mdnsInterface = getParameter('mdnsinterface');
+        // Set the first port to use for the commissioning server
         this.port = getIntParameter('port') ?? 5540;
         // Set the restart mode
         if (hasParameter('service'))
@@ -339,11 +350,11 @@ export class Matterbridge extends EventEmitter {
             }
             else {
                 this.log.warn(`Invalid matterlogger level: ${level}. Using default level ${this.debugEnabled ? 'debug' : 'info'}.`);
-                Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
+                Logger.defaultLogLevel = Level.INFO;
             }
         }
         else {
-            Logger.defaultLogLevel = this.debugEnabled ? Level.DEBUG : Level.INFO;
+            Logger.defaultLogLevel = Level.INFO;
         }
         Logger.format = Format.ANSI;
         // Parse command line
@@ -794,7 +805,7 @@ export class Matterbridge extends EventEmitter {
             this.log.debug('All listeners removed');
             this.checkUpdateInterval && clearInterval(this.checkUpdateInterval);
             this.checkUpdateInterval = undefined;
-            // Calling the shutdown functions with a reason
+            // Calling the shutdown method of each plugin
             for (const plugin of this.registeredPlugins) {
                 if (!plugin.enabled || plugin.error)
                     continue;
@@ -853,14 +864,29 @@ export class Matterbridge extends EventEmitter {
             // Close the express server
             if (this.expressServer) {
                 this.expressServer.close();
+                this.expressServer.removeAllListeners();
                 this.expressServer = undefined;
                 this.log.debug('Express server closed successfully');
             }
-            // Remove listeners
+            // Close the http server
+            if (this.httpServer) {
+                this.httpServer.close();
+                this.httpServer.removeAllListeners();
+                this.httpServer = undefined;
+                this.log.debug('Frontend http server closed successfully');
+            }
+            // Close the https server
+            if (this.httpsServer) {
+                this.httpsServer.close();
+                this.httpsServer.removeAllListeners();
+                this.httpsServer = undefined;
+                this.log.debug('Frontend https server closed successfully');
+            }
+            // Remove listeners from the express app
             if (this.expressApp) {
                 this.expressApp.removeAllListeners();
                 this.expressApp = undefined;
-                this.log.debug('Frontend closed successfully');
+                this.log.debug('Frontend app closed successfully');
             }
             // Close the WebSocket server
             if (this.webSocketServer) {
@@ -2062,6 +2088,8 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`Creating matter commissioning server for plugin ${plg}${pluginName}${db} with hardwareVersion ${hardwareVersion} hardwareVersionString ${hardwareVersionString}`);
         const commissioningServer = new CommissioningServer({
             port: this.port++,
+            // listeningAddressIpv4
+            // listeningAddressIpv6
             passcode: undefined,
             discriminator: undefined,
             deviceName,
@@ -2166,13 +2194,25 @@ export class Matterbridge extends EventEmitter {
         return commissioningServer;
     }
     /**
-     * Creates a Matter server using the provided storage manager.
+     * Creates a Matter server using the provided storage manager and the provided mdnsInterface.
      * @param storageManager The storage manager to be used by the Matter server.
      *
      */
     createMatterServer(storageManager) {
         this.log.debug('Creating matter server');
-        const matterServer = new MatterServer(storageManager, { mdnsAnnounceInterface: undefined });
+        // Validate mdnsInterface
+        if (this.mdnsInterface) {
+            const networkInterfaces = os.networkInterfaces();
+            const availableInterfaces = Object.keys(networkInterfaces);
+            if (!availableInterfaces.includes(this.mdnsInterface)) {
+                this.log.error(`Invalid mdnsInterface: ${this.mdnsInterface}. Available interfaces are: ${availableInterfaces.join(', ')}. Using all available interfaces.`);
+                this.mdnsInterface = undefined;
+            }
+            else {
+                this.log.info(`Using mdnsInterface '${this.mdnsInterface}' for the Matter server MdnsBroadcaster.`);
+            }
+        }
+        const matterServer = new MatterServer(storageManager, { mdnsInterface: this.mdnsInterface });
         this.log.debug('Created matter server');
         return matterServer;
     }
@@ -2269,26 +2309,29 @@ export class Matterbridge extends EventEmitter {
     async logNodeAndSystemInfo() {
         // IP address information
         const networkInterfaces = os.networkInterfaces();
-        this.systemInformation.ipv4Address = 'Not found';
-        this.systemInformation.ipv6Address = 'Not found';
+        this.systemInformation.ipv4Address = '';
+        this.systemInformation.ipv6Address = '';
         for (const [interfaceName, interfaceDetails] of Object.entries(networkInterfaces)) {
             if (!interfaceDetails) {
                 break;
             }
             for (const detail of interfaceDetails) {
-                if (detail.family === 'IPv4' && !detail.internal && this.systemInformation.ipv4Address === 'Not found') {
+                if (detail.family === 'IPv4' && !detail.internal && this.systemInformation.ipv4Address === '') {
                     this.systemInformation.interfaceName = interfaceName;
                     this.systemInformation.ipv4Address = detail.address;
                     this.systemInformation.macAddress = detail.mac;
                 }
-                else if (detail.family === 'IPv6' && !detail.internal && this.systemInformation.ipv6Address === 'Not found') {
+                else if (detail.family === 'IPv6' && !detail.internal && this.systemInformation.ipv6Address === '') {
                     this.systemInformation.interfaceName = interfaceName;
                     this.systemInformation.ipv6Address = detail.address;
                     this.systemInformation.macAddress = detail.mac;
                 }
             }
-            // Break if both addresses are found to improve efficiency
-            if (this.systemInformation.ipv4Address !== 'Not found' && this.systemInformation.ipv6Address !== 'Not found') {
+            if (this.systemInformation.ipv4Address !== '' /* && this.systemInformation.ipv6Address !== ''*/) {
+                this.log.debug(`Using interface: '${this.systemInformation.interfaceName}'`);
+                this.log.debug(`- with MAC address: '${this.systemInformation.macAddress}'`);
+                this.log.debug(`- with IPv4 address: '${this.systemInformation.ipv4Address}'`);
+                this.log.debug(`- with IPv6 address: '${this.systemInformation.ipv6Address}'`);
                 break;
             }
         }
@@ -2627,64 +2670,156 @@ export class Matterbridge extends EventEmitter {
      * @param port The port number to run the frontend server on. Default is 3000.
      */
     async initializeFrontend(port = 8283) {
-        if (hasParameter('test_https')) {
-            await this.initializeHttpsFrontend(8443);
-            return;
+        this.log.debug(`Initializing the frontend ${hasParameter('ssl') ? 'https' : 'http'} server on port ${YELLOW}${port}${db}`);
+        // Create the express app that serves the frontend
+        this.expressApp = express();
+        this.expressApp.use(express.static(path.join(this.rootDirectory, 'frontend/build')));
+        if (!hasParameter('ssl')) {
+            // Create an HTTP server and attach the express app
+            this.httpServer = createServer(this.expressApp);
+            // Listen on the specified port
+            this.httpServer.listen(port, () => {
+                if (this.systemInformation.ipv4Address !== '')
+                    this.log.info(`The frontend http server is listening on ${UNDERLINE}http://${this.systemInformation.ipv4Address}:${port}${UNDERLINEOFF}${rs}`);
+                if (this.systemInformation.ipv6Address !== '')
+                    this.log.debug(`The frontend http server is listening on ${UNDERLINE}http://[${this.systemInformation.ipv6Address}]:${port}${UNDERLINEOFF}${rs}`);
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.httpServer.on('error', (error) => {
+                this.log.error(`Frontend http server error listening on ${port}`);
+                switch (error.code) {
+                    case 'EACCES':
+                        this.log.error(`Port ${port} requires elevated privileges`);
+                        break;
+                    case 'EADDRINUSE':
+                        this.log.error(`Port ${port} is already in use`);
+                        break;
+                }
+                process.exit(1);
+            });
         }
-        this.log.debug(`Initializing the frontend on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
-        // Create a WebSocket server
-        const wssPort = 8284;
-        const wssHost = `ws://${this.systemInformation.ipv4Address}:${wssPort}`;
-        this.webSocketServer = new WebSocketServer({ port: wssPort, host: this.systemInformation.ipv4Address });
-        this.log.debug(`WebSocket server created on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
-        this.webSocketServer.on('connection', (ws) => {
-            this.log.info('WebSocketServer client connected');
+        else {
+            // Load the SSL certificate, the private key and optionally the CA certificate
+            let cert;
+            try {
+                cert = await fs.readFile(path.join(this.matterbridgeDirectory, 'certs/cert.pem'), 'utf8');
+                this.log.info(`Loaded certificate file ${path.join(this.matterbridgeDirectory, 'certs/cert.pem')}`);
+            }
+            catch (error) {
+                this.log.error(`Error reading certificate file: ${error}`);
+                process.exit(1);
+            }
+            let key;
+            try {
+                key = await fs.readFile(path.join(this.matterbridgeDirectory, 'certs/key.pem'), 'utf8');
+                this.log.info(`Loaded key file ${path.join(this.matterbridgeDirectory, 'certs/key.pem')}`);
+            }
+            catch (error) {
+                this.log.error(`Error reading key file: ${error}`);
+                process.exit(1);
+            }
+            let ca;
+            try {
+                ca = await fs.readFile(path.join(this.matterbridgeDirectory, 'certs/ca.pem'), 'utf8');
+                this.log.info(`Loaded CA certificate file ${path.join(this.matterbridgeDirectory, 'certs/ca.pem')}`);
+            }
+            catch (error) {
+                this.log.info(`CA certificate file ${path.join(this.matterbridgeDirectory, 'certs/ca.pem')} not loaded: ${error}`);
+            }
+            const serverOptions = { cert, key, ca };
+            // Create an HTTPS server with the SSL certificate and private key (ca is optional) and attach the express app
+            this.httpsServer = https.createServer(serverOptions, this.expressApp);
+            // Listen on the specified port
+            this.httpsServer.listen(port, () => {
+                if (this.systemInformation.ipv4Address !== '')
+                    this.log.info(`The frontend https server is listening on ${UNDERLINE}https://${this.systemInformation.ipv4Address}:${port}${UNDERLINEOFF}${rs}`);
+                if (this.systemInformation.ipv6Address !== '')
+                    this.log.debug(`The frontend https server is listening on ${UNDERLINE}https://[${this.systemInformation.ipv6Address}]:${port}${UNDERLINEOFF}${rs}`);
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.httpsServer.on('error', (error) => {
+                this.log.error(`Frontend https server error listening on ${port}`);
+                switch (error.code) {
+                    case 'EACCES':
+                        this.log.error(`Port ${port} requires elevated privileges`);
+                        break;
+                    case 'EADDRINUSE':
+                        this.log.error(`Port ${port} is already in use`);
+                        break;
+                }
+                process.exit(1);
+            });
+        }
+        // Createe a WebSocket server and attach it to the http server
+        const wssPort = port;
+        const wssHost = hasParameter('ssl') ? `wss://${this.systemInformation.ipv4Address}:${wssPort}` : `ws://${this.systemInformation.ipv4Address}:${wssPort}`;
+        this.webSocketServer = new WebSocketServer(hasParameter('ssl') ? { server: this.httpsServer } : { server: this.httpServer });
+        this.webSocketServer.on('connection', (ws, request) => {
+            const clientIp = request.socket.remoteAddress;
+            this.log.info(`WebSocketServer client ${clientIp} connected`);
             this.log.setGlobalCallback(this.wssSendMessage.bind(this));
             this.log.debug('WebSocketServer logger callback added');
-            this.wssSendMessage('Matterbridge', 'info', 'WebSocketServer client connected to Matterbridge');
+            this.wssSendMessage('Matterbridge', 'info', `WebSocketServer client ${clientIp} connected to Matterbridge`);
             ws.on('message', (message) => {
-                this.log.info(`WebSocket client sent a message => ${message}`);
+                this.log.debug(`WebSocket client message: ${message}`);
             });
             ws.on('close', () => {
                 this.log.info('WebSocket client disconnected');
                 if (this.webSocketServer?.clients.size === 0) {
                     this.log.setGlobalCallback(undefined);
-                    this.log.debug('All WebSocket client disconnected. WebSocketServer logger callback removed');
+                    this.log.debug('All WebSocket clients disconnected. WebSocketServer logger callback removed');
                 }
             });
             ws.on('error', (error) => {
                 this.log.error(`WebSocket client error: ${error}`);
             });
         });
+        this.webSocketServer.on('close', () => {
+            this.log.debug(`WebSocketServer closed`);
+        });
+        this.webSocketServer.on('listening', () => {
+            this.log.info(`The WebSocketServer is listening on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
+        });
         this.webSocketServer.on('error', (ws, error) => {
             this.log.error(`WebSocketServer error: ${error}`);
-            return;
         });
+        /*
+        // Create a WebSocket server
+        const wssPort = 8284;
+        const wssHost = `ws://${this.systemInformation.ipv4Address}:${wssPort}`;
+        this.webSocketServer = new WebSocketServer({ port: wssPort, host: this.systemInformation.ipv4Address });
+        this.log.debug(`WebSocket server created on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
+    
         this.webSocketServer.on('listening', () => {
-            this.log.info(`WebSocketServer is listening on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
-            return;
+          this.log.info(`WebSocketServer is listening on ${UNDERLINE}${wssHost}${UNDERLINEOFF}${rs}`);
+          return;
         });
+        */
+        /*
         // Serve React build directory
         this.expressApp = express();
         this.expressApp.use(express.static(path.join(this.rootDirectory, 'frontend/build')));
+    
         // Listen on HTTP
         this.expressServer = this.expressApp.listen(port, () => {
-            this.log.info(`The frontend is listening on ${UNDERLINE}http://${this.systemInformation.ipv4Address}:${port}${UNDERLINEOFF}${rs}`);
-            this.log.debug(`The frontend is listening on ${UNDERLINE}http://[${this.systemInformation.ipv6Address}]:${port}${UNDERLINEOFF}${rs}`);
+          this.log.info(`The frontend is listening on ${UNDERLINE}http://${this.systemInformation.ipv4Address}:${port}${UNDERLINEOFF}${rs}`);
+          this.log.debug(`The frontend is listening on ${UNDERLINE}http://[${this.systemInformation.ipv6Address}]:${port}${UNDERLINEOFF}${rs}`);
         });
+    
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.expressServer.on('error', (error) => {
-            this.log.error(`Frontend error listening on ${UNDERLINE}http://${this.systemInformation.ipv4Address}:${port}${UNDERLINEOFF}${rs}`);
-            switch (error.code) {
-                case 'EACCES':
-                    this.log.error(`Port ${port} requires elevated privileges`);
-                    break;
-                case 'EADDRINUSE':
-                    this.log.error(`Port ${port} is already in use`);
-                    break;
-            }
-            process.exit(1);
+        this.expressServer.on('error', (error: any) => {
+          this.log.error(`Frontend error listening on ${UNDERLINE}http://${this.systemInformation.ipv4Address}:${port}${UNDERLINEOFF}${rs}`);
+          switch (error.code) {
+            case 'EACCES':
+              this.log.error(`Port ${port} requires elevated privileges`);
+              break;
+            case 'EADDRINUSE':
+              this.log.error(`Port ${port} is already in use`);
+              break;
+          }
+          process.exit(1);
         });
+        */
         // Endpoint to validate login code
         this.expressApp.post('/api/login', express.json(), async (req, res) => {
             const { password } = req.body;
@@ -3102,60 +3237,6 @@ export class Matterbridge extends EventEmitter {
         });
         this.log.debug(`Frontend initialized on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
     }
-    // Just for testing purposes. Use with matterbridge -test_https so no bridge is loaded
-    async initializeHttpsFrontend(port = 8443) {
-        this.log.debug(`Initializing the https frontend on port ${YELLOW}${port}${db} static ${UNDERLINE}${path.join(this.rootDirectory, 'frontend/build')}${UNDERLINEOFF}${rs}`);
-        // Create the express app that serves the frontend
-        this.expressApp = express();
-        // Load the SSL certificate and private key
-        // If we need also the CA certificate, we can add it to the serverOptions object
-        // I created dev certificates with openssl using the following commands:
-        // openssl genrsa -out key.pem 2048
-        // openssl req -new -key key.pem -out csr.pem
-        // openssl x509 -req -days 365 -in csr.pem -signkey key.pem -out cert.pem
-        const serverOptions = {
-            cert: await fs.readFile(path.join(this.matterbridgeDirectory, 'certs/cert.pem'), 'utf8'),
-            key: await fs.readFile(path.join(this.matterbridgeDirectory, 'certs/key.pem'), 'utf8'),
-            // ca: await fs.readFile(path.join(this.matterbridgeDirectory, 'certs/ca.pem'), 'utf8'),
-        };
-        // Create an HTTPS server with the SSL certificate and private key and attach the express app
-        const httpsServer = https.createServer(serverOptions, this.expressApp);
-        // Fallback for routing
-        this.expressApp.get('/', (req, res) => {
-            this.log.debug('The frontend sent:', req.url);
-            res.send('Hello, HTTPS!');
-        });
-        // Listen on a specific port
-        // Connect to the frontend with 'https://localhost:8443'
-        httpsServer.listen(port, () => {
-            this.log.info(`HTTPS server listening on ${UNDERLINE}'https://localhost:${port}${UNDERLINEOFF}${rs}`);
-        });
-        // Attach WebSocket server to HTTPS server
-        this.webSocketServer = new WebSocketServer({ server: httpsServer });
-        this.log.info(`WebSocketServer runnig on ${UNDERLINE}wss://localhost:${port}${UNDERLINEOFF}${rs}`);
-        // Handle connections to the WebSocketServer
-        // Connect to the WebSocket server using wss from the react frontend this way: const ws = new WebSocket('wss://localhost:8443');
-        this.webSocketServer.on('connection', (ws) => {
-            this.log.info('WebSocketServer: WebSocket client connected');
-            ws.on('message', (message) => {
-                this.log.info(`WebSocket client sent message => ${message}`);
-            });
-            ws.on('close', () => {
-                this.log.info('WebSocket client disconnected');
-                if (this.webSocketServer?.clients.size === 0) {
-                    this.log.info('All WebSocket clients disconnected');
-                }
-            });
-            ws.on('error', (error) => {
-                this.log.error(`WebSocket client error: ${error}`);
-            });
-        });
-        // Handle error from the WebSocketServer
-        this.webSocketServer.on('error', (ws, error) => {
-            this.log.error(`WebSocketServer error: ${error}`);
-            return;
-        });
-    }
     /**
      * Retrieves the cluster text from a given device.
      * @param device - The MatterbridgeDevice object.