@matterbridge/core 3.10.14-dev-20261010-607ee18 → 3.10.14-dev-20261013-e87a0c8

package/dist/matterbridgeEndpoint.js

@@ -327,8 +327,6 @@ export class MatterbridgeEndpoint extends Endpoint {
         if (!this.lifecycle.isReady || this.construction.status !== Lifecycle.Status.Active)
             return;
         for (const [clusterName, clusterAttributes] of Object.entries(this.state)) {
-            if (!Number.isNaN(Number(clusterName)))
-                continue;
             for (const [attributeName, attributeValue] of Object.entries(clusterAttributes)) {
                 const clusterId = getClusterId(this, clusterName);
                 if (clusterId === undefined) {
@@ -601,20 +599,22 @@ export class MatterbridgeEndpoint extends Endpoint {
         return this;
     }
     createDefaultPowerTopologyClusterServer(feature = PowerTopology.Feature.TreeTopology, availableEndpoints = [], activeEndpoints = []) {
-        if (feature === PowerTopology.Feature.NodeTopology) {
-            this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.NodeTopology));
-        }
-        else if (feature === PowerTopology.Feature.TreeTopology) {
-            this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.TreeTopology));
-        }
-        else if (feature === PowerTopology.Feature.SetTopology) {
-            this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.SetTopology), { availableEndpoints });
-        }
-        else if (feature === PowerTopology.Feature.DynamicPowerFlow) {
-            this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.SetTopology, PowerTopology.Feature.DynamicPowerFlow), {
-                availableEndpoints,
-                activeEndpoints,
-            });
+        switch (feature) {
+            case PowerTopology.Feature.NodeTopology:
+                this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.NodeTopology));
+                break;
+            case PowerTopology.Feature.TreeTopology:
+                this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.TreeTopology));
+                break;
+            case PowerTopology.Feature.SetTopology:
+                this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.SetTopology), { availableEndpoints });
+                break;
+            case PowerTopology.Feature.DynamicPowerFlow:
+                this.behaviors.require(PowerTopologyServer.with(PowerTopology.Feature.SetTopology, PowerTopology.Feature.DynamicPowerFlow), {
+                    availableEndpoints,
+                    activeEndpoints,
+                });
+                break;
         }
         return this;
     }
@@ -882,7 +882,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return this;
     }
-    createDefaultTiltWindowCoveringClusterServer(positionTiltPercent100ths = 0, type = WindowCovering.WindowCoveringType.TiltBlindTiltOnly, endProductType = WindowCovering.EndProductType.InteriorVenetianBlind, movementDuration = 0) {
+    createDefaultTiltWindowCoveringClusterServer(positionTiltPercent100ths = 0, type = WindowCovering.WindowCoveringType.TiltBlindTiltOnly, endProductType = WindowCovering.EndProductType.TiltOnlyInteriorBlind, movementDuration = 0) {
         this.behaviors.require(MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt), {
             type,
             numberOfActuationsTilt: 0,
@@ -927,15 +927,22 @@ export class MatterbridgeEndpoint extends Endpoint {
         }, this.log);
     }
     async setWindowCoveringCurrentTargetStatus(current, target, status) {
-        await this.setAttribute(WindowCovering, 'currentPositionLiftPercent100ths', current, this.log);
-        await this.setAttribute(WindowCovering, 'targetPositionLiftPercent100ths', target, this.log);
         const { lift, tilt } = featuresFor(this, WindowCovering);
+        const axis = lift ? 'Lift' : 'Tilt';
+        if (lift) {
+            await this.setAttribute(WindowCovering, 'currentPositionLiftPercent100ths', current, this.log);
+            await this.setAttribute(WindowCovering, 'targetPositionLiftPercent100ths', target, this.log);
+        }
+        else {
+            await this.setAttribute(WindowCovering, 'currentPositionTiltPercent100ths', current, this.log);
+            await this.setAttribute(WindowCovering, 'targetPositionTiltPercent100ths', target, this.log);
+        }
         await this.setAttribute(WindowCovering, 'operationalStatus', {
             global: status,
             ...(lift ? { lift: status } : {}),
             ...(tilt ? { tilt: status } : {}),
         }, this.log);
-        this.log.debug(`Set WindowCovering currentPositionLiftPercent100ths: ${current}, targetPositionLiftPercent100ths: ${target} and operationalStatus: ${status}.`);
+        this.log.debug(`Set WindowCovering currentPosition${axis}Percent100ths: ${current}, targetPosition${axis}Percent100ths: ${target} and operationalStatus: ${status}.`);
     }
     async setWindowCoveringStatus(status) {
         const { lift, tilt } = featuresFor(this, WindowCovering);
@@ -1052,9 +1059,9 @@ export class MatterbridgeEndpoint extends Endpoint {
             ...(occupied !== undefined ? { unoccupiedCoolingSetpoint: unoccupiedCoolingSetpoint !== undefined ? unoccupiedCoolingSetpoint * 100 : 2700 } : {}),
             ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
             ...(occupied !== undefined ? { externallyMeasuredOccupancy: true } : {}),
-            numberOfPresets: Math.max(Array.isArray(presets) ? presets.length : 0, Array.isArray(presetTypes) ? Math.max(0, ...presetTypes.map((pt) => pt.numberOfPresets ?? 0)) : 0, 1),
+            numberOfPresets: Math.max(Array.isArray(presets) ? presets.length : 0, Array.isArray(presetTypes) ? Math.max(0, ...presetTypes.map((pt) => pt.numberOfPresets)) : 0, 1),
             activePresetHandle: activePresetHandle ? Uint8Array.from(activePresetHandle) : null,
-            presets: (presets ?? []).map((p) => ({
+            presets: presets.map((p) => ({
                 presetHandle: p.presetHandle ? Uint8Array.from(p.presetHandle) : null,
                 presetScenario: p.presetScenario,
                 name: p.name,
@@ -1099,11 +1106,13 @@ export class MatterbridgeEndpoint extends Endpoint {
             ...(occupied !== undefined ? { unoccupiedCoolingSetpoint: unoccupiedCoolingSetpoint !== undefined ? unoccupiedCoolingSetpoint * 100 : 2700 } : {}),
             ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
             ...(occupied !== undefined ? { externallyMeasuredOccupancy: true } : {}),
-            numberOfSchedules: Math.max(Array.isArray(schedules) ? schedules.length : 0, Array.isArray(scheduleTypes) ? Math.max(0, ...scheduleTypes.map((st) => st.numberOfSchedules ?? 0)) : 0, 1),
+            numberOfSchedules: Math.max(Array.isArray(schedules) ? schedules.length : 0, Array.isArray(scheduleTypes)
+                ? Math.max(0, ...scheduleTypes.map((st) => st.numberOfSchedules))
+                : 0, 1),
             numberOfScheduleTransitions,
             numberOfScheduleTransitionPerDay,
             activeScheduleHandle: activeScheduleHandle ? Uint8Array.from(activeScheduleHandle) : null,
-            schedules: (schedules ?? []).map((s) => ({
+            schedules: schedules.map((s) => ({
                 scheduleHandle: s.scheduleHandle ? Uint8Array.from(s.scheduleHandle) : null,
                 systemMode: s.systemMode,
                 name: s.name,
@@ -1111,10 +1120,15 @@ export class MatterbridgeEndpoint extends Endpoint {
                 transitions: s.transitions ?? [],
                 builtIn: s.builtIn ?? true,
             })),
-            scheduleTypes: (scheduleTypes ?? []).map((st) => ({
+            scheduleTypes: scheduleTypes.map((st) => ({
                 ...st,
                 numberOfSchedules: st.numberOfSchedules ?? 0,
-                scheduleTypeFeatures: st.scheduleTypeFeatures ?? { supportsSetpoints: true, supportsNames: true, supportsPresets: false, supportsOff: false },
+                scheduleTypeFeatures: st.scheduleTypeFeatures ?? {
+                    supportsSetpoints: true,
+                    supportsNames: true,
+                    supportsPresets: false,
+                    supportsOff: false,
+                },
             })),
         });
         return this;
@@ -1145,9 +1159,9 @@ export class MatterbridgeEndpoint extends Endpoint {
             ...(occupied !== undefined ? { unoccupiedCoolingSetpoint: unoccupiedCoolingSetpoint !== undefined ? unoccupiedCoolingSetpoint * 100 : 2700 } : {}),
             ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
             ...(occupied !== undefined ? { externallyMeasuredOccupancy: true } : {}),
-            numberOfPresets: Math.max(Array.isArray(presets) ? presets.length : 0, Array.isArray(presetTypes) ? Math.max(0, ...presetTypes.map((pt) => pt.numberOfPresets ?? 0)) : 0, 1),
+            numberOfPresets: Math.max(Array.isArray(presets) ? presets.length : 0, Array.isArray(presetTypes) ? Math.max(0, ...presetTypes.map((pt) => pt.numberOfPresets)) : 0, 1),
             activePresetHandle: activePresetHandle ? Uint8Array.from(activePresetHandle) : null,
-            presets: (presets ?? []).map((p) => ({
+            presets: presets.map((p) => ({
                 presetHandle: p.presetHandle ? Uint8Array.from(p.presetHandle) : null,
                 presetScenario: p.presetScenario,
                 name: p.name,
@@ -1161,7 +1175,7 @@ export class MatterbridgeEndpoint extends Endpoint {
                 presetTypeFeatures: pt.presetTypeFeatures ?? { automatic: false, supportsNames: true },
             })),
             maxThermostatSuggestions: Math.max(Array.isArray(thermostatSuggestions) ? thermostatSuggestions.length : 0, 5),
-            thermostatSuggestions: (thermostatSuggestions ?? []).map((s) => ({
+            thermostatSuggestions: thermostatSuggestions.map((s) => ({
                 uniqueId: s.uniqueId,
                 presetHandle: Uint8Array.from(s.presetHandle),
                 effectiveTime: s.effectiveTime,

package/dist/matterbridgePlatform.js

@@ -6,11 +6,12 @@ import { hasParameter } from '@matterbridge/utils/cli';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { isValidArray, isValidObject, isValidString } from '@matterbridge/utils/validate';
 import { fireAndForget } from '@matterbridge/utils/wait';
-import { CYAN, db, er, nf, wr } from 'node-ansi-logger';
+import { CYAN, db, debugStringify, er, nf, wr } from 'node-ansi-logger';
 import { NodeStorageManager } from 'node-persist-manager';
 import { bridgedNode } from './matterbridgeDeviceTypes.js';
 import { assertMatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { checkNotLatinCharacters } from './matterbridgeEndpointHelpers.js';
+import { toApiDevice } from './matterNodeHelpers.js';
 logModuleLoaded('MatterbridgePlatform');
 const MATTERBRIDGE_PLATFORM_BRAND = Symbol('MatterbridgePlatform.brand');
 export function isMatterbridgePlatform(value) {
@@ -71,6 +72,7 @@ export class MatterbridgePlatform {
         this.config = config;
         this.name = config.name;
         this.#server = new BroadcastServer('platform', this.log);
+        this.#server.on('broadcast_message', this.#msgHandler.bind(this));
         Object.defineProperty(this, MATTERBRIDGE_PLATFORM_BRAND, {
             value: true,
             writable: false,
@@ -121,6 +123,39 @@ export class MatterbridgePlatform {
             return;
         });
     }
+    #msgHandler(msg) {
+        if (!this.#server.isWorkerRequest(msg))
+            return;
+        if (this.#verbose)
+            this.log.debug(`Received broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}: ${debugStringify(msg)}${db}`);
+        switch (msg.type) {
+            case 'platform_get_apidevices':
+                if (msg.params.plugin !== this.name)
+                    return;
+                this.#server.respond({
+                    ...msg,
+                    result: {
+                        devices: this.getDevices()
+                            .map(toApiDevice)
+                            .filter((device) => device !== undefined),
+                    },
+                });
+                break;
+            case 'platform_get_apiselectdevices':
+                if (msg.params.plugin !== this.name)
+                    return;
+                this.#server.respond({ ...msg, result: { devices: this.getSelectDevices() } });
+                break;
+            case 'platform_get_apiselectentities':
+                if (msg.params.plugin !== this.name)
+                    return;
+                this.#server.respond({ ...msg, result: { entities: this.getSelectEntities() } });
+                break;
+            default:
+                if (this.#verbose)
+                    this.log.debug(`Unknown broadcast request ${CYAN}${msg.type}${db} from ${CYAN}${msg.src}${db}`);
+        }
+    }
     async destroy() {
         if (this.#verbose)
             this.log.debug(`Destroying MatterbridgePlatform for plugin ${this.config.name}`);
@@ -319,7 +354,8 @@ export class MatterbridgePlatform {
     getSelectDevices() {
         const selectDevices = [];
         for (const device of this.#selectDevices.values()) {
-            selectDevices.push({ pluginName: this.name, ...device });
+            const { serial, name, ...rest } = device;
+            selectDevices.push({ plugin: this.name, serialNumber: serial, deviceName: name, ...rest });
         }
         return selectDevices;
     }
@@ -332,7 +368,7 @@ export class MatterbridgePlatform {
     getSelectEntities() {
         const selectEntities = [];
         for (const entity of this.#selectEntities.values()) {
-            selectEntities.push({ pluginName: this.name, ...entity });
+            selectEntities.push({ plugin: this.name, ...entity });
         }
         return selectEntities;
     }

package/dist/pluginManager.js

@@ -104,7 +104,16 @@ export class PluginManager extends EventEmitter {
                     }
                     break;
                 case 'plugins_set':
-                    this.server.respond({ ...msg, result: { plugin: this.set(msg.params.plugin) } });
+                    {
+                        const plugin = this.get(msg.params.plugin.name);
+                        if (plugin) {
+                            Object.assign(plugin, msg.params.plugin);
+                            this.server.respond({ ...msg, result: { plugin: this.toApiPlugin(plugin) } });
+                        }
+                        else {
+                            this.server.respond({ ...msg, error: `Plugin ${msg.params.plugin.name} not found` });
+                        }
+                    }
                     break;
                 case 'plugins_storagepluginarray':
                     this.server.respond({ ...msg, result: { plugins: this.storagePluginArray() } });

package/dist/runners/threadBackend.js

@@ -2,7 +2,9 @@ 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) => {
+export default new ThreadsWrapper('Backend', entrypoint, startup, shutdown);
+let backend;
+async function entrypoint(worker) {
     worker.logger("info", 'Creating backend...');
     try {
         worker.logger("debug", 'Fetching shared Matterbridge state...');
@@ -10,10 +12,8 @@ export default new ThreadsWrapper('Backend', async (worker) => {
         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');
+        backend = new Backend(shared);
+        worker.logger("debug", 'Backend instance created');
         return true;
     }
     catch (error) {
@@ -21,4 +21,18 @@ export default new ThreadsWrapper('Backend', async (worker) => {
         worker.logger("error", errorMessage);
         return false;
     }
-});
+}
+async function startup(worker) {
+    if (!backend)
+        return;
+    worker.logger("debug", 'Starting up Backend...');
+    await backend.start();
+    worker.logger("debug", 'Backend has been started');
+}
+async function shutdown(worker) {
+    if (!backend)
+        return;
+    worker.logger("debug", 'Shutting down Backend...');
+    await backend.stop();
+    worker.logger("debug", 'Backend has been shut down');
+}

package/dist/runners/threadRootNode.js

@@ -3,28 +3,48 @@ 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...');
+export default new ThreadsWrapper('RootNode', entrypoint, startup, shutdown);
+let matterNode;
+async function entrypoint(worker) {
+    worker.logger("info", 'Creating MatterNode...');
     try {
         if (!isRootNodeWorkerData(worker.workerData)) {
-            worker.logger("error", 'Invalid root node worker data');
+            worker.logger("error", 'Invalid MatterNode worker data');
             return false;
         }
         const { sharedMatterbridge, pluginName } = worker.workerData;
-        const target = pluginName ? `plugin ${pluginName}` : 'bridge';
+        const target = pluginName ? `plugin ${pluginName}` : 'Matterbridge';
         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`);
+        worker.logger("debug", `Creating instance for ${target}...`);
+        matterNode = new MatterNode(sharedMatterbridge, pluginName);
+        worker.logger("debug", `Instance for ${target} created.`);
         return true;
     }
     catch (error) {
-        const errorMessage = inspectError(worker.log, 'Failed to create root node', error);
+        const errorMessage = inspectError(worker.log, `Failed to create MatterNode`, error);
         worker.logger("error", errorMessage);
         return false;
     }
-});
+}
+async function startup(worker) {
+    if (!matterNode)
+        return;
+    worker.logger("info", `Starting up MatterNode for ${matterNode.storeId}...`);
+    worker.logger("debug", `Creating MatterNode for ${matterNode.storeId}...`);
+    await matterNode.create();
+    worker.logger("debug", `Starting MatterNode for ${matterNode.storeId}...`);
+    await matterNode.start();
+    worker.logger("debug", `MatterNode for ${matterNode.storeId} started`);
+}
+async function shutdown(worker) {
+    if (!matterNode)
+        return;
+    worker.logger("info", `Shutting down MatterNode for ${matterNode.storeId}...`);
+    worker.logger("debug", `Stopping MatterNode for ${matterNode.storeId}...`);
+    await matterNode.stop();
+    worker.logger("debug", `MatterNode for ${matterNode.storeId} stopped`);
+    await matterNode.destroy();
+    worker.logger("debug", `MatterNode for ${matterNode.storeId} destroyed`);
+    matterNode = undefined;
+}

package/dist/runners/threadTracker.js

@@ -1,19 +1,22 @@
 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) => {
+export default new ThreadsWrapper('Tracker', entrypoint, startup, shutdown);
+let tracker;
+async function entrypoint(worker) {
     worker.logger("info", 'Creating tracker...');
     try {
-        const tracker = new Tracker('Tracker', true, false, true);
+        worker.logger("debug", 'Importing Tracker...');
+        const { Tracker } = await import('@matterbridge/utils/tracker');
+        worker.logger("debug", 'Tracker imported; creating instance...');
+        tracker = new Tracker('Tracker', false, false, true);
+        worker.logger("debug", 'Tracker instance created');
         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;
@@ -23,4 +26,18 @@ export default new ThreadsWrapper('Tracker', async (worker) => {
         worker.logger("error", errorMessage);
         return false;
     }
-});
+}
+async function startup(worker) {
+    if (!tracker)
+        return;
+    worker.logger("debug", 'Starting up tracker...');
+    tracker.start();
+    worker.logger("debug", 'Tracker startup complete');
+}
+async function shutdown(worker) {
+    if (!tracker)
+        return;
+    worker.logger("debug", 'Shutting down tracker...');
+    tracker.stop();
+    worker.logger("debug", 'Tracker shutdown complete');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.14-dev-20261010-607ee18",
+  "version": "3.10.14-dev-20261013-e87a0c8",
   "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.14-dev-20261010-607ee18",
-    "@matterbridge/thread": "3.10.14-dev-20261010-607ee18",
-    "@matterbridge/types": "3.10.14-dev-20261010-607ee18",
-    "@matterbridge/utils": "3.10.14-dev-20261010-607ee18",
+    "@matterbridge/dgram": "3.10.14-dev-20261013-e87a0c8",
+    "@matterbridge/thread": "3.10.14-dev-20261013-e87a0c8",
+    "@matterbridge/types": "3.10.14-dev-20261013-e87a0c8",
+    "@matterbridge/utils": "3.10.14-dev-20261013-e87a0c8",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.1",