@matterbridge/core 3.7.2-dev-20260330-bb55c39 → 3.7.2-dev-20260331-ac050d8

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 {};

package/dist/behaviors/doorLockServer.js

@@ -1,7 +1,13 @@
 import { DoorLockServer } from '@matter/node/behaviors/door-lock';
+import { hasRemoteActor } from '@matter/protocol';
 import { DoorLock } from '@matter/types/clusters/door-lock';
+import { StatusResponse } from '@matter/types/common';
+import { FabricIndex } from '@matter/types/datatype';
+import { Status } from '@matter/types/globals';
+import { getEnumDescription } from '@matterbridge/utils/enum';
+import { debugStringify } from 'node-ansi-logger';
 import { MatterbridgeServer } from './matterbridgeServer.js';
-export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
+export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Feature.User, DoorLock.Feature.PinCredential).enable({
     events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
     commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
 }) {
@@ -43,7 +49,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called`);
+        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called ${this.state.autoRelockTime ? 'with ' + this.state.autoRelockTime + ' seconds' : 'without'} autoRelockTime ${this.internal.enableTimeout ? 'with' : 'without'} enableTimeout`);
         await super.unlockDoor(request);
         if (!this.internal.enableTimeout)
             return;
@@ -52,9 +58,9 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
             this.internal.unlockTimeout = setTimeout(async () => {
                 this.internal.unlockTimeout = undefined;
                 const device = this.endpoint.stateOf(MatterbridgeServer);
-                const state = this.endpoint.stateOf(MatterbridgeDoorLockServer);
+                const state = this.endpoint.stateOf(MatterbridgeDoorLockServer.with());
                 device.log.info(`Auto-relocking door after ${state.autoRelockTime} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer).lockDoor({ pinCode: request.pinCode }));
+                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer.with()).lockDoor({ pinCode: request.pinCode }));
             }, this.state.autoRelockTime * 1000).unref();
         }
     }
@@ -73,7 +79,7 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called`);
+        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called ${this.internal.enableTimeout ? 'with' : 'without'} enableTimeout`);
         this.state.lockState = DoorLock.LockState.Unlocked;
         if (!this.internal.enableTimeout)
             return;
@@ -83,15 +89,355 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.enable({
                 this.internal.unlockTimeout = undefined;
                 const device = this.endpoint.stateOf(MatterbridgeServer);
                 device.log.info(`Locking door after ${request.timeout} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer).lockDoor({ pinCode: request.pinCode }));
+                await this.endpoint.act((agent) => agent.get(MatterbridgeDoorLockServer.with()).lockDoor({ pinCode: request.pinCode }));
             }, request.timeout * 1000).unref();
         }
     }
+    async setUser(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const accessingFabricIndex = this.getAccessingFabricIndex();
+        device.log.info(`Setting user operationType ${getEnumDescription(DoorLock.DataOperationType, request.operationType)} userIndex ${request.userIndex} userName ${request.userName ?? 'null'} userUniqueId ${request.userUniqueId ?? 'null'} userStatus ${getEnumDescription(DoorLock.UserStatus, request.userStatus, { fallback: 'null' })} userType ${getEnumDescription(DoorLock.UserType, request.userType, { fallback: 'null' })} credentialRule ${getEnumDescription(DoorLock.CredentialRule, request.credentialRule, { fallback: 'null' })} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.debug(`MatterbridgeDoorLockServer: setUser accessingFabricIndex ${accessingFabricIndex ?? 'null'}`);
+        await device.commandHandler.executeHandler('DoorLock.setUser', {
+            command: 'setUser',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        const user = this.internal.users.find((storedUser) => storedUser.userIndex === request.userIndex);
+        device.log.debug(`MatterbridgeDoorLockServer: setUser called for userIndex ${request.userIndex} (${user ? 'existing user ' + debugStringify(user) : 'new user'})`);
+        if (!user && request.operationType === DoorLock.DataOperationType.Add) {
+            this.internal.users.push({
+                userIndex: request.userIndex,
+                userName: request.userName ?? '',
+                userUniqueId: request.userUniqueId ?? 0xffffffff,
+                userStatus: request.userStatus ?? DoorLock.UserStatus.OccupiedEnabled,
+                userType: request.userType ?? DoorLock.UserType.UnrestrictedUser,
+                credentialRule: request.credentialRule ?? DoorLock.CredentialRule.Single,
+                credentials: [],
+                creatorFabricIndex: accessingFabricIndex,
+                lastModifiedFabricIndex: accessingFabricIndex,
+            });
+            this.events.lockUserChange.emit({
+                lockDataType: DoorLock.LockDataType.UserIndex,
+                dataOperationType: DoorLock.DataOperationType.Add,
+                operationSource: this.getOperationSource(),
+                userIndex: request.userIndex,
+                fabricIndex: accessingFabricIndex,
+                sourceNode: this.getAccessingNodeId(),
+                dataIndex: request.userIndex,
+            }, this.context);
+            device.log.debug(`MatterbridgeDoorLockServer: added userIndex ${request.userIndex} (total users: ${this.internal.users.length}) to internal state: ${debugStringify(this.internal.users.find((storedUser) => storedUser.userIndex === request.userIndex))}`);
+        }
+        else if (user && request.operationType === DoorLock.DataOperationType.Modify) {
+            user.userName = request.userName ?? user.userName;
+            user.userUniqueId = request.userUniqueId ?? user.userUniqueId;
+            user.userStatus = request.userStatus ?? user.userStatus;
+            user.userType = request.userType ?? user.userType;
+            user.credentialRule = request.credentialRule ?? user.credentialRule;
+            user.lastModifiedFabricIndex = accessingFabricIndex;
+            this.events.lockUserChange.emit({
+                lockDataType: DoorLock.LockDataType.UserIndex,
+                dataOperationType: DoorLock.DataOperationType.Modify,
+                operationSource: this.getOperationSource(),
+                userIndex: request.userIndex,
+                fabricIndex: accessingFabricIndex,
+                sourceNode: this.getAccessingNodeId(),
+                dataIndex: request.userIndex,
+            }, this.context);
+            device.log.debug(`MatterbridgeDoorLockServer: modified userIndex ${request.userIndex} (total users: ${this.internal.users.length}) in internal state: ${debugStringify(user)}`);
+        }
+    }
+    async getUser(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Getting userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        const response = await device.commandHandler.executeHandler('DoorLock.getUser', {
+            command: 'getUser',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        if (response !== undefined) {
+            return response;
+        }
+        device.log.debug(`MatterbridgeDoorLockServer: getUser called for userIndex ${request.userIndex}`);
+        if (!this.validateUserIndex(request.userIndex))
+            throw new StatusResponse.InvalidCommandError('Invalid userIndex in GetUser request');
+        const user = this.internal.users.find((storedUser) => storedUser.userIndex === request.userIndex);
+        if (!user) {
+            return {
+                userIndex: request.userIndex,
+                userName: null,
+                userUniqueId: null,
+                userStatus: null,
+                userType: null,
+                credentialRule: null,
+                credentials: null,
+                creatorFabricIndex: null,
+                lastModifiedFabricIndex: null,
+                nextUserIndex: null,
+            };
+        }
+        return {
+            ...user,
+            credentials: user.credentials?.map(({ credentialType, credentialIndex }) => ({ credentialType, credentialIndex })) ?? null,
+            nextUserIndex: this.getNextUserIndex(request.userIndex),
+        };
+    }
+    async clearUser(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const accessingFabricIndex = this.getAccessingFabricIndex();
+        device.log.info(`Clearing userIndex ${request.userIndex} ${request.userIndex === 0xfffe ? '(all users)' : ''} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.clearUser', {
+            command: 'clearUser',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: clearUser called for userIndex ${request.userIndex}`);
+        if (request.userIndex != 0xfffe && !this.validateUserIndex(request.userIndex))
+            throw new StatusResponse.InvalidCommandError('Invalid userIndex in ClearUser request');
+        if (request.userIndex === 0xfffe) {
+            this.internal.users = [];
+        }
+        else {
+            this.internal.users = this.internal.users.filter((storedUser) => storedUser.userIndex !== request.userIndex);
+        }
+        this.events.lockUserChange.emit({
+            lockDataType: DoorLock.LockDataType.UserIndex,
+            dataOperationType: DoorLock.DataOperationType.Clear,
+            operationSource: this.getOperationSource(),
+            userIndex: request.userIndex,
+            fabricIndex: accessingFabricIndex,
+            sourceNode: this.getAccessingNodeId(),
+            dataIndex: request.userIndex,
+        }, this.context);
+    }
+    async setCredential(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const accessingFabricIndex = this.getAccessingFabricIndex();
+        device.log.info(`Setting credential operationType ${getEnumDescription(DoorLock.DataOperationType, request.operationType)} credentialType ${getEnumDescription(DoorLock.CredentialType, request.credential.credentialType)} credentialIndex ${request.credential.credentialIndex} credentialData ${Buffer.from(request.credentialData).toString('hex') ? '0x' + Buffer.from(request.credentialData).toString('hex') : '0x'} userIndex ${request.userIndex ?? 'null'} userStatus ${getEnumDescription(DoorLock.UserStatus, request.userStatus, { fallback: 'null' })} userType ${getEnumDescription(DoorLock.UserType, request.userType, { fallback: 'null' })} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.setCredential', {
+            command: 'setCredential',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        const user = this.internal.users.find((storedUser) => storedUser.userIndex === request.userIndex);
+        const existingCredential = this.findStoredCredential(request.credential);
+        device.log.debug(`MatterbridgeDoorLockServer: setCredential pre-update lookup for credentialIndex ${request.credential.credentialIndex} (${existingCredential ? 'existing credential found' : 'no existing credential'})`);
+        if (user && (request.operationType === DoorLock.DataOperationType.Add || request.operationType === DoorLock.DataOperationType.Modify)) {
+            const credential = user.credentials?.find((storedCredential) => storedCredential.credentialType === request.credential.credentialType && storedCredential.credentialIndex === request.credential.credentialIndex);
+            if (credential) {
+                credential.credentialData = request.credentialData;
+                credential.creatorFabricIndex = credential.creatorFabricIndex ?? accessingFabricIndex;
+                credential.lastModifiedFabricIndex = accessingFabricIndex;
+                device.log.debug(`MatterbridgeDoorLockServer: modified credentialIndex ${request.credential.credentialIndex} for userIndex ${request.userIndex} in internal state: ${debugStringify(user)}`);
+            }
+            else {
+                user.credentials = user.credentials ?? [];
+                user.credentials.push({
+                    credentialType: request.credential.credentialType,
+                    credentialIndex: request.credential.credentialIndex,
+                    credentialData: request.credentialData,
+                    creatorFabricIndex: accessingFabricIndex,
+                    lastModifiedFabricIndex: accessingFabricIndex,
+                });
+                device.log.debug(`MatterbridgeDoorLockServer: added credentialIndex ${request.credential.credentialIndex} for userIndex ${request.userIndex} to internal state: ${debugStringify(user)}`);
+            }
+            this.events.lockUserChange.emit({
+                lockDataType: this.getLockDataTypeForCredentialType(request.credential.credentialType),
+                dataOperationType: request.operationType,
+                operationSource: this.getOperationSource(),
+                userIndex: request.userIndex,
+                fabricIndex: accessingFabricIndex,
+                sourceNode: this.getAccessingNodeId(),
+                dataIndex: this.getCredentialDataIndex(request.credential),
+            }, this.context);
+        }
+        else {
+            device.log.debug(`MatterbridgeDoorLockServer: setCredential did not update internal state for credentialIndex ${request.credential.credentialIndex} (user ${request.userIndex ?? 'null'} not found or operation not handled)`);
+        }
+        return {
+            status: Status.Success,
+            userIndex: request.userIndex,
+        };
+    }
+    async getCredentialStatus(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Getting credential status for credentialType ${getEnumDescription(DoorLock.CredentialType, request.credential.credentialType)} credentialIndex ${request.credential.credentialIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.getCredentialStatus', {
+            command: 'getCredentialStatus',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus called`);
+        const credentialRecord = this.findStoredCredential(request.credential);
+        const nextCredentialIndex = this.getNextOccupiedCredentialIndex(request.credential);
+        const response = {
+            credentialExists: credentialRecord !== null,
+            userIndex: credentialRecord?.user.userIndex ?? null,
+            creatorFabricIndex: credentialRecord?.storedCredential.creatorFabricIndex ?? null,
+            lastModifiedFabricIndex: credentialRecord?.storedCredential.lastModifiedFabricIndex ?? null,
+            nextCredentialIndex,
+        };
+        device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus result ${debugStringify(response)}`);
+        return response;
+    }
+    async clearCredential(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const accessingFabricIndex = this.getAccessingFabricIndex();
+        const clearedCredentialUserIndex = request.credential !== null && request.credential.credentialIndex !== 0xfffe ? (this.findStoredCredential(request.credential)?.user.userIndex ?? null) : null;
+        const credentialTypesToClear = request.credential !== null ? [request.credential.credentialType] : this.getStoredCredentialTypes();
+        device.log.info(`Clearing credentialType ${request.credential ? getEnumDescription(DoorLock.CredentialType, request.credential.credentialType) : 'null'} credentialIndex ${request.credential ? request.credential.credentialIndex : 'null'} ${request.credential === null ? '(all credentials)' : ''} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.clearCredential', {
+            command: 'clearCredential',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug('MatterbridgeDoorLockServer: clearCredential called');
+        for (const user of this.internal.users) {
+            user.credentials =
+                user.credentials?.filter((storedCredential) => {
+                    if (request.credential === null) {
+                        return false;
+                    }
+                    if (storedCredential.credentialType !== request.credential.credentialType) {
+                        return true;
+                    }
+                    if (request.credential.credentialIndex === 0xfffe) {
+                        return false;
+                    }
+                    return storedCredential.credentialIndex !== request.credential.credentialIndex;
+                }) ?? user.credentials;
+        }
+        for (const credentialType of credentialTypesToClear) {
+            this.events.lockUserChange.emit({
+                lockDataType: this.getLockDataTypeForCredentialType(credentialType),
+                dataOperationType: DoorLock.DataOperationType.Clear,
+                operationSource: this.getOperationSource(),
+                userIndex: request.credential === null || request.credential.credentialIndex === 0xfffe ? null : clearedCredentialUserIndex,
+                fabricIndex: accessingFabricIndex,
+                sourceNode: this.getAccessingNodeId(),
+                dataIndex: request.credential === null ? 0xfffe : this.getCredentialDataIndex(request.credential),
+            }, this.context);
+        }
+    }
+    validateUserIndex(userIndex) {
+        if (userIndex < 1 || userIndex > this.state.numberOfTotalUsersSupported) {
+            return false;
+        }
+        return true;
+    }
+    getNextUserIndex(userIndex) {
+        const nextUser = this.internal.users.find((storedUser) => storedUser.userIndex === userIndex + 1);
+        if (nextUser && nextUser.userStatus !== DoorLock.UserStatus.Available) {
+            return nextUser.userIndex;
+        }
+        return null;
+    }
+    getAccessingFabricIndex() {
+        let fabricIndex;
+        try {
+            fabricIndex = this.context.fabric;
+        }
+        catch {
+            return null;
+        }
+        if (fabricIndex === undefined || fabricIndex === FabricIndex.NO_FABRIC) {
+            return null;
+        }
+        return fabricIndex;
+    }
+    getAccessingNodeId() {
+        if (!hasRemoteActor(this.context)) {
+            return null;
+        }
+        return this.context.session.peerNodeId ?? null;
+    }
+    getOperationSource() {
+        return this.getAccessingNodeId() !== null ? DoorLock.OperationSource.Remote : DoorLock.OperationSource.Unspecified;
+    }
+    getLockDataTypeForCredentialType(credentialType) {
+        switch (credentialType) {
+            case DoorLock.CredentialType.ProgrammingPin:
+                return DoorLock.LockDataType.ProgrammingCode;
+            case DoorLock.CredentialType.Pin:
+                return DoorLock.LockDataType.Pin;
+            case DoorLock.CredentialType.Rfid:
+                return DoorLock.LockDataType.Rfid;
+            case DoorLock.CredentialType.Fingerprint:
+                return DoorLock.LockDataType.Fingerprint;
+            case DoorLock.CredentialType.FingerVein:
+                return DoorLock.LockDataType.FingerVein;
+            case DoorLock.CredentialType.Face:
+                return DoorLock.LockDataType.Face;
+            case DoorLock.CredentialType.AliroCredentialIssuerKey:
+                return DoorLock.LockDataType.AliroCredentialIssuerKey;
+            case DoorLock.CredentialType.AliroEvictableEndpointKey:
+                return DoorLock.LockDataType.AliroEvictableEndpointKey;
+            case DoorLock.CredentialType.AliroNonEvictableEndpointKey:
+                return DoorLock.LockDataType.AliroNonEvictableEndpointKey;
+            default:
+                return DoorLock.LockDataType.Unspecified;
+        }
+    }
+    getCredentialDataIndex(credential) {
+        if (credential.credentialType === DoorLock.CredentialType.ProgrammingPin) {
+            return null;
+        }
+        return credential.credentialIndex;
+    }
+    getStoredCredentialTypes() {
+        const credentialTypes = new Set();
+        for (const user of this.internal.users) {
+            for (const credential of user.credentials ?? []) {
+                credentialTypes.add(credential.credentialType);
+            }
+        }
+        return [...credentialTypes];
+    }
+    findStoredCredential(credential) {
+        for (const user of this.internal.users) {
+            for (const storedCredential of user.credentials ?? []) {
+                if (storedCredential.credentialType === credential.credentialType && storedCredential.credentialIndex === credential.credentialIndex) {
+                    return { user, storedCredential };
+                }
+            }
+        }
+        return null;
+    }
+    getNextOccupiedCredentialIndex(credential) {
+        for (const user of this.internal.users) {
+            for (const storedCredential of user.credentials ?? []) {
+                if (storedCredential.credentialType !== credential.credentialType || storedCredential.credentialIndex <= credential.credentialIndex) {
+                    continue;
+                }
+                return storedCredential.credentialIndex;
+            }
+        }
+        return null;
+    }
 }
 (function (MatterbridgeDoorLockServer) {
     class Internal {
         enableTimeout = true;
         unlockTimeout;
+        users = [];
     }
     MatterbridgeDoorLockServer.Internal = Internal;
 })(MatterbridgeDoorLockServer || (MatterbridgeDoorLockServer = {}));

package/dist/behaviors/export.d.ts

@@ -13,12 +13,10 @@ export * from './matterbridgeServer.js';
 export * from './modeSelectServer.js';
 export * from './onOffServer.js';
 export * from './operationalStateServer.js';
-export * from './pinDoorLockServer.js';
 export * from './powerSourceServer.js';
 export * from './serviceAreaServer.js';
 export * from './smokeCoAlarmServer.js';
 export * from './switchServer.js';
 export * from './thermostatServer.js';
-export * from './userPinDoorLockServer.js';
 export * from './valveConfigurationAndControlServer.js';
 export * from './windowCoveringServer.js';

package/dist/behaviors/export.js

@@ -13,12 +13,10 @@ export * from './matterbridgeServer.js';
 export * from './modeSelectServer.js';
 export * from './onOffServer.js';
 export * from './operationalStateServer.js';
-export * from './pinDoorLockServer.js';
 export * from './powerSourceServer.js';
 export * from './serviceAreaServer.js';
 export * from './smokeCoAlarmServer.js';
 export * from './switchServer.js';
 export * from './thermostatServer.js';
-export * from './userPinDoorLockServer.js';
 export * from './valveConfigurationAndControlServer.js';
 export * from './windowCoveringServer.js';

package/dist/export.d.ts

@@ -13,13 +13,11 @@ export * from './behaviors/matterbridgeServer.js';
 export * from './behaviors/modeSelectServer.js';
 export * from './behaviors/onOffServer.js';
 export * from './behaviors/operationalStateServer.js';
-export * from './behaviors/pinDoorLockServer.js';
 export * from './behaviors/powerSourceServer.js';
 export * from './behaviors/serviceAreaServer.js';
 export * from './behaviors/smokeCoAlarmServer.js';
 export * from './behaviors/switchServer.js';
 export * from './behaviors/thermostatServer.js';
-export * from './behaviors/userPinDoorLockServer.js';
 export * from './behaviors/valveConfigurationAndControlServer.js';
 export * from './behaviors/windowCoveringServer.js';
 export { addVirtualDevice } from './helpers.js';

package/dist/export.js

@@ -15,13 +15,11 @@ export * from './behaviors/matterbridgeServer.js';
 export * from './behaviors/modeSelectServer.js';
 export * from './behaviors/onOffServer.js';
 export * from './behaviors/operationalStateServer.js';
-export * from './behaviors/pinDoorLockServer.js';
 export * from './behaviors/powerSourceServer.js';
 export * from './behaviors/serviceAreaServer.js';
 export * from './behaviors/smokeCoAlarmServer.js';
 export * from './behaviors/switchServer.js';
 export * from './behaviors/thermostatServer.js';
-export * from './behaviors/userPinDoorLockServer.js';
 export * from './behaviors/valveConfigurationAndControlServer.js';
 export * from './behaviors/windowCoveringServer.js';
 export { addVirtualDevice } from './helpers.js';

package/dist/frontend.js

@@ -486,7 +486,7 @@ export class Frontend extends EventEmitter {
             };
             res.status(200).json(memoryReport);
         });
-        this.expressApp.get('/api/settings', express.json(), async (req, res) => {
+        this.expressApp.get('/api/settings', async (req, res) => {
             this.log.debug('The frontend sent /api/settings');
             if (!this.validateReq(req, res))
                 return;
@@ -863,10 +863,10 @@ export class Frontend extends EventEmitter {
             matterbridgeLatestVersion: this.matterbridge.matterbridgeLatestVersion,
             matterbridgeDevVersion: this.matterbridge.matterbridgeDevVersion,
             frontendVersion: this.matterbridge.frontendVersion,
-            dockerDev: undefined,
-            dockerVersion: undefined,
-            dockerLatestVersion: undefined,
-            dockerDevVersion: undefined,
+            dockerDev: this.matterbridge.dockerDev,
+            dockerVersion: this.matterbridge.dockerVersion,
+            dockerLatestVersion: this.matterbridge.dockerLatestVersion,
+            dockerDevVersion: this.matterbridge.dockerDevVersion,
             bridgeMode: this.matterbridge.bridgeMode,
             restartMode: this.matterbridge.restartMode,
             virtualMode: this.matterbridge.virtualMode,
@@ -2119,7 +2119,7 @@ export class Frontend extends EventEmitter {
         if (!this.listening || this.webSocketServer?.clients.size === 0)
             return;
         const stringifiedMsg = JSON.stringify(msg);
-        if (msg.method !== 'log')
+        if (!['log', 'cpu_update', 'memory_update', 'uptime_update'].includes(msg.method))
             this.log.debug(`Sending a broadcast message: ${debugStringify(msg)}`);
         this.webSocketServer?.clients.forEach((client) => {
             if (client.readyState === client.OPEN) {

package/dist/helpers.js

@@ -74,11 +74,6 @@ export async function addVirtualDevice(aggregatorEndpoint, name, type, callback)
 }
 export async function addVirtualDevices(matterbridge, aggregatorEndpoint) {
     if (hasParameter('experimental') && matterbridge.bridgeMode === 'bridge' && aggregatorEndpoint) {
-        const lockPin = new MatterbridgeEndpoint(doorLockDevice, { id: 'door_lock_pin' });
-        lockPin.createDefaultBridgedDeviceBasicInformationClusterServer('Matterbridge Pin Lock', 'sn_system_lock', 0xfff1, 'Matterbridge', 'Matterbridge Virtual Device', 20000, '2.0.0');
-        lockPin.createPinDoorLockClusterServer();
-        lockPin.addRequiredClusterServers();
-        await aggregatorEndpoint.add(lockPin);
         const lockUserPin = new MatterbridgeEndpoint(doorLockDevice, { id: 'door_lock_user_pin' });
         lockUserPin.createDefaultBridgedDeviceBasicInformationClusterServer('Matterbridge User Pin Lock', 'sn_system_lock', 0xfff1, 'Matterbridge', 'Matterbridge Virtual Device', 20000, '2.0.0');
         lockUserPin.createUserPinDoorLockClusterServer();

package/dist/matterNode.js

@@ -280,8 +280,16 @@ export class MatterNode extends EventEmitter {
             this.matterLog.logFilePath = path.join(this.matterbridge.matterbridgeDirectory, MATTER_LOGGER_FILE);
         }
         return (text, message) => {
-            const logger = text.slice(44, 44 + 20).trim();
-            const msg = text.slice(65);
+            let logger;
+            let msg;
+            if (!hasParameter('no-ansi') && process.env.NO_ANSI !== 'true') {
+                logger = text.slice(44, 44 + 20).trim();
+                msg = text.slice(65);
+            }
+            else {
+                logger = text.slice(30).trim().split(/\s+/, 1)[0];
+                msg = text.slice(30).trim().slice(logger.length).trimStart();
+            }
             this.matterLog.logName = logger;
             this.matterLog.log(MatterLogLevel.names[message.level], msg);
         };

package/dist/matterbridge.js

@@ -1053,8 +1053,16 @@ export class Matterbridge extends EventEmitter {
             this.matterLog.logFilePath = path.join(this.matterbridgeDirectory, MATTER_LOGGER_FILE);
         }
         return (text, message) => {
-            const logger = text.slice(44, 44 + 20).trim();
-            const msg = text.slice(65);
+            let logger;
+            let msg;
+            if (!hasParameter('no-ansi') && process.env.NO_ANSI !== 'true') {
+                logger = text.slice(44, 44 + 20).trim();
+                msg = text.slice(65);
+            }
+            else {
+                logger = text.slice(30).trim().split(/\s+/, 1)[0];
+                msg = text.slice(30).trim().slice(logger.length).trimStart();
+            }
             this.matterLog.logName = logger;
             switch (message.level) {
                 case MatterLogLevel.DEBUG:

package/dist/matterbridgeEndpoint.d.ts

@@ -24,7 +24,7 @@ import { ClusterId, EndpointNumber } from '@matter/types/datatype';
 import { Semtag } from '@matter/types/globals';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
 import { DeviceTypeDefinition } from './matterbridgeDeviceTypes.js';
-import { CommandHandler, CommandHandlerData, CommandHandlerFunction, CommandHandlers } from './matterbridgeEndpointCommandHandler.js';
+import { CommandHandler, CommandHandlerData, CommandHandlerExecutionResult, CommandHandlerFunction, CommandHandlers } from './matterbridgeEndpointCommandHandler.js';
 import { MatterbridgeEndpointOptions, SerializedMatterbridgeEndpoint } from './matterbridgeEndpointTypes.js';
 type BehaviorCommandName<T extends Behavior.Type> = {
     [K in keyof CommandsOfBehavior<T>]: K;
@@ -101,7 +101,7 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     addUserLabel(label: string, value: string): Promise<this>;
     addCommandHandler<C extends CommandHandlers>(command: C, handler: CommandHandlerFunction<C>): this;
     removeCommandHandler<C extends CommandHandlers>(command: C, handler: CommandHandlerFunction<C>): this;
-    executeCommandHandler<C extends CommandHandlers>(command: C, request: CommandHandlerData<C>['request'], cluster: CommandHandlerData<C>['cluster'], attributes: CommandHandlerData<C>['attributes'], endpoint: CommandHandlerData<C>['endpoint']): Promise<void>;
+    executeCommandHandler<C extends CommandHandlers>(command: C, request: CommandHandlerData<C>['request'], cluster: CommandHandlerData<C>['cluster'], attributes: CommandHandlerData<C>['attributes'], endpoint: CommandHandlerData<C>['endpoint']): Promise<CommandHandlerExecutionResult<C>>;
     invokeBehaviorCommand<T extends Behavior.Type, C extends BehaviorCommandName<T>>(cluster: T, command: C, params?: BehaviorCommandParams<T, C>): Promise<void>;
     invokeBehaviorCommand<T extends ClusterType, C extends keyof ClusterType.CommandsOf<T>>(cluster: T, command: C, params?: ClusterType.CommandsOf<T>[C] extends {
         requestSchema: infer S extends import('@matter/types/tlv').TlvSchema<unknown>;
@@ -182,9 +182,8 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     }, airflowDirection?: FanControl.AirflowDirection): this;
     createDefaultHepaFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
     createDefaultActivatedCarbonFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
-    createDefaultDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
-    createPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
-    createUserPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
+    createDefaultDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType, autoRelockTime?: number): this;
+    createUserPinDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType, autoRelockTime?: number, minPinCodeLength?: number, maxPinCodeLength?: number): this;
     createDefaultModeSelectClusterServer(description: string, supportedModes: ModeSelect.ModeOption[], currentMode?: number, startUpMode?: number): this;
     createDefaultValveConfigurationAndControlClusterServer(valveState?: ValveConfigurationAndControl.ValveState, valveLevel?: number): this;
     createDefaultPumpConfigurationAndControlClusterServer(pumpMode?: PumpConfigurationAndControl.OperationMode): this;