Update Demo Devices

Author: Luligu

packages/core/src/behaviors/booleanStateConfigurationServer.ts

@@ -28,7 +28,7 @@ import type { MaybePromise } from '@matter/general';
 import { BooleanStateConfigurationServer } from '@matter/node/behaviors/boolean-state-configuration';
 import { Status, StatusResponseError } from '@matter/types';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
-import { debugStringify } from 'node-ansi-logger';
+import { debugStringify, nf } from 'node-ansi-logger';
 
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import type { ClusterAttributeValues } from '../matterbridgeEndpointCommandHandler.js';
@@ -96,7 +96,7 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
 
   #assertAlarmModesSupported(alarms: BooleanStateConfiguration.AlarmMode): void {
     if ([Boolean(alarms.visual && !this.state.alarmsSupported.visual), Boolean(alarms.audible && !this.state.alarmsSupported.audible)].some(Boolean)) {
-      throw new StatusResponseError('Requested alarm mode is not supported', Status.ConstraintError);
+      throw new StatusResponseError(`Requested alarm mode is not supported (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
     }
   }
 
@@ -107,7 +107,7 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
         Boolean(alarmsToSuppress.audible && (!this.state.alarmsActive.audible || !this.state.alarmsEnabled?.audible)),
       ].some(Boolean)
     ) {
-      throw new StatusResponseError('Requested alarm mode is not active', Status.InvalidInState);
+      throw new StatusResponseError(`Requested alarm mode is not active (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
     }
   }
 
@@ -118,7 +118,7 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
    */
   override async suppressAlarm(request: BooleanStateConfiguration.SuppressAlarmRequest): Promise<void> {
     const device = this.endpoint.stateOf(MatterbridgeServer);
-    device.log.info(`Suppressing alarm ${debugStringify(request.alarmsToSuppress)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+    device.log.info(`Suppressing alarm ${debugStringify(request.alarmsToSuppress)}${nf} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     await device.commandHandler.executeHandler('BooleanStateConfiguration.suppressAlarm', {
       command: 'suppressAlarm',
       request,
@@ -130,7 +130,7 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
     this.#assertAlarmModesSupported(request.alarmsToSuppress);
     this.#assertSuppressAlarmAllowed(request.alarmsToSuppress);
     this.state.alarmsSuppressed = this.#mergeAlarmsSuppressed(request.alarmsToSuppress);
-    device.log.debug(`MatterbridgeBooleanStateConfigurationServer: suppressAlarm called`);
+    device.log.debug(`MatterbridgeBooleanStateConfigurationServer: suppressAlarm called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
   }
 
   /**
@@ -140,7 +140,7 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
    */
   override async enableDisableAlarm(request: BooleanStateConfiguration.EnableDisableAlarmRequest): Promise<void> {
     const device = this.endpoint.stateOf(MatterbridgeServer);
-    device.log.info(`Enabling/disabling alarm ${debugStringify(request.alarmsToEnableDisable)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+    device.log.info(`Enabling/disabling alarm ${debugStringify(request.alarmsToEnableDisable)}${nf} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     await device.commandHandler.executeHandler('BooleanStateConfiguration.enableDisableAlarm', {
       command: 'enableDisableAlarm',
       request,
@@ -151,6 +151,6 @@ export class MatterbridgeBooleanStateConfigurationServer extends BooleanStateCon
     });
     this.#assertAlarmModesSupported(request.alarmsToEnableDisable);
     this.#applyAlarmsEnabled(request.alarmsToEnableDisable);
-    device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called`);
+    device.log.debug(`MatterbridgeBooleanStateConfigurationServer: enableDisableAlarm called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
   }
 }

packages/core/src/demoDevices.ts

@@ -22,8 +22,12 @@
  */
 
 /* v8 ignore start - No test cause is just a way to easily add new devices for testing purposes without using plugins */
+/* oxlint-disable max-lines-per-function */
 /* oxlint-disable typescript/no-non-null-assertion */
 
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
 import { ClosureTag, ClosureWindowTag, CommonNumberTag, CommonPositionTag, RefrigeratorTag } from '@matter/node';
 import { AirQuality } from '@matter/types/clusters/air-quality';
 import { FanControl } from '@matter/types/clusters/fan-control';
@@ -32,6 +36,8 @@ import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
 import { RvcCleanMode } from '@matter/types/clusters/rvc-clean-mode';
 import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { EndpointNumber } from '@matter/types/datatype';
+import type { PlatformConfig, PlatformSchema } from '@matterbridge/types';
+import { getErrorMessage } from '@matterbridge/utils/error';
 
 import { AirConditioner } from './devices/airConditioner.js';
 import { BasicVideoPlayer } from './devices/basicVideoPlayer.js';
@@ -56,32 +62,142 @@ import { getSupportedDeviceType } from './matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
 import { getSemtag } from './matterbridgeEndpointHelpers.js';
 
+const demoPluginName = 'matterbridge-demo-devices';
+const demoPluginType = 'DynamicPlatform';
+const demoPluginVersion = '1.0.0';
+
+const demoPluginSchema: PlatformSchema = {
+  title: 'Matterbridge Demo Devices',
+  description: `${demoPluginName} v. ${demoPluginVersion} by Matterbridge`,
+  type: 'object',
+  properties: {
+    name: {
+      'description': 'Plugin name',
+      'type': 'string',
+      'readOnly': true,
+      'ui:widget': 'hidden',
+    },
+    type: {
+      'description': 'Plugin type',
+      'type': 'string',
+      'readOnly': true,
+      'ui:widget': 'hidden',
+    },
+    version: {
+      'description': 'Plugin version',
+      'type': 'string',
+      'readOnly': true,
+      'default': demoPluginVersion,
+      'ui:widget': 'hidden',
+    },
+    whiteList: {
+      description: 'Only the devices in the list will be exposed. If the list is empty, all devices will be exposed.',
+      type: 'array',
+      items: { type: 'string' },
+      default: [],
+      uniqueItems: true,
+      selectFrom: 'name',
+    },
+    blackList: {
+      description: 'The devices in the list will not be exposed. If the list is empty, no devices will be excluded.',
+      type: 'array',
+      items: { type: 'string' },
+      default: [],
+      uniqueItems: true,
+      selectFrom: 'name',
+    },
+    debug: {
+      description: 'Enable debug logging for the plugin.',
+      type: 'boolean',
+      default: false,
+    },
+    unregisterOnShutdown: {
+      description: 'Unregister all devices when the plugin is stopped.',
+      type: 'boolean',
+      default: false,
+    },
+  },
+};
+
 export async function createDemoDevices(matterbridge: Matterbridge): Promise<void> {
-  if (matterbridge.bridgeMode !== 'bridge' || !matterbridge.serverNode || !matterbridge.aggregatorNode) return;
+  if (matterbridge.bridgeMode !== 'bridge') {
+    matterbridge.log.error('Demo devices can only be created in bridge mode');
+    return;
+  }
   const serverNode = matterbridge.serverNode;
   const aggregator = matterbridge.aggregatorNode;
   if (!serverNode || !aggregator) {
     matterbridge.log.error('Demo devices can only be created when the server node and aggregator node are available');
     return;
   }
+  const configFile = path.join(matterbridge.matterbridgeDirectory, `${demoPluginName}.config.json`);
+  const schemaFile = path.join(matterbridge.matterbridgeDirectory, `${demoPluginName}.schema.json`);
+  const defaultConfig: PlatformConfig = {
+    name: demoPluginName,
+    type: demoPluginType,
+    version: demoPluginVersion,
+    debug: false,
+    unregisterOnShutdown: false,
+    whiteList: [],
+    blackList: [],
+  };
+  let config = defaultConfig;
+  try {
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const storedConfig = JSON.parse(await readFile(configFile, 'utf8')) as PlatformConfig;
+    config = {
+      ...defaultConfig,
+      ...storedConfig,
+      name: demoPluginName,
+      type: demoPluginType,
+      version: demoPluginVersion,
+      whiteList: Array.isArray(storedConfig.whiteList) ? storedConfig.whiteList : [],
+      blackList: Array.isArray(storedConfig.blackList) ? storedConfig.blackList : [],
+    };
+  } catch (error) {
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') matterbridge.log.error(`Failed to read demo devices config ${configFile}: ${getErrorMessage(error)}`);
+  }
+  try {
+    await writeFile(configFile, JSON.stringify(config, null, 2), 'utf8');
+    await writeFile(schemaFile, JSON.stringify(demoPluginSchema, null, 2), 'utf8');
+  } catch (error) {
+    matterbridge.log.error(`Failed to write demo devices config or schema: ${getErrorMessage(error)}`);
+  }
   let ep: MatterbridgeEndpoint | undefined;
   matterbridge.plugins.set({
-    name: 'matterbridge-demo-devices',
+    name: demoPluginName,
     path: '',
-    type: 'DynamicPlatform',
-    version: '1.0.0',
+    type: demoPluginType,
+    version: demoPluginVersion,
     description: 'Matterbridge demo devices',
     author: 'Matterbridge',
     enabled: false,
     private: true,
     registeredDevices: 0,
+    configJson: config,
+    schemaJson: demoPluginSchema,
+    hasWhiteList: true,
+    hasBlackList: true,
   });
 
   const registerDevice = async (device: MatterbridgeEndpoint, deviceName: string, serialNumber: string): Promise<void> => {
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const whiteList = config.whiteList as string[];
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const blackList = config.blackList as string[];
+    if (blackList.includes(deviceName)) {
+      matterbridge.log.info(`Skipping demo device ${deviceName} because it is in the blacklist`);
+      return;
+    }
+    if (whiteList.length > 0 && !whiteList.includes(deviceName)) {
+      matterbridge.log.info(`Skipping demo device ${deviceName} because it is not in the whitelist`);
+      return;
+    }
     device.createDefaultBridgedDeviceBasicInformationClusterServer(deviceName, serialNumber);
     device.addRequiredClusters();
-    device.plugin = 'matterbridge-demo-devices';
-    await matterbridge.addBridgedEndpoint('matterbridge-demo-devices', device);
+    device.plugin = demoPluginName;
+    await matterbridge.addBridgedEndpoint(demoPluginName, device);
   };
 
   const bridgedNode = getSupportedDeviceType('BridgedNode')!;

packages/core/vitest/devices/oven.test.ts

@@ -506,6 +506,9 @@ describe('Matterbridge ' + NAME, () => {
         LogLevel.INFO,
         `MatterbridgeOvenCavityOperationalStateServer: stop (endpoint OvenTestCabinetTop.3) called setting operational state to Stopped and operational error to No error`,
       );
+
+      // A repeated Stop does not complete the same operation again.
+      await cabinet1.invokeBehaviorCommand('ovenCavityOperationalState', 'stop', { newMode: 15 });
     } finally {
       vi.useRealTimers();
     }

packages/core/vitest/matterbridgeEndpoint-matterjs.test.ts

@@ -93,7 +93,7 @@ import {
 } from '@matter/types/clusters';
 import { flushAsync, HOMEDIR, loggerLogSpy, setDebug, setupTest } from '@matterbridge/vitest-utils';
 import { createServerNode, createTestEnvironment, destroyTestEnvironment, flushServerNode, server, startServerNode, stopServerNode } from '@matterbridge/vitest-utils/matter';
-import { AnsiLogger, debugStringify, er, hk, LogLevel } from 'node-ansi-logger';
+import { AnsiLogger, debugStringify, er, hk, LogLevel, nf } from 'node-ansi-logger';
 
 import { MatterbridgeBooleanStateConfigurationServer } from '../src/behaviors/booleanStateConfigurationServer.js';
 import { MatterbridgeColorControlServer } from '../src/behaviors/colorControlServer.js';
@@ -1253,13 +1253,16 @@ describe('Matterbridge ' + NAME, () => {
     await leak.setAttribute('booleanStateConfiguration', 'alarmsActive', { audible: true, visual: true });
     await leak.invokeBehaviorCommand('booleanStateConfiguration', 'suppressAlarm', { alarmsToSuppress: { audible: true, visual: true } });
     expect(leak.getAttribute('booleanStateConfiguration', 'alarmsSuppressed')).toEqual({ audible: true, visual: true });
-    expect(loggerLogSpy).toHaveBeenCalledWith(LogLevel.INFO, `Suppressing alarm ${debugStringify({ audible: true, visual: true })} (endpoint ${leak.id}.${leak.number})`);
+    expect(loggerLogSpy).toHaveBeenCalledWith(LogLevel.INFO, `Suppressing alarm ${debugStringify({ audible: true, visual: true })}${nf} (endpoint ${leak.id}.${leak.number})`);
     vi.clearAllMocks();
     await leak.invokeBehaviorCommand('booleanStateConfiguration', 'enableDisableAlarm', { alarmsToEnableDisable: { audible: true, visual: false } });
     expect(leak.getAttribute('booleanStateConfiguration', 'alarmsActive')).toEqual({ audible: true, visual: false });
     expect(leak.getAttribute('booleanStateConfiguration', 'alarmsEnabled')).toEqual({ audible: true, visual: false });
     expect(leak.getAttribute('booleanStateConfiguration', 'alarmsSuppressed')).toEqual({ audible: true, visual: false });
-    expect(loggerLogSpy).toHaveBeenCalledWith(LogLevel.INFO, `Enabling/disabling alarm ${debugStringify({ audible: true, visual: false })} (endpoint ${leak.id}.${leak.number})`);
+    expect(loggerLogSpy).toHaveBeenCalledWith(
+      LogLevel.INFO,
+      `Enabling/disabling alarm ${debugStringify({ audible: true, visual: false })}${nf} (endpoint ${leak.id}.${leak.number})`,
+    );
   });
 
   test('invoke MatterbridgeOperationalStateServer commands', async () => {