zigbee-herdsman 8.0.3 → 9.0.0

package/dist/controller/model/device.js

@@ -45,6 +45,7 @@ const ZSpec = __importStar(require("../../zspec"));
 const enums_1 = require("../../zspec/enums");
 const Zcl = __importStar(require("../../zspec/zcl"));
 const Zdo = __importStar(require("../../zspec/zdo"));
+const ota_1 = require("../helpers/ota");
 const zclTransactionSequenceNumber_1 = __importDefault(require("../helpers/zclTransactionSequenceNumber"));
 const endpoint_1 = __importDefault(require("./endpoint"));
 const entity_1 = __importDefault(require("./entity"));
@@ -86,6 +87,8 @@ class Device extends entity_1.default {
     _pendingRequestTimeout;
     _customClusters = {};
     _gpSecurityKey;
+    #scheduledOta;
+    #otaInProgress = false;
     // Getters/setters
     get ieeeAddr() {
         return this._ieeeAddr;
@@ -230,6 +233,12 @@ class Device extends entity_1.default {
     get genBasic() {
         return this.#genBasic;
     }
+    get scheduledOta() {
+        return this.#scheduledOta;
+    }
+    get otaInProgress() {
+        return this.#otaInProgress;
+    }
     meta;
     // This lookup contains all devices that are queried from the database, this is to ensure that always
     // the same instance is returned.
@@ -237,7 +246,7 @@ class Device extends entity_1.default {
     static loadedFromDatabase = false;
     static deletedDevices = new Map();
     static nwkToIeeeCache = new Map();
-    constructor(id, type, ieeeAddr, networkAddress, manufacturerID, endpoints, manufacturerName, powerSource, modelID, applicationVersion, stackVersion, zclVersion, hardwareVersion, dateCode, softwareBuildID, interviewState, meta, lastSeen, checkinInterval, pendingRequestTimeout, gpSecurityKey) {
+    constructor(id, type, ieeeAddr, networkAddress, manufacturerID, endpoints, manufacturerName, powerSource, modelID, applicationVersion, stackVersion, zclVersion, hardwareVersion, dateCode, softwareBuildID, interviewState, meta, lastSeen, checkinInterval, pendingRequestTimeout, gpSecurityKey, scheduledOta) {
         super();
         this.ID = id;
         this._type = type;
@@ -261,6 +270,7 @@ class Device extends entity_1.default {
         this._checkinInterval = checkinInterval;
         this._pendingRequestTimeout = pendingRequestTimeout;
         this._gpSecurityKey = gpSecurityKey;
+        this.#scheduledOta = scheduledOta;
     }
     createEndpoint(id) {
         if (this.getEndpoint(id)) {
@@ -312,74 +322,85 @@ class Device extends entity_1.default {
             // prevent race conditions where device gets deleted during processing
             return;
         }
-        // Respond to enroll requests
-        if (frame.header.isSpecific && frame.isCluster("ssIasZone") && frame.isCommand("enrollReq")) {
-            logger_1.logger.debug(`IAS - '${this.ieeeAddr}' responding to enroll response`, NS);
-            const payload = { enrollrspcode: 0, zoneid: 23 };
-            await endpoint.command("ssIasZone", "enrollRsp", payload, { disableDefaultResponse: true });
-        }
-        // Response to read requests
-        if (frame.header.isGlobal && frame.isCommand("read") && !this._customReadResponse?.(frame, endpoint)) {
-            const attributes = {
-                ...endpoint.clusters,
-            };
-            const isTimeReadRequest = dataPayload.clusterID === Zcl.Clusters.genTime.ID;
-            if (isTimeReadRequest) {
-                attributes.genTime = {
-                    attributes: timeService.getTimeClusterAttributes(),
+        if (frame.header.isGlobal) {
+            // Response to read requests
+            if (frame.command.name === "read" && !this._customReadResponse?.(frame, endpoint)) {
+                const attributes = {
+                    ...endpoint.clusters,
                 };
-            }
-            if (frame.cluster.name in attributes) {
-                const response = {};
-                for (const entry of frame.payload) {
-                    const name = frame.cluster.getAttribute(entry.attrId)?.name;
-                    if (name && name in attributes[frame.cluster.name].attributes) {
-                        response[name] = attributes[frame.cluster.name].attributes[name];
-                    }
+                const isTimeReadRequest = dataPayload.clusterID === Zcl.Clusters.genTime.ID;
+                if (isTimeReadRequest) {
+                    attributes.genTime = {
+                        attributes: timeService.getTimeClusterAttributes(),
+                    };
                 }
-                try {
-                    await endpoint.readResponse(frame.cluster.ID, frame.header.transactionSequenceNumber, response, {
-                        srcEndpoint: dataPayload.destinationEndpoint,
-                    });
-                }
-                catch (error) {
-                    logger_1.logger.error(`Read response to ${this.ieeeAddr} failed (${error.message})`, NS);
+                if (frame.cluster.name in attributes) {
+                    const response = {};
+                    for (const entry of frame.payload) {
+                        const name = frame.cluster.getAttribute(entry.attrId)?.name;
+                        if (name && name in attributes[frame.cluster.name].attributes) {
+                            response[name] = attributes[frame.cluster.name].attributes[name];
+                        }
+                    }
+                    try {
+                        await endpoint.readResponse(frame.cluster.ID, frame.header.transactionSequenceNumber, response, {
+                            srcEndpoint: dataPayload.destinationEndpoint,
+                        });
+                    }
+                    catch (error) {
+                        logger_1.logger.error(`Read response to ${this.ieeeAddr} failed (${error.message})`, NS);
+                    }
                 }
             }
         }
-        // Handle check-in from sleeping end devices
-        if (frame.header.isSpecific && frame.isCluster("genPollCtrl") && frame.isCommand("checkin")) {
-            try {
-                if (this.hasPendingRequests() || this._checkinInterval === undefined) {
-                    logger_1.logger.debug(`check-in from ${this.ieeeAddr}: accepting fast-poll`, NS);
-                    await endpoint.command(frame.cluster.name, "checkinRsp", {
-                        startFastPolling: 1,
-                        fastPollTimeout: 0,
-                    }, { sendPolicy: "immediate" });
-                    // This is a good time to read the checkin interval if we haven't stored it previously
-                    if (this._checkinInterval === undefined) {
-                        const pollPeriod = await endpoint.read("genPollCtrl", ["checkinInterval"], { sendPolicy: "immediate" });
-                        this._checkinInterval = pollPeriod.checkinInterval / 4; // convert to seconds
-                        this.resetPendingRequestTimeout();
-                        logger_1.logger.debug(`Request Queue (${this.ieeeAddr}): default expiration timeout set to ${this.pendingRequestTimeout}`, NS);
+        else if (frame.header.isSpecific) {
+            switch (frame.cluster.name) {
+                case "ssIasZone": {
+                    if (frame.command.name === "enrollReq") {
+                        // Respond to enroll requests
+                        logger_1.logger.debug(`IAS - '${this.ieeeAddr}' responding to enroll response`, NS);
+                        await endpoint.command("ssIasZone", "enrollRsp", { enrollrspcode: 0, zoneid: 23 }, { disableDefaultResponse: true });
                     }
-                    await Promise.all(this.endpoints.map(async (e) => await e.sendPendingRequests(true)));
-                    // We *must* end fast-poll when we're done sending things. Otherwise
-                    // we cause undue power-drain.
-                    logger_1.logger.debug(`check-in from ${this.ieeeAddr}: stopping fast-poll`, NS);
-                    await endpoint.command(frame.cluster.name, "fastPollStop", {}, { sendPolicy: "immediate" });
+                    break;
                 }
-                else {
-                    logger_1.logger.debug(`check-in from ${this.ieeeAddr}: declining fast-poll`, NS);
-                    await endpoint.command(frame.cluster.name, "checkinRsp", {
-                        startFastPolling: 0,
-                        fastPollTimeout: 0,
-                    }, { sendPolicy: "immediate" });
+                case "genPollCtrl": {
+                    if (frame.command.name === "checkin") {
+                        // Handle check-in from sleeping end devices
+                        try {
+                            if (this.hasPendingRequests() || this._checkinInterval === undefined) {
+                                logger_1.logger.debug(`check-in from ${this.ieeeAddr}: accepting fast-poll`, NS);
+                                await endpoint.command(frame.cluster.name, "checkinRsp", {
+                                    startFastPolling: 1,
+                                    fastPollTimeout: 0,
+                                }, { sendPolicy: "immediate" });
+                                // This is a good time to read the checkin interval if we haven't stored it previously
+                                if (this._checkinInterval === undefined) {
+                                    const pollPeriod = await endpoint.read("genPollCtrl", ["checkinInterval"], { sendPolicy: "immediate" });
+                                    this._checkinInterval = pollPeriod.checkinInterval / 4; // convert to seconds
+                                    this.resetPendingRequestTimeout();
+                                    logger_1.logger.debug(`Request Queue (${this.ieeeAddr}): default expiration timeout set to ${this.pendingRequestTimeout}`, NS);
+                                }
+                                await Promise.all(this.endpoints.map(async (e) => await e.sendPendingRequests(true)));
+                                // We *must* end fast-poll when we're done sending things. Otherwise
+                                // we cause undue power-drain.
+                                logger_1.logger.debug(`check-in from ${this.ieeeAddr}: stopping fast-poll`, NS);
+                                await endpoint.command(frame.cluster.name, "fastPollStop", {}, { sendPolicy: "immediate" });
+                            }
+                            else {
+                                logger_1.logger.debug(`check-in from ${this.ieeeAddr}: declining fast-poll`, NS);
+                                await endpoint.command(frame.cluster.name, "checkinRsp", {
+                                    startFastPolling: 0,
+                                    fastPollTimeout: 0,
+                                }, { sendPolicy: "immediate" });
+                            }
+                        }
+                        catch (error) {
+                            logger_1.logger.error(`Handling of poll check-in from ${this.ieeeAddr} failed (${error.message})`, NS);
+                        }
+                    }
+                    break;
                 }
             }
-            catch (error) {
-                logger_1.logger.error(`Handling of poll check-in from ${this.ieeeAddr} failed (${error.message})`, NS);
-            }
         }
         // Send a default response if necessary.
         const isDefaultResponse = frame.header.isGlobal && frame.command.name === "defaultRsp";
@@ -456,7 +477,7 @@ class Device extends entity_1.default {
             entry.interviewState = entry.interviewCompleted ? InterviewState.Successful : InterviewState.Failed;
             logger_1.logger.debug(`Migrated interviewState for '${ieeeAddr}': ${entry.interviewCompleted} -> ${entry.interviewState}`, NS);
         }
-        return new Device(entry.id, entry.type, ieeeAddr, networkAddress, entry.manufId, endpoints, entry.manufName, entry.powerSource, entry.modelId, entry.appVersion, entry.stackVersion, entry.zclVersion, entry.hwVersion, entry.dateCode, entry.swBuildId, entry.interviewState, meta, entry.lastSeen, entry.checkinInterval, pendingRequestTimeout, entry.gpSecurityKey);
+        return new Device(entry.id, entry.type, ieeeAddr, networkAddress, entry.manufId, endpoints, entry.manufName, entry.powerSource, entry.modelId, entry.appVersion, entry.stackVersion, entry.zclVersion, entry.hwVersion, entry.dateCode, entry.swBuildId, entry.interviewState, meta, entry.lastSeen, entry.checkinInterval, pendingRequestTimeout, entry.gpSecurityKey, entry.scheduledOta);
     }
     toDatabaseEntry() {
         const epList = this.endpoints.map((e) => e.ID);
@@ -488,6 +509,7 @@ class Device extends entity_1.default {
             lastSeen: this.lastSeen,
             checkinInterval: this.checkinInterval,
             gpSecurityKey: this.gpSecurityKey,
+            scheduledOta: this.scheduledOta,
         };
     }
     save(writeDatabase = true) {
@@ -565,7 +587,7 @@ class Device extends entity_1.default {
             throw new Error(`Device with IEEE address '${ieeeAddr}' already exists`);
         }
         const ID = entity_1.default.database.newID();
-        const device = new Device(ID, type, ieeeAddr, networkAddress, manufacturerID, [], manufacturerName, powerSource, modelID, undefined, undefined, undefined, undefined, undefined, undefined, interviewState, {}, undefined, undefined, 0, gpSecurityKey);
+        const device = new Device(ID, type, ieeeAddr, networkAddress, manufacturerID, [], manufacturerName, powerSource, modelID, undefined, undefined, undefined, undefined, undefined, undefined, interviewState, {}, undefined, undefined, 0, gpSecurityKey, undefined);
         entity_1.default.database.insert(device.toDatabaseEntry());
         Device.devices.set(device.ieeeAddr, device);
         Device.nwkToIeeeCache.set(device.networkAddress, device.ieeeAddr);
@@ -1054,6 +1076,269 @@ class Device extends entity_1.default {
         }
         this._customClusters[name] = cluster;
     }
+    #waitForOtaCommand(endpointId, commandId, transactionSequenceNumber, timeout) {
+        const waiter = entity_1.default.adapter.waitFor(this.networkAddress, endpointId, Zcl.FrameType.SPECIFIC, Zcl.Direction.CLIENT_TO_SERVER, transactionSequenceNumber, Zcl.Clusters.genOta.ID, commandId, timeout);
+        const promise = new Promise((resolve, reject) => {
+            waiter.promise.then((payload) => {
+                try {
+                    const frame = Zcl.Frame.fromBuffer(payload.clusterID, payload.header, payload.data, this.customClusters);
+                    resolve(frame);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, (error) => reject(error));
+        });
+        return { promise, cancel: waiter.cancel };
+    }
+    async findMatchingOtaImage(source, current, extraMetas) {
+        logger_1.logger.debug(() => `Getting image metadata for ${this.ieeeAddr}...`, NS);
+        const images = await (0, ota_1.getOtaIndex)(source);
+        // NOTE: Officially an image can be determined with a combination of manufacturerCode and imageType.
+        // However several manufacturers do not follow the spec properly.
+        // The index provides the needed extra metadata to prevent mismatches.
+        // e.g. Tuya must match on manufacturerName, Gledopto on modelId...
+        return images.find((i) => i.imageType === current.imageType &&
+            i.manufacturerCode === current.manufacturerCode &&
+            (i.minFileVersion === undefined || current.fileVersion >= i.minFileVersion) &&
+            (i.maxFileVersion === undefined || current.fileVersion <= i.maxFileVersion) &&
+            // let extra metas override the match from this.modelID, same for manufacturerName
+            (!i.modelId || i.modelId === this.modelID || i.modelId === extraMetas.modelId) &&
+            (!i.manufacturerName ||
+                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
+                i.manufacturerName.includes(this.manufacturerName) ||
+                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
+                i.manufacturerName.includes(extraMetas.manufacturerName)) &&
+            (!extraMetas.otaHeaderString || i.otaHeaderString === extraMetas.otaHeaderString) &&
+            (i.hardwareVersionMin === undefined ||
+                (current.hardwareVersion !== undefined && current.hardwareVersion >= i.hardwareVersionMin) ||
+                (extraMetas.hardwareVersionMin !== undefined && extraMetas.hardwareVersionMin >= i.hardwareVersionMin)) &&
+            (i.hardwareVersionMax === undefined ||
+                (current.hardwareVersion !== undefined && current.hardwareVersion <= i.hardwareVersionMax) ||
+                (extraMetas.hardwareVersionMax !== undefined && extraMetas.hardwareVersionMax <= i.hardwareVersionMax)));
+    }
+    async #notifyOta(endpoint) {
+        // Some devices (e.g. Insta) take a very long trying to discover the correct coordinator EP for OTA
+        const queryNextImageRequest = this.#waitForOtaCommand(endpoint.ID, Zcl.Clusters.genOta.commands.queryNextImageRequest.ID, undefined, 60000);
+        try {
+            await endpoint.commandResponse("genOta", "imageNotify", { payloadType: 0, queryJitter: 100 }, { sendPolicy: "immediate" });
+            const response = await queryNextImageRequest.promise;
+            return [response.payload, response.header.transactionSequenceNumber];
+        }
+        catch {
+            queryNextImageRequest.cancel();
+            throw new Error(`Device didn't respond to OTA request`);
+        }
+    }
+    /**
+     * If `current` is undefined, will automatically notify and reply to query with `NO_IMAGE_AVAILABLE` (stops device from doing further requests).
+     */
+    async checkOta(source, current, extraMetas, endpoint = this.endpoints.find((e) => e.supportsOutputCluster("genOta"))) {
+        (0, node_assert_1.default)(endpoint !== undefined, `No endpoint found with OTA cluster support for ${this.ieeeAddr}`);
+        if (this.modelID === "PP-WHT-US") {
+            // see https://github.com/Koenkk/zigbee-OTA/pull/14
+            const scenesEndpoint = this.endpoints.find((e) => e.supportsOutputCluster("genScenes"));
+            if (scenesEndpoint !== undefined) {
+                await scenesEndpoint.write("genScenes", { currentGroup: 49502 });
+            }
+        }
+        if (current === undefined) {
+            let queryTsn;
+            [current, queryTsn] = await this.#notifyOta(endpoint);
+            await endpoint.commandResponse("genOta", "queryNextImageResponse", { status: Zcl.Status.NO_IMAGE_AVAILABLE }, undefined, queryTsn);
+        }
+        logger_1.logger.debug(() => `Checking OTA ${this.ieeeAddr} ${source.downgrade ? "downgrade" : "upgrade"} image availability, current=${JSON.stringify(current)}`, NS);
+        if (this.meta.lumiFileVersion &&
+            (this.modelID === "lumi.airrtc.agl001" || this.modelID === "lumi.curtain.acn003" || this.modelID === "lumi.curtain.agl001")) {
+            // The current.fileVersion which comes from the device is wrong.
+            // Use the `lumiFileVersion` which comes from the manuSpecificLumi.attributeReport instead.
+            // https://github.com/Koenkk/zigbee2mqtt/issues/16345#issuecomment-1454835056
+            // https://github.com/Koenkk/zigbee2mqtt/issues/16345 doesn't seem to be needed for all
+            // https://github.com/Koenkk/zigbee2mqtt/issues/15745
+            current = { ...current, fileVersion: this.meta.lumiFileVersion };
+        }
+        const meta = await this.findMatchingOtaImage(source, current, extraMetas);
+        if (!meta) {
+            // no image in repo/URL for specified device
+            return {
+                available: 0,
+                current,
+            };
+        }
+        logger_1.logger.debug(() => `OTA ${source.downgrade ? "downgrade" : "upgrade"} image availability for ${this.ieeeAddr}, available=${JSON.stringify(meta)}`, NS);
+        return {
+            available: meta.force ? -1 : Math.sign(current.fileVersion - meta.fileVersion),
+            current,
+            availableMeta: meta,
+        };
+    }
+    async updateOta(source, requestPayload, requestTsn, extraMetas, onProgress, dataSettings, endpoint = this.endpoints.find((e) => e.supportsOutputCluster("genOta"))) {
+        (0, node_assert_1.default)(this.#otaInProgress === false, `OTA already in progress for ${this.ieeeAddr}`);
+        (0, node_assert_1.default)(endpoint !== undefined, `No endpoint found with OTA cluster support for ${this.ieeeAddr}`);
+        if (source === undefined) {
+            (0, node_assert_1.default)(this.#scheduledOta !== undefined, `No currently scheduled OTA for ${this.ieeeAddr}`);
+            source = this.#scheduledOta;
+        }
+        this.#otaInProgress = true;
+        // always expected both undefined if one is, but just in case
+        if (requestPayload === undefined || requestTsn === undefined) {
+            try {
+                [requestPayload, requestTsn] = await this.#notifyOta(endpoint);
+            }
+            finally {
+                this.#otaInProgress = false;
+            }
+        }
+        let available = 0;
+        let image;
+        if (source.url && !source.url.endsWith(".json")) {
+            // firmware file at `source.url`
+            try {
+                const downloadedFile = await (0, ota_1.getOtaFirmware)(source.url, undefined);
+                image = (0, ota_1.parseOtaImage)(downloadedFile);
+                available = Math.sign(requestPayload.fileVersion - image.header.fileVersion);
+                logger_1.logger.debug(() => 
+                // biome-ignore lint/style/noNonNullAssertion: valid from above, won't change after assignment
+                `Parsed image from '${source.url}' for ${this.ieeeAddr}, header=${JSON.stringify(image.header)}`, NS);
+            }
+            catch (error) {
+                logger_1.logger.error(`Failed to parse OTA image from '${source.url}' for ${this.ieeeAddr}, aborting (${error.message})`, NS);
+                // biome-ignore lint/style/noNonNullAssertion: expected valid
+                logger_1.logger.debug(error.stack, NS);
+            }
+        }
+        else {
+            let availableMeta;
+            try {
+                // index file at `source.url` (or undefined to use defaults)
+                ({ available, availableMeta } = await this.checkOta(source, requestPayload, extraMetas, endpoint));
+            }
+            finally {
+                this.#otaInProgress = false;
+            }
+            if ((source.downgrade ? available === 1 : available === -1) && availableMeta) {
+                try {
+                    const downloadedFile = await (0, ota_1.getOtaFirmware)(availableMeta.url, availableMeta.sha512);
+                    image = (0, ota_1.parseOtaImage)(downloadedFile);
+                    logger_1.logger.debug(() => 
+                    // biome-ignore lint/style/noNonNullAssertion: valid from above, won't change after assignment
+                    `Parsed image from '${availableMeta.url}' for ${this.ieeeAddr}, header=${JSON.stringify(image.header)}`, NS);
+                }
+                catch (error) {
+                    logger_1.logger.error(`Failed to parse OTA image for ${this.ieeeAddr}, aborting (${error.message})`, NS);
+                    // biome-ignore lint/style/noNonNullAssertion: expected valid
+                    logger_1.logger.debug(error.stack, NS);
+                }
+            }
+            else {
+                logger_1.logger.info(() => `No OTA ${source.downgrade ? "downgrade" : "upgrade"} image currently available for ${this.ieeeAddr}`, NS);
+            }
+        }
+        // reply to `queryNextImageRequest` now that we have the data for it, should trigger image block/page request from device
+        // NOTE: previous code had try/catch wrapping with ignored error, but that doesn't look good (would fail to start OTA from device side)
+        try {
+            await endpoint.commandResponse("genOta", "queryNextImageResponse", image && available !== 0
+                ? {
+                    status: Zcl.Status.SUCCESS,
+                    manufacturerCode: image.header.manufacturerCode,
+                    imageType: image.header.imageType,
+                    fileVersion: image.header.fileVersion,
+                    imageSize: image.header.totalImageSize,
+                }
+                : { status: Zcl.Status.NO_IMAGE_AVAILABLE }, undefined, requestTsn);
+        }
+        finally {
+            this.#otaInProgress = false;
+        }
+        if (!image || available === 0) {
+            this.#otaInProgress = false;
+            return [requestPayload, undefined];
+        }
+        logger_1.logger.debug(() => `Starting OTA update for ${this.ieeeAddr}`, NS);
+        const session = new ota_1.OtaSession(this.ieeeAddr, endpoint, image, onProgress, dataSettings, this.#waitForOtaCommand.bind(this));
+        let endResult;
+        try {
+            endResult = await session.run();
+        }
+        finally {
+            this.#otaInProgress = false;
+        }
+        logger_1.logger.debug(() => `Received upgrade end request for ${this.ieeeAddr}: ${JSON.stringify(endResult.payload)}`, NS);
+        if (endResult.payload.status === Zcl.Status.SUCCESS) {
+            try {
+                const currentTime = timeService.timestampToZigbeeUtcTime(Date.now());
+                await endpoint.commandResponse("genOta", "upgradeEndResponse", {
+                    manufacturerCode: image.header.manufacturerCode,
+                    imageType: image.header.imageType,
+                    fileVersion: image.header.fileVersion,
+                    currentTime,
+                    upgradeTime: currentTime + 1, // TODO: could this tiny offset be a problem for some stacks?
+                }, undefined, endResult.header.transactionSequenceNumber);
+                onProgress(100, 0);
+                logger_1.logger.info(() => `Update of ${this.ieeeAddr} successful (${Math.round((performance.now() - session.startTime) / 1000)} seconds). Waiting for device announce...`, NS);
+                let timer;
+                await new Promise((resolve) => {
+                    const onDeviceAnnounce = () => {
+                        clearTimeout(timer);
+                        logger_1.logger.debug(() => `Received device announce for ${this.ieeeAddr}, OTA update finished.`, NS);
+                        resolve();
+                    };
+                    // force "finished" after given time
+                    timer = setTimeout(() => {
+                        this.removeListener("deviceAnnounce", onDeviceAnnounce);
+                        logger_1.logger.debug(() => `Timed out waiting for device announce for ${this.ieeeAddr}, OTA update considered finished.`, NS);
+                        resolve();
+                    }, 120000 /** consider "done" after timeout even if no announce seen */);
+                    this.once("deviceAnnounce", onDeviceAnnounce);
+                });
+                // only "cancel" possible scheduled OTA when successful
+                this.#scheduledOta = undefined;
+                this.#otaInProgress = false;
+                return [
+                    requestPayload,
+                    {
+                        fieldControl: 0,
+                        manufacturerCode: image.header.manufacturerCode,
+                        imageType: image.header.imageType,
+                        fileVersion: image.header.fileVersion,
+                    },
+                ];
+            }
+            catch (error) {
+                this.#otaInProgress = false;
+                throw new Error(`OTA upgrade end response failed: ${error.message}`);
+            }
+        }
+        else {
+            /**
+             * For other status value received such as INVALID_IMAGE, REQUIRE_MORE_IMAGE, or ABORT,
+             * the upgrade server SHALL not send Upgrade End Response command but it SHALL send default
+             * response command with status of success and it SHALL wait for the client to reinitiate the upgrade process.
+             */
+            try {
+                await endpoint.defaultResponse(Zcl.Clusters.genOta.commands.upgradeEndRequest.ID, Zcl.Status.SUCCESS, Zcl.Clusters.genOta.ID, endResult.header.transactionSequenceNumber);
+            }
+            catch (error) {
+                logger_1.logger.debug(() => `OTA upgrade end request default response for ${this.ieeeAddr} failed: ${error.message}`, NS);
+            }
+            this.#otaInProgress = false;
+            throw new Error(`OTA update of ${this.ieeeAddr} failed with reason: ${Zcl.Status[endResult.payload.status]}`);
+        }
+    }
+    scheduleOta(source) {
+        (0, node_assert_1.default)(this.endpoints.some((e) => e.supportsOutputCluster("genOta")), `No endpoint found with OTA cluster support for ${this.ieeeAddr}`);
+        if (this.#scheduledOta) {
+            logger_1.logger.info(`Previously scheduled OTA update for '${this.ieeeAddr}' was cancelled in favor of new schedule request`, NS);
+        }
+        this.#scheduledOta = source;
+        logger_1.logger.info(`Scheduled OTA update for '${this.ieeeAddr}' on next request from device`, NS);
+    }
+    unscheduleOta() {
+        if (this.#scheduledOta !== undefined) {
+            this.#scheduledOta = undefined;
+            logger_1.logger.info(`Previously scheduled OTA update for '${this.ieeeAddr}' was cancelled`, NS);
+        }
+    }
 }
 exports.Device = Device;
 exports.default = Device;