@matterbridge/core 3.7.5-dev-20260418-caa9650 → 3.7.5-dev-20260420-1c36532

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,240 @@
1
+ import path from 'node:path';
2
+ import { Environment } from '@matter/general';
3
+ import { MdnsService } from '@matter/protocol';
4
+ import { MATTER_STORAGE_DIR, NODE_STORAGE_DIR } from '@matterbridge/types';
5
+ import { rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
6
+ import { NodeStorageManager } from 'node-persist-manager';
7
+ import { Matterbridge } from '../matterbridge.js';
8
+ import { flushAsync } from './jestFlushAsync.js';
9
+ import { assertAllEndpointNumbersPersisted, createTestEnvironment, flushAllEndpointNumberPersistence } from './jestMatterTest.js';
10
+ import { HOMEDIR, loggerLogSpy, originalProcessArgv } from './jestSetupTest.js';
11
+ let server;
12
+ let aggregator;
13
+ export let matterbridge;
14
+ export let frontend;
15
+ export let plugins;
16
+ export let devices;
17
+ export async function startMatterbridge(bridgeMode = 'bridge', frontendPort = 8283, matterPort = 5540, passcode = 20252026, discriminator = 3840, pluginSize = 0, devicesSize = 0) {
18
+ process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS'] = '100';
19
+ process.env['MATTERBRIDGE_PAUSE_MATTER_INTERVAL_MS'] = '100';
20
+ process.argv.length = 0;
21
+ process.argv.push(...originalProcessArgv, '--novirtual', '--debug', '--verbose', '--logger', 'debug', '--matterlogger', 'debug', bridgeMode === '' ? '--test' : '--' + bridgeMode, '--homedir', HOMEDIR, '--frontend', frontendPort.toString(), '--port', matterPort.toString(), '--passcode', passcode.toString(), '--discriminator', discriminator.toString());
22
+ expect(Matterbridge.instance).toBeUndefined();
23
+ matterbridge = await Matterbridge.loadInstance(true);
24
+ expect(matterbridge.environment).toBeDefined();
25
+ expect(matterbridge.systemCheckTimeout).toBeDefined();
26
+ expect(matterbridge.checkUpdateTimeout).toBeDefined();
27
+ expect(matterbridge.checkUpdateInterval).toBeDefined();
28
+ clearTimeout(matterbridge.systemCheckTimeout);
29
+ clearTimeout(matterbridge.checkUpdateTimeout);
30
+ clearInterval(matterbridge.checkUpdateInterval);
31
+ new MdnsService(matterbridge.environment);
32
+ expect(matterbridge).toBeDefined();
33
+ expect(matterbridge.profile).toBeUndefined();
34
+ expect(matterbridge.bridgeMode).toBe(bridgeMode);
35
+ frontend = matterbridge.frontend;
36
+ plugins = matterbridge.plugins;
37
+ devices = matterbridge.devices;
38
+ expect(matterbridge.initialized).toBeTruthy();
39
+ expect(matterbridge.log).toBeDefined();
40
+ expect(matterbridge.rootDirectory).toBe(path.resolve('./'));
41
+ expect(matterbridge.homeDirectory).toBe(path.join(HOMEDIR));
42
+ expect(matterbridge.matterbridgeDirectory).toBe(path.join(HOMEDIR, '.matterbridge'));
43
+ expect(matterbridge.matterbridgePluginDirectory).toBe(path.join(HOMEDIR, 'Matterbridge'));
44
+ expect(matterbridge.matterbridgeCertDirectory).toBe(path.join(HOMEDIR, '.mattercert'));
45
+ expect(plugins).toBeDefined();
46
+ expect(plugins.size).toBe(pluginSize);
47
+ expect(devices).toBeDefined();
48
+ expect(devices.size).toBe(devicesSize);
49
+ expect(frontend).toBeDefined();
50
+ expect(frontend.listening).toBeTruthy();
51
+ expect(frontend.httpServer).toBeDefined();
52
+ expect(frontend.httpsServer).toBeUndefined();
53
+ expect(frontend.expressApp).toBeDefined();
54
+ expect(frontend.webSocketServer).toBeDefined();
55
+ expect(matterbridge.nodeStorage).toBeDefined();
56
+ expect(matterbridge.nodeContext).toBeDefined();
57
+ expect(Environment.default.vars.get('path.root')).toBe(path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR));
58
+ expect(matterbridge.matterStorageService).toBeDefined();
59
+ expect(matterbridge.matterStorageManager).toBeDefined();
60
+ expect(matterbridge.matterbridgeContext).toBeDefined();
61
+ expect(matterbridge.controllerContext).toBeUndefined();
62
+ if (bridgeMode === 'bridge') {
63
+ expect(matterbridge.serverNode).toBeDefined();
64
+ expect(matterbridge.aggregatorNode).toBeDefined();
65
+ }
66
+ expect(matterbridge.mdnsInterface).toBe(undefined);
67
+ expect(matterbridge.port).toBe(matterPort + (bridgeMode === 'bridge' ? 1 : 0));
68
+ expect(matterbridge.passcode).toBe(passcode + (bridgeMode === 'bridge' ? 1 : 0));
69
+ expect(matterbridge.discriminator).toBe(discriminator + (bridgeMode === 'bridge' ? 1 : 0));
70
+ if (bridgeMode === 'bridge') {
71
+ const started = new Promise((resolve) => {
72
+ matterbridge.once('bridge_started', () => {
73
+ resolve();
74
+ });
75
+ });
76
+ const online = new Promise((resolve) => {
77
+ matterbridge.once('online', (name) => {
78
+ if (name === 'Matterbridge')
79
+ resolve();
80
+ });
81
+ });
82
+ await Promise.all([started, online]);
83
+ }
84
+ else if (bridgeMode === 'childbridge') {
85
+ await new Promise((resolve) => {
86
+ matterbridge.once('childbridge_started', () => {
87
+ resolve();
88
+ });
89
+ });
90
+ }
91
+ expect(loggerLogSpy).toHaveBeenCalledWith("info", `The frontend http server is listening on ${UNDERLINE}http://${matterbridge.systemInformation.ipv4Address}:${frontendPort}${UNDERLINEOFF}${rs}`);
92
+ if (bridgeMode === 'bridge') {
93
+ expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Starting Matterbridge server node`);
94
+ expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Server node for Matterbridge is online`);
95
+ expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in bridge mode...`);
96
+ expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in bridge mode`);
97
+ expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge bridge started successfully`);
98
+ }
99
+ else if (bridgeMode === 'childbridge') {
100
+ expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in childbridge mode...`);
101
+ expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in childbridge mode`);
102
+ expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge childbridge started successfully`);
103
+ }
104
+ return matterbridge;
105
+ }
106
+ export async function stopMatterbridge(cleanupPause = 10, destroyPause = 250, closeMdns = true) {
107
+ await destroyMatterbridgeEnvironment(cleanupPause, destroyPause, closeMdns);
108
+ }
109
+ export async function createMatterbridgeEnvironment() {
110
+ matterbridge = await Matterbridge.loadInstance(false);
111
+ expect(matterbridge).toBeDefined();
112
+ expect(matterbridge).toBeInstanceOf(Matterbridge);
113
+ matterbridge.matterbridgeVersion = '3.7.5';
114
+ matterbridge.bridgeMode = 'bridge';
115
+ matterbridge.rootDirectory = path.join(HOMEDIR);
116
+ matterbridge.homeDirectory = path.join(HOMEDIR);
117
+ matterbridge.matterbridgeDirectory = path.join(HOMEDIR, '.matterbridge');
118
+ matterbridge.matterbridgePluginDirectory = path.join(HOMEDIR, 'Matterbridge');
119
+ matterbridge.matterbridgeCertDirectory = path.join(HOMEDIR, '.mattercert');
120
+ matterbridge.log.logLevel = "debug";
121
+ frontend = matterbridge.frontend;
122
+ plugins = matterbridge.plugins;
123
+ devices = matterbridge.devices;
124
+ const environment = await createTestEnvironment();
125
+ expect(environment).toBeDefined();
126
+ expect(environment).toBeInstanceOf(Environment);
127
+ matterbridge.environment = environment;
128
+ return matterbridge;
129
+ }
130
+ export async function startMatterbridgeEnvironment(port = 5540, createOnly = false) {
131
+ matterbridge.nodeStorage = new NodeStorageManager({
132
+ dir: path.join(matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR),
133
+ writeQueue: false,
134
+ expiredInterval: undefined,
135
+ logging: false,
136
+ });
137
+ matterbridge.nodeContext = await matterbridge.nodeStorage.createStorage('matterbridge');
138
+ await matterbridge.startMatterStorage();
139
+ expect(matterbridge.matterStorageService).toBeDefined();
140
+ expect(matterbridge.matterStorageManager).toBeDefined();
141
+ expect(matterbridge.matterbridgeContext).toBeDefined();
142
+ server = await matterbridge.createServerNode(matterbridge.matterbridgeContext, port);
143
+ expect(server).toBeDefined();
144
+ expect(server).toBeDefined();
145
+ expect(server.lifecycle.isReady).toBeTruthy();
146
+ matterbridge.serverNode = server;
147
+ aggregator = await matterbridge.createAggregatorNode(matterbridge.matterbridgeContext);
148
+ expect(aggregator).toBeDefined();
149
+ matterbridge.aggregatorNode = aggregator;
150
+ expect(await server.add(aggregator)).toBeDefined();
151
+ expect(server.parts.has(aggregator.id)).toBeTruthy();
152
+ expect(server.parts.has(aggregator)).toBeTruthy();
153
+ expect(aggregator.lifecycle.isReady).toBeTruthy();
154
+ if (createOnly) {
155
+ await flushAsync();
156
+ return [server, aggregator];
157
+ }
158
+ expect(server.lifecycle.isOnline).toBeFalsy();
159
+ await new Promise((resolve) => {
160
+ server.lifecycle.online.on(async () => {
161
+ resolve();
162
+ });
163
+ server.start();
164
+ });
165
+ expect(server.lifecycle.isReady).toBeTruthy();
166
+ expect(server.lifecycle.isOnline).toBeTruthy();
167
+ expect(server.lifecycle.isCommissioned).toBeFalsy();
168
+ expect(server.lifecycle.isPartsReady).toBeTruthy();
169
+ expect(server.lifecycle.hasId).toBeTruthy();
170
+ expect(server.lifecycle.hasNumber).toBeTruthy();
171
+ expect(aggregator.lifecycle.isReady).toBeTruthy();
172
+ expect(aggregator.lifecycle.isInstalled).toBeTruthy();
173
+ expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
174
+ expect(aggregator.lifecycle.hasId).toBeTruthy();
175
+ expect(aggregator.lifecycle.hasNumber).toBeTruthy();
176
+ await flushAsync();
177
+ return [server, aggregator];
178
+ }
179
+ export function addMatterbridgePlatform(platform, name) {
180
+ expect(platform).toBeDefined();
181
+ platform.setMatterNode?.(matterbridge.addBridgedEndpoint.bind(matterbridge), matterbridge.removeBridgedEndpoint.bind(matterbridge), matterbridge.removeAllBridgedEndpoints.bind(matterbridge), matterbridge.addVirtualEndpoint.bind(matterbridge));
182
+ if (name)
183
+ platform.config.name = name;
184
+ expect(platform.config.name).toBeDefined();
185
+ expect(platform.config.type).toBeDefined();
186
+ expect(platform.type).toBeDefined();
187
+ expect(platform.config.version).toBeDefined();
188
+ expect(platform.version).toBeDefined();
189
+ expect(platform.config.debug).toBeDefined();
190
+ expect(platform.config.unregisterOnShutdown).toBeDefined();
191
+ matterbridge.plugins._plugins.set(platform.config.name, {
192
+ name: platform.config.name,
193
+ path: './',
194
+ type: platform.type,
195
+ version: platform.version,
196
+ description: 'Plugin ' + platform.config.name,
197
+ author: 'Unknown',
198
+ enabled: true,
199
+ });
200
+ platform['name'] = platform.config.name;
201
+ }
202
+ export async function stopMatterbridgeEnvironment(createOnly = false) {
203
+ expect(matterbridge).toBeDefined();
204
+ expect(server).toBeDefined();
205
+ expect(aggregator).toBeDefined();
206
+ await flushAllEndpointNumberPersistence(server);
207
+ await assertAllEndpointNumbersPersisted(server);
208
+ expect(server.lifecycle.isReady).toBeTruthy();
209
+ if (!createOnly) {
210
+ expect(server.lifecycle.isOnline).toBeTruthy();
211
+ }
212
+ await server.close();
213
+ expect(server.lifecycle.isReady).toBeFalsy();
214
+ expect(server.lifecycle.isOnline).toBeFalsy();
215
+ await matterbridge.stopMatterStorage();
216
+ expect(matterbridge.matterStorageService).not.toBeDefined();
217
+ expect(matterbridge.matterStorageManager).not.toBeDefined();
218
+ expect(matterbridge.matterbridgeContext).not.toBeDefined();
219
+ await matterbridge.nodeContext?.close();
220
+ matterbridge.nodeContext = undefined;
221
+ await matterbridge.nodeStorage?.close();
222
+ matterbridge.nodeStorage = undefined;
223
+ await flushAsync();
224
+ }
225
+ export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 250, closeMdns = true) {
226
+ await destroyInstance(matterbridge, cleanupPause, destroyPause);
227
+ if (closeMdns) {
228
+ await closeMdnsInstance(matterbridge);
229
+ }
230
+ Matterbridge.instance = undefined;
231
+ }
232
+ export async function destroyInstance(matterbridge, cleanupPause = 10, destroyPause = 250) {
233
+ await matterbridge.cleanup('destroying instance...', false, cleanupPause);
234
+ if (destroyPause > 0)
235
+ await flushAsync(undefined, undefined, destroyPause);
236
+ }
237
+ export async function closeMdnsInstance(matterbridge) {
238
+ const mdns = matterbridge.environment.get(MdnsService);
239
+ await mdns.close();
240
+ }
@@ -0,0 +1,21 @@
1
+ import type { jest } from '@jest/globals';
2
+ import { AnsiLogger } from 'node-ansi-logger';
3
+ export declare const originalProcessArgv: readonly string[];
4
+ export declare const originalProcessEnv: Readonly<Record<string, string | undefined>>;
5
+ export declare let loggerLogSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.log>;
6
+ export declare let loggerDebugSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.debug>;
7
+ export declare let loggerInfoSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.info>;
8
+ export declare let loggerNoticeSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.notice>;
9
+ export declare let loggerWarnSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.warn>;
10
+ export declare let loggerErrorSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.error>;
11
+ export declare let loggerFatalSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.fatal>;
12
+ export declare let consoleLogSpy: jest.SpiedFunction<typeof console.log>;
13
+ export declare let consoleDebugSpy: jest.SpiedFunction<typeof console.debug>;
14
+ export declare let consoleInfoSpy: jest.SpiedFunction<typeof console.info>;
15
+ export declare let consoleWarnSpy: jest.SpiedFunction<typeof console.warn>;
16
+ export declare let consoleErrorSpy: jest.SpiedFunction<typeof console.error>;
17
+ export declare let NAME: string;
18
+ export declare let HOMEDIR: string;
19
+ export declare let log: AnsiLogger;
20
+ export declare function setupTest(name: string, debug?: boolean): Promise<void>;
21
+ export declare function setDebug(debug: boolean): Promise<void>;
@@ -0,0 +1,78 @@
1
+ import { mkdirSync, rmSync } from 'node:fs';
2
+ import path from 'node:path';
3
+ import { AnsiLogger } from 'node-ansi-logger';
4
+ export const originalProcessArgv = Object.freeze([...process.argv]);
5
+ export const originalProcessEnv = Object.freeze({ ...process.env });
6
+ export let loggerLogSpy;
7
+ export let loggerDebugSpy;
8
+ export let loggerInfoSpy;
9
+ export let loggerNoticeSpy;
10
+ export let loggerWarnSpy;
11
+ export let loggerErrorSpy;
12
+ export let loggerFatalSpy;
13
+ export let consoleLogSpy;
14
+ export let consoleDebugSpy;
15
+ export let consoleInfoSpy;
16
+ export let consoleWarnSpy;
17
+ export let consoleErrorSpy;
18
+ export let NAME;
19
+ export let HOMEDIR;
20
+ export let log;
21
+ export async function setupTest(name, debug = false) {
22
+ expect(name).toBeDefined();
23
+ expect(typeof name).toBe('string');
24
+ expect(name.length).toBeGreaterThanOrEqual(4);
25
+ NAME = name;
26
+ HOMEDIR = path.join('.cache', 'jest', name);
27
+ log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
28
+ rmSync(HOMEDIR, { recursive: true, force: true });
29
+ mkdirSync(HOMEDIR, { recursive: true });
30
+ const { jest } = await import('@jest/globals');
31
+ loggerDebugSpy = jest.spyOn(AnsiLogger.prototype, 'debug');
32
+ loggerInfoSpy = jest.spyOn(AnsiLogger.prototype, 'info');
33
+ loggerNoticeSpy = jest.spyOn(AnsiLogger.prototype, 'notice');
34
+ loggerWarnSpy = jest.spyOn(AnsiLogger.prototype, 'warn');
35
+ loggerErrorSpy = jest.spyOn(AnsiLogger.prototype, 'error');
36
+ loggerFatalSpy = jest.spyOn(AnsiLogger.prototype, 'fatal');
37
+ if (debug) {
38
+ loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
39
+ consoleLogSpy = jest.spyOn(console, 'log');
40
+ consoleDebugSpy = jest.spyOn(console, 'debug');
41
+ consoleInfoSpy = jest.spyOn(console, 'info');
42
+ consoleWarnSpy = jest.spyOn(console, 'warn');
43
+ consoleErrorSpy = jest.spyOn(console, 'error');
44
+ }
45
+ else {
46
+ loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
47
+ consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
48
+ consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
49
+ consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
50
+ consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
51
+ consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
52
+ }
53
+ }
54
+ export async function setDebug(debug) {
55
+ const { jest } = await import('@jest/globals');
56
+ if (debug) {
57
+ loggerLogSpy.mockRestore();
58
+ consoleLogSpy.mockRestore();
59
+ consoleDebugSpy.mockRestore();
60
+ consoleInfoSpy.mockRestore();
61
+ consoleWarnSpy.mockRestore();
62
+ consoleErrorSpy.mockRestore();
63
+ loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
64
+ consoleLogSpy = jest.spyOn(console, 'log');
65
+ consoleDebugSpy = jest.spyOn(console, 'debug');
66
+ consoleInfoSpy = jest.spyOn(console, 'info');
67
+ consoleWarnSpy = jest.spyOn(console, 'warn');
68
+ consoleErrorSpy = jest.spyOn(console, 'error');
69
+ }
70
+ else {
71
+ loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
72
+ consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
73
+ consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
74
+ consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
75
+ consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
76
+ consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
77
+ }
78
+ }
@@ -83,7 +83,7 @@ import { MatterbridgeThermostatServer } from './behaviors/thermostatServer.js';
83
83
  import { MatterbridgeValveConfigurationAndControlServer } from './behaviors/valveConfigurationAndControlServer.js';
84
84
  import { MatterbridgeWindowCoveringServer } from './behaviors/windowCoveringServer.js';
85
85
  import { CommandHandler } from './matterbridgeEndpointCommandHandler.js';
86
- import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, checkNotLatinCharacters, createUniqueId, featuresFor, generateUniqueId, getApparentElectricalPowerMeasurementClusterServer, getAttribute, getAttributeId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getCluster, getClusterId, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultOperationalStateClusterServer, getDefaultPowerSourceBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceWiredClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, invokeBehaviorCommand, lowercaseFirstLetter, setAttribute, setCluster, subscribeAttribute, triggerEvent, updateAttribute, } from './matterbridgeEndpointHelpers.js';
86
+ import { addClusterServers, addFixedLabel, addOptionalClusterServers, addRequiredClusterServers, addUserLabel, checkNotLatinCharacters, createUniqueId, defaultFor, featuresFor, generateUniqueId, getApparentElectricalPowerMeasurementClusterServer, getAttribute, getAttributeId, getBehavior, getBehaviourTypesFromClusterClientIds, getBehaviourTypesFromClusterServerIds, getCluster, getClusterId, getDefaultDeviceEnergyManagementClusterServer, getDefaultDeviceEnergyManagementModeClusterServer, getDefaultElectricalEnergyMeasurementClusterServer, getDefaultElectricalPowerMeasurementClusterServer, getDefaultFlowMeasurementClusterServer, getDefaultIlluminanceMeasurementClusterServer, getDefaultOccupancySensingClusterServer, getDefaultOperationalStateClusterServer, getDefaultPowerSourceBatteryClusterServer, getDefaultPowerSourceRechargeableBatteryClusterServer, getDefaultPowerSourceReplaceableBatteryClusterServer, getDefaultPowerSourceWiredClusterServer, getDefaultPressureMeasurementClusterServer, getDefaultRelativeHumidityMeasurementClusterServer, getDefaultTemperatureMeasurementClusterServer, invokeBehaviorCommand, lowercaseFirstLetter, setAttribute, setCluster, subscribeAttribute, triggerEvent, updateAttribute, } from './matterbridgeEndpointHelpers.js';
87
87
  const MATTERBRIDGE_ENDPOINT_BRAND = Symbol('MatterbridgeEndpoint.brand');
88
88
  export function isMatterbridgeEndpoint(value) {
89
89
  if (!value || typeof value !== 'object')
@@ -210,9 +210,10 @@ export class MatterbridgeEndpoint extends Endpoint {
210
210
  const behavior = getBehavior(this, cluster);
211
211
  if (!behavior || !this.behaviors.supported[behavior.id])
212
212
  return false;
213
+ const normalizedAttribute = lowercaseFirstLetter(attribute);
213
214
  const options = this.behaviors.optionsFor(behavior);
214
- const defaults = this.behaviors.defaultsFor(behavior);
215
- return lowercaseFirstLetter(attribute) in options || lowercaseFirstLetter(attribute) in defaults;
215
+ const defaults = defaultFor(behavior, options);
216
+ return (options !== undefined && normalizedAttribute in options) || (defaults !== undefined && normalizedAttribute in defaults);
216
217
  }
217
218
  getClusterServerOptions(cluster) {
218
219
  const behavior = getBehavior(this, cluster);
@@ -296,6 +297,9 @@ export class MatterbridgeEndpoint extends Endpoint {
296
297
  if (attributeId === undefined) {
297
298
  continue;
298
299
  }
300
+ if (attributeValue === undefined) {
301
+ continue;
302
+ }
299
303
  callback(clusterName, clusterId, attributeName, attributeId, attributeValue);
300
304
  }
301
305
  }
@@ -625,7 +629,7 @@ export class MatterbridgeEndpoint extends Endpoint {
625
629
  return this;
626
630
  }
627
631
  createLevelControlClusterServer(currentLevel = 254, onLevel = null) {
628
- this.behaviors.require(MatterbridgeLevelControlServer, {
632
+ this.behaviors.require(MatterbridgeLevelControlServer.with(), {
629
633
  currentLevel,
630
634
  onLevel,
631
635
  options: {
@@ -895,7 +895,7 @@ export type CommandHandlerDataMap = {
895
895
  command: 'sendKey';
896
896
  request: KeypadInput.SendKeyRequest;
897
897
  cluster: 'keypadInput';
898
- attributes: ClusterAttributeValues<(typeof KeypadInput.Complete)['attributes']>;
898
+ attributes: {};
899
899
  endpoint: MatterbridgeEndpoint;
900
900
  };
901
901
  'resetCondition': CommandHandlerData<'ResourceMonitoring.resetCondition'>;
@@ -31,8 +31,11 @@ export declare function checkNotLatinCharacters(deviceName: string): boolean;
31
31
  export declare function generateUniqueId(deviceName: string): string;
32
32
  export declare function createUniqueId(param1: string, param2: string, param3: string, param4: string): string;
33
33
  export declare function getSemtag(semtag: Semtag, label?: string | null | undefined, mfgCode?: VendorId | null): Semtag;
34
- export declare function featuresFor(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Record<string, boolean | undefined>;
35
- export declare function internalFor<T extends object = Record<string, unknown>>(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Promise<T | undefined>;
34
+ export declare function featuresFor(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Partial<Record<string, boolean>>;
35
+ export declare function internalFor<T extends Behavior.Type>(endpoint: MatterbridgeEndpoint, cluster: T): Promise<InstanceType<T['Internal']> | undefined>;
36
+ export declare function internalFor<T extends object = Record<string, unknown>>(endpoint: MatterbridgeEndpoint, cluster: ClusterType | ClusterId | string): Promise<T | undefined>;
37
+ export declare function optionsFor<T extends Behavior.Type>(type: T, options: Behavior.Options<T>): Behavior.Options<T>;
38
+ export declare function defaultFor<T extends Behavior.Type>(type: T, options?: Behavior.Options<T>): Partial<Behavior.Options<T>> | undefined;
36
39
  export declare function getBehaviourTypesFromClusterServerIds(clusterServerList: ClusterId[]): Behavior.Type[];
37
40
  export declare function getBehaviourTypesFromClusterClientIds(clusterClientList: ClusterId[]): Behavior.Type[];
38
41
  export declare function getBehaviourTypeFromClusterServerId(clusterId: ClusterId): Behavior.Type;
@@ -45,7 +48,6 @@ export declare function addOptionalClusterServers(endpoint: MatterbridgeEndpoint
45
48
  export declare function addClusterServers(endpoint: MatterbridgeEndpoint, serverList: ClusterId[]): void;
46
49
  export declare function addFixedLabel(endpoint: MatterbridgeEndpoint, label: string, value: string): Promise<void>;
47
50
  export declare function addUserLabel(endpoint: MatterbridgeEndpoint, label: string, value: string): Promise<void>;
48
- export declare function optionsFor<T extends Behavior.Type>(type: T, options: Behavior.Options<T>): Behavior.Options<T>;
49
51
  export declare function getClusterId(endpoint: Endpoint, cluster: string): number | undefined;
50
52
  export declare function getAttributeId(endpoint: Endpoint, cluster: string, attribute: string): number | undefined;
51
53
  export declare function getAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, log?: AnsiLogger): any;
@@ -172,7 +172,8 @@ export function featuresFor(endpoint, cluster) {
172
172
  endpoint.log?.error(`featuresFor error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
173
173
  return {};
174
174
  }
175
- return endpoint.behaviors.supported[lowercaseFirstLetter(behaviorId)]['cluster']['supportedFeatures'];
175
+ const supportedBehavior = endpoint.behaviors.supported[lowercaseFirstLetter(behaviorId)];
176
+ return supportedBehavior?.cluster.supportedFeatures ?? {};
176
177
  }
177
178
  export async function internalFor(endpoint, cluster) {
178
179
  const behaviorId = getBehavior(endpoint, cluster)?.id;
@@ -180,7 +181,28 @@ export async function internalFor(endpoint, cluster) {
180
181
  endpoint.log?.error(`internalFor error: cluster not found on endpoint ${or}${endpoint.maybeId}${er}:${or}${endpoint.maybeNumber}${er}`);
181
182
  return undefined;
182
183
  }
183
- return endpoint.act((agent) => agent[behaviorId]?.internal);
184
+ const supportedBehavior = endpoint.behaviors.supported[lowercaseFirstLetter(behaviorId)];
185
+ if (!supportedBehavior) {
186
+ return undefined;
187
+ }
188
+ return endpoint.act(() => endpoint.behaviors.internalsOf(supportedBehavior));
189
+ }
190
+ export function optionsFor(type, options) {
191
+ return options;
192
+ }
193
+ export function defaultFor(type, options) {
194
+ let defaults;
195
+ if (options) {
196
+ for (const key in type.defaults) {
197
+ if (key in options) {
198
+ if (!defaults) {
199
+ defaults = {};
200
+ }
201
+ defaults[key] = options[key];
202
+ }
203
+ }
204
+ }
205
+ return defaults;
184
206
  }
185
207
  export function getBehaviourTypesFromClusterServerIds(clusterServerList) {
186
208
  const behaviorTypes = [];
@@ -488,9 +510,6 @@ export async function addUserLabel(endpoint, label, value) {
488
510
  await endpoint.setAttribute(UserLabel.Cluster.id, 'labelList', labelList, endpoint.log);
489
511
  }
490
512
  }
491
- export function optionsFor(type, options) {
492
- return options;
493
- }
494
513
  export function getClusterId(endpoint, cluster) {
495
514
  return endpoint.behaviors.supported[lowercaseFirstLetter(cluster)]?.schema?.id;
496
515
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@matterbridge/core",
3
- "version": "3.7.5-dev-20260418-caa9650",
3
+ "version": "3.7.5-dev-20260420-1c36532",
4
4
  "description": "Matterbridge core library",
5
5
  "author": "https://github.com/Luligu",
6
6
  "homepage": "https://matterbridge.io/",
@@ -130,10 +130,10 @@
130
130
  ],
131
131
  "dependencies": {
132
132
  "@matter/main": "0.16.11",
133
- "@matterbridge/dgram": "3.7.5-dev-20260418-caa9650",
134
- "@matterbridge/thread": "3.7.5-dev-20260418-caa9650",
135
- "@matterbridge/types": "3.7.5-dev-20260418-caa9650",
136
- "@matterbridge/utils": "3.7.5-dev-20260418-caa9650",
133
+ "@matterbridge/dgram": "3.7.5-dev-20260420-1c36532",
134
+ "@matterbridge/thread": "3.7.5-dev-20260420-1c36532",
135
+ "@matterbridge/types": "3.7.5-dev-20260420-1c36532",
136
+ "@matterbridge/utils": "3.7.5-dev-20260420-1c36532",
137
137
  "escape-html": "1.0.3",
138
138
  "express": "5.2.1",
139
139
  "express-rate-limit": "8.3.2",
@@ -1,68 +0,0 @@
1
- import type { jest } from '@jest/globals';
2
- import { Environment } from '@matter/general';
3
- import { Endpoint, ServerNode } from '@matter/node';
4
- import { AggregatorEndpoint } from '@matter/node/endpoints';
5
- import { ColorControl } from '@matter/types/clusters/color-control';
6
- import { LevelControl } from '@matter/types/clusters/level-control';
7
- import { DeviceTypeId } from '@matter/types/datatype';
8
- import { AnsiLogger } from 'node-ansi-logger';
9
- import type { DeviceManager } from '../deviceManager.js';
10
- import type { Frontend } from '../frontend.js';
11
- import { Matterbridge } from '../matterbridge.js';
12
- import type { MatterbridgePlatform } from '../matterbridgePlatform.js';
13
- import type { PluginManager } from '../pluginManager.js';
14
- export declare const originalProcessArgv: readonly string[];
15
- export declare const originalProcessEnv: Readonly<Record<string, string | undefined>>;
16
- export declare let loggerLogSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.log>;
17
- export declare let loggerDebugSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.debug>;
18
- export declare let loggerInfoSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.info>;
19
- export declare let loggerNoticeSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.notice>;
20
- export declare let loggerWarnSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.warn>;
21
- export declare let loggerErrorSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.error>;
22
- export declare let loggerFatalSpy: jest.SpiedFunction<typeof AnsiLogger.prototype.fatal>;
23
- export declare let consoleLogSpy: jest.SpiedFunction<typeof console.log>;
24
- export declare let consoleDebugSpy: jest.SpiedFunction<typeof console.debug>;
25
- export declare let consoleInfoSpy: jest.SpiedFunction<typeof console.info>;
26
- export declare let consoleWarnSpy: jest.SpiedFunction<typeof console.warn>;
27
- export declare let consoleErrorSpy: jest.SpiedFunction<typeof console.error>;
28
- export declare let NAME: string;
29
- export declare let HOMEDIR: string;
30
- export declare let matterbridge: Matterbridge;
31
- export declare let frontend: Frontend;
32
- export declare let plugins: PluginManager;
33
- export declare let devices: DeviceManager;
34
- export declare let environment: Environment;
35
- export declare let server: ServerNode<ServerNode.RootEndpoint>;
36
- export declare let aggregator: Endpoint<AggregatorEndpoint>;
37
- export declare let log: AnsiLogger;
38
- export declare function setupTest(name: string, debug?: boolean): Promise<void>;
39
- export declare function setDebug(debug: boolean): Promise<void>;
40
- export declare function startMatterbridge(bridgeMode?: 'bridge' | 'childbridge' | 'controller' | '', frontendPort?: number, matterPort?: number, passcode?: number, discriminator?: number, pluginSize?: number, devicesSize?: number): Promise<Matterbridge>;
41
- export declare function stopMatterbridge(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean): Promise<void>;
42
- export declare function createMatterbridgeEnvironment(name: string, createOnly?: boolean): Promise<Matterbridge>;
43
- export declare function startMatterbridgeEnvironment(port?: number, createOnly?: boolean): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
44
- export declare function addMatterbridgePlatform(platform: MatterbridgePlatform, name?: string): void;
45
- export declare function stopMatterbridgeEnvironment(createOnly?: boolean): Promise<void>;
46
- export declare function destroyMatterbridgeEnvironment(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean): Promise<void>;
47
- export declare function destroyInstance(matterbridge: Matterbridge, cleanupPause?: number, destroyPause?: number): Promise<void>;
48
- export declare function closeMdnsInstance(matterbridge: Matterbridge): Promise<void>;
49
- export declare function createTestEnvironment(name: string, createOnly?: boolean): Environment;
50
- export declare function destroyTestEnvironment(createOnly?: boolean): Promise<void>;
51
- export declare function flushAsync(ticks?: number, microTurns?: number, pause?: number): Promise<void>;
52
- export declare function logKeepAlives(log?: AnsiLogger): number;
53
- export declare function flushAllEndpointNumberPersistence(targetServer: ServerNode, rounds?: number, pause?: number): Promise<void>;
54
- export declare function assertAllEndpointNumbersPersisted(targetServer: ServerNode): Promise<number>;
55
- export declare function closeServerNodeStores(targetServer?: ServerNode): Promise<void>;
56
- export declare function createServerNode(name: string, port: number, deviceType?: DeviceTypeId, ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
57
- export declare function startServerNode(name: string, port: number, deviceType?: DeviceTypeId, createOnly?: boolean, ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
58
- export declare function stopServerNode(server: ServerNode<ServerNode.RootEndpoint>, createOnly?: boolean, ticks?: number, microTurns?: number, pause?: number): Promise<void>;
59
- export declare function addDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, pause?: number): Promise<boolean>;
60
- export declare function deleteDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, pause?: number): Promise<boolean>;
61
- export declare function getMoveToLevelRequest(level: number, transitionTime: number, executeIfOff: boolean): LevelControl.MoveToLevelRequest;
62
- export declare function getMoveToColorTemperatureRequest(colorTemperatureMireds: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToColorTemperatureRequest;
63
- export declare function getMoveToHueRequest(hue: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToHueRequest;
64
- export declare function getEnhancedMoveToHueRequest(enhancedHue: number, transitionTime: number, executeIfOff: boolean): ColorControl.EnhancedMoveToHueRequest;
65
- export declare function getMoveToSaturationRequest(saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToSaturationRequest;
66
- export declare function getMoveToHueAndSaturationRequest(hue: number, saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToHueAndSaturationRequest;
67
- export declare function getEnhancedMoveToHueAndSaturationRequest(enhancedHue: number, saturation: number, transitionTime: number, executeIfOff: boolean): ColorControl.EnhancedMoveToHueAndSaturationRequest;
68
- export declare function getMoveToColorRequest(colorX: number, colorY: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToColorRequest;