zwave-js 13.2.0 → 13.3.1

package/build/lib/node/Node.js

@@ -2970,7 +2970,10 @@ protocol version:      ${this.protocolVersion}`;
     }
     async handleZWavePlusGet(command) {
         const endpoint = this.getEndpoint(command.endpointIndex) ?? this;
-        await endpoint.commandClasses["Z-Wave Plus Info"]
+        // We are being queried, so the device may actually not support the CC, just control it.
+        // Using the commandClasses property would throw in that case
+        await endpoint
+            .createAPI(core_1.CommandClasses["Z-Wave Plus Info"], false)
             .withOptions({
             // Answer with the same encapsulation as asked, but omit
             // Supervision as it shouldn't be used for Get-Report flows
@@ -4052,6 +4055,9 @@ protocol version:      ${this.protocolVersion}`;
             return this._firmwareUpdateInProgress;
         }
     }
+    // Stores the CRC of the previously transferred firmware image.
+    // Allows detecting whether resuming is supported and where to continue in a multi-file transfer.
+    _previousFirmwareCRC;
     _abortFirmwareUpdate;
     /** Is used to remember fragment requests that came in before they were able to be handled */
     _firmwareUpdatePrematureRequest;
@@ -4064,6 +4070,8 @@ protocol version:      ${this.protocolVersion}`;
         const supportsActivation = this.getValue(FirmwareUpdateMetaDataCC_1.FirmwareUpdateMetaDataCCValues.supportsActivation.id);
         const continuesToFunction = this.getValue(FirmwareUpdateMetaDataCC_1.FirmwareUpdateMetaDataCCValues.continuesToFunction.id);
         const additionalFirmwareIDs = this.getValue(FirmwareUpdateMetaDataCC_1.FirmwareUpdateMetaDataCCValues.additionalFirmwareIDs.id);
+        const supportsResuming = this.getValue(FirmwareUpdateMetaDataCC_1.FirmwareUpdateMetaDataCCValues.supportsResuming.id);
+        const supportsNonSecureTransfer = this.getValue(FirmwareUpdateMetaDataCC_1.FirmwareUpdateMetaDataCCValues.supportsNonSecureTransfer.id);
         // Ensure all information was queried
         if (!firmwareUpgradable
             || !(0, typeguards_1.isArray)(additionalFirmwareIDs)) {
@@ -4076,6 +4084,8 @@ protocol version:      ${this.protocolVersion}`;
                 .map((_, i) => i),
             continuesToFunction,
             supportsActivation,
+            supportsResuming,
+            supportsNonSecureTransfer,
         };
     }
     /**
@@ -4100,6 +4110,8 @@ protocol version:      ${this.protocolVersion}`;
                 .fill(0).map((_, i) => i),
             continuesToFunction: meta.continuesToFunction,
             supportsActivation: meta.supportsActivation,
+            supportsResuming: meta.supportsResuming,
+            supportsNonSecureTransfer: meta.supportsNonSecureTransfer,
         };
     }
     /**
@@ -4113,7 +4125,7 @@ protocol version:      ${this.protocolVersion}`;
      *
      * @returns Whether all of the given updates were successful.
      */
-    async updateFirmware(updates) {
+    async updateFirmware(updates, options = {}) {
         if (updates.length === 0) {
             throw new core_1.ZWaveError(`At least one update must be provided`, core_1.ZWaveErrorCodes.Argument_Invalid);
         }
@@ -4170,7 +4182,8 @@ protocol version:      ${this.protocolVersion}`;
             this._firmwareUpdatePrematureRequest = undefined;
         };
         // Prepare the firmware update
-        let fragmentSize;
+        let fragmentSizeSecure;
+        let fragmentSizeNonSecure;
         let meta;
         try {
             const prepareResult = await this.prepareFirmwareUpdateInternal(updates.map((u) => u.firmwareTarget ?? 0), abortContext);
@@ -4186,7 +4199,8 @@ protocol version:      ${this.protocolVersion}`;
                 return result;
             }
             // If the firmware update was not aborted, prepareResult is definitely defined
-            ({ fragmentSize, ...meta } = prepareResult);
+            ({ fragmentSizeSecure, fragmentSizeNonSecure, ...meta } =
+                prepareResult);
         }
         catch {
             restore(false);
@@ -4198,33 +4212,84 @@ protocol version:      ${this.protocolVersion}`;
             };
             return result;
         }
+        // The resume and non-secure transfer features may not be supported by the node
+        // If not, disable them, even though the application requested them
+        if (!meta.supportsResuming)
+            options.resume = false;
+        const securityClass = this.getHighestSecurityClass();
+        const isSecure = securityClass === core_1.SecurityClass.S0_Legacy
+            || (0, core_1.securityClassIsS2)(securityClass);
+        if (!isSecure) {
+            // The nonSecureTransfer option is only relevant for secure devices
+            options.nonSecureTransfer = false;
+        }
+        else if (!meta.supportsNonSecureTransfer) {
+            options.nonSecureTransfer = false;
+        }
         // Throttle the progress emitter so applications can handle the load of events
         const notifyProgress = (0, shared_1.throttle)((progress) => this.emit("firmware update progress", this, progress), 250, true);
+        // If resuming is supported and desired, try to figure out with which file to continue
+        const updatesWithChecksum = updates.map((u) => ({
+            ...u,
+            checksum: (0, core_1.CRC16_CCITT)(u.data),
+        }));
+        let skipFinishedFiles = -1;
+        let shouldResume = options.resume
+            && this._previousFirmwareCRC != undefined;
+        if (shouldResume) {
+            skipFinishedFiles = updatesWithChecksum.findIndex((u) => u.checksum === this._previousFirmwareCRC);
+            if (skipFinishedFiles === -1)
+                shouldResume = false;
+        }
         // Perform all firmware updates in sequence
         let updateResult;
         let conservativeWaitTime;
-        const totalFragments = updates.reduce((total, update) => total + Math.ceil(update.data.length / fragmentSize), 0);
-        let sentFragmentsOfPreviousFiles = 0;
-        for (let i = 0; i < updates.length; i++) {
-            this.driver.controllerLog.logNode(this.id, `Updating firmware (part ${i + 1} / ${updates.length})...`);
-            const { firmwareTarget: target = 0, data } = updates[i];
+        const totalBytes = updatesWithChecksum.reduce((total, update) => total + update.data.length, 0);
+        let sentBytesOfPreviousFiles = 0;
+        for (let i = 0; i < updatesWithChecksum.length; i++) {
+            const { firmwareTarget: target = 0, data, checksum } = updatesWithChecksum[i];
+            if (i < skipFinishedFiles) {
+                // If we are resuming, skip this file since it was already done before
+                this.driver.controllerLog.logNode(this.id, `Skipping already completed firmware update (part ${i + 1} / ${updatesWithChecksum.length})...`);
+                sentBytesOfPreviousFiles += data.length;
+                continue;
+            }
+            this.driver.controllerLog.logNode(this.id, `Updating firmware (part ${i + 1} / ${updatesWithChecksum.length})...`);
+            // For determining the initial fragment size, assume the node respects our choice.
+            // If the node is not secure, these two values are identical anyways.
+            let fragmentSize = options.nonSecureTransfer
+                ? fragmentSizeNonSecure
+                : fragmentSizeSecure;
             // Tell the node to start requesting fragments
-            await this.beginFirmwareUpdateInternal(data, target, meta, fragmentSize);
+            const { resume, nonSecureTransfer } = await this
+                .beginFirmwareUpdateInternal(data, target, meta, fragmentSize, checksum, shouldResume, options.nonSecureTransfer);
+            // If the node did not accept non-secure transfer, revisit our choice of fragment size
+            if (options.nonSecureTransfer && !nonSecureTransfer) {
+                fragmentSize = fragmentSizeSecure;
+            }
+            // Remember the checksum, so we can resume if necessary
+            this._previousFirmwareCRC = checksum;
+            if (shouldResume) {
+                this.driver.controllerLog.logNode(this.id, `Node ${resume ? "accepted" : "did not accept"} resuming the update...`);
+            }
+            if (nonSecureTransfer) {
+                this.driver.controllerLog.logNode(this.id, `Firmware will be transferred without encryption...`);
+            }
             // And handle them
-            updateResult = await this.doFirmwareUpdateInternal(data, fragmentSize, abortContext, (fragment, total) => {
+            updateResult = await this.doFirmwareUpdateInternal(data, fragmentSize, nonSecureTransfer, abortContext, (fragment, total) => {
                 const progress = {
                     currentFile: i + 1,
-                    totalFiles: updates.length,
+                    totalFiles: updatesWithChecksum.length,
                     sentFragments: fragment,
                     totalFragments: total,
-                    progress: (0, math_1.roundTo)(((sentFragmentsOfPreviousFiles + fragment)
-                        / totalFragments)
-                        * 100, 2),
+                    progress: (0, math_1.roundTo)(((sentBytesOfPreviousFiles
+                        + Math.min(fragment * fragmentSize, data.length))
+                        / totalBytes) * 100, 2),
                 };
                 notifyProgress(progress);
                 // When this file is done, add the fragments to the total, so we can compute the total progress correctly
                 if (fragment === total) {
-                    sentFragmentsOfPreviousFiles += fragment;
+                    sentBytesOfPreviousFiles += data.length;
                 }
             });
             // If we wait, wait a bit longer than the device told us, so it is actually ready to use
@@ -4232,7 +4297,7 @@ protocol version:      ${this.protocolVersion}`;
                 .getConservativeWaitTimeAfterFirmwareUpdate(updateResult.waitTime);
             if (!updateResult.success) {
                 this.driver.controllerLog.logNode(this.id, {
-                    message: `Firmware update (part ${i + 1} / ${updates.length}) failed with status ${(0, shared_1.getEnumMemberName)(cc_1.FirmwareUpdateStatus, updateResult.status)}`,
+                    message: `Firmware update (part ${i + 1} / ${updatesWithChecksum.length}) failed with status ${(0, shared_1.getEnumMemberName)(cc_1.FirmwareUpdateStatus, updateResult.status)}`,
                     direction: "inbound",
                 });
                 const result = {
@@ -4244,16 +4309,20 @@ protocol version:      ${this.protocolVersion}`;
                 restore(false);
                 return result;
             }
-            else if (i < updates.length - 1) {
+            else if (i < updatesWithChecksum.length - 1) {
                 // Update succeeded, but we're not done yet
                 this.driver.controllerLog.logNode(this.id, {
-                    message: `Firmware update (part ${i + 1} / ${updates.length}) succeeded with status ${(0, shared_1.getEnumMemberName)(cc_1.FirmwareUpdateStatus, updateResult.status)}`,
+                    message: `Firmware update (part ${i + 1} / ${updatesWithChecksum.length}) succeeded with status ${(0, shared_1.getEnumMemberName)(cc_1.FirmwareUpdateStatus, updateResult.status)}`,
                     direction: "inbound",
                 });
                 this.driver.controllerLog.logNode(this.id, `Continuing with next part in ${conservativeWaitTime} seconds...`);
+                // If we've resumed the previous file, there's no need to resume the next one too
+                shouldResume = false;
                 await (0, async_1.wait)(conservativeWaitTime * 1000, true);
             }
         }
+        // We're done. No need to resume this update
+        this._previousFirmwareCRC = undefined;
         const result = {
             ...updateResult,
             waitTime: conservativeWaitTime,
@@ -4294,21 +4363,32 @@ protocol version:      ${this.protocolVersion}`;
         const fcc = new FirmwareUpdateMetaDataCC_1.FirmwareUpdateMetaDataCC(this.driver, {
             nodeId: this.id,
         });
-        const maxNetPayloadSize = this.driver.computeNetCCPayloadSize(fcc)
+        const maxGrossPayloadSizeSecure = this.driver.computeNetCCPayloadSize(fcc);
+        const maxGrossPayloadSizeNonSecure = this.driver
+            .computeNetCCPayloadSize(fcc, true);
+        const maxNetPayloadSizeSecure = maxGrossPayloadSizeSecure
+            - 2 // report number
+            - (fcc.version >= 2 ? 2 : 0); // checksum
+        const maxNetPayloadSizeNonSecure = maxGrossPayloadSizeNonSecure
             - 2 // report number
             - (fcc.version >= 2 ? 2 : 0); // checksum
         // Use the smallest allowed payload
-        const fragmentSize = Math.min(maxNetPayloadSize, meta.maxFragmentSize ?? Number.POSITIVE_INFINITY);
+        const fragmentSizeSecure = Math.min(maxNetPayloadSizeSecure, meta.maxFragmentSize ?? Number.POSITIVE_INFINITY);
+        const fragmentSizeNonSecure = Math.min(maxNetPayloadSizeNonSecure, meta.maxFragmentSize ?? Number.POSITIVE_INFINITY);
         if (abortContext.abort) {
             abortContext.abortPromise.resolve(true);
             return;
         }
         else {
-            return { ...meta, fragmentSize };
+            return {
+                ...meta,
+                fragmentSizeSecure,
+                fragmentSizeNonSecure,
+            };
         }
     }
-    /** Kicks off a firmware update of a single target */
-    async beginFirmwareUpdateInternal(data, target, meta, fragmentSize) {
+    /** Kicks off a firmware update of a single target. Returns whether the node accepted resuming and non-secure transfer */
+    async beginFirmwareUpdateInternal(data, target, meta, fragmentSize, checksum, resume, nonSecureTransfer) {
         const api = this.commandClasses["Firmware Update Meta Data"];
         // ================================
         // STEP 3:
@@ -4319,16 +4399,18 @@ protocol version:      ${this.protocolVersion}`;
         });
         // Request the node to start the upgrade
         // TODO: Should manufacturer id and firmware id be provided externally?
-        const requestUpdateStatus = await api.requestUpdate({
+        const result = await api.requestUpdate({
             manufacturerId: meta.manufacturerId,
             firmwareId: target == 0
                 ? meta.firmwareId
                 : meta.additionalFirmwareIDs[target - 1],
             firmwareTarget: target,
             fragmentSize,
-            checksum: (0, core_1.CRC16_CCITT)(data),
+            checksum,
+            resume,
+            nonSecureTransfer,
         });
-        switch (requestUpdateStatus) {
+        switch (result.status) {
             case cc_1.FirmwareUpdateRequestStatus.Error_AuthenticationExpected:
                 throw new core_1.ZWaveError(`Failed to start the update: A manual authentication event (e.g. button push) was expected!`, core_1.ZWaveErrorCodes.FirmwareUpdateCC_FailedToStart);
             case cc_1.FirmwareUpdateRequestStatus.Error_BatteryLow:
@@ -4349,9 +4431,13 @@ protocol version:      ${this.protocolVersion}`;
                 // Keep the node awake until the update is done.
                 this.keepAwake = true;
         }
+        return {
+            resume: !!result.resume,
+            nonSecureTransfer: !!result.nonSecureTransfer,
+        };
     }
     /** Performs the firmware update of a single target */
-    async doFirmwareUpdateInternal(data, fragmentSize, abortContext, onProgress) {
+    async doFirmwareUpdateInternal(data, fragmentSize, nonSecureTransfer, abortContext, onProgress) {
         const numFragments = Math.ceil(data.length / fragmentSize);
         // Make sure we're not responding to an outdated request immediately
         this._firmwareUpdatePrematureRequest = undefined;
@@ -4395,7 +4481,7 @@ protocol version:      ${this.protocolVersion}`;
                     message: `Received Firmware Update Get for an out-of-bounds fragment. Forcing the node to abort...`,
                     direction: "inbound",
                 });
-                await this.sendCorruptedFirmwareUpdateReport(fragmentRequest.reportNumber, (0, node_crypto_1.randomBytes)(fragmentSize));
+                await this.sendCorruptedFirmwareUpdateReport(fragmentRequest.reportNumber, (0, node_crypto_1.randomBytes)(fragmentSize), nonSecureTransfer);
                 // This will cause the node to abort the process, wait for that
                 break update;
             }
@@ -4407,7 +4493,7 @@ protocol version:      ${this.protocolVersion}`;
                 }
                 const fragment = data.subarray((num - 1) * fragmentSize, num * fragmentSize);
                 if (abortContext.abort) {
-                    await this.sendCorruptedFirmwareUpdateReport(fragmentRequest.reportNumber, (0, node_crypto_1.randomBytes)(fragment.length));
+                    await this.sendCorruptedFirmwareUpdateReport(fragmentRequest.reportNumber, (0, node_crypto_1.randomBytes)(fragment.length), nonSecureTransfer);
                     // This will cause the node to abort the process, wait for that
                     break update;
                 }
@@ -4426,7 +4512,12 @@ protocol version:      ${this.protocolVersion}`;
                     });
                     const isLast = num === numFragments;
                     try {
-                        await this.commandClasses["Firmware Update Meta Data"].sendFirmwareFragment(num, isLast, fragment);
+                        await this.commandClasses["Firmware Update Meta Data"]
+                            .withOptions({
+                            // Only encapsulate if the transfer is secure
+                            autoEncapsulate: !nonSecureTransfer,
+                        })
+                            .sendFirmwareFragment(num, isLast, fragment);
                         onProgress(num, numFragments);
                         // If that was the last one wait for status report from the node and restart interview
                         if (isLast) {
@@ -4485,9 +4576,14 @@ protocol version:      ${this.protocolVersion}`;
             return;
         await this._abortFirmwareUpdate();
     }
-    async sendCorruptedFirmwareUpdateReport(reportNum, fragment) {
+    async sendCorruptedFirmwareUpdateReport(reportNum, fragment, nonSecureTransfer = false) {
         try {
-            await this.commandClasses["Firmware Update Meta Data"].sendFirmwareFragment(reportNum, true, fragment);
+            await this.commandClasses["Firmware Update Meta Data"]
+                .withOptions({
+                // Only encapsulate if the transfer is secure
+                autoEncapsulate: !nonSecureTransfer,
+            })
+                .sendFirmwareFragment(reportNum, true, fragment);
         }
         catch {
             // ignore
@@ -5742,7 +5838,7 @@ ${(0, HealthCheck_1.formatRouteHealthCheckSummary)(this.id, otherNode.id, summar
                 continue;
             ret.endpoints ??= {};
             const endpointDump = endpoint.createEndpointDump();
-            collectValues(index, (ccId) => endpointDump.commandClasses[(0, core_1.getCCName)(ccId)]?.values);
+            collectValues(endpoint.index, (ccId) => endpointDump.commandClasses[(0, core_1.getCCName)(ccId)]?.values);
             ret.endpoints[endpoint.index] = endpointDump;
         }
         if (this.deviceConfig) {