@matterbridge/core 3.7.1-dev-20260325-72b7b24 → 3.7.1-dev-20260326-40eef29

package/dist/mb_coap.d.ts

@@ -0,0 +1,24 @@
+import { Coap } from '@matterbridge/dgram';
+export declare const MB_COAP_DEFAULT_REQUEST_INTERVAL_MS = 10000;
+export declare const MB_COAP_DEFAULT_TIMEOUT_MS = 600000;
+export interface MbCoapOptions {
+    showHelp: boolean;
+    requestIntervalMs?: number;
+    interfaceName?: string;
+    ipv4InterfaceAddress: string;
+    ipv6InterfaceAddress: string;
+    disableLoopback: boolean;
+    disableIpv4: boolean;
+    disableIpv6: boolean;
+    disableTimeout: boolean;
+}
+export interface MbCoapRuntime {
+    coapIpv4?: Coap;
+    coapIpv6?: Coap;
+    cleanupAndLogAndExit: () => void;
+}
+export declare function getMbCoapHelpText(): string;
+export declare function printMbCoapHelp(log?: (message: string) => void): void;
+export declare function getMbCoapOptions(): MbCoapOptions;
+export declare function startMbCoap(options: MbCoapOptions, exitFn?: (code: number) => never | void, registerSignalHandlers?: boolean): MbCoapRuntime;
+export declare function mbCoapMain(exitFn?: (code: number) => never | void, log?: (message: string) => void): MbCoapRuntime | undefined;

package/dist/mb_coap.js

@@ -0,0 +1,153 @@
+import { Coap, COAP_MULTICAST_IPV4_ADDRESS, COAP_MULTICAST_IPV6_ADDRESS, COAP_MULTICAST_PORT, COAP_OPTION_URI_PATH } from '@matterbridge/dgram';
+import { getIntParameter, getParameter, hasParameter } from '@matterbridge/utils/cli';
+export const MB_COAP_DEFAULT_REQUEST_INTERVAL_MS = 10000;
+export const MB_COAP_DEFAULT_TIMEOUT_MS = 600000;
+function defaultConsoleLog(message) {
+    console.log(message);
+}
+export function getMbCoapHelpText() {
+    return `Copyright (c) Matterbridge. All rights reserved. Version 2.0.0.
+
+Usage: mb_coap [options...]
+
+If no command line is provided, mb_coap starts IPv4 and IPv6 CoAP multicast listeners and waits for incoming traffic for up to 10 minutes.
+
+Options:
+  -h, --help                 Show this help message and exit.
+  --request <interval>       Send a multicast CoAP request to /cit/d (default interval: 10000ms).
+  --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: ::).
+  --no-loopback              Disable multicast loopback (default: enabled).
+  --noIpv4                   Disable IPv4 CoAP server (default: enabled).
+  --noIpv6                   Disable IPv6 CoAP server (default: enabled).
+  --no-timeout               Disable automatic timeout of 10 minutes.
+  -d, --debug                Enable debug logging (default: disabled).
+  -v, --verbose              Enable verbose logging (default: disabled).
+  -s, --silent               Enable silent mode, only log notices, warnings and errors.
+
+Examples:
+  # Start IPv4 and IPv6 CoAP listeners and wait for incoming traffic
+  mb_coap
+
+  # Start listeners and send multicast CoAP requests every 10 seconds
+  mb_coap --request
+
+  # Start listeners and send multicast CoAP requests every 5 seconds
+  mb_coap --request 5000
+
+  # Start listeners only on the eth0 interface
+  mb_coap --interfaceName eth0
+
+  # Start listeners with verbose logging enabled
+  mb_coap --verbose
+
+  # Start only the IPv4 listener and send multicast CoAP requests every 10 seconds
+  mb_coap --request --noIpv6
+
+`;
+}
+export function printMbCoapHelp(log = defaultConsoleLog) {
+    log(getMbCoapHelpText());
+}
+export function getMbCoapOptions() {
+    const requestIntervalMs = hasParameter('request') ? getIntParameter('request') || MB_COAP_DEFAULT_REQUEST_INTERVAL_MS : undefined;
+    return {
+        showHelp: hasParameter('h') || hasParameter('help'),
+        requestIntervalMs,
+        interfaceName: getParameter('interfaceName'),
+        ipv4InterfaceAddress: getParameter('ipv4InterfaceAddress') || '0.0.0.0',
+        ipv6InterfaceAddress: getParameter('ipv6InterfaceAddress') || '::',
+        disableLoopback: hasParameter('no-loopback'),
+        disableIpv4: hasParameter('noIpv4'),
+        disableIpv6: hasParameter('noIpv6'),
+        disableTimeout: hasParameter('no-timeout'),
+    };
+}
+export function startMbCoap(options, exitFn = process.exit, registerSignalHandlers = true) {
+    let coapIpv4;
+    let coapIpv6;
+    if (!options.disableIpv4) {
+        coapIpv4 = new Coap('CoAP Server udp4', COAP_MULTICAST_IPV4_ADDRESS, COAP_MULTICAST_PORT, 'udp4', true, options.interfaceName, options.ipv4InterfaceAddress);
+        if (hasParameter('v') || hasParameter('verbose'))
+            coapIpv4.listNetworkInterfaces();
+    }
+    if (!options.disableIpv6) {
+        coapIpv6 = new Coap('CoAP Server udp6', COAP_MULTICAST_IPV6_ADDRESS, COAP_MULTICAST_PORT, 'udp6', true, options.interfaceName, options.ipv6InterfaceAddress);
+        if (options.disableIpv4 && (hasParameter('v') || hasParameter('verbose')))
+            coapIpv6.listNetworkInterfaces();
+    }
+    function cleanupAndLogAndExit() {
+        coapIpv4?.stop();
+        coapIpv6?.stop();
+        exitFn(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);
+    };
+    if (registerSignalHandlers) {
+        process.on('SIGINT', () => {
+            cleanupAndLogAndExit();
+        });
+    }
+    if (coapIpv4) {
+        coapIpv4.start();
+        coapIpv4.on('ready', (address) => {
+            if (options.disableLoopback) {
+                coapIpv4.socket.setMulticastLoopback(false);
+                coapIpv4.log.info('Multicast loopback disabled for coapIpv4');
+            }
+            coapIpv4.log.info(`coapIpv4 server ready on ${address.family} ${address.address}:${address.port}`);
+            if (options.requestIntervalMs === undefined)
+                return;
+            requestUdp4();
+            setInterval(() => {
+                requestUdp4();
+            }, options.requestIntervalMs).unref();
+        });
+    }
+    if (coapIpv6) {
+        coapIpv6.start();
+        coapIpv6.on('ready', (address) => {
+            if (options.disableLoopback) {
+                coapIpv6.socket.setMulticastLoopback(false);
+                coapIpv6.log.info('Multicast loopback disabled for coapIpv6');
+            }
+            coapIpv6.log.info(`coapIpv6 server ready on ${address.family} ${address.address}:${address.port}`);
+            if (options.requestIntervalMs === undefined)
+                return;
+            requestUdp6();
+            setInterval(() => {
+                requestUdp6();
+            }, options.requestIntervalMs).unref();
+        });
+    }
+    if (!options.disableTimeout) {
+        setTimeout(() => {
+            cleanupAndLogAndExit();
+        }, MB_COAP_DEFAULT_TIMEOUT_MS).unref();
+    }
+    return {
+        coapIpv4,
+        coapIpv6,
+        cleanupAndLogAndExit,
+    };
+}
+export function mbCoapMain(exitFn = process.exit, log = defaultConsoleLog) {
+    const options = getMbCoapOptions();
+    if (options.showHelp) {
+        printMbCoapHelp(log);
+        exitFn(0);
+        return;
+    }
+    return startMbCoap(options, exitFn);
+}

package/dist/mb_health.d.ts

@@ -0,0 +1,10 @@
+export declare function checkHealth(url: string, timeoutMs: number): Promise<boolean>;
+export declare function fetchHealth(url: string, timeoutMs: number): Promise<{
+    ok: boolean;
+    statusCode: number;
+    body: string;
+    json?: unknown;
+}>;
+export declare function mbHealthExitCode(url: string, timeoutMs: number): Promise<number>;
+export declare function mbHealthCli(url: string, timeoutMs: number, exitFn?: (code: number) => never | void): Promise<void>;
+export declare function mbHealthMain(exitFn?: (code: number) => never | void, url?: string): Promise<void>;

package/dist/mb_health.js

@@ -0,0 +1,84 @@
+import http from 'node:http';
+import https from 'node:https';
+const DEFAULT_MB_HEALTH_URL = 'http://localhost:8283/health';
+export async function checkHealth(url, timeoutMs) {
+    try {
+        const { ok } = await fetchHealth(url, timeoutMs);
+        return ok;
+    }
+    catch {
+        return false;
+    }
+}
+export function fetchHealth(url, timeoutMs) {
+    return new Promise((resolve) => {
+        const parsedUrl = new URL(url);
+        const requestImpl = parsedUrl.protocol === 'https:' ? https : http;
+        const isHttps = parsedUrl.protocol === 'https:';
+        const request = requestImpl.request({
+            protocol: parsedUrl.protocol,
+            hostname: parsedUrl.hostname,
+            port: parsedUrl.port,
+            path: parsedUrl.pathname + parsedUrl.search,
+            method: 'GET',
+            ...(isHttps ? { rejectUnauthorized: false } : {}),
+            headers: {
+                'cache-control': 'no-store',
+                'accept': 'application/json',
+            },
+        }, (response) => {
+            const chunks = [];
+            response.on('data', (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            response.on('end', () => {
+                const statusCode = response.statusCode ?? 0;
+                const ok = statusCode >= 200 && statusCode < 300;
+                const body = Buffer.concat(chunks).toString('utf8');
+                let json;
+                try {
+                    if (body.trim().length > 0)
+                        json = JSON.parse(body);
+                }
+                catch {
+                    json = undefined;
+                }
+                resolve({ ok, statusCode, body, json });
+            });
+            response.on('error', () => {
+                resolve({ ok: false, statusCode: response.statusCode ?? 0, body: '' });
+            });
+        });
+        request.on('error', () => resolve({ ok: false, statusCode: 0, body: '' }));
+        request.setTimeout(timeoutMs, () => {
+            request.destroy();
+            resolve({ ok: false, statusCode: 0, body: '' });
+        });
+        request.end();
+    });
+}
+export async function mbHealthExitCode(url, timeoutMs) {
+    try {
+        const { ok } = await fetchHealth(url, timeoutMs);
+        return ok ? 0 : 1;
+    }
+    catch {
+        return 1;
+    }
+}
+export async function mbHealthCli(url, timeoutMs, exitFn = process.exit) {
+    const { ok, statusCode, body, json } = await fetchHealth(url, timeoutMs);
+    if (json !== undefined) {
+        console.log(JSON.stringify(json, null, 2));
+    }
+    else if (body) {
+        console.log(body);
+    }
+    else {
+        console.log(JSON.stringify({ ok, statusCode }, null, 2));
+    }
+    exitFn(ok ? 0 : 1);
+}
+export async function mbHealthMain(exitFn = process.exit, url = DEFAULT_MB_HEALTH_URL) {
+    await mbHealthCli(url, 5000, exitFn);
+}

package/dist/mb_mdns.d.ts

@@ -0,0 +1,34 @@
+import { Mdns } from '@matterbridge/dgram';
+export declare const MB_MDNS_DEFAULT_INTERVAL_MS = 10000;
+export declare const MB_MDNS_DEFAULT_TIMEOUT_MS = 600000;
+export declare const MB_MDNS_CLEANUP_DELAY_MS = 250;
+export interface MbMdnsOptions {
+    showHelp: boolean;
+    interfaceName?: string;
+    ipv4InterfaceAddress: string;
+    ipv6InterfaceAddress: string;
+    outgoingIpv4InterfaceAddress?: string;
+    outgoingIpv6InterfaceAddress?: string;
+    advertiseIntervalMs?: number;
+    queryIntervalMs?: number;
+    unicast: boolean;
+    filters: string[];
+    ipFilters: string[];
+    disableIpv4: boolean;
+    disableIpv6: boolean;
+    disableLoopback: boolean;
+    disableTimeout: boolean;
+    verbose: boolean;
+}
+export interface MbMdnsRuntime {
+    mdnsIpv4?: Mdns;
+    mdnsIpv6?: Mdns;
+    cleanupAndLogAndExit: () => Promise<void>;
+}
+export declare function getMbMdnsHelpText(): string;
+export declare function printMbMdnsHelp(log?: (message: string) => void): void;
+export declare function getMbMdnsOptions(): MbMdnsOptions;
+export declare function sendMdnsQuery(mdns: Mdns, unicast?: boolean): void;
+export declare function advertiseMatterbridgeService(mdns: Mdns, ttl?: number): void;
+export declare function startMbMdns(options: MbMdnsOptions, registerSignalHandlers?: boolean): MbMdnsRuntime;
+export declare function mbMdnsMain(exitFn?: (code: number) => never | void, log?: (message: string) => void): MbMdnsRuntime | undefined;

package/dist/mb_mdns.js

@@ -0,0 +1,278 @@
+import os from 'node:os';
+import { Mdns, MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from '@matterbridge/dgram';
+import { getIntParameter, getParameter, getStringArrayParameter, hasParameter } from '@matterbridge/utils/cli';
+import { excludedInterfaceNamePattern } from '@matterbridge/utils/network';
+import pkg from '../package.json' with { type: 'json' };
+export const MB_MDNS_DEFAULT_INTERVAL_MS = 10000;
+export const MB_MDNS_DEFAULT_TIMEOUT_MS = 600000;
+export const MB_MDNS_CLEANUP_DELAY_MS = 250;
+function defaultConsoleLog(message) {
+    console.log(message);
+}
+export function getMbMdnsHelpText() {
+    return `Copyright (c) Matterbridge. All rights reserved. Version 2.0.0.
+
+Usage: mb_mdns [options...]
+
+If no command line is provided, mb_mdns shows all incoming mDNS records on all interfaces (0.0.0.0 and ::).
+
+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 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).
+  --unicast                                 Enable unicast responses for mDNS queries (default: disabled).
+  --filter <string...>                      Filter strings to match in the mDNS record name (default: no filter).
+  --ip-filter <string...>                   Filter strings to match in the mDNS sender ip address (default: no filter).
+  --noIpv4                                  Disable IPv4 mDNS server (default: enabled).
+  --noIpv6                                  Disable IPv6 mDNS server (default: enabled).
+  --no-loopback                             Disable multicast loopback (default: enabled).
+  --no-timeout                              Disable automatic timeout of 10 minutes.
+  -d, --debug                               Enable debug logging (default: disabled).
+  -v, --verbose                             Enable verbose logging (default: disabled).
+  -s, --silent                              Enable silent mode, only log notices, warnings and errors.
+
+Examples:
+  # Listen for Matter device commissioner service records only on eth0 interface
+  mb_mdns --interfaceName eth0 --filter _matterc._udp
+
+  # Listen for Matter device discovery service records only on eth0 interface
+  mb_mdns --interfaceName eth0 --filter _matter._tcp
+
+  # Listen for Matter commissioner and discovery service records on all interfaces
+  mb_mdns --filter _matterc._udp _matter._tcp
+
+  # Listen for Matter commissioner and discovery service records on all interfaces from specific ipv4 and ipv6 ips
+  mb_mdns --filter _matterc._udp _matter._tcp --ip-filter 192.168.69.20 fe80::1077:2e0d:2c91:aa90
+
+  # Query for mDNS devices every 10s on a specific interface
+  mb_mdns --interfaceName eth0 --query
+
+  # Advertise _matterbridge._tcp.local every 5s with filter
+  mb_mdns --advertise 5000 --filter _matterbridge._tcp.local
+
+  # Query each 5s and listen for _matterbridge._tcp.local service records
+  mb_mdns --query 5000 --filter _matterbridge._tcp.local
+`;
+}
+export function printMbMdnsHelp(log = defaultConsoleLog) {
+    log(getMbMdnsHelpText());
+}
+export function getMbMdnsOptions() {
+    const advertiseIntervalMs = hasParameter('advertise') ? getIntParameter('advertise') || MB_MDNS_DEFAULT_INTERVAL_MS : undefined;
+    const queryIntervalMs = hasParameter('query') ? getIntParameter('query') || MB_MDNS_DEFAULT_INTERVAL_MS : undefined;
+    return {
+        showHelp: hasParameter('h') || hasParameter('help'),
+        interfaceName: getParameter('interfaceName'),
+        ipv4InterfaceAddress: getParameter('ipv4InterfaceAddress') || '0.0.0.0',
+        ipv6InterfaceAddress: getParameter('ipv6InterfaceAddress') || '::',
+        outgoingIpv4InterfaceAddress: getParameter('outgoingIpv4InterfaceAddress'),
+        outgoingIpv6InterfaceAddress: getParameter('outgoingIpv6InterfaceAddress'),
+        advertiseIntervalMs,
+        queryIntervalMs,
+        unicast: hasParameter('unicast'),
+        filters: getStringArrayParameter('filter') ?? [],
+        ipFilters: getStringArrayParameter('ip-filter') ?? [],
+        disableIpv4: hasParameter('noIpv4'),
+        disableIpv6: hasParameter('noIpv6'),
+        disableLoopback: hasParameter('no-loopback'),
+        disableTimeout: hasParameter('no-timeout'),
+        verbose: hasParameter('v') || hasParameter('verbose'),
+    };
+}
+export function sendMdnsQuery(mdns, unicast = false) {
+    mdns.log.info('Sending mDNS query for common services...');
+    try {
+        mdns.sendQuery([
+            { name: '_matterc._udp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_matter._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_matterbridge._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_home-assistant._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_shelly._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_mqtt._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_http._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_googlecast._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_airplay._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_amzn-alexa._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_companion-link._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_hap._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_hap._udp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_ipp._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_ipps._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_meshcop._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_printer._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_raop._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_sleep-proxy._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_ssh._tcp.local', type: 12, class: 1, unicastResponse: unicast },
+            { name: '_services._dns-sd._udp.local', type: 12, class: 1, unicastResponse: unicast },
+        ]);
+    }
+    catch (error) {
+        mdns.log.error(`Error sending mDNS query: ${error.message}`);
+    }
+}
+export function advertiseMatterbridgeService(mdns, ttl = 120) {
+    mdns.log.info(`Sending mDNS advertisement for matterbridge service with TTL ${ttl ? ttl.toString() : 'goodbye'}...`);
+    const httpServiceType = '_http._tcp.local';
+    const matterbridgeServiceType = '_matterbridge._tcp.local';
+    const httpInstanceName = 'matterbridge._http._tcp.local';
+    const matterbridgeInstanceName = 'matterbridge._matterbridge._tcp.local';
+    const hostName = 'matterbridge.local';
+    const port = 8283;
+    const ptrHttpServiceTypeRdata = mdns.encodeDnsName(httpServiceType);
+    const ptrMatterbridgeServiceTypeRdata = mdns.encodeDnsName(matterbridgeServiceType);
+    const ptrHttpInstanceRdata = mdns.encodeDnsName(httpInstanceName);
+    const ptrMatterbridgeInstanceRdata = mdns.encodeDnsName(matterbridgeInstanceName);
+    const srvRdata = mdns.encodeSrvRdata(0, 0, port, hostName);
+    const txtRdata = mdns.encodeTxtRdata([`version=${pkg.version}`, 'path=/']);
+    const answers = [
+        { name: '_services._dns-sd._udp.local', rtype: 12, rclass: 1, ttl, rdata: ptrHttpServiceTypeRdata },
+        { name: httpServiceType, rtype: 12, rclass: 1, ttl, rdata: ptrHttpInstanceRdata },
+        { name: '_services._dns-sd._udp.local', rtype: 12, rclass: 1, ttl, rdata: ptrMatterbridgeServiceTypeRdata },
+        { name: matterbridgeServiceType, rtype: 12, rclass: 1, ttl, rdata: ptrMatterbridgeInstanceRdata },
+        { name: httpInstanceName, rtype: 33, rclass: 1 | 32768, ttl, rdata: srvRdata },
+        { name: matterbridgeInstanceName, rtype: 33, rclass: 1 | 32768, ttl, rdata: srvRdata },
+        { name: httpInstanceName, rtype: 16, rclass: 1 | 32768, ttl, rdata: txtRdata },
+        { name: matterbridgeInstanceName, rtype: 16, rclass: 1 | 32768, ttl, rdata: txtRdata },
+    ];
+    const interfaces = os.networkInterfaces();
+    let interfaceInfos = mdns.interfaceName ? (interfaces[mdns.interfaceName] ?? []) : [];
+    if (interfaceInfos.length === 0) {
+        for (const name of Object.keys(interfaces)) {
+            if (excludedInterfaceNamePattern.test(name))
+                continue;
+            const infos = interfaces[name];
+            if (infos && infos.length > 0 && !infos[0].internal) {
+                interfaceInfos = infos;
+                break;
+            }
+        }
+    }
+    for (const info of interfaceInfos) {
+        if (info.family === 'IPv4' && !info.internal) {
+            answers.push({ name: hostName, rtype: 1, rclass: 1 | 32768, ttl, rdata: mdns.encodeA(info.address) });
+        }
+        else if (info.family === 'IPv6' && !info.internal) {
+            answers.push({ name: hostName, rtype: 28, rclass: 1 | 32768, ttl, rdata: mdns.encodeAAAA(info.address) });
+        }
+    }
+    try {
+        mdns.sendResponse(answers);
+    }
+    catch (error) {
+        mdns.log.error(`Error sending mDNS advertisement: ${error.message}`);
+    }
+}
+export function startMbMdns(options, registerSignalHandlers = true) {
+    let mdnsIpv4QueryInterval;
+    let mdnsIpv6QueryInterval;
+    let mdnsIpv4AdvertiseInterval;
+    let mdnsIpv6AdvertiseInterval;
+    let mdnsIpv4;
+    let mdnsIpv6;
+    async function cleanupAndLogAndExit() {
+        clearInterval(mdnsIpv4QueryInterval);
+        clearInterval(mdnsIpv6QueryInterval);
+        clearInterval(mdnsIpv4AdvertiseInterval);
+        clearInterval(mdnsIpv6AdvertiseInterval);
+        if (options.advertiseIntervalMs !== undefined) {
+            if (mdnsIpv4)
+                advertiseMatterbridgeService(mdnsIpv4, 0);
+            if (mdnsIpv6)
+                advertiseMatterbridgeService(mdnsIpv6, 0);
+        }
+        await new Promise((resolve) => setTimeout(resolve, MB_MDNS_CLEANUP_DELAY_MS));
+        mdnsIpv4?.stop();
+        mdnsIpv6?.stop();
+        mdnsIpv4?.logDevices();
+        mdnsIpv6?.logDevices();
+        await new Promise((resolve) => setTimeout(resolve, MB_MDNS_CLEANUP_DELAY_MS));
+    }
+    if (!options.disableIpv4) {
+        mdnsIpv4 = new Mdns('mDNS Server udp4', MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT, 'udp4', true, options.interfaceName, options.ipv4InterfaceAddress, options.outgoingIpv4InterfaceAddress);
+        if (options.verbose)
+            mdnsIpv4.listNetworkInterfaces();
+        if (options.filters.length > 0)
+            mdnsIpv4.filters.push(...options.filters);
+        if (options.ipFilters.length > 0)
+            mdnsIpv4.ipFilters.push(...options.ipFilters);
+        mdnsIpv4.on('error', (err) => {
+            mdnsIpv4?.log.error(`mDNS udp4 Server error: ${err.message}\n${err.stack}`);
+        });
+        mdnsIpv4.start();
+        mdnsIpv4.on('ready', (address) => {
+            if (options.disableLoopback) {
+                mdnsIpv4?.socket.setMulticastLoopback(false);
+                mdnsIpv4?.log.info('Multicast loopback disabled for mdnsIpv4');
+            }
+            mdnsIpv4?.log.info(`mdnsIpv4 server ready on ${address.family} ${address.address}:${address.port}`);
+            if (options.advertiseIntervalMs !== undefined) {
+                advertiseMatterbridgeService(mdnsIpv4);
+                mdnsIpv4AdvertiseInterval = setInterval(() => advertiseMatterbridgeService(mdnsIpv4), options.advertiseIntervalMs).unref();
+            }
+            if (options.queryIntervalMs !== undefined) {
+                sendMdnsQuery(mdnsIpv4, options.unicast);
+                mdnsIpv4QueryInterval = setInterval(() => sendMdnsQuery(mdnsIpv4, options.unicast), options.queryIntervalMs).unref();
+            }
+        });
+    }
+    if (!options.disableIpv6) {
+        mdnsIpv6 = new Mdns('mDNS Server udp6', MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, 'udp6', true, options.interfaceName, options.ipv6InterfaceAddress, options.outgoingIpv6InterfaceAddress);
+        if (options.disableIpv4 && options.verbose)
+            mdnsIpv6.listNetworkInterfaces();
+        if (options.filters.length > 0)
+            mdnsIpv6.filters.push(...options.filters);
+        if (options.ipFilters.length > 0)
+            mdnsIpv6.ipFilters.push(...options.ipFilters);
+        mdnsIpv6.on('error', (err) => {
+            mdnsIpv6?.log.error(`mDNS udp6 Server error: ${err.message}\n${err.stack}`);
+        });
+        mdnsIpv6.start();
+        mdnsIpv6.on('ready', (address) => {
+            if (options.disableLoopback) {
+                mdnsIpv6?.socket.setMulticastLoopback(false);
+                mdnsIpv6?.log.info('Multicast loopback disabled for mdnsIpv6');
+            }
+            mdnsIpv6?.log.info(`mdnsIpv6 server ready on ${address.family} ${address.address}:${address.port}`);
+            if (options.advertiseIntervalMs !== undefined) {
+                advertiseMatterbridgeService(mdnsIpv6);
+                mdnsIpv6AdvertiseInterval = setInterval(() => advertiseMatterbridgeService(mdnsIpv6), options.advertiseIntervalMs).unref();
+            }
+            if (options.queryIntervalMs !== undefined) {
+                sendMdnsQuery(mdnsIpv6, options.unicast);
+                mdnsIpv6QueryInterval = setInterval(() => sendMdnsQuery(mdnsIpv6, options.unicast), options.queryIntervalMs).unref();
+            }
+        });
+    }
+    if (registerSignalHandlers) {
+        process.on('SIGINT', async () => {
+            await cleanupAndLogAndExit();
+        });
+        process.on('SIGTERM', async () => {
+            await cleanupAndLogAndExit();
+        });
+    }
+    if (!options.disableTimeout) {
+        setTimeout(async () => {
+            await cleanupAndLogAndExit();
+        }, MB_MDNS_DEFAULT_TIMEOUT_MS).unref();
+    }
+    return {
+        mdnsIpv4,
+        mdnsIpv6,
+        cleanupAndLogAndExit,
+    };
+}
+export function mbMdnsMain(exitFn = process.exit, log = defaultConsoleLog) {
+    const options = getMbMdnsOptions();
+    if (options.showHelp) {
+        printMbMdnsHelp(log);
+        exitFn(0);
+        return;
+    }
+    return startMbMdns(options);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.7.1-dev-20260325-72b7b24",
+  "version": "3.7.1-dev-20260326-40eef29",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -122,10 +122,10 @@
   ],
   "dependencies": {
     "@matter/main": "0.16.10",
-    "@matterbridge/dgram": "3.7.1-dev-20260325-72b7b24",
-    "@matterbridge/thread": "3.7.1-dev-20260325-72b7b24",
-    "@matterbridge/types": "3.7.1-dev-20260325-72b7b24",
-    "@matterbridge/utils": "3.7.1-dev-20260325-72b7b24",
+    "@matterbridge/dgram": "3.7.1-dev-20260326-40eef29",
+    "@matterbridge/thread": "3.7.1-dev-20260326-40eef29",
+    "@matterbridge/types": "3.7.1-dev-20260326-40eef29",
+    "@matterbridge/utils": "3.7.1-dev-20260326-40eef29",
     "express": "5.2.1",
     "multer": "2.1.1",
     "node-ansi-logger": "3.2.0",