@matter-server/dashboard 0.2.7-alpha.0-20260118-993a1c7 → 0.2.7-alpha.0-20260119-49e7237

package/dist/web/js/main.js

@@ -146,6 +146,8 @@ class Connection {
       };
       this.socket.onclose = () => {
         console.log("WebSocket Closed");
+        this.socket = void 0;
+        this.serverInfo = void 0;
         onConnectionLost();
       };
       this.socket.onerror = error => {
@@ -170,6 +172,7 @@ class Connection {
       this.socket.close();
       this.socket = void 0;
     }
+    this.serverInfo = void 0;
   }
   sendMessage(message) {
     if (!this.socket) {
@@ -187,6 +190,20 @@ class Connection {
  */
 class MatterError extends Error {}
 class InvalidServerVersion extends MatterError {}
+class CommandTimeoutError extends MatterError {
+  constructor(command, timeoutMs) {
+    super(`Command '${command}' timed out after ${timeoutMs}ms`);
+    this.command = command;
+    this.timeoutMs = timeoutMs;
+    this.name = "CommandTimeoutError";
+  }
+}
+class ConnectionClosedError extends MatterError {
+  constructor(message = "Connection closed while command was pending") {
+    super(message);
+    this.name = "ConnectionClosedError";
+  }
+}
 
 /**
  * @license
@@ -255,6 +272,7 @@ class MatterNode {
 function toNodeKey(nodeId) {
   return String(nodeId);
 }
+const DEFAULT_COMMAND_TIMEOUT = 5 * 60 * 1e3;
 class MatterClient {
   /**
    * Create a new MatterClient.
@@ -274,9 +292,12 @@ class MatterClient {
   serverBaseAddress;
   /** Whether this client is connected to a production server (optional, for UI purposes) */
   isProduction = false;
+  /** Default timeout for commands in milliseconds. Set to 0 to disable timeouts. */
+  commandTimeout = DEFAULT_COMMAND_TIMEOUT;
   // Using 'unknown' for resolve since the actual types vary by command
   result_futures = {};
-  msgId = 0;
+  // Start with random offset for defense-in-depth and easier debugging across sessions
+  msgId = Math.floor(Math.random() * 2147483647);
   eventListeners = {};
   get serverInfo() {
     return this.connection.serverInfo;
@@ -290,112 +311,112 @@ class MatterClient {
       this.eventListeners[event] = this.eventListeners[event].filter(l => l !== listener);
     };
   }
-  async commissionWithCode(code, networkOnly = true) {
+  async commissionWithCode(code, networkOnly = true, timeout) {
     return await this.sendCommand("commission_with_code", 0, {
       code,
       network_only: networkOnly
-    });
+    }, timeout);
   }
-  async setWifiCredentials(ssid, credentials) {
+  async setWifiCredentials(ssid, credentials, timeout) {
     await this.sendCommand("set_wifi_credentials", 0, {
       ssid,
       credentials
-    });
+    }, timeout);
   }
-  async setThreadOperationalDataset(dataset) {
+  async setThreadOperationalDataset(dataset, timeout) {
     await this.sendCommand("set_thread_dataset", 0, {
       dataset
-    });
+    }, timeout);
   }
-  async openCommissioningWindow(nodeId, timeout, iteration, option, discriminator) {
+  async openCommissioningWindow(nodeId, windowTimeout, iteration, option, discriminator, timeout) {
     return await this.sendCommand("open_commissioning_window", 0, {
       node_id: nodeId,
-      timeout,
+      timeout: windowTimeout,
       iteration,
       option,
       discriminator
-    });
+    }, timeout);
   }
-  async discoverCommissionableNodes() {
-    return await this.sendCommand("discover_commissionable_nodes", 0, {});
+  async discoverCommissionableNodes(timeout) {
+    return await this.sendCommand("discover_commissionable_nodes", 0, {}, timeout);
   }
-  async getMatterFabrics(nodeId) {
+  async getMatterFabrics(nodeId, timeout) {
     return await this.sendCommand("get_matter_fabrics", 3, {
       node_id: nodeId
-    });
+    }, timeout);
   }
-  async removeMatterFabric(nodeId, fabricIndex) {
+  async removeMatterFabric(nodeId, fabricIndex, timeout) {
     await this.sendCommand("remove_matter_fabric", 3, {
       node_id: nodeId,
       fabric_index: fabricIndex
-    });
+    }, timeout);
   }
-  async pingNode(nodeId, attempts = 1) {
+  async pingNode(nodeId, attempts = 1, timeout) {
     return await this.sendCommand("ping_node", 0, {
       node_id: nodeId,
       attempts
-    });
+    }, timeout);
   }
-  async getNodeIPAddresses(nodeId, preferCache, scoped) {
+  async getNodeIPAddresses(nodeId, preferCache, scoped, timeout) {
     return await this.sendCommand("get_node_ip_addresses", 8, {
       node_id: nodeId,
       prefer_cache: preferCache,
       scoped
-    });
+    }, timeout);
   }
-  async removeNode(nodeId) {
+  async removeNode(nodeId, timeout) {
     await this.sendCommand("remove_node", 0, {
       node_id: nodeId
-    });
+    }, timeout);
   }
-  async interviewNode(nodeId) {
+  async interviewNode(nodeId, timeout) {
     await this.sendCommand("interview_node", 0, {
       node_id: nodeId
-    });
+    }, timeout);
   }
-  async importTestNode(dump) {
+  async importTestNode(dump, timeout) {
     await this.sendCommand("import_test_node", 0, {
       dump
-    });
+    }, timeout);
   }
-  async readAttribute(nodeId, attributePath) {
+  async readAttribute(nodeId, attributePath, timeout) {
     return await this.sendCommand("read_attribute", 0, {
       node_id: nodeId,
       attribute_path: attributePath
-    });
+    }, timeout);
   }
-  async writeAttribute(nodeId, attributePath, value) {
+  async writeAttribute(nodeId, attributePath, value, timeout) {
     return await this.sendCommand("write_attribute", 0, {
       node_id: nodeId,
       attribute_path: attributePath,
       value
-    });
+    }, timeout);
   }
-  async checkNodeUpdate(nodeId) {
+  async checkNodeUpdate(nodeId, timeout) {
     return await this.sendCommand("check_node_update", 10, {
       node_id: nodeId
-    });
+    }, timeout);
   }
-  async updateNode(nodeId, softwareVersion) {
+  async updateNode(nodeId, softwareVersion, timeout) {
     await this.sendCommand("update_node", 10, {
       node_id: nodeId,
       software_version: softwareVersion
-    });
+    }, timeout);
   }
-  async setACLEntry(nodeId, entry) {
+  async setACLEntry(nodeId, entry, timeout) {
     return await this.sendCommand("set_acl_entry", 0, {
       node_id: nodeId,
       entry
-    });
+    }, timeout);
   }
-  async setNodeBinding(nodeId, endpoint, bindings) {
+  async setNodeBinding(nodeId, endpoint, bindings, timeout) {
     return await this.sendCommand("set_node_binding", 0, {
       node_id: nodeId,
       endpoint,
       bindings
-    });
+    }, timeout);
   }
-  async deviceCommand(nodeId, endpointId, clusterId, commandName, payload = {}) {
+  async deviceCommand(nodeId, endpointId, clusterId, commandName, payload = {}, timeout) {
     return await this.sendCommand("device_command", 0, {
       node_id: nodeId,
       endpoint_id: endpointId,
@@ -403,59 +424,147 @@ class MatterClient {
       command_name: commandName,
       payload,
       response_type: null
-    });
+    }, timeout);
   }
-  async getNodes(onlyAvailable = false) {
+  async getNodes(onlyAvailable = false, timeout) {
     return await this.sendCommand("get_nodes", 0, {
       only_available: onlyAvailable
-    });
+    }, timeout);
   }
-  async getNode(nodeId) {
+  async getNode(nodeId, timeout) {
     return await this.sendCommand("get_node", 0, {
       node_id: nodeId
-    });
+    }, timeout);
   }
-  async getVendorNames(filterVendors) {
+  async getVendorNames(filterVendors, timeout) {
     return await this.sendCommand("get_vendor_names", 0, {
       filter_vendors: filterVendors
-    });
+    }, timeout);
   }
-  async fetchServerInfo() {
-    return await this.sendCommand("server_info", 0, {});
+  async fetchServerInfo(timeout) {
+    return await this.sendCommand("server_info", 0, {}, timeout);
   }
-  async setDefaultFabricLabel(label) {
+  async setDefaultFabricLabel(label, timeout) {
     await this.sendCommand("set_default_fabric_label", 0, {
       label
-    });
+    }, timeout);
+  }
+  /**
+   * Get the current log levels for console and file logging.
+   * @param timeout Optional command timeout in milliseconds
+   * @returns The current log level configuration
+   */
+  async getLogLevel(timeout) {
+    return await this.sendCommand("get_loglevel", 0, {}, timeout);
   }
-  sendCommand(command, require_schema = void 0, args) {
+  /**
+   * Set the log level for console and/or file logging.
+   * Changes are temporary and will be reset when the server restarts.
+   * @param consoleLoglevel Console log level to set (optional)
+   * @param fileLoglevel File log level to set, only applied if file logging is enabled (optional)
+   * @param timeout Optional command timeout in milliseconds
+   * @returns The log level configuration after the change
+   */
+  async setLogLevel(consoleLoglevel, fileLoglevel, timeout) {
+    return await this.sendCommand("set_loglevel", 0, {
+      console_loglevel: consoleLoglevel,
+      file_loglevel: fileLoglevel
+    }, timeout);
+  }
+  /**
+   * Send a command to the Matter server.
+   * @param command The command name
+   * @param require_schema Minimum schema version required (0 for any version)
+   * @param args Command arguments
+   * @param timeout Optional timeout in milliseconds. Defaults to `commandTimeout`. Set to 0 to disable.
+   * @returns Promise that resolves with the command result
+   * @throws Error if the command times out or fails
+   */
+  sendCommand(command, require_schema = void 0, args, timeout = this.commandTimeout) {
     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;
+    if (this.msgId >= Number.MAX_SAFE_INTEGER) {
+      this.msgId = 0;
+    }
+    const messageId = String(++this.msgId);
     const message = {
-      message_id: messageId.toString(),
+      message_id: messageId,
       command,
       args
     };
-    const messagePromise = new Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
+      let timeoutId;
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          const pending = this.result_futures[messageId];
+          if (pending) {
+            if (pending.timeoutId) {
+              clearTimeout(pending.timeoutId);
+            }
+            delete this.result_futures[messageId];
+            reject(new CommandTimeoutError(command, timeout));
+          }
+        }, timeout);
+      }
       this.result_futures[messageId] = {
         resolve,
-        reject
+        reject,
+        timeoutId
       };
       this.connection.sendMessage(message);
     });
-    return messagePromise.finally(() => {
+  }
+  /**
+   * Safely resolve a pending command, ensuring it's only resolved once.
+   * Clears timeout and removes from pending futures before resolving.
+   */
+  _resolvePendingCommand(messageId, result) {
+    const pending = this.result_futures[messageId];
+    if (pending) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
       delete this.result_futures[messageId];
-    });
+      pending.resolve(result);
+    }
+  }
+  /**
+   * Safely reject a pending command, ensuring it's only rejected once.
+   * Clears timeout and removes from pending futures before rejecting.
+   */
+  _rejectPendingCommand(messageId, error) {
+    const pending = this.result_futures[messageId];
+    if (pending) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      delete this.result_futures[messageId];
+      pending.reject(error);
+    }
+  }
+  /**
+   * Reject all pending commands with a ConnectionClosedError.
+   * Called when the connection is closed or lost.
+   */
+  _rejectAllPendingCommands() {
+    const error = new ConnectionClosedError();
+    const pendingIds = Object.keys(this.result_futures);
+    for (const messageId of pendingIds) {
+      this._rejectPendingCommand(messageId, error);
+    }
   }
   async connect() {
     if (this.connection.connected) {
       return;
     }
-    await this.connection.connect(msg => this._handleIncomingMessage(msg), () => this.fireEvent("connection_lost"));
+    await this.connection.connect(msg => this._handleIncomingMessage(msg), () => {
+      this._rejectAllPendingCommands();
+      this.fireEvent("connection_lost");
+    });
   }
   disconnect(clearStorage = false) {
+    this._rejectAllPendingCommands();
     if (this.connection && this.connection.connected) {
       this.connection.disconnect();
     }
@@ -479,19 +588,11 @@ class MatterClient {
       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];
-      }
+      this._rejectPendingCommand(msg.message_id, new Error(msg.details));
       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];
-      }
+      this._resolvePendingCommand(msg.message_id, msg.result);
       return;
     }
     console.warn("Received message with unknown format", msg);
@@ -641,7 +742,7 @@ const ThemeService = new ThemeServiceImpl();
  * SPDX-License-Identifier: Apache-2.0
  */
 async function main() {
-  import('./matter-dashboard-app-BxQ4W_uT.js').then(function (n) { return n.s; });
+  import('./matter-dashboard-app-Dr-IYMsD.js').then(function (n) { return n.C; });
   let url = "";
   const isProductionServer = location.origin.includes(":5580") || location.href.includes("hassio_ingress") || location.href.includes("/api/ingress/");
   if (!isProductionServer) {