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

package/dist/esm/util/network.js

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+const PLATFORM_MAC = platform() === "darwin";
+async function pingIp(ipAddress, timeout = 2, attempts = 1) {
+  const isIpv6 = ipAddress.includes(":");
+  let command;
+  let args;
+  if (isIpv6 && PLATFORM_MAC) {
+    command = "ping6";
+    args = ["-c", "1", ipAddress];
+  } else if (isIpv6) {
+    command = "ping";
+    args = ["-6", "-c", "1", "-W", timeout.toString(), ipAddress];
+  } else {
+    command = "ping";
+    args = ["-c", "1", "-W", timeout.toString(), ipAddress];
+  }
+  while (attempts > 0) {
+    attempts--;
+    try {
+      const success = await runPingCommand(command, args, timeout + 2);
+      if (success || attempts === 0) {
+        return success;
+      }
+    } catch {
+      if (attempts === 0) {
+        return false;
+      }
+    }
+    if (attempts > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 1e4));
+    }
+  }
+  return false;
+}
+function runPingCommand(command, args, timeoutSeconds) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      proc.kill();
+      reject(new Error("Ping timeout"));
+    }, timeoutSeconds * 1e3);
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      resolve(code === 0);
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+export {
+  pingIp
+};
+//# sourceMappingURL=network.js.map

package/dist/esm/util/network.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/util/network.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,aAAa;AACtB,SAAS,gBAAgB;AAEzB,MAAM,eAAe,SAAS,MAAM;AASpC,eAAsB,OAAO,WAAmB,UAAU,GAAG,WAAW,GAAqB;AACzF,QAAM,SAAS,UAAU,SAAS,GAAG;AAGrC,MAAI;AACJ,MAAI;AAEJ,MAAI,UAAU,cAAc;AAExB,cAAU;AACV,WAAO,CAAC,MAAM,KAAK,SAAS;AAAA,EAChC,WAAW,QAAQ;AAEf,cAAU;AACV,WAAO,CAAC,MAAM,MAAM,KAAK,MAAM,QAAQ,SAAS,GAAG,SAAS;AAAA,EAChE,OAAO;AAEH,cAAU;AACV,WAAO,CAAC,MAAM,KAAK,MAAM,QAAQ,SAAS,GAAG,SAAS;AAAA,EAC1D;AAEA,SAAO,WAAW,GAAG;AACjB;AACA,QAAI;AACA,YAAM,UAAU,MAAM,eAAe,SAAS,MAAM,UAAU,CAAC;AAC/D,UAAI,WAAW,aAAa,GAAG;AAC3B,eAAO;AAAA,MACX;AAAA,IACJ,QAAQ;AAEJ,UAAI,aAAa,GAAG;AAChB,eAAO;AAAA,MACX;AAAA,IACJ;AAEA,QAAI,WAAW,GAAG;AACd,YAAM,IAAI,QAAQ,aAAW,WAAW,SAAS,GAAK,CAAC;AAAA,IAC3D;AAAA,EACJ;AACA,SAAO;AACX;AAKA,SAAS,eAAe,SAAiB,MAAgB,gBAA0C;AAC/F,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACpC,UAAM,OAAO,MAAM,SAAS,MAAM;AAAA,MAC9B,OAAO,CAAC,UAAU,QAAQ,MAAM;AAAA,IACpC,CAAC;AAED,UAAM,QAAQ,WAAW,MAAM;AAC3B,WAAK,KAAK;AACV,aAAO,IAAI,MAAM,cAAc,CAAC;AAAA,IACpC,GAAG,iBAAiB,GAAI;AAExB,SAAK,GAAG,SAAS,UAAQ;AACrB,mBAAa,KAAK;AAClB,cAAQ,SAAS,CAAC;AAAA,IACtB,CAAC;AAED,SAAK,GAAG,SAAS,SAAO;AACpB,mBAAa,KAAK;AAClB,aAAO,GAAG;AAAA,IACd,CAAC;AAAA,EACL,CAAC;AACL;",
+  "names": []
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@matter-server/ws-controller",
+    "version": "0.2.0-alpha.0-00000000-000000000",
+    "type": "module",
+    "description": "matter.js based Matter controller library",
+    "bugs": {
+        "url": "https://github.com/matter-js/matterjs-server/issues"
+    },
+    "homepage": "https://github.com/matter-js/matterjs-server",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/matter-js/matterjs-server.git"
+    },
+    "author": "Apollon77",
+    "main": "dist/esm/index.js",
+    "scripts": {
+        "clean": "matter-build clean",
+        "build": "matter-build",
+        "build-clean": "matter-build --clean"
+    },
+    "engines": {
+        "node": ">=20.19.0 <22.0.0 || >=22.13.0"
+    },
+    "optionalDependencies": {
+        "@matter/nodejs-ble": "0.16.1"
+    },
+    "dependencies": {
+        "@matter/main": "0.16.1",
+        "@project-chip/matter.js": "0.16.1",
+        "ws": "^8.18.3"
+    },
+    "devDependencies": {
+        "@types/node": "^25.0.3",
+        "@types/ws": "^8.18.1"
+    },
+    "files": [
+        "dist/**/*",
+        "src/**/*",
+        "LICENSE",
+        "README.md"
+    ],
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/src/controller/AttributeDataCache.ts

@@ -0,0 +1,194 @@
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ClusterBehavior, Logger, NodeId } from "@matter/main";
+import { DecodedAttributeReportValue } from "@matter/main/protocol";
+import { AttributeId, ClusterId, EndpointNumber, getClusterById } from "@matter/main/types";
+import { Endpoint, PairedNode } from "@project-chip/matter.js/device";
+import { ClusterMap } from "../model/ModelMapper.js";
+import { buildAttributePath, convertMatterToWebSocketTagBased } from "../server/Converters.js";
+import { AttributesData } from "../types/CommandHandler.js";
+
+const logger = Logger.get("AttributeDataCache");
+
+/**
+ * Nested cache structure for node attributes in WebSocket format.
+ * Structure: endpointId -> clusterId -> attributeId -> value
+ */
+type EndpointAttributeCache = Map<EndpointNumber, Map<ClusterId, Map<AttributeId, unknown>>>;
+
+/**
+ * Cache for node attributes in WebSocket format.
+ *
+ * Stores attributes pre-converted to WebSocket tag-based format for fast retrieval
+ * when clients request node data. The cache is structured as:
+ * nodeId -> endpointId -> clusterId -> attributeId -> value
+ */
+export class AttributeDataCache {
+    #cache = new Map<NodeId, EndpointAttributeCache>();
+
+    /**
+     * Add a node to the cache and populate its attributes.
+     * If the node is not initialized, the cache entry will be empty.
+     */
+    add(node: PairedNode): void {
+        this.#populateFromNode(node);
+    }
+
+    /**
+     * Remove a node from the cache.
+     */
+    delete(nodeId: NodeId): void {
+        this.#cache.delete(nodeId);
+    }
+
+    /**
+     * Update (reinitialize) the cache for a node.
+     * Creates a fresh cache structure from the node's current state.
+     * Use this when the node structure may have changed (endpoints added/removed).
+     */
+    update(node: PairedNode): void {
+        this.#populateFromNode(node);
+    }
+
+    /**
+     * Update a single attribute in the cache.
+     * Use this for incremental updates when an attribute value changes.
+     */
+    updateAttribute(nodeId: NodeId, data: DecodedAttributeReportValue<any>): void {
+        const { endpointId, clusterId, attributeId } = data.path;
+
+        let nodeCache = this.#cache.get(nodeId);
+        if (!nodeCache) {
+            nodeCache = new Map();
+            this.#cache.set(nodeId, nodeCache);
+        }
+
+        let endpointCache = nodeCache.get(endpointId);
+        if (!endpointCache) {
+            endpointCache = new Map();
+            nodeCache.set(endpointId, endpointCache);
+        }
+
+        let clusterCache = endpointCache.get(clusterId);
+        if (!clusterCache) {
+            clusterCache = new Map();
+            endpointCache.set(clusterId, clusterCache);
+        }
+
+        // Convert and store the value
+        const cluster = getClusterById(clusterId);
+        const clusterData = ClusterMap[cluster.name.toLowerCase()];
+        const convertedValue = convertMatterToWebSocketTagBased(
+            data.value,
+            clusterData?.attributes[attributeId],
+            clusterData?.model,
+        );
+        clusterCache.set(attributeId, convertedValue);
+    }
+
+    /**
+     * Get cached attributes for a node as flat AttributesData.
+     * Returns undefined if no cache exists for the node.
+     */
+    get(nodeId: NodeId): AttributesData | undefined {
+        const nodeCache = this.#cache.get(nodeId);
+        if (!nodeCache) {
+            return undefined;
+        }
+
+        const attributes: AttributesData = {};
+        for (const [endpointId, endpointCache] of nodeCache) {
+            for (const [clusterId, clusterCache] of endpointCache) {
+                for (const [attributeId, value] of clusterCache) {
+                    const pathStr = buildAttributePath(endpointId, clusterId, attributeId);
+                    attributes[pathStr] = value;
+                }
+            }
+        }
+        return attributes;
+    }
+
+    /**
+     * Check if a node exists in the cache.
+     */
+    has(nodeId: NodeId): boolean {
+        return this.#cache.has(nodeId);
+    }
+
+    /**
+     * Populate the cache for a node from its current state.
+     * Creates a completely fresh cache structure.
+     */
+    #populateFromNode(node: PairedNode): void {
+        const nodeId = node.nodeId;
+        if (!node.initialized) {
+            logger.debug(`Node ${nodeId} not initialized, skipping cache population`);
+            return;
+        }
+
+        const rootEndpoint = node.getRootEndpoint();
+        if (rootEndpoint === undefined) {
+            logger.debug(`Node ${nodeId} has no root endpoint, skipping cache population`);
+            return;
+        }
+
+        const nodeCache: EndpointAttributeCache = new Map();
+        this.#collectEndpointAttributes(rootEndpoint, nodeCache);
+        this.#cache.set(nodeId, nodeCache);
+        logger.debug(`Populated attribute cache for node ${nodeId}`);
+    }
+
+    /**
+     * Recursively collect attributes from an endpoint into the cache structure.
+     * Always creates fresh maps for each endpoint and cluster to ensure no stale data.
+     */
+    #collectEndpointAttributes(endpoint: Endpoint, nodeCache: EndpointAttributeCache): void {
+        const endpointId = endpoint.number!;
+        // Always create fresh maps for this endpoint
+        const endpointCache: Map<ClusterId, Map<AttributeId, unknown>> = new Map();
+
+        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) as Record<string, unknown>;
+
+            // Always create a fresh map for this cluster
+            const clusterCache: Map<AttributeId, unknown> = new Map();
+
+            for (const attributeName in cluster.attributes) {
+                const attribute = cluster.attributes[attributeName];
+                if (attribute === undefined) {
+                    continue;
+                }
+                const attributeValue = clusterState[attributeName];
+                const convertedValue = convertMatterToWebSocketTagBased(
+                    attributeValue,
+                    clusterData?.attributes[attribute.id],
+                    clusterData?.model,
+                );
+                clusterCache.set(attribute.id, convertedValue);
+            }
+
+            if (clusterCache.size) {
+                endpointCache.set(clusterId, clusterCache);
+            }
+        }
+
+        if (endpointCache.size) {
+            nodeCache.set(endpointId, endpointCache);
+        }
+
+        // Recursively collect from child endpoints
+        for (const childEndpoint of endpoint.getChildEndpoints()) {
+            this.#collectEndpointAttributes(childEndpoint, nodeCache);
+        }
+    }
+}