@matterbridge/core 3.7.2-dev-20260330-bb55c39 → 3.7.2-dev-20260402-c12a10e

package/dist/backendWsServer.js

@@ -0,0 +1,307 @@
+import { Logger, LogLevel as MatterLogLevel } from '@matter/general';
+import { BroadcastServer } from '@matterbridge/thread';
+import { hasParameter } from '@matterbridge/utils/cli';
+import { inspectError } from '@matterbridge/utils/error';
+import { isValidNumber, isValidString } from '@matterbridge/utils/validate';
+import { withTimeout } from '@matterbridge/utils/wait';
+import { AnsiLogger, CYAN, debugStringify, nf } from 'node-ansi-logger';
+import WebSocket, { WebSocketServer } from 'ws';
+if (hasParameter('loader'))
+    console.log('\u001B[32mBackendWsServer loaded.\u001B[40;0m');
+export class BackendsWsServer {
+    debug;
+    verbose;
+    webSocketServer;
+    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: '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', 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;
+            }
+        }
+    }
+    async start() {
+        this.log.debug(`Creating WebSocketServer...`);
+        this.webSocketServer = new WebSocketServer({ noServer: true });
+        this.backend.emit('websocket_server_listening', hasParameter('ssl') ? '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`);
+                this.wsMessageHandler(websocket, data);
+            });
+            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 if ('error' in data) {
+                    this.log.debug(`Sending api error message: ${debugStringify(data)}`);
+                }
+                client.send(JSON.stringify(data));
+            }
+            else {
+                this.log.error('Cannot send api response, client not connected');
+            }
+        };
+        try {
+            data = JSON.parse(rawData.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)}`);
+        }
+        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);
+            if (this.verbose)
+                this.log.debug(`Sending a broadcast message: ${debugStringify(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');
+        this.backend.restartRequired = true;
+        this.backend.fixedRestartRequired = fixed;
+        if (snackbar === true)
+            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');
+        this.backend.restartRequired = false;
+        if (snackbar === true)
+            this.wssSendCloseSnackbarMessage(`Restart required`);
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'restart_not_required', success: true });
+    }
+    wssSendUpdateRequired(devVersion = false) {
+        if (!this.hasActiveClients())
+            return;
+        if (this.verbose)
+            this.log.debug('Sending an update required message to all connected clients');
+        this.backend.updateRequired = true;
+        this.wssBroadcastMessage({ id: 0, src: 'Matterbridge', dst: 'Frontend', method: 'update_required', success: true, response: { devVersion } });
+    }
+    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/behaviors/doorLockServer.d.ts

@@ -1,6 +1,7 @@
 import { DoorLockServer } from '@matter/node/behaviors/door-lock';
 import { DoorLock } from '@matter/types/clusters/door-lock';
-declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<DoorLock.Cluster, import("@matter/types").ClusterTypeModifier.ElementFlagAlterations<{
+import { FabricIndex } from '@matter/types/datatype';
+declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterTypeModifier.WithAlterations<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.User, DoorLock.Feature.PinCredential]>, import("@matter/types").ClusterTypeModifier.ElementFlagAlterations<{
     readonly events: {
         readonly doorLockAlarm: true;
         readonly lockOperation: true;
@@ -11,18 +12,51 @@ declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBeh
         readonly unlockDoor: true;
         readonly unlockWithTimeout: true;
     };
-}>>, typeof DoorLockServer, import("@matter/node/behaviors/door-lock").DoorLockInterface>;
+}>>, import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.User, DoorLock.Feature.PinCredential]>, typeof DoorLockServer, import("@matter/node/behaviors/door-lock").DoorLockInterface>, import("@matter/node/behaviors/door-lock").DoorLockInterface>;
 export declare class MatterbridgeDoorLockServer extends MatterbridgeDoorLockServer_base {
     protected internal: MatterbridgeDoorLockServer.Internal;
     initialize(): Promise<void>;
     lockDoor(request: DoorLock.LockDoorRequest): Promise<void>;
     unlockDoor(request: DoorLock.UnlockDoorRequest): Promise<void>;
     unlockWithTimeout(request: DoorLock.UnlockWithTimeoutRequest): Promise<void>;
+    setUser(request: DoorLock.SetUserRequest): Promise<void>;
+    getUser(request: DoorLock.GetUserRequest): Promise<DoorLock.GetUserResponse>;
+    clearUser(request: DoorLock.ClearUserRequest): Promise<void>;
+    setCredential(request: DoorLock.SetCredentialRequest): Promise<DoorLock.SetCredentialResponse>;
+    getCredentialStatus(request: DoorLock.GetCredentialStatusRequest): Promise<DoorLock.GetCredentialStatusResponse>;
+    clearCredential(request: DoorLock.ClearCredentialRequest): Promise<void>;
+    private validateUserIndex;
+    private getNextUserIndex;
+    private getAccessingFabricIndex;
+    private getAccessingNodeId;
+    private getOperationSource;
+    private getLockDataTypeForCredentialType;
+    private getCredentialDataIndex;
+    private getStoredCredentialTypes;
+    private findStoredCredential;
+    private getNextOccupiedCredentialIndex;
 }
 export declare namespace MatterbridgeDoorLockServer {
+    type StoredCredential = DoorLock.Credential & {
+        creatorFabricIndex: FabricIndex | null;
+        lastModifiedFabricIndex: FabricIndex | null;
+        credentialData: Uint8Array;
+    };
+    type StoredUser = {
+        userIndex: number;
+        userName: string | null;
+        userUniqueId: number | null;
+        userStatus: DoorLock.UserStatus | null;
+        userType: DoorLock.UserType | null;
+        credentialRule: DoorLock.CredentialRule | null;
+        credentials: StoredCredential[] | null;
+        creatorFabricIndex: FabricIndex | null;
+        lastModifiedFabricIndex: FabricIndex | null;
+    };
     class Internal {
         enableTimeout: boolean;
         unlockTimeout: NodeJS.Timeout | undefined;
+        users: StoredUser[];
     }
 }
 export {};