@matterbridge/core 3.10.13-dev-20261007-320f739 → 3.10.13-dev-20261009-7fc645a

package/dist/matterbridge.js

@@ -170,6 +170,13 @@ export class Matterbridge extends EventEmitter {
         this.server.close();
     }
     getPlatformMatterbridge() {
+        this.systemInformation.totalMemory = formatBytes(os.totalmem());
+        this.systemInformation.freeMemory = formatBytes(os.freemem());
+        this.systemInformation.systemUptime = formatUptime(os.uptime());
+        this.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
+        this.systemInformation.rss = formatBytes(memoryFootprint());
+        this.systemInformation.heapTotal = formatBytes(process.memoryUsage().heapTotal);
+        this.systemInformation.heapUsed = formatBytes(process.memoryUsage().heapUsed);
         return {
             systemInformation: { ...this.systemInformation },
             uuid: this.uuid,
@@ -193,6 +200,13 @@ export class Matterbridge extends EventEmitter {
         };
     }
     getSharedMatterbridge() {
+        this.systemInformation.totalMemory = formatBytes(os.totalmem());
+        this.systemInformation.freeMemory = formatBytes(os.freemem());
+        this.systemInformation.systemUptime = formatUptime(os.uptime());
+        this.systemInformation.processUptime = formatUptime(Math.floor(process.uptime()));
+        this.systemInformation.rss = formatBytes(memoryFootprint());
+        this.systemInformation.heapTotal = formatBytes(process.memoryUsage().heapTotal);
+        this.systemInformation.heapUsed = formatBytes(process.memoryUsage().heapUsed);
         return {
             systemInformation: { ...this.systemInformation },
             uuid: this.uuid,
@@ -318,6 +332,15 @@ export class Matterbridge extends EventEmitter {
                     await this.nodeContext?.set('globalModulesDirectory', msg.params.prefix);
                     this.server.respond({ ...msg, result: { success: true } });
                     break;
+                case 'matterbridge_matterdata':
+                    this.server.respond({ ...msg, result: { port: this.port, passcode: this.passcode, discriminator: this.discriminator } });
+                    if (this.port !== undefined)
+                        this.port++;
+                    if (this.passcode !== undefined)
+                        this.passcode++;
+                    if (this.discriminator !== undefined)
+                        this.discriminator++;
+                    break;
                 case 'matterbridge_platform':
                     this.server.respond({ ...msg, result: { data: this.getPlatformMatterbridge(), success: true } });
                     break;
@@ -750,6 +773,8 @@ export class Matterbridge extends EventEmitter {
         }
         else {
             this.globalModulesDirectory = await this.nodeContext.get('globalModulesDirectory', '');
+            if (this.globalModulesDirectory.includes('.bun'))
+                this.globalModulesDirectory = '';
         }
         if (this.globalModulesDirectory === '') {
             this.log.debug(`Getting global node_modules directory...`);
@@ -924,7 +949,7 @@ export class Matterbridge extends EventEmitter {
             this.shutdown = true;
             return;
         }
-        if (getIntParameter('frontend') !== 0 || getIntParameter('frontend') === undefined)
+        if ((getIntParameter('frontend') !== 0 || getIntParameter('frontend') === undefined) && !hasParameter('experimental-backend'))
             await this.frontend.start(getIntParameter('frontend'));
         try {
             await this.startMatterStorage();
@@ -1017,15 +1042,45 @@ export class Matterbridge extends EventEmitter {
             this.log.warn('Fixed delay switch found. Waiting for ' + delay + ' seconds before starting matterbridge...');
             await wait(delay * 1000, 'Fixed race condition delay', true);
         }
+        if (hasParameter('experimental-tracker')) {
+            this.log.notice('***Experimental tracker enabled for Threads');
+            for (let i = 0; i < 10; i++) {
+                this.server.request({ type: 'manager_run', src: 'matterbridge', dst: 'manager', params: { name: 'Tracker' } });
+            }
+        }
         if (hasParameter('bridge') || (!hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'bridge')) {
             this.bridgeMode = 'bridge';
             this.log.debug(`Starting matterbridge in mode ${this.bridgeMode}`);
+            if (hasParameter('experimental-node')) {
+                this.log.notice(`***Starting experimental MatterNode in ${this.bridgeMode} mode...`);
+                this.server.request({
+                    type: 'manager_run',
+                    src: 'matterbridge',
+                    dst: 'manager',
+                    params: { name: 'RootNode', workerData: { threadName: 'RootNode', sharedMatterbridge: this.getSharedMatterbridge() } },
+                });
+                this.log.notice(`***Started experimental MatterNode in ${this.bridgeMode} mode`);
+                return;
+            }
             await this.startBridge();
             return;
         }
         if (hasParameter('childbridge') || (!hasParameter('bridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'childbridge')) {
             this.bridgeMode = 'childbridge';
             this.log.debug(`Starting matterbridge in mode ${this.bridgeMode}`);
+            if (hasParameter('experimental-node')) {
+                this.log.notice(`***Starting experimental MatterNode in ${this.bridgeMode} mode...`);
+                for (const plugin of this.plugins.array().filter((p) => p.enabled)) {
+                    this.server.request({
+                        type: 'manager_run',
+                        src: 'matterbridge',
+                        dst: 'manager',
+                        params: { name: 'RootNode', workerData: { threadName: 'RootNode', sharedMatterbridge: this.getSharedMatterbridge(), pluginName: plugin.name } },
+                    });
+                }
+                this.log.notice(`***Started experimental MatterNode in ${this.bridgeMode} mode`);
+                return;
+            }
             await this.startChildbridge();
             return;
         }
@@ -1478,6 +1533,8 @@ export class Matterbridge extends EventEmitter {
             this.frontend.destroy();
             this.plugins.destroy();
             this.devices.destroy();
+            this.server.request({ type: 'manager_shutdown', src: 'matterbridge', dst: 'manager', params: {} });
+            await wait(100);
             this.server.close();
             if (this.nodeStorage && this.nodeContext) {
                 this.log.debug(`Closing node storage context for ${plg}Matterbridge${db}...`);

package/dist/runners/threadBackend.d.ts

@@ -0,0 +1,3 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+declare const _default: ThreadsWrapper;
+export default _default;

package/dist/runners/threadBackend.js

@@ -0,0 +1,24 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
+logModuleLoaded('Backend', '\u001B[35m');
+export default new ThreadsWrapper('Backend', async (worker) => {
+    worker.logger("info", 'Creating backend...');
+    try {
+        worker.logger("debug", 'Fetching shared Matterbridge state...');
+        const shared = (await worker.server.fetch({ type: 'matterbridge_shared', src: 'matterbridge', dst: 'matterbridge' }, 1000)).result.data;
+        worker.logger("debug", 'Shared Matterbridge state fetched; importing Backend...');
+        const { Backend } = await import('../backend.js');
+        worker.logger("debug", 'Backend imported; creating instance...');
+        const backend = new Backend(shared);
+        worker.logger("debug", 'Starting Backend...');
+        await backend.start();
+        worker.logger("debug", 'Backend started');
+        return true;
+    }
+    catch (error) {
+        const errorMessage = inspectError(worker.log, 'Failed to create backend', error);
+        worker.logger("error", errorMessage);
+        return false;
+    }
+});

package/dist/runners/threadRootNode.d.ts

@@ -0,0 +1,3 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+declare const _default: ThreadsWrapper;
+export default _default;

package/dist/runners/threadRootNode.js

@@ -0,0 +1,30 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+import { isRootNodeWorkerData } from '@matterbridge/types';
+import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
+logModuleLoaded('RootNode', '\u001B[35m');
+export default new ThreadsWrapper('RootNode', async (worker) => {
+    worker.logger("info", 'Creating root node...');
+    try {
+        if (!isRootNodeWorkerData(worker.workerData)) {
+            worker.logger("error", 'Invalid root node worker data');
+            return false;
+        }
+        const { sharedMatterbridge, pluginName } = worker.workerData;
+        const target = pluginName ? `plugin ${pluginName}` : 'bridge';
+        worker.logger("debug", `Importing MatterNode for ${target}...`);
+        const { MatterNode } = await import('../matterNode.js');
+        worker.logger("debug", 'MatterNode imported; creating instance...');
+        const matterNode = new MatterNode(sharedMatterbridge, pluginName);
+        await matterNode.create();
+        worker.logger("debug", 'Starting MatterNode...');
+        await matterNode.start();
+        worker.logger("debug", `Root node for ${target} started`);
+        return true;
+    }
+    catch (error) {
+        const errorMessage = inspectError(worker.log, 'Failed to create root node', error);
+        worker.logger("error", errorMessage);
+        return false;
+    }
+});

package/dist/runners/threadTracker.d.ts

@@ -0,0 +1,3 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+declare const _default: ThreadsWrapper;
+export default _default;

package/dist/runners/threadTracker.js

@@ -0,0 +1,26 @@
+import { ThreadsWrapper } from '@matterbridge/thread/wrapper';
+import { inspectError } from '@matterbridge/utils/error';
+import { logModuleLoaded } from '@matterbridge/utils/loader';
+import { Tracker } from '@matterbridge/utils/tracker';
+logModuleLoaded('Tracker', '\u001B[35m');
+export default new ThreadsWrapper('Tracker', async (worker) => {
+    worker.logger("info", 'Creating tracker...');
+    try {
+        const tracker = new Tracker('Tracker', true, false, true);
+        worker.on('startup', () => {
+            worker.logger("notice", 'Tracker received startup');
+            tracker.start();
+        });
+        worker.on('shutdown', () => {
+            worker.logger("notice", 'Tracker received shutdown');
+            tracker.stop();
+        });
+        worker.logger("debug", 'Tracker created');
+        return true;
+    }
+    catch (error) {
+        const errorMessage = inspectError(worker.log, 'Failed to create tracker', error);
+        worker.logger("error", errorMessage);
+        return false;
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.13-dev-20261007-320f739",
+  "version": "3.10.13-dev-20261009-7fc645a",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -136,10 +136,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.13-dev-20261007-320f739",
-    "@matterbridge/thread": "3.10.13-dev-20261007-320f739",
-    "@matterbridge/types": "3.10.13-dev-20261007-320f739",
-    "@matterbridge/utils": "3.10.13-dev-20261007-320f739",
+    "@matterbridge/dgram": "3.10.13-dev-20261009-7fc645a",
+    "@matterbridge/thread": "3.10.13-dev-20261009-7fc645a",
+    "@matterbridge/types": "3.10.13-dev-20261009-7fc645a",
+    "@matterbridge/utils": "3.10.13-dev-20261009-7fc645a",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",