matterbridge 3.1.6-dev-20250721-75fab6b → 3.1.7-dev-20250723-aab81fe

package/CHANGELOG.md

@@ -12,11 +12,44 @@ If you like this project and find it useful, please consider giving it a star on
 
 ### Added
 
-- [reset]: Improved reset all devices command. It will shutdown all the plugins and recreate the devices with new state and enpoint numbers even if the device is not selected.
+- [operationalState]: Improved documentation on createDefaultOperationalStateClusterServer() and added the optional attribute countdownTime. Thanks Ludovic BOUÉ (https://github.com/Luligu/matterbridge/pull/363).
+
+### Changed
+
+- [package]: Updated dependencies.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
+## [3.1.7] - 2025-07-24
+
+### Added
+
+- [docker]: Added trigger of Build Docker Image latest from publish.yml.
+- [docker]: Added on demand trigger for Build Docker Image latest from other plugins.
+- [mdns]: Added bin mb_mdns.
+- [coap]: Added bin mb_coap.
+
+### Changed
+
+- [package]: Updated dependencies.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
+## [3.1.6] - 2025-07-22
+
+### Added
+
+- [reset]: Improved "Reset all devices" command in the frontend. It will shutdown all the plugins and recreate the devices with new state and enpoint numbers even if the device is not selected.
 - [enpoint]: Enhanced HEPA and Activated Carbon Filter Monitoring Cluster Server methods with additional features and improved default parameters.
-- [enpoint]: Added resetCondition command for HEPA and Activated Carbon Filter Monitoring Cluster Server.
+- [enpoint]: Added resetCondition MAtter command for HEPA and Activated Carbon Filter Monitoring Cluster Server.
 - [dishwasher]: Added Dishwasher class and Jest test. It is not supported by the Home app.
-- [extractorHood]: Added ExtractorHood class and Jest test.
+- [extractorHood]: Added ExtractorHood class and Jest test. It is not supported by the Home app.
+- [fan]: Added the createCompleteFanControlClusterServer() cluster helper that create a fan device with all the features. Thanks Ludovic BOUÉ (https://github.com/Luligu/matterbridge/pull/362).
+- [docker]: Added logging configuration instructions to [docker setup](README-DOCKER.md).
 
 ### Changed
 

package/README-DOCKER.md

@@ -171,3 +171,38 @@ docker logs \
 ```bash
 docker logs --tail 1000 -f matterbridge
 ```
+
+### Prevent the logs to grow
+
+If you want to prevent the docker logs to grow too much, you can configure Docker's logging options globally.
+
+**Warning**: This will restart Docker and affect all running containers.
+
+```bash
+sudo nano /etc/docker/daemon.json
+```
+
+Add or update the logging configuration in the daemon.json file:
+
+```json
+{
+  "log-driver": "json-file",
+  "log-opts": {
+    "max-size": "100m",
+    "max-file": "3"
+  }
+}
+```
+
+Where:
+
+- `max-size`: Maximum size of each log file (e.g., "10m", "100m", "1g")
+- `max-file`: Maximum number of log files to keep
+
+Save the file and restart Docker:
+
+```bash
+sudo systemctl restart docker
+```
+
+**Note**: This configuration applies to new containers. Existing containers will need to be recreated to use the new logging settings.

package/bin/mb_coap.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/dgram/mb_coap.js');

package/bin/mb_mdns.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/dgram/mb_mdns.js');

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

@@ -0,0 +1,237 @@
+import dgram from 'node:dgram';
+import EventEmitter from 'node:events';
+import os from 'node:os';
+import { AnsiLogger, BLUE, db, idn, nf, rs } from 'node-ansi-logger';
+export class Dgram extends EventEmitter {
+    log;
+    socket;
+    bound = false;
+    socketType;
+    interfaceName;
+    interfaceAddress;
+    interfaceNetmask;
+    constructor(name, socketType, reuseAddr = true, interfaceName, interfaceAddress) {
+        super();
+        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
+        this.socket = dgram.createSocket({ type: socketType, reuseAddr });
+        this.socketType = socketType;
+        this.interfaceName = interfaceName;
+        this.interfaceAddress = interfaceAddress;
+        this.socket.on('error', (error) => {
+            this.log.debug(`Socket error: ${error instanceof Error ? error.message : error}`);
+            this.emit('error', error);
+            this.onError(error);
+        });
+        this.socket.on('close', () => {
+            this.log.debug('Socket closed');
+            this.bound = false;
+            this.emit('close');
+            this.onClose();
+        });
+        this.socket.on('connect', () => {
+            this.log.info('Socket connected');
+            this.emit('connect');
+            this.onConnect();
+        });
+        this.socket.on('message', (msg, rinfo) => {
+            this.log.debug(`Socket received a message from ${BLUE}${rinfo.family}${db} ${BLUE}${rinfo.address}${db}:${BLUE}${rinfo.port}${db}`);
+            this.emit('message', msg, rinfo);
+            this.onMessage(msg, rinfo);
+        });
+        this.socket.on('listening', () => {
+            this.bound = true;
+            const address = this.socket.address();
+            this.log.debug(`Socket listening on ${BLUE}${address.family}${db} ${BLUE}${address.address}${db}:${BLUE}${address.port}${db}`);
+            this.emit('listening', address);
+            this.onListening(address);
+        });
+    }
+    send(msg, serverAddress, serverPort) {
+        this.socket.send(msg, 0, msg.length, serverPort, serverAddress, (error) => {
+            if (error) {
+                this.log.error(`Socket failed to send a message: ${error instanceof Error ? error.message : error}`);
+                this.emit('error', error);
+                this.onError(error);
+            }
+            else {
+                this.log.debug(`Socket sent a message to ${BLUE}${serverAddress}${db}:${BLUE}${serverPort}${db}`);
+                this.emit('sent', msg, serverAddress, serverPort);
+                this.onSent(msg, serverAddress, serverPort);
+            }
+        });
+    }
+    onError(error) {
+        this.log.error(`Socket error: ${error instanceof Error ? error.message : error}`);
+    }
+    onClose() {
+        this.log.info(`Socket closed`);
+    }
+    onConnect() {
+        this.log.info(`Socket connected`);
+    }
+    onSent(msg, serverAddress, serverPort) {
+        this.log.info(`Socket sent a message to ${BLUE}${serverAddress}${db}:${BLUE}${serverPort}${db}`);
+    }
+    onMessage(msg, rinfo) {
+        this.log.info(`Socket received a message from ${BLUE}${rinfo.family}${nf} ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}`);
+    }
+    onListening(address) {
+        this.log.info(`Socket listening on ${BLUE}${address.family}${nf} ${BLUE}${address.address}${nf}:${BLUE}${address.port}${nf}`);
+        this.onReady(address);
+    }
+    onReady(address) {
+        this.log.info(`Socket ready on ${BLUE}${address.family}${nf} ${BLUE}${address.address}${nf}:${BLUE}${address.port}${nf}`);
+        this.emit('ready', address);
+    }
+    getIpv4InterfaceAddress(networkInterface) {
+        if (networkInterface === '')
+            networkInterface = undefined;
+        const interfaces = os.networkInterfaces();
+        if (networkInterface && !interfaces[networkInterface]) {
+            this.log.warn(`Interface "${networkInterface}" not found. Using first external IPv4 interface.`);
+            networkInterface = undefined;
+        }
+        if (!networkInterface) {
+            for (const [interfaceName, interfaceDetails] of Object.entries(interfaces)) {
+                if (!interfaceDetails)
+                    continue;
+                for (const detail of interfaceDetails) {
+                    if (detail.family === 'IPv4' && !detail.internal) {
+                        networkInterface = interfaceName;
+                        break;
+                    }
+                }
+                if (networkInterface)
+                    break;
+            }
+        }
+        if (!networkInterface) {
+            throw new Error(`Didn't find an external IPv4 network interface`);
+        }
+        const addresses = interfaces[networkInterface];
+        const ipv4Address = addresses?.find((addr) => addr.family === 'IPv4' && !addr.internal);
+        if (!ipv4Address) {
+            throw new Error(`Interface ${networkInterface} does not have an external IPv4 address`);
+        }
+        return ipv4Address.address;
+    }
+    getIpv6InterfaceAddress(networkInterface) {
+        if (networkInterface === '')
+            networkInterface = undefined;
+        const interfaces = os.networkInterfaces();
+        if (networkInterface && !interfaces[networkInterface]) {
+            this.log.warn(`Interface "${networkInterface}" not found. Using first external IPv6 interface.`);
+            networkInterface = undefined;
+        }
+        if (!networkInterface) {
+            for (const [interfaceName, interfaceDetails] of Object.entries(interfaces)) {
+                if (!interfaceDetails)
+                    continue;
+                for (const detail of interfaceDetails) {
+                    if (detail.family === 'IPv6' && !detail.internal) {
+                        networkInterface = interfaceName;
+                        break;
+                    }
+                }
+                if (networkInterface)
+                    break;
+            }
+        }
+        if (!networkInterface) {
+            throw new Error(`Didn't find an external IPv6 network interface`);
+        }
+        const addresses = interfaces[networkInterface];
+        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');
+        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');
+        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');
+            return uniqueLocalAddress.address;
+        }
+        this.log.debug('No IPv6 Unique Local Addresses (ULA) address found');
+        throw new Error(`Interface ${networkInterface} does not have a suitable external IPv6 address`);
+    }
+    getInterfacesNames() {
+        const interfaces = os.networkInterfaces();
+        const interfaceNames = [];
+        for (const name in interfaces) {
+            if (interfaces[name]) {
+                interfaceNames.push(name);
+            }
+        }
+        return interfaceNames;
+    }
+    getIpv6ScopeIdForAllInterfacesAddress() {
+        const interfaces = os.networkInterfaces();
+        for (const name in interfaces) {
+            const iface = interfaces[name];
+            if (iface) {
+                const ipv6Address = iface.find((addr) => addr.family === 'IPv6' && !addr.internal && addr.scopeid);
+                if (ipv6Address) {
+                    return process.platform === 'win32' ? '%' + String(ipv6Address.scopeid) : '%' + name;
+                }
+            }
+        }
+        return '';
+    }
+    getInterfaceNameFromScopeId(scopeId) {
+        const nets = os.networkInterfaces();
+        for (const ifaceName in nets) {
+            const addresses = nets[ifaceName] || [];
+            for (const addr of addresses) {
+                if (addr.family === 'IPv6' && addr.scopeid === scopeId) {
+                    return ifaceName;
+                }
+            }
+        }
+        return undefined;
+    }
+    getNetmask(interfaceAddress) {
+        const cleanedAddress = interfaceAddress.includes('%') ? interfaceAddress.split('%')[0] : interfaceAddress;
+        const nets = os.networkInterfaces();
+        for (const ifaceName in nets) {
+            const ifaceAddresses = nets[ifaceName];
+            if (!ifaceAddresses)
+                continue;
+            for (const addr of ifaceAddresses) {
+                if (addr.address === cleanedAddress) {
+                    return addr.netmask;
+                }
+            }
+        }
+        return undefined;
+    }
+    getIpv4BroadcastAddress(ipAddress, netmask) {
+        if (!ipAddress || !netmask) {
+            return undefined;
+        }
+        const ipParts = ipAddress.split('.').map(Number);
+        const maskParts = netmask.split('.').map(Number);
+        const broadcastParts = ipParts.map((octet, i) => (octet & maskParts[i]) | (255 - maskParts[i]));
+        return broadcastParts.join('.');
+    }
+    getIpv6BroadcastAddress() {
+        return 'ff02::1';
+    }
+    listNetworkInterfaces() {
+        const interfaces = os.networkInterfaces();
+        for (const [name, addresses] of Object.entries(interfaces)) {
+            if (!addresses)
+                continue;
+            this.log.debug(`Interface: ${idn}${name}${rs}${db}`);
+            for (const address of addresses) {
+                this.log.debug(`- address ${BLUE}${address.address}${db} netmask ${BLUE}${address.netmask}${db} ${address.mac ? 'MAC: ' + BLUE + address.mac + db : ''} type: ${BLUE}${address.family}${db} ${BLUE}${address.internal ? 'internal' : 'external'}${db} ${address.scopeid !== undefined ? 'scopeid: ' + BLUE + address.scopeid + db : ''} cidr: ${BLUE}${address.cidr}${db}`);
+            }
+        }
+    }
+}

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);
+}