matterbridge 3.4.5-dev-20251224-e00e572 → 3.4.5-dev-20251224-1bb63cb

package/CHANGELOG.md

@@ -34,10 +34,14 @@ Advantages:
 
 - [DevContainer]: Refactored Dev Container setup. The Matterbridge instance can now be paired on native Linux hosts or WSL 2 with Docker engine CLI integration. On Docker Desktop on Windows or macOS is not possible cause Docker Desktop runs inside a VM and not directly on the host so mDNS is not supported.
 - [DevContainer]: Since is now possible to pair from Dev Container, named volumes have been added to persist storage and plugins across rebuilds.
+- [mb_mdns]: Add query and advertise interval. Improved help for easy mDNS testing.
+- [mb_mdns]: Advertise full DNS-SD record set (PTR/SRV/TXT/A/AAAA) for matterbridge.\_http.\_tcp.local on port 8283.
+- [mdns]: Added TXT/SRV/A/AAAA encoders into the Mdns class.
 
 ### Changed
 
 - [package]: Updated dependencies.
+- [mdns]: Mdns.sendResponse now accepts an array and sends multi-answer responses.
 
 ### Fixed
 

package/dist/dgram/mb_mdns.js

@@ -1,37 +1,49 @@
-import { getParameter, getStringArrayParameter, hasParameter } from '../utils/commandLine.js';
+import { getIntParameter, getParameter, getStringArrayParameter, hasParameter } from '../utils/commandLine.js';
+import { getIpv4InterfaceAddress, getIpv6InterfaceAddress } from '../utils/network.js';
 import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from './multicast.js';
 import { Mdns } from './mdns.js';
 {
     if (hasParameter('h') || hasParameter('help')) {
-        console.log(`Usage: mb_mdns [options]
+        console.log(`Copyright (c) Matterbridge. All rights reserved.\n`);
+        console.log(`Usage: mb_mdns [options...]
+
+If no command line is provided, mb_mdns shows all incoming mDNS records.
 
 Options:
   -h, --help                                Show this help message and exit.
   --interfaceName <name>                    Network interface name to bind to (default all interfaces).
   --ipv4InterfaceAddress <address>          IPv4 address of the network interface to bind to (default: 0.0.0.0).
   --ipv6InterfaceAddress <address>          IPv6 address of the network interface to bind to (default: ::).
-  --outgoingIpv4InterfaceAddress <address>  Outgoing IPv4 address (default first external address).
-  --outgoingIpv6InterfaceAddress <address>  Outgoing IPv6 address (default first external address).
-  --advertise                               Enable mDNS advertisement (default: disabled).
-  --query                                   Enable mDNS query (default: disabled).
-  --filter <string>                         Filter string to match in the mDNS record name (can be repeated).
+  --outgoingIpv4InterfaceAddress <address>  Outgoing IPv4 address of the network interface (default first external address).
+  --outgoingIpv6InterfaceAddress <address>  Outgoing IPv6 address of the network interface (default first external address).
+  --advertise <interval>                    Enable matterbridge mDNS advertisement each ms (default interval: 10000ms).
+  --query <interval>                        Enable common mDNS services query each ms (default interval: 10000ms).
+  --filter <string...>                      Filter strings to match in the mDNS record name (default: no filter).
   -v, --verbose                             Enable verbose logging (default: disabled).
 
 Examples:
-  # List Matter device commissioner service records only on eth0 interface
+  # Listen for Matter device commissioner service records only on eth0 interface
   mb_mdns --interfaceName eth0 --filter _matterc._udp
 
-  # List Matter device service records only on eth0 interface
+  # Listen for Matter device discovery service records only on eth0 interface
   mb_mdns --interfaceName eth0 --filter _matter._tcp
 
-  # List both Matter commissioner and device service records only on eth0 interface
-  mb_mdns --interfaceName eth0 --filter _matterc._udp _matter._tcp
+  # Listen for Matter commissioner and discovery service records on all interfaces
+  mb_mdns --filter _matterc._udp _matter._tcp
 
   # Query for mDNS devices every 10s on a specific interface
   mb_mdns --interfaceName eth0 --query
+
+  # Advertise matterbridge._http._tcp.local every 5s with filter
+  mb_mdns --advertise 5000 --filter matterbridge._http._tcp.local
+
+  # Query each 5s and listen for matterbridge._http._tcp.local service records
+  mb_mdns --query 5000 --filter matterbridge._http._tcp.local
+
 `);
         process.exit(0);
     }
+    const { default: pkg } = await import('../../package.json', { with: { type: 'json' } });
     const mdnsIpv4 = new Mdns('mDNS Server udp4', MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT, 'udp4', true, getParameter('interfaceName'), getParameter('ipv4InterfaceAddress') || '0.0.0.0', getParameter('outgoingIpv4InterfaceAddress'));
     const mdnsIpv6 = new Mdns('mDNS Server udp6', MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, 'udp6', true, getParameter('interfaceName'), getParameter('ipv6InterfaceAddress') || '::', getParameter('outgoingIpv6InterfaceAddress'));
     if (hasParameter('v') || hasParameter('verbose')) {
@@ -56,7 +68,9 @@ Examples:
         process.exit(0);
     }
     const queryUdp4 = () => {
+        mdnsIpv4.log.info('Sending mDNS query for services...');
         mdnsIpv4.sendQuery([
+            { name: '_matterc._udp.local', type: 12, class: 1, unicastResponse: false },
             { name: '_matter._tcp.local', type: 12, class: 1, unicastResponse: false },
             { name: '_shelly._tcp.local', type: 12, class: 1, unicastResponse: false },
             { name: '_http._tcp.local', type: 12, class: 1, unicastResponse: false },
@@ -64,11 +78,44 @@ Examples:
         ]);
     };
     const advertiseUdp4 = () => {
-        const ptrRdata = mdnsIpv4.encodeDnsName('matterbridge._http._tcp.local');
-        mdnsIpv4.sendResponse('_http._tcp.local', 12, 1, 120, ptrRdata);
+        mdnsIpv4.log.info('Sending mDNS advertisement for matterbridge service...');
+        const serviceType = '_http._tcp.local';
+        const instanceName = 'matterbridge._http._tcp.local';
+        const hostName = 'matterbridge.local';
+        const port = 8283;
+        const ttl = 120;
+        const ptrInstanceRdata = mdnsIpv4.encodeDnsName(instanceName);
+        const ptrServiceTypeRdata = mdnsIpv4.encodeDnsName(serviceType);
+        const srvRdata = mdnsIpv4.encodeSrvRdata(0, 0, port, hostName);
+        const txtRdata = mdnsIpv4.encodeTxtRdata([`version=${pkg.version}`, 'path=/']);
+        const answers = [
+            { name: '_services._dns-sd._udp.local', rtype: 12, rclass: 1, ttl, rdata: ptrServiceTypeRdata },
+            { name: serviceType, rtype: 12, rclass: 1, ttl, rdata: ptrInstanceRdata },
+            { name: instanceName, rtype: 33, rclass: 1 | 32768, ttl, rdata: srvRdata },
+            { name: instanceName, rtype: 16, rclass: 1 | 32768, ttl, rdata: txtRdata },
+        ];
+        try {
+            const ipv4 = getIpv4InterfaceAddress();
+            if (ipv4 && ipv4 !== '0.0.0.0') {
+                answers.push({ name: hostName, rtype: 1, rclass: 1 | 32768, ttl, rdata: mdnsIpv4.encodeA(ipv4) });
+            }
+        }
+        catch {
+        }
+        try {
+            const ipv6 = getIpv6InterfaceAddress();
+            if (ipv6 && ipv6 !== '::') {
+                answers.push({ name: hostName, rtype: 28, rclass: 1 | 32768, ttl, rdata: mdnsIpv4.encodeAAAA(ipv6) });
+            }
+        }
+        catch {
+        }
+        mdnsIpv4.sendResponse(answers);
     };
     const queryUdp6 = () => {
+        mdnsIpv6.log.info('Sending mDNS query for services...');
         mdnsIpv6.sendQuery([
+            { name: '_matterc._udp.local', type: 12, class: 1, unicastResponse: true },
             { name: '_matter._tcp.local', type: 12, class: 1, unicastResponse: true },
             { name: '_shelly._tcp.local', type: 12, class: 1, unicastResponse: true },
             { name: '_http._tcp.local', type: 12, class: 1, unicastResponse: true },
@@ -76,8 +123,39 @@ Examples:
         ]);
     };
     const advertiseUdp6 = () => {
-        const ptrRdata = mdnsIpv6.encodeDnsName('matterbridge._http._tcp.local');
-        mdnsIpv6.sendResponse('_http._tcp.local', 12, 1, 120, ptrRdata);
+        mdnsIpv6.log.info('Sending mDNS advertisement for matterbridge service...');
+        const serviceType = '_http._tcp.local';
+        const instanceName = 'matterbridge._http._tcp.local';
+        const hostName = 'matterbridge.local';
+        const port = 8283;
+        const ttl = 120;
+        const ptrInstanceRdata = mdnsIpv6.encodeDnsName(instanceName);
+        const ptrServiceTypeRdata = mdnsIpv6.encodeDnsName(serviceType);
+        const srvRdata = mdnsIpv6.encodeSrvRdata(0, 0, port, hostName);
+        const txtRdata = mdnsIpv6.encodeTxtRdata([`version=${pkg.version}`, 'path=/']);
+        const answers = [
+            { name: '_services._dns-sd._udp.local', rtype: 12, rclass: 1, ttl, rdata: ptrServiceTypeRdata },
+            { name: serviceType, rtype: 12, rclass: 1, ttl, rdata: ptrInstanceRdata },
+            { name: instanceName, rtype: 33, rclass: 1 | 32768, ttl, rdata: srvRdata },
+            { name: instanceName, rtype: 16, rclass: 1 | 32768, ttl, rdata: txtRdata },
+        ];
+        try {
+            const ipv4 = getIpv4InterfaceAddress();
+            if (ipv4) {
+                answers.push({ name: hostName, rtype: 1, rclass: 1 | 32768, ttl, rdata: mdnsIpv6.encodeA(ipv4) });
+            }
+        }
+        catch {
+        }
+        try {
+            const ipv6 = getIpv6InterfaceAddress();
+            if (ipv6) {
+                answers.push({ name: hostName, rtype: 28, rclass: 1 | 32768, ttl, rdata: mdnsIpv6.encodeAAAA(ipv6) });
+            }
+        }
+        catch {
+        }
+        mdnsIpv6.sendResponse(answers);
     };
     process.on('SIGINT', () => {
         cleanupAndLogAndExit();
@@ -85,33 +163,33 @@ Examples:
     mdnsIpv4.start();
     mdnsIpv4.on('ready', (address) => {
         mdnsIpv4.log.info(`mdnsIpv4 server ready on ${address.family} ${address.address}:${address.port}`);
-        if (getParameter('advertise')) {
+        if (hasParameter('advertise')) {
             advertiseUdp4();
             setInterval(() => {
                 advertiseUdp4();
-            }, 10000).unref();
+            }, getIntParameter('advertise') || 10000).unref();
         }
-        if (getParameter('query')) {
+        if (hasParameter('query')) {
             queryUdp4();
             setInterval(() => {
                 queryUdp4();
-            }, 10000).unref();
+            }, getIntParameter('query') || 10000).unref();
         }
     });
     mdnsIpv6.start();
     mdnsIpv6.on('ready', (address) => {
         mdnsIpv6.log.info(`mdnsIpv6 server ready on ${address.family} ${address.address}:${address.port}`);
-        if (getParameter('advertise')) {
+        if (hasParameter('advertise')) {
             advertiseUdp6();
             setInterval(() => {
                 advertiseUdp6();
-            }, 10000).unref();
+            }, getIntParameter('advertise') || 10000).unref();
         }
-        if (getParameter('query')) {
+        if (hasParameter('query')) {
             queryUdp6();
             setInterval(() => {
                 queryUdp6();
-            }, 10000).unref();
+            }, getIntParameter('query') || 10000).unref();
         }
     });
     setTimeout(() => {

package/dist/dgram/mdns.js

@@ -271,6 +271,56 @@ export class Mdns extends Multicast {
         });
         return Buffer.concat([...buffers, Buffer.from([0])]);
     }
+    encodeTxtRdata(txt) {
+        const parts = txt.map((entry) => {
+            const value = Buffer.from(entry, 'utf8');
+            if (value.length > 255)
+                throw new Error(`TXT entry too long: ${entry}`);
+            return Buffer.concat([Buffer.from([value.length]), value]);
+        });
+        return Buffer.concat(parts);
+    }
+    encodeSrvRdata(priority, weight, port, target) {
+        const fixed = Buffer.alloc(6);
+        fixed.writeUInt16BE(priority, 0);
+        fixed.writeUInt16BE(weight, 2);
+        fixed.writeUInt16BE(port, 4);
+        return Buffer.concat([fixed, this.encodeDnsName(target)]);
+    }
+    encodeA(ipv4) {
+        const parts = ipv4.split('.').map((p) => Number(p));
+        if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
+            throw new Error(`Invalid IPv4 address: ${ipv4}`);
+        }
+        return Buffer.from(parts);
+    }
+    encodeAAAA(ipv6WithOptionalScope) {
+        const ipv6 = ipv6WithOptionalScope.split('%')[0];
+        const [left, right] = ipv6.split('::');
+        const leftParts = left ? left.split(':').filter(Boolean) : [];
+        const rightParts = right ? right.split(':').filter(Boolean) : [];
+        if (ipv6.includes('::')) {
+            const missing = 8 - (leftParts.length + rightParts.length);
+            if (missing < 0)
+                throw new Error(`Invalid IPv6 address: ${ipv6WithOptionalScope}`);
+            const groups = [...leftParts, ...Array(missing).fill('0'), ...rightParts];
+            return Buffer.from(groups.flatMap((g) => {
+                const word = parseInt(g || '0', 16);
+                if (!Number.isFinite(word) || word < 0 || word > 0xffff)
+                    throw new Error(`Invalid IPv6 group: ${g}`);
+                return [(word >> 8) & 0xff, word & 0xff];
+            }));
+        }
+        const groups = ipv6.split(':');
+        if (groups.length !== 8)
+            throw new Error(`Invalid IPv6 address: ${ipv6WithOptionalScope}`);
+        return Buffer.from(groups.flatMap((g) => {
+            const word = parseInt(g || '0', 16);
+            if (!Number.isFinite(word) || word < 0 || word > 0xffff)
+                throw new Error(`Invalid IPv6 group: ${g}`);
+            return [(word >> 8) & 0xff, word & 0xff];
+        }));
+    }
     decodeResourceRecord(msg, offset) {
         const nameResult = this.decodeDnsName(msg, offset);
         const name = nameResult.name;
@@ -399,29 +449,36 @@ export class Mdns extends Multicast {
             }
         });
     }
-    sendResponse(name, rtype, rclass, ttl, rdata) {
+    sendResponse(answers) {
+        if (!Array.isArray(answers) || answers.length === 0) {
+            throw new Error('sendResponse requires a non-empty answers array');
+        }
         const header = Buffer.alloc(12);
         header.writeUInt16BE(0, 0);
         header.writeUInt16BE(0x8400, 2);
         header.writeUInt16BE(0, 4);
-        header.writeUInt16BE(1, 6);
+        header.writeUInt16BE(answers.length, 6);
         header.writeUInt16BE(0, 8);
         header.writeUInt16BE(0, 10);
-        const aname = this.encodeDnsName(name);
-        const answerFixed = Buffer.alloc(10);
-        answerFixed.writeUInt16BE(rtype, 0);
-        answerFixed.writeUInt16BE(rclass, 2);
-        answerFixed.writeUInt32BE(ttl, 4);
-        answerFixed.writeUInt16BE(rdata.length, 8);
-        const answer = Buffer.concat([aname, answerFixed, rdata]);
-        const response = Buffer.concat([header, answer]);
+        const answerBuffers = answers.map(({ name, rtype, rclass, ttl, rdata }) => {
+            const aname = this.encodeDnsName(name);
+            const answerFixed = Buffer.alloc(10);
+            answerFixed.writeUInt16BE(rtype, 0);
+            answerFixed.writeUInt16BE(rclass, 2);
+            answerFixed.writeUInt32BE(ttl, 4);
+            answerFixed.writeUInt16BE(rdata.length, 8);
+            return Buffer.concat([aname, answerFixed, rdata]);
+        });
+        const response = Buffer.concat([header, ...answerBuffers]);
         this.socket.send(response, 0, response.length, this.multicastPort, this.multicastAddress, (error) => {
             if (error) {
-                this.log.error(`Dgram mDNS server failed to send response message for ${MAGENTA}${name}${er} type ${MAGENTA}${this.dnsTypeToString(rtype)}${er} class ${MAGENTA}${this.dnsResponseClassToString(rclass)}${er} ttl ${MAGENTA}${ttl}${er}: ${error instanceof Error ? error.message : error}`);
+                const items = answers.map((a) => `- name ${MAGENTA}${a.name}${er} type ${MAGENTA}${this.dnsTypeToString(a.rtype)}${er} class ${MAGENTA}${this.dnsResponseClassToString(a.rclass)}${er} ttl ${MAGENTA}${a.ttl}${er}`).join('\n');
+                this.log.error(`Dgram mDNS server failed to send response message (${MAGENTA}${answers.length}${er} answers): ${error instanceof Error ? error.message : error}\n${items}`);
                 this.emit('error', error);
             }
             else {
-                this.log.debug(`Dgram mDNS server sent response message for ${MAGENTA}${name}${db} type ${MAGENTA}${this.dnsTypeToString(rtype)}${db} class ${MAGENTA}${this.dnsResponseClassToString(rclass)}${db} ttl ${MAGENTA}${ttl}${db}`);
+                const items = answers.map((a) => `- name ${MAGENTA}${a.name}${db} type ${MAGENTA}${this.dnsTypeToString(a.rtype)}${db} class ${MAGENTA}${this.dnsResponseClassToString(a.rclass)}${db} ttl ${MAGENTA}${a.ttl}${db}`).join('\n');
+                this.log.debug(`Dgram mDNS server sent response message:\n${items}`);
                 this.emit('sent', response, this.multicastAddress, this.multicastPort);
             }
         });

package/dist/utils/network.js

@@ -41,13 +41,24 @@ export function getIpv4InterfaceAddress() {
         }
     }
 }
-export function getIpv6InterfaceAddress() {
+export function getIpv6InterfaceAddress(scope = false) {
     for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
         if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
             continue;
         for (const detail of interfaceDetails) {
-            if (detail.family === 'IPv6' && !detail.internal)
-                return detail.address;
+            if (detail.family === 'IPv6' && !detail.internal) {
+                const address = detail.address;
+                if (!scope)
+                    return address;
+                if (address.includes('%'))
+                    return address;
+                const isWindows = os.platform() === 'win32';
+                const zoneId = isWindows ? detail.scopeid : interfaceName;
+                if (zoneId !== undefined && zoneId !== null && `${zoneId}`.length > 0) {
+                    return `${address}%${zoneId}`;
+                }
+                return address;
+            }
         }
     }
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.4.5-dev-20251224-e00e572",
+  "version": "3.4.5-dev-20251224-1bb63cb",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.4.5-dev-20251224-e00e572",
+      "version": "3.4.5-dev-20251224-1bb63cb",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.4.5-dev-20251224-e00e572",
+  "version": "3.4.5-dev-20251224-1bb63cb",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",