zwave-js 10.0.2 → 10.0.3

package/build/lib/node/Node.js

@@ -1234,6 +1234,7 @@ protocol version:      ${this.protocolVersion}`;
             const securityClass = this.getHighestSecurityClass();
             if (securityClass == undefined ||
                 (0, core_1.securityClassIsS2)(securityClass)) {
+                this.driver.controllerLog.logNode(this.nodeId, "Root device interview: Security S2", "silly");
                 if (!this.driver.securityManager2) {
                     if (!this._hasEmittedNoS2NetworkKeyError) {
                         // Cannot interview a secure device securely without a network key
@@ -1265,6 +1266,7 @@ protocol version:      ${this.protocolVersion}`;
             this.addCC(core_1.CommandClasses.Security, { secure: true });
             // Query supported CCs unless we know for sure that the node wasn't assigned the S0 security class
             if (this.hasSecurityClass(core_1.SecurityClass.S0_Legacy) !== false) {
+                this.driver.controllerLog.logNode(this.nodeId, "Root device interview: Security S0", "silly");
                 if (!this.driver.securityManager) {
                     if (!this._hasEmittedNoS0NetworkKeyError) {
                         // Cannot interview a secure device securely without a network key
@@ -1289,9 +1291,11 @@ protocol version:      ${this.protocolVersion}`;
         // Manufacturer Specific and Version CC need to be handled before the other CCs because they are needed to
         // identify the device and apply device configurations
         if (this.supportsCC(core_1.CommandClasses["Manufacturer Specific"])) {
+            this.driver.controllerLog.logNode(this.nodeId, "Root device interview: Manufacturer Specific", "silly");
             await interviewEndpoint(this, core_1.CommandClasses["Manufacturer Specific"]);
         }
         if (this.supportsCC(core_1.CommandClasses.Version)) {
+            this.driver.controllerLog.logNode(this.nodeId, "Root device interview: Version", "silly");
             await interviewEndpoint(this, core_1.CommandClasses.Version);
             // After the version CC interview of the root endpoint, we have enough info to load the correct device config file
             await this.loadDeviceConfig();
@@ -1338,8 +1342,15 @@ protocol version:      ${this.protocolVersion}`;
             // This interview cannot be done
             throw new core_1.ZWaveError("The CC interview cannot be completed because there are circular dependencies between CCs!", core_1.ZWaveErrorCodes.CC_Invalid);
         }
+        this.driver.controllerLog.logNode(this.nodeId, `Root device interviews before endpoints: ${rootInterviewOrderBeforeEndpoints
+            .map((cc) => `\n· ${(0, core_1.getCCName)(cc)}`)
+            .join("")}`, "silly");
+        this.driver.controllerLog.logNode(this.nodeId, `Root device interviews after endpoints: ${rootInterviewOrderAfterEndpoints
+            .map((cc) => `\n· ${(0, core_1.getCCName)(cc)}`)
+            .join("")}`, "silly");
         // Now that we know the correct order, do the interview in sequence
         for (const cc of rootInterviewOrderBeforeEndpoints) {
+            this.driver.controllerLog.logNode(this.nodeId, `Root device interview: ${(0, core_1.getCCName)(cc)}`, "silly");
             const action = await interviewEndpoint(this, cc);
             if (action === "continue")
                 continue;
@@ -1361,9 +1372,13 @@ protocol version:      ${this.protocolVersion}`;
                 // Security S2 is always supported *securely*
                 endpoint.addCC(core_1.CommandClasses["Security 2"], { secure: true });
                 // If S2 is the highest security class, interview it for the endpoint
-                if (securityClass != undefined &&
-                    (0, core_1.securityClassIsS2)(securityClass) &&
+                if ((0, core_1.securityClassIsS2)(securityClass) &&
                     !!this.driver.securityManager2) {
+                    this.driver.controllerLog.logNode(this.nodeId, {
+                        endpoint: endpoint.index,
+                        message: `Endpoint ${endpoint.index} interview: Security S2`,
+                        level: "silly",
+                    });
                     const action = await interviewEndpoint(endpoint, core_1.CommandClasses["Security 2"]);
                     if (typeof action === "boolean")
                         return action;
@@ -1375,19 +1390,92 @@ protocol version:      ${this.protocolVersion}`;
                 // If S0 is the highest security class, interview it for the endpoint
                 if (securityClass === core_1.SecurityClass.S0_Legacy &&
                     !!this.driver.securityManager) {
+                    this.driver.controllerLog.logNode(this.nodeId, {
+                        endpoint: endpoint.index,
+                        message: `Endpoint ${endpoint.index} interview: Security S0`,
+                        level: "silly",
+                    });
                     const action = await interviewEndpoint(endpoint, core_1.CommandClasses.Security);
                     if (typeof action === "boolean")
                         return action;
                 }
             }
-            if (endpoint.supportsCC(core_1.CommandClasses.Security) &&
-                // The root endpoint has been interviewed, so we know if the device supports security
-                this.hasSecurityClass(core_1.SecurityClass.S0_Legacy) === true &&
-                // Only interview SecurityCC if the network key was set
-                this.driver.securityManager) {
-                // Security is always supported *securely*
-                endpoint.addCC(core_1.CommandClasses.Security, { secure: true });
+            // It has been found that legacy nodes do not always advertise the S0 Command Class in their Multi
+            // Channel Capability Report and still accept all their Command Class using S0 encapsulation.
+            // A controlling node SHOULD try to control End Points with S0 encapsulation even if S0 is not
+            // listed in the Multi Channel Capability Report.
+            const endpointMissingS0 = securityClass === core_1.SecurityClass.S0_Legacy &&
+                this.supportsCC(core_1.CommandClasses.Security) &&
+                !endpoint.supportsCC(core_1.CommandClasses.Security);
+            if (endpointMissingS0) {
+                this.driver.controllerLog.logNode(this.nodeId, {
+                    endpoint: endpoint.index,
+                    message: `is included using Security S0, but endpoint ${endpoint.index} does not list the CC. Testing if it accepts secure commands anyways.`,
+                    level: "silly",
+                });
+                // Define which CCs we can use to test this - and if supported, how
+                const tests = [
+                    {
+                        ccId: core_1.CommandClasses["Z-Wave Plus Info"],
+                        test: () => endpoint.commandClasses["Z-Wave Plus Info"].get(),
+                    },
+                    {
+                        ccId: core_1.CommandClasses["Binary Switch"],
+                        test: () => endpoint.commandClasses["Binary Switch"].get(),
+                    },
+                    {
+                        ccId: core_1.CommandClasses["Binary Sensor"],
+                        test: () => endpoint.commandClasses["Binary Sensor"].get(),
+                    },
+                    {
+                        ccId: core_1.CommandClasses["Multilevel Switch"],
+                        test: () => endpoint.commandClasses["Multilevel Switch"].get(),
+                    },
+                    {
+                        ccId: core_1.CommandClasses["Multilevel Sensor"],
+                        test: () => endpoint.commandClasses["Multilevel Sensor"].get(),
+                    },
+                    // TODO: add other tests if necessary
+                ];
+                for (const { ccId, test } of tests) {
+                    if (!endpoint.supportsCC(ccId))
+                        continue;
+                    // Temporarily mark the CC as secure so we can use it to test
+                    endpoint.addCC(ccId, { secure: true });
+                    // Perform the test and treat errors as negative results
+                    const success = !!(await test().catch(() => false));
+                    if (success) {
+                        this.driver.controllerLog.logNode(this.nodeId, {
+                            endpoint: endpoint.index,
+                            message: `Endpoint ${endpoint.index} accepts/expects secure commands`,
+                            level: "silly",
+                        });
+                        // Mark all endpoint CCs as secure
+                        for (const [ccId] of endpoint.getCCs()) {
+                            endpoint.addCC(ccId, { secure: true });
+                        }
+                    }
+                    else {
+                        this.driver.controllerLog.logNode(this.nodeId, {
+                            endpoint: endpoint.index,
+                            message: `Endpoint ${endpoint.index} is actually not using S0`,
+                            level: "silly",
+                        });
+                        // Mark the CC as not secure again
+                        endpoint.addCC(ccId, { secure: false });
+                    }
+                }
             }
+            // if (
+            // 	endpoint.supportsCC(CommandClasses.Security) &&
+            // 	// The root endpoint has been interviewed, so we know if the device supports security
+            // 	this.hasSecurityClass(SecurityClass.S0_Legacy) === true &&
+            // 	// Only interview SecurityCC if the network key was set
+            // 	this.driver.securityManager
+            // ) {
+            // 	// Security is always supported *securely*
+            // 	endpoint.addCC(CommandClasses.Security, { secure: true });
+            // }
             // The Security S0/S2 CC adds new CCs to the endpoint, so we need to once more remove those
             // that aren't actually properly supported by the device.
             this.applyCommandClassesCompatFlag(endpoint.index);
@@ -1408,8 +1496,20 @@ protocol version:      ${this.protocolVersion}`;
                 // This interview cannot be done
                 throw new core_1.ZWaveError("The CC interview cannot be completed because there are circular dependencies between CCs!", core_1.ZWaveErrorCodes.CC_Invalid);
             }
+            this.driver.controllerLog.logNode(this.nodeId, {
+                endpoint: endpoint.index,
+                message: `Endpoint ${endpoint.index} interview order: ${endpointInterviewOrder
+                    .map((cc) => `\n· ${(0, core_1.getCCName)(cc)}`)
+                    .join("")}`,
+                level: "silly",
+            });
             // Now that we know the correct order, do the interview in sequence
             for (const cc of endpointInterviewOrder) {
+                this.driver.controllerLog.logNode(this.nodeId, {
+                    endpoint: endpoint.index,
+                    message: `Endpoint ${endpoint.index} interview: ${(0, core_1.getCCName)(cc)}`,
+                    level: "silly",
+                });
                 const action = await interviewEndpoint(endpoint, cc);
                 if (action === "continue")
                     continue;
@@ -1419,6 +1519,7 @@ protocol version:      ${this.protocolVersion}`;
         }
         // Continue with the application CCs for the root endpoint
         for (const cc of rootInterviewOrderAfterEndpoints) {
+            this.driver.controllerLog.logNode(this.nodeId, `Root device interview: ${(0, core_1.getCCName)(cc)}`, "silly");
             const action = await interviewEndpoint(this, cc);
             if (action === "continue")
                 continue;