@matterbridge/thread 3.10.13-dev-20261007-320f739 → 3.10.13-dev-20261009-7fc645a

package/dist/backendWsServer.js

@@ -1,393 +0,0 @@
-import { Logger, LogLevel as MatterLogLevel } from '@matter/general';
-import { hasAnyParameter } from '@matterbridge/utils/cli';
-import { writeDiagnostic } from '@matterbridge/utils/diagnostic';
-import { inspectError } from '@matterbridge/utils/error';
-import { logModuleLoaded } from '@matterbridge/utils/loader';
-import { isValidNumber, isValidString } from '@matterbridge/utils/validate';
-import { fireAndForget, withTimeout } from '@matterbridge/utils/wait';
-import { AnsiLogger, CYAN, debugStringify, nf } from 'node-ansi-logger';
-import { WebSocket, WebSocketServer } from 'ws';
-import { BroadcastServer } from './broadcastServer.js';
-logModuleLoaded('BackendWsServer');
-export class BackendWsServer {
-    debug;
-    verbose;
-    diagnostic;
-    log;
-    backend;
-    matterbridge;
-    server;
-    webSocketServer;
-    constructor(matterbridge, backend) {
-        this.debug = hasAnyParameter('debug', 'verbose', 'debug-backend', 'verbose-backend');
-        this.verbose = hasAnyParameter('verbose', 'verbose-backend');
-        this.diagnostic = hasAnyParameter('diagnostic', 'diagnostic-backend');
-        this.backend = backend;
-        this.matterbridge = matterbridge;
-        this.log = new AnsiLogger({
-            logName: 'BackendWsServer',
-            logNameColor: '\x1b[38;5;97m',
-            logTimestampFormat: 4,
-            logLevel: this.debug ? "debug" : "info",
-        });
-        this.server = new BroadcastServer('frontend', this.log);
-        this.server.on('broadcast_message', (msg) => fireAndForget(this.broadcastMsgHandler(msg), this.log, 'Broadcast message handler'));
-    }
-    destroy() {
-        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;
-            }
-        }
-    }
-    async start() {
-        this.log.debug(`Creating WebSocketServer...`);
-        this.webSocketServer = new WebSocketServer({ noServer: true });
-        this.backend.emit('websocket_server_listening', this.backend.secure ? 'wss' : 'ws');
-        this.webSocketServer.on('connection', (websocket, request) => {
-            const clientIp = request.socket.remoteAddress;
-            this.log.info(`WebSocketServer client ${CYAN}${clientIp}${nf} connected to Matterbridge`);
-            let callbackLogLevel = "notice";
-            if (this.log.logLevel === "info" || Logger.level === MatterLogLevel.INFO)
-                callbackLogLevel = "info";
-            if (this.log.logLevel === "debug" || Logger.level === MatterLogLevel.DEBUG)
-                callbackLogLevel = "debug";
-            AnsiLogger.setGlobalCallback(this.wssSendLogMessage.bind(this), callbackLogLevel);
-            this.log.debug(`WebSocketServer logger global callback set to ${callbackLogLevel}`);
-            websocket.on('message', (data) => {
-                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} sent a message`);
-                fireAndForget(this.wsMessageHandler(websocket, data), this.log, `Error handling message from WebSocket client ${clientIp}`);
-            });
-            websocket.on('ping', () => {
-                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} ping received`);
-                websocket.pong();
-            });
-            websocket.on('pong', () => {
-                this.log.debug(`WebSocket client ${CYAN}${clientIp}${nf} pong received`);
-            });
-            websocket.on('close', (code, reason) => {
-                this.log.info(`WebSocket client ${CYAN}${clientIp}${nf} disconnected code ${code} reason ${reason.toString()}`);
-                if (this.webSocketServer?.clients.size === 0) {
-                    AnsiLogger.setGlobalCallback(undefined);
-                    this.log.debug('All WebSocket clients disconnected. WebSocketServer logger global callback removed');
-                    setTimeout(() => {
-                        if (this.webSocketServer?.clients.size === 0) {
-                            this.log.debug('All WebSocket clients disconnected. Auth clients list cleared');
-                            this.backend.authClients.clear();
-                        }
-                    }, 1000).unref();
-                }
-                else {
-                    this.log.debug(`WebSocketServer still has ${this.webSocketServer?.clients.size} connected clients`);
-                }
-            });
-            websocket.on('error', (error) => {
-                inspectError(this.log, `WebSocket client error`, error);
-            });
-        });
-        this.webSocketServer.on('close', () => {
-            this.log.debug(`WebSocketServer closed`);
-        });
-        this.webSocketServer.on('error', (ws, error) => {
-            inspectError(this.log, `WebSocketServer error`, error);
-        });
-        return this.webSocketServer;
-    }
-    async stop() {
-        if (this.webSocketServer) {
-            this.log.debug('Closing WebSocket server...');
-            this.webSocketServer.clients.forEach((client) => {
-                if (client.readyState === WebSocket.OPEN) {
-                    client.close();
-                }
-            });
-            await withTimeout(new Promise((resolve) => {
-                this.webSocketServer?.close((error) => {
-                    if (error) {
-                        inspectError(this.log, `Error closing WebSocket server`, error);
-                    }
-                    else {
-                        this.log.debug('WebSocket server closed successfully');
-                        this.backend.emit('websocket_server_stopped');
-                    }
-                    resolve();
-                });
-            }), 10000, false);
-            this.webSocketServer.removeAllListeners();
-            this.webSocketServer = undefined;
-        }
-        else {
-            this.log.debug('WebSocket server is not running');
-        }
-        return this.webSocketServer;
-    }
-    hasActiveClients() {
-        return this.webSocketServer !== undefined && this.webSocketServer.clients.size > 0;
-    }
-    async wsMessageHandler(client, rawData) {
-        let data;
-        const sendResponse = (data) => {
-            if (client.readyState === client.OPEN) {
-                if ('response' in data) {
-                    const { response, ...rest } = data;
-                    this.log.debug(`Sending api response message: ${debugStringify(rest)}`);
-                }
-                else {
-                    this.log.debug(`Sending api error message: ${debugStringify(data)}`);
-                }
-                const bigintReplacer = (_, v) => (typeof v === 'bigint' ? `${v}n` : v);
-                client.send(JSON.stringify(data, bigintReplacer));
-            }
-            else {
-                this.log.error('Cannot send api response, client not connected');
-            }
-        };
-        try {
-            const raw = Array.isArray(rawData) ? Buffer.concat(rawData) : rawData instanceof ArrayBuffer ? Buffer.from(rawData) : rawData;
-            data = JSON.parse(raw.toString());
-            if (!isValidNumber(data.id) || !isValidString(data.dst) || !isValidString(data.src) || !isValidString(data.method) || data.dst !== 'Matterbridge') {
-                this.log.error(`Invalid message from websocket client: ${debugStringify(data)}`);
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Invalid message' });
-                return;
-            }
-            this.log.debug(`Received message from websocket client: ${debugStringify(data)}`);
-            if (data.method === 'ping') {
-                sendResponse({ id: data.id, method: 'pong', src: 'Matterbridge', dst: data.src, success: true, response: 'pong' });
-            }
-            else if (data.method === '/api/restart') {
-                this.wssSendSnackbarMessage('Restarting matterbridge...', 0);
-                await this.server.fetch({ type: 'matterbridge_restart', src: 'frontend', dst: 'matterbridge', params: undefined });
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
-            }
-            else if (data.method === '/api/shutdown') {
-                this.wssSendSnackbarMessage('Shutting down matterbridge...', 0);
-                await this.server.fetch({ type: 'matterbridge_shutdown', src: 'frontend', dst: 'matterbridge', params: undefined });
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true });
-            }
-            else if (data.method === '/api/settings') {
-                const start = performance.now();
-                const settings = await this.backend.getApiSettings();
-                if (this.diagnostic)
-                    writeDiagnostic(`Frontend:${data.sender}`, `getApiSettings() took ${(performance.now() - start).toFixed(2)} ms`);
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: settings });
-            }
-            else if (data.method === '/api/plugins') {
-                const start = performance.now();
-                const plugins = await this.backend.getApiPlugins();
-                if (this.diagnostic)
-                    writeDiagnostic(`Frontend:${data.sender}`, `getApiPlugins() took ${(performance.now() - start).toFixed(2)} ms`);
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: plugins });
-            }
-            else if (data.method === '/api/devices') {
-                const start = performance.now();
-                const devices = await this.backend.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
-                if (this.diagnostic)
-                    writeDiagnostic(`Frontend:${data.sender}`, `getApiDevices() took ${(performance.now() - start).toFixed(2)} ms`);
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: devices });
-            }
-            else if (data.method === '/api/clusters') {
-                if (!isValidString(data.params.plugin, 10)) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter plugin in /api/clusters' });
-                    return;
-                }
-                if (!isValidNumber(data.params.endpoint, 1)) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' });
-                    return;
-                }
-                const start = performance.now();
-                const clusters = await this.backend.getApiCluster(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
-                if (this.diagnostic)
-                    writeDiagnostic(`Frontend:${data.sender}`, `getApiCluster() took ${(performance.now() - start).toFixed(2)} ms`);
-                if (clusters) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: clusters });
-                }
-                else {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Endpoint not found in /api/clusters' });
-                }
-            }
-            else if (data.method === '/api/matter') {
-                if (!isValidString(data.params.id)) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter id in /api/matter' });
-                    return;
-                }
-                const matter = await this.backend.getApiMatter(data.params.id);
-                if (!matter) {
-                    sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: `Unknown server node id ${data.params.id} in /api/matter` });
-                    return;
-                }
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: matter });
-                this.wssSendRefreshRequired('matter', { matter });
-            }
-        }
-        catch (error) {
-            inspectError(this.log, `Error parsing message from websocket client`, error);
-            return;
-        }
-    }
-    wssBroadcastMessage(msg) {
-        if (!this.hasActiveClients())
-            return;
-        try {
-            const stringifiedMsg = JSON.stringify(msg);
-            this.webSocketServer?.clients.forEach((client) => {
-                if (client.readyState === client.OPEN) {
-                    client.send(stringifiedMsg);
-                }
-            });
-        }
-        catch (error) {
-            inspectError(this.log, `Error broadcasting message to websocket clients`, error);
-        }
-    }
-    wssSendLogMessage(level, time, name, message) {
-        if (!this.hasActiveClients())
-            return;
-        if (!level || !time || !name || !message)
-            return;
-        message = message.replace(/\x1B\[[0-9;]*[m|s|u|K]/g, '');
-        message = message.replace(/^\*+/, '');
-        message = message.replace(/[\t\n]/g, '');
-        message = message.replace(/[\x00-\x1F\x7F]/g, '');
-        message = message.replace(/\\"/g, '"');
-        const maxContinuousLength = 100;
-        const keepStartLength = 20;
-        const keepEndLength = 20;
-        if (level !== 'spawn') {
-            message = message
-                .split(' ')
-                .map((word) => {
-                if (word.length > maxContinuousLength) {
-                    return word.slice(0, keepStartLength) + ' ... ' + word.slice(-keepEndLength);
-                }
-                return word;
-            })
-                .join(' ');
-        }
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'log', success: true, response: { level, time, name, message } });
-    }
-    wssSendRefreshRequired(changed, params) {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending a refresh required message to all connected clients');
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'refresh_required', success: true, response: { changed, lock: params?.lock, ...params } });
-    }
-    wssSendRestartRequired(snackbar = true, fixed = false) {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending a restart required message to all connected clients');
-        if (snackbar)
-            this.wssSendSnackbarMessage(`Restart required`, 0);
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_required', success: true, response: { fixed } });
-    }
-    wssSendRestartNotRequired(snackbar = true) {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending a restart not required message to all connected clients');
-        if (snackbar)
-            this.wssSendCloseSnackbarMessage(`Restart required`);
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
-    }
-    wssSendUpdateRequired(version, devVersion = false) {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            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())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending a cpu update message to all connected clients');
-        this.wssBroadcastMessage({
-            id: 0,
-            src: 'Matterbridge',
-            dst: 'Frontend',
-            method: 'cpu_update',
-            success: true,
-            response: { cpuUsage: Math.round(cpuUsage * 100) / 100, processCpuUsage: Math.round(processCpuUsage * 100) / 100 },
-        });
-    }
-    wssSendMemoryUpdate(totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers) {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending a memory update message to all connected clients');
-        this.wssBroadcastMessage({
-            id: 0,
-            src: 'Matterbridge',
-            dst: 'Frontend',
-            method: 'memory_update',
-            success: true,
-            response: { totalMemory, freeMemory, rss, heapTotal, heapUsed, external, arrayBuffers },
-        });
-    }
-    wssSendUptimeUpdate(systemUptime, processUptime) {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending a uptime update message to all connected clients');
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'uptime_update', success: true, response: { systemUptime, processUptime } });
-    }
-    wssSendSnackbarMessage(message, timeout = 5, severity = 'info') {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending a snackbar message to all connected clients');
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'snackbar', success: true, response: { message, timeout, severity } });
-    }
-    wssSendCloseSnackbarMessage(message) {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending a close snackbar message to all connected clients');
-        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'close_snackbar', success: true, response: { message } });
-    }
-    wssSendAttributeChangedMessage(plugin, serialNumber, uniqueId, number, id, cluster, attribute, value) {
-        if (!this.hasActiveClients())
-            return;
-        if (this.verbose)
-            this.log.debug('Sending an attribute update message to all connected clients');
-        this.wssBroadcastMessage({
-            id: 0,
-            src: 'Matterbridge',
-            dst: 'Frontend',
-            method: 'state_update',
-            success: true,
-            response: { plugin, serialNumber, uniqueId, number, id, cluster, attribute, value },
-        });
-    }
-}

package/dist/threadBackend.d.ts

@@ -1,3 +0,0 @@
-import { WorkerWrapper } from './workerWrapper.js';
-declare const _default: WorkerWrapper;
-export default _default;

package/dist/threadBackend.js

@@ -1,24 +0,0 @@
-import { inspectError } from '@matterbridge/utils/error';
-import { logModuleLoaded } from '@matterbridge/utils/loader';
-import { WorkerWrapper } from './workerWrapper.js';
-logModuleLoaded('Backend', '\u001B[35m');
-export default new WorkerWrapper('Backend', async (worker) => {
-    worker.logger("info", 'Creating backend...');
-    try {
-        worker.logger("debug", 'Fetching shared Matterbridge state...');
-        const shared = (await worker.server.fetch({ type: 'matterbridge_shared', src: 'matterbridge', dst: 'matterbridge' }, 1000)).result.data;
-        worker.logger("debug", 'Shared Matterbridge state fetched; importing Backend...');
-        const { Backend } = await import('./backend.js');
-        worker.logger("debug", 'Backend imported; creating instance...');
-        const backend = new Backend(shared);
-        worker.logger("debug", 'Starting Backend...');
-        await backend.start();
-        worker.logger("debug", 'Backend started');
-        return true;
-    }
-    catch (error) {
-        const errorMessage = inspectError(worker.log, 'Failed to create backend', error);
-        worker.logger("error", errorMessage);
-        return false;
-    }
-});