matterbridge 3.4.6-dev-20251228-e06f048 → 3.4.6-dev-20251228-76bd627

package/dist/dgram/mb_mdns.js

@@ -81,7 +81,7 @@ Examples:
         await reflectorServer?.stop();
     }
     const query = (mdns) => {
-        mdns.log.info('Sending mDNS query for services...');
+        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 },
@@ -154,6 +154,7 @@ Examples:
             mdnsIpv4.filters.push(...filters);
         mdnsIpv4.start();
         mdnsIpv4.on('ready', (address) => {
+            mdnsIpv4?.socket.setMulticastLoopback(false);
             mdnsIpv4?.log.info(`mdnsIpv4 server ready on ${address.family} ${address.address}:${address.port}`);
             if (hasParameter('advertise')) {
                 advertise(mdnsIpv4);
@@ -174,6 +175,7 @@ Examples:
             mdnsIpv6.filters.push(...filters);
         mdnsIpv6.start();
         mdnsIpv6.on('ready', (address) => {
+            mdnsIpv6?.socket.setMulticastLoopback(false);
             mdnsIpv6?.log.info(`mdnsIpv6 server ready on ${address.family} ${address.address}:${address.port}`);
             if (hasParameter('advertise')) {
                 advertise(mdnsIpv6);

package/dist/dgram/mdns.js

@@ -1,4 +1,4 @@
-import { BLUE, CYAN, db, er, GREEN, idn, MAGENTA, nf, rs } from 'node-ansi-logger';
+import { BLUE, CYAN, db, GREEN, idn, MAGENTA, nf, rs } from 'node-ansi-logger';
 import { hasParameter } from '../utils/commandLine.js';
 import { Multicast } from './multicast.js';
 export var DnsRecordType;
@@ -106,6 +106,28 @@ export var DnsClassFlag;
     DnsClassFlag[DnsClassFlag["FLUSH"] = 32768] = "FLUSH";
     DnsClassFlag[DnsClassFlag["QU"] = 32768] = "QU";
 })(DnsClassFlag || (DnsClassFlag = {}));
+export function isMdns(message) {
+    if (!message || message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    return id === 0;
+}
+export function isMdnsQuery(message) {
+    if (message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    const flags = message.readUInt16BE(2);
+    const qr = (flags & 0x8000) >> 15;
+    return id == 0 && qr === 0;
+}
+export function isMdnsResponse(message) {
+    if (message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    const flags = message.readUInt16BE(2);
+    const qr = (flags & 0x8000) >> 15;
+    return id == 0 && qr === 1;
+}
 export class Mdns extends Multicast {
     deviceQueries = new Map();
     deviceResponses = new Map();
@@ -306,9 +328,10 @@ export class Mdns extends Multicast {
                 throw new Error(`Invalid IPv6 address: ${ipv6WithOptionalScope}`);
             const groups = [...leftParts, ...Array(missing).fill('0'), ...rightParts];
             return Buffer.from(groups.flatMap((g) => {
-                const word = parseInt(g || '0', 16);
-                if (!Number.isFinite(word) || word < 0 || word > 0xffff)
+                const word = parseInt(g, 16);
+                if (!Number.isFinite(word) || word < 0 || word > 0xffff) {
                     throw new Error(`Invalid IPv6 group: ${g}`);
+                }
                 return [(word >> 8) & 0xff, word & 0xff];
             }));
         }
@@ -316,7 +339,9 @@ export class Mdns extends Multicast {
         if (groups.length !== 8)
             throw new Error(`Invalid IPv6 address: ${ipv6WithOptionalScope}`);
         return Buffer.from(groups.flatMap((g) => {
-            const word = parseInt(g || '0', 16);
+            if (!g)
+                throw new Error(`Invalid IPv6 group: ${g}`);
+            const word = parseInt(g, 16);
             if (!Number.isFinite(word) || word < 0 || word > 0xffff)
                 throw new Error(`Invalid IPv6 group: ${g}`);
             return [(word >> 8) & 0xff, word & 0xff];
@@ -436,18 +461,15 @@ export class Mdns extends Multicast {
         const query = Buffer.concat([header, ...questionBuffers]);
         if (hasParameter('v') || hasParameter('verbose')) {
             const decoded = this.decodeMdnsMessage(query);
-            this.logMdnsMessage(decoded);
+            this.logMdnsMessage(decoded, undefined, 'Sending query mDNS message');
         }
         this.socket.send(query, 0, query.length, this.multicastPort, this.multicastAddress, (error) => {
             if (error) {
-                this.log.error(`Dgram mDNS server failed to send query message: ${error.message}`);
+                this.log.error(`Dgram mDNS server failed to send query message: ${error instanceof Error ? error.message : error}`);
                 this.emit('error', error);
             }
             else {
-                const names = questions
-                    .map((q) => `- name ${MAGENTA}${q.name}${db} type ${MAGENTA}${this.dnsTypeToString(q.type)}${db} class ${MAGENTA}${this.dnsQuestionClassToString(q.class)}${db} unicastResponse ${MAGENTA}${q.unicastResponse}${db}`)
-                    .join('\n');
-                this.log.debug(`Dgram mDNS server sent query message:\n${names}`);
+                this.log.debug(`Dgram mDNS server sent query message`);
                 this.emit('sent', query, this.multicastAddress, this.multicastPort);
             }
         });
@@ -476,17 +498,15 @@ export class Mdns extends Multicast {
         const response = Buffer.concat([header, ...answerBuffers]);
         if (hasParameter('v') || hasParameter('verbose')) {
             const decoded = this.decodeMdnsMessage(response);
-            this.logMdnsMessage(decoded);
+            this.logMdnsMessage(decoded, undefined, 'Sending response mDNS message');
         }
         this.socket.send(response, 0, response.length, this.multicastPort, this.multicastAddress, (error) => {
             if (error) {
-                const items = answers.map((a) => `- name ${MAGENTA}${a.name}${er} type ${MAGENTA}${this.dnsTypeToString(a.rtype)}${er} class ${MAGENTA}${this.dnsResponseClassToString(a.rclass)}${er} ttl ${MAGENTA}${a.ttl}${er}`).join('\n');
-                this.log.error(`Dgram mDNS server failed to send response message (${MAGENTA}${answers.length}${er} answers): ${error instanceof Error ? error.message : error}\n${items}`);
+                this.log.error(`Dgram mDNS server failed to send response message: ${error instanceof Error ? error.message : error}`);
                 this.emit('error', error);
             }
             else {
-                const items = answers.map((a) => `- name ${MAGENTA}${a.name}${db} type ${MAGENTA}${this.dnsTypeToString(a.rtype)}${db} class ${MAGENTA}${this.dnsResponseClassToString(a.rclass)}${db} ttl ${MAGENTA}${a.ttl}${db}`).join('\n');
-                this.log.debug(`Dgram mDNS server sent response message:\n${items}`);
+                this.log.debug(`Dgram mDNS server sent response message`);
                 this.emit('sent', response, this.multicastAddress, this.multicastPort);
             }
         });

package/dist/dgram/mdnsReflectorClient.js

@@ -1,6 +1,7 @@
-import { AnsiLogger, BLUE, nt } from 'node-ansi-logger';
+import crypto from 'node:crypto';
+import { AnsiLogger, BLUE, nt, nf } from 'node-ansi-logger';
 import { getStringArrayParameter, hasParameter } from '../utils/commandLine.js';
-import { Mdns } from './mdns.js';
+import { isMdns, isMdnsQuery, Mdns } from './mdns.js';
 import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from './multicast.js';
 import { Unicast } from './unicast.js';
 import { MDNS_REFLECTOR_ADDRESS, MDNS_REFLECTOR_BIND_ADDRESS_IPV4, MDNS_REFLECTOR_BIND_ADDRESS_IPV6, MDNS_REFLECTOR_HOST_DOCKER, MDNS_REFLECTOR_PORT } from './mdnsReflectorTypes.js';
@@ -13,22 +14,51 @@ export class MdnsReflectorClient {
     mdnsIpv6 = new Mdns('mDNS udp6 Server', MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, 'udp6', true, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV6);
     unicastIpv4 = new Unicast('mDNS udp4 Reflector Client', 'udp4', false, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV4);
     unicastIpv6 = new Unicast('mDNS udp6 Reflector Client', 'udp6', false, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV6);
+    reflectedIpv4 = new Map();
+    reflectedIpv6 = new Map();
+    TTL_MS = 1500;
     constructor() {
         this.log.logNameColor = '\x1b[38;5;97m';
         this.mdnsIpv4.log.logNameColor = '\x1b[38;5;97m';
-        this.mdnsIpv4.log.logLevel = "warn";
+        if (!this.debug && !this.verbose && !this.silent)
+            this.mdnsIpv4.log.logLevel = "warn";
         this.mdnsIpv6.log.logNameColor = '\x1b[38;5;97m';
-        this.mdnsIpv6.log.logLevel = "warn";
+        if (!this.debug && !this.verbose && !this.silent)
+            this.mdnsIpv6.log.logLevel = "warn";
         this.unicastIpv4.log.logNameColor = '\x1b[38;5;97m';
-        this.unicastIpv4.log.logLevel = "warn";
+        if (!this.debug && !this.verbose && !this.silent)
+            this.unicastIpv4.log.logLevel = "warn";
         this.unicastIpv6.log.logNameColor = '\x1b[38;5;97m';
-        this.unicastIpv6.log.logLevel = "warn";
+        if (!this.debug && !this.verbose && !this.silent)
+            this.unicastIpv6.log.logLevel = "warn";
         const filters = getStringArrayParameter('filter');
         if (filters)
             this.mdnsIpv4.filters.push(...filters);
         if (filters)
             this.mdnsIpv6.filters.push(...filters);
     }
+    fingerprint(buf) {
+        return crypto.createHash('sha1').update(buf).digest('hex');
+    }
+    remember(cache, key, ttlMs) {
+        cache.set(key, Date.now() + ttlMs);
+    }
+    seenRecently(cache, key) {
+        const exp = cache.get(key);
+        if (!exp)
+            return false;
+        if (exp < Date.now()) {
+            cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    prune(cache) {
+        const now = Date.now();
+        for (const [k, exp] of cache)
+            if (exp < now)
+                cache.delete(k);
+    }
     async start() {
         this.log.notice('mDNS Reflector Client starting...');
         this.mdnsIpv4.on('error', (err) => {
@@ -61,21 +91,55 @@ export class MdnsReflectorClient {
             this.unicastIpv6.start();
         });
         await Promise.all(promises);
+        this.mdnsIpv4.socket.setMulticastLoopback(false);
+        this.mdnsIpv6.socket.setMulticastLoopback(false);
         this.mdnsIpv4.on('message', (msg, rinfo) => {
-            this.log.notice(`Sending message from mDNS ipv4 multicast ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to unicast ipv4 reflector`);
+            if (this.seenRecently(this.reflectedIpv4, this.fingerprint(msg))) {
+                this.log.info(`Ignoring recently reflected ${isMdnsQuery(msg) ? 'query' : 'response'} message from mDNS ipv4 multicast ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}`);
+                return;
+            }
+            this.log.notice(`Sending ${isMdnsQuery(msg) ? 'query' : 'response'} message from mDNS ipv4 multicast ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to unicast ipv4 reflector`);
             this.unicastIpv4.send(msg, MDNS_REFLECTOR_HOST_DOCKER, MDNS_REFLECTOR_PORT);
             this.unicastIpv4.send(msg, MDNS_REFLECTOR_ADDRESS, MDNS_REFLECTOR_PORT);
         });
         this.mdnsIpv6.on('message', (msg, rinfo) => {
-            this.log.notice(`Sending message from mDNS ipv6 multicast ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to unicast ipv6 reflector`);
+            if (this.seenRecently(this.reflectedIpv6, this.fingerprint(msg))) {
+                this.log.info(`Ignoring recently reflected ${isMdnsQuery(msg) ? 'query' : 'response'} message from mDNS ipv6 multicast ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}`);
+                return;
+            }
+            this.log.notice(`Sending ${isMdnsQuery(msg) ? 'query' : 'response'} message from mDNS ipv6 multicast ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to unicast ipv6 reflector`);
             this.unicastIpv6.send(msg, MDNS_REFLECTOR_HOST_DOCKER, MDNS_REFLECTOR_PORT);
             this.unicastIpv6.send(msg, MDNS_REFLECTOR_ADDRESS, MDNS_REFLECTOR_PORT);
         });
         this.unicastIpv4.on('message', (msg, rinfo) => {
-            this.log.notice(`Received message from unicast reflector on ipv4 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt}: ${msg.toString()}`);
+            if (isMdns(msg)) {
+                this.remember(this.reflectedIpv4, this.fingerprint(msg), this.TTL_MS);
+                this.prune(this.reflectedIpv4);
+                this.log.notice(`Reflecting ${isMdnsQuery(msg) ? 'query' : 'response'} message from reflector on ipv4 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to mDNS ipv4 multicast`);
+                this.mdnsIpv4.send(msg, MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT);
+                if (hasParameter('localhost')) {
+                    this.log.notice(`Reflecting ${isMdnsQuery(msg) ? 'query' : 'response'} message from reflector on ipv4 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to mDNS ipv4 localhost`);
+                    this.mdnsIpv4.send(msg, 'localhost', MDNS_MULTICAST_PORT);
+                }
+            }
+            else {
+                this.log.info(`Received message from unicast reflector on ipv4 ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}: ${msg.toString()}`);
+            }
         });
         this.unicastIpv6.on('message', (msg, rinfo) => {
-            this.log.notice(`Received message from unicast reflector on ipv6 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt}: ${msg.toString()}`);
+            if (isMdns(msg)) {
+                this.remember(this.reflectedIpv6, this.fingerprint(msg), this.TTL_MS);
+                this.prune(this.reflectedIpv6);
+                this.log.notice(`Reflecting ${isMdnsQuery(msg) ? 'query' : 'response'} message from reflector on ipv6 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to mDNS ipv6 multicast`);
+                this.mdnsIpv6.send(msg, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT);
+                if (hasParameter('localhost')) {
+                    this.log.notice(`Reflecting ${isMdnsQuery(msg) ? 'query' : 'response'} message from reflector on ipv6 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to mDNS ipv6 localhost`);
+                    this.mdnsIpv6.send(msg, 'localhost', MDNS_MULTICAST_PORT);
+                }
+            }
+            else {
+                this.log.info(`Received message from unicast reflector on ipv6 ${BLUE}${rinfo.address}${nf}:${BLUE}${rinfo.port}${nf}: ${msg.toString()}`);
+            }
         });
         this.log.notice('mDNS Reflector Client started.');
     }
@@ -83,19 +147,19 @@ export class MdnsReflectorClient {
         this.log.notice('mDNS Reflector Client stopping...');
         const promises = [];
         promises[0] = new Promise((resolve) => {
-            this.mdnsIpv4.once('closed', () => resolve());
+            this.mdnsIpv4.once('close', () => resolve());
             this.mdnsIpv4.stop();
         });
         promises[1] = new Promise((resolve) => {
-            this.mdnsIpv6.once('closed', () => resolve());
+            this.mdnsIpv6.once('close', () => resolve());
             this.mdnsIpv6.stop();
         });
         promises[2] = new Promise((resolve) => {
-            this.unicastIpv4.once('closed', () => resolve());
+            this.unicastIpv4.once('close', () => resolve());
             this.unicastIpv4.stop();
         });
         promises[3] = new Promise((resolve) => {
-            this.unicastIpv6.once('closed', () => resolve());
+            this.unicastIpv6.once('close', () => resolve());
             this.unicastIpv6.stop();
         });
         await Promise.all(promises);

package/dist/dgram/mdnsReflectorServer.js

@@ -1,7 +1,7 @@
 import os from 'node:os';
 import { AnsiLogger, BLUE, nt } from 'node-ansi-logger';
 import { hasParameter, getStringArrayParameter } from '../utils/commandLine.js';
-import { Mdns } from './mdns.js';
+import { isMdns, isMdnsQuery, isMdnsResponse, Mdns } from './mdns.js';
 import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from './multicast.js';
 import { Unicast } from './unicast.js';
 import { MDNS_REFLECTOR_BIND_ADDRESS_IPV4, MDNS_REFLECTOR_BIND_ADDRESS_IPV6, MDNS_REFLECTOR_PORT } from './mdnsReflectorTypes.js';
@@ -19,13 +19,17 @@ export class MdnsReflectorServer {
     constructor() {
         this.log.logNameColor = '\x1b[38;5;115m';
         this.mdnsIpv4.log.logNameColor = '\x1b[38;5;115m';
-        this.mdnsIpv4.log.logLevel = "warn";
+        if (!this.debug && !this.verbose && !this.silent)
+            this.mdnsIpv4.log.logLevel = "warn";
         this.mdnsIpv6.log.logNameColor = '\x1b[38;5;115m';
-        this.mdnsIpv6.log.logLevel = "warn";
+        if (!this.debug && !this.verbose && !this.silent)
+            this.mdnsIpv6.log.logLevel = "warn";
         this.unicastIpv4.log.logNameColor = '\x1b[38;5;115m';
-        this.unicastIpv4.log.logLevel = "warn";
+        if (!this.debug && !this.verbose && !this.silent)
+            this.unicastIpv4.log.logLevel = "warn";
         this.unicastIpv6.log.logNameColor = '\x1b[38;5;115m';
-        this.unicastIpv6.log.logLevel = "warn";
+        if (!this.debug && !this.verbose && !this.silent)
+            this.unicastIpv6.log.logLevel = "warn";
         const filters = getStringArrayParameter('filter');
         if (filters)
             this.mdnsIpv4.filters.push(...filters);
@@ -177,10 +181,30 @@ export class MdnsReflectorServer {
             this.unicastIpv6.start();
         });
         await Promise.all(promises);
+        this.mdnsIpv4.socket.setMulticastLoopback(false);
+        this.mdnsIpv6.socket.setMulticastLoopback(false);
+        this.mdnsIpv4.on('message', (msg, rinfo) => {
+            if (this.ipv4Clients.size === 0)
+                return;
+            this.log.notice(`Sending ${isMdnsQuery(msg) ? 'query' : 'response'} message from mDNS ipv4 multicast ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to ${this.ipv4Clients.size} ipv4 reflector clients`);
+            for (const client of this.ipv4Clients.values()) {
+                this.unicastIpv4.send(msg, client.address, client.port);
+            }
+        });
+        this.mdnsIpv6.on('message', (msg, rinfo) => {
+            if (this.ipv6Clients.size === 0)
+                return;
+            this.log.notice(`Sending ${isMdnsQuery(msg) ? 'query' : 'response'} message from mDNS ipv6 multicast ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to ${this.ipv6Clients.size} ipv6 reflector clients`);
+            for (const client of this.ipv6Clients.values()) {
+                this.unicastIpv6.send(msg, client.address, client.port);
+            }
+        });
         this.unicastIpv4.on('message', (msg, rinfo) => {
             this.ipv4Clients.set(`${rinfo.address}:${rinfo.port}`, rinfo);
+            if (!isMdns(msg))
+                return;
             this.log.notice(`Reflecting message from unicast client ipv4 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to mDNS ipv4 multicast`);
-            const upgradedMsg = this.upgradeAddress(msg);
+            const upgradedMsg = isMdnsResponse(msg) ? this.upgradeAddress(msg) : msg;
             this.mdnsIpv4.send(upgradedMsg, MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT);
             if (hasParameter('broadcast')) {
                 const broadcastAddress = this.getBroadcastAddress(this.mdnsIpv4);
@@ -197,8 +221,10 @@ export class MdnsReflectorServer {
         });
         this.unicastIpv6.on('message', (msg, rinfo) => {
             this.ipv6Clients.set(`${rinfo.address}:${rinfo.port}`, rinfo);
+            if (!isMdns(msg))
+                return;
             this.log.notice(`Reflecting message from unicast client ipv6 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to mDNS ipv6 multicast`);
-            const upgradedMsg = this.upgradeAddress(msg);
+            const upgradedMsg = isMdnsResponse(msg) ? this.upgradeAddress(msg) : msg;
             this.mdnsIpv6.send(upgradedMsg, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT);
             if (hasParameter('broadcast')) {
                 const broadcastAddress = this.getBroadcastAddress(this.mdnsIpv6);
@@ -228,19 +254,19 @@ export class MdnsReflectorServer {
         await new Promise((resolve) => setTimeout(resolve, 100));
         const promises = [];
         promises[0] = new Promise((resolve) => {
-            this.mdnsIpv4.once('closed', () => resolve());
+            this.mdnsIpv4.once('close', () => resolve());
             this.mdnsIpv4.stop();
         });
         promises[1] = new Promise((resolve) => {
-            this.mdnsIpv6.once('closed', () => resolve());
+            this.mdnsIpv6.once('close', () => resolve());
             this.mdnsIpv6.stop();
         });
         promises[2] = new Promise((resolve) => {
-            this.unicastIpv4.once('closed', () => resolve());
+            this.unicastIpv4.once('close', () => resolve());
             this.unicastIpv4.stop();
         });
         promises[3] = new Promise((resolve) => {
-            this.unicastIpv6.once('closed', () => resolve());
+            this.unicastIpv6.once('close', () => resolve());
             this.unicastIpv6.stop();
         });
         await Promise.all(promises);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.4.6-dev-20251228-e06f048",
+  "version": "3.4.6-dev-20251228-76bd627",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.4.6-dev-20251228-e06f048",
+      "version": "3.4.6-dev-20251228-76bd627",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.4.6-dev-20251228-e06f048",
+  "version": "3.4.6-dev-20251228-76bd627",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",