@matterbridge/core 3.7.2-dev-20260331-ac050d8 → 3.7.2-dev-20260402-c12a10e

package/dist/backendExpress.d.ts

@@ -0,0 +1,18 @@
+import { type SharedMatterbridge } from '@matterbridge/types';
+import express from 'express';
+import type { Frontend } from './frontend.js';
+export declare class BackendExpress {
+    private debug;
+    private verbose;
+    private expressApp;
+    private log;
+    private backend;
+    private matterbridge;
+    private readonly server;
+    constructor(matterbridge: SharedMatterbridge, backend: Frontend);
+    destroy(): void;
+    private broadcastMsgHandler;
+    private validateReq;
+    start(): Promise<express.Application | undefined>;
+    stop(): Promise<express.Application | undefined>;
+}

package/dist/backendExpress.js

@@ -0,0 +1,445 @@
+import os from 'node:os';
+import path from 'node:path';
+import { BroadcastServer } from '@matterbridge/thread';
+import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_BACKUP_FILE, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, MATTERBRIDGE_PLUGIN_CONFIG_FILE, MATTERBRIDGE_PLUGIN_STORAGE_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
+import { hasParameter } from '@matterbridge/utils/cli';
+import { getErrorMessage } from '@matterbridge/utils/error';
+import { formatBytes } from '@matterbridge/utils/format';
+import express from 'express';
+import multer from 'multer';
+import { AnsiLogger, er, nf } from 'node-ansi-logger';
+if (hasParameter('loader'))
+    console.log('\u001B[32mBackendExpress loaded.\u001B[40;0m');
+export class BackendExpress {
+    debug;
+    verbose;
+    expressApp;
+    log;
+    backend;
+    matterbridge;
+    server;
+    constructor(matterbridge, backend) {
+        this.debug = hasParameter('debug') || hasParameter('verbose') || hasParameter('debug-frontend') || hasParameter('verbose-frontend');
+        this.verbose = hasParameter('verbose') || hasParameter('verbose-frontend');
+        this.backend = backend;
+        this.matterbridge = matterbridge;
+        this.log = new AnsiLogger({
+            logName: 'BackendExpress',
+            logNameColor: '\x1b[38;5;97m',
+            logTimestampFormat: 4,
+            logLevel: this.debug ? "debug" : "info",
+        });
+        this.server = new BroadcastServer('frontend', this.log);
+        this.server.on('broadcast_message', this.broadcastMsgHandler.bind(this));
+    }
+    destroy() {
+        this.server.off('broadcast_message', this.broadcastMsgHandler.bind(this));
+        this.server.close();
+    }
+    async broadcastMsgHandler(msg) {
+        if (this.server.isWorkerRequest(msg)) {
+            switch (msg.type) {
+                case 'get_log_level':
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+                case 'set_log_level':
+                    this.log.logLevel = msg.params.logLevel;
+                    this.server.respond({ ...msg, result: { logLevel: this.log.logLevel } });
+                    break;
+            }
+        }
+    }
+    validateReq(req, res) {
+        if (req.ip && !this.backend.authClients.has(req.ip)) {
+            this.log.warn(`Warning blocked unauthorized access request ${req.originalUrl ?? req.url} from ${req.ip}`);
+            res.status(401).json({ error: 'Unauthorized' });
+            return false;
+        }
+        return true;
+    }
+    async start() {
+        this.log.debug('Starting express application...');
+        const uploadDir = path.join(this.matterbridge.matterbridgeDirectory, 'uploads');
+        const upload = multer({ dest: uploadDir });
+        this.expressApp = express();
+        if (this.verbose) {
+            this.expressApp.use((req, res, next) => {
+                this.log.debug(`Received request on expressApp: ${req.method} ${req.url}`);
+                next();
+            });
+        }
+        this.expressApp.use(express.static(path.join(this.matterbridge.rootDirectory, 'apps', 'frontend', 'build')));
+        this.expressApp.post('/api/login', express.json(), async (req, res) => {
+            const { password } = req.body;
+            this.log.debug(`The frontend sent /api/login with password ${password ? '[redacted]' : '(empty)'}`);
+            if (this.backend.storedPassword === '' || password === this.backend.storedPassword) {
+                this.log.debug('/api/login password valid');
+                res.json({ valid: true });
+                if (req.ip)
+                    this.backend.authClients.add(req.ip);
+            }
+            else {
+                this.log.warn('/api/login error wrong password');
+                res.json({ valid: false });
+            }
+        });
+        this.expressApp.get('/health', (req, res) => {
+            this.log.debug('Express received /health');
+            const healthStatus = {
+                status: 'ok',
+                uptime: process.uptime(),
+                timestamp: new Date().toISOString(),
+            };
+            res.status(200).json(healthStatus);
+        });
+        this.expressApp.get('/memory', async (req, res) => {
+            this.log.debug('Express received /memory');
+            const memoryUsageRaw = process.memoryUsage();
+            const memoryUsage = {
+                rss: formatBytes(memoryUsageRaw.rss),
+                heapTotal: formatBytes(memoryUsageRaw.heapTotal),
+                heapUsed: formatBytes(memoryUsageRaw.heapUsed),
+                external: formatBytes(memoryUsageRaw.external),
+                arrayBuffers: formatBytes(memoryUsageRaw.arrayBuffers),
+            };
+            const { default: v8 } = await import('node:v8');
+            const heapStatsRaw = v8.getHeapStatistics();
+            const heapSpacesRaw = v8.getHeapSpaceStatistics();
+            const heapStats = Object.fromEntries(Object.entries(heapStatsRaw).map(([key, value]) => [key, formatBytes(value)]));
+            const heapSpaces = heapSpacesRaw.map((space) => ({
+                ...space,
+                space_size: formatBytes(space.space_size),
+                space_used_size: formatBytes(space.space_used_size),
+                space_available_size: formatBytes(space.space_available_size),
+                physical_space_size: formatBytes(space.physical_space_size),
+            }));
+            const { createRequire } = await import('node:module');
+            const require = createRequire(import.meta.url);
+            const cjsModules = Object.keys(require.cache).sort();
+            const memoryReport = {
+                memoryUsage,
+                heapStats,
+                heapSpaces,
+                cjsModules,
+            };
+            res.status(200).json(memoryReport);
+        });
+        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());
+        });
+        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());
+        });
+        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());
+        });
+        this.expressApp.get('/api/view-mblog', async (req, res) => {
+            this.log.debug('The frontend sent /api/view-mblog');
+            if (!this.validateReq(req, res))
+                return;
+            try {
+                const fs = await import('node:fs');
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_LOGGER_FILE), 'utf8');
+                res.type('text/plain; charset=utf-8');
+                res.send(data);
+            }
+            catch (error) {
+                this.log.error(`Error reading matterbridge log file ${MATTERBRIDGE_LOGGER_FILE}: ${getErrorMessage(error)}`);
+                res.status(500).send('Error reading matterbridge log file. Please enable the matterbridge log on file in the settings.');
+            }
+        });
+        this.expressApp.get('/api/download-mblog', async (req, res) => {
+            this.log.debug(`The frontend sent /api/download-mblog ${path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_LOGGER_FILE)}`);
+            if (!this.validateReq(req, res))
+                return;
+            const fs = await import('node:fs');
+            try {
+                await fs.promises.access(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_LOGGER_FILE), fs.constants.F_OK);
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_LOGGER_FILE), 'utf8');
+                await fs.promises.writeFile(path.join(os.tmpdir(), MATTERBRIDGE_LOGGER_FILE), data, 'utf-8');
+            }
+            catch (error) {
+                await fs.promises.writeFile(path.join(os.tmpdir(), MATTERBRIDGE_LOGGER_FILE), 'Enable the matterbridge log on file in the settings to download the matterbridge log.', 'utf-8');
+                this.log.debug(`Error in /api/download-mblog: ${getErrorMessage(error)}`);
+            }
+            res.type('text/plain; charset=utf-8');
+            res.download(path.join(os.tmpdir(), MATTERBRIDGE_LOGGER_FILE), 'matterbridge.log', (error) => {
+                if (error) {
+                    this.log.error(`Error downloading log file ${MATTERBRIDGE_LOGGER_FILE}: ${getErrorMessage(error)}`);
+                    res.status(500).send('Error downloading the matterbridge log file');
+                }
+                else {
+                    this.log.debug(`Matterbridge log file ${MATTERBRIDGE_LOGGER_FILE} downloaded successfully`);
+                }
+            });
+        });
+        this.expressApp.get('/api/view-mjlog', async (req, res) => {
+            this.log.debug('The frontend sent /api/view-mjlog');
+            if (!this.validateReq(req, res))
+                return;
+            try {
+                const fs = await import('node:fs');
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTER_LOGGER_FILE), 'utf8');
+                res.type('text/plain; charset=utf-8');
+                res.send(data);
+            }
+            catch (error) {
+                this.log.error(`Error reading matter log file ${MATTER_LOGGER_FILE}: ${getErrorMessage(error)}`);
+                res.status(500).send('Error reading matter log file. Please enable the matter log on file in the settings.');
+            }
+        });
+        this.expressApp.get('/api/download-mjlog', async (req, res) => {
+            this.log.debug(`The frontend sent /api/download-mjlog ${path.join(this.matterbridge.matterbridgeDirectory, MATTER_LOGGER_FILE)}`);
+            if (!this.validateReq(req, res))
+                return;
+            const fs = await import('node:fs');
+            try {
+                await fs.promises.access(path.join(this.matterbridge.matterbridgeDirectory, MATTER_LOGGER_FILE), fs.constants.F_OK);
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTER_LOGGER_FILE), 'utf8');
+                await fs.promises.writeFile(path.join(os.tmpdir(), MATTER_LOGGER_FILE), data, 'utf-8');
+            }
+            catch (error) {
+                await fs.promises.writeFile(path.join(os.tmpdir(), MATTER_LOGGER_FILE), 'Enable the matter log on file in the settings to download the matter log.', 'utf-8');
+                this.log.debug(`Error in /api/download-mjlog: ${getErrorMessage(error)}`);
+            }
+            res.type('text/plain; charset=utf-8');
+            res.download(path.join(os.tmpdir(), MATTER_LOGGER_FILE), 'matter.log', (error) => {
+                if (error) {
+                    this.log.error(`Error downloading log file ${MATTER_LOGGER_FILE}: ${getErrorMessage(error)}`);
+                    res.status(500).send('Error downloading the matter log file');
+                }
+                else {
+                    this.log.debug(`Matter log file ${MATTER_LOGGER_FILE} downloaded successfully`);
+                }
+            });
+        });
+        this.expressApp.get('/api/view-diagnostic', async (req, res) => {
+            this.log.debug('The frontend sent /api/view-diagnostic');
+            if (!this.validateReq(req, res))
+                return;
+            await this.backend.generateDiagnostic();
+            try {
+                const fs = await import('node:fs');
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), 'utf8');
+                res.type('text/plain; charset=utf-8');
+                res.send(data.slice(29));
+            }
+            catch (error) {
+                this.log.error(`Error reading diagnostic log file ${MATTERBRIDGE_DIAGNOSTIC_FILE}: ${getErrorMessage(error)}`);
+                res.status(500).send('Error reading diagnostic log file.');
+            }
+        });
+        this.expressApp.get('/api/download-diagnostic', async (req, res) => {
+            this.log.debug(`The frontend sent /api/download-diagnostic`);
+            if (!this.validateReq(req, res))
+                return;
+            await this.backend.generateDiagnostic();
+            try {
+                const fs = await import('node:fs');
+                await fs.promises.access(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), fs.constants.F_OK);
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_DIAGNOSTIC_FILE), 'utf8');
+                await fs.promises.writeFile(path.join(os.tmpdir(), MATTERBRIDGE_DIAGNOSTIC_FILE), data, 'utf-8');
+            }
+            catch (error) {
+                this.log.debug(`Error in /api/download-diagnostic: ${getErrorMessage(error)}`);
+            }
+            res.type('text/plain; charset=utf-8');
+            res.download(path.join(os.tmpdir(), MATTERBRIDGE_DIAGNOSTIC_FILE), MATTERBRIDGE_DIAGNOSTIC_FILE, (error) => {
+                if (error) {
+                    this.log.error(`Error downloading file ${MATTERBRIDGE_DIAGNOSTIC_FILE}: ${getErrorMessage(error)}`);
+                    res.status(500).send('Error downloading the diagnostic log file');
+                }
+                else {
+                    this.log.debug(`Diagnostic log file ${MATTERBRIDGE_DIAGNOSTIC_FILE} downloaded successfully`);
+                }
+            });
+        });
+        this.expressApp.get('/api/viewhistory', async (req, res) => {
+            this.log.debug('The frontend sent /api/viewhistory');
+            if (!this.validateReq(req, res))
+                return;
+            try {
+                const fs = await import('node:fs');
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), 'utf8');
+                res.type('text/html; charset=utf-8');
+                res.send(data);
+            }
+            catch (error) {
+                this.log.error(`Error in /api/viewhistory reading history file ${MATTERBRIDGE_HISTORY_FILE}: ${getErrorMessage(error)}`);
+                res.status(500).send('Error reading history file.');
+            }
+        });
+        this.expressApp.get('/api/downloadhistory', async (req, res) => {
+            this.log.debug(`The frontend sent /api/downloadhistory`);
+            if (!this.validateReq(req, res))
+                return;
+            try {
+                const fs = await import('node:fs');
+                await fs.promises.access(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), fs.constants.F_OK);
+                const data = await fs.promises.readFile(path.join(this.matterbridge.matterbridgeDirectory, MATTERBRIDGE_HISTORY_FILE), 'utf8');
+                await fs.promises.writeFile(path.join(os.tmpdir(), MATTERBRIDGE_HISTORY_FILE), data, 'utf-8');
+                res.type('text/html; charset=utf-8');
+                res.download(path.join(os.tmpdir(), MATTERBRIDGE_HISTORY_FILE), MATTERBRIDGE_HISTORY_FILE, (error) => {
+                    if (error) {
+                        this.log.error(`Error in /api/downloadhistory downloading history file ${MATTERBRIDGE_HISTORY_FILE}: ${getErrorMessage(error)}`);
+                        res.status(500).send('Error downloading history file');
+                    }
+                    else {
+                        this.log.debug(`History file ${MATTERBRIDGE_HISTORY_FILE} downloaded successfully`);
+                    }
+                });
+            }
+            catch (error) {
+                this.log.error(`Error in /api/downloadhistory reading history file ${MATTERBRIDGE_HISTORY_FILE}: ${getErrorMessage(error)}`);
+                res.status(500).send('Error reading history file.');
+            }
+        });
+        this.expressApp.get('/api/download-backup', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-backup');
+            if (!this.validateReq(req, res))
+                return;
+            res.download(path.join(os.tmpdir(), MATTERBRIDGE_BACKUP_FILE), MATTERBRIDGE_BACKUP_FILE, (error) => {
+                this.backend.wssSendCloseSnackbarMessage('Creating matterbridge backup...');
+                if (error) {
+                    this.log.error(`Error downloading file ${MATTERBRIDGE_BACKUP_FILE}: ${getErrorMessage(error)}`);
+                    res.status(500).send(`Error downloading the matterbridge backup file.`);
+                }
+                else {
+                    this.log.debug(`Backup ${MATTERBRIDGE_BACKUP_FILE} downloaded successfully`);
+                }
+            });
+        });
+        this.expressApp.get('/api/download-mbstorage', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-mbstorage');
+            if (!this.validateReq(req, res))
+                return;
+            res.download(path.join(os.tmpdir(), `matterbridge.${NODE_STORAGE_DIR}.zip`), `matterbridge.${NODE_STORAGE_DIR}.zip`, (error) => {
+                this.backend.wssSendCloseSnackbarMessage('Creating matterbridge storage backup...');
+                if (error) {
+                    this.log.error(`Error downloading file ${`matterbridge.${NODE_STORAGE_DIR}.zip`}: ${getErrorMessage(error)}`);
+                    res.status(500).send('Error downloading the matterbridge storage file');
+                }
+                else {
+                    this.log.debug(`Matterbridge storage matterbridge.${NODE_STORAGE_DIR}.zip downloaded successfully`);
+                }
+            });
+        });
+        this.expressApp.get('/api/download-mjstorage', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-mjstorage');
+            if (!this.validateReq(req, res))
+                return;
+            res.download(path.join(os.tmpdir(), `matterbridge.${MATTER_STORAGE_DIR}.zip`), `matterbridge.${MATTER_STORAGE_DIR}.zip`, (error) => {
+                this.backend.wssSendCloseSnackbarMessage('Creating matter storage backup...');
+                if (error) {
+                    this.log.error(`Error downloading the matter storage matterbridge.${MATTER_STORAGE_DIR}.zip: ${getErrorMessage(error)}`);
+                    res.status(500).send('Error downloading the matter storage file');
+                }
+                else {
+                    this.log.debug(`Matter storage matterbridge.${MATTER_STORAGE_DIR}.zip downloaded successfully`);
+                }
+            });
+        });
+        this.expressApp.get('/api/download-pluginstorage', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-pluginstorage');
+            if (!this.validateReq(req, res))
+                return;
+            res.download(path.join(os.tmpdir(), MATTERBRIDGE_PLUGIN_STORAGE_FILE), MATTERBRIDGE_PLUGIN_STORAGE_FILE, (error) => {
+                this.backend.wssSendCloseSnackbarMessage('Creating plugin backup...');
+                if (error) {
+                    this.log.error(`Error downloading file ${MATTERBRIDGE_PLUGIN_STORAGE_FILE}: ${getErrorMessage(error)}`);
+                    res.status(500).send('Error downloading the matterbridge plugin storage file');
+                }
+                else {
+                    this.log.debug(`Plugin storage ${MATTERBRIDGE_PLUGIN_STORAGE_FILE} downloaded successfully`);
+                }
+            });
+        });
+        this.expressApp.get('/api/download-pluginconfig', async (req, res) => {
+            this.log.debug('The frontend sent /api/download-pluginconfig');
+            if (!this.validateReq(req, res))
+                return;
+            res.download(path.join(os.tmpdir(), MATTERBRIDGE_PLUGIN_CONFIG_FILE), MATTERBRIDGE_PLUGIN_CONFIG_FILE, (error) => {
+                this.backend.wssSendCloseSnackbarMessage('Creating config backup...');
+                if (error) {
+                    this.log.error(`Error downloading file ${MATTERBRIDGE_PLUGIN_CONFIG_FILE}: ${getErrorMessage(error)}`);
+                    res.status(500).send('Error downloading the matterbridge plugin config file');
+                }
+                else {
+                    this.log.debug(`Plugin config ${MATTERBRIDGE_PLUGIN_CONFIG_FILE} downloaded successfully`);
+                }
+            });
+        });
+        this.expressApp.post('/api/uploadpackage', upload.single('file'), async (req, res) => {
+            this.log.debug('The frontend sent /api/uploadpackage');
+            if (!this.validateReq(req, res))
+                return;
+            const { filename } = req.body;
+            const file = req.file;
+            if (!file || !filename) {
+                this.log.error(`uploadpackage: invalid request: file and filename are required`);
+                res.status(400).send('Invalid request: file and filename are required');
+                return;
+            }
+            this.backend.wssSendSnackbarMessage(`Installing package ${filename}...`, 0);
+            const filePath = path.join(this.matterbridge.matterbridgeDirectory, 'uploads', filename);
+            try {
+                const fs = await import('node:fs');
+                await fs.promises.rename(file.path, filePath);
+                this.log.info(`File ${plg}${filename}${nf} uploaded successfully`);
+                if (filename.endsWith('.tgz')) {
+                    this.server.request({
+                        type: 'manager_run',
+                        src: 'frontend',
+                        dst: 'manager',
+                        params: {
+                            name: 'SpawnCommand',
+                            workerData: {
+                                threadName: 'SpawnCommand',
+                                command: 'npm',
+                                args: ['install', '-g', filePath, '--omit=dev', '--verbose'],
+                                packageCommand: 'install',
+                                packageName: filename,
+                            },
+                        },
+                    });
+                }
+                res.send(`File ${filename} uploaded successfully`);
+            }
+            catch (err) {
+                this.log.error(`Error uploading or installing plugin package file ${plg}${filename}${er}:`, err);
+                this.backend.wssSendCloseSnackbarMessage(`Installing package ${filename}...`);
+                this.backend.wssSendSnackbarMessage(`Error uploading or installing plugin package ${filename}`, 10, 'error');
+                res.status(500).send(`Error uploading or installing plugin package ${filename}`);
+            }
+        });
+        this.expressApp.use((req, res) => {
+            const filePath = path.resolve(this.matterbridge.rootDirectory, 'apps', 'frontend', 'build');
+            this.log.debug(`The frontend sent ${req.url} method ${req.method}: sending index.html in ${filePath} as fallback`);
+            res.sendFile('index.html', { root: filePath });
+        });
+        this.log.debug('Express application started');
+        return this.expressApp;
+    }
+    async stop() {
+        if (this.expressApp) {
+            this.log.debug('Stopping express application...');
+            this.expressApp.removeAllListeners();
+            this.expressApp = undefined;
+            this.log.debug('Frontend app closed successfully');
+            this.log.debug('Express application stopped');
+        }
+        else {
+            this.log.debug('Express application is not running');
+        }
+        return this.expressApp;
+    }
+}

package/dist/backendWsServer.d.ts

@@ -0,0 +1,35 @@
+import type { EndpointNumber } from '@matter/types/datatype';
+import type { ApiMatter, RefreshRequiredChanged, SharedMatterbridge, WsMessageBroadcast } from '@matterbridge/types';
+import { WebSocketServer } from 'ws';
+import type { Frontend } from './frontend.js';
+export declare class BackendsWsServer {
+    private debug;
+    private verbose;
+    private webSocketServer;
+    private log;
+    private backend;
+    private matterbridge;
+    private readonly server;
+    constructor(matterbridge: SharedMatterbridge, backend: Frontend);
+    destroy(): void;
+    private broadcastMsgHandler;
+    start(): Promise<WebSocketServer | undefined>;
+    stop(): Promise<WebSocketServer | undefined>;
+    hasActiveClients(): boolean;
+    private wsMessageHandler;
+    wssBroadcastMessage(msg: WsMessageBroadcast): void;
+    wssSendLogMessage(level: string, time: string, name: string, message: string): void;
+    wssSendRefreshRequired(changed: RefreshRequiredChanged, params?: {
+        matter?: ApiMatter;
+        lock?: string;
+    }): void;
+    wssSendRestartRequired(snackbar?: boolean, fixed?: boolean): void;
+    wssSendRestartNotRequired(snackbar?: boolean): void;
+    wssSendUpdateRequired(devVersion?: boolean): 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;
+    wssSendSnackbarMessage(message: string, timeout?: number, severity?: 'info' | 'warning' | 'error' | 'success'): void;
+    wssSendCloseSnackbarMessage(message: string): void;
+    wssSendAttributeChangedMessage(plugin: string, serialNumber: string, uniqueId: string, number: EndpointNumber, id: string, cluster: string, attribute: string, value: number | string | boolean | null): void;
+}