@matter/node 0.16.0-alpha.0-20251020-3f6e46245 → 0.16.0-alpha.0-20251022-5a69ce65a

package/src/behavior/system/controller/ControllerBehavior.ts

@@ -6,14 +6,14 @@
 
 import { Behavior } from "#behavior/Behavior.js";
 import { BasicInformationBehavior } from "#behaviors/basic-information";
-import { ConnectionlessTransportSet, ImplementationError } from "#general";
+import { ConnectionlessTransportSet, ImplementationError, Logger } from "#general";
 import { Node } from "#node/Node.js";
 import {
     Ble,
     ClientSubscriptions,
     Fabric,
     FabricAuthority,
-    FabricAuthorityConfigurationProvider,
+    FabricAuthorityConfiguration,
     FabricManager,
     MdnsClient,
     MdnsScannerTargetCriteria,
@@ -21,13 +21,15 @@ import {
     Scanner,
     ScannerSet,
 } from "#protocol";
-import { FabricId } from "@matter/types";
+import { CaseAuthenticatedTag, FabricId, NodeId } from "#types";
 import type { CommissioningClient } from "../commissioning/CommissioningClient.js";
 import { CommissioningServer } from "../commissioning/CommissioningServer.js";
 import { NetworkServer } from "../network/NetworkServer.js";
 import { ActiveDiscoveries } from "./discovery/ActiveDiscoveries.js";
 import type { Discovery } from "./discovery/Discovery.js";
 
+const logger = Logger.get("ControllerBehavior");
+
 /**
  * Node controller functionality.
  *
@@ -44,10 +46,8 @@ export class ControllerBehavior extends Behavior {
 
     override async initialize() {
         if (this.state.adminFabricLabel === undefined || this.state.adminFabricLabel === "") {
-            throw new ImplementationError("adminFabricLabel must be set for ControllerBehavior.");
+            throw new ImplementationError("adminFabricLabel must be set for ControllerBehavior");
         }
-        const adminFabricLabel = this.state.adminFabricLabel;
-        const adminFabricId = this.state.adminFabricId;
 
         // Configure discovery transports
         if (this.state.ip === undefined) {
@@ -61,28 +61,12 @@ export class ControllerBehavior extends Behavior {
             this.state.ble = (await this.agent.load(NetworkServer)).state.ble;
         }
         if (this.state.ble !== false) {
-            this.env.get(ScannerSet).add(this.env.get(Ble).scanner);
-        }
-
-        // Configure management of controlled fabrics
-        if (!this.env.has(FabricAuthorityConfigurationProvider)) {
-            const biState = this.endpoint.stateOf(BasicInformationBehavior);
-            this.env.set(
-                FabricAuthorityConfigurationProvider,
-                new (class extends FabricAuthorityConfigurationProvider {
-                    get vendorId() {
-                        return biState.vendorId;
-                    }
-
-                    override get adminFabricLabel() {
-                        return adminFabricLabel;
-                    }
-
-                    get fabricId() {
-                        return adminFabricId;
-                    }
-                })(),
-            );
+            try {
+                this.env.get(ScannerSet).add(this.env.get(Ble).scanner);
+            } catch (error) {
+                logger.error("Disabling BLE due to initialization error:", error);
+                this.state.ble = false;
+            }
         }
 
         // Ensure the fabric authority is fully initialized
@@ -104,6 +88,7 @@ export class ControllerBehavior extends Behavior {
         if (node.lifecycle.isOnline) {
             this.#nodeOnline();
         }
+        this.reactTo(node.lifecycle.goingOffline, this.#nodeGoingOffline);
     }
 
     override async [Symbol.asyncDispose]() {
@@ -112,17 +97,22 @@ export class ControllerBehavior extends Behavior {
         this.env.delete(ScannerSet);
     }
 
+    get fabricAuthorityConfig(): FabricAuthorityConfiguration {
+        const biState = this.endpoint.stateOf(BasicInformationBehavior);
+        return {
+            adminVendorId: biState.vendorId,
+            ...this.state,
+        };
+    }
+
     #nodeOnline() {
         // Configure network connections
         const netTransports = this.env.get(ConnectionlessTransportSet);
         if (this.state.ble) {
+            // no try-catch needed because we already added the scanner in initialize()
             netTransports.add(this.env.get(Ble).centralInterface);
         }
 
-        // Clean up as the node goes offline
-        const node = Node.forEndpoint(this.endpoint);
-        this.reactTo(node.lifecycle.goingOffline, this.#nodeGoingOffline);
-
         // Add each pre-existing fabric to discovery criteria
         const authority = this.env.get(FabricAuthority);
         for (const fabric of authority.fabrics) {
@@ -140,6 +130,21 @@ export class ControllerBehavior extends Behavior {
 
     async #nodeGoingOffline() {
         await this.env.close(ClientSubscriptions);
+
+        // Configure each MDNS scanner with criteria
+        const scanners = this.env.get(ScannerSet);
+        for (const scanner of scanners) {
+            if (scanner instanceof MdnsClient) {
+                scanner.targetCriteriaProviders.delete(this.internal.mdnsTargetCriteria);
+            }
+        }
+        // Clear operational targets
+        this.internal.mdnsTargetCriteria.operationalTargets.length = 0;
+
+        const netTransports = this.env.get(ConnectionlessTransportSet);
+        if (this.state.ble) {
+            netTransports.delete(this.env.get(Ble).centralInterface);
+        }
     }
 
     #enableScanningForFabric(fabric: Fabric) {
@@ -191,5 +196,17 @@ export namespace ControllerBehavior {
          * If not provided, a random FabricId will be generated.
          */
         adminFabricId?: FabricId = undefined;
+
+        /**
+         * Contains the NodeId of the admin node when a defined number needs to be used because special Certificates
+         * are used.
+         * If not provided, a random NodeId will be generated.
+         */
+        adminNodeId?: NodeId = undefined;
+
+        /**
+         * Case Authenticated Tags to be used to commission and connect to devices.
+         */
+        caseAuthenticatedTags?: CaseAuthenticatedTag[] = undefined;
     }
 }

package/src/behavior/system/network/ServerNetworkRuntime.ts

@@ -18,7 +18,6 @@ import {
     UdpInterface,
 } from "#general";
 import type { ServerNode } from "#node/ServerNode.js";
-import { NodePeerAddressStore } from "#node/client/NodePeerAddressStore.js";
 import { InteractionServer } from "#node/server/InteractionServer.js";
 import {
     Advertiser,
@@ -30,7 +29,6 @@ import {
     ExchangeManager,
     MdnsAdvertiser,
     MdnsService,
-    PeerAddressStore,
     PeerSet,
     ScannerSet,
     SecureChannelProtocol,
@@ -294,7 +292,6 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         // Initialize ScannerSet
         this.owner.env.get(ScannerSet).add(mdns.client);
 
-        env.set(PeerAddressStore, new NodePeerAddressStore(owner));
         await env.load(PeerSet);
 
         await this.owner.act(agent => this.owner.lifecycle.online.emit(agent.context));
@@ -327,6 +324,7 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         await env.close(SecureChannelProtocol);
         await env.close(ConnectionlessTransportSet);
         await env.close(InteractionServer);
+        await env.close(PeerSet);
     }
 
     protected override blockNewActivity() {

package/src/behavior/system/subscriptions/SubscriptionsServer.ts

@@ -227,10 +227,10 @@ export class SubscriptionsBehavior extends Behavior {
             const { peerAddress: peerAddressDetails, operationalAddress, subscriptionId } = subscription;
             const peerAddress = PeerAddress(peerAddressDetails);
             if (peerStopList.has(peerAddress)) {
-                logger.debug(`Skip re-establishing former subscription to ${peerAddress}`);
+                logger.debug(`Skip reestablishing former subscription to ${peerAddress}`);
                 continue;
             }
-            logger.debug(`Try to re-establish former subscription ${subscriptionId} to ${peerAddress}`);
+            logger.debug(`Try to reestablish former subscription ${subscriptionId} to ${peerAddress}`);
             if (sessions.getSessionForNode(peerAddress) !== undefined) {
                 logger.debug(`We already have and existing session for peer ${peerAddress}`);
             } else {
@@ -280,7 +280,7 @@ export class SubscriptionsBehavior extends Behavior {
         interactionServer.subscriptionEstablishmentStarted.off(blockHandler);
 
         logger.info(
-            `Re-established ${successfullReEstablishments.length}${successfullReEstablishments.length ? ` (${successfullReEstablishments.join(",")})` : ""} of ${formerSubscriptions.length} former subscriptions successfully`,
+            `Reestablished ${successfullReEstablishments.length}${successfullReEstablishments.length ? ` (${successfullReEstablishments.join(",")})` : ""} of ${formerSubscriptions.length} former subscriptions successfully`,
         );
     }
 }

package/src/endpoint/properties/Endpoints.ts

@@ -8,7 +8,7 @@ import { IndexBehavior } from "#behavior/system/index/IndexBehavior.js";
 import type { Endpoint } from "#endpoint/Endpoint.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
 import type { ImmutableSet } from "#general";
-import { Node } from "#node/Node.js";
+import type { Node } from "#node/Node.js";
 import { StatusResponse } from "#types";
 
 /**

package/src/node/client/Peers.ts

@@ -12,14 +12,12 @@ import { InstanceDiscovery } from "#behavior/system/controller/discovery/Instanc
 import { EndpointContainer } from "#endpoint/properties/EndpointContainer.js";
 import { CancelablePromise, Duration, ImplementationError, Logger, Minutes, Seconds, Time, Timestamp } from "#general";
 import { ClientGroup } from "#node/ClientGroup.js";
-import { InteractionServer } from "#node/index.js";
-import { FabricManager, PeerAddress, PeerAddressStore } from "#protocol";
+import { InteractionServer } from "#node/server/InteractionServer.js";
+import { ClientSubscriptionHandler, ClientSubscriptions, FabricManager, PeerAddress } from "#protocol";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
-import { ClientSubscriptionHandler, ClientSubscriptions } from "@matter/protocol";
 import { ClientNode } from "../ClientNode.js";
 import type { ServerNode } from "../ServerNode.js";
 import { ClientNodeFactory } from "./ClientNodeFactory.js";
-import { NodePeerAddressStore } from "./NodePeerAddressStore.js";
 
 const logger = Logger.get("ClientNodes");
 
@@ -44,8 +42,6 @@ export class Peers extends EndpointContainer<ClientNode> {
             owner.env.set(ClientNodeFactory, new Factory(this));
         }
 
-        this.owner.env.set(PeerAddressStore, new NodePeerAddressStore(owner));
-
         owner.env.applyTo(InteractionServer, this.#configureInteractionServer.bind(this));
 
         this.added.on(this.#handlePeerAdded.bind(this));

package/src/node/server/ServerEnvironment.ts

@@ -7,10 +7,11 @@
 import { limitNodeDataToAllowedFabrics } from "#behavior/cluster/FabricScopedDataHandler.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
 import { Crypto, Observable } from "#general";
+import { NodePeerAddressStore } from "#node/client/NodePeerAddressStore.js";
 import { ChangeNotificationService } from "#node/integration/ChangeNotificationService.js";
 import { ServerEndpointInitializer } from "#node/server/ServerEndpointInitializer.js";
 import type { ServerNode } from "#node/ServerNode.js";
-import { FabricManager, MdnsService, OccurrenceManager, SessionManager } from "#protocol";
+import { FabricManager, MdnsService, OccurrenceManager, PeerAddressStore, SessionManager } from "#protocol";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { IdentityService } from "./IdentityService.js";
 
@@ -25,10 +26,17 @@ export namespace ServerEnvironment {
         const { env } = node;
 
         // Install support services
-        const store = await ServerNodeStore.create(env, node.id);
-        env.set(ServerNodeStore, store);
+        if (!env.has(ServerNodeStore)) {
+            // TODO Remove the "if" once the legacy controller is removed
+            const store = await ServerNodeStore.create(env, node.id);
+            env.set(ServerNodeStore, store);
+        }
         env.set(EndpointInitializer, new ServerEndpointInitializer(env));
         env.set(IdentityService, new IdentityService(node));
+        if (!env.has(PeerAddressStore)) {
+            // TODO Remove the "if" once the legacy controller is removed
+            env.set(PeerAddressStore, new NodePeerAddressStore(node));
+        }
         env.set(ChangeNotificationService, new ChangeNotificationService(node));
 
         // Ensure these are fully initialized