zwave-js 8.5.1 → 8.7.1

package/build/lib/driver/Driver.js

@@ -55,9 +55,12 @@ const ApplicationCommandRequest_1 = require("../controller/ApplicationCommandReq
 const ApplicationUpdateRequest_1 = require("../controller/ApplicationUpdateRequest");
 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");
+const SoftResetRequest_1 = require("../controller/SoftResetRequest");
 const Controller_2 = require("../log/Controller");
 const Driver_1 = require("../log/Driver");
 const Constants_1 = require("../message/Constants");
@@ -93,9 +96,12 @@ const defaultOptions = {
         report: 10000,
         nonce: 5000,
         sendDataCallback: 65000,
-        refreshValue: 5000, // Default should handle most slow devices until we have a better solution
+        refreshValue: 5000,
+        refreshValueAfterTransition: 1000,
+        serialAPIStarted: 5000,
     },
     attempts: {
+        openSerialPort: 10,
         controller: 3,
         sendData: 3,
         retryAfterTransmitReport: false,
@@ -103,6 +109,8 @@ const defaultOptions = {
     },
     preserveUnknownValues: false,
     disableOptimisticValueUpdate: false,
+    // By default enable soft reset unless the env variable is set
+    enableSoftReset: !process.env.ZWAVEJS_DISABLE_SOFT_RESET,
     interview: {
         skipInterview: false,
         queryAllUserCodes: false,
@@ -110,6 +118,7 @@ const defaultOptions = {
     storage: {
         driver: fs_extra_1.default,
         cacheDir: path_1.default.resolve(libraryRootDir, "cache"),
+        lockDir: process.env.ZWAVEJS_LOCK_DIRECTORY,
         throttle: "normal",
     },
     preferences: {
@@ -138,6 +147,10 @@ function checkOptions(options) {
     if (options.timeouts.sendDataCallback < 10000) {
         throw new core_1.ZWaveError(`The Send Data Callback timeout must be at least 10000 milliseconds!`, core_1.ZWaveErrorCodes.Driver_InvalidOptions);
     }
+    if (options.timeouts.serialAPIStarted < 1000 ||
+        options.timeouts.serialAPIStarted > 30000) {
+        throw new core_1.ZWaveError(`The Serial API started timeout must be between 1000 and 30000 milliseconds!`, core_1.ZWaveErrorCodes.Driver_InvalidOptions);
+    }
     if (options.securityKeys != undefined) {
         if (options.networkKey != undefined) {
             throw new core_1.ZWaveError(`The deprecated networkKey option may not be used together with the new securityKeys option!`, core_1.ZWaveErrorCodes.Driver_InvalidOptions);
@@ -182,6 +195,8 @@ class Driver extends shared_1.TypedEventEmitter {
         this.port = port;
         /** A map of handlers for all sorts of requests */
         this.requestHandlers = new Map();
+        /** A map of awaited messages */
+        this.awaitedMessages = [];
         /** A map of awaited commands */
         this.awaitedCommands = [];
         /** A map of Node ID -> ongoing sessions */
@@ -193,6 +208,7 @@ class Driver extends shared_1.TypedEventEmitter {
         this._nodesReadyEventEmitted = false;
         this.retryNodeInterviewTimeouts = new Map();
         this._statisticsEnabled = false;
+        this.isSoftResetting = false;
         this._cleanupHandler = () => {
             void this.destroy();
         };
@@ -217,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,
@@ -408,15 +425,19 @@ class Driver extends shared_1.TypedEventEmitter {
         this.serial
             .on("data", this.serialport_onData.bind(this))
             .on("error", (err) => {
+            var _a;
+            if (this.isSoftResetting && !((_a = this.serial) === null || _a === void 0 ? void 0 : _a.isOpen)) {
+                // A disconnection while soft resetting is to be expected
+                return;
+            }
+            else if (!this._isOpen) {
+                // tryOpenSerialport takes care of error handling
+                return;
+            }
             const message = `Serial port errored: ${err.message}`;
             this.driverLog.print(message, "error");
             const error = new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_Failed);
-            if (this._isOpen) {
-                this.emit("error", error);
-            }
-            else {
-                spOpenPromise.reject(error);
-            }
+            this.emit("error", error);
             void this.destroy();
         });
         // If the port is already open, close it first
@@ -426,22 +447,16 @@ class Driver extends shared_1.TypedEventEmitter {
         // Everything async (inluding opening the serial port) must happen in the setImmediate callback
         // asynchronously open the serial port
         setImmediate(async () => {
-            try {
-                await this.serial.open();
-            }
-            catch (e) {
-                const message = `Failed to open the serial port: ${(0, shared_1.getErrorMessage)(e)}`;
-                this.driverLog.print(message, "error");
-                spOpenPromise.reject(new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_Failed));
-                void this.destroy();
+            if (!(await this.tryOpenSerialport(spOpenPromise)))
                 return;
-            }
             this.driverLog.print("serial port opened");
             this._isOpen = true;
             spOpenPromise.resolve();
+            // Perform initialization sequence
             await this.writeHeader(serial_1.MessageHeaders.NAK);
-            // set unref, so stopping the process doesn't need to wait for the 1500ms
-            await (0, async_1.wait)(1500, true);
+            // 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);
@@ -482,7 +497,7 @@ class Driver extends shared_1.TypedEventEmitter {
                     message = `Failed to initialize the driver, no response from the controller. Are you sure this is a Z-Wave controller?`;
                 }
                 else {
-                    message = `Failed to initialize the driver: ${(0, shared_1.getErrorMessage)(e)}`;
+                    message = `Failed to initialize the driver: ${(0, shared_1.getErrorMessage)(e, true)}`;
                 }
                 this.driverLog.print(message, "error");
                 this.emit("error", new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_Failed));
@@ -492,10 +507,63 @@ class Driver extends shared_1.TypedEventEmitter {
         });
         return spOpenPromise;
     }
+    async tryOpenSerialport(openPromise) {
+        let lastError;
+        // After a reset, the serial port may need a few seconds until we can open it - try a few times
+        for (let attempt = 1; attempt <= this.options.attempts.openSerialPort; attempt++) {
+            try {
+                await this.serial.open();
+                return true;
+            }
+            catch (e) {
+                lastError = e;
+            }
+            if (attempt < this.options.attempts.openSerialPort) {
+                await (0, async_1.wait)(1000);
+            }
+        }
+        const message = `Failed to open the serial port: ${(0, shared_1.getErrorMessage)(lastError)}`;
+        this.driverLog.print(message, "error");
+        const error = new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_Failed);
+        if (this._isOpen || !openPromise) {
+            this.emit("error", error);
+        }
+        else {
+            openPromise === null || openPromise === void 0 ? void 0 : openPromise.reject(error);
+        }
+        void this.destroy();
+        return false;
+    }
     /** Indicates whether all nodes are ready, i.e. the "all nodes ready" event has been emitted */
     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.
@@ -508,39 +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],
-            };
-            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.
@@ -1017,6 +1102,182 @@ 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
+     */
+    async trySoftReset() {
+        if (this.options.enableSoftReset) {
+            await this.softReset();
+        }
+        else {
+            const message = `The soft reset feature is not enabled, skipping API call.`;
+            this.controllerLog.print(message, "warn");
+        }
+    }
+    /**
+     * Instruct the controller to soft-reset.
+     *
+     * **Warning:** USB modules will reconnect, meaning that they might get a new address.
+     *
+     * **Warning:** This call will throw if soft-reset is not enabled.
+     */
+    async softReset() {
+        if (!this.options.enableSoftReset) {
+            const message = `The soft reset feature has been disabled with a config option or the ZWAVEJS_DISABLE_SOFT_RESET environment variable.`;
+            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;
+            await this.sendMessage(new SoftResetRequest_1.SoftResetRequest(this), {
+                supportCheck: false,
+                pauseSendThread: true,
+            });
+        }
+        catch (e) {
+            this.controllerLog.print(`Soft reset failed: ${(0, shared_1.getErrorMessage)(e)}`, "error");
+        }
+        // Make sure we're able to communicate with the controller again
+        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();
+    }
+    async ensureSerialAPI() {
+        // Wait 1.5 seconds after reset to ensure that the module is ready for communication again
+        // Z-Wave 700 sticks are relatively fast, so we also wait for the Serial API started command
+        // to bail early
+        this.controllerLog.print("Waiting for the controller to reconnect...");
+        let waitResult = await this.waitForMessage((msg) => msg.functionType === Constants_1.FunctionType.SerialAPIStarted, 1500).catch(() => false);
+        if (waitResult) {
+            // Serial API did start, maybe do something with the information?
+            this.controllerLog.print("reconnected and restarted");
+            return true;
+        }
+        // If the controller disconnected the serial port during the soft reset, we need to re-open it
+        if (!this.serial.isOpen) {
+            this.controllerLog.print("Re-opening serial port...");
+            await this.tryOpenSerialport();
+        }
+        // Wait the configured amount of time for the Serial API started command to be received
+        this.controllerLog.print("Waiting for the Serial API to start...");
+        waitResult = await this.waitForMessage((msg) => msg.functionType === Constants_1.FunctionType.SerialAPIStarted, this.options.timeouts.serialAPIStarted).catch(() => false);
+        if (waitResult) {
+            // Serial API did start, maybe do something with the information?
+            this.controllerLog.print("Serial API started");
+            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
+        // anyways, so we might aswell use it here too
+        const pollController = async () => {
+            try {
+                // And resume sending - this requires us to unpause the send thread
+                this.unpauseSendThread();
+                await this.sendMessage(new GetControllerVersionMessages_1.GetControllerVersionRequest(this), {
+                    supportCheck: false,
+                });
+                this.pauseSendThread();
+                this.controllerLog.print("Serial API responded");
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
+        // Poll the controller with increasing backoff delay
+        if (await pollController())
+            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");
+        return false;
+    }
     /**
      * Performs a hard reset on the controller. This wipes out all configuration!
      *
@@ -1063,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();
@@ -1088,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");
@@ -1105,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);
@@ -1117,7 +1393,7 @@ class Driver extends shared_1.TypedEventEmitter {
      * Is called when the serial port has received a single-byte message or a complete message buffer
      */
     async serialport_onData(data) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g;
         if (typeof data === "number") {
             switch (data) {
                 // single-byte messages - just forward them to the send thread
@@ -1145,10 +1421,14 @@ class Driver extends shared_1.TypedEventEmitter {
             // Then ensure there are no errors
             if ((0, ICommandClassContainer_1.isCommandClassContainer)(msg)) {
                 (0, CommandClass_1.assertValidCCs)(msg);
-                (_c = msg.getNodeUnsafe()) === null || _c === void 0 ? void 0 : _c.incrementStatistics("commandsRX");
             }
-            else {
-                (_d = this._controller) === null || _d === void 0 ? void 0 : _d.incrementStatistics("messagesRX");
+            if (!!this._controller) {
+                if ((0, ICommandClassContainer_1.isCommandClassContainer)(msg)) {
+                    (_c = msg.getNodeUnsafe()) === null || _c === void 0 ? void 0 : _c.incrementStatistics("commandsRX");
+                }
+                else {
+                    this._controller.incrementStatistics("messagesRX");
+                }
             }
             // all good, send ACK
             await this.writeHeader(serial_1.MessageHeaders.ACK);
@@ -1162,25 +1442,27 @@ class Driver extends shared_1.TypedEventEmitter {
                     const response = this.handleDecodeError(e, data, msg);
                     if (response)
                         await this.writeHeader(response);
-                    if ((0, ICommandClassContainer_1.isCommandClassContainer)(msg)) {
-                        (_e = msg.getNodeUnsafe()) === null || _e === void 0 ? void 0 : _e.incrementStatistics("commandsDroppedRX");
-                        // Figure out if the command was received with supervision encapsulation
-                        const supervisionSessionId = SupervisionCC_1.SupervisionCC.getSessionId(msg.command);
-                        if (supervisionSessionId !== undefined &&
-                            msg.command instanceof CommandClass_1.InvalidCC) {
-                            // If it was, we need to notify the sender that we couldn't decode the command
-                            await ((_f = msg
-                                .getNodeUnsafe()) === null || _f === void 0 ? void 0 : _f.createAPI(core_1.CommandClasses.Supervision, false).sendReport({
-                                sessionId: supervisionSessionId,
-                                moreUpdatesFollow: false,
-                                status: SupervisionCC_1.SupervisionStatus.NoSupport,
-                                secure: msg.command.secure,
-                            }));
-                            return;
+                    if (!!this._controller) {
+                        if ((0, ICommandClassContainer_1.isCommandClassContainer)(msg)) {
+                            (_d = msg.getNodeUnsafe()) === null || _d === void 0 ? void 0 : _d.incrementStatistics("commandsDroppedRX");
+                            // Figure out if the command was received with supervision encapsulation
+                            const supervisionSessionId = SupervisionCC_1.SupervisionCC.getSessionId(msg.command);
+                            if (supervisionSessionId !== undefined &&
+                                msg.command instanceof CommandClass_1.InvalidCC) {
+                                // If it was, we need to notify the sender that we couldn't decode the command
+                                await ((_e = msg
+                                    .getNodeUnsafe()) === null || _e === void 0 ? void 0 : _e.createAPI(core_1.CommandClasses.Supervision, false).sendReport({
+                                    sessionId: supervisionSessionId,
+                                    moreUpdatesFollow: false,
+                                    status: SupervisionCC_1.SupervisionStatus.NoSupport,
+                                    secure: msg.command.secure,
+                                }));
+                                return;
+                            }
+                        }
+                        else {
+                            this._controller.incrementStatistics("messagesDroppedRX");
                         }
-                    }
-                    else {
-                        (_g = this._controller) === null || _g === void 0 ? void 0 : _g.incrementStatistics("messagesDroppedRX");
                     }
                 }
             }
@@ -1192,7 +1474,7 @@ class Driver extends shared_1.TypedEventEmitter {
                         return;
                     }
                     // Print something, so we know what is wrong
-                    this._driverLog.print((_h = ee.stack) !== null && _h !== void 0 ? _h : ee.message, "error");
+                    this._driverLog.print((_f = ee.stack) !== null && _f !== void 0 ? _f : ee.message, "error");
                 }
             }
             // Don't keep handling the message
@@ -1207,7 +1489,7 @@ class Driver extends shared_1.TypedEventEmitter {
                 // and handle the encapsulation part normally
                 if (msg.command instanceof
                     SecurityCC_1.SecurityCCCommandEncapsulationNonceGet) {
-                    void ((_j = msg.getNodeUnsafe()) === null || _j === void 0 ? void 0 : _j.handleSecurityNonceGet());
+                    void ((_g = msg.getNodeUnsafe()) === null || _g === void 0 ? void 0 : _g.handleSecurityNonceGet());
                 }
                 // Transport Service commands must be handled before assembling partial CCs
                 if ((0, TransportServiceCC_1.isTransportServiceEncapsulation)(msg.command)) {
@@ -1312,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 ||
@@ -1344,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, {
@@ -1850,8 +2161,42 @@ ${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
+            for (const entry of this.awaitedMessages) {
+                if (entry.predicate(msg)) {
+                    // resolve the promise - this will remove the entry from the list
+                    entry.promise.resolve(msg);
+                    return;
+                }
+            }
+            // Otherwise loop through the static handlers
             // TODO: This deserves a nicer formatting
             this.driverLog.print(`handling request ${Constants_1.FunctionType[msg.functionType]} (${msg.functionType})`);
             handlers = this.requestHandlers.get(msg.functionType);
@@ -2010,6 +2355,9 @@ ${handlers.length} left`);
             transaction.changeNodeStatusOnTimeout =
                 options.changeNodeStatusOnMissingACK;
         }
+        if (options.pauseSendThread === true) {
+            transaction.pauseSendThread = true;
+        }
         transaction.requestWakeUpOnDemand = !!options.requestWakeUpOnDemand;
         transaction.tag = options.tag;
         // start sending now (maybe)
@@ -2216,7 +2564,41 @@ ${handlers.length} left`);
         return (_a = this.serial) === null || _a === void 0 ? void 0 : _a.writeAsync(data);
     }
     /**
-     * Waits until a command is received or a timeout has elapsed. Returns the received command.
+     * Waits until an unsolicited serial message is received or a timeout has elapsed. Returns the received message.
+     *
+     * **Note:** This does not trigger for [Bridge]ApplicationUpdateRequests, which are handled differently. To wait for a certain CommandClass, use {@link waitForCommand}.
+     * @param timeout The number of milliseconds to wait. If the timeout elapses, the returned promise will be rejected
+     * @param predicate A predicate function to test all incoming messages
+     */
+    waitForMessage(predicate, timeout) {
+        return new Promise((resolve, reject) => {
+            const entry = {
+                predicate,
+                promise: (0, deferred_promise_1.createDeferredPromise)(),
+                timeout: undefined,
+            };
+            this.awaitedMessages.push(entry);
+            const removeEntry = () => {
+                if (entry.timeout)
+                    clearTimeout(entry.timeout);
+                const index = this.awaitedMessages.indexOf(entry);
+                if (index !== -1)
+                    this.awaitedMessages.splice(index, 1);
+            };
+            // When the timeout elapses, remove the wait entry and reject the returned Promise
+            entry.timeout = setTimeout(() => {
+                removeEntry();
+                reject(new core_1.ZWaveError(`Received no matching message within the provided timeout!`, core_1.ZWaveErrorCodes.Controller_Timeout));
+            }, timeout).unref();
+            // When the promise is resolved, remove the wait entry and resolve the returned Promise
+            void entry.promise.then((cc) => {
+                removeEntry();
+                resolve(cc);
+            });
+        });
+    }
+    /**
+     * Waits until a CommandClass is received or a timeout has elapsed. Returns the received command.
      * @param timeout The number of milliseconds to wait. If the timeout elapses, the returned promise will be rejected
      * @param predicate A predicate function to test all incoming command classes
      */
@@ -2323,6 +2705,20 @@ ${handlers.length} left`);
     rejectAllTransactionsForNode(nodeId, errorMsg = `The node is dead`, errorCode = core_1.ZWaveErrorCodes.Controller_MessageDropped) {
         this.rejectTransactions((t) => t.message.getNodeId() === nodeId, errorMsg, errorCode);
     }
+    /**
+     * @internal
+     * Pauses the send thread, avoiding commands to be sent to the controller
+     */
+    pauseSendThread() {
+        this.sendThread.send({ type: "pause" });
+    }
+    /**
+     * @internal
+     * Unpauses the send thread, allowing commands to be sent to the controller again
+     */
+    unpauseSendThread() {
+        this.sendThread.send({ type: "unpause" });
+    }
     /** Re-sorts the send queue */
     sortSendQueue() {
         this.sendThread.send("sortQueue");