@matter/protocol 0.16.0-alpha.0-20251213-e83db3732 → 0.16.0-alpha.0-20251217-038f88085

package/dist/esm/peer/ControllerCommissioningFlow.js

@@ -3,6 +3,8 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Invoke } from "#action/request/Invoke.js";
+import { Read } from "#action/request/Read.js";
 import { Certificate } from "#certificate/kinds/Certificate.js";
 import { BasicInformation } from "#clusters/basic-information";
 import { Descriptor } from "#clusters/descriptor";
@@ -15,9 +17,9 @@ import {
   ChannelType,
   Diagnostic,
   Duration,
+  ImplementationError,
   Instant,
   Logger,
-  MatterError,
   Millis,
   Minutes,
   repackErrorAs,
@@ -29,10 +31,11 @@ import {
 } from "#general";
 import {
   EndpointNumber,
+  Status,
   StatusResponseError
 } from "#types";
-import { ClusterClient } from "../cluster/client/ClusterClient.js";
 import { TlvCertSigningRequest } from "../common/OperationalCredentialsTypes.js";
+import { CommissioningError } from "./CommissioningError.js";
 const logger = Logger.get("ControllerCommissioner");
 var CommissioningStepResultCode = /* @__PURE__ */ ((CommissioningStepResultCode2) => {
   CommissioningStepResultCode2[CommissioningStepResultCode2["Success"] = 0] = "Success";
@@ -41,8 +44,6 @@ var CommissioningStepResultCode = /* @__PURE__ */ ((CommissioningStepResultCode2
   CommissioningStepResultCode2[CommissioningStepResultCode2["Stop"] = 3] = "Stop";
   return CommissioningStepResultCode2;
 })(CommissioningStepResultCode || {});
-class CommissioningError extends MatterError {
-}
 class MaximumCommissionedFabricsReachedError extends CommissioningError {
 }
 class CommissioningTimeoutError extends CommissioningError {
@@ -59,15 +60,14 @@ class ThreadNetworkSetupFailedError extends CommissioningError {
 }
 class NodeIdConflictError extends CommissioningError {
 }
-class CommissionableDeviceDiscoveryFailedError extends CommissioningError {
-}
 class OperativeConnectionFailedError extends CommissioningError {
 }
 class RecoverableCommissioningError extends CommissioningError {
 }
 const DEFAULT_FAILSAFE_TIME = Minutes.one;
+const RootEndpointNumber = EndpointNumber(0);
 class ControllerCommissioningFlow {
-  interactionClient;
+  interaction;
   ca;
   fabric;
   transitionToCase;
@@ -81,8 +81,8 @@ class ControllerCommissioningFlow {
   lastBreadcrumb = 1;
   collectedCommissioningData = {};
   #defaultFailSafeTime = DEFAULT_FAILSAFE_TIME;
-  constructor(interactionClient, ca, fabric, commissioningOptions, transitionToCase) {
-    this.interactionClient = interactionClient;
+  constructor(interaction, ca, fabric, commissioningOptions, transitionToCase) {
+    this.interaction = interaction;
     this.ca = ca;
     this.fabric = fabric;
     this.transitionToCase = transitionToCase;
@@ -150,24 +150,58 @@ class ControllerCommissioningFlow {
     }
   }
   /**
-   * Helper method to create ClusterClients. If not feature specific and for the Root Endpoint they are also reused.
+   * Convenience method to get a number of attributes in a read and return exactly these values in the order as
+   * defined in the request
    */
-  #getClusterClient(cluster, endpointId = EndpointNumber(0), isFeatureSpecific = false) {
-    if (!isFeatureSpecific && endpointId === 0) {
-      const clusterClient = this.#clusterClients.get(cluster.id);
-      if (clusterClient !== void 0) {
-        logger.debug(
-          `Returning existing cluster client for cluster ${cluster.name} (endpoint ${endpointId}, isFeatureSpecific ${isFeatureSpecific})`
-        );
-        return clusterClient;
+  async #readConcreteAttributeValues(request) {
+    const attributeMap = /* @__PURE__ */ new Map();
+    if (request.attributeRequests === void 0) {
+      throw new ImplementationError("Can only handle Attribute reads");
+    }
+    for (const { endpointId, clusterId, attributeId } of request.attributeRequests) {
+      if (endpointId === void 0 || clusterId === void 0) {
+        continue;
+      }
+      attributeMap.set(`${endpointId}-${clusterId}-${attributeId}`, void 0);
+    }
+    for await (const data of this.interaction.read(request)) {
+      for (const entry of data) {
+        if (entry.kind !== "attr-value") {
+          continue;
+        }
+        const {
+          path: { endpointId, clusterId, attributeId },
+          value
+        } = entry;
+        const key = `${endpointId}-${clusterId}-${attributeId}`;
+        if (!attributeMap.has(key)) {
+          continue;
+        }
+        attributeMap.set(key, value);
+      }
+    }
+    return [...attributeMap.values()];
+  }
+  // TODO improve response typing
+  async #invokeCommand(request, options = {}) {
+    for await (const data of this.interaction.invoke(
+      Invoke({
+        commands: [request],
+        ...options
+      })
+    )) {
+      for (const entry of data) {
+        switch (entry.kind) {
+          case "cmd-status":
+            if (entry.status !== Status.Success) {
+              throw StatusResponseError.create(entry.status, void 0, entry.clusterStatus);
+            }
+            return;
+          case "cmd-response":
+            return entry.data;
+        }
       }
     }
-    logger.debug(
-      `Creating new cluster client for cluster ${cluster.name} (endpoint ${endpointId}, isFeatureSpecific ${isFeatureSpecific})`
-    );
-    const client = ClusterClient(cluster, endpointId, this.interactionClient);
-    this.#clusterClients.set(cluster.id, client);
-    return client;
   }
   /**
    * Initialize commissioning steps and add them in the default order as defined by
@@ -218,7 +252,7 @@ class ControllerCommissioningFlow {
       name: "AccessControl",
       stepLogic: () => this.#configureAccessControlLists()
     });
-    if (this.interactionClient.channelType === ChannelType.BLE) {
+    if (this.interaction.channelType === ChannelType.BLE) {
       this.commissioningSteps.push({
         stepNumber: 16,
         subStepNumber: 1,
@@ -247,7 +281,7 @@ class ControllerCommissioningFlow {
       }
     } else {
       logger.info(
-        `Skipping NetworkCommissioning steps because the device is already on IP network (${this.interactionClient.channelType})`
+        `Skipping NetworkCommissioning steps because the device is already on IP network (${this.interaction.channelType})`
       );
     }
     this.commissioningSteps.push({
@@ -321,49 +355,84 @@ class ControllerCommissioningFlow {
    * Initial Step to receive some common data used by other steps
    */
   async #getInitialData() {
-    const operationalCredentialsClient = this.#getClusterClient(OperationalCredentials.Cluster);
-    const supportedFabrics = await operationalCredentialsClient.getSupportedFabricsAttribute();
-    const commissionedFabrics = await operationalCredentialsClient.getCommissionedFabricsAttribute();
+    const [
+      supportedFabrics,
+      commissionedFabrics,
+      rootPartsList,
+      rootServerList,
+      vendorId,
+      productId,
+      productName,
+      supportsConcurrentConnection
+    ] = await this.#readConcreteAttributeValues(
+      Read(
+        Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: OperationalCredentials.Complete,
+          attributes: ["supportedFabrics", "commissionedFabrics"]
+        }),
+        Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: Descriptor.Complete,
+          attributes: ["partsList", "serverList"]
+        }),
+        Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: BasicInformation.Complete,
+          attributes: ["vendorId", "productId", "productName"]
+        }),
+        Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: GeneralCommissioning.Complete,
+          attributes: ["supportsConcurrentConnection"]
+        })
+      )
+    );
     if (commissionedFabrics >= supportedFabrics) {
       throw new MaximumCommissionedFabricsReachedError(
         `Commissioned fabrics (${commissionedFabrics}) exceed supported fabrics (${supportedFabrics}). Please remove some fabrics before commissioning.`
       );
     }
-    const descriptorClient = this.#getClusterClient(Descriptor.Cluster);
-    this.collectedCommissioningData.rootPartsList = await descriptorClient.getPartsListAttribute();
-    this.collectedCommissioningData.rootServerList = await descriptorClient.getServerListAttribute();
-    const networkData = await this.interactionClient.getMultipleAttributes({
-      attributes: [
-        {
-          clusterId: NetworkCommissioning.Complete.id,
-          attributeId: NetworkCommissioning.Complete.attributes.featureMap.id
-        },
-        {
-          clusterId: NetworkCommissioning.Complete.id,
-          attributeId: NetworkCommissioning.Complete.attributes.networks.id
-        }
-      ]
-    });
+    this.collectedCommissioningData.rootPartsList = rootPartsList;
+    this.collectedCommissioningData.rootServerList = rootServerList;
+    this.collectedCommissioningData.vendorId = vendorId;
+    this.collectedCommissioningData.productId = productId;
+    this.collectedCommissioningData.productName = productName;
+    this.collectedCommissioningData.supportsConcurrentConnection = supportsConcurrentConnection;
+    const networkData = this.interaction.read(
+      Read(
+        Read.Attribute({
+          cluster: NetworkCommissioning.Complete,
+          attributes: ["featureMap", "networks"]
+        })
+      )
+    );
     const networkFeatures = new Array();
     const networkStatus = new Array();
-    for (const {
-      path: { endpointId, attributeId },
-      value
-    } of networkData) {
-      if (attributeId === NetworkCommissioning.Complete.attributes.featureMap.id) {
-        networkFeatures.push({ endpointId, value });
-      } else if (attributeId === NetworkCommissioning.Complete.attributes.networks.id) {
-        networkStatus.push({ endpointId, value });
+    for await (const data of networkData) {
+      for (const entry of data) {
+        if (entry.kind !== "attr-value") {
+          continue;
+        }
+        const {
+          path: { endpointId, attributeId },
+          value
+        } = entry;
+        if (attributeId === NetworkCommissioning.Complete.attributes.featureMap.id) {
+          networkFeatures.push({
+            endpointId,
+            value
+          });
+        } else if (attributeId === NetworkCommissioning.Complete.attributes.networks.id) {
+          networkStatus.push({
+            endpointId,
+            value
+          });
+        }
       }
     }
     this.collectedCommissioningData.networkFeatures = networkFeatures;
     this.collectedCommissioningData.networkStatus = networkStatus;
-    const basicInfoClient = this.#getClusterClient(BasicInformation.Cluster);
-    this.collectedCommissioningData.vendorId = await basicInfoClient.getVendorIdAttribute();
-    this.collectedCommissioningData.productId = await basicInfoClient.getProductIdAttribute();
-    this.collectedCommissioningData.productName = await basicInfoClient.getProductNameAttribute();
-    const generalCommissioningClient = this.#getClusterClient(GeneralCommissioning.Cluster);
-    this.collectedCommissioningData.supportsConcurrentConnection = await generalCommissioningClient.getSupportsConcurrentConnectionAttribute();
     return {
       code: 0 /* Success */,
       breadcrumb: this.lastBreadcrumb
@@ -379,9 +448,16 @@ class ControllerCommissioningFlow {
    * Attribute”) prior to invoking the ArmFailSafe command.
    */
   async #armFailsafe(time) {
-    const client = this.#getClusterClient(GeneralCommissioning.Cluster);
     if (this.collectedCommissioningData.basicCommissioningInfo === void 0) {
-      const basicCommissioningInfo = await client.getBasicCommissioningInfoAttribute();
+      const [basicCommissioningInfo] = await this.#readConcreteAttributeValues(
+        Read(
+          Read.Attribute({
+            endpoint: RootEndpointNumber,
+            cluster: GeneralCommissioning.Complete,
+            attributes: ["basicCommissioningInfo"]
+          })
+        )
+      );
       this.collectedCommissioningData.basicCommissioningInfo = basicCommissioningInfo;
       this.#defaultFailSafeTime = Seconds(basicCommissioningInfo.failSafeExpiryLengthSeconds);
       this.#commissioningStartedTime = Time.nowMs;
@@ -392,9 +468,14 @@ class ControllerCommissioningFlow {
     const expiryLength = time ?? this.#defaultFailSafeTime;
     this.#ensureGeneralCommissioningSuccess(
       "armFailSafe",
-      await client.armFailSafe({
-        breadcrumb: this.lastBreadcrumb,
-        expiryLengthSeconds: Seconds.of(expiryLength)
+      await this.#invokeCommand({
+        endpoint: RootEndpointNumber,
+        cluster: GeneralCommissioning.Complete,
+        command: "armFailSafe",
+        fields: {
+          breadcrumb: this.lastBreadcrumb,
+          expiryLengthSeconds: Seconds.of(expiryLength)
+        }
       })
     );
     this.#currentFailSafeEndTime = Timestamp(Time.nowMs + expiryLength);
@@ -410,22 +491,26 @@ class ControllerCommissioningFlow {
     return Duration.max(Timespan(Time.nowMs, this.#currentFailSafeEndTime).duration, 0);
   }
   async #ensureFailsafeTimerFor(maxProcessingTime) {
-    const minFailsafeTime = this.interactionClient.maximumPeerResponseTime(maxProcessingTime);
+    const minFailsafeTime = this.interaction.maximumPeerResponseTime(maxProcessingTime);
     const timeLeft = this.#failSafeTimeLeft;
     if (timeLeft < minFailsafeTime) {
       logger.debug(`Failsafe timer has only ${timeLeft}s left, re-arming for at least ${minFailsafeTime}`);
       await this.#armFailsafe(Duration.max(minFailsafeTime, this.#defaultFailSafeTime));
     } else {
-      logger.debug(`Failsafe timer is already set for at least ${timeLeft}s`);
+      logger.debug(`Failsafe timer is already set for at least ${Seconds.of(timeLeft)}s`);
     }
   }
   async #resetFailsafeTimer() {
     if (this.#currentFailSafeEndTime === void 0) return;
     try {
-      const client = this.#getClusterClient(GeneralCommissioning.Cluster);
-      await client.armFailSafe({
-        breadcrumb: this.lastBreadcrumb,
-        expiryLengthSeconds: 0
+      await this.#invokeCommand({
+        endpoint: RootEndpointNumber,
+        cluster: GeneralCommissioning.Complete,
+        command: "armFailSafe",
+        fields: {
+          breadcrumb: this.lastBreadcrumb,
+          expiryLengthSeconds: 0
+        }
       });
       this.#currentFailSafeEndTime = void 0;
     } catch (error) {
@@ -449,8 +534,15 @@ class ControllerCommissioningFlow {
       ({ value: { wiFiNetworkInterface, threadNetworkInterface } }) => wiFiNetworkInterface || threadNetworkInterface
     );
     if (hasRadioNetwork) {
-      const client = this.#getClusterClient(GeneralCommissioning.Cluster);
-      let locationCapability = await client.getLocationCapabilityAttribute();
+      let [locationCapability] = await this.#readConcreteAttributeValues(
+        Read(
+          Read.Attribute({
+            endpoint: RootEndpointNumber,
+            cluster: GeneralCommissioning.Complete,
+            attributes: ["locationCapability"]
+          })
+        )
+      );
       if (locationCapability === GeneralCommissioning.RegulatoryLocationType.IndoorOutdoor) {
         locationCapability = this.commissioningOptions.regulatoryLocation;
       } else {
@@ -459,13 +551,20 @@ class ControllerCommissioningFlow {
         );
       }
       let countryCode = this.commissioningOptions.regulatoryCountryCode;
-      const regulatoryResult = await client.setRegulatoryConfig(
+      const regulatoryResult = await this.#invokeCommand(
         {
-          breadcrumb: this.lastBreadcrumb++,
-          newRegulatoryConfig: locationCapability,
-          countryCode
+          endpoint: RootEndpointNumber,
+          cluster: GeneralCommissioning.Complete,
+          command: "setRegulatoryConfig",
+          fields: {
+            breadcrumb: this.lastBreadcrumb++,
+            newRegulatoryConfig: locationCapability,
+            countryCode
+          }
         },
-        { useExtendedFailSafeMessageResponseTimeout: true }
+        {
+          useExtendedFailSafeMessageResponseTimeout: true
+        }
       );
       if (regulatoryResult.errorCode === GeneralCommissioning.CommissioningError.ValueOutsideRange && countryCode !== "XX") {
         logger.debug(
@@ -474,13 +573,20 @@ class ControllerCommissioningFlow {
         countryCode = "XX";
         this.#ensureGeneralCommissioningSuccess(
           "setRegulatoryConfig",
-          await client.setRegulatoryConfig(
+          await this.#invokeCommand(
             {
-              breadcrumb: this.lastBreadcrumb,
-              newRegulatoryConfig: locationCapability,
-              countryCode
+              endpoint: RootEndpointNumber,
+              cluster: GeneralCommissioning.Complete,
+              command: "setRegulatoryConfig",
+              fields: {
+                breadcrumb: this.lastBreadcrumb,
+                newRegulatoryConfig: locationCapability,
+                countryCode
+              }
             },
-            { useExtendedFailSafeMessageResponseTimeout: true }
+            {
+              useExtendedFailSafeMessageResponseTimeout: true
+            }
           )
         );
       } else {
@@ -522,24 +628,44 @@ class ControllerCommissioningFlow {
    * (see Section 6.2.3, “Device Attestation Procedure”).
    */
   async #deviceAttestation() {
-    const operationalCredentialsClusterClient = this.#getClusterClient(OperationalCredentials.Cluster);
-    const { certificate: deviceAttestation } = await operationalCredentialsClusterClient.certificateChainRequest(
+    const { certificate: deviceAttestation } = await this.#invokeCommand(
       {
-        certificateType: OperationalCredentials.CertificateChainType.DacCertificate
+        endpoint: RootEndpointNumber,
+        cluster: OperationalCredentials.Complete,
+        command: "certificateChainRequest",
+        fields: {
+          certificateType: OperationalCredentials.CertificateChainType.DacCertificate
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
-    const { certificate: productAttestation } = await operationalCredentialsClusterClient.certificateChainRequest(
+    const { certificate: productAttestation } = await this.#invokeCommand(
       {
-        certificateType: OperationalCredentials.CertificateChainType.PaiCertificate
+        endpoint: RootEndpointNumber,
+        cluster: OperationalCredentials.Complete,
+        command: "certificateChainRequest",
+        fields: {
+          certificateType: OperationalCredentials.CertificateChainType.PaiCertificate
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
-    const { attestationElements, attestationSignature } = await operationalCredentialsClusterClient.attestationRequest(
+    const { attestationElements, attestationSignature } = await this.#invokeCommand(
       {
-        attestationNonce: this.fabric.crypto.randomBytes(32)
+        endpoint: RootEndpointNumber,
+        cluster: OperationalCredentials.Complete,
+        command: "attestationRequest",
+        fields: {
+          attestationNonce: this.fabric.crypto.randomBytes(32)
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     if (deviceAttestation.byteLength === 0 || productAttestation.byteLength === 0 || attestationElements.byteLength === 0 || attestationSignature.byteLength === 0) {
       throw new CommissioningError("Device Attestation data missing from device");
@@ -566,36 +692,56 @@ class ControllerCommissioningFlow {
    *     DCL contains the name and other information of the Commissioner’s manufacturer.
    */
   async #certificates() {
-    const operationalCredentialsClusterClient = this.#getClusterClient(OperationalCredentials.Cluster);
-    const { nocsrElements, attestationSignature: csrSignature } = await operationalCredentialsClusterClient.csrRequest(
-      { csrNonce: this.fabric.crypto.randomBytes(32) },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+    const { nocsrElements, attestationSignature: csrSignature } = await this.#invokeCommand(
+      {
+        endpoint: RootEndpointNumber,
+        cluster: OperationalCredentials.Complete,
+        command: "csrRequest",
+        fields: { csrNonce: this.fabric.crypto.randomBytes(32) }
+      },
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     if (nocsrElements.byteLength === 0 || csrSignature.byteLength === 0) {
       throw new UnexpectedDataError("Invalid response from device");
     }
     const { certSigningRequest } = TlvCertSigningRequest.decode(nocsrElements);
     const operationalPublicKey = await Certificate.getPublicKeyFromCsr(this.ca.crypto, certSigningRequest);
-    await operationalCredentialsClusterClient.addTrustedRootCertificate(
+    await this.#invokeCommand(
       {
-        rootCaCertificate: this.ca.rootCert
+        endpoint: RootEndpointNumber,
+        cluster: OperationalCredentials.Complete,
+        command: "addTrustedRootCertificate",
+        fields: {
+          rootCaCertificate: this.ca.rootCert
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     const peerOperationalCert = await this.ca.generateNoc(
       operationalPublicKey,
       this.fabric.fabricId,
-      this.interactionClient.address.nodeId
+      this.interaction.address.nodeId
     );
-    const addNocResponse = await operationalCredentialsClusterClient.addNoc(
+    const addNocResponse = await this.#invokeCommand(
       {
-        nocValue: peerOperationalCert,
-        icacValue: this.ca.icacCert ?? new Uint8Array(0),
-        ipkValue: this.fabric.identityProtectionKey,
-        adminVendorId: this.fabric.rootVendorId,
-        caseAdminSubject: this.fabric.rootNodeId
+        endpoint: RootEndpointNumber,
+        cluster: OperationalCredentials.Complete,
+        command: "addNoc",
+        fields: {
+          nocValue: peerOperationalCert,
+          icacValue: this.ca.icacCert ?? new Uint8Array(0),
+          ipkValue: this.fabric.identityProtectionKey,
+          adminVendorId: this.fabric.rootVendorId,
+          caseAdminSubject: this.fabric.rootNodeId
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     this.#ensureOperationalCredentialsSuccess("addNoc", addNocResponse);
     const { fabricIndex } = addNocResponse;
@@ -621,13 +767,17 @@ class ControllerCommissioningFlow {
         breadcrumb: this.lastBreadcrumb
       };
     }
-    const operationalCredentialCluster = this.#getClusterClient(OperationalCredentials.Cluster);
     try {
       this.#ensureOperationalCredentialsSuccess(
         "updateFabricLabel",
-        await operationalCredentialCluster.updateFabricLabel({
-          label: this.fabric.label,
-          fabricIndex
+        await this.#invokeCommand({
+          endpoint: RootEndpointNumber,
+          cluster: OperationalCredentials.Complete,
+          command: "updateFabricLabel",
+          fields: {
+            label: this.fabric.label,
+            fabricIndex
+          }
         })
       );
     } catch (error) {
@@ -723,22 +873,32 @@ class ControllerCommissioningFlow {
       }
     }
     logger.debug("Configuring WiFi network ...");
-    const networkCommissioningClusterClient = this.#getClusterClient(
-      NetworkCommissioning.Cluster.with("WiFiNetworkInterface"),
-      EndpointNumber(0),
-      true
-    );
     const ssid = Bytes.fromString(this.commissioningOptions.wifiNetwork.wifiSsid);
     const credentials = Bytes.fromString(this.commissioningOptions.wifiNetwork.wifiCredentials);
+    const [scanMaxTimeSeconds, connectMaxTimeSeconds] = await this.#readConcreteAttributeValues(
+      Read(
+        Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: NetworkCommissioning.Complete,
+          attributes: ["scanMaxTimeSeconds", "connectMaxTimeSeconds"]
+        })
+      )
+    );
     if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
-      const scanMaxTime = Seconds(await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute());
-      await this.#ensureFailsafeTimerFor(scanMaxTime);
-      const { networkingStatus, wiFiScanResults, debugText } = await networkCommissioningClusterClient.scanNetworks(
+      await this.#ensureFailsafeTimerFor(Seconds(scanMaxTimeSeconds));
+      const { networkingStatus, wiFiScanResults, debugText } = await this.#invokeCommand(
         {
-          ssid,
-          breadcrumb: this.lastBreadcrumb++
+          endpoint: RootEndpointNumber,
+          cluster: NetworkCommissioning.Complete,
+          command: "scanNetworks",
+          fields: {
+            ssid,
+            breadcrumb: this.lastBreadcrumb++
+          }
         },
-        { expectedProcessingTime: scanMaxTime }
+        {
+          expectedProcessingTime: Seconds(scanMaxTimeSeconds)
+        }
       );
       if (networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
         throw new WifiNetworkSetupFailedError(`Commissionee failed to scan for WiFi networks: ${debugText}`);
@@ -753,13 +913,20 @@ class ControllerCommissioningFlow {
       networkingStatus: addNetworkingStatus,
       debugText: addDebugText,
       networkIndex
-    } = await networkCommissioningClusterClient.addOrUpdateWiFiNetwork(
+    } = await this.#invokeCommand(
       {
-        ssid,
-        credentials,
-        breadcrumb: this.lastBreadcrumb++
+        endpoint: RootEndpointNumber,
+        cluster: NetworkCommissioning.Complete,
+        command: "addOrUpdateWiFiNetwork",
+        fields: {
+          ssid,
+          credentials,
+          breadcrumb: this.lastBreadcrumb++
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     if (addNetworkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
       throw new WifiNetworkSetupFailedError(`Commissionee failed to add WiFi network: ${addDebugText}`);
@@ -770,7 +937,15 @@ class ControllerCommissioningFlow {
     logger.debug(
       `Commissionee added WiFi network ${this.commissioningOptions.wifiNetwork.wifiSsid} with network index ${networkIndex}`
     );
-    const updatedNetworks = await networkCommissioningClusterClient.getNetworksAttribute();
+    const [updatedNetworks] = await this.#readConcreteAttributeValues(
+      Read(
+        Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: NetworkCommissioning.Complete,
+          attributes: ["networks"]
+        })
+      )
+    );
     if (updatedNetworks[networkIndex] === void 0) {
       throw new WifiNetworkSetupFailedError(`Commissionee did not return network with index ${networkIndex}`);
     }
@@ -785,14 +960,20 @@ class ControllerCommissioningFlow {
         breadcrumb: this.lastBreadcrumb
       };
     }
-    const connectMaxTime = Seconds(await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute());
-    await this.#ensureFailsafeTimerFor(connectMaxTime);
-    const connectResult = await networkCommissioningClusterClient.connectNetwork(
+    await this.#ensureFailsafeTimerFor(Seconds(connectMaxTimeSeconds));
+    const connectResult = await this.#invokeCommand(
       {
-        networkId,
-        breadcrumb: this.lastBreadcrumb++
+        endpoint: RootEndpointNumber,
+        cluster: NetworkCommissioning.Complete,
+        command: "connectNetwork",
+        fields: {
+          networkId,
+          breadcrumb: this.lastBreadcrumb++
+        }
       },
-      { expectedProcessingTime: connectMaxTime }
+      {
+        expectedProcessingTime: Seconds(connectMaxTimeSeconds)
+      }
     );
     if (connectResult.networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
       throw new WifiNetworkSetupFailedError(
@@ -849,17 +1030,29 @@ class ControllerCommissioningFlow {
       }
     }
     logger.debug("Configuring Thread network ...");
-    const networkCommissioningClusterClient = this.#getClusterClient(
-      NetworkCommissioning.Cluster.with("ThreadNetworkInterface"),
-      EndpointNumber(0),
-      true
+    const [scanMaxTimeSeconds, connectMaxTimeSeconds] = await this.#readConcreteAttributeValues(
+      Read(
+        Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: NetworkCommissioning.Complete,
+          attributes: ["scanMaxTimeSeconds", "connectMaxTimeSeconds"]
+        })
+      )
     );
-    if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
-      const scanMaxTime = Seconds(await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute());
-      await this.#ensureFailsafeTimerFor(scanMaxTime);
-      const { networkingStatus, threadScanResults, debugText } = await networkCommissioningClusterClient.scanNetworks(
-        { breadcrumb: this.lastBreadcrumb++ },
-        { expectedProcessingTime: scanMaxTime }
+    if (!this.commissioningOptions.threadNetwork?.networkName) {
+      logger.info("Thread network name is not configured. Skip scanning for it.");
+    } else if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
+      await this.#ensureFailsafeTimerFor(Seconds(scanMaxTimeSeconds));
+      const { networkingStatus, threadScanResults, debugText } = await this.#invokeCommand(
+        {
+          endpoint: RootEndpointNumber,
+          cluster: NetworkCommissioning.Complete,
+          command: "scanNetworks",
+          fields: { breadcrumb: this.lastBreadcrumb++ }
+        },
+        {
+          expectedProcessingTime: Seconds(scanMaxTimeSeconds)
+        }
       );
       if (networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
         throw new ThreadNetworkSetupFailedError(
@@ -887,12 +1080,19 @@ class ControllerCommissioningFlow {
       networkingStatus: addNetworkingStatus,
       debugText: addDebugText,
       networkIndex
-    } = await networkCommissioningClusterClient.addOrUpdateThreadNetwork(
+    } = await this.#invokeCommand(
       {
-        operationalDataset: Bytes.fromHex(this.commissioningOptions.threadNetwork.operationalDataset),
-        breadcrumb: this.lastBreadcrumb++
+        endpoint: RootEndpointNumber,
+        cluster: NetworkCommissioning.Complete,
+        command: "addOrUpdateThreadNetwork",
+        fields: {
+          operationalDataset: Bytes.fromHex(this.commissioningOptions.threadNetwork.operationalDataset),
+          breadcrumb: this.lastBreadcrumb++
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     if (addNetworkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
       throw new ThreadNetworkSetupFailedError(`Commissionee failed to add Thread network: ${addDebugText}`);
@@ -903,7 +1103,15 @@ class ControllerCommissioningFlow {
     logger.debug(
       `Commissionee added Thread network ${this.commissioningOptions.threadNetwork.networkName} with network index ${networkIndex}`
     );
-    const updatedNetworks = await networkCommissioningClusterClient.getNetworksAttribute();
+    const updatedNetworks = await this.#readConcreteAttributeValues(
+      Read(
+        Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: NetworkCommissioning.Complete,
+          attributes: ["networks"]
+        })
+      )
+    );
     if (updatedNetworks[networkIndex] === void 0) {
       throw new ThreadNetworkSetupFailedError(`Commissionee did not return network with index ${networkIndex}`);
     }
@@ -917,14 +1125,20 @@ class ControllerCommissioningFlow {
         breadcrumb: this.lastBreadcrumb
       };
     }
-    const connectMaxTime = Seconds(await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute());
-    await this.#ensureFailsafeTimerFor(connectMaxTime);
-    const connectResult = await networkCommissioningClusterClient.connectNetwork(
+    await this.#ensureFailsafeTimerFor(Seconds(connectMaxTimeSeconds));
+    const connectResult = await this.#invokeCommand(
       {
-        networkId,
-        breadcrumb: this.lastBreadcrumb++
+        endpoint: RootEndpointNumber,
+        cluster: NetworkCommissioning.Complete,
+        command: "connectNetwork",
+        fields: {
+          networkId,
+          breadcrumb: this.lastBreadcrumb++
+        }
       },
-      { expectedProcessingTime: connectMaxTime }
+      {
+        expectedProcessingTime: Seconds(connectMaxTimeSeconds)
+      }
     );
     if (connectResult.networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
       throw new ThreadNetworkSetupFailedError(
@@ -974,7 +1188,7 @@ class ControllerCommissioningFlow {
     let transitionResult;
     try {
       transitionResult = await this.transitionToCase(
-        this.interactionClient.address,
+        this.interaction.address,
         // Assume concurrent connections are supported if not know (which should not be the case when we came here)
         isConcurrentFlow
       );
@@ -989,7 +1203,7 @@ class ControllerCommissioningFlow {
         breadcrumb: this.lastBreadcrumb
       };
     }
-    this.interactionClient = transitionResult;
+    this.interaction = transitionResult;
     this.#clusterClients.clear();
     logger.debug("Successfully reconnected with device ...");
     return {
@@ -1005,12 +1219,18 @@ class ControllerCommissioningFlow {
    * the commissioning process.
    */
   async #completeCommissioning() {
-    const generalCommissioningClusterClient = this.#getClusterClient(GeneralCommissioning.Cluster);
     this.#ensureGeneralCommissioningSuccess(
       "commissioningComplete",
-      await generalCommissioningClusterClient.commissioningComplete(void 0, {
-        useExtendedFailSafeMessageResponseTimeout: true
-      })
+      await this.#invokeCommand(
+        {
+          endpoint: RootEndpointNumber,
+          cluster: GeneralCommissioning.Complete,
+          command: "commissioningComplete"
+        },
+        {
+          useExtendedFailSafeMessageResponseTimeout: true
+        }
+      )
     );
     this.#currentFailSafeEndTime = void 0;
     return {
@@ -1020,8 +1240,6 @@ class ControllerCommissioningFlow {
   }
 }
 export {
-  CommissionableDeviceDiscoveryFailedError,
-  CommissioningError,
   CommissioningTimeoutError,
   ControllerCommissioningFlow,
   DeviceAlreadyCommissionedToThisFabricError,