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

package/dist/esm/server/WebSocketControllerHandler.js

@@ -0,0 +1,767 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ObserverGroup } from "@matter/general";
+import { camelize, ClusterId, FabricIndex, Logger, Millis, NodeId } from "@matter/main";
+import { EndpointNumber, getClusterById, QrPairingCodeCodec } from "@matter/main/types";
+import { NodeStates } from "@project-chip/matter.js/device";
+import { WebSocketServer } from "ws";
+import { TestNodeCommandHandler } from "../controller/TestNodeCommandHandler.js";
+import { VendorIds } from "../data/VendorIDs.js";
+import { ClusterMap } from "../model/ModelMapper.js";
+import {
+  ServerError,
+  ServerErrorCode
+} from "../types/WebSocketMessageTypes.js";
+import { MATTER_VERSION } from "../util/matterVersion.js";
+import {
+  convertMatterToWebSocketTagBased,
+  parseBigIntAwareJson,
+  splitAttributePath,
+  toBigIntAwareJson
+} from "./Converters.js";
+const logger = Logger.get("WebSocketControllerHandler");
+const EVENT_HISTORY_SIZE = 25;
+const SCHEMA_VERSION = 11;
+class WebSocketControllerHandler {
+  #controller;
+  #commandHandler;
+  #testNodeHandler;
+  #config;
+  #wss;
+  #closed = false;
+  /** Circular buffer for recent node events (max 25) */
+  #eventHistory = [];
+  /** Track when each node was last interviewed (connected) - keyed by nodeId */
+  #lastInterviewDates = /* @__PURE__ */ new Map();
+  constructor(controller, config) {
+    this.#controller = controller;
+    this.#commandHandler = controller.commandHandler;
+    this.#testNodeHandler = new TestNodeCommandHandler();
+    this.#config = config;
+  }
+  /**
+   * Get the appropriate command handler for a node ID.
+   * Returns TestNodeCommandHandler for test nodes, ControllerCommandHandler for real nodes.
+   */
+  #handlerFor(nodeId) {
+    return TestNodeCommandHandler.isTestNodeId(nodeId) ? this.#testNodeHandler : this.#commandHandler;
+  }
+  /**
+   * Add an event to the history buffer, maintaining max size.
+   */
+  #addEventToHistory(event) {
+    this.#eventHistory.push(event);
+    if (this.#eventHistory.length > EVENT_HISTORY_SIZE) {
+      this.#eventHistory.shift();
+    }
+  }
+  /**
+   * Get the event history (last 25 events).
+   */
+  getEventHistory() {
+    return [...this.#eventHistory];
+  }
+  async register(server) {
+    const wss = this.#wss = new WebSocketServer({ server, path: "/ws" });
+    wss.on("connection", (ws) => {
+      if (this.#closed) return;
+      let listening = false;
+      const observers = new ObserverGroup();
+      const sendNodeDetailsEvent = (eventName, nodeId) => {
+        if (this.#closed || !listening) return;
+        switch (eventName) {
+          case "node_added":
+          case "node_updated":
+            this.#collectNodeDetails(nodeId).then(
+              (nodeDetails) => {
+                logger.debug(`Sending ${eventName} event for Node ${nodeId}`, nodeDetails);
+                ws.send(toBigIntAwareJson({ event: eventName, data: nodeDetails }));
+              },
+              (err) => logger.error(`Failed to collect node details for Node ${nodeId}`, err)
+            );
+            break;
+          case "node_removed":
+            logger.debug(`Sending node_removed event for Node ${nodeId}`);
+            ws.send(toBigIntAwareJson({ event: eventName, data: nodeId }));
+            break;
+        }
+      };
+      observers.on(this.#commandHandler.events.attributeChanged, (nodeId, data) => {
+        if (this.#closed) return;
+        const { endpointId, clusterId, attributeId } = data.path;
+        const pathStr = `${endpointId}/${clusterId}/${attributeId}`;
+        const cluster = getClusterById(clusterId);
+        const clusterData = ClusterMap[cluster.name.toLowerCase()];
+        const value = convertMatterToWebSocketTagBased(
+          data.value,
+          clusterData?.attributes[attributeId],
+          clusterData?.model
+        );
+        logger.debug(`Sending attribute_updated event for Node ${nodeId}`, pathStr, value);
+        ws.send(toBigIntAwareJson({ event: "attribute_updated", data: [nodeId, pathStr, value] }));
+      });
+      observers.on(this.#commandHandler.events.eventChanged, (nodeId, data) => {
+        if (this.#closed || !listening) return;
+        const { path, events } = data;
+        const { endpointId, clusterId, eventId } = path;
+        for (const event of events) {
+          let timestamp;
+          let timestampType;
+          if (event.epochTimestamp !== void 0) {
+            timestamp = event.epochTimestamp;
+            timestampType = 1;
+          } else if (event.systemTimestamp !== void 0) {
+            timestamp = event.systemTimestamp;
+            timestampType = 0;
+          } else {
+            timestamp = Date.now();
+            timestampType = 2;
+          }
+          const nodeEvent = {
+            node_id: nodeId,
+            endpoint_id: endpointId,
+            cluster_id: clusterId,
+            event_id: eventId,
+            event_number: event.eventNumber,
+            priority: event.priority,
+            timestamp,
+            timestamp_type: timestampType,
+            data: event.data ?? null
+          };
+          this.#addEventToHistory(nodeEvent);
+          logger.debug(`Sending node_event for Node ${nodeId}`, nodeEvent);
+          ws.send(toBigIntAwareJson({ event: "node_event", data: nodeEvent }));
+        }
+      });
+      observers.on(this.#commandHandler.events.nodeAdded, (nodeId) => {
+        sendNodeDetailsEvent("node_added", nodeId);
+      });
+      observers.on(this.#commandHandler.events.nodeStateChanged, (nodeId, state) => {
+        if (state === NodeStates.Disconnected) return;
+        if (state === NodeStates.Connected) {
+          this.#lastInterviewDates.set(nodeId, /* @__PURE__ */ new Date());
+        }
+        sendNodeDetailsEvent("node_updated", nodeId);
+      });
+      observers.on(this.#commandHandler.events.nodeStructureChanged, (nodeId) => {
+        sendNodeDetailsEvent("node_updated", nodeId);
+      });
+      observers.on(this.#commandHandler.events.nodeDecommissioned, (nodeId) => {
+        sendNodeDetailsEvent("node_removed", nodeId);
+      });
+      observers.on(this.#commandHandler.events.nodeEndpointAdded, (nodeId, endpointId) => {
+        if (this.#closed || !listening) return;
+        logger.info(`Sending endpoint_added event for Node ${nodeId} endpoint ${endpointId}`);
+        ws.send(
+          toBigIntAwareJson({ event: "endpoint_added", data: { node_id: nodeId, endpoint_id: endpointId } })
+        );
+      });
+      observers.on(this.#commandHandler.events.nodeEndpointRemoved, (nodeId, endpointId) => {
+        if (this.#closed || !listening) return;
+        logger.info(`Sending endpoint_removed event for Node ${nodeId} endpoint ${endpointId}`);
+        ws.send(
+          toBigIntAwareJson({
+            event: "endpoint_removed",
+            data: { node_id: nodeId, endpoint_id: endpointId }
+          })
+        );
+      });
+      observers.on(this.#testNodeHandler.nodeAdded, (_nodeId, testNode) => {
+        if (this.#closed || !listening) return;
+        logger.info(`Sending node_added event for test node ${testNode.node_id}`);
+        ws.send(toBigIntAwareJson({ event: "node_added", data: testNode }));
+      });
+      observers.on(this.#testNodeHandler.nodeRemoved, (nodeId) => {
+        if (this.#closed || !listening) return;
+        logger.info(`Sending node_removed event for test node ${nodeId}`);
+        ws.send(toBigIntAwareJson({ event: "node_removed", data: nodeId }));
+      });
+      const onClose = () => observers.close();
+      ws.on(
+        "message",
+        (data) => void this.#handleWebSocketRequest(data.toString()).then(
+          ({ response, enableListeners }) => {
+            if (this.#closed) return;
+            if (enableListeners) {
+              listening = true;
+            }
+            const responseStr = toBigIntAwareJson(response);
+            logger.debug("Sending WebSocket response", responseStr);
+            ws.send(toBigIntAwareJson(response));
+          },
+          (err) => logger.error("Websocket request error", err)
+        )
+      );
+      ws.on("close", onClose);
+      ws.on("error", (err) => {
+        logger.error("Websocket error", err);
+        onClose();
+      });
+      this.#getServerInfo().then(
+        (response) => ws.send(toBigIntAwareJson(response)),
+        (err) => logger.error("Websocket handshake error", err)
+      );
+    });
+    await this.#commandHandler.connect();
+  }
+  unregister() {
+    if (!this.#wss || this.#closed) {
+      return Promise.resolve();
+    }
+    this.#closed = true;
+    const shutdownMessage = toBigIntAwareJson({ event: "server_shutdown", data: {} });
+    this.#wss.clients.forEach((client) => {
+      if (client.readyState === 1) {
+        try {
+          client.send(shutdownMessage, () => {
+            client.close();
+          });
+        } catch (err) {
+          logger.warn("Failed to send server_shutdown event to client", err);
+        }
+      }
+    });
+    console.log("send close to clients");
+    const wss = this.#wss;
+    return new Promise((resolve, reject) => {
+      wss.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  async #handleWebSocketRequest(data) {
+    let messageId;
+    try {
+      logger.debug("Received WebSocket request", data);
+      const request = parseBigIntAwareJson(data);
+      const { command, args } = request;
+      messageId = request.message_id;
+      let result;
+      let enableListeners = void 0;
+      switch (command) {
+        case "start_listening":
+          result = await this.#handleStartListening(args);
+          enableListeners = true;
+          break;
+        case "set_default_fabric_label":
+          result = await this.#handleSetDefaultFabricLabel(args);
+          break;
+        case "commission_with_code":
+          result = await this.#handleCommissionWithCode(args);
+          break;
+        case "commission_on_network":
+          result = await this.#handleCommissionOnNetwork(args);
+          break;
+        case "get_node":
+          result = await this.#handleGetNode(args);
+          break;
+        case "get_nodes":
+          result = await this.#handleGetNodes(args);
+          break;
+        case "get_node_ip_addresses":
+          result = await this.#handleGetNodeIpAddresses(args);
+          break;
+        case "read_attribute":
+          result = await this.#handleReadAttribute(args);
+          break;
+        case "get_vendor_names":
+          result = await this.#handleGetVendorNames(args);
+          break;
+        case "device_command":
+          result = await this.#handleDeviceCommand(args);
+          break;
+        case "write_attribute":
+          result = await this.#handleWriteAttribute(args);
+          break;
+        case "interview_node":
+          result = await this.#handleInterviewNode(args);
+          break;
+        case "ping_node":
+          result = await this.#handlePingNode(args);
+          break;
+        case "diagnostics":
+          result = {
+            info: await this.#getServerInfo(),
+            nodes: await this.#handleGetNodes(args),
+            events: this.getEventHistory()
+          };
+          break;
+        case "remove_node":
+          result = await this.#handleRemoveNode(args);
+          break;
+        case "set_wifi_credentials":
+          result = await this.#handleSetWifiCredentials(args);
+          break;
+        case "set_thread_dataset":
+          result = await this.#handleSetThreadDataset(args);
+          break;
+        case "open_commissioning_window":
+          result = await this.#handleOpenCommissioningWindow(args);
+          break;
+        case "discover_commissionable_nodes":
+          result = await this.#handleDiscoverCommissionableNodes(args);
+          break;
+        case "get_matter_fabrics":
+          result = await this.#handleGetMatterFabrics(args);
+          break;
+        case "remove_matter_fabric":
+          result = await this.#handleRemoveMatterFabric(args);
+          break;
+        case "set_acl_entry":
+          result = await this.#handleSetAclEntry(args);
+          break;
+        case "set_node_binding":
+          result = await this.#handleSetNodeBinding(args);
+          break;
+        case "import_test_node":
+          result = await this.#handleImportTestNode(args);
+          break;
+        case "check_node_update":
+          result = await this.#handleCheckNodeUpdate(args);
+          break;
+        case "update_node":
+          result = await this.#handleUpdateNode(args);
+          break;
+        case "server_info":
+          result = await this.#getServerInfo();
+          break;
+        case "discover":
+          result = await this.#handleDiscoverCommissionableNodes({});
+          break;
+        default:
+          throw ServerError.invalidCommand(command);
+      }
+      if (result === void 0) {
+        throw new Error("No response");
+      }
+      logger.info("WebSocket request handled", messageId, result);
+      return {
+        response: {
+          message_id: messageId ?? "",
+          result
+        },
+        enableListeners
+      };
+    } catch (err) {
+      logger.error("Failed to handle websocket request", err);
+      const errorCode = err instanceof ServerError ? err.code : ServerErrorCode.UnknownError;
+      return {
+        response: {
+          message_id: messageId ?? "",
+          error_code: errorCode,
+          details: err.message
+        }
+      };
+    }
+  }
+  async #getServerInfo() {
+    await this.#commandHandler.start();
+    const { fabricId: fabric_id, compressedFabricId: compressed_fabric_id } = await this.#commandHandler.getCommissionerFabricData();
+    return {
+      fabric_id,
+      compressed_fabric_id,
+      schema_version: SCHEMA_VERSION,
+      min_supported_schema_version: SCHEMA_VERSION,
+      sdk_version: `matter.js/${MATTER_VERSION}`,
+      wifi_credentials_set: !!(this.#config.wifiSsid && this.#config.wifiCredentials),
+      thread_credentials_set: !!this.#config.threadDataset,
+      bluetooth_enabled: this.#commandHandler.bleEnabled
+    };
+  }
+  /**
+   * Broadcast an event to all connected WebSocket clients.
+   */
+  #broadcastEvent(event, data) {
+    if (!this.#wss || this.#closed) return;
+    const message = toBigIntAwareJson({ event, data });
+    this.#wss.clients.forEach((client) => {
+      if (client.readyState === 1) {
+        try {
+          client.send(message);
+        } catch (err) {
+          logger.warn(`Failed to broadcast ${event} event to client`, err);
+        }
+      }
+    });
+  }
+  /**
+   * Send server_info_updated event to all connected clients.
+   */
+  async #broadcastServerInfoUpdated() {
+    const serverInfo = await this.#getServerInfo();
+    logger.info("Broadcasting server_info_updated event", serverInfo);
+    this.#broadcastEvent("server_info_updated", serverInfo);
+  }
+  async #handleStartListening(_args) {
+    return await this.#handleGetNodes({});
+  }
+  async #handleSetDefaultFabricLabel(args) {
+    const { label } = args;
+    const effectiveLabel = label && label.trim() !== "" ? label.trim() : "Home";
+    await this.#commandHandler.setFabricLabel(effectiveLabel);
+    await this.#config.set({ fabricLabel: effectiveLabel });
+    return null;
+  }
+  async #handleCommissionWithCode(args) {
+    const { code, network_only } = args;
+    const isQrCode = code.startsWith("MT:");
+    const nextNodeId = this.#config.nextNodeId;
+    let wifiCredentials = void 0;
+    let threadCredentials = void 0;
+    if (!network_only && this.#commandHandler.bleEnabled) {
+      if (this.#config.wifiSsid && this.#config.wifiCredentials) {
+        wifiCredentials = {
+          wifiSsid: this.#config.wifiSsid,
+          wifiCredentials: this.#config.wifiCredentials
+        };
+      }
+      if (this.#config.threadDataset) {
+        threadCredentials = {
+          networkName: "",
+          // Thread network name is not needed when providing operational dataset
+          operationalDataset: this.#config.threadDataset
+        };
+      }
+    }
+    await this.#config.set({ nextNodeId: nextNodeId + 1 });
+    const { nodeId } = await this.#commandHandler.commissionNode({
+      nodeId: NodeId(nextNodeId),
+      onNetworkOnly: network_only,
+      ...isQrCode ? { qrCode: code } : { manualCode: code },
+      wifiCredentials,
+      threadCredentials
+    });
+    return await this.#collectNodeDetails(nodeId);
+  }
+  async #handleCommissionOnNetwork(args) {
+    const { setup_pin_code, filter_type, filter, ip_addr } = args;
+    const nextNodeId = this.#config.nextNodeId;
+    let commissionRequest;
+    const baseRequest = {
+      nodeId: NodeId(nextNodeId),
+      onNetworkOnly: true,
+      // commission_on_network is always network-only
+      knownAddress: ip_addr ? { ip: ip_addr, port: 5540 } : void 0
+    };
+    switch (filter_type) {
+      case 1:
+        if (filter === void 0)
+          throw ServerError.invalidArguments("filter required for filter_type 1 (short discriminator)");
+        commissionRequest = { ...baseRequest, passcode: setup_pin_code, shortDiscriminator: filter };
+        break;
+      case 2:
+        if (filter === void 0)
+          throw ServerError.invalidArguments("filter required for filter_type 2 (long discriminator)");
+        commissionRequest = { ...baseRequest, passcode: setup_pin_code, longDiscriminator: filter };
+        break;
+      case 3:
+        if (filter === void 0)
+          throw ServerError.invalidArguments("filter required for filter_type 3 (vendor ID)");
+        commissionRequest = { ...baseRequest, passcode: setup_pin_code, vendorId: filter, productId: 0 };
+        break;
+      case 4:
+      // Device type - not directly supported, fall back to no filter
+      case 0:
+      // No filter
+      default:
+        commissionRequest = { ...baseRequest, passcode: setup_pin_code };
+        break;
+    }
+    await this.#config.set({ nextNodeId: nextNodeId + 1 });
+    const { nodeId } = await this.#commandHandler.commissionNode(commissionRequest);
+    return await this.#collectNodeDetails(nodeId);
+  }
+  async #handleGetNodes(args) {
+    const { only_available = false } = args ?? {};
+    const nodeDetails = new Array();
+    for (const node of this.#commandHandler.getNodeIds()) {
+      const details = await this.#collectNodeDetails(node);
+      if (!only_available || details.available) {
+        nodeDetails.push(details);
+      }
+    }
+    for (const testNode of this.#testNodeHandler.getNodes()) {
+      if (!only_available || testNode.available) {
+        nodeDetails.push(testNode);
+      }
+    }
+    return nodeDetails;
+  }
+  async #handleGetNode(args) {
+    const { node_id } = args;
+    const nodeId = NodeId(node_id);
+    const handler = this.#handlerFor(node_id);
+    if (!handler.hasNode(nodeId)) {
+      throw ServerError.nodeNotExists(node_id);
+    }
+    if (handler === this.#commandHandler) {
+      return await this.#commandHandler.getNodeDetails(nodeId, this.#lastInterviewDates.get(nodeId));
+    }
+    return await handler.getNodeDetails(nodeId);
+  }
+  async #handleGetNodeIpAddresses(args) {
+    const { node_id, prefer_cache, scoped } = args;
+    const result = await this.#handlerFor(node_id).getNodeIpAddresses(NodeId(node_id), prefer_cache);
+    if (!scoped) {
+      return result;
+    }
+    return result.map((ip) => ip.includes("%") ? ip.split("%")[0] : ip);
+  }
+  async #handleReadAttribute(args) {
+    const { node_id: nodeId, attribute_path, fabric_filtered = false } = args;
+    const attributePaths = Array.isArray(attribute_path) ? attribute_path : [attribute_path];
+    const result = await this.#handlerFor(nodeId).handleReadAttributes(
+      NodeId(nodeId),
+      attributePaths,
+      fabric_filtered
+    );
+    if (Object.keys(result).length === 0) {
+      throw new Error("Failed to read attribute: no values returned");
+    }
+    return result;
+  }
+  async #handleWriteAttribute(args) {
+    const { node_id: nodeId, attribute_path, value } = args;
+    const { endpointId, clusterId, attributeId } = splitAttributePath(attribute_path);
+    if (endpointId === void 0 || clusterId === void 0 || attributeId === void 0) {
+      throw ServerError.invalidArguments("write_attribute does not support wildcards in attribute path");
+    }
+    const { status } = await this.#handlerFor(nodeId).handleWriteAttribute({
+      nodeId: NodeId(nodeId),
+      endpointId,
+      clusterId,
+      attributeId,
+      value
+    });
+    return [
+      {
+        Path: { EndpointId: endpointId, ClusterId: clusterId, AttributeId: attributeId },
+        Status: status ?? 0
+      }
+    ];
+  }
+  async #handleGetVendorNames(args) {
+    const { filter_vendors } = args;
+    const dclVendors = await this.#controller.getAllVendors();
+    const mergedVendors = {};
+    for (const [vendorIdStr, vendorName] of Object.entries(VendorIds)) {
+      mergedVendors[vendorIdStr] = vendorName;
+    }
+    for (const [vendorId, vendorInfo] of dclVendors) {
+      mergedVendors[vendorId] = vendorInfo.vendorName;
+    }
+    if (!filter_vendors || !filter_vendors.length) {
+      return mergedVendors;
+    }
+    const result = {};
+    for (const vendorId of filter_vendors) {
+      const vendorName = mergedVendors[vendorId];
+      if (vendorName) {
+        result[vendorId] = vendorName;
+      }
+    }
+    return result;
+  }
+  async #handleDeviceCommand(args) {
+    const {
+      node_id: nodeId,
+      endpoint_id: endpointId,
+      cluster_id: clusterId,
+      command_name: commandName,
+      payload,
+      response_type,
+      timed_request_timeout_ms: timedInteractionTimeoutMs
+    } = args;
+    const result = await this.#handlerFor(nodeId).handleInvoke({
+      nodeId: NodeId(nodeId),
+      endpointId: EndpointNumber(endpointId),
+      clusterId: ClusterId(clusterId),
+      commandName: camelize(commandName),
+      data: payload,
+      timedInteractionTimeoutMs: typeof timedInteractionTimeoutMs === "number" ? Millis(timedInteractionTimeoutMs) : void 0
+    });
+    if (TestNodeCommandHandler.isTestNodeId(nodeId) || response_type === null) {
+      return null;
+    }
+    const cmdResult = this.#convertCommandDataToWebSocketTagBased(ClusterId(clusterId), commandName, result);
+    if (cmdResult === void 0) {
+      return null;
+    }
+    return cmdResult;
+  }
+  async #handleInterviewNode(args) {
+    const { node_id } = args;
+    const nodeId = NodeId(node_id);
+    if (TestNodeCommandHandler.isTestNodeId(nodeId)) {
+      const testNode = this.#testNodeHandler.getNode(nodeId);
+      if (testNode === void 0) {
+        throw ServerError.nodeNotExists(nodeId);
+      }
+      logger.debug(`interview_node called for test node ${nodeId}`);
+      this.#broadcastEvent("node_updated", testNode);
+      return null;
+    }
+    await this.#commandHandler.interviewNode(nodeId);
+    return null;
+  }
+  async #handlePingNode(args) {
+    const { node_id, attempts = 1 } = args;
+    return await this.#handlerFor(node_id).pingNode(NodeId(node_id), attempts);
+  }
+  async #handleRemoveNode(args) {
+    const { node_id } = args;
+    await this.#handlerFor(node_id).removeNode(NodeId(node_id));
+    return null;
+  }
+  async #handleSetWifiCredentials(args) {
+    const { ssid, credentials } = args;
+    await this.#config.set({ wifiSsid: ssid, wifiCredentials: credentials });
+    try {
+      await this.#broadcastServerInfoUpdated();
+    } catch (error) {
+      logger.warn("Failed to broadcast server info update", error);
+    }
+    return {};
+  }
+  async #handleSetThreadDataset(args) {
+    const { dataset } = args;
+    await this.#config.set({ threadDataset: dataset });
+    try {
+      await this.#broadcastServerInfoUpdated();
+    } catch (error) {
+      logger.warn("Failed to broadcast server info update", error);
+    }
+    return {};
+  }
+  async #handleOpenCommissioningWindow(args) {
+    const {
+      node_id,
+      timeout
+      /*, iteration, option, discriminator*/
+    } = args;
+    const nodeId = NodeId(node_id);
+    const { manualCode, qrCode } = await this.#commandHandler.openCommissioningWindow({
+      nodeId,
+      timeout
+    });
+    const pairingCodeCodec = QrPairingCodeCodec.decode(qrCode);
+    return { setup_pin_code: pairingCodeCodec[0].passcode, setup_manual_code: manualCode, setup_qr_code: qrCode };
+  }
+  async #handleDiscoverCommissionableNodes(_args) {
+    const result = await this.#commandHandler.handleDiscovery({});
+    return result.map(
+      ({
+        commissioningMode,
+        deviceName,
+        deviceType,
+        hostName,
+        instanceName,
+        longDiscriminator,
+        // numIPs,
+        pairingHint,
+        pairingInstruction,
+        port,
+        productId,
+        rotatingId,
+        // rotatingIdLen,
+        // shortDiscriminator,
+        // supportsTcpClient,
+        supportsTcpServer,
+        vendorId,
+        addresses,
+        mrpSessionActiveInterval,
+        mrpSessionIdleInterval
+      }) => ({
+        instance_name: instanceName,
+        host_name: hostName,
+        // TODO
+        port,
+        long_discriminator: longDiscriminator,
+        vendor_id: vendorId,
+        product_id: productId,
+        commissioning_mode: commissioningMode,
+        device_type: deviceType,
+        device_name: deviceName,
+        pairing_instruction: pairingInstruction,
+        pairing_hint: pairingHint,
+        mrp_retry_interval_idle: mrpSessionIdleInterval,
+        mrp_retry_interval_active: mrpSessionActiveInterval,
+        supports_tcp: supportsTcpServer,
+        addresses,
+        rotating_id: rotatingId
+      })
+    );
+  }
+  async #handleGetMatterFabrics(args) {
+    const { node_id } = args;
+    const nodeId = NodeId(node_id);
+    const fabrics = await this.#commandHandler.getFabrics(nodeId);
+    return fabrics.map(({ fabricId, vendorId, fabricIndex, label }) => ({
+      fabric_id: fabricId,
+      vendor_id: vendorId,
+      fabric_index: fabricIndex,
+      fabric_label: label,
+      vendor_name: VendorIds[vendorId]
+    }));
+  }
+  async #handleRemoveMatterFabric(args) {
+    const { node_id, fabric_index } = args;
+    await this.#commandHandler.removeFabric(NodeId(node_id), FabricIndex(fabric_index));
+    return {};
+  }
+  async #handleSetAclEntry(args) {
+    const { node_id, entry } = args;
+    return await this.#commandHandler.setAclEntry(NodeId(node_id), entry);
+  }
+  async #handleSetNodeBinding(args) {
+    const { node_id, endpoint, bindings } = args;
+    return await this.#commandHandler.setNodeBinding(NodeId(node_id), EndpointNumber(endpoint), bindings);
+  }
+  async #handleImportTestNode(args) {
+    const { dump } = args;
+    this.#testNodeHandler.importTestNodes(dump);
+    return null;
+  }
+  async #handleCheckNodeUpdate(args) {
+    const { node_id } = args;
+    return await this.#commandHandler.checkNodeUpdate(NodeId(node_id));
+  }
+  async #handleUpdateNode(args) {
+    const { node_id, software_version } = args;
+    const targetVersion = typeof software_version === "string" ? parseInt(software_version, 10) : software_version;
+    return await this.#commandHandler.updateNode(NodeId(node_id), targetVersion);
+  }
+  async #collectNodeDetails(nodeId) {
+    const lastInterviewDate = this.#lastInterviewDates.get(nodeId);
+    return await this.#commandHandler.getNodeDetails(nodeId, lastInterviewDate);
+  }
+  #convertCommandDataToWebSocketTagBased(clusterId, commandName, value, clusterData) {
+    if (!clusterData) {
+      const cluster = getClusterById(clusterId);
+      clusterData = clusterData ?? ClusterMap[cluster.name.toLowerCase()];
+    }
+    if (clusterData === void 0 || clusterData.commands[commandName.toLowerCase()] === void 0) {
+      logger.warn(
+        `Cluster ${clusterId} does not have command ${commandName}. Do not convert data to WebSocket tag based`,
+        value
+      );
+      return {};
+    }
+    return convertMatterToWebSocketTagBased(
+      value,
+      clusterData.commands[commandName.toLowerCase()].responseModel,
+      clusterData.model
+    );
+  }
+}
+export {
+  WebSocketControllerHandler
+};
+//# sourceMappingURL=WebSocketControllerHandler.js.map