matterbridge 3.4.7-dev-20260104-6b10cee → 3.4.7-dev-20260112-a00b2bf

package/dist/dgram/dgram.d.ts

@@ -0,0 +1,45 @@
+import dgram from 'node:dgram';
+import EventEmitter from 'node:events';
+import { AddressInfo } from 'node:net';
+import { AnsiLogger } from 'node-ansi-logger';
+export interface DgramEvents {
+    error: [error: Error];
+    close: [];
+    connect: [];
+    message: [msg: Buffer, rinfo: dgram.RemoteInfo];
+    listening: [address: AddressInfo];
+    sent: [msg: Buffer, serverAddress: string, serverPort: number];
+    ready: [address: AddressInfo];
+    bound: [address: AddressInfo];
+}
+export declare class Dgram extends EventEmitter<DgramEvents> {
+    verbose: boolean;
+    debug: boolean;
+    silent: boolean;
+    log: AnsiLogger;
+    socket: dgram.Socket;
+    bound: boolean;
+    socketType: 'udp4' | 'udp6';
+    interfaceName?: string;
+    interfaceAddress?: string;
+    interfaceNetmask?: string;
+    excludedInterfaceNamePattern: RegExp;
+    constructor(name: string, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string);
+    send(msg: Buffer, serverAddress: string, serverPort: number): void;
+    onError(error: Error): void;
+    onClose(): void;
+    onConnect(): void;
+    onSent(msg: Buffer, serverAddress: string, serverPort: number): void;
+    onMessage(msg: Buffer, rinfo: dgram.RemoteInfo): void;
+    onListening(address: AddressInfo): void;
+    onReady(address: AddressInfo): void;
+    getIpv4InterfaceAddress(networkInterface?: string): string | undefined;
+    getIpv6InterfaceAddress(networkInterface?: string): string | undefined;
+    getInterfacesNames(): string[];
+    getIpv6ScopeId(interfaceName?: string): string;
+    getInterfaceNameFromScopeId(scopeId: number): string | undefined;
+    getNetmask(interfaceAddress: string): string | undefined;
+    getIpv4BroadcastAddress(ipAddress: string | undefined, netmask: string | undefined): string | undefined;
+    getIpv6BroadcastAddress(): string;
+    listNetworkInterfaces(): void;
+}

package/dist/dgram/dgram.js

@@ -14,6 +14,7 @@ export class Dgram extends EventEmitter {
     interfaceName;
     interfaceAddress;
     interfaceNetmask;
+    excludedInterfaceNamePattern = /(tailscale|wireguard|wintun|openvpn|\bwg\d*\b|\btun\d*\b|\btap\d*\b|\butun\d*\b|zerotier|hamachi|hyper-?v|v\s*ethernet|wsl|default switch|vmware|vmnet|vbox|virtualbox|virbr|docker|podman|\bveth\b|\bbr-\b|cni|kube|flannel|calico|teredo|isatap)/i;
     constructor(name, socketType, reuseAddr = true, interfaceName, interfaceAddress) {
         super();
         this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: this.debug ? "debug" : this.silent ? "notice" : "info" });
@@ -98,7 +99,7 @@ export class Dgram extends EventEmitter {
         }
         if (!networkInterface) {
             for (const [interfaceName, interfaceDetails] of Object.entries(interfaces)) {
-                if (interfaceName.toLowerCase().includes('tailscale'))
+                if (!networkInterface && this.excludedInterfaceNamePattern.test(interfaceName))
                     continue;
                 if (!interfaceDetails)
                     continue;
@@ -185,6 +186,8 @@ export class Dgram extends EventEmitter {
         for (const name in interfaces) {
             if (interfaceName && name !== interfaceName)
                 continue;
+            if (!interfaceName && this.excludedInterfaceNamePattern.test(name))
+                continue;
             const iface = interfaces[name];
             if (iface) {
                 const ipv6Address = iface.find((addr) => addr.family === 'IPv6' && !addr.internal && addr.scopeid);

package/dist/dgram/mb_coap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dgram/mb_coap.js

@@ -1,5 +1,4 @@
-import { COAP_MULTICAST_IPV4_ADDRESS, COAP_MULTICAST_IPV6_ADDRESS, COAP_MULTICAST_PORT } from './multicast.js';
-import { Coap, COAP_OPTION_URI_PATH } from './coap.js';
+import { COAP_MULTICAST_IPV4_ADDRESS, COAP_MULTICAST_IPV6_ADDRESS, COAP_MULTICAST_PORT, Coap, COAP_OPTION_URI_PATH } from '@matterbridge/dgram';
 {
     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);

package/dist/dgram/mb_mdns.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dgram/mb_mdns.js

@@ -1,9 +1,6 @@
 import os from 'node:os';
-import { getIntParameter, getParameter, getStringArrayParameter, hasParameter } from '../utils/commandLine.js';
-import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from './multicast.js';
-import { Mdns } from './mdns.js';
-import { MdnsReflectorClient } from './mdnsReflectorClient.js';
-import { MdnsReflectorServer } from './mdnsReflectorServer.js';
+import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, Mdns } from '@matterbridge/dgram';
+import { getIntParameter, getParameter, getStringArrayParameter, hasParameter } from '@matterbridge/utils';
 {
     if (hasParameter('h') || hasParameter('help')) {
         console.log(`Copyright (c) Matterbridge. All rights reserved. Version 1.0.0.\n`);
@@ -24,14 +21,6 @@ Options:
   --noIpv4                                  Disable IPv4 mDNS server (default: enabled).
   --noIpv6                                  Disable IPv6 mDNS server (default: enabled).
   --no-timeout                              Disable automatic timeout of 10 minutes. Reflector mode disables timeout automatically.
-  --reflector-client                        Enable mDNS reflector client (default: disabled).
-    --filter <string[]>                     Filters to apply to incoming mDNS messages.
-    --localhost                             Use localhost addresses to send messages to the container.
-  --reflector-server                        Enable mDNS reflector server (default: disabled).
-    --filter <string[]>                     Filters to apply to incoming mDNS messages.
-    --broadcast                             Use broadcast addresses to reflect messages to the lan.
-    --localhost                             Use localhost addresses to reflect messages to the lan.
-    --share-with-clients                    Share messages between reflector clients.
   -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.
@@ -64,8 +53,6 @@ Examples:
     let mdnsIpv6AdvertiseInterval;
     let mdnsIpv4 = undefined;
     let mdnsIpv6 = undefined;
-    let reflectorClient = undefined;
-    let reflectorServer = undefined;
     async function cleanupAndLogAndExit() {
         clearInterval(mdnsIpv4QueryInterval);
         clearInterval(mdnsIpv6QueryInterval);
@@ -83,21 +70,25 @@ Examples:
         mdnsIpv4?.logDevices();
         mdnsIpv6?.logDevices();
         await new Promise((resolve) => setTimeout(resolve, 250));
-        await reflectorClient?.stop();
-        await reflectorServer?.stop();
     }
     const query = (mdns) => {
         mdns.log.info('Sending mDNS query for common services...');
-        mdns.sendQuery([
-            { name: '_matterc._udp.local', type: 12, class: 1, unicastResponse: true },
-            { name: '_matter._tcp.local', type: 12, class: 1, unicastResponse: true },
-            { name: '_matterbridge._tcp.local', type: 12, class: 1, unicastResponse: true },
-            { name: '_home-assistant._tcp.local', type: 12, class: 1, unicastResponse: true },
-            { name: '_shelly._tcp.local', type: 12, class: 1, unicastResponse: true },
-            { name: '_mqtt._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 },
-        ]);
+        try {
+            mdns.sendQuery([
+                { name: '_matterc._udp.local', type: 12, class: 1, unicastResponse: true },
+                { name: '_matter._tcp.local', type: 12, class: 1, unicastResponse: true },
+                { name: '_matterbridge._tcp.local', type: 12, class: 1, unicastResponse: true },
+                { name: '_home-assistant._tcp.local', type: 12, class: 1, unicastResponse: true },
+                { name: '_shelly._tcp.local', type: 12, class: 1, unicastResponse: true },
+                { name: '_mqtt._tcp.local', type: 12, class: 1, unicastResponse: true },
+                { name: '_http._tcp.local', type: 12, class: 1, unicastResponse: true },
+                { name: '_googlecast._tcp.local', type: 12, class: 1, unicastResponse: true },
+                { name: '_services._dns-sd._udp.local', type: 12, class: 1, unicastResponse: true },
+            ]);
+        }
+        catch (error) {
+            mdns.log.error(`Error sending mDNS query: ${error.message}`);
+        }
     };
     const advertise = (mdns, ttl = 120) => {
         mdns.log.info(`Sending mDNS advertisement for matterbridge service with TTL ${ttl ? ttl.toString() : 'goodbye'}...`);
@@ -135,30 +126,33 @@ Examples:
                 }
             }
         }
-        try {
-            for (const info of interfaceInfos) {
-                if (info.family === 'IPv4' && !info.internal) {
-                    const ipv4 = info.address;
-                    answers.push({ name: hostName, rtype: 1, rclass: 1 | 32768, ttl, rdata: mdns.encodeA(ipv4) });
-                }
-                else if (info.family === 'IPv6' && !info.internal) {
-                    const ipv6 = info.address;
-                    answers.push({ name: hostName, rtype: 28, rclass: 1 | 32768, ttl, rdata: mdns.encodeAAAA(ipv6) });
-                }
+        for (const info of interfaceInfos) {
+            if (info.family === 'IPv4' && !info.internal) {
+                const ipv4 = info.address;
+                answers.push({ name: hostName, rtype: 1, rclass: 1 | 32768, ttl, rdata: mdns.encodeA(ipv4) });
             }
+            else if (info.family === 'IPv6' && !info.internal) {
+                const ipv6 = info.address;
+                answers.push({ name: hostName, rtype: 28, rclass: 1 | 32768, ttl, rdata: mdns.encodeAAAA(ipv6) });
+            }
+        }
+        try {
+            mdns.sendResponse(answers);
         }
         catch (error) {
-            mdns.log.error(`Error encoding network interface addresses: ${error.message}`);
+            mdns.log.error(`Error sending mDNS advertisement: ${error.message}`);
         }
-        const _response = mdns.sendResponse(answers);
     };
-    if (!hasParameter('noIpv4') && !hasParameter('reflector-server') && !hasParameter('reflector-client')) {
+    if (!hasParameter('noIpv4')) {
         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'));
         if (hasParameter('v') || hasParameter('verbose'))
             mdnsIpv4.listNetworkInterfaces();
         const filters = getStringArrayParameter('filter');
         if (filters)
             mdnsIpv4.filters.push(...filters);
+        mdnsIpv4.on('error', (err) => {
+            mdnsIpv4?.log.error(`mDNS udp4 Server error: ${err.message}\n${err.stack}`);
+        });
         mdnsIpv4.start();
         mdnsIpv4.on('ready', (address) => {
             mdnsIpv4?.socket.setMulticastLoopback(false);
@@ -173,13 +167,16 @@ Examples:
             }
         });
     }
-    if (!hasParameter('noIpv6') && !hasParameter('reflector-server') && !hasParameter('reflector-client')) {
+    if (!hasParameter('noIpv6')) {
         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'))
             mdnsIpv6.listNetworkInterfaces();
         const filters = getStringArrayParameter('filter');
         if (filters)
             mdnsIpv6.filters.push(...filters);
+        mdnsIpv6.on('error', (err) => {
+            mdnsIpv6?.log.error(`mDNS udp6 Server error: ${err.message}\n${err.stack}`);
+        });
         mdnsIpv6.start();
         mdnsIpv6.on('ready', (address) => {
             mdnsIpv6?.socket.setMulticastLoopback(false);
@@ -194,21 +191,13 @@ Examples:
             }
         });
     }
-    if (hasParameter('reflector-client')) {
-        reflectorClient = new MdnsReflectorClient();
-        await reflectorClient.start();
-    }
-    if (hasParameter('reflector-server')) {
-        reflectorServer = new MdnsReflectorServer();
-        await reflectorServer.start();
-    }
     process.on('SIGINT', async () => {
         await cleanupAndLogAndExit();
     });
     process.on('SIGTERM', async () => {
         await cleanupAndLogAndExit();
     });
-    if (!hasParameter('no-timeout') && !hasParameter('reflector-server') && !hasParameter('reflector-client')) {
+    if (!hasParameter('no-timeout')) {
         setTimeout(async () => {
             await cleanupAndLogAndExit();
         }, 600000).unref();

package/dist/dgram/mdns.d.ts

@@ -0,0 +1,188 @@
+import dgram from 'node:dgram';
+import { AnsiLogger } from 'node-ansi-logger';
+import { Multicast } from './multicast.js';
+export declare const enum DnsRecordType {
+    A = 1,
+    NS = 2,
+    MD = 3,
+    MF = 4,
+    CNAME = 5,
+    SOA = 6,
+    MB = 7,
+    MG = 8,
+    MR = 9,
+    NULL = 10,
+    WKS = 11,
+    PTR = 12,
+    HINFO = 13,
+    MINFO = 14,
+    MX = 15,
+    TXT = 16,
+    RP = 17,
+    AFSDB = 18,
+    X25 = 19,
+    ISDN = 20,
+    RT = 21,
+    NSAP = 22,
+    NSAP_PTR = 23,
+    SIG = 24,
+    KEY = 25,
+    PX = 26,
+    GPOS = 27,
+    AAAA = 28,
+    LOC = 29,
+    NXT = 30,
+    EID = 31,
+    NIMLOC = 32,
+    SRV = 33,
+    ATMA = 34,
+    NAPTR = 35,
+    KX = 36,
+    CERT = 37,
+    A6 = 38,
+    DNAME = 39,
+    SINK = 40,
+    OPT = 41,
+    APL = 42,
+    DS = 43,
+    SSHFP = 44,
+    IPSECKEY = 45,
+    RRSIG = 46,
+    NSEC = 47,
+    DNSKEY = 48,
+    DHCID = 49,
+    NSEC3 = 50,
+    NSEC3PARAM = 51,
+    TLSA = 52,
+    SMIMEA = 53,
+    HIP = 55,
+    NINFO = 56,
+    RKEY = 57,
+    TALINK = 58,
+    CDS = 59,
+    CDNSKEY = 60,
+    OPENPGPKEY = 61,
+    CSYNC = 62,
+    ZONEMD = 63,
+    SVCB = 64,
+    HTTPS = 65,
+    SPF = 99,
+    UINFO = 100,
+    UID = 101,
+    GID = 102,
+    UNSPEC = 103,
+    NID = 104,
+    L32 = 105,
+    L64 = 106,
+    LP = 107,
+    EUI48 = 108,
+    EUI64 = 109,
+    TKEY = 249,
+    TSIG = 250,
+    IXFR = 251,
+    AXFR = 252,
+    MAILB = 253,
+    MAILA = 254,
+    ANY = 255,
+    URI = 256,
+    CAA = 257,
+    AVC = 258,
+    DOA = 259,
+    AMTRELAY = 260,
+    ZONEVERSION = 261,
+    TA = 32768,
+    DLV = 32769
+}
+export declare const enum DnsClass {
+    IN = 1,
+    CH = 3,
+    HS = 4,
+    ANY = 255
+}
+export declare const enum DnsClassFlag {
+    FLUSH = 32768,
+    QU = 32768
+}
+export interface MdnsMessage {
+    id: number;
+    qr: number;
+    opcode: number;
+    aa: boolean;
+    tc: boolean;
+    rd: boolean;
+    ra: boolean;
+    z: number;
+    rcode: number;
+    qdCount: number;
+    anCount: number;
+    nsCount: number;
+    arCount: number;
+    questions?: DnsQuestion[];
+    answers?: MdnsRecord[];
+    authorities?: MdnsRecord[];
+    additionals?: MdnsRecord[];
+}
+interface DnsQuestion {
+    name: string;
+    type: number;
+    class: number;
+}
+interface MdnsRecord {
+    name: string;
+    type: number;
+    class: number;
+    ttl: number;
+    data: string;
+}
+export declare function isMdns(message: Buffer): boolean;
+export declare function isMdnsQuery(message: Buffer): boolean;
+export declare function isMdnsResponse(message: Buffer): boolean;
+export declare class Mdns extends Multicast {
+    deviceQueries: Map<string, {
+        rinfo: dgram.RemoteInfo;
+        query: MdnsMessage;
+    }>;
+    deviceResponses: Map<string, {
+        rinfo: dgram.RemoteInfo;
+        response: MdnsMessage;
+        dataPTR?: string;
+    }>;
+    filters: string[];
+    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, outgoingInterfaceAddress?: string);
+    onQuery(rinfo: dgram.RemoteInfo, _query: MdnsMessage): void;
+    onResponse(rinfo: dgram.RemoteInfo, _response: MdnsMessage): void;
+    onMessage(msg: Buffer, rinfo: dgram.RemoteInfo): void;
+    decodeMdnsMessage(msg: Buffer): MdnsMessage;
+    decodeDnsName(msg: Buffer, offset: number): {
+        name: string;
+        newOffset: number;
+    };
+    encodeDnsName(name: string): Buffer;
+    encodeTxtRdata(txt: string[]): Buffer;
+    encodeSrvRdata(priority: number, weight: number, port: number, target: string): Buffer;
+    encodeA(ipv4: string): Buffer;
+    encodeAAAA(ipv6WithOptionalScope: string): Buffer;
+    decodeResourceRecord(msg: Buffer, offset: number): {
+        record: MdnsRecord;
+        newOffset: number;
+    };
+    sendQuery(questions: {
+        name: string;
+        type: number;
+        class: number;
+        unicastResponse?: boolean;
+    }[]): Buffer<ArrayBuffer>;
+    sendResponse(answers: {
+        name: string;
+        rtype: number;
+        rclass: number;
+        ttl: number;
+        rdata: Buffer;
+    }[]): Buffer<ArrayBuffer>;
+    dnsTypeToString(type: number): string;
+    dnsResponseClassToString(cls: number): string;
+    dnsQuestionClassToString(cls: number): string;
+    logMdnsMessage(msg: MdnsMessage, log?: AnsiLogger, text?: string): void;
+    logDevices(): void;
+}
+export {};

package/dist/dgram/multicast.d.ts

@@ -0,0 +1,18 @@
+import { AddressInfo } from 'node:net';
+import { Dgram } from './dgram.js';
+export declare const MDNS_MULTICAST_IPV4_ADDRESS = "224.0.0.251";
+export declare const MDNS_MULTICAST_IPV6_ADDRESS = "ff02::fb";
+export declare const MDNS_MULTICAST_PORT = 5353;
+export declare const COAP_MULTICAST_IPV4_ADDRESS = "224.0.1.187";
+export declare const COAP_MULTICAST_IPV6_ADDRESS = "ff02::fd";
+export declare const COAP_MULTICAST_PORT = 5683;
+export declare class Multicast extends Dgram {
+    multicastAddress: string;
+    multicastPort: number;
+    outgoingInterfaceAddress: string | undefined;
+    joinedInterfaces: string[];
+    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, outgoingInterfaceAddress?: string);
+    start(): void;
+    onListening(address: AddressInfo): void;
+    stop(): void;
+}

package/dist/dgram/unicast.d.ts

@@ -0,0 +1,11 @@
+import { AddressInfo } from 'node:net';
+import { RemoteInfo } from 'node:dgram';
+import { Dgram } from './dgram.js';
+export declare class Unicast extends Dgram {
+    port: number | undefined;
+    constructor(name: string, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string, port?: number);
+    start(): void;
+    onListening(address: AddressInfo): void;
+    onMessage(msg: Buffer, rinfo: RemoteInfo): void;
+    stop(): void;
+}

package/dist/frontend.d.ts

@@ -0,0 +1,58 @@
+import EventEmitter from 'node:events';
+import { LogLevel } from 'node-ansi-logger';
+import { EndpointNumber } from '@matter/types/datatype';
+import type { ApiMatter } from './matterbridgeTypes.js';
+import type { Matterbridge } from './matterbridge.js';
+import type { RefreshRequiredChanged, WsMessageBroadcast } from './frontendTypes.js';
+interface FrontendEvents {
+    server_listening: [protocol: string, port: number, address?: string];
+    server_error: [error: Error];
+    server_stopped: [];
+    websocket_server_listening: [protocol: string];
+    websocket_server_stopped: [];
+}
+export declare class Frontend extends EventEmitter<FrontendEvents> {
+    private matterbridge;
+    private log;
+    private port;
+    private listening;
+    private storedPassword;
+    private expressApp;
+    private httpServer;
+    private httpsServer;
+    private webSocketServer;
+    private readonly server;
+    private readonly debug;
+    private readonly verbose;
+    constructor(matterbridge: Matterbridge);
+    destroy(): void;
+    private msgHandler;
+    set logLevel(logLevel: LogLevel);
+    start(port?: number): Promise<void>;
+    stop(): Promise<void>;
+    private getApiSettings;
+    private getReachability;
+    private getPowerSource;
+    private getBatteryLevel;
+    private getClusterTextFromDevice;
+    private getPlugins;
+    private getDevices;
+    private getClusters;
+    private generateDiagnostic;
+    private wsMessageHandler;
+    wssSendLogMessage(level: string, time: string, name: string, message: string): void;
+    wssSendRefreshRequired(changed: RefreshRequiredChanged, params?: {
+        matter: ApiMatter;
+    }): void;
+    wssSendRestartRequired(snackbar?: boolean, fixed?: boolean): void;
+    wssSendRestartNotRequired(snackbar?: boolean): void;
+    wssSendUpdateRequired(devVersion?: boolean): void;
+    wssSendCpuUpdate(cpuUsage: number, processCpuUsage: number): void;
+    wssSendMemoryUpdate(totalMemory: string, freeMemory: string, rss: string, heapTotal: string, heapUsed: string, external: string, arrayBuffers: string): void;
+    wssSendUptimeUpdate(systemUptime: string, processUptime: string): void;
+    wssSendSnackbarMessage(message: string, timeout?: number, severity?: 'info' | 'warning' | 'error' | 'success'): void;
+    wssSendCloseSnackbarMessage(message: string): void;
+    wssSendAttributeChangedMessage(plugin: string, serialNumber: string, uniqueId: string, number: EndpointNumber, id: string, cluster: string, attribute: string, value: number | string | boolean | null): void;
+    wssBroadcastMessage(msg: WsMessageBroadcast): void;
+}
+export {};