@project-chip/matter.js 0.13.0-alpha.0-20250304-d4a7592a4 → 0.13.0-alpha.0-20250307-ebf84a05a

package/src/cluster/server/CommissioningServerFailsafeContext.ts

@@ -1,92 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { BasicInformation, GeneralCommissioning, NetworkCommissioning, OperationalCredentials } from "#clusters";
-import { asyncNew } from "#general";
-import { type EndpointInterface, Fabric, FailsafeContext } from "#protocol";
-import { EndpointNumber, TypeFromSchema } from "#types";
-import { Endpoint } from "../../device/Endpoint.js";
-
-/**
- * {@link FailsafeContext} implementation for {@link EndpointInterface} API.
- */
-export class CommissioningServerFailsafeContext extends FailsafeContext {
-    #rootEndpoint: Endpoint;
-    #storedNetworkClusterState = new Map<
-        EndpointNumber,
-        TypeFromSchema<typeof NetworkCommissioning.TlvNetworkInfo>[]
-    >();
-
-    constructor(rootEndpoint: Endpoint, options: FailsafeContext.Options) {
-        super(options);
-        this.#rootEndpoint = rootEndpoint;
-    }
-
-    static async create(rootEndpoint: Endpoint, options: FailsafeContext.Options) {
-        return asyncNew(this, rootEndpoint, options);
-    }
-
-    override async storeEndpointState() {
-        await this.#storeEndpointState(this.#rootEndpoint);
-    }
-
-    override async restoreFabric(fabric: Fabric) {
-        await super.restoreFabric(fabric);
-        const operationalCredentialsCluster = this.#rootEndpoint.getClusterServer(OperationalCredentials.Cluster);
-        operationalCredentialsCluster?.attributes.nocs.updatedLocalForFabric(fabric);
-        operationalCredentialsCluster?.attributes.fabrics.updatedLocalForFabric(fabric);
-    }
-
-    override async restoreNetworkState() {
-        await this.#restoreEndpointState(this.#rootEndpoint);
-    }
-
-    override async revokeFabric(fabric: Fabric) {
-        const basicInformationCluster = this.#rootEndpoint.getClusterServer(BasicInformation.Cluster);
-        basicInformationCluster?.triggerLeaveEvent?.({ fabricIndex: fabric.fabricIndex });
-
-        await fabric.remove();
-
-        const operationalCredentialsCluster = this.#rootEndpoint.getClusterServer(OperationalCredentials.Cluster);
-        operationalCredentialsCluster?.attributes.nocs.updatedLocalForFabric(fabric);
-        operationalCredentialsCluster?.attributes.commissionedFabrics.updatedLocal();
-        operationalCredentialsCluster?.attributes.fabrics.updatedLocalForFabric(fabric);
-        operationalCredentialsCluster?.attributes.trustedRootCertificates.updatedLocal();
-    }
-
-    override async restoreBreadcrumb() {
-        const generalCommissioningCluster = this.#rootEndpoint.getClusterServer(GeneralCommissioning.Cluster);
-        generalCommissioningCluster?.setBreadcrumbAttribute(0);
-    }
-
-    async #storeEndpointState(endpoint: Endpoint) {
-        // TODO: When implementing Network clusters we somehow need to make sure that a "temporary" network
-        //  configuration is not persisted to disk. The NetworkClusterHandlers need to make sure it is only persisted
-        //  when the commissioning is completed.
-        const networkCluster = endpoint.getClusterServer(NetworkCommissioning.Complete);
-        if (networkCluster !== undefined) {
-            this.#storedNetworkClusterState.set(endpoint.getNumber(), networkCluster.getNetworksAttribute());
-        }
-        for (const childEndpoint of endpoint.getChildEndpoints()) {
-            await this.#storeEndpointState(childEndpoint);
-        }
-    }
-
-    async #restoreEndpointState(endpoint: Endpoint) {
-        const endpointId = endpoint.getNumber();
-        const networkState = this.#storedNetworkClusterState.get(endpointId);
-        if (networkState !== undefined) {
-            const networkCluster = endpoint.getClusterServer(NetworkCommissioning.Complete);
-            if (networkCluster !== undefined) {
-                networkCluster.setNetworksAttribute(networkState);
-            }
-            this.#storedNetworkClusterState.delete(endpointId);
-        }
-        for (const childEndpoint of endpoint.getChildEndpoints()) {
-            await this.#restoreEndpointState(childEndpoint);
-        }
-    }
-}

package/src/cluster/server/GeneralCommissioningServer.ts

@@ -1,201 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-    AdministratorCommissioning,
-    BasicInformationCluster,
-    GeneralCommissioning,
-    GeneralCommissioningCluster,
-} from "#clusters";
-import { ImplementationError, Logger, MatterFlowError } from "#general";
-import { MatterDevice } from "#MatterDevice.js";
-import { assertSecureSession } from "#protocol";
-import { ClusterServerHandlers } from "./ClusterServerTypes.js";
-import { CommissioningServerFailsafeContext } from "./CommissioningServerFailsafeContext.js";
-
-const SuccessResponse = { errorCode: GeneralCommissioning.CommissioningError.Ok, debugText: "" };
-const logger = Logger.get("GeneralCommissioningClusterHandler");
-
-export const GeneralCommissioningClusterHandler: (options?: {
-    /** Is the commissioner allowed to change the country code? */
-    allowCountryCodeChange?: boolean;
-    /** If set, only these country codes are allowed to be set when changing country is allowed. */
-    countryCodeWhitelist?: string[];
-}) => ClusterServerHandlers<typeof GeneralCommissioningCluster> = options => ({
-    initializeClusterServer: ({ attributes: { breadcrumb } }) => {
-        breadcrumb.setLocal(BigInt(0));
-    },
-
-    armFailSafe: async ({
-        request: { breadcrumb: breadcrumbStep, expiryLengthSeconds },
-        attributes: { breadcrumb, basicCommissioningInfo },
-        session,
-        endpoint,
-    }) => {
-        assertSecureSession(session, "armFailSafe can only be called on a secure session");
-        const device = MatterDevice.of(session);
-
-        try {
-            // If the fail-safe timer is not currently armed, the commissioning window is open, and the command was
-            // received over a CASE session, the command SHALL leave the current fail-safe state unchanged and immediately
-            // respond with an ArmFailSafeResponse containing an ErrorCode value of BusyWithOtherAdmin. This is done to
-            // allow commissioners, which use PASE connections, the opportunity to use the failsafe during the
-            // relatively short commissioning window.
-            if (
-                !device.isFailsafeArmed() &&
-                endpoint.getClusterServer(AdministratorCommissioning.Cluster)?.getWindowStatusAttribute() !==
-                    AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen &&
-                !session.isPase
-            ) {
-                throw new MatterFlowError("Failed to arm failsafe using CASE while commissioning window is opened.");
-            }
-
-            if (device.isFailsafeArmed()) {
-                await device.failsafeContext.extend(session.fabric, expiryLengthSeconds);
-            } else {
-                // If ExpiryLengthSeconds is 0 and the fail-safe timer was not armed, then this command invocation SHALL
-                // lead to a success response with no side effect against the fail-safe context.
-                if (expiryLengthSeconds === 0) return SuccessResponse;
-
-                await device.beginTimed(
-                    new CommissioningServerFailsafeContext(endpoint, {
-                        fabrics: device.fabricManager,
-                        sessions: device.sessionManager,
-                        expiryLengthSeconds,
-                        maxCumulativeFailsafeSeconds: basicCommissioningInfo.getLocal().maxCumulativeFailsafeSeconds,
-                        associatedFabric: session.fabric,
-                    }),
-                );
-            }
-
-            if (device.isFailsafeArmed()) {
-                // If failsafe is armed after the command, set breadcrumb (not when expired)
-                breadcrumb.setLocal(breadcrumbStep);
-            }
-        } catch (error) {
-            MatterFlowError.accept(error);
-
-            logger.debug(`Error while arming failSafe timer`, error);
-            return {
-                errorCode: GeneralCommissioning.CommissioningError.BusyWithOtherAdmin,
-                debugText: error.message,
-            };
-        }
-        return SuccessResponse;
-    },
-
-    setRegulatoryConfig: async ({
-        request: { breadcrumb: breadcrumbStep, newRegulatoryConfig, countryCode },
-        attributes: { breadcrumb, regulatoryConfig, locationCapability },
-        endpoint,
-    }) => {
-        const locationCapabilityValue = locationCapability.getLocal();
-
-        // Check and handle country code
-        const basicInformationCluster = endpoint.getClusterServer(BasicInformationCluster);
-        if (basicInformationCluster === undefined) {
-            throw new ImplementationError("BasicInformationCluster needs to be present on the root endpoint");
-        }
-        const currentLocationCountryCode = basicInformationCluster.getLocationAttribute();
-
-        if (currentLocationCountryCode !== countryCode) {
-            if (options?.allowCountryCodeChange === false && countryCode !== "XX") {
-                return {
-                    errorCode: GeneralCommissioning.CommissioningError.ValueOutsideRange,
-                    debugText: `Country code change not allowed: ${countryCode}`,
-                };
-            }
-            if (options?.countryCodeWhitelist !== undefined && !options?.countryCodeWhitelist.includes(countryCode)) {
-                return {
-                    errorCode: GeneralCommissioning.CommissioningError.ValueOutsideRange,
-                    debugText: `Country code change not allowed: ${countryCode}`,
-                };
-            }
-            if (countryCode !== "XX") {
-                basicInformationCluster.setLocationAttribute(countryCode);
-            }
-        }
-
-        // Check and handle regulatory config for LocationCapability
-        let validValues;
-        switch (locationCapabilityValue) {
-            case GeneralCommissioning.RegulatoryLocationType.Outdoor:
-                validValues = [GeneralCommissioning.RegulatoryLocationType.Outdoor];
-                break;
-            case GeneralCommissioning.RegulatoryLocationType.Indoor:
-                validValues = [GeneralCommissioning.RegulatoryLocationType.Indoor];
-                break;
-            case GeneralCommissioning.RegulatoryLocationType.IndoorOutdoor:
-                validValues = [
-                    GeneralCommissioning.RegulatoryLocationType.Indoor,
-                    GeneralCommissioning.RegulatoryLocationType.Outdoor,
-                    GeneralCommissioning.RegulatoryLocationType.IndoorOutdoor,
-                ];
-                break;
-            default:
-                return {
-                    errorCode: GeneralCommissioning.CommissioningError.ValueOutsideRange,
-                    debugText: `Invalid regulatory location: ${
-                        newRegulatoryConfig === GeneralCommissioning.RegulatoryLocationType.Indoor
-                            ? "Indoor"
-                            : "Outdoor"
-                    }`,
-                };
-        }
-        if (!validValues.includes(newRegulatoryConfig)) {
-            return {
-                errorCode: GeneralCommissioning.CommissioningError.ValueOutsideRange,
-                debugText: `Invalid regulatory location: ${
-                    newRegulatoryConfig === GeneralCommissioning.RegulatoryLocationType.Indoor ? "Indoor" : "Outdoor"
-                }`,
-            };
-        }
-        regulatoryConfig.setLocal(newRegulatoryConfig);
-
-        breadcrumb.setLocal(breadcrumbStep);
-        return SuccessResponse;
-    },
-
-    commissioningComplete: async ({ session, attributes: { breadcrumb } }) => {
-        const fabric = session.associatedFabric;
-
-        if (session.isPase) {
-            return {
-                errorCode: GeneralCommissioning.CommissioningError.InvalidAuthentication,
-                debugText: "Command not executed over CASE session.",
-            };
-        }
-
-        const device = MatterDevice.of(session);
-        if (!device.isFailsafeArmed()) {
-            return { errorCode: GeneralCommissioning.CommissioningError.NoFailSafe, debugText: "FailSafe not armed." };
-        }
-
-        assertSecureSession(session, "commissioningComplete can only be called on a secure session");
-
-        const failsafeFabric = device.failsafeContext.associatedFabric?.fabricIndex;
-        if (fabric.fabricIndex !== failsafeFabric) {
-            return {
-                errorCode: GeneralCommissioning.CommissioningError.InvalidAuthentication,
-                debugText: `Associated fabric ${fabric.fabricIndex} does not match the one from the failsafe context ${failsafeFabric}.`,
-            };
-        }
-
-        // On successful execution of the CommissioningComplete command the following actions SHALL be undertaken on the Server:
-        // 1. The Fail-Safe timer associated with the current Fail-Safe context SHALL be disarmed.
-        // 2. The commissioning window at the Server SHALL be closed.
-        // 3. Any temporary administrative privileges automatically granted to any open PASE session SHALL be revoked (see Section 6.6.2.8, “Bootstrapping of the Access Control Cluster”).
-        // 4. The Secure Session Context of any PASE session still established at the Server SHALL be cleared.
-        await device.failsafeContext.completeCommission();
-
-        // 5. The Breadcrumb attribute SHALL be reset to zero.
-        breadcrumb.setLocal(BigInt(0));
-
-        logger.info(`Commissioning completed on fabric #${fabric.fabricId} as node #${fabric.nodeId}.`);
-
-        return SuccessResponse;
-    },
-});

package/src/cluster/server/GeneralDiagnosticsServer.ts

@@ -1,108 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { GeneralDiagnostics, GeneralDiagnosticsCluster } from "#clusters";
-import {
-    Bytes,
-    ipv4ToBytes,
-    ipv6ToBytes,
-    NamedHandler,
-    Network,
-    NetworkInterfaceDetailed,
-    NotImplementedError,
-    Time,
-} from "#general";
-import { AttributeServer } from "#protocol";
-import { WrapCommandHandler } from "../../device/Device.js";
-import { ClusterServer } from "./ClusterServer.js";
-import { ClusterServerHandlers } from "./ClusterServerTypes.js";
-
-export const GeneralDiagnosticsClusterHandler: () => Promise<
-    ClusterServerHandlers<typeof GeneralDiagnosticsCluster>
-> = async () => {
-    let bootUpTime = 0;
-
-    // We update the totalOperationalHours attribute every hour
-    let totalOperationalHoursAttribute: AttributeServer<number> | undefined = undefined;
-    const totalOperationalHoursUpdateTimer = Time.getPeriodicTimer(
-        "GeneralDiagnosticsCluster.totalOperationalHoursUpdate",
-        60 * 60_1000,
-        () => {
-            if (totalOperationalHoursAttribute === undefined) return;
-            totalOperationalHoursAttribute.setLocal(totalOperationalHoursAttribute.getLocal() + 1);
-        },
-    );
-
-    const network = Network.get();
-    const interfaces = await network.getNetInterfaces();
-    const interfaceDetails = new Array<NetworkInterfaceDetailed>();
-    for (const { name, type } of interfaces) {
-        const details = await network.getIpMac(name);
-        if (details !== undefined) {
-            interfaceDetails.push({ name, type, ...details });
-        }
-    }
-
-    return {
-        initializeClusterServer: ({ attributes: { totalOperationalHours, networkInterfaces } }) => {
-            bootUpTime = Time.nowMs();
-            if (totalOperationalHours?.getLocal() !== undefined) {
-                totalOperationalHoursAttribute = totalOperationalHours;
-                totalOperationalHoursUpdateTimer.start();
-            }
-
-            // Filter all unassigned MACs out, sort operational on top, limit to 8 entries and map to the required format.
-            networkInterfaces.setLocal(
-                interfaceDetails
-                    .filter(({ mac }) => mac !== "00:00:00:00:00:00")
-                    .slice(0, 8)
-                    .map(({ name, mac, ipV4, ipV6, type }) => ({
-                        name: name.substring(0, 32),
-                        isOperational: true,
-                        offPremiseServicesReachableIPv4: null, // null means unknown or not supported
-                        offPremiseServicesReachableIPv6: null, // null means unknown or not supported
-                        hardwareAddress: Bytes.fromHex(mac.replace(/[^\da-f]/gi, "")),
-                        iPv4Addresses: ipV4.slice(0, 4).map(ip => ipv4ToBytes(ip)),
-                        iPv6Addresses: ipV6.slice(0, 8).map(ip => ipv6ToBytes(ip)),
-                        type: type ?? GeneralDiagnostics.InterfaceType.Ethernet,
-                    })),
-            );
-        },
-
-        destroyClusterServer: () => {
-            totalOperationalHoursUpdateTimer.stop();
-        },
-
-        upTimeAttributeGetter: () => {
-            return Math.round((Time.nowMs() - bootUpTime) / 1000);
-        },
-
-        testEventTrigger: () => {},
-        timeSnapshot: () => {
-            throw new NotImplementedError();
-        },
-    };
-};
-
-export const createDefaultGeneralDiagnosticsClusterServer = async (commandHandler: NamedHandler<any>) =>
-    ClusterServer(
-        GeneralDiagnosticsCluster,
-        {
-            networkInterfaces: [],
-            rebootCount: 0,
-            upTime: 0,
-            totalOperationalHours: 0,
-            bootReason: GeneralDiagnostics.BootReason.Unspecified,
-            activeHardwareFaults: [],
-            activeRadioFaults: [],
-            activeNetworkFaults: [],
-            testEventTriggersEnabled: false,
-        },
-        WrapCommandHandler(await GeneralDiagnosticsClusterHandler(), commandHandler),
-        {
-            bootReason: true,
-        },
-    );

package/src/cluster/server/GroupKeyManagementServer.ts

@@ -1,72 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { GroupKeyManagement } from "#clusters";
-import { ImplementationError } from "#general";
-import { assertSecureSession } from "#protocol";
-import { StatusCode, StatusResponseError } from "#types";
-import { ClusterServerHandlers } from "./ClusterServerTypes.js";
-
-export const GroupKeyManagementClusterHandler: () => ClusterServerHandlers<typeof GroupKeyManagement.Cluster> = () => ({
-    initializeClusterServer: ({ attributes: { maxGroupKeysPerFabric, maxGroupsPerFabric } }) => {
-        if (maxGroupKeysPerFabric.getLocal() !== 1) {
-            throw new ImplementationError("maxGroupKeysPerFabric must be 1 for now.");
-        }
-        if (maxGroupsPerFabric.getLocal() !== 0) {
-            throw new ImplementationError("maxGroupsPerFabric must be 0 for now.");
-        }
-    },
-
-    groupTableAttributeGetter: () => {
-        return []; // List is always empty because only IPK exists
-    },
-
-    keySetWrite: async () => {
-        throw new StatusResponseError(
-            "We do not support additional groups beyond the IPK",
-            StatusCode.ResourceExhausted,
-        );
-    },
-
-    keySetRead: async ({ request: { groupKeySetId }, session }) => {
-        assertSecureSession(session);
-        const fabric = session.associatedFabric;
-
-        const groupKeySet = fabric.getGroupKeySet(groupKeySetId);
-        if (groupKeySet === undefined) {
-            throw new StatusResponseError(`GroupKeySet ${groupKeySetId} not found`, StatusCode.NotFound);
-        }
-
-        return {
-            groupKeySet: {
-                ...groupKeySet,
-                epochKey0: null,
-                epochKey1: null,
-                epochKey2: null,
-            },
-        };
-    },
-
-    keySetRemove: async ({ request: { groupKeySetId } }) => {
-        if (groupKeySetId === 0) {
-            throw new StatusResponseError(`GroupKeySet ${groupKeySetId} cannot be removed`, StatusCode.InvalidCommand);
-        }
-
-        // We only have key 0, so we can't remove it
-        throw new StatusResponseError(`GroupKeySet ${groupKeySetId} not found`, StatusCode.NotFound);
-    },
-
-    keySetReadAllIndices: async ({ session }) => {
-        assertSecureSession(session);
-        const fabric = session.associatedFabric;
-
-        const groupKeySetIDs = fabric.getAllGroupKeySets().map(({ groupKeySetId }) => groupKeySetId);
-
-        return {
-            groupKeySetIDs,
-        };
-    },
-});

package/src/cluster/server/GroupsServer.ts

@@ -1,174 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { GroupsCluster, IdentifyCluster } from "#clusters";
-import { assertSecureSession, Fabric } from "#protocol";
-import { GroupId, StatusCode } from "#types";
-import { ClusterServer } from "./ClusterServer.js";
-import { ClusterServerHandlers } from "./ClusterServerTypes.js";
-
-/*
-TODO: If the Scenes server cluster is implemented on the same endpoint, the following extension field SHALL
-      be added to the Scene Table:
-      * OnOff
- */
-
-export class GroupsManager {
-    static async setGroup(fabric: Fabric, endpointId: number, groupId: GroupId, groupName: string) {
-        let endpointGroups = fabric.getScopedClusterDataValue<Map<GroupId, string>>(
-            GroupsCluster,
-            endpointId.toString(),
-        );
-        if (endpointGroups === undefined) {
-            endpointGroups = new Map<GroupId, string>();
-        }
-        endpointGroups.set(groupId, groupName || "");
-
-        await fabric.setScopedClusterDataValue(GroupsCluster, endpointId.toString(), endpointGroups);
-    }
-
-    static getGroupName(fabric: Fabric, endpointId: number, groupId: GroupId): string | undefined {
-        const endpointGroups = fabric.getScopedClusterDataValue<Map<GroupId, string>>(
-            GroupsCluster,
-            endpointId.toString(),
-        );
-        return endpointGroups?.get(groupId);
-    }
-
-    static hasGroup(fabric: Fabric, endpointId: number, groupId: GroupId): boolean {
-        const endpointGroups = fabric.getScopedClusterDataValue<Map<GroupId, string>>(
-            GroupsCluster,
-            endpointId.toString(),
-        );
-        return endpointGroups?.has(groupId) ?? false;
-    }
-
-    static getGroups(fabric: Fabric, endpointId: number): Map<GroupId, string> {
-        return (
-            fabric.getScopedClusterDataValue<Map<GroupId, string>>(GroupsCluster, endpointId.toString()) ??
-            new Map<GroupId, string>()
-        );
-    }
-
-    static async removeGroup(fabric: Fabric, endpointId: number, groupId: GroupId): Promise<boolean> {
-        const endpointGroups = fabric.getScopedClusterDataValue<Map<GroupId, string>>(
-            GroupsCluster,
-            endpointId.toString(),
-        );
-        if (endpointGroups !== undefined) {
-            if (endpointGroups.delete(groupId)) {
-                await fabric.persist(false); // persist scoped cluster data changes
-                return true;
-            }
-        }
-        return false;
-    }
-
-    static async removeAllGroups(fabric: Fabric, endpointId: number) {
-        await fabric.deleteScopedClusterDataValue(GroupsCluster, endpointId.toString());
-    }
-}
-
-export const GroupsClusterHandler: () => ClusterServerHandlers<typeof GroupsCluster> = () => {
-    const addGroupLogic = async (groupId: GroupId, groupName: string, fabric: Fabric, endpointId: number) => {
-        if (groupId < 1) {
-            return { status: StatusCode.ConstraintError, groupId };
-        }
-        if (groupName.length > 16) {
-            return { status: StatusCode.ConstraintError, groupId };
-        }
-
-        await GroupsManager.setGroup(fabric, endpointId, groupId, groupName);
-
-        return { status: StatusCode.Success, groupId };
-    };
-
-    return {
-        addGroup: async ({ request: { groupId, groupName }, session, endpoint }) => {
-            assertSecureSession(session);
-            return addGroupLogic(groupId, groupName, session.associatedFabric, endpoint.getNumber());
-        },
-
-        viewGroup: async ({ request: { groupId }, session, endpoint }) => {
-            if (groupId < 1) {
-                return { status: StatusCode.ConstraintError, groupId, groupName: "" };
-            }
-
-            assertSecureSession(session);
-            const groupName = GroupsManager.getGroupName(session.associatedFabric, endpoint.getNumber(), groupId);
-            if (groupName !== undefined) {
-                return { status: StatusCode.Success, groupId, groupName: groupName };
-            }
-            return { status: StatusCode.NotFound, groupId, groupName: "" };
-        },
-
-        getGroupMembership: async ({ request: { groupList }, session, endpoint }) => {
-            // TODO Later:
-            //  Zigbee: If the total number of groups will cause the maximum payload length of a frame to be exceeded,
-            //  then the GroupList field SHALL contain only as many groups as will fit.
-
-            assertSecureSession(session);
-            const endpointGroups = GroupsManager.getGroups(session.associatedFabric, endpoint.getNumber());
-            const fabricGroupsList = Array.from(endpointGroups.keys());
-            const capacity = fabricGroupsList.length < 0xff ? 0xfe - fabricGroupsList.length : 0;
-            if (groupList.length === 0) {
-                return { capacity, groupList: fabricGroupsList };
-            }
-            const filteredGroupsList = groupList.filter(groupId => endpointGroups.get(groupId));
-            if (filteredGroupsList.length === 0) {
-                return { capacity, groupList: [] };
-            }
-            return { capacity, groupList: filteredGroupsList };
-        },
-
-        removeGroup: async ({ request: { groupId }, session, endpoint }) => {
-            if (groupId < 1) {
-                return { status: StatusCode.ConstraintError, groupId };
-            }
-
-            assertSecureSession(session);
-            if (await GroupsManager.removeGroup(session.associatedFabric, endpoint.getNumber(), groupId)) {
-                return { status: StatusCode.Success, groupId };
-            }
-            return { status: StatusCode.NotFound, groupId };
-        },
-
-        removeAllGroups: async ({ session, endpoint }) => {
-            assertSecureSession(session);
-            const fabric = session.associatedFabric;
-            await GroupsManager.removeAllGroups(fabric, endpoint.getNumber());
-
-            return;
-        },
-
-        addGroupIfIdentifying: async ({ request: { groupId, groupName }, session, endpoint }) => {
-            const identifyCluster = endpoint.getClusterServer(IdentifyCluster);
-            if (identifyCluster) {
-                if (identifyCluster.attributes.identifyTime.getLocal() > 0) {
-                    // We identify ourselves currently
-                    assertSecureSession(session);
-                    await addGroupLogic(groupId, groupName, session.associatedFabric, endpoint.getNumber());
-                }
-            }
-
-            // TODO If the AddGroupIfIdentifying command was received as unicast and the evaluated status is not SUCCESS, or
-            //      if the AddGroupIfIdentifying command was received as unicast and the evaluated status is SUCCESS and a
-            //      response is not suppressed, the server SHALL generate a response with the Status field set to the
-            //      evaluated status.
-        },
-    };
-};
-
-export const createDefaultGroupsClusterServer = () =>
-    ClusterServer(
-        GroupsCluster,
-        {
-            nameSupport: {
-                nameSupport: true,
-            },
-        },
-        GroupsClusterHandler(),
-    );

package/src/cluster/server/IdentifyServer.ts

@@ -1,18 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Identify, IdentifyCluster } from "#clusters";
-import { ClusterServer } from "./ClusterServer.js";
-import { ClusterServerHandlers } from "./ClusterServerTypes.js";
-
-export const createDefaultIdentifyClusterServer = (handlers: ClusterServerHandlers<typeof IdentifyCluster>) =>
-    ClusterServer(
-        IdentifyCluster,
-        {
-            identifyTime: 0,
-            identifyType: Identify.IdentifyType.None,
-        },
-        handlers,
-    );