zwave-js 8.6.0 → 8.7.2

package/build/lib/driver/Driver.js

@@ -56,6 +56,7 @@ const ApplicationUpdateRequest_1 = require("../controller/ApplicationUpdateReque
 const BridgeApplicationCommandRequest_1 = require("../controller/BridgeApplicationCommandRequest");
 const Controller_1 = require("../controller/Controller");
 const GetControllerVersionMessages_1 = require("../controller/GetControllerVersionMessages");
+const Inclusion_1 = require("../controller/Inclusion");
 const SendDataBridgeMessages_1 = require("../controller/SendDataBridgeMessages");
 const SendDataMessages_1 = require("../controller/SendDataMessages");
 const SendDataShared_1 = require("../controller/SendDataShared");
@@ -232,6 +233,7 @@ class Driver extends shared_1.TypedEventEmitter {
         this._controllerLog = new Controller_2.ControllerLogger(this._logContainer);
         // Initialize the cache
         this.cacheDir = this.options.storage.cacheDir;
+        // TODO: Load provisioning list
         // Initialize config manager
         this.configManager = new config_1.ConfigManager({
             logContainer: this._logContainer,
@@ -452,7 +454,9 @@ class Driver extends shared_1.TypedEventEmitter {
             spOpenPromise.resolve();
             // Perform initialization sequence
             await this.writeHeader(serial_1.MessageHeaders.NAK);
-            await this.trySoftReset();
+            // Per the specs, this should be followed by a soft-reset but we need to be able
+            // to handle sticks that don't support the soft reset command. Therefore we do it
+            // after opening the value DBs
             // Try to create the cache directory. This can fail, in which case we should expose a good error message
             try {
                 await this.options.storage.driver.ensureDir(this.cacheDir);
@@ -534,6 +538,32 @@ class Driver extends shared_1.TypedEventEmitter {
     get allNodesReady() {
         return this._nodesReadyEventEmitted;
     }
+    async initValueDBs(homeId) {
+        // Always start the value and metadata databases
+        const options = {
+            ignoreReadErrors: true,
+            ...ThrottlePresets_1.throttlePresets[this.options.storage.throttle],
+        };
+        if (this.options.storage.lockDir) {
+            options.lockfileDirectory = this.options.storage.lockDir;
+        }
+        const valueDBFile = path_1.default.join(this.cacheDir, `${homeId.toString(16)}.values.jsonl`);
+        this._valueDB = new jsonl_db_1.JsonlDB(valueDBFile, {
+            ...options,
+            reviver: (key, value) => (0, core_1.deserializeCacheValue)(value),
+            serializer: (key, value) => (0, core_1.serializeCacheValue)(value),
+        });
+        await this._valueDB.open();
+        const metadataDBFile = path_1.default.join(this.cacheDir, `${homeId.toString(16)}.metadata.jsonl`);
+        this._metadataDB = new jsonl_db_1.JsonlDB(metadataDBFile, options);
+        await this._metadataDB.open();
+        if (process.env.NO_CACHE === "true") {
+            // Since value/metadata DBs are append-only, we need to clear them
+            // if the cache should be ignored
+            this._valueDB.clear();
+            this._metadataDB.clear();
+        }
+    }
     /**
      * Initializes the variables for controller and nodes,
      * adds event handlers and starts the interview process.
@@ -546,42 +576,56 @@ class Driver extends shared_1.TypedEventEmitter {
                 .on("node added", this.onNodeAdded.bind(this))
                 .on("node removed", this.onNodeRemoved.bind(this));
         }
-        const initValueDBs = async () => {
-            // Always start the value and metadata databases
-            const options = {
-                ignoreReadErrors: true,
-                ...ThrottlePresets_1.throttlePresets[this.options.storage.throttle],
-            };
-            if (this.options.storage.lockDir) {
-                options.lockfileDirectory = this.options.storage.lockDir;
-            }
-            const valueDBFile = path_1.default.join(this.cacheDir, `${this._controller.homeId.toString(16)}.values.jsonl`);
-            this._valueDB = new jsonl_db_1.JsonlDB(valueDBFile, {
-                ...options,
-                reviver: (key, value) => (0, core_1.deserializeCacheValue)(value),
-                serializer: (key, value) => (0, core_1.serializeCacheValue)(value),
-            });
-            await this._valueDB.open();
-            const metadataDBFile = path_1.default.join(this.cacheDir, `${this._controller.homeId.toString(16)}.metadata.jsonl`);
-            this._metadataDB = new jsonl_db_1.JsonlDB(metadataDBFile, options);
-            await this._metadataDB.open();
-            if (process.env.NO_CACHE === "true") {
-                // Since value/metadata DBs are append-only, we need to clear them
-                // if the cache should be ignored
-                this._valueDB.clear();
-                this._metadataDB.clear();
-            }
-        };
         if (!this.options.interview.skipInterview) {
+            // Determine controller IDs to open the Value DBs
+            // We need to do this first because some older controllers, especially the UZB1 and
+            // some 500-series sticks in virtualized environments don't respond after a soft reset
+            // No need to initialize databases if skipInterview is true, because it is only used in some
+            // Driver unit tests that don't need access to them
+            // Identify the controller and determine if it supports soft reset
+            await this.controller.identify();
+            if (this.options.enableSoftReset && !(await this.maySoftReset())) {
+                this.driverLog.print(`Soft reset is enabled through config, but this stick does not support it.`, "warn");
+                this.options.enableSoftReset = false;
+            }
+            if (this.options.enableSoftReset) {
+                try {
+                    await this.softResetInternal(false);
+                }
+                catch (e) {
+                    if ((0, core_1.isZWaveError)(e) &&
+                        e.code === core_1.ZWaveErrorCodes.Driver_Failed) {
+                        // Remember that soft reset is not supported by this stick
+                        await this.rememberNoSoftReset();
+                        // Then fail the driver
+                        await this.destroy();
+                        return;
+                    }
+                }
+            }
+            // There are situations where a controller claims it has the ID 0,
+            // which isn't valid. In this case try again after having soft-reset the stick
+            if (this.controller.ownNodeId === 0 &&
+                this.options.enableSoftReset) {
+                this.driverLog.print(`Controller identification returned invalid node ID 0 - trying again...`, "warn");
+                await this.controller.identify();
+            }
+            if (this.controller.ownNodeId === 0) {
+                this.driverLog.print(`Controller identification returned invalid node ID 0`, "error");
+                await this.destroy();
+                return;
+            }
+            // now that we know the home ID, we can open the databases
+            await this.initValueDBs(this.controller.homeId);
             // Interview the controller.
-            await this._controller.interview(initValueDBs, async () => {
+            await this._controller.interview(async () => {
                 // Try to restore the network information from the cache
                 if (process.env.NO_CACHE !== "true") {
                     await this.restoreNetworkStructureFromCache();
                 }
             });
-            // No need to initialize databases if skipInterview is true, because it is only used in some
-            // Driver unit tests that don't need access to them
+            // Auto-enable smart start inclusion
+            this._controller.autoProvisionSmartStart();
         }
         // Set up the S0 security manager. We can only do that after the controller
         // interview because we need to know the controller node id.
@@ -1058,6 +1102,76 @@ class Driver extends shared_1.TypedEventEmitter {
             throw new core_1.ZWaveError("Cannot retrieve the version of a CC that is not implemented", core_1.ZWaveErrorCodes.CC_NotSupported);
         }
     }
+    async maySoftReset() {
+        var _a;
+        // If we've previously determined a stick not to support soft reset, don't bother trying again
+        let supportsSoftReset;
+        if (this._controllerInterviewed) {
+            supportsSoftReset = this.controller.supportsSoftReset;
+        }
+        else {
+            // The controller wasn't interviewed yet, read the json file manually
+            const fs = this.options.storage.driver;
+            const cacheFile = path_1.default.join(this.cacheDir, this.controller.homeId.toString(16) + ".json");
+            // Read it if it exists
+            let json;
+            if (await fs.pathExists(cacheFile)) {
+                try {
+                    json = JSON.parse(await fs.readFile(cacheFile, "utf8"));
+                }
+                catch { }
+            }
+            supportsSoftReset = (_a = json === null || json === void 0 ? void 0 : json.controller) === null || _a === void 0 ? void 0 : _a.supportsSoftReset;
+        }
+        if (supportsSoftReset === false)
+            return false;
+        // Blacklist some sticks that are known to not support soft reset
+        const { manufacturerId, productType, productId } = this.controller;
+        // Z-Wave.me UZB1
+        if (manufacturerId === 0x0115 &&
+            productType === 0x0000 &&
+            productId === 0x0000) {
+            return false;
+        }
+        // Z-Wave.me UZB
+        if (manufacturerId === 0x0115 &&
+            productType === 0x0400 &&
+            productId === 0x0001) {
+            return false;
+        }
+        return true;
+    }
+    async rememberNoSoftReset() {
+        var _a;
+        this.driverLog.print("Soft reset seems not to be supported by this stick, disabling it.", "warn");
+        this.controller.supportsSoftReset = false;
+        if (this._controllerInterviewed) {
+            // We can use the normal method for this
+            await this.saveNetworkToCacheInternal();
+        }
+        else {
+            // saveNetworkToCache won't write anything, just edit the file "manually"
+            // TODO: This is ugly, rework this when changing how the network data is saved
+            const fs = this.options.storage.driver;
+            await fs.ensureDir(this.cacheDir);
+            const cacheFile = path_1.default.join(this.cacheDir, this.controller.homeId.toString(16) + ".json");
+            // Read it if it exists
+            let json;
+            if (await fs.pathExists(cacheFile)) {
+                try {
+                    json = JSON.parse(await fs.readFile(cacheFile, "utf8"));
+                }
+                catch { }
+            }
+            // Change the supportsSoftReset flag
+            json !== null && json !== void 0 ? json : (json = {});
+            (_a = json.controller) !== null && _a !== void 0 ? _a : (json.controller = {});
+            json.controller.supportsSoftReset = false;
+            // And save it again
+            const jsonString = (0, shared_1.stringify)(json);
+            await this.options.storage.driver.writeFile(cacheFile, jsonString, "utf8");
+        }
+    }
     /**
      * Soft-resets the controller if the feature is enabled
      */
@@ -1083,6 +1197,9 @@ class Driver extends shared_1.TypedEventEmitter {
             this.controllerLog.print(message, "error");
             throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_FeatureDisabled);
         }
+        return this.softResetInternal(true);
+    }
+    async softResetInternal(destroyOnError) {
         this.controllerLog.print("Performing soft reset...");
         try {
             this.isSoftResetting = true;
@@ -1095,7 +1212,14 @@ class Driver extends shared_1.TypedEventEmitter {
             this.controllerLog.print(`Soft reset failed: ${(0, shared_1.getErrorMessage)(e)}`, "error");
         }
         // Make sure we're able to communicate with the controller again
-        await this.ensureSerialAPI();
+        if (!(await this.ensureSerialAPI())) {
+            if (destroyOnError) {
+                await this.destroy();
+            }
+            else {
+                throw new core_1.ZWaveError("The Serial API did not respond after soft-reset", core_1.ZWaveErrorCodes.Driver_Failed);
+            }
+        }
         this.isSoftResetting = false;
         // And resume sending
         this.unpauseSendThread();
@@ -1109,7 +1233,7 @@ class Driver extends shared_1.TypedEventEmitter {
         if (waitResult) {
             // Serial API did start, maybe do something with the information?
             this.controllerLog.print("reconnected and restarted");
-            return;
+            return true;
         }
         // If the controller disconnected the serial port during the soft reset, we need to re-open it
         if (!this.serial.isOpen) {
@@ -1122,7 +1246,7 @@ class Driver extends shared_1.TypedEventEmitter {
         if (waitResult) {
             // Serial API did start, maybe do something with the information?
             this.controllerLog.print("Serial API started");
-            return;
+            return true;
         }
         this.controllerLog.print("Did not receive notification that Serial API has started, checking if it responds...");
         // We don't need to use any specific command here. However we're going to use this one in the interview
@@ -1144,21 +1268,15 @@ class Driver extends shared_1.TypedEventEmitter {
         };
         // Poll the controller with increasing backoff delay
         if (await pollController())
-            return;
-        this.controllerLog.print("Serial API did not respond, trying again in 2 seconds...");
-        await (0, async_1.wait)(2000, true);
-        if (await pollController())
-            return;
-        this.controllerLog.print("Serial API did not respond, trying again in 5 seconds...");
-        await (0, async_1.wait)(5000, true);
-        if (await pollController())
-            return;
-        this.controllerLog.print("Serial API did not respond, trying again in 10 seconds...");
-        await (0, async_1.wait)(10000, true);
-        if (await pollController())
-            return;
+            return true;
+        for (const backoff of [2, 5, 10, 15]) {
+            this.controllerLog.print(`Serial API did not respond, trying again in ${backoff} seconds...`);
+            await (0, async_1.wait)(backoff * 1000, true);
+            if (await pollController())
+                return true;
+        }
         this.controllerLog.print("Serial API did not respond, giving up", "error");
-        await this.destroy();
+        return false;
     }
     /**
      * Performs a hard reset on the controller. This wipes out all configuration!
@@ -1206,12 +1324,27 @@ class Driver extends shared_1.TypedEventEmitter {
      * Must be called under any circumstances.
      */
     async destroy() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         // Ensure this is only called once and all subsequent calls block
         if (this._destroyPromise)
             return this._destroyPromise;
         this._destroyPromise = (0, deferred_promise_1.createDeferredPromise)();
         this.driverLog.print("destroying driver instance...");
+        // Disable inclusion before shutting down
+        try {
+            switch ((_a = this._controller) === null || _a === void 0 ? void 0 : _a.inclusionState) {
+                case Inclusion_1.InclusionState.SmartStart:
+                case Inclusion_1.InclusionState.Including:
+                    await this._controller.stopInclusionNoCallback();
+                    break;
+                case Inclusion_1.InclusionState.Excluding:
+                    await this._controller.stopExclusionNoCallback();
+                    break;
+            }
+        }
+        catch {
+            // ignore
+        }
         // First stop the send thread machine and close the serial port, so nothing happens anymore
         if (this.sendThread.initialized)
             this.sendThread.stop();
@@ -1231,8 +1364,8 @@ class Driver extends shared_1.TypedEventEmitter {
         }
         try {
             // Attempt to close the value DBs
-            await ((_a = this._valueDB) === null || _a === void 0 ? void 0 : _a.close());
-            await ((_b = this._metadataDB) === null || _b === void 0 ? void 0 : _b.close());
+            await ((_b = this._valueDB) === null || _b === void 0 ? void 0 : _b.close());
+            await ((_c = this._metadataDB) === null || _c === void 0 ? void 0 : _c.close());
         }
         catch (e) {
             this.driverLog.print(`Closing the value DBs failed: ${(0, shared_1.getErrorMessage)(e)}`, "error");
@@ -1248,7 +1381,7 @@ class Driver extends shared_1.TypedEventEmitter {
                 clearTimeout(timeout);
         }
         // Destroy all nodes
-        (_c = this._controller) === null || _c === void 0 ? void 0 : _c.nodes.forEach((n) => n.destroy());
+        (_d = this._controller) === null || _d === void 0 ? void 0 : _d.nodes.forEach((n) => n.destroy());
         process.removeListener("exit", this._cleanupHandler);
         process.removeListener("SIGINT", this._cleanupHandler);
         process.removeListener("uncaughtException", this._cleanupHandler);
@@ -1461,7 +1594,7 @@ class Driver extends shared_1.TypedEventEmitter {
         throw e;
     }
     async handleSecurityS2DecodeError(e, msg) {
-        var _a;
+        var _a, _b;
         if (!(0, core_1.isZWaveError)(e))
             return false;
         if ((e.code === core_1.ZWaveErrorCodes.Security2CC_NoSPAN ||
@@ -1493,13 +1626,42 @@ class Driver extends shared_1.TypedEventEmitter {
                 ? "Message authentication failed"
                 : "No SPAN is established yet";
             if (this.controller.bootstrappingS2NodeId === nodeId) {
-                // The node is currently being bootstrapped. Us not being able to decode the command means we need to abort the bootstrapping process
-                this.controllerLog.logNode(nodeId, {
-                    message: `${message}, cannot decode command. Aborting the S2 bootstrapping process...`,
-                    level: "error",
-                    direction: "inbound",
-                });
-                this.controller.cancelSecureBootstrapS2(shared_2.KEXFailType.BootstrappingCanceled);
+                // The node is currently being bootstrapped.
+                if ((_b = this.securityManager2) === null || _b === void 0 ? void 0 : _b.tempKeys.has(nodeId)) {
+                    // The DSK has been verified, so we should be able to decode this command.
+                    // If this is the first attempt, we need to request a nonce first
+                    if (this.securityManager2.getSPANState(nodeId).type ===
+                        core_1.SPANState.None) {
+                        this.controllerLog.logNode(nodeId, {
+                            message: `${message}, cannot decode command. Requesting a nonce...`,
+                            level: "verbose",
+                            direction: "outbound",
+                        });
+                        // Send the node our nonce
+                        node.commandClasses["Security 2"]
+                            .sendNonce()
+                            .catch(() => {
+                            // Ignore errors
+                        });
+                    }
+                    else {
+                        // Us repeatedly not being able to decode the command means we need to abort the bootstrapping process
+                        // because the PIN is wrong
+                        this.controllerLog.logNode(nodeId, {
+                            message: `${message}, cannot decode command. Aborting the S2 bootstrapping process...`,
+                            level: "error",
+                            direction: "inbound",
+                        });
+                        this.controller.cancelSecureBootstrapS2(shared_2.KEXFailType.BootstrappingCanceled);
+                    }
+                }
+                else {
+                    this.controllerLog.logNode(nodeId, {
+                        message: `Ignoring KEXSet because the DSK has not been verified yet`,
+                        level: "verbose",
+                        direction: "inbound",
+                    });
+                }
             }
             else if (!this.hasPendingTransactions(isS2NonceReport)) {
                 this.controllerLog.logNode(nodeId, {
@@ -1999,6 +2161,31 @@ ${handlers.length} left`);
                     return;
                 }
             }
+            else if (msg instanceof ApplicationUpdateRequest_1.ApplicationUpdateRequestSmartStartHomeIDReceived) {
+                // the controller is in Smart Start learn mode and a node requests inclusion via Smart Start
+                this.controllerLog.print("Received Smart Start inclusion request");
+                if (this.controller.inclusionState !== Inclusion_1.InclusionState.Idle &&
+                    this.controller.inclusionState !== Inclusion_1.InclusionState.SmartStart) {
+                    this.controllerLog.print("Controller is busy and cannot handle this inclusion request right now...");
+                    return;
+                }
+                // Check if the node is on the provisioning list
+                const provisioningEntry = this.controller.provisioningList.find((entry) => (0, core_1.nwiHomeIdFromDSK)((0, core_1.dskFromString)(entry.dsk)).equals(msg.nwiHomeId));
+                if (!provisioningEntry) {
+                    this.controllerLog.print("NWI Home ID not found in provisioning list, ignoring request...");
+                    return;
+                }
+                this.controllerLog.print("NWI Home ID found in provisioning list, including node...");
+                try {
+                    const result = await this.controller.beginInclusionSmartStart(provisioningEntry);
+                    if (!result) {
+                        this.controllerLog.print("Smart Start inclusion could not be started", "error");
+                    }
+                }
+                catch (e) {
+                    this.controllerLog.print(`Smart Start inclusion could not be started: ${(0, shared_1.getErrorMessage)(e)}`, "error");
+                }
+            }
         }
         else {
             // Check if we have a dynamic handler waiting for this message