@matter-server/ws-controller 0.2.0-alpha.0-00000000-000000000

package/dist/esm/controller/ControllerCommandHandler.js

@@ -0,0 +1,1015 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AsyncObservable, isObject } from "@matter/general";
+import {
+  Bytes,
+  ClusterBehavior,
+  FabricIndex,
+  ipv4BytesToString,
+  ipv6BytesToString,
+  Logger,
+  Millis,
+  NodeId,
+  Observable,
+  Seconds,
+  SoftwareUpdateManager
+} from "@matter/main";
+import {
+  AccessControl,
+  Binding,
+  GeneralCommissioning,
+  GeneralDiagnosticsCluster,
+  OperationalCredentials
+} from "@matter/main/clusters";
+import {
+  PeerAddress,
+  Read,
+  SupportedTransportsSchema
+} from "@matter/main/protocol";
+import {
+  Attribute,
+  ClusterId,
+  Command,
+  DeviceTypeId,
+  EndpointNumber,
+  getClusterById,
+  GroupId,
+  ManualPairingCodeCodec,
+  QrPairingCodeCodec,
+  StatusResponseError,
+  TlvAny,
+  TlvBoolean,
+  TlvByteString,
+  TlvInt32,
+  TlvNoResponse,
+  TlvNullable,
+  TlvObject,
+  TlvString,
+  TlvUInt64,
+  TlvVoid,
+  VendorId
+} from "@matter/main/types";
+import { NodeStates } from "@project-chip/matter.js/device";
+import { ClusterMap } from "../model/ModelMapper.js";
+import {
+  buildAttributePath,
+  convertCommandDataToMatter,
+  convertMatterToWebSocketTagBased,
+  getDateAsString,
+  splitAttributePath
+} from "../server/Converters.js";
+import {
+  UpdateSource
+} from "../types/WebSocketMessageTypes.js";
+import { pingIp } from "../util/network.js";
+import { Nodes } from "./Nodes.js";
+const logger = Logger.get("ControllerCommandHandler");
+class ControllerCommandHandler {
+  #controller;
+  #started = false;
+  #connected = false;
+  #bleEnabled = false;
+  #otaEnabled = false;
+  /** Node management and attribute cache */
+  #nodes = new Nodes();
+  /** Cache of available updates keyed by nodeId */
+  #availableUpdates = /* @__PURE__ */ new Map();
+  events = {
+    started: new AsyncObservable(),
+    attributeChanged: new Observable(),
+    eventChanged: new Observable(),
+    nodeAdded: new Observable(),
+    nodeStateChanged: new Observable(),
+    nodeStructureChanged: new Observable(),
+    nodeDecommissioned: new Observable(),
+    nodeEndpointAdded: new Observable(),
+    nodeEndpointRemoved: new Observable()
+  };
+  constructor(controllerInstance, bleEnabled, otaEnabled) {
+    this.#controller = controllerInstance;
+    this.#bleEnabled = bleEnabled;
+    this.#otaEnabled = otaEnabled;
+  }
+  get started() {
+    return this.#started;
+  }
+  get bleEnabled() {
+    return this.#bleEnabled;
+  }
+  async start() {
+    if (this.#started) {
+      return;
+    }
+    this.#started = true;
+    await this.#controller.start();
+    logger.info(`Controller started`);
+    if (!this.#bleEnabled) {
+      await this.#setupOtaEventHandlers();
+    }
+    await this.events.started.emit();
+  }
+  /**
+   * Set up event handlers for OTA update notifications from the SoftwareUpdateManager.
+   */
+  async #setupOtaEventHandlers() {
+    if (!this.#otaEnabled) {
+      return;
+    }
+    try {
+      const otaProvider = this.#controller.otaProvider;
+      if (!otaProvider) {
+        logger.info("OTA provider not available");
+        return;
+      }
+      const softwareUpdateManagerEvents = await otaProvider.act((agent) => agent.get(SoftwareUpdateManager).events);
+      if (softwareUpdateManagerEvents === void 0) {
+        logger.info("SoftwareUpdateManager not available");
+        return;
+      }
+      softwareUpdateManagerEvents.updateAvailable.on(
+        (peerAddress, updateDetails) => {
+          logger.info(`Update available for node ${peerAddress.nodeId}:`, updateDetails);
+          this.#availableUpdates.set(peerAddress.nodeId, updateDetails);
+        }
+      );
+      softwareUpdateManagerEvents.updateDone.on((peerAddress) => {
+        logger.info(`Update done for node ${peerAddress.nodeId}`);
+        this.#availableUpdates.delete(peerAddress.nodeId);
+      });
+      logger.info("OTA event handlers registered");
+    } catch (error) {
+      logger.warn("Failed to setup OTA event handlers:", error);
+    }
+  }
+  close() {
+    if (!this.#started) return;
+    return this.#controller.close();
+  }
+  async #registerNode(nodeId) {
+    const node = await this.#controller.getNode(nodeId);
+    const attributeCache = this.#nodes.attributeCache;
+    node.events.attributeChanged.on((data) => {
+      attributeCache.updateAttribute(nodeId, data);
+      this.events.attributeChanged.emit(nodeId, data);
+    });
+    node.events.eventTriggered.on((data) => this.events.eventChanged.emit(nodeId, data));
+    node.events.stateChanged.on((state) => {
+      if (state === NodeStates.Connected) {
+        attributeCache.update(node);
+      }
+      this.events.nodeStateChanged.emit(nodeId, state);
+    });
+    node.events.structureChanged.on(() => {
+      if (node.isConnected) {
+        attributeCache.update(node);
+      }
+      this.events.nodeStructureChanged.emit(nodeId);
+    });
+    node.events.decommissioned.on(() => this.events.nodeDecommissioned.emit(nodeId));
+    node.events.nodeEndpointAdded.on((endpointId) => this.events.nodeEndpointAdded.emit(nodeId, endpointId));
+    node.events.nodeEndpointRemoved.on((endpointId) => this.events.nodeEndpointRemoved.emit(nodeId, endpointId));
+    this.#nodes.set(nodeId, node);
+    if (node.initialized) {
+      attributeCache.add(node);
+    }
+    return node;
+  }
+  async connect() {
+    if (this.#connected) {
+      return;
+    }
+    this.#connected = true;
+    await this.start();
+    const nodes = this.#controller.getCommissionedNodes();
+    logger.info(`Found ${nodes.length} nodes: ${nodes.map((nodeId) => nodeId.toString()).join(", ")}`);
+    for (const nodeId of nodes) {
+      try {
+        logger.info(`Initializing node "${nodeId}" ...`);
+        const node = await this.#registerNode(nodeId);
+        node.connect({
+          subscribeMinIntervalFloorSeconds: 1,
+          subscribeMaxIntervalCeilingSeconds: void 0
+        });
+      } catch (error) {
+        logger.warn(`Failed to connect to node "${nodeId}":`, error);
+      }
+    }
+  }
+  getNodeIds() {
+    return this.#nodes.getIds();
+  }
+  hasNode(nodeId) {
+    return this.#nodes.has(nodeId);
+  }
+  /**
+   * Alias for decommissionNode to match NodeCommandHandler interface.
+   */
+  removeNode(nodeId) {
+    return this.decommissionNode(nodeId);
+  }
+  async interviewNode(nodeId) {
+    const node = this.#nodes.get(nodeId);
+    logger.info(`Interview requested for node ${nodeId} - do a complete read`);
+    const read = {
+      ...Read({
+        fabricFilter: true,
+        attributes: [{}]
+      }),
+      includeKnownVersions: true
+      // do not send DataVersionFilters, so we do a new clean read
+    };
+    for await (const _chunk of node.node.interaction.read(read)) ;
+    this.events.nodeStateChanged.emit(nodeId, node.connectionState);
+  }
+  /**
+   * Get full node details in WebSocket API format.
+   * @param nodeId The node ID
+   * @param lastInterviewDate Optional last interview date (tracked externally)
+   */
+  async getNodeDetails(nodeId, lastInterviewDate) {
+    const node = this.#nodes.get(nodeId);
+    const attributeCache = this.#nodes.attributeCache;
+    let isBridge = false;
+    if (!attributeCache.has(nodeId)) {
+      attributeCache.add(node);
+    }
+    const attributes = attributeCache.get(nodeId) ?? {};
+    const endpoint1DeviceTypes = attributes["1/29/0"];
+    if (Array.isArray(endpoint1DeviceTypes)) {
+      isBridge = endpoint1DeviceTypes.some((entry) => entry["0"] === 14);
+    }
+    const commissionedAt = node.state.commissioning.commissionedAt;
+    const dateCommissioned = commissionedAt !== void 0 ? new Date(commissionedAt) : /* @__PURE__ */ new Date();
+    return {
+      node_id: node.nodeId,
+      date_commissioned: getDateAsString(dateCommissioned),
+      last_interview: getDateAsString(lastInterviewDate ?? /* @__PURE__ */ new Date()),
+      interview_version: 6,
+      available: node.isConnected,
+      is_bridge: isBridge,
+      attributes,
+      attribute_subscriptions: []
+    };
+  }
+  /**
+   * Read multiple attributes from a node by path strings.
+   * Handles wildcards in paths.
+   */
+  async handleReadAttributes(nodeId, attributePaths, fabricFiltered = false) {
+    const node = this.#nodes.get(nodeId);
+    const result = {};
+    const hasWildcards = attributePaths.some((path) => path.includes("*"));
+    let allAttributes;
+    if (hasWildcards) {
+      if (!node.initialized) {
+        throw new Error(`Node ${nodeId} not ready`);
+      }
+      const rootEndpoint = node.getRootEndpoint();
+      if (rootEndpoint === void 0) {
+        throw new Error(`Node ${nodeId} not ready`);
+      }
+      allAttributes = {};
+      this.#collectAttributesFromEndpoint(rootEndpoint, allAttributes);
+    }
+    for (const path of attributePaths) {
+      const { endpointId, clusterId, attributeId } = splitAttributePath(path);
+      if (path.includes("*") && allAttributes !== void 0) {
+        for (const [attrPath, value] of Object.entries(allAttributes)) {
+          const parts = attrPath.split("/").map(Number);
+          if ((endpointId === void 0 || parts[0] === endpointId) && (clusterId === void 0 || parts[1] === clusterId) && (attributeId === void 0 || parts[2] === attributeId)) {
+            result[attrPath] = value;
+          }
+        }
+        continue;
+      }
+      const { values, status } = await this.handleReadAttribute({
+        nodeId,
+        endpointId,
+        clusterId,
+        attributeId,
+        fabricFiltered
+      });
+      if (values.length) {
+        for (const valueData of values) {
+          const { pathStr, value } = this.#convertAttributeToWebSocket(
+            {
+              endpointId: EndpointNumber(valueData.endpointId),
+              clusterId: ClusterId(valueData.clusterId),
+              attributeId: valueData.attributeId
+            },
+            valueData.value
+          );
+          result[pathStr] = value;
+        }
+      } else if (status && status.length > 0) {
+        logger.warn(`Failed to read attribute ${path}: status=${JSON.stringify(status)}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Collect all attributes from an endpoint and its children into WebSocket format.
+   */
+  #collectAttributesFromEndpoint(endpoint, attributesData) {
+    const endpointId = endpoint.number;
+    for (const behavior of endpoint.endpoint.behaviors.active) {
+      if (!ClusterBehavior.is(behavior)) {
+        continue;
+      }
+      const cluster = behavior.cluster;
+      const clusterId = cluster.id;
+      const clusterData = ClusterMap[cluster.name.toLowerCase()];
+      const clusterState = endpoint.endpoint.stateOf(behavior);
+      for (const attributeName in cluster.attributes) {
+        const attribute = cluster.attributes[attributeName];
+        if (attribute === void 0) {
+          continue;
+        }
+        const attributeValue = clusterState[attributeName];
+        const { pathStr, value } = this.#convertAttributeToWebSocket(
+          { endpointId, clusterId, attributeId: attribute.id },
+          attributeValue,
+          clusterData
+        );
+        attributesData[pathStr] = value;
+      }
+    }
+    for (const childEndpoint of endpoint.getChildEndpoints()) {
+      this.#collectAttributesFromEndpoint(childEndpoint, attributesData);
+    }
+  }
+  /**
+   * Convert attribute data to WebSocket tag-based format.
+   */
+  #convertAttributeToWebSocket(path, value, clusterData) {
+    const { endpointId, clusterId, attributeId } = path;
+    if (!clusterData) {
+      const cluster = getClusterById(clusterId);
+      clusterData = ClusterMap[cluster.name.toLowerCase()];
+    }
+    return {
+      pathStr: buildAttributePath(endpointId, clusterId, attributeId),
+      value: convertMatterToWebSocketTagBased(value, clusterData?.attributes[attributeId], clusterData?.model)
+    };
+  }
+  /**
+   * Set the fabric label. Pass null or empty string to reset to "Home".
+   * Note: matter.js requires non-empty labels (1-32 chars), so null/empty resets to default.
+   */
+  setFabricLabel(label) {
+    const effectiveLabel = label && label.trim() !== "" ? label : "Home";
+    return this.#controller.updateFabricLabel(effectiveLabel);
+  }
+  disconnectNode(nodeId) {
+    return this.#controller.disconnectNode(nodeId, true);
+  }
+  async handleReadAttribute(data) {
+    const { nodeId, endpointId, clusterId, attributeId, fabricFiltered = true } = data;
+    const client = await this.#nodes.interactionClientFor(nodeId);
+    const { attributeData, attributeStatus } = await client.getMultipleAttributesAndStatus({
+      attributes: [{ endpointId, clusterId, attributeId }],
+      isFabricFiltered: fabricFiltered
+    });
+    return {
+      values: attributeData.map(
+        ({ path: { endpointId: endpointId2, clusterId: clusterId2, attributeId: attributeId2 }, value, version: dataVersion }) => ({
+          attributeId: attributeId2,
+          clusterId: clusterId2,
+          dataVersion,
+          endpointId: endpointId2,
+          value
+        })
+      ),
+      status: attributeStatus?.map(({ path: { endpointId: endpointId2, clusterId: clusterId2, attributeId: attributeId2 }, status, clusterStatus }) => ({
+        attributeId: attributeId2,
+        clusterId: clusterId2,
+        endpointId: endpointId2,
+        status,
+        clusterStatus
+      }))
+    };
+  }
+  async handleReadEvent(data) {
+    const { nodeId, endpointId, clusterId, eventId, eventMin } = data;
+    const client = await this.#nodes.interactionClientFor(nodeId);
+    const { eventData, eventStatus } = await client.getMultipleEventsAndStatus({
+      events: [
+        {
+          endpointId,
+          clusterId,
+          eventId
+        }
+      ],
+      eventFilters: eventMin ? [{ eventMin }] : void 0
+    });
+    return {
+      values: eventData.flatMap(
+        ({ path: { endpointId: endpointId2, clusterId: clusterId2, eventId: eventId2 }, events }) => events.map(({ eventNumber, data: data2 }) => ({
+          eventId: eventId2,
+          clusterId: clusterId2,
+          endpointId: endpointId2,
+          eventNumber,
+          value: data2
+        }))
+      ),
+      status: eventStatus?.map(({ path: { endpointId: endpointId2, clusterId: clusterId2, eventId: eventId2 }, status, clusterStatus }) => ({
+        clusterId: clusterId2,
+        endpointId: endpointId2,
+        eventId: eventId2,
+        status,
+        clusterStatus
+      }))
+    };
+  }
+  async handleSubscribeAttribute(data) {
+    const { nodeId, endpointId, clusterId, attributeId, minInterval, maxInterval, changeListener } = data;
+    const client = await this.#nodes.interactionClientFor(nodeId);
+    const updated = Observable();
+    let ignoreData = true;
+    const { attributeReports = [] } = await client.subscribeMultipleAttributesAndEvents({
+      attributes: [
+        {
+          endpointId,
+          clusterId,
+          attributeId
+        }
+      ],
+      minIntervalFloorSeconds: minInterval,
+      maxIntervalCeilingSeconds: maxInterval,
+      attributeListener: (data2) => {
+        if (ignoreData) return;
+        changeListener({
+          attributeId: data2.path.attributeId,
+          clusterId: data2.path.clusterId,
+          endpointId: data2.path.endpointId,
+          dataVersion: data2.version,
+          value: data2.value
+        });
+      },
+      updateReceived: () => {
+        updated.emit();
+      },
+      keepSubscriptions: false
+    });
+    ignoreData = false;
+    return {
+      values: attributeReports.map(
+        ({ path: { endpointId: endpointId2, clusterId: clusterId2, attributeId: attributeId2 }, value, version: dataVersion }) => ({
+          attributeId: attributeId2,
+          clusterId: clusterId2,
+          endpointId: endpointId2,
+          dataVersion,
+          value
+        })
+      ),
+      updated
+    };
+  }
+  async handleSubscribeEvent(data) {
+    const { nodeId, endpointId, clusterId, eventId, minInterval, maxInterval, changeListener } = data;
+    const client = await this.#nodes.interactionClientFor(nodeId);
+    const updated = Observable();
+    let ignoreData = true;
+    const { eventReports = [] } = await client.subscribeMultipleAttributesAndEvents({
+      events: [
+        {
+          endpointId,
+          clusterId,
+          eventId
+        }
+      ],
+      minIntervalFloorSeconds: minInterval,
+      maxIntervalCeilingSeconds: maxInterval,
+      eventListener: (data2) => {
+        if (ignoreData) return;
+        data2.events.forEach(
+          (event) => changeListener({
+            eventId: data2.path.eventId,
+            clusterId: data2.path.clusterId,
+            endpointId: data2.path.endpointId,
+            eventNumber: event.eventNumber,
+            value: event.data
+          })
+        );
+      },
+      updateReceived: () => {
+        updated.emit();
+      },
+      keepSubscriptions: false
+    });
+    ignoreData = false;
+    return {
+      values: eventReports.flatMap(
+        ({ path: { endpointId: endpointId2, clusterId: clusterId2, eventId: eventId2 }, events }) => events.map(({ eventNumber, data: data2 }) => ({
+          eventId: eventId2,
+          clusterId: clusterId2,
+          endpointId: endpointId2,
+          eventNumber,
+          value: data2
+        }))
+      ),
+      updated
+    };
+  }
+  async handleWriteAttribute(data) {
+    const { nodeId, endpointId, clusterId, attributeId, value } = data;
+    const client = this.#nodes.clusterClientByIdFor(nodeId, endpointId, clusterId);
+    logger.info("Writing attribute", attributeId, "with value", value);
+    try {
+      await client.attributes[attributeId].set(value);
+      return {
+        attributeId,
+        clusterId,
+        endpointId,
+        status: 0
+      };
+    } catch (error) {
+      StatusResponseError.accept(error);
+      return {
+        attributeId,
+        clusterId,
+        endpointId,
+        status: error.code,
+        clusterStatus: error.clusterCode
+      };
+    }
+  }
+  async handleInvoke(data) {
+    const {
+      nodeId,
+      endpointId,
+      clusterId,
+      commandName,
+      timedInteractionTimeoutMs: timedRequestTimeoutMs,
+      interactionTimeoutMs
+    } = data;
+    let { data: commandData } = data;
+    const client = this.#nodes.clusterClientByIdFor(nodeId, endpointId, clusterId);
+    if (!client[commandName] || !client.isCommandSupportedByName(commandName)) {
+      throw new Error("Command not existing");
+    }
+    if (isObject(commandData)) {
+      if (Object.keys(commandData).length === 0) {
+        commandData = void 0;
+      } else {
+        const cluster = ClusterMap[client.name.toLowerCase()];
+        const model = cluster?.commands[commandName.toLowerCase()];
+        if (cluster && model) {
+          commandData = convertCommandDataToMatter(commandData, model, cluster.model);
+        }
+      }
+    }
+    return client[commandName](commandData, {
+      timedRequestTimeout: Millis(timedRequestTimeoutMs),
+      expectedProcessingTime: interactionTimeoutMs !== void 0 ? Millis(interactionTimeoutMs) : void 0
+    });
+  }
+  /** InvokeById minimalistic handler because only used for error testing */
+  async handleInvokeById(data) {
+    const { nodeId, endpointId, clusterId, commandId, data: commandData, timedInteractionTimeoutMs } = data;
+    const client = await this.#nodes.interactionClientFor(nodeId);
+    await client.invoke({
+      endpointId,
+      clusterId,
+      command: Command(commandId, TlvAny, 0, TlvNoResponse, {
+        timed: timedInteractionTimeoutMs !== void 0
+      }),
+      request: commandData === void 0 ? TlvVoid.encodeTlv() : TlvObject({}).encodeTlv(commandData),
+      asTimedRequest: timedInteractionTimeoutMs !== void 0,
+      timedRequestTimeout: Millis(timedInteractionTimeoutMs),
+      skipValidation: true
+    });
+  }
+  async handleWriteAttributeById(data) {
+    const { nodeId, endpointId, clusterId, attributeId, value } = data;
+    const client = await this.#nodes.interactionClientFor(nodeId);
+    logger.info("Writing attribute", attributeId, "with value", value);
+    let tlvValue;
+    if (value === null) {
+      tlvValue = TlvNullable(TlvBoolean).encodeTlv(value);
+    } else if (value instanceof Uint8Array) {
+      tlvValue = TlvByteString.encodeTlv(value);
+    } else {
+      switch (typeof value) {
+        case "boolean":
+          tlvValue = TlvBoolean.encodeTlv(value);
+          break;
+        case "number":
+          tlvValue = TlvInt32.encodeTlv(value);
+          break;
+        case "bigint":
+          tlvValue = TlvUInt64.encodeTlv(value);
+          break;
+        case "string":
+          tlvValue = TlvString.encodeTlv(value);
+          break;
+        default:
+          throw new Error("Unsupported value type for Any encoding");
+      }
+    }
+    await client.setAttribute({
+      attributeData: {
+        endpointId,
+        clusterId,
+        attribute: Attribute(attributeId, TlvAny),
+        value: tlvValue
+      }
+    });
+  }
+  #determineCommissionOptions(data) {
+    let passcode = void 0;
+    let shortDiscriminator = void 0;
+    let longDiscriminator = void 0;
+    let productId = void 0;
+    let vendorId = void 0;
+    let knownAddress = void 0;
+    if ("manualCode" in data && data.manualCode.length > 0) {
+      const pairingCodeCodec = ManualPairingCodeCodec.decode(data.manualCode);
+      shortDiscriminator = pairingCodeCodec.shortDiscriminator;
+      longDiscriminator = void 0;
+      passcode = pairingCodeCodec.passcode;
+    } else if ("qrCode" in data && data.qrCode.length > 0) {
+      const pairingCodeCodec = QrPairingCodeCodec.decode(data.qrCode);
+      longDiscriminator = pairingCodeCodec[0].discriminator;
+      shortDiscriminator = void 0;
+      passcode = pairingCodeCodec[0].passcode;
+    } else if ("passcode" in data) {
+      passcode = data.passcode;
+      if ("shortDiscriminator" in data) {
+        shortDiscriminator = data.shortDiscriminator;
+      } else if ("longDiscriminator" in data) {
+        longDiscriminator = data.longDiscriminator;
+      } else if ("vendorId" in data && "productId" in data) {
+        vendorId = VendorId(data.vendorId);
+        productId = data.productId;
+      }
+    } else {
+      throw new Error("No pairing code provided");
+    }
+    if (data.knownAddress !== void 0) {
+      const { ip, port } = data.knownAddress;
+      knownAddress = {
+        type: "udp",
+        ip,
+        port
+      };
+    }
+    if (passcode == void 0) {
+      throw new Error("No passcode provided");
+    }
+    const { onNetworkOnly } = data;
+    return {
+      commissioning: {
+        nodeId: data.nodeId,
+        regulatoryLocation: GeneralCommissioning.RegulatoryLocationType.IndoorOutdoor,
+        regulatoryCountryCode: "XX"
+      },
+      discovery: {
+        knownAddress,
+        identifierData: longDiscriminator !== void 0 ? { longDiscriminator } : shortDiscriminator !== void 0 ? { shortDiscriminator } : vendorId !== void 0 ? { vendorId, productId } : {},
+        discoveryCapabilities: {
+          ble: this.bleEnabled && !onNetworkOnly,
+          onIpNetwork: true
+        }
+      },
+      passcode
+    };
+  }
+  async commissionNode(data) {
+    const nodeId = await this.#controller.commissionNode(this.#determineCommissionOptions(data), {
+      connectNodeAfterCommissioning: true
+    });
+    await this.#registerNode(nodeId);
+    this.events.nodeAdded.emit(nodeId);
+    return { nodeId };
+  }
+  getCommissionerNodeId() {
+    return this.#controller.nodeId;
+  }
+  async getCommissionerFabricData() {
+    const { fabricId, globalId } = this.#controller.fabric;
+    return {
+      fabricId,
+      compressedFabricId: globalId
+    };
+  }
+  /** Discover commissionable devices */
+  async handleDiscovery({ findBy }) {
+    const result = await this.#controller.discoverCommissionableDevices(
+      findBy ?? {},
+      { onIpNetwork: true },
+      void 0,
+      Seconds(3)
+      // Just check for 3 sec
+    );
+    logger.info("Discovered result", result);
+    const latestDiscovery = result[result.length - 1];
+    if (latestDiscovery === void 0) {
+      return [];
+    }
+    return [latestDiscovery].map(({ DT, DN, CM, D, RI, PH, PI, T, VP, deviceIdentifier, addresses, SII, SAI }) => {
+      const { tcpClient: supportsTcpClient, tcpServer: supportsTcpServer } = SupportedTransportsSchema.decode(
+        T ?? 0
+      );
+      const vendorId = VP === void 0 ? -1 : VP.includes("+") ? parseInt(VP.split("+")[0]) : parseInt(VP);
+      const productId = VP === void 0 ? -1 : VP.includes("+") ? parseInt(VP.split("+")[1]) : -1;
+      const port = addresses.length ? addresses[0].port : 0;
+      const numIPs = addresses.length;
+      return {
+        commissioningMode: CM,
+        deviceName: DN ?? "",
+        deviceType: DT ?? 0,
+        hostName: "000000000000",
+        // Right now we do not return real hostname, only used internally
+        instanceName: deviceIdentifier,
+        longDiscriminator: D,
+        numIPs,
+        pairingHint: PH ?? -1,
+        pairingInstruction: PI ?? "",
+        port,
+        productId,
+        rotatingId: RI ?? "",
+        rotatingIdLen: RI?.length ?? 0,
+        shortDiscriminator: D >> 8 & 15,
+        vendorId,
+        supportsTcpServer,
+        supportsTcpClient,
+        addresses: addresses.filter(({ type }) => type === "udp").map(({ ip }) => ip),
+        mrpSessionIdleInterval: SII,
+        mrpSessionActiveInterval: SAI
+      };
+    });
+  }
+  async getNodeIpAddresses(nodeId, preferCache = true) {
+    const node = this.#nodes.get(nodeId);
+    const addresses = /* @__PURE__ */ new Set();
+    const generalDiag = node.getRootClusterClient(GeneralDiagnosticsCluster);
+    if (generalDiag) {
+      try {
+        const networkInterfaces = await generalDiag.getNetworkInterfacesAttribute(preferCache ? true : true);
+        if (networkInterfaces) {
+          const interfaces = networkInterfaces.filter(({ isOperational }) => isOperational);
+          if (interfaces.length) {
+            logger.info(`Found ${interfaces.length} operational network interfaces`, interfaces);
+            interfaces.forEach(({ iPv4Addresses, iPv6Addresses }) => {
+              iPv4Addresses.forEach((ip) => addresses.add(ipv4BytesToString(Bytes.of(ip))));
+              iPv6Addresses.forEach((ip) => addresses.add(ipv6BytesToString(Bytes.of(ip))));
+            });
+          }
+        }
+      } catch (e) {
+        logger.info(`Failed to get network interfaces: ${e}`);
+      }
+    }
+    return Array.from(addresses.values());
+  }
+  /**
+   * Ping a node on all its known IP addresses.
+   * @param nodeId The node ID to ping
+   * @param attempts Number of ping attempts per IP (default: 1)
+   * @returns A record of IP addresses to ping success status
+   */
+  async pingNode(nodeId, attempts = 1) {
+    const node = this.#nodes.get(nodeId);
+    const result = {};
+    const ipAddresses = await this.getNodeIpAddresses(nodeId, false);
+    if (ipAddresses.length === 0) {
+      logger.info(`No IP addresses found for node ${nodeId}`);
+      return result;
+    }
+    logger.info(`Pinging node ${nodeId} on ${ipAddresses.length} addresses:`, ipAddresses);
+    const pingPromises = ipAddresses.map(async (ip) => {
+      const cleanIp = ip.includes("%") ? ip.split("%")[0] : ip;
+      logger.debug(`Pinging ${cleanIp}`);
+      const success = await pingIp(ip, 10, attempts);
+      result[ip] = success;
+      logger.debug(`Ping result for ${cleanIp}: ${success}`);
+    });
+    await Promise.all(pingPromises);
+    if (node.isConnected) {
+      const anySuccess = Object.values(result).some((v) => v);
+      if (!anySuccess && ipAddresses.length > 0) {
+        logger.info(`Node ${nodeId} is connected but no pings succeeded`);
+      }
+    }
+    return result;
+  }
+  async decommissionNode(nodeId) {
+    const node = this.#nodes.has(nodeId) ? this.#nodes.get(nodeId) : void 0;
+    await this.#controller.removeNode(nodeId, !!node?.isConnected);
+    this.#nodes.delete(nodeId);
+    this.events.nodeDecommissioned.emit(nodeId);
+  }
+  async openCommissioningWindow(data) {
+    const { nodeId, timeout } = data;
+    const node = this.#nodes.get(nodeId);
+    const { manualPairingCode, qrPairingCode } = await node.openEnhancedCommissioningWindow(timeout);
+    return { manualCode: manualPairingCode, qrCode: qrPairingCode };
+  }
+  async getFabrics(nodeId) {
+    const client = this.#nodes.clusterClientFor(nodeId, EndpointNumber(0), OperationalCredentials.Cluster);
+    return (await client.getFabricsAttribute(true, false)).map(({ fabricId, fabricIndex, vendorId, label }) => ({
+      fabricId,
+      vendorId,
+      fabricIndex,
+      label
+    }));
+  }
+  removeFabric(nodeId, fabricIndex) {
+    const client = this.#nodes.clusterClientFor(nodeId, EndpointNumber(0), OperationalCredentials.Cluster);
+    return client.removeFabric({ fabricIndex });
+  }
+  /**
+   * Set Access Control List entries on a node.
+   * Writes to the ACL attribute on the AccessControl cluster (endpoint 0).
+   */
+  async setAclEntry(nodeId, entries) {
+    const client = this.#nodes.clusterClientFor(nodeId, EndpointNumber(0), AccessControl.Cluster);
+    const aclEntries = entries.map((entry) => ({
+      privilege: entry.privilege,
+      authMode: entry.auth_mode,
+      subjects: entry.subjects?.map((s) => NodeId(BigInt(s))) ?? null,
+      targets: entry.targets?.map((t) => ({
+        cluster: t.cluster !== null ? ClusterId(t.cluster) : null,
+        endpoint: t.endpoint !== null ? EndpointNumber(t.endpoint) : null,
+        deviceType: t.device_type !== null ? DeviceTypeId(t.device_type) : null
+      })) ?? null,
+      fabricIndex: FabricIndex.OMIT_FABRIC
+    }));
+    logger.info("Setting ACL entries", aclEntries);
+    try {
+      await client.setAclAttribute(aclEntries);
+      return [
+        {
+          path: {
+            endpoint_id: 0,
+            cluster_id: AccessControl.Cluster.id,
+            attribute_id: 0
+            // ACL attribute ID
+          },
+          status: 0
+        }
+      ];
+    } catch (error) {
+      StatusResponseError.accept(error);
+      return [
+        {
+          path: {
+            endpoint_id: 0,
+            cluster_id: AccessControl.Cluster.id,
+            attribute_id: 0
+          },
+          status: error.code
+        }
+      ];
+    }
+  }
+  /**
+   * Set bindings on a specific endpoint of a node.
+   * Writes to the Binding attribute on the Binding cluster.
+   */
+  async setNodeBinding(nodeId, endpointId, bindings) {
+    const client = this.#nodes.clusterClientFor(nodeId, endpointId, Binding.Cluster);
+    const bindingEntries = bindings.map((binding) => ({
+      node: binding.node !== null ? NodeId(binding.node) : void 0,
+      group: binding.group !== null ? GroupId(binding.group) : void 0,
+      endpoint: binding.endpoint !== null ? EndpointNumber(binding.endpoint) : void 0,
+      cluster: binding.cluster !== null ? ClusterId(binding.cluster) : void 0,
+      fabricIndex: FabricIndex.OMIT_FABRIC
+    }));
+    logger.info("Setting bindings on endpoint", endpointId, bindingEntries);
+    try {
+      await client.attributes.binding.set(bindingEntries);
+      return [
+        {
+          path: {
+            endpoint_id: endpointId,
+            cluster_id: Binding.Cluster.id,
+            attribute_id: 0
+            // Binding attribute ID
+          },
+          status: 0
+        }
+      ];
+    } catch (error) {
+      StatusResponseError.accept(error);
+      return [
+        {
+          path: {
+            endpoint_id: endpointId,
+            cluster_id: Binding.Cluster.id,
+            attribute_id: 0
+          },
+          status: error.code
+        }
+      ];
+    }
+  }
+  /**
+   * Check if a software update is available for a node.
+   * First checks the cached updates from OTA events, then queries the DCL if not found.
+   */
+  async checkNodeUpdate(nodeId) {
+    if (!this.#otaEnabled) {
+      throw new Error("OTA is disabled.");
+    }
+    const cachedUpdate = this.#availableUpdates.get(nodeId);
+    if (cachedUpdate) {
+      return this.#convertToMatterSoftwareVersion(cachedUpdate);
+    }
+    const node = this.#nodes.get(nodeId);
+    try {
+      const otaProvider = this.#controller.otaProvider;
+      if (!otaProvider) {
+        logger.info("OTA provider not available");
+        return null;
+      }
+      const updatesAvailable = await otaProvider.act(
+        (agent) => agent.get(SoftwareUpdateManager).queryUpdates({
+          peerToCheck: node.node,
+          includeStoredUpdates: true
+        })
+      );
+      const peerAddress = this.#controller.fabric.addressOf(nodeId);
+      const nodeUpdate = updatesAvailable.find(
+        ({ peerAddress: updateAddress }) => PeerAddress.is(peerAddress, updateAddress)
+      );
+      if (nodeUpdate) {
+        const { info } = nodeUpdate;
+        this.#availableUpdates.set(nodeId, info);
+        return this.#convertToMatterSoftwareVersion(info);
+      }
+      return null;
+    } catch (error) {
+      logger.warn(`Failed to check for updates for node ${nodeId}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Trigger a software update for a node.
+   * @param nodeId The node to update
+   * @param softwareVersion The target software version to update to
+   */
+  async updateNode(nodeId, softwareVersion) {
+    if (!this.#otaEnabled) {
+      throw new Error("OTA is disabled.");
+    }
+    if (!this.#nodes.has(nodeId)) {
+      throw new Error(`Node ${nodeId} not found`);
+    }
+    try {
+      const otaProvider = this.#controller.otaProvider;
+      if (!otaProvider) {
+        throw new Error("OTA provider not available");
+      }
+      let updateInfo = this.#availableUpdates.get(nodeId);
+      if (!updateInfo) {
+        const result = await this.checkNodeUpdate(nodeId);
+        if (!result) {
+          throw new Error("No update available for this node");
+        }
+        updateInfo = this.#availableUpdates.get(nodeId);
+        if (!updateInfo) {
+          throw new Error("Failed to get update info");
+        }
+      }
+      logger.info(`Starting update for node ${nodeId} to version ${softwareVersion}`);
+      await otaProvider.act(
+        (agent) => agent.get(SoftwareUpdateManager).forceUpdate(
+          this.#controller.fabric.addressOf(nodeId),
+          updateInfo.vendorId,
+          updateInfo.productId,
+          softwareVersion
+        )
+      );
+      return this.#convertToMatterSoftwareVersion(updateInfo);
+    } catch (error) {
+      logger.error(`Failed to update node ${nodeId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Convert SoftwareUpdateInfo to MatterSoftwareVersion format for WebSocket API.
+   */
+  #convertToMatterSoftwareVersion(updateInfo) {
+    const { vendorId, productId, softwareVersion, softwareVersionString, releaseNotesUrl, source } = updateInfo;
+    return {
+      vid: vendorId,
+      pid: productId,
+      software_version: softwareVersion,
+      software_version_string: softwareVersionString,
+      min_applicable_software_version: 0,
+      // Not available from SoftwareUpdateInfo
+      max_applicable_software_version: softwareVersion - 1,
+      release_notes_url: releaseNotesUrl,
+      update_source: source === "dcl-prod" ? UpdateSource.MAIN_NET_DCL : source === "dcl-test" ? UpdateSource.TEST_NET_DCL : UpdateSource.LOCAL
+    };
+  }
+}
+export {
+  ControllerCommandHandler
+};
+//# sourceMappingURL=ControllerCommandHandler.js.map