@matterbridge/core 3.9.2-dev-20260620-9802e5b → 3.9.2-dev-20260621-75283ba

package/dist/backend.d.ts

@@ -29,9 +29,9 @@ export declare class Backend extends EventEmitter<BackendEvents> {
     private broadcastMsgHandler;
     start(port?: number): Promise<void>;
     stop(): Promise<void>;
-    getApiSettings(): ApiSettings;
-    getApiPlugins(): ApiPlugin[];
-    getApiDevices(_pluginName?: string): ApiDevice[];
+    getApiSettings(): Promise<ApiSettings>;
+    getApiPlugins(): Promise<ApiPlugin[]>;
+    getApiDevices(pluginName?: string): Promise<ApiDevice[]>;
     generateDiagnostic(): Promise<void>;
 }
 export {};

package/dist/backend.js

@@ -292,13 +292,16 @@ export class Backend extends EventEmitter {
         this.backendExpress = undefined;
         this.log.debug('Backend stopped');
     }
-    getApiSettings() {
-        return {};
+    async getApiSettings() {
+        const response = await this.server.fetch({ type: 'matterbridge_apisettings', src: 'frontend', dst: 'matterbridge', params: undefined });
+        return response.result.data;
     }
-    getApiPlugins() {
-        return [];
+    async getApiPlugins() {
+        const response = await this.server.fetch({ type: 'plugins_apipluginarray', src: 'frontend', dst: 'plugins', params: undefined });
+        return response.result.plugins;
     }
-    getApiDevices(_pluginName) {
+    async getApiDevices(pluginName) {
+        const _response = await this.server.fetch({ type: 'devices_basearray', src: 'frontend', dst: 'devices', params: { pluginName } });
         return [];
     }
     async generateDiagnostic() { }

package/dist/backendExpress.js

@@ -131,23 +131,23 @@ export class BackendExpress {
             };
             res.status(200).json(memoryReport);
         });
-        this.expressApp.get('/api/settings', (req, res) => {
+        this.expressApp.get('/api/settings', async (req, res) => {
             this.log.debug('The frontend sent /api/settings');
             if (!this.validateReq(req, res))
                 return;
-            res.json(this.backend.getApiSettings());
+            res.json(await this.backend.getApiSettings());
         });
-        this.expressApp.get('/api/plugins', (req, res) => {
+        this.expressApp.get('/api/plugins', async (req, res) => {
             this.log.debug('The frontend sent /api/plugins');
             if (!this.validateReq(req, res))
                 return;
-            res.json(this.backend.getApiPlugins());
+            res.json(await this.backend.getApiPlugins());
         });
-        this.expressApp.get('/api/devices', (req, res) => {
+        this.expressApp.get('/api/devices', async (req, res) => {
             this.log.debug('The frontend sent /api/devices');
             if (!this.validateReq(req, res))
                 return;
-            res.json(this.backend.getApiDevices());
+            res.json(await this.backend.getApiDevices());
         });
         this.expressApp.get('/api/view-mblog', async (req, res) => {
             this.log.debug('The frontend sent /api/view-mblog');

package/dist/backendWsServer.d.ts

@@ -1,5 +1,5 @@
 import type { EndpointNumber } from '@matter/types/datatype';
-import type { ApiMatter, RefreshRequiredChanged, SharedMatterbridge, WsMessageBroadcast } from '@matterbridge/types';
+import type { ApiMatter, BridgeStatus, PluginStatusUpdate, RefreshRequiredChanged, SharedMatterbridge, WsMessageBroadcast } from '@matterbridge/types';
 import { WebSocketServer } from 'ws';
 import type { Backend } from './backend.js';
 export declare class BackendWsServer {
@@ -25,7 +25,10 @@ export declare class BackendWsServer {
     }): void;
     wssSendRestartRequired(snackbar?: boolean, fixed?: boolean): void;
     wssSendRestartNotRequired(snackbar?: boolean): void;
-    wssSendUpdateRequired(devVersion?: boolean): void;
+    wssSendUpdateRequired(version: string, devVersion?: boolean): void;
+    wssSendPluginUpdateRequired(plugin: string, version: string, devVersion?: boolean): void;
+    wssSendPluginStatusUpdate(plugin: string, status: PluginStatusUpdate): void;
+    wssSendMatterbridgeStatusUpdate(status: BridgeStatus): void;
     wssSendCpuUpdate(cpuUsage: number, processCpuUsage: number): void;
     wssSendMemoryUpdate(totalMemory: string, freeMemory: string, rss: string, heapTotal: string, heapUsed: string, external: string, arrayBuffers: string): void;
     wssSendUptimeUpdate(systemUptime: string, processUptime: string): void;

package/dist/backendWsServer.js

@@ -232,12 +232,33 @@ export class BackendWsServer {
             this.wssSendCloseSnackbarMessage(`Restart required`);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
     }
-    wssSendUpdateRequired(devVersion = false) {
+    wssSendUpdateRequired(version, devVersion = false) {
         if (!this.hasActiveClients())
             return;
         if (this.verbose)
-            this.log.debug('Sending an update required message to all connected clients');
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { devVersion } });
+            this.log.debug('Sending a matterbridge version update required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { version, devVersion } });
+    }
+    wssSendPluginUpdateRequired(plugin, version, devVersion = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a plugin version update required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_update_required', success: true, response: { plugin, version, devVersion } });
+    }
+    wssSendPluginStatusUpdate(plugin, status) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a plugin status update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_status_update', success: true, response: { plugin, status } });
+    }
+    wssSendMatterbridgeStatusUpdate(status) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending a matterbridge status update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'matterbridge_status_update', success: true, response: { status } });
     }
     wssSendCpuUpdate(cpuUsage, processCpuUsage) {
         if (!this.hasActiveClients())

package/dist/frontend.d.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'node:events';
 import { type EndpointNumber } from '@matter/types/datatype';
-import type { ApiClusters, ApiDevice, ApiMatter, ApiPlugin, ApiSettings, RefreshRequiredChanged, WsMessageBroadcast } from '@matterbridge/types';
+import type { ApiClusters, ApiDevice, ApiMatter, ApiPlugin, ApiSettings, BridgeStatus, PluginStatusUpdate, RefreshRequiredChanged, WsMessageBroadcast } from '@matterbridge/types';
 import { LogLevel } from 'node-ansi-logger';
 import type { Matterbridge } from './matterbridge.js';
 interface FrontendEvents {
@@ -57,7 +57,10 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     }): void;
     wssSendRestartRequired(snackbar?: boolean, fixed?: boolean): void;
     wssSendRestartNotRequired(snackbar?: boolean): void;
-    wssSendUpdateRequired(devVersion?: boolean): void;
+    wssSendUpdateRequired(version: string, devVersion?: boolean): void;
+    wssSendPluginUpdateRequired(plugin: string, version: string, devVersion?: boolean): void;
+    wssSendPluginStatusUpdate(plugin: string, status: PluginStatusUpdate): void;
+    wssSendMatterbridgeStatusUpdate(status: BridgeStatus): void;
     wssSendCpuUpdate(cpuUsage: number, processCpuUsage: number): void;
     wssSendMemoryUpdate(totalMemory: string, freeMemory: string, rss: string, heapTotal: string, heapUsed: string, external: string, arrayBuffers: string): void;
     wssSendUptimeUpdate(systemUptime: string, processUptime: string): void;

package/dist/frontend.js

@@ -93,13 +93,29 @@ export class Frontend extends EventEmitter {
                     this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_updaterequired':
-                    this.wssSendUpdateRequired(msg.params.devVersion);
+                    this.wssSendUpdateRequired(msg.params.version, msg.params.devVersion);
+                    this.server.respond({ ...msg, result: { success: true } });
+                    break;
+                case 'frontend_pluginupdaterequired':
+                    this.wssSendPluginUpdateRequired(msg.params.plugin, msg.params.version, msg.params.devVersion);
+                    this.server.respond({ ...msg, result: { success: true } });
+                    break;
+                case 'frontend_pluginstatusupdate':
+                    this.wssSendPluginStatusUpdate(msg.params.plugin, msg.params.status);
+                    this.server.respond({ ...msg, result: { success: true } });
+                    break;
+                case 'frontend_matterbridgestatusupdate':
+                    this.wssSendMatterbridgeStatusUpdate(msg.params.status);
                     this.server.respond({ ...msg, result: { success: true } });
                     break;
                 case 'frontend_snackbarmessage':
                     this.wssSendSnackbarMessage(msg.params.message, msg.params.timeout, msg.params.severity);
                     this.server.respond({ ...msg, result: { success: true } });
                     break;
+                case 'frontend_closesnackbarmessage':
+                    this.wssSendCloseSnackbarMessage(msg.params.message);
+                    this.server.respond({ ...msg, result: { success: true } });
+                    break;
                 case 'frontend_attributechanged':
                     this.wssSendAttributeChangedMessage(msg.params.plugin, msg.params.serialNumber, msg.params.uniqueId, msg.params.number, msg.params.id, msg.params.cluster, msg.params.attribute, msg.params.value);
                     this.server.respond({ ...msg, result: { success: true } });
@@ -931,6 +947,7 @@ export class Frontend extends EventEmitter {
             bridgeMode: this.matterbridge.bridgeMode,
             restartMode: this.matterbridge.restartMode,
             virtualMode: this.matterbridge.virtualMode,
+            bridgeStatus: this.matterbridge.bridgeStatus,
             profile: this.matterbridge.profile,
             loggerLevel: this.matterbridge.logLevel,
             fileLogger: this.matterbridge.fileLogger,
@@ -2113,12 +2130,30 @@ export class Frontend extends EventEmitter {
             this.wssSendCloseSnackbarMessage(`Restart required`);
         this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
     }
-    wssSendUpdateRequired(devVersion = false) {
+    wssSendUpdateRequired(version, devVersion = false) {
         if (!this.listening || this.webSocketServer?.clients.size === 0)
             return;
-        this.log.debug('Sending an update required message to all connected clients');
+        this.log.debug('Sending a matterbridge version update required message to all connected clients');
         this.updateRequired = true;
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { devVersion } });
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { version, devVersion } });
+    }
+    wssSendPluginUpdateRequired(plugin, version, devVersion = false) {
+        if (!this.listening || this.webSocketServer?.clients.size === 0)
+            return;
+        this.log.debug('Sending a plugin version update required message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_update_required', success: true, response: { plugin, version, devVersion } });
+    }
+    wssSendPluginStatusUpdate(plugin, status) {
+        if (!this.listening || this.webSocketServer?.clients.size === 0)
+            return;
+        this.log.debug('Sending a plugin status update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'plugin_status_update', success: true, response: { plugin, status } });
+    }
+    wssSendMatterbridgeStatusUpdate(status) {
+        if (!this.listening || this.webSocketServer?.clients.size === 0)
+            return;
+        this.log.debug('Sending a matterbridge status update message to all connected clients');
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'matterbridge_status_update', success: true, response: { status } });
     }
     wssSendCpuUpdate(cpuUsage, processCpuUsage) {
         if (!this.listening || this.webSocketServer?.clients.size === 0)

package/dist/helpers.js

@@ -61,7 +61,7 @@ export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
     if (matterbridge.virtualMode !== 'disabled' && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
         matterbridge.log.notice(`Creating virtual devices for Matterbridge server node...`);
         await addVirtualDevice(aggregatorEndpoint, 'Restart Matterbridge', matterbridge.virtualMode, async () => {
-            if (matterbridge.restartMode === '')
+            if (matterbridge.restartMode === 'none')
                 await matterbridge.restartProcess();
             else
                 await matterbridge.shutdownProcess();

package/dist/matterbridge.d.ts

@@ -5,7 +5,7 @@ import { Endpoint, ServerNode } from '@matter/node';
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
 import { type DeviceCertification } from '@matter/protocol';
 import { DeviceTypeId, VendorId } from '@matter/types/datatype';
-import type { ApiMatter, MaybePromise, PlatformMatterbridge, SharedMatterbridge, SystemInformation } from '@matterbridge/types';
+import type { ApiMatter, ApiSettings, BridgeMode, BridgeStatus, MaybePromise, PlatformMatterbridge, RestartMode, SharedMatterbridge, SystemInformation, VirtualMode } from '@matterbridge/types';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
 import { type NodeStorage, NodeStorageManager } from 'node-persist-manager';
 import { DeviceManager } from './deviceManager.js';
@@ -50,9 +50,10 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     dockerVersion: string | undefined;
     dockerLatestVersion: string | undefined;
     dockerDevVersion: string | undefined;
-    bridgeMode: 'bridge' | 'childbridge' | 'controller' | '';
-    restartMode: 'service' | 'docker' | '';
-    virtualMode: 'disabled' | 'outlet' | 'light' | 'switch' | 'mounted_switch';
+    bridgeMode: BridgeMode;
+    restartMode: RestartMode;
+    virtualMode: VirtualMode;
+    bridgeStatus: BridgeStatus;
     readonly profile: string | undefined;
     readonly log: AnsiLogger;
     logLevel: LogLevel;
@@ -116,6 +117,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     destroy(): void;
     getPlatformMatterbridge(): PlatformMatterbridge;
     getSharedMatterbridge(): SharedMatterbridge;
+    getApiSettings(): ApiSettings;
     private msgHandler;
     static loadInstance(initialize?: boolean): Promise<Matterbridge>;
     private initialize;
@@ -134,6 +136,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     shutdownProcessAndReset(): Promise<void>;
     shutdownProcessAndFactoryReset(): Promise<void>;
     private cleanup;
+    private sendPluginStatusUpdate;
     private startBridge;
     private startChildbridge;
     private startController;

package/dist/matterbridge.js

@@ -17,7 +17,7 @@ import { dev, MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_LOGGER_FILE,
 import { getIntParameter, getParameter, hasAnyParameter, hasParameter } from '@matterbridge/utils/cli';
 import { copyDirectory } from '@matterbridge/utils/copy-dir';
 import { createDirectory } from '@matterbridge/utils/create-dir';
-import { inspectError, logError } from '@matterbridge/utils/error';
+import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
 import { formatBytes, formatPercent, formatUptime } from '@matterbridge/utils/format';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { excludedInterfaceNamePattern } from '@matterbridge/utils/network';
@@ -72,9 +72,10 @@ export class Matterbridge extends EventEmitter {
     dockerVersion;
     dockerLatestVersion;
     dockerDevVersion;
-    bridgeMode = '';
-    restartMode = '';
+    bridgeMode = 'none';
+    restartMode = 'none';
     virtualMode = 'outlet';
+    bridgeStatus = 'inactive';
     profile = getParameter('profile');
     log = new AnsiLogger({
         logName: 'Matterbridge',
@@ -209,6 +210,49 @@ export class Matterbridge extends EventEmitter {
             passcode: this.passcode,
         };
     }
+    getApiSettings() {
+        return {
+            systemInformation: { ...this.systemInformation },
+            matterbridgeInformation: {
+                rootDirectory: this.rootDirectory,
+                homeDirectory: this.homeDirectory,
+                matterbridgeDirectory: this.matterbridgeDirectory,
+                matterbridgePluginDirectory: this.matterbridgePluginDirectory,
+                matterbridgeCertDirectory: this.matterbridgeCertDirectory,
+                globalModulesDirectory: this.globalModulesDirectory,
+                matterbridgeVersion: this.matterbridgeVersion,
+                matterbridgeLatestVersion: this.matterbridgeLatestVersion,
+                matterbridgeDevVersion: this.matterbridgeDevVersion,
+                frontendVersion: this.frontendVersion,
+                dockerDev: this.dockerDev,
+                dockerVersion: this.dockerVersion,
+                dockerLatestVersion: this.dockerLatestVersion,
+                dockerDevVersion: this.dockerDevVersion,
+                bridgeMode: this.bridgeMode,
+                restartMode: this.restartMode,
+                virtualMode: this.virtualMode,
+                bridgeStatus: this.bridgeStatus,
+                profile: this.profile,
+                readOnly: hasParameter('readonly'),
+                shellyBoard: false,
+                shellySysUpdate: false,
+                shellyMainUpdate: false,
+                loggerLevel: this.logLevel,
+                fileLogger: this.fileLogger,
+                matterLoggerLevel: this.matterLogLevel,
+                matterFileLogger: this.matterFileLogger,
+                matterMdnsInterface: this.mdnsInterface,
+                matterIpv4Address: this.ipv4Address,
+                matterIpv6Address: this.ipv6Address,
+                matterPort: this.port ?? 5540,
+                matterDiscriminator: this.discriminator,
+                matterPasscode: this.passcode,
+                restartRequired: false,
+                fixedRestartRequired: false,
+                updateRequired: false,
+            },
+        };
+    }
     async msgHandler(msg) {
         if (this.server.isWorkerRequest(msg) && (msg.dst === 'all' || msg.dst === 'matterbridge')) {
             if (this.verbose)
@@ -249,6 +293,9 @@ export class Matterbridge extends EventEmitter {
                 case 'matterbridge_shared':
                     this.server.respond({ ...msg, result: { data: this.getSharedMatterbridge(), success: true } });
                     break;
+                case 'matterbridge_apisettings':
+                    this.server.respond({ ...msg, result: { data: this.getApiSettings(), success: true } });
+                    break;
                 case 'matterbridge_start_plugin_server':
                     {
                         const plugin = this.plugins.get(msg.params.pluginName);
@@ -299,7 +346,7 @@ export class Matterbridge extends EventEmitter {
                         const packageName = msg.result.packageName.replace(/@.*$/, '');
                         if (packageName === 'matterbridge') {
                             this.log.info('Matterbridge has been updated. Full restart required.');
-                            if (this.restartMode !== '')
+                            if (this.restartMode !== 'none')
                                 await this.cleanup('updating...', false);
                         }
                     }
@@ -440,7 +487,7 @@ export class Matterbridge extends EventEmitter {
             }
         }
         catch (error) {
-            this.log.debug(`Pairing file ${CYAN}${pairingFilePath}${db} not found: ${error instanceof Error ? error.message : error}`);
+            this.log.debug(`Pairing file ${CYAN}${pairingFilePath}${db} not found: ${getErrorMessage(error)}`);
         }
         await this.nodeContext.set('matterport', this.port);
         await this.nodeContext.set('matterpasscode', this.passcode);
@@ -549,14 +596,14 @@ export class Matterbridge extends EventEmitter {
                 this.mdnsInterface = undefined;
         }
         if (this.mdnsInterface) {
-            if (!availableInterfaceNames.includes(this.mdnsInterface)) {
+            if (availableInterfaceNames.includes(this.mdnsInterface)) {
+                this.log.info(`Using mdnsinterface ${CYAN}${this.mdnsInterface}${nf} for the Matter MdnsBroadcaster.`);
+            }
+            else {
                 this.log.error(`Invalid mdnsinterface: ${this.mdnsInterface}. Available interfaces are: ${availableInterfaceNames.join(', ')}. Using all available interfaces.`);
                 this.mdnsInterface = undefined;
                 await this.nodeContext.remove('mattermdnsinterface');
             }
-            else {
-                this.log.info(`Using mdnsinterface ${CYAN}${this.mdnsInterface}${nf} for the Matter MdnsBroadcaster.`);
-            }
         }
         if (this.mdnsInterface)
             this.environment.vars.set('mdns.networkInterface', this.mdnsInterface);
@@ -683,12 +730,12 @@ export class Matterbridge extends EventEmitter {
             await plugin.nodeContext.set('author', plugin.author);
         }
         await this.logNodeAndSystemInfo();
-        this.log.notice(`Matterbridge version ${this.matterbridgeVersion} ` +
-            `${hasParameter('bridge') || (!hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'bridge') ? 'mode bridge ' : ''}` +
-            `${hasParameter('childbridge') || (!hasParameter('bridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'childbridge') ? 'mode childbridge ' : ''}` +
-            `${hasParameter('controller') ? 'mode controller ' : ''}` +
-            `${this.restartMode !== '' ? 'restart mode ' + this.restartMode + ' ' : ''}` +
-            `running on ${this.systemInformation.osType} (v.${this.systemInformation.osRelease}) platform ${this.systemInformation.osPlatform} arch ${this.systemInformation.osArch}`);
+        this.log.notice('Matterbridge version ' + this.matterbridgeVersion + ' ' +
+            (hasParameter('bridge') || (!hasParameter('childbridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'bridge') ? 'mode bridge ' : '') +
+            (hasParameter('childbridge') || (!hasParameter('bridge') && (await this.nodeContext?.get('bridgeMode', '')) === 'childbridge') ? 'mode childbridge ' : '') +
+            (hasParameter('controller') ? 'mode controller ' : '') +
+            (this.restartMode === 'none' ? '' : 'restart mode ' + this.restartMode + ' ') +
+            'running on ' + this.systemInformation.osType + ' (v.' + this.systemInformation.osRelease + ') platform ' + this.systemInformation.osPlatform + ' arch ' + this.systemInformation.osArch);
         const minNodeVersion = 20;
         const nodeVersion = process.versions.node;
         const [versionMajor] = nodeVersion.split('.').map(Number);
@@ -705,13 +752,13 @@ export class Matterbridge extends EventEmitter {
             this.log.info(`│ Registered plugins (${this.plugins.length})`);
             let index = 0;
             for (const plugin of this.plugins) {
-                if (index !== this.plugins.length - 1) {
-                    this.log.info(`├─┬─ plugin ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} version: ${plg}${plugin.version}${nf} ${plugin.enabled ? GREEN : RED}enabled${nf}`);
-                    this.log.info(`│ └─ entry ${UNDERLINE}${db}${plugin.path}${UNDERLINEOFF}${db}`);
+                if (index === this.plugins.length - 1) {
+                    this.log.info(`└─┬─ plugin ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} version: ${plg}${plugin.version}${nf} ${plugin.enabled ? GREEN : RED}${plugin.enabled ? 'enabled' : 'disabled'}${nf}`);
+                    this.log.info(`  └─ entry ${UNDERLINE}${db}${plugin.path}${UNDERLINEOFF}${db}`);
                 }
                 else {
-                    this.log.info(`└─┬─ plugin ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} version: ${plg}${plugin.version}${nf} ${plugin.enabled ? GREEN : RED}disabled${nf}`);
-                    this.log.info(`  └─ entry ${UNDERLINE}${db}${plugin.path}${UNDERLINEOFF}${db}`);
+                    this.log.info(`├─┬─ plugin ${plg}${plugin.name}${nf}: "${plg}${BRIGHT}${plugin.description}${RESET}${nf}" type: ${typ}${plugin.type}${nf} version: ${plg}${plugin.version}${nf} ${plugin.enabled ? GREEN : RED}${plugin.enabled ? 'enabled' : 'disabled'}${nf}`);
+                    this.log.info(`│ └─ entry ${UNDERLINE}${db}${plugin.path}${UNDERLINEOFF}${db}`);
                 }
                 index++;
             }
@@ -741,27 +788,31 @@ export class Matterbridge extends EventEmitter {
             this.shutdown = true;
             return;
         }
-        if (getParameter('add')) {
-            this.log.debug(`Adding plugin ${getParameter('add')}`);
-            await this.plugins.add(getParameter('add'));
+        const addPlugin = getParameter('add');
+        if (addPlugin) {
+            this.log.debug(`Adding plugin ${addPlugin}`);
+            await this.plugins.add(addPlugin);
             this.shutdown = true;
             return;
         }
-        if (getParameter('remove')) {
-            this.log.debug(`Removing plugin ${getParameter('remove')}`);
-            await this.plugins.remove(getParameter('remove'));
+        const removePlugin = getParameter('remove');
+        if (removePlugin) {
+            this.log.debug(`Removing plugin ${removePlugin}`);
+            await this.plugins.remove(removePlugin);
             this.shutdown = true;
             return;
         }
-        if (getParameter('enable')) {
-            this.log.debug(`Enabling plugin ${getParameter('enable')}`);
-            await this.plugins.enable(getParameter('enable'));
+        const enablePlugin = getParameter('enable');
+        if (enablePlugin) {
+            this.log.debug(`Enabling plugin ${enablePlugin}`);
+            await this.plugins.enable(enablePlugin);
             this.shutdown = true;
             return;
         }
-        if (getParameter('disable')) {
-            this.log.debug(`Disabling plugin ${getParameter('disable')}`);
-            await this.plugins.disable(getParameter('disable'));
+        const disablePlugin = getParameter('disable');
+        if (disablePlugin) {
+            this.log.debug(`Disabling plugin ${disablePlugin}`);
+            await this.plugins.disable(disablePlugin);
             this.shutdown = true;
             return;
         }
@@ -783,8 +834,8 @@ export class Matterbridge extends EventEmitter {
             }
         }
         catch (error) {
-            this.log.fatal(`Fatal error creating matter storage: ${error instanceof Error ? error.message : error}`);
-            throw new Error(`Fatal error creating matter storage: ${error instanceof Error ? error.message : error}`, { cause: error });
+            this.log.fatal(`Fatal error creating matter storage: ${getErrorMessage(error)}`);
+            throw new Error(`Fatal error creating matter storage: ${getErrorMessage(error)}`, { cause: error });
         }
         if (hasParameter('reset') && getParameter('reset') === undefined) {
             this.initialized = true;
@@ -792,15 +843,13 @@ export class Matterbridge extends EventEmitter {
             this.shutdown = true;
             return;
         }
-        if (hasParameter('reset') && getParameter('reset') !== undefined) {
-            this.log.debug(`Reset plugin ${getParameter('reset')}`);
-            const plugin = this.plugins.get(getParameter('reset'));
+        const resetPlugin = getParameter('reset');
+        if (hasParameter('reset') && resetPlugin !== undefined) {
+            this.log.debug(`Reset plugin ${resetPlugin}`);
+            const plugin = this.plugins.get(resetPlugin);
             if (plugin) {
                 const matterStorageManager = await this.matterStorageService?.open(plugin.name);
-                if (!matterStorageManager) {
-                    this.log.error(`Plugin ${plg}${plugin.name}${er} storageManager not found`);
-                }
-                else {
+                if (matterStorageManager) {
                     await matterStorageManager.createContext('events')?.clearAll();
                     await matterStorageManager.createContext('fabrics')?.clearAll();
                     await matterStorageManager.createContext('root')?.clearAll();
@@ -808,6 +857,9 @@ export class Matterbridge extends EventEmitter {
                     await matterStorageManager.createContext('persist')?.clearAll();
                     this.log.notice(`Reset commissioning for plugin ${plg}${plugin.name}${nt} done! Remove the device from the controller.`);
                 }
+                else {
+                    this.log.error(`Plugin ${plg}${plugin.name}${er} storageManager not found`);
+                }
             }
             else {
                 this.log.warn(`Plugin ${plg}${getParameter('reset')}${wr} not registerd in matterbridge`);
@@ -845,13 +897,13 @@ export class Matterbridge extends EventEmitter {
         }
         if (hasParameter('delay') && os.uptime() <= 60 * 5) {
             const { wait } = await import('@matterbridge/utils/wait');
-            const delay = getIntParameter('delay') || 120;
+            const delay = getIntParameter('delay') ?? 120;
             this.log.warn('Delay switch found with system uptime less then 5 minutes. Waiting for ' + delay + ' seconds before starting matterbridge...');
             await wait(delay * 1000, 'Race condition delay', true);
         }
         if (hasParameter('fixed_delay')) {
             const { wait } = await import('@matterbridge/utils/wait');
-            const delay = getIntParameter('fixed_delay') || 120;
+            const delay = getIntParameter('fixed_delay') ?? 120;
             this.log.warn('Fixed delay switch found. Waiting for ' + delay + ' seconds before starting matterbridge...');
             await wait(delay * 1000, 'Fixed race condition delay', true);
         }
@@ -899,25 +951,29 @@ export class Matterbridge extends EventEmitter {
         this.log.debug(`Registering uncaughtException and unhandledRejection handlers...`);
         process.removeAllListeners('uncaughtException');
         process.removeAllListeners('unhandledRejection');
-        this.exceptionHandler = async (error) => {
-            const errorMessage = error instanceof Error ? error.message : error;
+        this.exceptionHandler = (error) => {
+            const errorMessage = getErrorMessage(error);
             const errorInspect = inspect(error, { depth: 10 });
-            this.log.error(`Unhandled Exception detected: ${errorMessage}\nstack: ${errorInspect}}`);
+            this.log.error(`Unhandled Exception detected: ${errorMessage}\nstack: ${errorInspect}`);
         };
         process.on('uncaughtException', this.exceptionHandler);
-        this.rejectionHandler = async (reason, promise) => {
-            const errorMessage = reason instanceof Error ? reason.message : reason;
+        this.rejectionHandler = (reason, _promise) => {
+            const errorMessage = getErrorMessage(reason);
             const errorInspect = inspect(reason, { depth: 10 });
-            this.log.error(`Unhandled Rejection detected: ${promise}\nreason: ${errorMessage}\nstack: ${errorInspect}`);
+            this.log.error(`Unhandled Rejection detected: ${errorMessage}\nstack: ${errorInspect}`);
         };
         process.on('unhandledRejection', this.rejectionHandler);
         this.log.debug(`Registering SIGINT and SIGTERM signal handlers...`);
-        this.sigintHandler = async () => {
-            await this.cleanup('SIGINT received, cleaning up...');
+        this.sigintHandler = () => {
+            this.cleanup('SIGINT received, cleaning up...').catch((error) => {
+                this.log.error(`Error cleaning up on SIGINT: ${getErrorMessage(error)}`);
+            });
         };
         process.on('SIGINT', this.sigintHandler);
-        this.sigtermHandler = async () => {
-            await this.cleanup('SIGTERM received, cleaning up...');
+        this.sigtermHandler = () => {
+            this.cleanup('SIGTERM received, cleaning up...').catch((error) => {
+                this.log.error(`Error cleaning up on SIGTERM: ${getErrorMessage(error)}`);
+            });
         };
         process.on('SIGTERM', this.sigtermHandler);
     }
@@ -1152,6 +1208,7 @@ export class Matterbridge extends EventEmitter {
             this.emit('cleanup_started');
             this.hasCleanupStarted = true;
             this.log.info(message);
+            this.server.request({ type: 'frontend_matterbridgestatusupdate', src: 'matterbridge', dst: 'frontend', params: { status: (this.bridgeStatus = 'stopping') } });
             if (this.startMatterInterval) {
                 clearInterval(this.startMatterInterval);
                 this.startMatterInterval = undefined;
@@ -1300,6 +1357,7 @@ export class Matterbridge extends EventEmitter {
                     unlinkSafe(path.join(this.matterbridgeDirectory, MATTER_STORAGE_DIR, device.deviceName.replace(/[ .]/g, ''), 'root.subscriptions.subscriptions'), this.log);
                 }
             }
+            this.server.request({ type: 'frontend_matterbridgestatusupdate', src: 'matterbridge', dst: 'frontend', params: { status: (this.bridgeStatus = 'stopped') } });
             await this.frontend.stop();
             this.frontend.destroy();
             this.plugins.destroy();
@@ -1388,93 +1446,119 @@ export class Matterbridge extends EventEmitter {
                 this.log.debug('Cleanup already started...');
         }
     }
+    sendPluginStatusUpdate(plugin) {
+        this.server.request({
+            type: 'frontend_pluginstatusupdate',
+            src: 'matterbridge',
+            dst: 'frontend',
+            params: {
+                plugin: plugin.name,
+                status: {
+                    locked: plugin.locked,
+                    error: plugin.error,
+                    enabled: plugin.enabled,
+                    loaded: plugin.loaded,
+                    started: plugin.started,
+                    configured: plugin.configured,
+                    registeredDevices: plugin.registeredDevices,
+                },
+            },
+        });
+    }
     async startBridge() {
         if (!this.matterStorageManager)
             throw new Error('No storage manager initialized');
         if (!this.matterbridgeContext)
             throw new Error('No storage context initialized');
+        this.server.request({ type: 'frontend_matterbridgestatusupdate', src: 'matterbridge', dst: 'frontend', params: { status: (this.bridgeStatus = 'starting') } });
         this.serverNode = await this.createServerNode(this.matterbridgeContext, this.port ? this.port++ : undefined, this.passcode ? this.passcode++ : undefined, this.discriminator ? this.discriminator++ : undefined);
         this.aggregatorNode = await this.createAggregatorNode(this.matterbridgeContext);
         await this.serverNode.add(this.aggregatorNode);
         await addVirtualDevices(this, this.aggregatorNode);
-        await this.startPlugins();
+        await this.startPlugins(false, true);
         this.log.debug('Starting start matter interval in bridge mode...');
         this.frontend.wssSendSnackbarMessage(`The bridge is starting...`, 0, 'info');
         let failCount = 0;
-        this.startMatterInterval = setInterval(async () => {
-            if (failCount && failCount % 10 === 0) {
-                this.frontend.wssSendSnackbarMessage(`The bridge is still starting...`, 10, 'info');
-                this.frontend.wssSendRefreshRequired('plugins');
-            }
-            for (const plugin of this.plugins) {
-                if (!plugin.enabled)
-                    continue;
-                if (plugin.error) {
-                    clearInterval(this.startMatterInterval);
-                    this.startMatterInterval = undefined;
-                    this.log.debug('Cleared startMatterInterval interval for Matterbridge for plugin in error state');
-                    this.log.error(`The plugin ${plg}${plugin.name}${er} is in error state.`);
-                    this.log.error('The bridge will not start until the problem is solved to prevent the controllers from deleting all registered devices.');
-                    this.log.error('If you want to start the bridge disable the plugin in error state and restart.');
-                    this.frontend.wssSendSnackbarMessage(`The plugin ${plugin.name} is in error state. Check the logs.`, 0, 'error');
-                    this.frontend.wssSendSnackbarMessage(`The bridge is offline. Startup halted due to plugin errors.`, 0, 'error');
-                    this.frontend.wssSendRefreshRequired('plugins');
-                    this.frontend.wssSendCloseSnackbarMessage(`The bridge is starting...`);
-                    return;
-                }
-                if (!plugin.loaded || !plugin.started) {
-                    this.log.debug(`Waiting (failSafeCount=${failCount}/${this.failCountLimit}) in startMatterInterval interval for plugin ${plg}${plugin.name}${db} loaded: ${plugin.loaded} started: ${plugin.started}...`);
-                    failCount++;
-                    if (failCount > this.failCountLimit) {
-                        this.log.error(`Error waiting for plugin ${plg}${plugin.name}${er} to load and start. Plugin is in error state.`);
-                        plugin.error = true;
-                    }
-                    return;
+        this.startMatterInterval = setInterval(() => {
+            void (async () => {
+                if (failCount && failCount % 10 === 0) {
+                    this.frontend.wssSendSnackbarMessage(`The bridge is still starting...`, 10, 'info');
                 }
-            }
-            clearInterval(this.startMatterInterval);
-            this.startMatterInterval = undefined;
-            this.log.debug('Cleared startMatterInterval interval in bridge mode');
-            fireAndForget(this.startServerNode(this.serverNode), this.log, 'Start server node');
-            for (const device of this.devices.array()) {
-                if (device.mode === 'server' && device.serverNode) {
-                    this.log.debug(`Starting server node for device ${dev}${device.deviceName}${db} in server mode...`);
-                    fireAndForget(this.startServerNode(device.serverNode), this.log, `Start server node for device ${device.deviceName}`);
-                }
-            }
-            this.configureTimeout = setTimeout(async () => {
-                for (const plugin of this.plugins.array()) {
-                    if (!plugin.enabled || !plugin.loaded || !plugin.started || plugin.error)
+                for (const plugin of this.plugins) {
+                    if (!plugin.enabled)
                         continue;
-                    try {
-                        if ((await this.plugins.configure(plugin)) === undefined) {
-                            if (plugin.configured !== true)
-                                this.frontend.wssSendSnackbarMessage(`The plugin ${plugin.name} failed to configure. Check the logs.`, 0, 'error');
+                    if (plugin.error) {
+                        clearInterval(this.startMatterInterval);
+                        this.startMatterInterval = undefined;
+                        this.log.debug('Cleared startMatterInterval interval for Matterbridge for plugin in error state');
+                        this.log.error(`The plugin ${plg}${plugin.name}${er} is in error state.`);
+                        this.log.error('The bridge will not start until the problem is solved to prevent the controllers from deleting all registered devices.');
+                        this.log.error('If you want to start the bridge disable the plugin in error state and restart.');
+                        this.frontend.wssSendSnackbarMessage(`The plugin ${plugin.name} is in error state. Check the logs.`, 0, 'error');
+                        this.frontend.wssSendSnackbarMessage(`The bridge is offline. Startup halted due to plugin errors.`, 0, 'error');
+                        this.frontend.wssSendRefreshRequired('plugins');
+                        this.frontend.wssSendCloseSnackbarMessage(`The bridge is starting...`);
+                        this.server.request({ type: 'frontend_matterbridgestatusupdate', src: 'matterbridge', dst: 'frontend', params: { status: (this.bridgeStatus = 'error') } });
+                        return;
+                    }
+                    this.sendPluginStatusUpdate(plugin);
+                    if (!plugin.loaded || !plugin.started) {
+                        this.log.debug(`Waiting (failSafeCount=${failCount}/${this.failCountLimit}) in startMatterInterval interval for plugin ${plg}${plugin.name}${db} loaded: ${plugin.loaded} started: ${plugin.started}...`);
+                        failCount++;
+                        if (failCount > this.failCountLimit) {
+                            this.log.error(`Error waiting for plugin ${plg}${plugin.name}${er} to load and start. Plugin is in error state.`);
+                            plugin.error = true;
                         }
+                        return;
                     }
-                    catch (error) {
-                        plugin.error = true;
-                        this.log.error(`Error configuring plugin ${plg}${plugin.name}${er}`, error);
+                }
+                clearInterval(this.startMatterInterval);
+                this.startMatterInterval = undefined;
+                this.log.debug('Cleared startMatterInterval interval in bridge mode');
+                fireAndForget(this.startServerNode(this.serverNode), this.log, 'Start server node');
+                for (const device of this.devices.array()) {
+                    if (device.mode === 'server' && device.serverNode) {
+                        this.log.debug(`Starting server node for device ${dev}${device.deviceName}${db} in server mode...`);
+                        fireAndForget(this.startServerNode(device.serverNode), this.log, `Start server node for device ${device.deviceName}`);
                     }
                 }
-                this.frontend.wssSendRefreshRequired('plugins');
-            }, 30 * 1000).unref();
-            this.reachabilityTimeout = setTimeout(() => {
-                this.log.info(`Setting reachability to true for ${plg}Matterbridge${db}`);
-                if (this.aggregatorNode)
-                    fireAndForget(this.setAggregatorReachability(this.aggregatorNode, true), this.log, `Set aggregator node reachability for Matterbridge`);
-            }, 60 * 1000).unref();
-            this.emit('bridge_started');
-            this.log.notice('Matterbridge bridge started successfully');
-            this.frontend.wssSendRefreshRequired('settings');
-            this.frontend.wssSendRefreshRequired('plugins');
-            this.frontend.wssSendCloseSnackbarMessage(`The bridge is starting...`);
+                this.configureTimeout = setTimeout(() => {
+                    void (async () => {
+                        for (const plugin of this.plugins.array()) {
+                            if (!plugin.enabled || !plugin.loaded || !plugin.started || plugin.error)
+                                continue;
+                            try {
+                                if ((await this.plugins.configure(plugin)) === undefined) {
+                                    if (plugin.configured !== true)
+                                        this.frontend.wssSendSnackbarMessage(`The plugin ${plugin.name} failed to configure. Check the logs.`, 0, 'error');
+                                }
+                            }
+                            catch (error) {
+                                plugin.error = true;
+                                this.log.error(`Error configuring plugin ${plg}${plugin.name}${er}`, error);
+                            }
+                            this.sendPluginStatusUpdate(plugin);
+                        }
+                    })();
+                }, 30 * 1000).unref();
+                this.reachabilityTimeout = setTimeout(() => {
+                    this.log.info(`Setting reachability to true for ${plg}Matterbridge${db}`);
+                    if (this.aggregatorNode)
+                        fireAndForget(this.setAggregatorReachability(this.aggregatorNode, true), this.log, `Failed to set aggregator node reachability for Matterbridge`);
+                }, 60 * 1000).unref();
+                this.emit('bridge_started');
+                this.log.notice('Matterbridge bridge started successfully');
+                this.server.request({ type: 'frontend_matterbridgestatusupdate', src: 'matterbridge', dst: 'frontend', params: { status: (this.bridgeStatus = 'started') } });
+                this.server.request({ type: 'frontend_refreshrequired', src: 'matterbridge', dst: 'frontend', params: { changed: 'plugins' } });
+                this.server.request({ type: 'frontend_closesnackbarmessage', src: 'matterbridge', dst: 'frontend', params: { message: `The bridge is starting...` } });
+            })();
         }, Number(process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS']) || this.startMatterIntervalMs);
     }
     async startChildbridge(delay = 1000) {
         if (!this.matterStorageManager)
             throw new Error('No storage manager initialized');
         const { wait } = await import('@matterbridge/utils/wait');
+        this.server.request({ type: 'frontend_matterbridgestatusupdate', src: 'matterbridge', dst: 'frontend', params: { status: (this.bridgeStatus = 'starting') } });
         this.log.debug('Loading all plugins in childbridge mode...');
         await this.startPlugins(true, false);
         this.log.debug('Creating server nodes for DynamicPlatform plugins and starting all plugins in childbridge mode...');
@@ -1486,100 +1570,105 @@ export class Matterbridge extends EventEmitter {
         this.log.debug('Starting start matter interval in childbridge mode...');
         this.frontend.wssSendSnackbarMessage(`The bridge is starting...`, 0, 'info');
         let failCount = 0;
-        this.startMatterInterval = setInterval(async () => {
-            if (failCount && failCount % 10 === 0) {
-                this.frontend.wssSendSnackbarMessage(`The bridge is still starting...`, 10, 'info');
-                this.frontend.wssSendRefreshRequired('plugins');
-            }
-            let allStarted = true;
-            for (const plugin of this.plugins.array()) {
-                if (!plugin.enabled)
-                    continue;
-                if (plugin.error) {
-                    clearInterval(this.startMatterInterval);
-                    this.startMatterInterval = undefined;
-                    this.log.debug('Cleared startMatterInterval interval for a plugin in error state');
-                    this.log.error(`The plugin ${plg}${plugin.name}${er} is in error state.`);
-                    this.log.error('The bridge will not start until the problem is solved to prevent the controllers from deleting all registered devices.');
-                    this.log.error('If you want to start the bridge disable the plugin in error state and restart.');
-                    this.frontend.wssSendSnackbarMessage(`The plugin ${plugin.name} is in error state. Check the logs.`, 0, 'error');
-                    this.frontend.wssSendSnackbarMessage(`The bridge is offline. Startup halted due to plugin errors.`, 0, 'error');
-                    this.frontend.wssSendRefreshRequired('plugins');
-                    this.frontend.wssSendCloseSnackbarMessage(`The bridge is starting...`);
-                    return;
+        this.startMatterInterval = setInterval(() => {
+            void (async () => {
+                if (failCount && failCount % 10 === 0) {
+                    this.frontend.wssSendSnackbarMessage(`The bridge is still starting...`, 10, 'info');
                 }
-                this.log.debug(`Checking plugin ${plg}${plugin.name}${db} to start matter in childbridge mode...`);
-                if (!plugin.loaded || !plugin.started) {
-                    allStarted = false;
-                    this.log.debug(`Waiting (failSafeCount=${failCount}/${this.failCountLimit}) for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) ...`);
-                    failCount++;
-                    if (failCount > this.failCountLimit) {
-                        this.log.error(`Error waiting for plugin ${plg}${plugin.name}${er} to load and start. Plugin is in error state.`);
-                        plugin.error = true;
+                let allStarted = true;
+                for (const plugin of this.plugins.array()) {
+                    if (!plugin.enabled)
+                        continue;
+                    if (plugin.error) {
+                        clearInterval(this.startMatterInterval);
+                        this.startMatterInterval = undefined;
+                        this.log.debug('Cleared startMatterInterval interval for a plugin in error state');
+                        this.log.error(`The plugin ${plg}${plugin.name}${er} is in error state.`);
+                        this.log.error('The bridge will not start until the problem is solved to prevent the controllers from deleting all registered devices.');
+                        this.log.error('If you want to start the bridge disable the plugin in error state and restart.');
+                        this.frontend.wssSendSnackbarMessage(`The plugin ${plugin.name} is in error state. Check the logs.`, 0, 'error');
+                        this.frontend.wssSendSnackbarMessage(`The bridge is offline. Startup halted due to plugin errors.`, 0, 'error');
+                        this.frontend.wssSendRefreshRequired('plugins');
+                        this.frontend.wssSendCloseSnackbarMessage(`The bridge is starting...`);
+                        this.server.request({ type: 'frontend_matterbridgestatusupdate', src: 'matterbridge', dst: 'frontend', params: { status: (this.bridgeStatus = 'error') } });
+                        return;
+                    }
+                    this.sendPluginStatusUpdate(plugin);
+                    this.log.debug(`Checking plugin ${plg}${plugin.name}${db} to start matter in childbridge mode...`);
+                    if (!plugin.loaded || !plugin.started) {
+                        allStarted = false;
+                        this.log.debug(`Waiting (failSafeCount=${failCount}/${this.failCountLimit}) for plugin ${plg}${plugin.name}${db} to load (${plugin.loaded}) and start (${plugin.started}) ...`);
+                        failCount++;
+                        if (failCount > this.failCountLimit) {
+                            this.log.error(`Error waiting for plugin ${plg}${plugin.name}${er} to load and start. Plugin is in error state.`);
+                            plugin.error = true;
+                        }
                     }
                 }
-            }
-            if (!allStarted)
-                return;
-            clearInterval(this.startMatterInterval);
-            this.startMatterInterval = undefined;
-            if (delay > 0)
-                await wait(Number(process.env['MATTERBRIDGE_PAUSE_MATTER_INTERVAL_MS']) || delay);
-            this.log.debug('Cleared startMatterInterval interval in childbridge mode');
-            this.configureTimeout = setTimeout(async () => {
+                if (!allStarted)
+                    return;
+                clearInterval(this.startMatterInterval);
+                this.startMatterInterval = undefined;
+                if (delay > 0)
+                    await wait(Number(process.env['MATTERBRIDGE_PAUSE_MATTER_INTERVAL_MS']) || delay);
+                this.log.debug('Cleared startMatterInterval interval in childbridge mode');
+                this.configureTimeout = setTimeout(() => {
+                    void (async () => {
+                        for (const plugin of this.plugins.array()) {
+                            if (!plugin.enabled || !plugin.loaded || !plugin.started || plugin.error)
+                                continue;
+                            try {
+                                if ((await this.plugins.configure(plugin)) === undefined) {
+                                    if (plugin.configured !== true)
+                                        this.frontend.wssSendSnackbarMessage(`The plugin ${plugin.name} failed to configure. Check the logs.`, 0, 'error');
+                                }
+                            }
+                            catch (error) {
+                                plugin.error = true;
+                                this.log.error(`Error configuring plugin ${plg}${plugin.name}${er}`, error);
+                            }
+                            this.sendPluginStatusUpdate(plugin);
+                        }
+                    })();
+                }, 30 * 1000).unref();
                 for (const plugin of this.plugins.array()) {
-                    if (!plugin.enabled || !plugin.loaded || !plugin.started || plugin.error)
+                    if (!plugin.enabled || plugin.error)
+                        continue;
+                    if (plugin.type !== 'DynamicPlatform' && (!plugin.registeredDevices || plugin.registeredDevices === 0)) {
+                        this.log.error(`Plugin ${plg}${plugin.name}${er} didn't register any devices to Matterbridge. Verify the plugin configuration.`);
                         continue;
-                    try {
-                        if ((await this.plugins.configure(plugin)) === undefined) {
-                            if (plugin.configured !== true)
-                                this.frontend.wssSendSnackbarMessage(`The plugin ${plugin.name} failed to configure. Check the logs.`, 0, 'error');
-                        }
                     }
-                    catch (error) {
-                        plugin.error = true;
-                        this.log.error(`Error configuring plugin ${plg}${plugin.name}${er}`, error);
+                    if (!plugin.serverNode) {
+                        this.log.error(`Server node not found for plugin ${plg}${plugin.name}${er}`);
+                        continue;
                     }
+                    if (!plugin.storageContext) {
+                        this.log.error(`Storage context not found for plugin ${plg}${plugin.name}${er}`);
+                        continue;
+                    }
+                    if (!plugin.nodeContext) {
+                        this.log.error(`Node storage context not found for plugin ${plg}${plugin.name}${er}`);
+                        continue;
+                    }
+                    fireAndForget(this.startServerNode(plugin.serverNode), this.log, `Start server node for plugin ${plugin.name}`);
+                    plugin.reachabilityTimeout = setTimeout(() => {
+                        this.log.info(`Setting reachability to true for ${plg}${plugin.name}${nf}`);
+                        if (plugin.type === 'DynamicPlatform' && plugin.aggregatorNode)
+                            fireAndForget(this.setAggregatorReachability(plugin.aggregatorNode, true), this.log, `Set aggregator node reachability for plugin ${plugin.name}`);
+                    }, 60 * 1000).unref();
                 }
-                this.frontend.wssSendRefreshRequired('plugins');
-            }, 30 * 1000).unref();
-            for (const plugin of this.plugins.array()) {
-                if (!plugin.enabled || plugin.error)
-                    continue;
-                if (plugin.type !== 'DynamicPlatform' && (!plugin.registeredDevices || plugin.registeredDevices === 0)) {
-                    this.log.error(`Plugin ${plg}${plugin.name}${er} didn't register any devices to Matterbridge. Verify the plugin configuration.`);
-                    continue;
-                }
-                if (!plugin.serverNode) {
-                    this.log.error(`Server node not found for plugin ${plg}${plugin.name}${er}`);
-                    continue;
-                }
-                if (!plugin.storageContext) {
-                    this.log.error(`Storage context not found for plugin ${plg}${plugin.name}${er}`);
-                    continue;
-                }
-                if (!plugin.nodeContext) {
-                    this.log.error(`Node storage context not found for plugin ${plg}${plugin.name}${er}`);
-                    continue;
-                }
-                fireAndForget(this.startServerNode(plugin.serverNode), this.log, `Start server node for plugin ${plugin.name}`);
-                plugin.reachabilityTimeout = setTimeout(() => {
-                    this.log.info(`Setting reachability to true for ${plg}${plugin.name}${nf}`);
-                    if (plugin.type === 'DynamicPlatform' && plugin.aggregatorNode)
-                        fireAndForget(this.setAggregatorReachability(plugin.aggregatorNode, true), this.log, `Set aggregator node reachability for plugin ${plugin.name}`);
-                }, 60 * 1000).unref();
-            }
-            for (const device of this.devices.array()) {
-                if (device.mode === 'server' && device.serverNode) {
-                    this.log.debug(`Starting server node for device ${dev}${device.deviceName}${db} in server mode...`);
-                    fireAndForget(this.startServerNode(device.serverNode), this.log, `Start server node for device ${device.deviceName}`);
+                for (const device of this.devices.array()) {
+                    if (device.mode === 'server' && device.serverNode) {
+                        this.log.debug(`Starting server node for device ${dev}${device.deviceName}${db} in server mode...`);
+                        fireAndForget(this.startServerNode(device.serverNode), this.log, `Start server node for device ${device.deviceName}`);
+                    }
                 }
-            }
-            this.emit('childbridge_started');
-            this.log.notice('Matterbridge childbridge started successfully');
-            this.frontend.wssSendRefreshRequired('settings');
-            this.frontend.wssSendRefreshRequired('plugins');
-            this.frontend.wssSendCloseSnackbarMessage(`The bridge is starting...`);
+                this.emit('childbridge_started');
+                this.log.notice('Matterbridge childbridge started successfully');
+                this.server.request({ type: 'frontend_matterbridgestatusupdate', src: 'matterbridge', dst: 'frontend', params: { status: (this.bridgeStatus = 'started') } });
+                this.server.request({ type: 'frontend_refreshrequired', src: 'matterbridge', dst: 'frontend', params: { changed: 'plugins' } });
+                this.server.request({ type: 'frontend_closesnackbarmessage', src: 'matterbridge', dst: 'frontend', params: { message: `The bridge is starting...` } });
+            })();
         }, Number(process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS']) || this.startMatterIntervalMs);
     }
     async startController() {
@@ -1732,9 +1821,13 @@ export class Matterbridge extends EventEmitter {
             this.frontend.wssSendSnackbarMessage(`${storeId} is offline`, 5, 'warning');
             this.frontend.wssSendSnackbarMessage(`Server node for ${storeId} fully decommissioned successfully!`, 5, 'success');
         });
-        serverNode.lifecycle.online.on(async () => {
+        serverNode.lifecycle.online.on(() => {
             this.log.notice(`Server node for ${storeId} is online`);
-            if (!serverNode.lifecycle.isCommissioned) {
+            if (serverNode.lifecycle.isCommissioned) {
+                this.log.notice(`Server node for ${storeId} is already commissioned.`);
+                this.advertisingNodes.delete(storeId);
+            }
+            else {
                 this.log.notice(`Server node for ${storeId} is not commissioned. Pair to commission.`);
                 this.advertisingNodes.set(storeId, Date.now());
                 const { qrPairingCode, manualPairingCode } = serverNode.state.commissioning.pairingCodes;
@@ -1742,10 +1835,6 @@ export class Matterbridge extends EventEmitter {
                 this.log.notice(`QR Code URL: https://project-chip.github.io/connectedhomeip/qrcode.html?data=${qrPairingCode}`);
                 this.log.notice(`Manual pairing code ${CYAN}${manualPairingCode}${nt} discriminator ${CYAN}${discriminator}${nt} short discriminator ${CYAN}${pairingData.shortDiscriminator}${nt} passcode ${CYAN}${passcode}${nt}`);
             }
-            else {
-                this.log.notice(`Server node for ${storeId} is already commissioned.`);
-                this.advertisingNodes.delete(storeId);
-            }
             this.frontend.wssSendRefreshRequired('matter', { matter: { ...this.getServerNodeData(serverNode) } });
             this.frontend.wssSendSnackbarMessage(`${storeId} is online`, 5, 'success');
             this.emit('online', storeId);
@@ -1790,7 +1879,7 @@ export class Matterbridge extends EventEmitter {
         return serverNode;
     }
     getServerNodeData(serverNode) {
-        const advertiseTime = this.advertisingNodes.get(serverNode.id) || 0;
+        const advertiseTime = this.advertisingNodes.get(serverNode.id) ?? 0;
         return {
             id: serverNode.id,
             online: serverNode.lifecycle.isOnline,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.9.2-dev-20260620-9802e5b",
+  "version": "3.9.2-dev-20260621-75283ba",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -130,16 +130,16 @@
   ],
   "dependencies": {
     "@matter/main": "0.17.3",
-    "@matterbridge/dgram": "3.9.2-dev-20260620-9802e5b",
-    "@matterbridge/thread": "3.9.2-dev-20260620-9802e5b",
-    "@matterbridge/types": "3.9.2-dev-20260620-9802e5b",
-    "@matterbridge/utils": "3.9.2-dev-20260620-9802e5b",
+    "@matterbridge/dgram": "3.9.2-dev-20260621-75283ba",
+    "@matterbridge/thread": "3.9.2-dev-20260621-75283ba",
+    "@matterbridge/types": "3.9.2-dev-20260621-75283ba",
+    "@matterbridge/utils": "3.9.2-dev-20260621-75283ba",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.5.2",
     "multer": "2.2.0",
-    "node-ansi-logger": "3.3.0-dev-20260617-6ebcff7",
-    "node-persist-manager": "2.1.0-dev-20260617-3224082",
+    "node-ansi-logger": "3.3.0",
+    "node-persist-manager": "2.1.0",
     "ws": "8.21.0"
   }
 }