@matterbridge/core 3.7.2-dev-20260328-c77b608 → 3.7.2-dev-20260329-5cac980

package/dist/behaviors/thermostatServer.js

@@ -0,0 +1,50 @@
+import { ThermostatServer } from '@matter/node/behaviors/thermostat';
+import { Thermostat } from '@matter/types/clusters/thermostat';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode, Thermostat.Feature.Presets) {
+    async initialize() {
+        await super.initialize();
+        this.endpoint.construction.onSuccess(async () => {
+            const device = this.endpoint.stateOf(MatterbridgeServer);
+            device.log.debug(`Removing atomic commands (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            await this.endpoint.setStateOf(ThermostatServer, {
+                acceptedCommandList: [0],
+                generatedCommandList: [],
+            });
+        });
+    }
+    async setpointRaiseLower(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('Thermostat.setpointRaiseLower', {
+            command: 'setpointRaiseLower',
+            request,
+            cluster: ThermostatServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
+        device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10}`);
+        await super.setpointRaiseLower(request);
+    }
+    async setActivePresetRequest(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const presetHandle = request.presetHandle ? `0x${Buffer.from(request.presetHandle).toString('hex')}` : 'null';
+        device.log.info(`Setting preset to ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('Thermostat.setActivePresetRequest', {
+            command: 'setActivePresetRequest',
+            request,
+            cluster: ThermostatServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest called with presetHandle: ${presetHandle}`);
+        await super.setActivePresetRequest(request);
+        const activePresetHandle = this.state.activePresetHandle ? `0x${Buffer.from(this.state.activePresetHandle).toString('hex')}` : 'null';
+        device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest completed with activePresetHandle: ${activePresetHandle} occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint} occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint}`);
+    }
+}
+export class MatterbridgePresetThermostatServer extends ThermostatServer.with(Thermostat.Feature.Presets, Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode) {
+}

package/dist/behaviors/userPinDoorLockServer.d.ts

@@ -0,0 +1,57 @@
+import { DoorLockServer } from '@matter/node/behaviors/door-lock';
+import { DoorLock } from '@matter/types/clusters/door-lock';
+import { FabricIndex } from '@matter/types/datatype';
+declare const MatterbridgeUserPinDoorLockServer_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, DoorLock.Feature.CredentialOverTheAirAccess]>, import("@matter/types").ClusterTypeModifier.ElementFlagAlterations<{
+    readonly events: {
+        readonly doorLockAlarm: true;
+        readonly lockOperation: true;
+        readonly lockOperationError: true;
+    };
+    readonly commands: {
+        readonly lockDoor: true;
+        readonly unlockDoor: true;
+        readonly unlockWithTimeout: true;
+    };
+}>>, import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<DoorLock.Cluster, readonly [DoorLock.Feature.User, DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess]>, typeof DoorLockServer, import("@matter/node/behaviors/door-lock").DoorLockInterface>, import("@matter/node/behaviors/door-lock").DoorLockInterface>;
+export declare class MatterbridgeUserPinDoorLockServer extends MatterbridgeUserPinDoorLockServer_base {
+    protected internal: MatterbridgeUserPinDoorLockServer.Internal;
+    private getAccessingFabricIndex;
+    private findStoredCredential;
+    private getStoredCredentialStateDebug;
+    private logStoredCredentialState;
+    private hasMatchingPinCredential;
+    private validateRemotePinCode;
+    private getNextOccupiedCredentialIndex;
+    private upsertStoredCredential;
+    private clearStoredCredential;
+    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>;
+}
+export declare namespace MatterbridgeUserPinDoorLockServer {
+    type StoredCredential = DoorLock.Credential & {
+        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;
+        nextUserIndex: number | null;
+    };
+    class Internal {
+        users: StoredUser[];
+    }
+}
+export {};

package/dist/behaviors/userPinDoorLockServer.js

@@ -0,0 +1,348 @@
+import { DoorLockServer } from '@matter/node/behaviors/door-lock';
+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';
+import { debugStringify } from 'node-ansi-logger';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeUserPinDoorLockServer extends DoorLockServer.with(DoorLock.Feature.User, DoorLock.Feature.PinCredential, DoorLock.Feature.CredentialOverTheAirAccess).enable({
+    events: { doorLockAlarm: true, lockOperation: true, lockOperationError: true },
+    commands: { lockDoor: true, unlockDoor: true, unlockWithTimeout: true },
+}) {
+    getAccessingFabricIndex() {
+        let fabricIndex;
+        try {
+            fabricIndex = this.context.fabric;
+        }
+        catch {
+            return null;
+        }
+        if (fabricIndex === undefined || fabricIndex === FabricIndex.NO_FABRIC) {
+            return null;
+        }
+        return fabricIndex;
+    }
+    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;
+    }
+    getStoredCredentialStateDebug() {
+        if (this.internal.users.length === 0) {
+            return 'no users';
+        }
+        return this.internal.users
+            .map((user) => {
+            const credentials = user.credentials
+                ?.map((credential) => `${getEnumDescription(DoorLock.CredentialType, credential.credentialType)}:${credential.credentialIndex}=0x${Buffer.from(credential.credentialData).toString('hex')}`)
+                .join(', ') ?? 'none';
+            return `user ${user.userIndex} [${credentials}]`;
+        })
+            .join('; ');
+    }
+    logStoredCredentialState(reason) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.debug(`MatterbridgeDoorLockServer: ${reason}; stored credentials: ${this.getStoredCredentialStateDebug()}`);
+    }
+    hasMatchingPinCredential(pinCode) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.debug(`MatterbridgeDoorLockServer: checking remote PIN 0x${Buffer.from(pinCode).toString('hex')} against ${this.internal.users.length} user(s)`);
+        for (const user of this.internal.users) {
+            for (const storedCredential of user.credentials ?? []) {
+                if (storedCredential.credentialType !== DoorLock.CredentialType.Pin) {
+                    continue;
+                }
+                if (Buffer.from(storedCredential.credentialData).equals(Buffer.from(pinCode))) {
+                    device.log.debug(`MatterbridgeDoorLockServer: remote PIN matched userIndex ${user.userIndex} credentialIndex ${storedCredential.credentialIndex}`);
+                    return true;
+                }
+            }
+        }
+        device.log.debug(`MatterbridgeDoorLockServer: remote PIN 0x${Buffer.from(pinCode).toString('hex')} did not match any stored PIN credential`);
+        return false;
+    }
+    validateRemotePinCode(pinCode) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.requirePinForRemoteOperation) {
+            device.log.debug('MatterbridgeDoorLockServer: skipping remote PIN validation because requirePinForRemoteOperation is false');
+            return;
+        }
+        if (pinCode === undefined) {
+            device.log.debug('MatterbridgeDoorLockServer: rejecting remote operation because the request did not include a PIN');
+            this.logStoredCredentialState('remote PIN validation failed');
+            throw new StatusResponse.FailureError('Missing or invalid PIN code for remote operation');
+        }
+        device.log.debug(`MatterbridgeDoorLockServer: validating remote PIN 0x${Buffer.from(pinCode).toString('hex')}`);
+        if (!this.hasMatchingPinCredential(pinCode)) {
+            this.logStoredCredentialState('remote PIN validation failed');
+            throw new StatusResponse.FailureError('Missing or invalid PIN code for remote operation');
+        }
+        device.log.debug(`MatterbridgeDoorLockServer: accepted remote PIN 0x${Buffer.from(pinCode).toString('hex')}`);
+    }
+    getNextOccupiedCredentialIndex(credential) {
+        let nextCredentialIndex = null;
+        for (const user of this.internal.users) {
+            for (const storedCredential of user.credentials ?? []) {
+                if (storedCredential.credentialType !== credential.credentialType || storedCredential.credentialIndex <= credential.credentialIndex) {
+                    continue;
+                }
+                if (nextCredentialIndex === null || storedCredential.credentialIndex < nextCredentialIndex) {
+                    nextCredentialIndex = storedCredential.credentialIndex;
+                }
+            }
+        }
+        return nextCredentialIndex;
+    }
+    upsertStoredCredential(userIndex, credential, credentialData) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (userIndex === null) {
+            device.log.debug(`MatterbridgeDoorLockServer: not storing credentialType ${getEnumDescription(DoorLock.CredentialType, credential.credentialType)} credentialIndex ${credential.credentialIndex} because userIndex is null`);
+            return;
+        }
+        const user = this.internal.users.find((storedUser) => storedUser.userIndex === userIndex);
+        if (!user) {
+            device.log.debug(`MatterbridgeDoorLockServer: not storing credentialType ${getEnumDescription(DoorLock.CredentialType, credential.credentialType)} credentialIndex ${credential.credentialIndex} because userIndex ${userIndex} was not found`);
+            return;
+        }
+        let removedCredentials = 0;
+        for (const storedUser of this.internal.users) {
+            const nextCredentials = storedUser.credentials?.filter((storedCredential) => storedCredential.credentialType !== credential.credentialType || storedCredential.credentialIndex !== credential.credentialIndex) ?? null;
+            removedCredentials += (storedUser.credentials?.length ?? 0) - (nextCredentials?.length ?? 0);
+            storedUser.credentials = nextCredentials && nextCredentials.length > 0 ? nextCredentials : null;
+        }
+        if (!user.credentials) {
+            user.credentials = [];
+        }
+        user.credentials.push({
+            credentialType: credential.credentialType,
+            credentialIndex: credential.credentialIndex,
+            credentialData: Uint8Array.from(credentialData),
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: stored credentialType ${getEnumDescription(DoorLock.CredentialType, credential.credentialType)} credentialIndex ${credential.credentialIndex} for userIndex ${userIndex} (removed ${removedCredentials} replaced credential(s))`);
+        this.logStoredCredentialState('credential stored');
+    }
+    clearStoredCredential(credential) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        for (const user of this.internal.users) {
+            if (credential === null) {
+                user.credentials = null;
+                continue;
+            }
+            const nextCredentials = user.credentials?.filter((storedCredential) => storedCredential.credentialType !== credential.credentialType || storedCredential.credentialIndex !== credential.credentialIndex) ?? null;
+            user.credentials = nextCredentials && nextCredentials.length > 0 ? nextCredentials : null;
+        }
+        device.log.debug(`MatterbridgeDoorLockServer: cleared ${credential ? `${getEnumDescription(DoorLock.CredentialType, credential.credentialType)} credentialIndex ${credential.credentialIndex}` : 'all credentials'} from internal state`);
+        this.logStoredCredentialState('credential cleared');
+    }
+    async lockDoor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Locking door with pincode ${request.pinCode ? '0x' + Buffer.from(request.pinCode).toString('hex') : 'N/A'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.validateRemotePinCode(request.pinCode);
+        device.log.debug(`MatterbridgeDoorLockServer: remote lockDoor PIN validation completed`);
+        await device.commandHandler.executeHandler('DoorLock.lockDoor', {
+            command: 'lockDoor',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: lockDoor called`);
+        await super.lockDoor(request);
+    }
+    async unlockDoor(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Unlocking door with pincode ${request.pinCode ? '0x' + Buffer.from(request.pinCode).toString('hex') : 'N/A'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.validateRemotePinCode(request.pinCode);
+        device.log.debug(`MatterbridgeDoorLockServer: remote unlockDoor PIN validation completed`);
+        await device.commandHandler.executeHandler('DoorLock.unlockDoor', {
+            command: 'unlockDoor',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: unlockDoor called`);
+        await super.unlockDoor(request);
+    }
+    async unlockWithTimeout(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Unlocking door with pincode ${request.pinCode ? '0x' + Buffer.from(request.pinCode).toString('hex') : 'N/A'} timeout ${request.timeout} seconds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.validateRemotePinCode(request.pinCode);
+        device.log.debug(`MatterbridgeDoorLockServer: remote unlockWithTimeout PIN validation completed`);
+        await device.commandHandler.executeHandler('DoorLock.unlockWithTimeout', {
+            command: 'unlockWithTimeout',
+            request,
+            cluster: DoorLockServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeDoorLockServer: unlockWithTimeout called`);
+        this.state.lockState = DoorLock.LockState.Unlocked;
+    }
+    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,
+                userStatus: request.userStatus,
+                userType: request.userType,
+                credentialRule: request.credentialRule,
+                credentials: null,
+                creatorFabricIndex: accessingFabricIndex,
+                lastModifiedFabricIndex: accessingFabricIndex,
+                nextUserIndex: null,
+            });
+            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))}`);
+            this.logStoredCredentialState('user added');
+            return;
+        }
+        this.logStoredCredentialState(`setUser completed for userIndex ${request.userIndex} without adding a new internal user`);
+    }
+    async getUser(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Getting userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('DoorLock.getUser', {
+            command: 'getUser',
+            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: getUser called for userIndex ${request.userIndex} (total users: ${this.internal.users.length}) (${user ? 'existing user: ' + debugStringify(user) : 'new user'})`);
+        this.logStoredCredentialState(`getUser returning state for userIndex ${request.userIndex}`);
+        if (user) {
+            return {
+                ...user,
+                credentials: user.credentials?.map(({ credentialType, credentialIndex }) => ({ credentialType, credentialIndex })) ?? null,
+            };
+        }
+        return {
+            userIndex: request.userIndex,
+            userName: null,
+            userUniqueId: null,
+            userStatus: null,
+            userType: null,
+            credentialRule: null,
+            credentials: null,
+            creatorFabricIndex: null,
+            lastModifiedFabricIndex: null,
+            nextUserIndex: null,
+        };
+    }
+    async clearUser(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        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}`);
+        this.logStoredCredentialState(`clearUser completed for userIndex ${request.userIndex}`);
+    }
+    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'})`);
+        device.log.debug(`MatterbridgeDoorLockServer: setCredential called for credentialIndex ${request.credential.credentialIndex}`);
+        if (user && (request.operationType === DoorLock.DataOperationType.Add || request.operationType === DoorLock.DataOperationType.Modify)) {
+            this.upsertStoredCredential(request.userIndex, request.credential, request.credentialData);
+            user.lastModifiedFabricIndex = accessingFabricIndex;
+            device.log.debug(`MatterbridgeDoorLockServer: setCredential updated lastModifiedFabricIndex for userIndex ${user.userIndex} to ${accessingFabricIndex ?? 'null'}`);
+        }
+        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,
+        });
+        const credentialRecord = this.findStoredCredential(request.credential);
+        const nextCredentialIndex = this.getNextOccupiedCredentialIndex(request.credential);
+        device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus called`);
+        device.log.debug(`MatterbridgeDoorLockServer: getCredentialStatus result for credentialIndex ${request.credential.credentialIndex} (${credentialRecord ? `userIndex ${credentialRecord.user.userIndex} credentialData 0x${Buffer.from(credentialRecord.storedCredential.credentialData).toString('hex')}` : 'credential missing'}, nextCredentialIndex ${nextCredentialIndex ?? 'null'})`);
+        return {
+            credentialExists: credentialRecord !== null,
+            userIndex: credentialRecord?.user.userIndex ?? null,
+            creatorFabricIndex: credentialRecord?.user.creatorFabricIndex ?? null,
+            lastModifiedFabricIndex: credentialRecord?.user.lastModifiedFabricIndex ?? null,
+            nextCredentialIndex,
+            credentialData: credentialRecord?.storedCredential.credentialData ?? null,
+        };
+    }
+    async clearCredential(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        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,
+        });
+        this.clearStoredCredential(request.credential);
+        device.log.debug('MatterbridgeDoorLockServer: clearCredential called');
+        this.logStoredCredentialState(`clearCredential completed for ${request.credential
+            ? `${getEnumDescription(DoorLock.CredentialType, request.credential.credentialType)} credentialIndex ${request.credential.credentialIndex}`
+            : 'all credentials'}`);
+    }
+}
+(function (MatterbridgeUserPinDoorLockServer) {
+    class Internal {
+        users = [];
+    }
+    MatterbridgeUserPinDoorLockServer.Internal = Internal;
+})(MatterbridgeUserPinDoorLockServer || (MatterbridgeUserPinDoorLockServer = {}));

package/dist/behaviors/valveConfigurationAndControlServer.d.ts

@@ -0,0 +1,8 @@
+import { ValveConfigurationAndControlServer } from '@matter/node/behaviors/valve-configuration-and-control';
+import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
+declare const MatterbridgeValveConfigurationAndControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<ValveConfigurationAndControl.Cluster, readonly [ValveConfigurationAndControl.Feature.Level]>, typeof ValveConfigurationAndControlServer, import("@matter/node/behaviors/valve-configuration-and-control").ValveConfigurationAndControlInterface>;
+export declare class MatterbridgeValveConfigurationAndControlServer extends MatterbridgeValveConfigurationAndControlServer_base {
+    open(request: ValveConfigurationAndControl.OpenRequest): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

package/dist/behaviors/valveConfigurationAndControlServer.js

@@ -0,0 +1,44 @@
+import { ValveConfigurationAndControlServer } from '@matter/node/behaviors/valve-configuration-and-control';
+import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+export class MatterbridgeValveConfigurationAndControlServer extends ValveConfigurationAndControlServer.with(ValveConfigurationAndControl.Feature.Level) {
+    async open(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Opening valve to ${request.targetLevel ? request.targetLevel + '%' : 'fully opened'} ${request.openDuration ? 'for ' + request.openDuration + 's' : 'until closed'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ValveConfigurationAndControl.open', {
+            command: 'open',
+            request,
+            cluster: ValveConfigurationAndControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: open called with openDuration: ${request.openDuration} targetLevel: ${request.targetLevel}`);
+        this.state.targetState = ValveConfigurationAndControl.ValveState.Open;
+        this.state.currentState = ValveConfigurationAndControl.ValveState.Open;
+        this.state.targetLevel = request.targetLevel ?? 100;
+        this.state.currentLevel = request.targetLevel ?? 100;
+        this.state.openDuration = request.openDuration ?? this.state.defaultOpenDuration;
+        if (this.state.openDuration === null)
+            this.state.remainingDuration = null;
+    }
+    async close() {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Closing valve (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ValveConfigurationAndControl.close', {
+            command: 'close',
+            request: {},
+            cluster: ValveConfigurationAndControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
+        device.log.debug(`MatterbridgeValveConfigurationAndControlServer: close called`);
+        this.state.targetState = ValveConfigurationAndControl.ValveState.Closed;
+        this.state.currentState = ValveConfigurationAndControl.ValveState.Closed;
+        this.state.targetLevel = 0;
+        this.state.currentLevel = 0;
+        this.state.openDuration = null;
+        this.state.remainingDuration = null;
+    }
+}