@matter/node 0.14.0 → 0.14.1-alpha.0-20250606-a9bcd03f9

package/src/behaviors/groups/GroupsServer.ts

@@ -4,11 +4,189 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
-
+import { GroupKeyManagementServer } from "#behaviors/group-key-management";
+import { IdentifyBehavior } from "#behaviors/identify";
+import { Groups } from "#clusters/groups";
+import { Endpoint } from "#endpoint/Endpoint.js";
+import { RootEndpoint } from "#endpoints/root";
+import { Logger } from "#general";
+import { AccessLevel } from "#model";
+import {
+    Command,
+    StatusCode,
+    StatusResponseError,
+    TlvField,
+    TlvGroupId,
+    TlvNoResponse,
+    TlvObject,
+    TlvString,
+} from "#types";
+import { InternalError } from "@matter/general";
 import { GroupsBehavior } from "./GroupsBehavior.js";
 
+const logger = Logger.get("GroupsServer");
+
+// We enable group names by default
+const GroupsBase = GroupsBehavior.with(Groups.Feature.GroupNames);
+
+/**
+ * Monkey patching Tlv Structure of addGroup* commands to prevent data validation of the groupName field to be
+ * handled as ConstraintError because we need to return a special error.
+ * We do this to leave the model in fact for other validations and only apply the change for our Schema-aware Tlv parsing.
+ */
+Groups.Cluster.commands = {
+    ...Groups.Cluster.commands,
+    addGroup: Command(
+        0x0,
+        TlvObject({
+            groupId: TlvField(0, TlvGroupId),
+            groupName: TlvField(1, TlvString),
+        }),
+        0x0,
+        Groups.TlvAddGroupResponse,
+        { invokeAcl: AccessLevel.Manage },
+    ),
+    addGroupIfIdentifying: Command(
+        0x5,
+        TlvObject({
+            groupId: TlvField(0, TlvGroupId),
+            groupName: TlvField(1, TlvString),
+        }),
+        0x5,
+        TlvNoResponse,
+        { invokeAcl: AccessLevel.Manage },
+    ),
+};
+
 /**
  * This is the default server implementation of {@link GroupsBehavior}.
  */
-export class GroupsServer extends GroupsBehavior {}
+export class GroupsServer extends GroupsBase {
+    override initialize() {
+        this.state.nameSupport.groupNames = this.features.groupNames;
+    }
+
+    // We need to search the root here ourselves because we cannot include ServerNode because else we generate a
+    // circular dependency
+    #rootEndpoint(): Endpoint<RootEndpoint> {
+        const rootEndpoint = this.endpoint.ownerOfType(RootEndpoint);
+        if (rootEndpoint === undefined) {
+            throw new InternalError("RootEndpoint not found");
+        }
+        return rootEndpoint;
+    }
+
+    #actOnGroupKeyManagement(act: (groupKeyManagement: GroupKeyManagementServer) => unknown) {
+        return this.#rootEndpoint().act(agent => act(agent.get(GroupKeyManagementServer)));
+    }
+
+    override async addGroup({ groupId, groupName }: Groups.AddGroupRequest): Promise<Groups.AddGroupResponse> {
+        const fabric = this.session.associatedFabric;
+
+        if (groupId < 1) {
+            return { status: StatusCode.ConstraintError, groupId };
+        }
+        if (groupName.length > 16) {
+            return { status: StatusCode.ConstraintError, groupId };
+        }
+
+        if (!fabric.groups.groupKeyIdMap.has(groupId)) {
+            return { status: StatusCode.UnsupportedAccess, groupId };
+        }
+
+        const endpointNumber = this.endpoint.number;
+
+        try {
+            await this.#actOnGroupKeyManagement(gkm =>
+                gkm.addEndpointForGroup(fabric, groupId, endpointNumber, groupName),
+            );
+        } catch (error) {
+            logger.error(error);
+            StatusResponseError.accept(error);
+            return { status: error.code, groupId };
+        }
+
+        return { status: StatusCode.Success, groupId };
+    }
+
+    override viewGroup({ groupId }: Groups.ViewGroupRequest): Groups.ViewGroupResponse {
+        const fabric = this.session.associatedFabric;
+
+        if (groupId < 1) {
+            return { status: StatusCode.ConstraintError, groupId, groupName: "" };
+        }
+
+        const fabricIndex = fabric.fabricIndex;
+        const endpointNumber = this.endpoint.number;
+
+        const { groupTable } = this.#rootEndpoint().stateOf(GroupKeyManagementServer);
+        const groupEntry = groupTable.find(entry => entry.groupId === groupId && entry.fabricIndex === fabricIndex);
+        if (groupEntry === undefined || !groupEntry.endpoints.includes(endpointNumber)) {
+            return { status: StatusCode.NotFound, groupId, groupName: "" };
+        }
+        return { status: StatusCode.Success, groupId, groupName: groupEntry.groupName ?? "" };
+    }
+
+    override async getGroupMembership({
+        groupList,
+    }: Groups.GetGroupMembershipRequest): Promise<Groups.GetGroupMembershipResponse> {
+        const fabric = this.session.associatedFabric;
+        const fabricIndex = fabric.fabricIndex;
+        const endpointNumber = this.endpoint.number;
+
+        const { groupTable } = this.#rootEndpoint().stateOf(GroupKeyManagementServer);
+        const endpointGroups = groupTable.filter(
+            entry => entry.endpoints.includes(endpointNumber) && entry.fabricIndex === fabricIndex,
+        );
+        const fabricGroupsList = endpointGroups.map(entry => entry.groupId);
+
+        if (groupList.length === 0) {
+            return { capacity: 0xfe - fabricGroupsList.length, groupList: fabricGroupsList };
+        }
+
+        const filteredGroupsList = groupList.filter(groupId => fabricGroupsList.includes(groupId));
+        return { capacity: 0xfe - fabricGroupsList.length, groupList: filteredGroupsList };
+    }
+
+    override async removeGroup({ groupId }: Groups.RemoveGroupRequest): Promise<Groups.RemoveGroupResponse> {
+        if (groupId < 1) {
+            return { status: StatusCode.ConstraintError, groupId };
+        }
+
+        try {
+            if (
+                await this.#actOnGroupKeyManagement(gkm =>
+                    gkm.removeEndpoint(this.session.associatedFabric, this.endpoint.number, groupId),
+                )
+            ) {
+                return { status: StatusCode.Success, groupId };
+            }
+            return { status: StatusCode.NotFound, groupId };
+        } catch (error) {
+            StatusResponseError.accept(error);
+            return { status: error.code, groupId };
+        }
+    }
+
+    // TODO ScenesManagement cluster is also affected by this command
+    override async removeAllGroups() {
+        try {
+            await this.#actOnGroupKeyManagement(gkm =>
+                gkm.removeEndpoint(this.session.associatedFabric, this.endpoint.number),
+            );
+        } catch (error) {
+            StatusResponseError.accept(error);
+            throw error;
+        }
+    }
+
+    override async addGroupIfIdentifying({ groupId, groupName }: Groups.AddGroupIfIdentifyingRequest) {
+        if (this.endpoint.stateOf(IdentifyBehavior).identifyTime > 0) {
+            // We identify ourselves currently
+            const { status } = await this.addGroup({ groupId, groupName });
+            if (status !== StatusCode.Success) {
+                throw new StatusResponseError(`Failed to add group ${groupId}`, status);
+            }
+        }
+    }
+}

package/src/behaviors/level-control/LevelControlServer.ts

@@ -4,17 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Behavior } from "#behavior/Behavior.js";
 import { ActionContext } from "#behavior/context/ActionContext.js";
-import { Behavior } from "#behavior/index.js";
 import { Transitions } from "#behavior/Transitions.js";
 import { ColorControlServer } from "#behaviors/color-control";
 import { GeneralDiagnosticsBehavior } from "#behaviors/general-diagnostics";
 import { OnOffServer } from "#behaviors/on-off";
 import { GeneralDiagnostics } from "#clusters/general-diagnostics";
 import { LevelControl } from "#clusters/level-control";
-import { Endpoint } from "#endpoint/index.js";
-import { RootEndpoint } from "#endpoints/root";
+import { Endpoint } from "#endpoint/Endpoint.js";
 import { AsyncObservable, Logger, MaybePromise } from "#general";
+import { ServerNode } from "#node/ServerNode.js";
 import { Val } from "#protocol";
 import { ClusterType, StatusCode, StatusResponseError, TypeFromPartialBitSchema } from "#types";
 import { LevelControlBehavior } from "./LevelControlBehavior.js";
@@ -572,8 +572,8 @@ export class LevelControlBaseServer extends LevelControlBase {
     }
 
     #getBootReason() {
-        const rootEndpoint = this.endpoint.ownerOfType(RootEndpoint);
-        if (rootEndpoint !== undefined && rootEndpoint.behaviors.has(GeneralDiagnosticsBehavior)) {
+        const rootEndpoint = this.env.get(ServerNode);
+        if (rootEndpoint.behaviors.has(GeneralDiagnosticsBehavior)) {
             return rootEndpoint.stateOf(GeneralDiagnosticsBehavior).bootReason;
         }
     }

package/src/behaviors/mode-select/ModeSelectServer.ts

@@ -9,8 +9,8 @@ import { OnOffServer } from "#behaviors/on-off";
 import { GeneralDiagnostics } from "#clusters/general-diagnostics";
 import { ModeSelect } from "#clusters/mode-select";
 import { OnOff } from "#clusters/on-off";
-import { RootEndpoint } from "#endpoints/root";
 import { Logger, MaybePromise } from "#general";
+import { ServerNode } from "#node/ServerNode.js";
 import { ClusterType, StatusCode, StatusResponseError } from "#types";
 import { ModeSelectBehavior } from "./ModeSelectBehavior.js";
 
@@ -101,8 +101,8 @@ export class ModeSelectBaseServer extends ModeSelectBase {
     }
 
     #getBootReason() {
-        const rootEndpoint = this.endpoint.ownerOfType(RootEndpoint);
-        if (rootEndpoint !== undefined && rootEndpoint.behaviors.has(GeneralDiagnosticsBehavior)) {
+        const rootEndpoint = this.env.get(ServerNode);
+        if (rootEndpoint.behaviors.has(GeneralDiagnosticsBehavior)) {
             return rootEndpoint.stateOf(GeneralDiagnosticsBehavior).bootReason;
         }
     }

package/src/behaviors/on-off/OnOffServer.ts

@@ -7,8 +7,8 @@
 import { GeneralDiagnosticsBehavior } from "#behaviors/general-diagnostics";
 import { GeneralDiagnostics } from "#clusters/general-diagnostics";
 import { OnOff } from "#clusters/on-off";
-import { RootEndpoint } from "#endpoints/root";
 import { MaybePromise, Time, Timer } from "#general";
+import { ServerNode } from "#node/ServerNode.js";
 import { OnOffBehavior } from "./OnOffBehavior.js";
 
 const OnOffLogicBase = OnOffBehavior.with(OnOff.Feature.Lighting);
@@ -187,8 +187,8 @@ export class OnOffBaseServer extends OnOffLogicBase {
     }
 
     #getBootReason() {
-        const rootEndpoint = this.endpoint.ownerOfType(RootEndpoint);
-        if (rootEndpoint !== undefined && rootEndpoint.behaviors.has(GeneralDiagnosticsBehavior)) {
+        const rootEndpoint = this.env.get(ServerNode);
+        if (rootEndpoint.behaviors.has(GeneralDiagnosticsBehavior)) {
             return rootEndpoint.stateOf(GeneralDiagnosticsBehavior).bootReason;
         }
     }

package/src/behaviors/operational-credentials/OperationalCredentialsServer.ts

@@ -15,7 +15,6 @@ import { CryptoVerifyError, Logger, MatterFlowError, MaybePromise, UnexpectedDat
 import { AccessLevel } from "#model";
 import type { Node } from "#node/Node.js";
 import {
-    assertSecureSession,
     CertificateError,
     DeviceCertification,
     DeviceCommissioner,
@@ -25,6 +24,7 @@ import {
     FabricTableFullError,
     MatterFabricConflictError,
     MatterFabricInvalidAdminSubjectError,
+    NodeSession,
     PublicKeyError,
     TlvAttestation,
     TlvCertSigningRequest,
@@ -101,6 +101,9 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
 
         const certification = await this.getCertification();
 
+        const session = this.session;
+        NodeSession.assert(session);
+
         const elements = TlvAttestation.encode({
             declaration: certification.declaration,
             attestationNonce: attestationNonce,
@@ -108,7 +111,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
         });
         return {
             attestationElements: elements,
-            attestationSignature: await certification.sign(this.session, elements),
+            attestationSignature: await certification.sign(session, elements),
         };
     }
 
@@ -117,7 +120,9 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             throw new StatusResponseError("Invalid csr nonce length", StatusCode.InvalidCommand);
         }
 
-        if (isForUpdateNoc && this.session.isPase) {
+        const session = this.session;
+        NodeSession.assert(session);
+        if (isForUpdateNoc && session.isPase) {
             throw new StatusResponseError(
                 "csrRequest for UpdateNoc received on a PASE session",
                 StatusCode.InvalidCommand,
@@ -140,7 +145,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             this.session.id,
         );
         const nocsrElements = TlvCertSigningRequest.encode({ certSigningRequest, csrNonce });
-        return { nocsrElements, attestationSignature: await certification.sign(this.session, nocsrElements) };
+        return { nocsrElements, attestationSignature: await certification.sign(session, nocsrElements) };
     }
 
     override async certificateChainRequest({ certificateType }: OperationalCredentials.CertificateChainRequest) {
@@ -264,12 +269,15 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             targets: null, // entire node
         });
 
+        const session = this.session;
+        NodeSession.assert(session);
+
         await failsafeContext.addFabric(fabric);
 
         try {
-            if (this.session.isPase) {
-                logger.debug(`Add Fabric ${fabric.fabricIndex} to PASE session ${this.session.name}`);
-                this.session.addAssociatedFabric(fabric);
+            if (session.isPase) {
+                logger.debug(`Add Fabric ${fabric.fabricIndex} to PASE session ${session.name}`);
+                session.addAssociatedFabric(fabric);
             }
 
             // Update attributes
@@ -282,7 +290,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             }
         } catch (e) {
             // Fabric insertion into FabricManager is not currently transactional so we need to remove manually
-            await fabric.remove(this.session.id);
+            await fabric.remove(session.id);
             throw e;
         }
 
@@ -302,7 +310,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
     }
 
     override async updateNoc({ nocValue, icacValue }: OperationalCredentials.UpdateNocRequest) {
-        assertSecureSession(this.session);
+        NodeSession.assert(this.session);
 
         const timedOp = this.#failsafeContext;
 

package/src/endpoint/Endpoint.ts

@@ -124,7 +124,7 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
      */
     ownerOfType<T extends EndpointType.Empty>(type: T): Endpoint<T> | undefined {
         for (let endpoint: Endpoint | undefined = this; endpoint !== undefined; endpoint = endpoint.owner) {
-            if (endpoint.type.deviceClass === type.deviceClass) {
+            if (endpoint.type.deviceType === type.deviceType) {
                 return endpoint as Endpoint<T>;
             }
         }

package/src/node/Node.ts

@@ -10,8 +10,8 @@ import { IndexBehavior } from "#behavior/system/index/IndexBehavior.js";
 import { NetworkRuntime } from "#behavior/system/network/NetworkRuntime.js";
 import { PartsBehavior } from "#behavior/system/parts/PartsBehavior.js";
 import { Endpoint } from "#endpoint/Endpoint.js";
-import { MutableEndpoint } from "#endpoint/index.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
+import { MutableEndpoint } from "#endpoint/type/MutableEndpoint.js";
 import {
     Construction,
     Diagnostic,

package/src/node/ServerNode.ts

@@ -12,7 +12,7 @@ import { NetworkServer } from "#behavior/system/network/NetworkServer.js";
 import { ServerNetworkRuntime } from "#behavior/system/network/ServerNetworkRuntime.js";
 import { ProductDescriptionServer } from "#behavior/system/product-description/ProductDescriptionServer.js";
 import { SessionsBehavior } from "#behavior/system/sessions/SessionsBehavior.js";
-import { SubscriptionBehavior } from "#behavior/system/subscription/index.js";
+import { SubscriptionBehavior } from "#behavior/system/subscription/SubscriptionBehavior.js";
 import { Endpoint } from "#endpoint/Endpoint.js";
 import type { Environment } from "#general";
 import { Construction, DiagnosticSource, Identity, MatterError, asyncNew, errorOf } from "#general";

package/src/node/client/NodePeerAddressStore.ts

@@ -5,7 +5,7 @@
  */
 
 import { RemoteDescriptor } from "#behavior/system/commissioning/RemoteDescriptor.js";
-import { ClientNode } from "#node/ClientNode.js";
+import type { ClientNode } from "#node/ClientNode.js";
 import { IdentityService } from "#node/server/IdentityService.js";
 import type { ServerNode } from "#node/ServerNode.js";
 import { OperationalPeer, PeerAddress, PeerAddressMap, PeerAddressStore } from "#protocol";

package/src/node/server/InteractionServer.ts

@@ -5,7 +5,7 @@
  */
 
 import { NodeActivity } from "#behavior/context/NodeActivity.js";
-import { OnlineContext } from "#behavior/index.js";
+import { OnlineContext } from "#behavior/context/server/OnlineContext.js";
 import { AccessControlServer } from "#behaviors/access-control";
 import { AccessControl as AccessControlClusterType } from "#clusters/access-control";
 import {
@@ -20,7 +20,6 @@ import {
 } from "#general";
 import { GLOBAL_IDS, Specification } from "#model";
 import {
-    assertSecureSession,
     DataReport,
     DataReportPayloadIterator,
     ExchangeManager,
@@ -30,10 +29,10 @@ import {
     Message,
     MessageExchange,
     MessageType,
+    NodeSession,
     PeerAddress,
     ProtocolHandler,
     ReadRequest,
-    SecureSession,
     SessionManager,
     SessionType,
     SubscribeRequest,
@@ -474,7 +473,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             );
         }
 
-        assertSecureSession(exchange.session, "Subscriptions are only implemented on secure sessions");
+        NodeSession.assert(exchange.session, "Subscriptions are only implemented on secure sessions");
         const session = exchange.session;
         const fabric = session.fabric;
 
@@ -606,7 +605,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             isFabricFiltered,
         }: SubscribeRequest,
         messenger: InteractionServerMessenger,
-        session: SecureSession,
+        session: NodeSession,
         exchange: MessageExchange,
         message: Message,
     ) {
@@ -660,7 +659,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             maxInterval,
             sendInterval,
         }: PeerSubscription,
-        session: SecureSession,
+        session: NodeSession,
     ) {
         const exchange = this.#context.exchangeManager.initiateExchange(session.peerAddress, INTERACTION_PROTOCOL_ID);
         const message = {} as Message;

package/src/node/server/ServerSubscription.ts

@@ -7,8 +7,8 @@
 import { OnlineContext } from "#behavior/context/server/OnlineContext.js";
 import { Logger, MatterError, NetworkError, NoResponseTimeoutError, ObserverGroup, Time, Timer } from "#general";
 import { Specification } from "#model";
-import { ServerNode } from "#node/index.js";
-import type { AttributeResponseFilter, Message, MessageExchange } from "#protocol";
+import type { ServerNode } from "#node/ServerNode.js";
+import type { AttributeResponseFilter, Message, MessageExchange, NodeSession } from "#protocol";
 import {
     AttributeReadResponse,
     AttributeSubscriptionResponse,
@@ -19,7 +19,6 @@ import {
     PeerAddress,
     Read,
     ReadResult,
-    SecureSession,
     Subscription,
     SubscriptionCriteria,
 } from "#protocol";
@@ -95,7 +94,7 @@ export namespace ServerSubscriptionConfig {
  * Interface between {@link ServerSubscription} and the local Matter environment.
  */
 export interface ServerSubscriptionContext {
-    session: SecureSession;
+    session: NodeSession;
     node: ServerNode;
     initiateExchange(address: PeerAddress, protocolId: number): MessageExchange;
 }