@matter-server/dashboard 0.2.0-alpha.0-00000000-000000000

package/dist/web/js/main.js

@@ -0,0 +1,547 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const BIGINT_MARKER = "__BIGINT__";
+function toBigIntAwareJson(value, spaces) {
+  const replacements = new Array();
+  let result = JSON.stringify(value, (_key, val) => {
+    if (typeof val === "bigint") {
+      if (val > Number.MAX_SAFE_INTEGER) {
+        replacements.push({
+          from: `"0x${val.toString(16)}"`,
+          to: val.toString()
+        });
+        return `0x${val.toString(16)}`;
+      } else {
+        return Number(val);
+      }
+    }
+    return val;
+  }, spaces);
+  if (replacements.length > 0) {
+    replacements.forEach(({
+      from,
+      to
+    }) => {
+      result = result.replaceAll(from, to);
+    });
+  }
+  return result;
+}
+function parseBigIntAwareJson(json) {
+  const processed = json.replace(/([:,[])\s*(\d{15,})(?=[,}\]\s])/g, (match, prefix, number) => {
+    const num = BigInt(number);
+    if (num > Number.MAX_SAFE_INTEGER) {
+      return `${prefix}"${BIGINT_MARKER}${number}"`;
+    }
+    return match;
+  });
+  return JSON.parse(processed, (_key, value) => {
+    if (typeof value === "string" && value.startsWith(BIGINT_MARKER)) {
+      return BigInt(value.slice(BIGINT_MARKER.length));
+    }
+    return value;
+  });
+}
+
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class Connection {
+  /**
+   * Create a new connection.
+   * @param ws_server_url WebSocket server URL
+   * @param wsFactory Optional factory function to create WebSocket instances.
+   *                  If not provided, uses the global WebSocket constructor.
+   */
+  constructor(ws_server_url, wsFactory) {
+    this.ws_server_url = ws_server_url;
+    this.ws_server_url = ws_server_url;
+    this.wsFactory = wsFactory ?? (url => new WebSocket(url));
+  }
+  serverInfo = void 0;
+  socket;
+  wsFactory;
+  get connected() {
+    var _this$socket;
+    return ((_this$socket = this.socket) === null || _this$socket === void 0 ? void 0 : _this$socket.readyState) === 1;
+  }
+  async connect(onMessage, onConnectionLost) {
+    if (this.socket) {
+      throw new Error("Already connected");
+    }
+    console.debug("Trying to connect");
+    return new Promise((resolve, reject) => {
+      this.socket = this.wsFactory(this.ws_server_url);
+      this.socket.onopen = () => {
+        console.log("WebSocket Connected");
+      };
+      this.socket.onclose = () => {
+        console.log("WebSocket Closed");
+        onConnectionLost();
+      };
+      this.socket.onerror = error => {
+        console.error("WebSocket Error: ", error);
+        reject(new Error("WebSocket Error"));
+      };
+      this.socket.onmessage = event => {
+        const dataStr = typeof event.data === "string" ? event.data : String(event.data);
+        const data = parseBigIntAwareJson(dataStr);
+        console.log("WebSocket OnMessage", data);
+        if (!this.serverInfo) {
+          this.serverInfo = data;
+          resolve();
+          return;
+        }
+        onMessage(data);
+      };
+    });
+  }
+  disconnect() {
+    if (this.socket) {
+      this.socket.close();
+      this.socket = void 0;
+    }
+  }
+  sendMessage(message) {
+    if (!this.socket) {
+      throw new Error("Not connected");
+    }
+    console.log("WebSocket send message", message);
+    this.socket.send(toBigIntAwareJson(message));
+  }
+}
+
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MatterError extends Error {}
+class InvalidServerVersion extends MatterError {}
+
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MatterNode {
+  constructor(data) {
+    this.data = data;
+    this.node_id = data.node_id;
+    this.date_commissioned = data.date_commissioned;
+    this.last_interview = data.last_interview;
+    this.interview_version = data.interview_version;
+    this.available = data.available;
+    this.is_bridge = data.is_bridge;
+    this.attributes = data.attributes;
+    this.attribute_subscriptions = data.attribute_subscriptions;
+  }
+  node_id;
+  date_commissioned;
+  last_interview;
+  interview_version;
+  available;
+  is_bridge;
+  attributes;
+  attribute_subscriptions;
+  get nodeLabel() {
+    const label = this.attributes["0/40/5"];
+    if (typeof label !== "string") return "";
+    if (label.includes("\0\0")) return "";
+    return label.trim();
+  }
+  get vendorName() {
+    const value = this.attributes["0/40/1"];
+    return typeof value === "string" ? value : "";
+  }
+  get productName() {
+    const value = this.attributes["0/40/3"];
+    return typeof value === "string" ? value : "";
+  }
+  get serialNumber() {
+    const value = this.attributes["0/40/15"];
+    return typeof value === "string" ? value : "";
+  }
+  get updateState() {
+    const value = this.attributes["0/42/2"];
+    return typeof value === "number" ? value : void 0;
+  }
+  get updateStateProgress() {
+    const value = this.attributes["0/42/3"];
+    return typeof value === "number" ? value : void 0;
+  }
+  update(data) {
+    return new MatterNode({
+      ...this.data,
+      ...data
+    });
+  }
+}
+
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function toNodeKey(nodeId) {
+  return String(nodeId);
+}
+class MatterClient {
+  /**
+   * Create a new MatterClient.
+   * @param url WebSocket URL to connect to
+   * @param wsFactory Optional factory function to create WebSocket instances.
+   *                  For Node.js, pass: (url) => new WebSocket(url) from the 'ws' package.
+   *                  For browser, leave undefined to use native WebSocket.
+   */
+  constructor(url, wsFactory) {
+    this.url = url;
+    this.url = url;
+    this.connection = new Connection(this.url, wsFactory);
+    this.serverBaseAddress = this.url.split("://")[1].split(":")[0] || "";
+  }
+  connection;
+  nodes = {};
+  serverBaseAddress;
+  /** Whether this client is connected to a production server (optional, for UI purposes) */
+  isProduction = false;
+  // Using 'unknown' for resolve since the actual types vary by command
+  result_futures = {};
+  msgId = 0;
+  eventListeners = {};
+  get serverInfo() {
+    return this.connection.serverInfo;
+  }
+  addEventListener(event, listener) {
+    if (!this.eventListeners[event]) {
+      this.eventListeners[event] = [];
+    }
+    this.eventListeners[event].push(listener);
+    return () => {
+      this.eventListeners[event] = this.eventListeners[event].filter(l => l !== listener);
+    };
+  }
+  async commissionWithCode(code, networkOnly = true) {
+    return await this.sendCommand("commission_with_code", 0, {
+      code,
+      network_only: networkOnly
+    });
+  }
+  async setWifiCredentials(ssid, credentials) {
+    await this.sendCommand("set_wifi_credentials", 0, {
+      ssid,
+      credentials
+    });
+  }
+  async setThreadOperationalDataset(dataset) {
+    await this.sendCommand("set_thread_dataset", 0, {
+      dataset
+    });
+  }
+  async openCommissioningWindow(nodeId, timeout, iteration, option, discriminator) {
+    return await this.sendCommand("open_commissioning_window", 0, {
+      node_id: nodeId,
+      timeout,
+      iteration,
+      option,
+      discriminator
+    });
+  }
+  async discoverCommissionableNodes() {
+    return await this.sendCommand("discover_commissionable_nodes", 0, {});
+  }
+  async getMatterFabrics(nodeId) {
+    return await this.sendCommand("get_matter_fabrics", 3, {
+      node_id: nodeId
+    });
+  }
+  async removeMatterFabric(nodeId, fabricIndex) {
+    await this.sendCommand("remove_matter_fabric", 3, {
+      node_id: nodeId,
+      fabric_index: fabricIndex
+    });
+  }
+  async pingNode(nodeId, attempts = 1) {
+    return await this.sendCommand("ping_node", 0, {
+      node_id: nodeId,
+      attempts
+    });
+  }
+  async getNodeIPAddresses(nodeId, preferCache, scoped) {
+    return await this.sendCommand("get_node_ip_addresses", 8, {
+      node_id: nodeId,
+      prefer_cache: preferCache,
+      scoped
+    });
+  }
+  async removeNode(nodeId) {
+    await this.sendCommand("remove_node", 0, {
+      node_id: nodeId
+    });
+  }
+  async interviewNode(nodeId) {
+    await this.sendCommand("interview_node", 0, {
+      node_id: nodeId
+    });
+  }
+  async importTestNode(dump) {
+    await this.sendCommand("import_test_node", 0, {
+      dump
+    });
+  }
+  async readAttribute(nodeId, attributePath) {
+    return await this.sendCommand("read_attribute", 0, {
+      node_id: nodeId,
+      attribute_path: attributePath
+    });
+  }
+  async writeAttribute(nodeId, attributePath, value) {
+    return await this.sendCommand("write_attribute", 0, {
+      node_id: nodeId,
+      attribute_path: attributePath,
+      value
+    });
+  }
+  async checkNodeUpdate(nodeId) {
+    return await this.sendCommand("check_node_update", 10, {
+      node_id: nodeId
+    });
+  }
+  async updateNode(nodeId, softwareVersion) {
+    await this.sendCommand("update_node", 10, {
+      node_id: nodeId,
+      software_version: softwareVersion
+    });
+  }
+  async setACLEntry(nodeId, entry) {
+    return await this.sendCommand("set_acl_entry", 0, {
+      node_id: nodeId,
+      entry
+    });
+  }
+  async setNodeBinding(nodeId, endpoint, bindings) {
+    return await this.sendCommand("set_node_binding", 0, {
+      node_id: nodeId,
+      endpoint,
+      bindings
+    });
+  }
+  async deviceCommand(nodeId, endpointId, clusterId, commandName, payload = {}) {
+    return await this.sendCommand("device_command", 0, {
+      node_id: nodeId,
+      endpoint_id: endpointId,
+      cluster_id: clusterId,
+      command_name: commandName,
+      payload,
+      response_type: null
+    });
+  }
+  async getNodes(onlyAvailable = false) {
+    return await this.sendCommand("get_nodes", 0, {
+      only_available: onlyAvailable
+    });
+  }
+  async getNode(nodeId) {
+    return await this.sendCommand("get_node", 0, {
+      node_id: nodeId
+    });
+  }
+  async getVendorNames(filterVendors) {
+    return await this.sendCommand("get_vendor_names", 0, {
+      filter_vendors: filterVendors
+    });
+  }
+  async fetchServerInfo() {
+    return await this.sendCommand("server_info", 0, {});
+  }
+  async setDefaultFabricLabel(label) {
+    await this.sendCommand("set_default_fabric_label", 0, {
+      label
+    });
+  }
+  sendCommand(command, require_schema = void 0, args) {
+    if (require_schema && this.serverInfo.schema_version < require_schema) {
+      throw new InvalidServerVersion(`Command not available due to incompatible server version. Update the Matter Server to a version that supports at least api schema ${require_schema}.`);
+    }
+    const messageId = ++this.msgId;
+    const message = {
+      message_id: messageId.toString(),
+      command,
+      args
+    };
+    const messagePromise = new Promise((resolve, reject) => {
+      this.result_futures[messageId] = {
+        resolve,
+        reject
+      };
+      this.connection.sendMessage(message);
+    });
+    return messagePromise.finally(() => {
+      delete this.result_futures[messageId];
+    });
+  }
+  async connect() {
+    if (this.connection.connected) {
+      return;
+    }
+    await this.connection.connect(msg => this._handleIncomingMessage(msg), () => this.fireEvent("connection_lost"));
+  }
+  disconnect(clearStorage = false) {
+    if (this.connection && this.connection.connected) {
+      this.connection.disconnect();
+    }
+    if (clearStorage && typeof localStorage !== "undefined") {
+      localStorage.removeItem("matterURL");
+      location.reload();
+    }
+  }
+  async startListening() {
+    await this.connect();
+    const nodesArray = await this.sendCommand("start_listening", 0, {});
+    const nodes = {};
+    for (const node of nodesArray) {
+      nodes[toNodeKey(node.node_id)] = new MatterNode(node);
+    }
+    this.nodes = nodes;
+  }
+  _handleIncomingMessage(msg) {
+    if ("event" in msg) {
+      this._handleEventMessage(msg);
+      return;
+    }
+    if ("error_code" in msg) {
+      const promise = this.result_futures[msg.message_id];
+      if (promise) {
+        promise.reject(new Error(msg.details));
+        delete this.result_futures[msg.message_id];
+      }
+      return;
+    }
+    if ("result" in msg) {
+      const promise = this.result_futures[msg.message_id];
+      if (promise) {
+        promise.resolve(msg.result);
+        delete this.result_futures[msg.message_id];
+      }
+      return;
+    }
+    console.warn("Received message with unknown format", msg);
+  }
+  _handleEventMessage(event) {
+    console.log("Incoming event", event);
+    this.onRawEvent(event);
+    if (event.event === "node_added") {
+      const node = new MatterNode(event.data);
+      this.nodes = {
+        ...this.nodes,
+        [toNodeKey(node.node_id)]: node
+      };
+      this.fireEvent("nodes_changed");
+      return;
+    }
+    if (event.event === "node_removed") {
+      delete this.nodes[toNodeKey(event.data)];
+      this.nodes = {
+        ...this.nodes
+      };
+      this.fireEvent("nodes_changed");
+      return;
+    }
+    if (event.event === "node_updated") {
+      const node = new MatterNode(event.data);
+      this.nodes = {
+        ...this.nodes,
+        [toNodeKey(node.node_id)]: node
+      };
+      this.fireEvent("nodes_changed");
+      return;
+    }
+    if (event.event === "attribute_updated") {
+      const [nodeId, attributeKey, attributeValue] = event.data;
+      const nodeKey = toNodeKey(nodeId);
+      const existingNode = this.nodes[nodeKey];
+      if (existingNode) {
+        const node = new MatterNode(existingNode.data);
+        node.attributes[attributeKey] = attributeValue;
+        this.nodes = {
+          ...this.nodes,
+          [nodeKey]: node
+        };
+        this.fireEvent("nodes_changed");
+      }
+      return;
+    }
+    if (event.event === "server_info_updated") {
+      this.connection.serverInfo = event.data;
+      this.fireEvent("server_info_updated");
+      return;
+    }
+    if (event.event === "server_shutdown") {
+      this.fireEvent("server_shutdown");
+      this.disconnect();
+      return;
+    }
+  }
+  fireEvent(event) {
+    const listeners = this.eventListeners[event];
+    if (listeners) {
+      for (const listener of listeners) {
+        listener();
+      }
+    }
+  }
+  /**
+   * Hook for subclasses to receive raw events.
+   * Override this method to intercept all incoming events.
+   * @param event The raw event message
+   */
+  onRawEvent(_event) {}
+}
+
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function main() {
+  import('./matter-dashboard-app-5UjO1Ik8.js').then(function (n) { return n.s; });
+  let url = "";
+  const isProductionServer = location.origin.includes(":5580") || location.href.includes("hassio_ingress") || location.href.includes("/api/ingress/");
+  if (!isProductionServer) {
+    let storageUrl = localStorage.getItem("matterURL");
+    if (!storageUrl) {
+      const urlParams = new URLSearchParams(window.location.search);
+      const suggestedUrl = urlParams.get("url");
+      storageUrl = prompt("Enter Websocket URL to a running Matter Server", suggestedUrl || "ws://localhost:5580/ws");
+      if (!storageUrl) {
+        alert("Unable to connect without URL");
+        return;
+      }
+      if (suggestedUrl) {
+        history.pushState({}, "", window.location.pathname);
+      }
+      localStorage.setItem("matterURL", storageUrl);
+    }
+    url = storageUrl;
+  } else {
+    let baseUrl = window.location.origin + window.location.pathname;
+    if (baseUrl.endsWith("/")) {
+      baseUrl = baseUrl.slice(0, -1);
+    }
+    url = baseUrl.replace("http", "ws") + "/ws";
+    console.log(`Connecting to Matter Server API using url: ${url}`);
+  }
+  const client = new MatterClient(url);
+  client.isProduction = isProductionServer;
+  const dashboard = document.createElement("matter-dashboard-app");
+  dashboard.client = client;
+  document.body.append(dashboard);
+}
+main();
+
+export { toBigIntAwareJson as t };