@matter/node 0.16.0-alpha.0-20251003-dc6d5523d → 0.16.0-alpha.0-20251004-92135c7df

package/src/behavior/system/commissioning/CommissioningClient.ts

@@ -8,8 +8,10 @@ import { Behavior } from "#behavior/Behavior.js";
 import { Events as BaseEvents } from "#behavior/Events.js";
 import { OperationalCredentialsClient } from "#behaviors/operational-credentials";
 import {
+    Diagnostic,
     Duration,
     ImplementationError,
+    Logger,
     NotImplementedError,
     Observable,
     ServerAddress,
@@ -45,6 +47,8 @@ import { ControllerBehavior } from "../controller/ControllerBehavior.js";
 import { NetworkClient } from "../network/NetworkClient.js";
 import { RemoteDescriptor } from "./RemoteDescriptor.js";
 
+const logger = Logger.get("CommissioningClient");
+
 /**
  * Client functionality related to commissioning.
  *
@@ -155,6 +159,13 @@ export class CommissioningClient extends Behavior {
         network.state.startupSubscription = opts.startupSubscription;
         network.state.caseAuthenticatedTags = opts.caseAuthenticatedTags;
 
+        logger.notice(
+            "Commissioned",
+            Diagnostic.strong(this.endpoint.id),
+            "as",
+            Diagnostic.strong(this.endpoint.identity),
+        );
+
         node.lifecycle.commissioned.emit(this.context);
 
         await node.start();
@@ -177,11 +188,22 @@ export class CommissioningClient extends Behavior {
             throw new ImplementationError("Cannot decommission node that is not commissioned");
         }
 
+        const formerAddress = PeerAddress(peerAddress).toString();
+
         const opcreds = this.agent.get(OperationalCredentialsClient);
 
         await opcreds.removeFabric({ fabricIndex: opcreds.state.currentFabricIndex });
 
         this.state.peerAddress = undefined;
+
+        await this.context.transaction.commit();
+
+        logger.info(
+            "Decommissioned",
+            Diagnostic.strong(this.endpoint.id),
+            "formerly",
+            Diagnostic.strong(formerAddress),
+        );
     }
 
     /**

package/src/endpoint/Endpoint.ts

@@ -24,6 +24,7 @@ import { DataModelPath } from "#model";
 import type { Node } from "#node/Node.js";
 import { IdentityService } from "#node/server/IdentityService.js";
 import { ProtocolService } from "#node/server/ProtocolService.js";
+import { Val } from "#protocol";
 import { EndpointNumber } from "#types";
 import { RootEndpoint } from "../endpoints/root.js";
 import { Agent } from "./Agent.js";
@@ -170,14 +171,28 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
         return this.#stateView;
     }
 
+    /**
+     * Current state for a specific behavior ID.
+     */
+    stateOf(type: string): Immutable<Val.Struct>;
+
     /**
      * Current state for a specific behavior.
      */
-    stateOf<T extends Behavior.Type>(type: T) {
-        if (!this.behaviors.has(type)) {
-            throw new ImplementationError(`Behavior ${type.id} is not supported by ${this}`);
+    stateOf<T extends Behavior.Type>(type: T): Immutable<Behavior.StateOf<T>>;
+
+    stateOf(type: Behavior.Type | string) {
+        if (typeof type === "string") {
+            if (!(type in this.#stateView)) {
+                throw new ImplementationError(`Behavior ${type} is not supported by ${this}`);
+            }
+        } else {
+            if (!this.behaviors.has(type)) {
+                throw new ImplementationError(`Behavior ${type.id} is not supported by ${this}`);
+            }
+            type = type.id;
         }
-        return (this.#stateView as Record<string, unknown>)[type.id] as Immutable<Behavior.StateOf<T>>;
+        return (this.#stateView as Record<string, unknown>)[type];
     }
 
     /**
@@ -719,20 +734,28 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
      * Path identifying the endpoint in the Matter data model.
      */
     get path(): DataModelPath {
-        let ident;
+        if (this.#owner) {
+            return this.#owner.path.at(this.identity, this.#type.name);
+        }
+
+        return DataModelPath(this.identity, this.type?.name);
+    }
+
+    /**
+     * Diagnostic identity.
+     *
+     * This is an unqualified path segment.
+     */
+    get identity() {
         if (this.lifecycle?.hasId) {
-            ident = this.id;
-        } else if (this.lifecycle?.hasNumber) {
-            ident = this.number;
-        } else {
-            ident = "?";
+            return this.id;
         }
 
-        if (this.#owner) {
-            return this.#owner.path.at(ident, this.#type.name);
+        if (this.lifecycle?.hasNumber) {
+            return this.number;
         }
 
-        return DataModelPath(ident, this.type?.name);
+        return "?";
     }
 
     /**

package/src/endpoint/properties/Behaviors.ts

@@ -19,6 +19,7 @@ import {
     describeList,
     Diagnostic,
     EventEmitter,
+    Immutable,
     ImplementationError,
     Lifecycle,
     Logger,
@@ -557,6 +558,14 @@ export class Behaviors {
         return elements;
     }
 
+    /**
+     * Access the state view of a behavior if loaded.
+     */
+    maybeStateOf(behaviorId: string): Immutable<Val.Struct> | undefined {
+        const backing = this.#backings[behaviorId];
+        return backing?.maybeDatasource?.view;
+    }
+
     [Symbol.iterator]() {
         return Object.values(this.#supported)[Symbol.iterator]();
     }

package/src/node/ClientNode.ts

@@ -11,8 +11,8 @@ import { NetworkClient } from "#behavior/system/network/NetworkClient.js";
 import { NetworkRuntime } from "#behavior/system/network/NetworkRuntime.js";
 import { Agent } from "#endpoint/Agent.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
-import { Identity, Lifecycle, MaybePromise } from "#general";
-import { Interactable, OccurrenceManager } from "#protocol";
+import { Diagnostic, Identity, Lifecycle, Logger, MaybePromise } from "#general";
+import { Interactable, OccurrenceManager, PeerAddress } from "#protocol";
 import { ClientNodeStore } from "#storage/client/ClientNodeStore.js";
 import { RemoteWriter } from "#storage/client/RemoteWriter.js";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
@@ -22,6 +22,8 @@ import { ClientNodeInteraction } from "./client/ClientNodeInteraction.js";
 import { Node } from "./Node.js";
 import type { ServerNode } from "./ServerNode.js";
 
+const logger = Logger.get("ClientNode");
+
 /**
  * A remote Matter {@link Node}.
  *
@@ -188,6 +190,30 @@ export class ClientNode extends Node<ClientNode.RootEndpoint> {
 
         return this.#interaction;
     }
+
+    override get identity() {
+        // If commissioned, use the peer address for logging purposes
+        let address = this.behaviors.maybeStateOf("commissioning")?.peerAddress as PeerAddress | undefined;
+
+        // During early initialization commissioning state may not be loaded, so check directly in storage too
+        if (!address) {
+            address = this.env.get(ClientNodeStore).storeForEndpoint(this).peerAddress as PeerAddress | undefined;
+        }
+
+        // Use the peer address as a log identifier if present
+        if (address) {
+            return PeerAddress(address).toString();
+        }
+
+        // Fall back to persistence ID
+        return super.identity;
+    }
+
+    protected override statusUpdate(message: string): void {
+        // Log client node status updates as info rather than notice and change the log facility to make clear it's a
+        // client
+        logger.info(Diagnostic.strong(this.toString()), message);
+    }
 }
 
 export namespace ClientNode {

package/src/storage/client/ClientEndpointStore.ts

@@ -26,6 +26,13 @@ export class ClientEndpointStore extends EndpointStore {
         return this.#number;
     }
 
+    /**
+     * Shortcut to persisted peer address so we can use in logging prior to full initialization.
+     */
+    get peerAddress() {
+        return this.initialValues.get("commissioning")?.["peerAddress"];
+    }
+
     participantFor(transaction: Transaction) {
         let participant = transaction.getParticipant(this.#owner);
         if (participant === undefined) {