matterbridge 3.1.6 → 3.1.7-dev-20250723-aab81fe

package/dist/dgram/coap.js

@@ -0,0 +1,252 @@
+import { BLUE, db, GREEN, MAGENTA, nf } from 'node-ansi-logger';
+import { COAP_MULTICAST_IPV4_ADDRESS, COAP_MULTICAST_PORT, Multicast } from './multicast.js';
+export const COAP_OPTION_URI_PATH = 11;
+export const COIOT_OPTION_DEVID = 3332;
+export const COIOT_OPTION_VALIDITY = 3412;
+export const COIOT_OPTION_SERIAL = 3420;
+export const COIOT_REQUEST_STATUS_ID = 56831;
+export const COIOT_REQUEST_DESCRIPTION_ID = 56832;
+export class Coap extends Multicast {
+    constructor(name, multicastAddress, multicastPort, socketType, reuseAddr = true, interfaceName, interfaceAddress) {
+        super(name, multicastAddress, multicastPort, socketType, reuseAddr, interfaceName, interfaceAddress);
+    }
+    onCoapMessage(message, rinfo) {
+        this.log.debug(`Coap message received from ${BLUE}${rinfo.family}${db} ${BLUE}${rinfo.address}${db}:${BLUE}${rinfo.port}${db}`);
+    }
+    onMessage(msg, rinfo) {
+        this.log.info(`Dgram multicast socket received a CoAP message from ${BLUE}${rinfo.family}${nf} ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}`);
+        try {
+            const result = this.decodeCoapMessage(msg);
+            this.onCoapMessage(result, rinfo);
+            this.logCoapMessage(result);
+        }
+        catch (error) {
+            this.log.error(`Error decoding CoAP message: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    decodeCoapMessage(msg) {
+        if (msg.length < 4) {
+            throw new Error('Message too short to be a valid CoAP message');
+        }
+        const version = (msg[0] & 0xc0) >> 6;
+        const type = (msg[0] & 0x30) >> 4;
+        const tokenLength = msg[0] & 0x0f;
+        const code = msg[1];
+        const messageId = msg.readUInt16BE(2);
+        let offset = 4;
+        let token = Buffer.alloc(0);
+        if (tokenLength > 0) {
+            if (msg.length < offset + tokenLength) {
+                throw new Error('Message too short for the token length specified');
+            }
+            token = msg.slice(offset, offset + tokenLength);
+            offset += tokenLength;
+        }
+        const options = [];
+        let currentOptionNumber = 0;
+        while (offset < msg.length) {
+            if (msg[offset] === 0xff) {
+                offset++;
+                break;
+            }
+            const optionHeader = msg[offset++];
+            let delta = (optionHeader & 0xf0) >> 4;
+            let length = optionHeader & 0x0f;
+            if (delta === 13) {
+                if (offset >= msg.length) {
+                    throw new Error('Invalid extended option delta');
+                }
+                delta = msg[offset++] + 13;
+            }
+            else if (delta === 14) {
+                if (offset + 1 >= msg.length) {
+                    throw new Error('Invalid extended option delta');
+                }
+                delta = msg.readUInt16BE(offset) + 269;
+                offset += 2;
+            }
+            else if (delta === 15) {
+                throw new Error('Reserved option delta value encountered');
+            }
+            if (length === 13) {
+                if (offset >= msg.length) {
+                    throw new Error('Invalid extended option length');
+                }
+                length = msg[offset++] + 13;
+            }
+            else if (length === 14) {
+                if (offset + 1 >= msg.length) {
+                    throw new Error('Invalid extended option length');
+                }
+                length = msg.readUInt16BE(offset) + 269;
+                offset += 2;
+            }
+            else if (length === 15) {
+                throw new Error('Reserved option length value encountered');
+            }
+            currentOptionNumber += delta;
+            if (offset + length > msg.length) {
+                throw new Error('Option length exceeds message length');
+            }
+            const optionValue = msg.slice(offset, offset + length);
+            offset += length;
+            options.push({
+                number: currentOptionNumber,
+                value: optionValue,
+            });
+        }
+        const payload = offset < msg.length ? msg.slice(offset) : undefined;
+        return {
+            version,
+            type,
+            tokenLength,
+            code,
+            messageId,
+            token,
+            options,
+            payload,
+        };
+    }
+    encodeCoapMessage(msg) {
+        const parts = [];
+        const token = msg.token || Buffer.alloc(0);
+        const tokenLength = token.length;
+        if (tokenLength > 8) {
+            throw new Error('Token length cannot exceed 8 bytes');
+        }
+        const header = Buffer.alloc(4);
+        header[0] = ((msg.version & 0x03) << 6) | ((msg.type & 0x03) << 4) | (tokenLength & 0x0f);
+        header[1] = msg.code;
+        header.writeUInt16BE(msg.messageId, 2);
+        parts.push(header);
+        if (tokenLength > 0) {
+            parts.push(token);
+        }
+        const sortedOptions = msg.options.slice().sort((a, b) => a.number - b.number);
+        let previousOptionNumber = 0;
+        for (const option of sortedOptions) {
+            const optionDelta = option.number - previousOptionNumber;
+            const optionValueLength = option.value.length;
+            let deltaNibble;
+            let deltaExtended = null;
+            let lengthNibble;
+            let lengthExtended = null;
+            if (optionDelta < 13) {
+                deltaNibble = optionDelta;
+            }
+            else if (optionDelta < 269) {
+                deltaNibble = 13;
+                deltaExtended = Buffer.from([optionDelta - 13]);
+            }
+            else {
+                deltaNibble = 14;
+                deltaExtended = Buffer.alloc(2);
+                deltaExtended.writeUInt16BE(optionDelta - 269, 0);
+            }
+            if (optionValueLength < 13) {
+                lengthNibble = optionValueLength;
+            }
+            else if (optionValueLength < 269) {
+                lengthNibble = 13;
+                lengthExtended = Buffer.from([optionValueLength - 13]);
+            }
+            else {
+                lengthNibble = 14;
+                lengthExtended = Buffer.alloc(2);
+                lengthExtended.writeUInt16BE(optionValueLength - 269, 0);
+            }
+            const optionHeader = Buffer.alloc(1);
+            optionHeader[0] = (deltaNibble << 4) | (lengthNibble & 0x0f);
+            parts.push(optionHeader);
+            if (deltaExtended) {
+                parts.push(deltaExtended);
+            }
+            if (lengthExtended) {
+                parts.push(lengthExtended);
+            }
+            parts.push(option.value);
+            previousOptionNumber = option.number;
+        }
+        if (msg.payload && msg.payload.length > 0) {
+            parts.push(Buffer.from([0xff]));
+            parts.push(msg.payload);
+        }
+        return Buffer.concat(parts);
+    }
+    coapTypeToString(type) {
+        switch (type) {
+            case 0:
+                return 'Confirmable (CON)';
+            case 1:
+                return 'Non-confirmable (NON)';
+            case 2:
+                return 'Acknowledgement (ACK)';
+            case 3:
+                return 'Reset (RST)';
+            default:
+                return `Unknown Type (${type})`;
+        }
+    }
+    coapCodeToString(code) {
+        const cls = code >> 5;
+        const detail = code & 0x1f;
+        const codeStr = `${cls}.${detail.toString().padStart(2, '0')}`;
+        return codeStr;
+    }
+    sendRequest(messageId, options, payload, token, address, port) {
+        const coapMessage = {
+            version: 1,
+            type: 1,
+            tokenLength: token ? Buffer.from(token).length : 0,
+            code: 1,
+            messageId,
+            token: token ? Buffer.from(token) : Buffer.alloc(0),
+            options,
+            payload: payload ? Buffer.from(JSON.stringify(payload)) : undefined,
+        };
+        const encodedBuffer = this.encodeCoapMessage(coapMessage);
+        this.send(encodedBuffer, address ?? COAP_MULTICAST_IPV4_ADDRESS, port ?? COAP_MULTICAST_PORT);
+    }
+    logCoapMessage(msg) {
+        this.log.info(`Decoded CoAP message: version ${MAGENTA}${msg.version}${nf} type ${MAGENTA}${this.coapTypeToString(msg.type)}${nf} ` +
+            `code ${MAGENTA}${this.coapCodeToString(msg.code)}${nf} messageId ${MAGENTA}${msg.messageId}${nf} ` +
+            `tokenLength ${MAGENTA}${msg.tokenLength}${nf} token ${MAGENTA}${msg.tokenLength == 0 ? 'no token' : msg.token.toString('hex')}${nf} ` +
+            `options ${MAGENTA}${msg.options.length}${nf} payload ${MAGENTA}${msg.payload ? msg.payload.length + ' bytes' : undefined}${nf}`);
+        msg.options.forEach((option) => {
+            if (option.number === COAP_OPTION_URI_PATH) {
+                this.log.info(`Option: COAP_OPTION_URI_PATH => ${GREEN}${option.value}${nf}`);
+            }
+            else if (option.number === COIOT_OPTION_DEVID) {
+                const parts = option.value.toString().split('#');
+                const deviceModel = parts[0];
+                const deviceMac = parts[1];
+                const protocolRevision = parts[2];
+                this.log.info(`Option: COIOT_OPTION_DEVID => ${option.value} => Model: ${GREEN}${deviceModel}${nf}, MAC: ${GREEN}${deviceMac}${nf}, Protocol: ${GREEN}${protocolRevision}${nf}`);
+            }
+            else if (option.number === COIOT_OPTION_SERIAL) {
+                const serial = option.value.readUInt16BE(0);
+                this.log.info(`Option: COIOT_OPTION_SERIAL => 0x${option.value.toString('hex')} => serial: ${GREEN}${serial}${nf}`);
+            }
+            else if (option.number === COIOT_OPTION_VALIDITY) {
+                const validity = option.value.readUInt16BE(0);
+                let validFor = 0;
+                if ((validity & 0x1) === 0) {
+                    validFor = Math.floor(validity / 10);
+                }
+                else {
+                    validFor = validity * 4;
+                }
+                this.log.info(`Option: COIOT_OPTION_VALIDITY => 0x${option.value.toString('hex')} => valid for: ${GREEN}${validFor}${nf} seconds`);
+            }
+            else
+                this.log.info(`Option: ${option.number} - ${option.value
+                    .toString('hex')
+                    .match(/.{1,2}/g)
+                    ?.join(' ')}`);
+        });
+        if (msg.payload && msg.payload.length > 0)
+            this.log.info(`Payload:`, JSON.parse(msg.payload.toString()), '\n');
+        else
+            this.log.info(`No payload`, '\n');
+    }
+}

package/dist/dgram/dgram.js

@@ -1,34 +1,7 @@
-/**
- * @description This file contains the class Dgram.
- * @file dgram.ts
- * @author Luca Liguori
- * @created 2025-03-22
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// Node.js imports
 import dgram from 'node:dgram';
 import EventEmitter from 'node:events';
 import os from 'node:os';
-// AnsiLogger imports
 import { AnsiLogger, BLUE, db, idn, nf, rs } from 'node-ansi-logger';
-/**
- * This class implements a dgram socket.
- */
 export class Dgram extends EventEmitter {
     log;
     socket;
@@ -37,18 +10,9 @@ export class Dgram extends EventEmitter {
     interfaceName;
     interfaceAddress;
     interfaceNetmask;
-    /**
-     * Creates an instance of Dgram.
-     *
-     * @param {string} name - The name of the socket.
-     * @param {'udp4' | 'udp6'} socketType - The type of the socket (IPv4 or IPv6).
-     * @param {boolean | undefined} reuseAddr - Whether to allow address reuse.
-     * @param {string} [interfaceName] - The name of the network interface to bind to.
-     * @param {string} [interfaceAddress] - The address of the network interface to bind to.
-     */
     constructor(name, socketType, reuseAddr = true, interfaceName, interfaceAddress) {
         super();
-        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: "debug" /* LogLevel.DEBUG */ });
+        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
         this.socket = dgram.createSocket({ type: socketType, reuseAddr });
         this.socketType = socketType;
         this.interfaceName = interfaceName;
@@ -82,13 +46,6 @@ export class Dgram extends EventEmitter {
             this.onListening(address);
         });
     }
-    /**
-     * Sends a message to the specified server.
-     *
-     * @param {Buffer} msg - The message buffer to send.
-     * @param {string} serverAddress - The IPv4 address of the destination server.
-     * @param {number} serverPort - The port of the destination server.
-     */
     send(msg, serverAddress, serverPort) {
         this.socket.send(msg, 0, msg.length, serverPort, serverAddress, (error) => {
             if (error) {
@@ -126,30 +83,18 @@ export class Dgram extends EventEmitter {
         this.log.info(`Socket ready on ${BLUE}${address.family}${nf} ${BLUE}${address.address}${nf}:${BLUE}${address.port}${nf}`);
         this.emit('ready', address);
     }
-    /**
-     * Retrieves the IPv4 address of the specified network interface or the first external IPv4 interface if no interface is specified.
-     * Throws an error if no suitable interface or address is found.
-     *
-     * @param {string} networkInterface - The name of the network interface to retrieve the IPv4 address from. If not specified, the first external IPv4 interface will be used.
-     * @returns {string | undefined} The IPv4 address of the specified network interface or the first external IPv4 interface.
-     * @throws Error if no suitable interface or address is found.
-     */
     getIpv4InterfaceAddress(networkInterface) {
-        // Normalize the interface name: treat an empty string as undefined.
         if (networkInterface === '')
             networkInterface = undefined;
         const interfaces = os.networkInterfaces();
-        // If a specific interface is provided but not found, warn and fall back.
         if (networkInterface && !interfaces[networkInterface]) {
             this.log.warn(`Interface "${networkInterface}" not found. Using first external IPv4 interface.`);
             networkInterface = undefined;
         }
-        // If no interface was specified or the provided one doesn't exist, find the first external IPv4 interface.
         if (!networkInterface) {
             for (const [interfaceName, interfaceDetails] of Object.entries(interfaces)) {
                 if (!interfaceDetails)
                     continue;
-                // Check if at least one external IPv4 address exists on this interface.
                 for (const detail of interfaceDetails) {
                     if (detail.family === 'IPv4' && !detail.internal) {
                         networkInterface = interfaceName;
@@ -163,7 +108,6 @@ export class Dgram extends EventEmitter {
         if (!networkInterface) {
             throw new Error(`Didn't find an external IPv4 network interface`);
         }
-        // Select the first external IPv4 address from the interface.
         const addresses = interfaces[networkInterface];
         const ipv4Address = addresses?.find((addr) => addr.family === 'IPv4' && !addr.internal);
         if (!ipv4Address) {
@@ -171,25 +115,14 @@ export class Dgram extends EventEmitter {
         }
         return ipv4Address.address;
     }
-    /**
-     * Retrieves the IPv6 address of the specified network interface or the first external IPv6 interface if no interface is specified.
-     * Throws an error if no suitable interface or address is found.
-     *
-     * @param {string} [networkInterface] - The name of the network interface to retrieve the IPv6 address from. If not specified, the first external IPv6 interface will be used.
-     * @returns {string | undefined} The IPv6 address of the specified network interface or the first external IPv6 interface.
-     * @throws {Error} If no suitable interface or address is found.
-     */
     getIpv6InterfaceAddress(networkInterface) {
-        // Normalize the interface name: treat an empty string as undefined.
         if (networkInterface === '')
             networkInterface = undefined;
         const interfaces = os.networkInterfaces();
-        // If a specific interface is provided, verify it exists. Otherwise, warn and use the first external IPv6 interface.
         if (networkInterface && !interfaces[networkInterface]) {
             this.log.warn(`Interface "${networkInterface}" not found. Using first external IPv6 interface.`);
             networkInterface = undefined;
         }
-        // If no network interface was specified, search for the first external IPv6 interface.
         if (!networkInterface) {
             for (const [interfaceName, interfaceDetails] of Object.entries(interfaces)) {
                 if (!interfaceDetails)
@@ -208,21 +141,18 @@ export class Dgram extends EventEmitter {
             throw new Error(`Didn't find an external IPv6 network interface`);
         }
         const addresses = interfaces[networkInterface];
-        // Try to find a link-local address and use scopeid
         const linkLocalAddress = addresses?.find((addr) => addr.family === 'IPv6' && !addr.internal && addr.address.startsWith('fe80'));
         if (linkLocalAddress) {
             this.log.debug('Found IPv6 link-local address');
             return linkLocalAddress.scopeid ? `${linkLocalAddress.address}%${process.platform !== 'win32' ? networkInterface : linkLocalAddress.scopeid}` : linkLocalAddress.address;
         }
         this.log.debug('No IPv6 link-local address found');
-        // Try to find a unique local address
         const ulaAddress = addresses?.find((addr) => addr.family === 'IPv6' && !addr.internal && addr.address.startsWith('fd') && addr.netmask === 'ffff:ffff:ffff:ffff::');
         if (ulaAddress) {
             this.log.debug('Found IPv6 Unique Local Addresses (ULA) unicast address');
             return ulaAddress.address;
         }
         this.log.debug('No IPv6 Unique Local Addresses (ULA) unicast address found');
-        // Try to find a unique local address
         const uniqueLocalAddress = addresses?.find((addr) => addr.family === 'IPv6' && !addr.internal && addr.address.startsWith('fd'));
         if (uniqueLocalAddress) {
             this.log.debug('Found IPv6 Unique Local Addresses (ULA) address');
@@ -231,11 +161,6 @@ export class Dgram extends EventEmitter {
         this.log.debug('No IPv6 Unique Local Addresses (ULA) address found');
         throw new Error(`Interface ${networkInterface} does not have a suitable external IPv6 address`);
     }
-    /**
-     * Retrieves the names of all available network interfaces.
-     *
-     * @returns {string[]} An array of network interface names.
-     */
     getInterfacesNames() {
         const interfaces = os.networkInterfaces();
         const interfaceNames = [];
@@ -246,11 +171,6 @@ export class Dgram extends EventEmitter {
         }
         return interfaceNames;
     }
-    /**
-     *  Retrieves the scope ID for all interfaces address '::'.
-     *
-     * @returns {string} The scope ID of the first found IPv6 address or an empty string.
-     */
     getIpv6ScopeIdForAllInterfacesAddress() {
         const interfaces = os.networkInterfaces();
         for (const name in interfaces) {
@@ -258,24 +178,17 @@ export class Dgram extends EventEmitter {
             if (iface) {
                 const ipv6Address = iface.find((addr) => addr.family === 'IPv6' && !addr.internal && addr.scopeid);
                 if (ipv6Address) {
-                    return process.platform === 'win32' ? '%' + String(ipv6Address.scopeid) : '%' + name; // Use the scope ID for Windows, or the interface name for non-Windows platforms
+                    return process.platform === 'win32' ? '%' + String(ipv6Address.scopeid) : '%' + name;
                 }
             }
         }
         return '';
     }
-    /**
-     * Retrieves the interface name from the scope id of an IPv6 address.
-     *
-     * @param {number} scopeId - The scope id of the IPv6 address.
-     * @returns {string | undefined} The interface name or undefined if not found.
-     */
     getInterfaceNameFromScopeId(scopeId) {
         const nets = os.networkInterfaces();
         for (const ifaceName in nets) {
             const addresses = nets[ifaceName] || [];
             for (const addr of addresses) {
-                // Check for IPv6 addresses with a matching scope id.
                 if (addr.family === 'IPv6' && addr.scopeid === scopeId) {
                     return ifaceName;
                 }
@@ -283,16 +196,8 @@ export class Dgram extends EventEmitter {
         }
         return undefined;
     }
-    /**
-     * Retrieves the netmask of the specified interface address.
-     *
-     * @param {string} interfaceAddress - The interface address for which to retrieve the netmask.
-     * @returns {string | undefined} The netmask of the specified interface address or undefined if not found.
-     */
     getNetmask(interfaceAddress) {
-        // Remove zone index if present (e.g. for IPv6 "fe80::1%eth0")
         const cleanedAddress = interfaceAddress.includes('%') ? interfaceAddress.split('%')[0] : interfaceAddress;
-        // Iterate over all interfaces.
         const nets = os.networkInterfaces();
         for (const ifaceName in nets) {
             const ifaceAddresses = nets[ifaceName];
@@ -306,13 +211,6 @@ export class Dgram extends EventEmitter {
         }
         return undefined;
     }
-    /**
-     * Computes the broadcast address given an IPv4 address and netmask.
-     *
-     * @param {string | undefined} [ipAddress] - The IPv4 address e.g. "192.168.1.20"
-     * @param {string | undefined} [netmask] - The IPv4 netmask e.g. "255.255.255.0"
-     * @returns {string | undefined} The computed broadcast address, e.g. "192.168.1.255"
-     */
     getIpv4BroadcastAddress(ipAddress, netmask) {
         if (!ipAddress || !netmask) {
             return undefined;
@@ -322,17 +220,9 @@ export class Dgram extends EventEmitter {
         const broadcastParts = ipParts.map((octet, i) => (octet & maskParts[i]) | (255 - maskParts[i]));
         return broadcastParts.join('.');
     }
-    /**
-     * Returns the broadcast IPv6 address.
-     *
-     * @returns {string} The broadcast IPv6 address, e.g. "ff02::1"
-     */
     getIpv6BroadcastAddress() {
         return 'ff02::1';
     }
-    /**
-     * Logs all available network interfaces and their details.
-     */
     listNetworkInterfaces() {
         const interfaces = os.networkInterfaces();
         for (const [name, addresses] of Object.entries(interfaces)) {
@@ -345,4 +235,3 @@ export class Dgram extends EventEmitter {
         }
     }
 }
-//# sourceMappingURL=dgram.js.map

package/dist/dgram/mb_coap.js

@@ -0,0 +1,52 @@
+import { COAP_MULTICAST_IPV4_ADDRESS, COAP_MULTICAST_IPV6_ADDRESS, COAP_MULTICAST_PORT } from './multicast.js';
+import { Coap, COAP_OPTION_URI_PATH } from './coap.js';
+{
+    const coapIpv4 = new Coap('CoAP Server udp4', COAP_MULTICAST_IPV4_ADDRESS, COAP_MULTICAST_PORT, 'udp4', true);
+    const coapIpv6 = new Coap('CoAP Server udp6', COAP_MULTICAST_IPV6_ADDRESS, COAP_MULTICAST_PORT, 'udp6', true);
+    coapIpv4.listNetworkInterfaces();
+    function cleanupAndLogAndExit() {
+        if (process.argv.includes('--coap-udp4'))
+            coapIpv4.stop();
+        if (process.argv.includes('--coap-udp6'))
+            coapIpv6.stop();
+        process.exit(0);
+    }
+    const requestUdp4 = () => {
+        coapIpv4.sendRequest(32000, [
+            { number: COAP_OPTION_URI_PATH, value: Buffer.from('cit') },
+            { number: COAP_OPTION_URI_PATH, value: Buffer.from('d') },
+        ], {}, undefined, COAP_MULTICAST_IPV4_ADDRESS, COAP_MULTICAST_PORT);
+    };
+    const requestUdp6 = () => {
+        coapIpv6.sendRequest(32000, [
+            { number: COAP_OPTION_URI_PATH, value: Buffer.from('cit') },
+            { number: COAP_OPTION_URI_PATH, value: Buffer.from('d') },
+        ], {}, undefined, COAP_MULTICAST_IPV6_ADDRESS, COAP_MULTICAST_PORT);
+    };
+    process.on('SIGINT', () => {
+        cleanupAndLogAndExit();
+    });
+    coapIpv4.start();
+    coapIpv4.on('ready', (address) => {
+        coapIpv4.log.info(`coapIpv4 server ready on ${address.family} ${address.address}:${address.port}`);
+        if (!process.argv.includes('--coap-request'))
+            return;
+        requestUdp4();
+        setInterval(() => {
+            requestUdp4();
+        }, 10000).unref();
+    });
+    coapIpv6.start();
+    coapIpv6.on('ready', (address) => {
+        coapIpv6.log.info(`coapIpv6 server ready on ${address.family} ${address.address}:${address.port}`);
+        if (!process.argv.includes('--coap-request'))
+            return;
+        requestUdp6();
+        setInterval(() => {
+            requestUdp6();
+        }, 10000).unref();
+    });
+    setTimeout(() => {
+        cleanupAndLogAndExit();
+    }, 600000);
+}

package/dist/dgram/mb_mdns.js

@@ -0,0 +1,60 @@
+import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from './multicast.js';
+import { Mdns } from './mdns.js';
+{
+    const mdnsIpv4 = new Mdns('mDNS Server udp4', MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT, 'udp4', true, undefined, '0.0.0.0');
+    const mdnsIpv6 = new Mdns('mDNS Server udp6', MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, 'udp6', true, undefined, '::');
+    mdnsIpv4.listNetworkInterfaces();
+    function cleanupAndLogAndExit() {
+        mdnsIpv4.stop();
+        mdnsIpv6.stop();
+        mdnsIpv4.logDevices();
+        mdnsIpv6.logDevices();
+        process.exit(0);
+    }
+    const queryUdp4 = () => {
+        mdnsIpv4.sendQuery([
+            { 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 },
+            { name: '_services._dns-sd._udp.local', type: 12, class: 1, unicastResponse: false },
+        ]);
+        const ptrRdata = mdnsIpv4.encodeDnsName('matterbridge._http._tcp.local');
+        mdnsIpv4.sendResponse('_http._tcp.local', 12, 1, 120, ptrRdata);
+    };
+    const queryUdp6 = () => {
+        mdnsIpv6.sendQuery([
+            { 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 },
+            { name: '_services._dns-sd._udp.local', type: 12, class: 1, unicastResponse: true },
+        ]);
+        const ptrRdata = mdnsIpv6.encodeDnsName('matterbridge._http._tcp.local');
+        mdnsIpv6.sendResponse('_http._tcp.local', 12, 1, 120, ptrRdata);
+    };
+    process.on('SIGINT', () => {
+        cleanupAndLogAndExit();
+    });
+    mdnsIpv4.start();
+    mdnsIpv4.on('ready', (address) => {
+        mdnsIpv4.log.info(`mdnsIpv4 server ready on ${address.family} ${address.address}:${address.port}`);
+        if (!process.argv.includes('--query'))
+            return;
+        queryUdp4();
+        setInterval(() => {
+            queryUdp4();
+        }, 10000).unref();
+    });
+    mdnsIpv6.start();
+    mdnsIpv6.on('ready', (address) => {
+        mdnsIpv6.log.info(`mdnsIpv6 server ready on ${address.family} ${address.address}:${address.port}`);
+        if (!process.argv.includes('--query'))
+            return;
+        queryUdp6();
+        setInterval(() => {
+            queryUdp6();
+        }, 10000).unref();
+    });
+    setTimeout(() => {
+        cleanupAndLogAndExit();
+    }, 600000);
+}