@capgo/capacitor-updater 8.45.9 → 8.45.11

package/ios/Sources/CapacitorUpdaterPlugin/CapgoUpdater.swift

@@ -81,15 +81,51 @@ import UIKit
         CapgoUpdater.buildUserAgent(appId: appId, pluginVersion: pluginVersion, versionOs: versionOs)
     }
 
+    struct RequestResult {
+        let data: Data?
+        let response: HTTPURLResponse?
+        let error: Error?
+        let timedOut: Bool
+    }
+
+    private struct DownloadRequestResult {
+        let fileURL: URL?
+        let response: HTTPURLResponse?
+        let error: Error?
+        let timedOut: Bool
+    }
+
+    private func isTimedOutError(_ error: Error?) -> Bool {
+        guard let nsError = error as NSError? else {
+            return false
+        }
+
+        return nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorTimedOut
+    }
+
     private lazy var alamofireSession: Session = {
-        let configuration = URLSessionConfiguration.default
+        let configuration = URLSessionConfiguration.ephemeral
         configuration.httpAdditionalHeaders = ["User-Agent": self.userAgent]
+        configuration.httpCookieStorage = nil
+        configuration.httpShouldSetCookies = false
+        configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
+        configuration.urlCache = nil
         return Session(configuration: configuration)
     }()
+    private let networkResponseQueue = DispatchQueue(label: "ee.forgr.capacitor-updater.network-response", qos: .utility)
 
     public var notifyDownloadRaw: (String, Int, Bool, BundleInfo?) -> Void = { _, _, _, _  in }
     public func notifyDownload(id: String, percent: Int, ignoreMultipleOfTen: Bool = false, bundle: BundleInfo? = nil) {
-        notifyDownloadRaw(id, percent, ignoreMultipleOfTen, bundle)
+        let emit = {
+            self.notifyDownloadRaw(id, percent, ignoreMultipleOfTen, bundle)
+        }
+        if Thread.isMainThread {
+            emit()
+        } else {
+            DispatchQueue.main.async {
+                emit()
+            }
+        }
     }
     public var notifyDownload: (String, Int) -> Void = { _, _  in }
     public var notifyListeners: (String, [String: Any]) -> Void = { _, _ in }
@@ -98,6 +134,145 @@ import UIKit
         self.logger = logger
     }
 
+    private func createRequest(url: URL, method: String, parameters: [String: Any]? = nil, expectsJSONResponse: Bool = false) -> URLRequest? {
+        var request = URLRequest(url: url)
+        request.httpMethod = method
+        request.timeoutInterval = self.timeout
+        request.setValue(self.userAgent, forHTTPHeaderField: "User-Agent")
+        if expectsJSONResponse || parameters != nil {
+            request.setValue("application/json", forHTTPHeaderField: "Accept")
+        }
+
+        guard let parameters else {
+            return request
+        }
+
+        guard JSONSerialization.isValidJSONObject(parameters) else {
+            logger.error("Invalid JSON body for \(method) \(url.absoluteString)")
+            return nil
+        }
+
+        do {
+            request.httpBody = try JSONSerialization.data(withJSONObject: parameters)
+            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            return request
+        } catch {
+            logger.error("Error encoding request body for \(method) \(url.absoluteString)")
+            logger.debug("Error: \(error.localizedDescription)")
+            return nil
+        }
+    }
+
+    func performRequest(_ request: URLRequest, label: String) -> RequestResult {
+        let waitTimeout = max(self.timeout + 5, 10)
+        let semaphore = DispatchSemaphore(value: 0)
+        var responseData: Data?
+        var httpResponse: HTTPURLResponse?
+        var requestError: Error?
+        let dataRequest = self.alamofireSession.request(request).responseData(queue: self.networkResponseQueue) { response in
+            responseData = response.data
+            httpResponse = response.response
+            requestError = response.error
+            semaphore.signal()
+        }
+        dataRequest.resume()
+
+        if semaphore.wait(timeout: .now() + waitTimeout) == .timedOut {
+            dataRequest.cancel()
+            logger.error("\(label) timed out after \(Int(waitTimeout))s")
+            return RequestResult(data: responseData, response: httpResponse, error: requestError, timedOut: true)
+        }
+
+        return RequestResult(data: responseData, response: httpResponse, error: requestError, timedOut: false)
+    }
+
+    private func performDownloadRequest(_ request: URLRequest, label: String) -> DownloadRequestResult {
+        let waitTimeout = max(self.timeout + 5, 10)
+        let semaphore = DispatchSemaphore(value: 0)
+        var tempFileURL: URL?
+        var httpResponse: HTTPURLResponse?
+        var requestError: Error?
+        let temporaryDownloadURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let destination: DownloadRequest.Destination = { _, _ in
+            (temporaryDownloadURL, [.removePreviousFile, .createIntermediateDirectories])
+        }
+        let downloadRequest = self.alamofireSession.download(request, to: destination).response(queue: self.networkResponseQueue) { response in
+            tempFileURL = response.fileURL
+            httpResponse = response.response
+            requestError = response.error
+            semaphore.signal()
+        }
+        downloadRequest.resume()
+
+        if semaphore.wait(timeout: .now() + waitTimeout) == .timedOut {
+            downloadRequest.cancel()
+            logger.error("\(label) timed out after \(Int(waitTimeout))s")
+            return DownloadRequestResult(
+                fileURL: existingDownloadFileURL(tempFileURL, fallback: temporaryDownloadURL),
+                response: httpResponse,
+                error: requestError,
+                timedOut: true
+            )
+        }
+
+        if isTimedOutError(requestError) {
+            logger.error("\(label) timed out after \(Int(waitTimeout))s")
+        }
+
+        return DownloadRequestResult(
+            fileURL: existingDownloadFileURL(tempFileURL, fallback: temporaryDownloadURL),
+            response: httpResponse,
+            error: requestError,
+            timedOut: isTimedOutError(requestError)
+        )
+    }
+
+    private func existingDownloadFileURL(_ fileURL: URL?, fallback: URL) -> URL? {
+        let fileManager = FileManager.default
+        if let fileURL, fileManager.fileExists(atPath: fileURL.path) {
+            return fileURL
+        }
+        return fileManager.fileExists(atPath: fallback.path) ? fallback : nil
+    }
+
+    private func storeDownloadedFile(_ downloadedFileURL: URL, at tempPath: URL, existingBytes: Int64, response: HTTPURLResponse?) throws {
+        let fileManager = FileManager.default
+        if existingBytes > 0 && (response?.statusCode == 206 || response == nil) {
+            let resumedData = try Data(contentsOf: downloadedFileURL)
+            let fileHandle = try FileHandle(forWritingTo: tempPath)
+            fileHandle.seek(toFileOffset: UInt64(existingBytes))
+            fileHandle.write(resumedData)
+            try fileHandle.close()
+            try? fileManager.removeItem(at: downloadedFileURL)
+            return
+        }
+
+        if fileManager.fileExists(atPath: tempPath.path) {
+            try fileManager.removeItem(at: tempPath)
+        }
+        try fileManager.moveItem(at: downloadedFileURL, to: tempPath)
+    }
+
+    private func persistPartialDownload(_ downloadResult: DownloadRequestResult, id: String, tempPath: URL, existingBytes: Int64) {
+        guard let downloadedFileURL = downloadResult.fileURL else {
+            return
+        }
+        guard FileManager.default.fileExists(atPath: downloadedFileURL.path) else {
+            return
+        }
+        if let statusCode = downloadResult.response?.statusCode, statusCode < 200 || statusCode >= 300 {
+            return
+        }
+
+        do {
+            try storeDownloadedFile(downloadedFileURL, at: tempPath, existingBytes: existingBytes, response: downloadResult.response)
+            logger.info("Stored partial download for retry")
+        } catch {
+            logger.error("Failed to store partial download")
+            logger.debug("Path: \(downloadedFileURL.path), Error: \(error)")
+        }
+    }
+
     deinit {
         // Invalidate the stats timer to prevent memory leaks
         statsFlushTimer?.invalidate()
@@ -224,8 +399,8 @@ import UIKit
         self.alamofireSession.request(
             self.statsUrl,
             method: .post,
-            parameters: parameters,
-            encoder: JSONParameterEncoder.default,
+            parameters: parameters.toParameters(),
+            encoding: JSONEncoding.default,
             requestModifier: { $0.timeoutInterval = self.timeout }
         ).responseData { response in
             switch response.result {
@@ -334,6 +509,65 @@ import UIKit
         }
     }
 
+    private func extractZipEntry(_ archive: Archive, entry: Entry, to destPath: URL) throws {
+        let fileManager = FileManager.default
+
+        switch entry.type {
+        case .directory:
+            try fileManager.createDirectory(at: destPath, withIntermediateDirectories: true, attributes: nil)
+        case .file:
+            let parentDir = destPath.deletingLastPathComponent()
+            try fileManager.createDirectory(at: parentDir, withIntermediateDirectories: true, attributes: nil)
+
+            if fileManager.fileExists(atPath: destPath.path) {
+                try fileManager.removeItem(at: destPath)
+            }
+
+            guard fileManager.createFile(atPath: destPath.path, contents: nil) else {
+                throw CustomError.cannotUnzip
+            }
+
+            let fileHandle = try FileHandle(forWritingTo: destPath)
+            defer {
+                fileHandle.closeFile()
+            }
+
+            _ = try archive.extract(entry, bufferSize: 16 * 1024, skipCRC32: true) { data in
+                if !data.isEmpty {
+                    fileHandle.write(data)
+                }
+            }
+        case .symlink:
+            var linkData = Data()
+            _ = try archive.extract(entry, bufferSize: 16 * 1024, skipCRC32: true) { data in
+                linkData.append(data)
+            }
+
+            guard let linkPath = String(data: linkData, encoding: .utf8) else {
+                throw CustomError.cannotUnzip
+            }
+
+            let parentDir = destPath.deletingLastPathComponent()
+            try fileManager.createDirectory(at: parentDir, withIntermediateDirectories: true, attributes: nil)
+
+            let isAbsolutePath = (linkPath as NSString).isAbsolutePath
+            let linkURL = URL(fileURLWithPath: linkPath, relativeTo: isAbsolutePath ? nil : parentDir)
+            let canonicalPath = linkURL.standardizedFileURL.path
+            let canonicalDir = parentDir.standardizedFileURL.path
+            let normalizedDir = canonicalDir.hasSuffix("/") ? canonicalDir : "\(canonicalDir)/"
+
+            if canonicalPath != canonicalDir && !canonicalPath.hasPrefix(normalizedDir) {
+                throw CustomError.cannotUnzip
+            }
+
+            if fileManager.fileExists(atPath: destPath.path) {
+                try fileManager.removeItem(at: destPath)
+            }
+
+            try fileManager.createSymbolicLink(atPath: destPath.path, withDestinationPath: linkPath)
+        }
+    }
+
     private func saveDownloaded(sourceZip: URL, id: String, base: URL, notify: Bool) throws {
         try prepareFolder(source: base)
         let destPersist: URL = base.appendingPathComponent(id)
@@ -365,14 +599,26 @@ import UIKit
 
                 let destPath = destUnZip.appendingPathComponent(entry.path)
 
+                if entry.type == .directory {
+                    try FileManager.default.createDirectory(at: destPath, withIntermediateDirectories: true, attributes: nil)
+                    processedEntries += 1
+                    if notify && totalEntries > 0 {
+                        let newPercent = self.calcTotalPercent(percent: Int(Double(processedEntries) / Double(totalEntries) * 100), min: 75, max: 81)
+                        if newPercent != self.unzipPercent {
+                            self.unzipPercent = newPercent
+                            self.notifyDownload(id: id, percent: newPercent)
+                        }
+                    }
+                    continue
+                }
+
                 // Create parent directories if needed
                 let parentDir = destPath.deletingLastPathComponent()
                 if !FileManager.default.fileExists(atPath: parentDir.path) {
                     try FileManager.default.createDirectory(at: parentDir, withIntermediateDirectories: true, attributes: nil)
                 }
 
-                // Extract the entry
-                _ = try archive.extract(entry, to: destPath, skipCRC32: true)
+                try self.extractZipEntry(archive, entry: entry, to: destPath)
 
                 // Update progress
                 processedEntries += 1
@@ -476,65 +722,117 @@ import UIKit
     }
 
     public func getLatest(url: URL, channel: String?) -> AppVersion {
-        let semaphore: DispatchSemaphore = DispatchSemaphore(value: 0)
         let latest: AppVersion = AppVersion()
+        func applyLatestResponse(_ value: AppVersionDec?) {
+            if let url = value?.url {
+                latest.url = url
+            }
+            if let checksum = value?.checksum {
+                latest.checksum = checksum
+            }
+            if let version = value?.version {
+                latest.version = version
+            }
+            if let major = value?.major {
+                latest.major = major
+            }
+            if let breaking = value?.breaking {
+                latest.breaking = breaking
+            }
+            if let error = value?.error {
+                latest.error = error
+            }
+            if let kind = value?.kind {
+                latest.kind = kind
+            }
+            if let message = value?.message {
+                latest.message = message
+            }
+            if let sessionKey = value?.session_key {
+                latest.sessionKey = sessionKey
+            }
+            if let data = value?.data {
+                latest.data = data
+            }
+            if let manifest = value?.manifest {
+                latest.manifest = manifest
+            }
+            if let link = value?.link {
+                latest.link = link
+            }
+            if let comment = value?.comment {
+                latest.comment = comment
+            }
+        }
+
         var parameters: InfoObject = self.createInfoObject()
         if let channel = channel {
             parameters.defaultChannel = channel
         }
-        logger.info("Auto-update parameters: \(parameters)")
-        let request = alamofireSession.request(url, method: .post, parameters: parameters, encoder: JSONParameterEncoder.default, requestModifier: { $0.timeoutInterval = self.timeout })
+        guard let request = createRequest(url: url, method: "POST", parameters: parameters.toParameters()) else {
+            latest.message = "Error getting Latest"
+            latest.error = "request_error"
+            latest.kind = "failed"
+            return latest
+        }
 
-        request.validate().responseDecodable(of: AppVersionDec.self) { response in
-            switch response.result {
-            case .success:
-                latest.statusCode = response.response?.statusCode ?? 0
-                if let url = response.value?.url {
-                    latest.url = url
-                }
-                if let checksum = response.value?.checksum {
-                    latest.checksum = checksum
-                }
-                if let version = response.value?.version {
-                    latest.version = version
-                }
-                if let major = response.value?.major {
-                    latest.major = major
-                }
-                if let breaking = response.value?.breaking {
-                    latest.breaking = breaking
-                }
-                if let error = response.value?.error {
-                    latest.error = error
-                }
-                if let message = response.value?.message {
-                    latest.message = message
-                }
-                if let sessionKey = response.value?.session_key {
-                    latest.sessionKey = sessionKey
-                }
-                if let data = response.value?.data {
-                    latest.data = data
-                }
-                if let manifest = response.value?.manifest {
-                    latest.manifest = manifest
-                }
-                if let link = response.value?.link {
-                    latest.link = link
-                }
-                if let comment = response.value?.comment {
-                    latest.comment = comment
-                }
-            case let .failure(error):
-                self.logger.error("Error getting latest version")
-                self.logger.debug("Response: \(response.value.debugDescription), Error: \(error)")
-                latest.message = "Error getting Latest"
-                latest.error = "response_error"
-                latest.statusCode = response.response?.statusCode ?? 0
+        let result = performRequest(request, label: "getLatest")
+        latest.statusCode = result.response?.statusCode ?? 0
+
+        if result.timedOut {
+            latest.message = "Error getting Latest"
+            latest.error = "timeout_error"
+            latest.kind = "failed"
+            return latest
+        }
+
+        if let error = result.error {
+            self.logger.error("Error getting latest version")
+            self.logger.debug("Error: \(error.localizedDescription)")
+            latest.message = "Error getting Latest"
+            latest.error = "response_error"
+            latest.kind = "failed"
+            return latest
+        }
+
+        guard let data = result.data else {
+            self.logger.error("Missing latest version response data")
+            latest.message = "Error getting Latest"
+            latest.error = "response_error"
+            latest.kind = "failed"
+            return latest
+        }
+
+        if self.checkAndHandleRateLimitResponse(statusCode: latest.statusCode) {
+            latest.message = "Rate limit exceeded"
+            latest.error = "rate_limit_exceeded"
+            latest.kind = "failed"
+            return latest
+        }
+
+        guard let responseValue = try? JSONDecoder().decode(AppVersionDec.self, from: data) else {
+            self.logger.error("Error decoding latest version")
+            latest.message = "Error getting Latest"
+            latest.error = "decode_error"
+            latest.kind = "failed"
+            return latest
+        }
+
+        applyLatestResponse(responseValue)
+
+        if latest.statusCode < 200 || latest.statusCode >= 300 {
+            if latest.message == nil || latest.message?.isEmpty == true {
+                latest.message = responseValue.message ?? "Server error: \(latest.statusCode)"
             }
-            semaphore.signal()
+            if latest.error == nil || latest.error?.isEmpty == true {
+                latest.error = responseValue.error ?? "response_error"
+            }
+            if latest.kind == nil || latest.kind?.isEmpty == true {
+                latest.kind = responseValue.kind ?? "failed"
+            }
+            return latest
         }
-        semaphore.wait()
+
         return latest
     }
 
@@ -741,13 +1039,13 @@ import UIKit
                 userInfo: [NSLocalizedDescriptionKey: "Manifest download failed due to invalid or missing entries"]
             )
             // Update bundle status to ERROR if download failed
-            let errorBundle = bundleInfo.setStatus(status: BundleStatus.ERROR.localizedString)
+            let errorBundle = bundleInfo.setStatus(status: BundleStatus.ERROR.storedValue)
             self.saveBundleInfo(id: id, bundle: errorBundle)
             throw resolvedError
         }
 
         // Update bundle status to PENDING after successful download
-        let updatedBundle = bundleInfo.setStatus(status: BundleStatus.PENDING.localizedString)
+        let updatedBundle = bundleInfo.setStatus(status: BundleStatus.PENDING.storedValue)
         self.saveBundleInfo(id: id, bundle: updatedBundle)
 
         // Send stats for manifest download complete
@@ -772,85 +1070,105 @@ import UIKit
         version: String,
         bundleId: String
     ) throws {
-        let semaphore = DispatchSemaphore(value: 0)
-        var downloadError: Error?
-
-        self.alamofireSession.download(downloadUrl).responseData { response in
-            defer { semaphore.signal() }
+        guard let url = URL(string: downloadUrl) else {
+            throw NSError(
+                domain: "ManifestDownloadError",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid manifest download URL for file \(fileName): \(downloadUrl)"]
+            )
+        }
 
-            switch response.result {
-            case .success(let data):
-                do {
-                    let statusCode = response.response?.statusCode ?? 200
-                    if statusCode < 200 || statusCode >= 300 {
-                        self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
-                        if let stringData = String(data: data, encoding: .utf8) {
-                            throw NSError(domain: "StatusCodeError", code: statusCode, userInfo: [NSLocalizedDescriptionKey: "Failed to fetch. Status code (\(statusCode)) invalid. Data: \(stringData) for file \(fileName) at url \(downloadUrl)"])
-                        } else {
-                            throw NSError(domain: "StatusCodeError", code: statusCode, userInfo: [NSLocalizedDescriptionKey: "Failed to fetch. Status code (\(statusCode)) invalid for file \(fileName) at url \(downloadUrl)"])
-                        }
-                    }
+        guard let request = createRequest(url: url, method: "GET") else {
+            throw NSError(
+                domain: "ManifestDownloadError",
+                code: 2,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid manifest request for file \(fileName): \(downloadUrl)"]
+            )
+        }
 
-                    // Add decryption step if public key is set and sessionKey is provided
-                    var finalData = data
-                    if !self.publicKey.isEmpty && !sessionKey.isEmpty {
-                        let tempFile = self.cacheFolder.appendingPathComponent("temp_\(UUID().uuidString)")
-                        try finalData.write(to: tempFile)
-                        do {
-                            try CryptoCipher.decryptFile(filePath: tempFile, publicKey: self.publicKey, sessionKey: sessionKey, version: version)
-                        } catch {
-                            self.sendStats(action: "decrypt_fail", versionName: version)
-                            throw error
-                        }
-                        finalData = try Data(contentsOf: tempFile)
-                        try FileManager.default.removeItem(at: tempFile)
-                    }
+        let result = performRequest(request, label: "downloadManifestFile \(fileName)")
 
-                    // Decompress Brotli if needed
-                    if isBrotli {
-                        guard let decompressedData = self.decompressBrotli(data: finalData, fileName: fileName) else {
-                            self.sendStats(action: "download_manifest_brotli_fail", versionName: "\(version):\(destFileName)")
-                            throw NSError(domain: "BrotliDecompressionError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to decompress Brotli data for file \(fileName) at url \(downloadUrl)"])
-                        }
-                        finalData = decompressedData
-                    }
+        if result.timedOut {
+            self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
+            throw NSError(
+                domain: NSURLErrorDomain,
+                code: NSURLErrorTimedOut,
+                userInfo: [NSLocalizedDescriptionKey: "Timed out downloading manifest file \(fileName) at url \(downloadUrl)"]
+            )
+        }
 
-                    // Write to destination
-                    try finalData.write(to: destFilePath)
-
-                    // Always verify checksum when file_hash is present
-                    let calculatedChecksum = CryptoCipher.calcChecksum(filePath: destFilePath)
-                    CryptoCipher.logChecksumInfo(label: "Calculated checksum", hexChecksum: calculatedChecksum)
-                    CryptoCipher.logChecksumInfo(label: "Expected checksum", hexChecksum: fileHash)
-                    if calculatedChecksum != fileHash {
-                        try? FileManager.default.removeItem(at: destFilePath)
-                        self.sendStats(action: "download_manifest_checksum_fail", versionName: "\(version):\(destFileName)")
-                        throw NSError(domain: "ChecksumError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Computed checksum is not equal to required checksum (\(calculatedChecksum) != \(fileHash)) for file \(fileName) at url \(downloadUrl)"])
-                    }
+        if let error = result.error {
+            self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
+            self.logger.error("Manifest file download network error")
+            self.logger.debug("Bundle: \(bundleId), File: \(fileName), Error: \(error.localizedDescription)")
+            throw error
+        }
 
-                    // Save to cache
-                    try finalData.write(to: cacheFilePath)
+        guard let data = result.data else {
+            self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
+            throw NSError(
+                domain: "ManifestDownloadError",
+                code: 3,
+                userInfo: [NSLocalizedDescriptionKey: "Manifest file response was empty for \(fileName) at url \(downloadUrl)"]
+            )
+        }
 
-                    self.logger.info("Manifest file downloaded and cached")
-                    self.logger.debug("Bundle: \(bundleId), File: \(fileName), Brotli: \(isBrotli), Encrypted: \(!self.publicKey.isEmpty && !sessionKey.isEmpty)")
+        let statusCode = result.response?.statusCode ?? 200
+        if statusCode < 200 || statusCode >= 300 {
+            self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
+            if let stringData = String(data: data, encoding: .utf8) {
+                throw NSError(domain: "StatusCodeError", code: statusCode, userInfo: [NSLocalizedDescriptionKey: "Failed to fetch. Status code (\(statusCode)) invalid. Data: \(stringData) for file \(fileName) at url \(downloadUrl)"])
+            } else {
+                throw NSError(domain: "StatusCodeError", code: statusCode, userInfo: [NSLocalizedDescriptionKey: "Failed to fetch. Status code (\(statusCode)) invalid for file \(fileName) at url \(downloadUrl)"])
+            }
+        }
 
+        do {
+            // Add decryption step if public key is set and sessionKey is provided
+            var finalData = data
+            if !self.publicKey.isEmpty && !sessionKey.isEmpty {
+                let tempFile = self.cacheFolder.appendingPathComponent("temp_\(UUID().uuidString)")
+                try finalData.write(to: tempFile)
+                do {
+                    try CryptoCipher.decryptFile(filePath: tempFile, publicKey: self.publicKey, sessionKey: sessionKey, version: version)
                 } catch {
-                    downloadError = error
-                    self.logger.error("Manifest file download failed")
-                    self.logger.debug("Bundle: \(bundleId), File: \(fileName), Error: \(error.localizedDescription)")
+                    self.sendStats(action: "decrypt_fail", versionName: version)
+                    throw error
                 }
+                finalData = try Data(contentsOf: tempFile)
+                try FileManager.default.removeItem(at: tempFile)
+            }
 
-            case .failure(let error):
-                downloadError = error
-                self.sendStats(action: "download_manifest_file_fail", versionName: "\(version):\(fileName)")
-                self.logger.error("Manifest file download network error")
-                self.logger.debug("Bundle: \(bundleId), File: \(fileName), Error: \(error.localizedDescription), Response: \(response.debugDescription)")
+            // Decompress Brotli if needed
+            if isBrotli {
+                guard let decompressedData = self.decompressBrotli(data: finalData, fileName: fileName) else {
+                    self.sendStats(action: "download_manifest_brotli_fail", versionName: "\(version):\(destFileName)")
+                    throw NSError(domain: "BrotliDecompressionError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to decompress Brotli data for file \(fileName) at url \(downloadUrl)"])
+                }
+                finalData = decompressedData
             }
-        }
 
-        semaphore.wait()
+            // Write to destination
+            try finalData.write(to: destFilePath)
+
+            // Always verify checksum when file_hash is present
+            let calculatedChecksum = CryptoCipher.calcChecksum(filePath: destFilePath)
+            CryptoCipher.logChecksumInfo(label: "Calculated checksum", hexChecksum: calculatedChecksum)
+            CryptoCipher.logChecksumInfo(label: "Expected checksum", hexChecksum: fileHash)
+            if calculatedChecksum != fileHash {
+                try? FileManager.default.removeItem(at: destFilePath)
+                self.sendStats(action: "download_manifest_checksum_fail", versionName: "\(version):\(destFileName)")
+                throw NSError(domain: "ChecksumError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Computed checksum is not equal to required checksum (\(calculatedChecksum) != \(fileHash)) for file \(fileName) at url \(downloadUrl)"])
+            }
+
+            // Save to cache
+            try finalData.write(to: cacheFilePath)
 
-        if let error = downloadError {
+            self.logger.info("Manifest file downloaded and cached")
+            self.logger.debug("Bundle: \(bundleId), File: \(fileName), Brotli: \(isBrotli), Encrypted: \(!self.publicKey.isEmpty && !sessionKey.isEmpty)")
+        } catch {
+            self.logger.error("Manifest file download failed")
+            self.logger.debug("Bundle: \(bundleId), File: \(fileName), Error: \(error.localizedDescription)")
             throw error
         }
     }
@@ -999,7 +1317,6 @@ import UIKit
 
     public func download(url: URL, version: String, sessionKey: String, link: String? = nil, comment: String? = nil) throws -> BundleInfo {
         let id: String = self.randomString(length: 10)
-        let semaphore = DispatchSemaphore(value: 0)
         // Each download uses its own temp files keyed by bundle ID to prevent collisions
         if version != getLocalUpdateVersion(for: id) {
             cleanDownloadData(for: id)
@@ -1011,10 +1328,11 @@ import UIKit
         try checkDiskSpace()
 
         var checksum = ""
-        var targetSize = -1
         var lastSentProgress = 0
-        var totalReceivedBytes: Int64 = loadDownloadProgress(for: id) // Retrieving the amount of already downloaded data if exist, defined at 0 otherwise
-        let requestHeaders: HTTPHeaders = ["Range": "bytes=\(totalReceivedBytes)-"]
+        let totalReceivedBytes: Int64 = loadDownloadProgress(for: id) // Retrieving the amount of already downloaded data if exist, defined at 0 otherwise
+        let tempPath = tempDataPath(for: id)
+        let bundleInfo = BundleInfo(id: id, version: version, status: BundleStatus.DOWNLOADING, downloaded: Date(), checksum: checksum, link: link, comment: comment)
+        self.saveBundleInfo(id: id, bundle: bundleInfo)
 
         // Send stats for zip download start
         self.sendStats(action: "download_zip_start", versionName: version)
@@ -1024,66 +1342,61 @@ import UIKit
             self.notifyDownload(id: id, percent: 0, ignoreMultipleOfTen: true)
         }
         var mainError: NSError?
-        let monitor = ClosureEventMonitor()
-        monitor.requestDidCompleteTaskWithError = { (_, _, error) in
-            if error != nil {
-                self.logger.error("Downloading failed - ClosureEventMonitor activated")
-                mainError = error as NSError?
-            }
-        }
-        let configuration = URLSessionConfiguration.default
-        configuration.httpAdditionalHeaders = ["User-Agent": self.userAgent]
-        let session = Session(configuration: configuration, eventMonitors: [monitor])
 
-        let request = session.streamRequest(url, headers: requestHeaders).validate().onHTTPResponse(perform: { response  in
-            if let contentLength = response.headers.value(for: "Content-Length") {
-                targetSize = (Int(contentLength) ?? -1) + Int(totalReceivedBytes)
-            }
-        }).responseStream { [weak self] streamResponse in
-            guard let self = self else { return }
-            switch streamResponse.event {
-            case .stream(let result):
-                if case .success(let data) = result {
-                    self.tempData.append(data)
+        guard var request = createRequest(url: url, method: "GET") else {
+            self.saveBundleInfo(id: id, bundle: BundleInfo(id: id, version: version, status: BundleStatus.ERROR, downloaded: Date(), checksum: checksum, link: link, comment: comment))
+            throw NSError(
+                domain: "DownloadError",
+                code: 2,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid download request for \(url.absoluteString)"]
+            )
+        }
 
-                    self.savePartialData(startingAt: UInt64(totalReceivedBytes), for: id) // Saving the received data in the package_<id>.tmp file
-                    totalReceivedBytes += Int64(data.count)
+        if totalReceivedBytes > 0 {
+            request.setValue("bytes=\(totalReceivedBytes)-", forHTTPHeaderField: "Range")
+        }
 
-                    let percent = max(10, Int((Double(totalReceivedBytes) / Double(targetSize)) * 70.0))
+        let downloadResult = performDownloadRequest(request, label: "download \(version)")
 
-                    let currentMilestone = (percent / 10) * 10
-                    if currentMilestone > lastSentProgress && currentMilestone <= 70 {
-                        for milestone in stride(from: lastSentProgress + 10, through: currentMilestone, by: 10) {
-                            self.notifyDownload(id: id, percent: milestone, ignoreMultipleOfTen: false)
-                        }
-                        lastSentProgress = currentMilestone
-                    }
+        if downloadResult.timedOut {
+            persistPartialDownload(downloadResult, id: id, tempPath: tempPath, existingBytes: totalReceivedBytes)
+            mainError = NSError(
+                domain: NSURLErrorDomain,
+                code: NSURLErrorTimedOut,
+                userInfo: [NSLocalizedDescriptionKey: "Timed out downloading bundle from \(url.absoluteString)"]
+            )
+        } else if let error = downloadResult.error {
+            logger.error("Download failed")
+            persistPartialDownload(downloadResult, id: id, tempPath: tempPath, existingBytes: totalReceivedBytes)
+            mainError = error as NSError
+        } else if let statusCode = downloadResult.response?.statusCode, statusCode < 200 || statusCode >= 300 {
+            logger.error("Download failed")
+            mainError = NSError(
+                domain: "DownloadError",
+                code: statusCode,
+                userInfo: [NSLocalizedDescriptionKey: "Download request failed with status code \(statusCode)"]
+            )
+        } else if let downloadedFileURL = downloadResult.fileURL {
+            do {
+                try storeDownloadedFile(downloadedFileURL, at: tempPath, existingBytes: totalReceivedBytes, response: downloadResult.response)
 
-                } else {
-                    self.logger.error("Download failed")
+                if lastSentProgress < 70 {
+                    self.notifyDownload(id: id, percent: 70, ignoreMultipleOfTen: true)
+                    lastSentProgress = 70
                 }
-
-            case .complete:
-                self.logger.info("Download complete, total received bytes: \(totalReceivedBytes)")
-                self.notifyDownload(id: id, percent: 70, ignoreMultipleOfTen: true)
-                semaphore.signal()
-            }
-        }
-        self.saveBundleInfo(id: id, bundle: BundleInfo(id: id, version: version, status: BundleStatus.DOWNLOADING, downloaded: Date(), checksum: checksum, link: link, comment: comment))
-        let reachabilityManager = NetworkReachabilityManager()
-        reachabilityManager?.startListening { status in
-            switch status {
-            case .notReachable:
-                // Stop the download request if the network is not reachable
-                request.cancel()
-                mainError = NSError(domain: NSURLErrorDomain, code: NSURLErrorNotConnectedToInternet, userInfo: nil)
-                semaphore.signal()
-            default:
-                break
+                self.logger.info("Download complete")
+            } catch let error as NSError {
+                mainError = error
+            } catch {
+                mainError = error as NSError
             }
+        } else {
+            mainError = NSError(
+                domain: "DownloadError",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Downloaded file is missing at \(tempPath.path)"]
+            )
         }
-        semaphore.wait()
-        reachabilityManager?.stopListening()
 
         if mainError != nil {
             logger.error("Failed to download bundle")
@@ -1092,7 +1405,6 @@ import UIKit
             throw mainError!
         }
 
-        let tempPath = tempDataPath(for: id)
         let finalPath = tempPath.deletingLastPathComponent().appendingPathComponent("\(id)")
         do {
             try CryptoCipher.decryptFile(filePath: tempPath, publicKey: self.publicKey, sessionKey: sessionKey, version: version)
@@ -1313,7 +1625,7 @@ import UIKit
         if removeInfo {
             self.removeBundleInfo(id: id)
         } else {
-            self.saveBundleInfo(id: id, bundle: deleted.setStatus(status: BundleStatus.DELETED.localizedString))
+            self.saveBundleInfo(id: id, bundle: deleted.setStatus(status: BundleStatus.DELETED.storedValue))
         }
         logger.info("Bundle deleted successfully")
         logger.debug("Version: \(deleted.getVersionName())")
@@ -1668,54 +1980,74 @@ import UIKit
             setChannel.error = "missing_config"
             return setChannel
         }
-        let semaphore: DispatchSemaphore = DispatchSemaphore(value: 0)
+        guard let channelURL = URL(string: self.channelUrl) else {
+            logger.error("Invalid channel URL")
+            setChannel.message = "Channel URL is invalid"
+            setChannel.error = "invalid_config"
+            return setChannel
+        }
         var parameters: InfoObject = self.createInfoObject()
         parameters.channel = channel
+        guard let request = createRequest(url: channelURL, method: "POST", parameters: parameters.toParameters()) else {
+            setChannel.error = "Request failed: invalid request"
+            return setChannel
+        }
 
-        let request = alamofireSession.request(self.channelUrl, method: .post, parameters: parameters, encoder: JSONParameterEncoder.default, requestModifier: { $0.timeoutInterval = self.timeout })
+        let result = performRequest(request, label: "setChannel")
 
-        request.validate().responseDecodable(of: SetChannelDec.self) { response in
-            // Check for 429 rate limit
-            if self.checkAndHandleRateLimitResponse(statusCode: response.response?.statusCode) {
-                setChannel.message = "Rate limit exceeded"
-                setChannel.error = "rate_limit_exceeded"
-                semaphore.signal()
-                return
-            }
+        if self.checkAndHandleRateLimitResponse(statusCode: result.response?.statusCode) {
+            setChannel.message = "Rate limit exceeded"
+            setChannel.error = "rate_limit_exceeded"
+            return setChannel
+        }
 
-            switch response.result {
-            case .success:
-                if let responseValue = response.value {
-                    if let error = responseValue.error {
-                        setChannel.error = error
-                    } else if responseValue.unset == true {
-                        // Server requested to unset channel (public channel was requested)
-                        // Clear persisted defaultChannel and revert to config value
-                        UserDefaults.standard.removeObject(forKey: defaultChannelKey)
-                        UserDefaults.standard.synchronize()
-                        self.logger.info("Public channel requested, channel override removed")
-
-                        setChannel.status = responseValue.status ?? "ok"
-                        setChannel.message = responseValue.message ?? "Public channel requested, channel override removed. Device will use public channel automatically."
-                    } else {
-                        // Success - persist defaultChannel
-                        self.defaultChannel = channel
-                        UserDefaults.standard.set(channel, forKey: defaultChannelKey)
-                        UserDefaults.standard.synchronize()
-                        self.logger.info("defaultChannel persisted locally: \(channel)")
-
-                        setChannel.status = responseValue.status ?? ""
-                        setChannel.message = responseValue.message ?? ""
-                    }
-                }
-            case let .failure(error):
-                self.logger.error("Error setting channel")
-                self.logger.debug("Error: \(error)")
-                setChannel.error = "Request failed: \(error.localizedDescription)"
-            }
-            semaphore.signal()
+        if result.timedOut {
+            setChannel.error = "Request timed out"
+            return setChannel
+        }
+
+        if let error = result.error {
+            self.logger.error("Error setting channel")
+            self.logger.debug("Error: \(error.localizedDescription)")
+            setChannel.error = "Request failed: \(error.localizedDescription)"
+            return setChannel
+        }
+
+        guard let data = result.data else {
+            setChannel.error = "Request failed: empty response"
+            return setChannel
+        }
+
+        guard let responseValue = try? JSONDecoder().decode(SetChannelDec.self, from: data) else {
+            setChannel.error = "decode_error"
+            return setChannel
+        }
+
+        let statusCode = result.response?.statusCode ?? 0
+        if statusCode < 200 || statusCode >= 300 {
+            setChannel.message = responseValue.message ?? "Server error: \(statusCode)"
+            setChannel.error = responseValue.error ?? "response_error"
+            return setChannel
+        }
+
+        if let error = responseValue.error {
+            setChannel.error = error
+        } else if responseValue.unset == true {
+            UserDefaults.standard.removeObject(forKey: defaultChannelKey)
+            UserDefaults.standard.synchronize()
+            self.logger.info("Public channel requested, channel override removed")
+
+            setChannel.status = responseValue.status ?? "ok"
+            setChannel.message = responseValue.message ?? "Public channel requested, channel override removed. Device will use public channel automatically."
+        } else {
+            self.defaultChannel = channel
+            UserDefaults.standard.set(channel, forKey: defaultChannelKey)
+            UserDefaults.standard.synchronize()
+            self.logger.info("defaultChannel persisted locally: \(channel)")
+
+            setChannel.status = responseValue.status ?? ""
+            setChannel.message = responseValue.message ?? ""
         }
-        semaphore.wait()
         return setChannel
     }
 
@@ -1736,49 +2068,77 @@ import UIKit
             getChannel.error = "missing_config"
             return getChannel
         }
-        let semaphore: DispatchSemaphore = DispatchSemaphore(value: 0)
+        guard let channelURL = URL(string: self.channelUrl) else {
+            logger.error("Invalid channel URL")
+            getChannel.message = "Channel URL is invalid"
+            getChannel.error = "invalid_config"
+            return getChannel
+        }
         let parameters: InfoObject = self.createInfoObject()
-        let request = alamofireSession.request(self.channelUrl, method: .put, parameters: parameters, encoder: JSONParameterEncoder.default, requestModifier: { $0.timeoutInterval = self.timeout })
+        guard let request = createRequest(url: channelURL, method: "PUT", parameters: parameters.toParameters()) else {
+            getChannel.error = "Request failed: invalid request"
+            return getChannel
+        }
 
-        request.validate().responseDecodable(of: GetChannelDec.self) { response in
-            defer {
-                semaphore.signal()
-            }
+        let result = performRequest(request, label: "getChannel")
 
-            // Check for 429 rate limit
-            if self.checkAndHandleRateLimitResponse(statusCode: response.response?.statusCode) {
-                getChannel.message = "Rate limit exceeded"
-                getChannel.error = "rate_limit_exceeded"
-                return
-            }
+        if self.checkAndHandleRateLimitResponse(statusCode: result.response?.statusCode) {
+            getChannel.message = "Rate limit exceeded"
+            getChannel.error = "rate_limit_exceeded"
+            return getChannel
+        }
 
-            switch response.result {
-            case .success:
-                if let responseValue = response.value {
-                    if let error = responseValue.error {
-                        getChannel.error = error
-                    } else {
-                        getChannel.status = responseValue.status ?? ""
-                        getChannel.message = responseValue.message ?? ""
-                        getChannel.channel = responseValue.channel ?? ""
-                        getChannel.allowSet = responseValue.allowSet ?? true
-                    }
-                }
-            case let .failure(error):
-                if let data = response.data, let bodyString = String(data: data, encoding: .utf8) {
-                    if bodyString.contains("channel_not_found") && response.response?.statusCode == 400 && !self.defaultChannel.isEmpty {
-                        getChannel.channel = self.defaultChannel
-                        getChannel.status = "default"
-                        return
-                    }
+        if result.timedOut {
+            getChannel.error = "Request timed out"
+            return getChannel
+        }
+
+        if let error = result.error {
+            if let data = result.data, let bodyString = String(data: data, encoding: .utf8) {
+                if bodyString.contains("channel_not_found") && result.response?.statusCode == 400 && !self.defaultChannel.isEmpty {
+                    getChannel.channel = self.defaultChannel
+                    getChannel.status = "default"
+                    return getChannel
                 }
+            }
 
-                self.logger.error("Error getting channel")
-                self.logger.debug("Error: \(error)")
-                getChannel.error = "Request failed: \(error.localizedDescription)"
+            self.logger.error("Error getting channel")
+            self.logger.debug("Error: \(error.localizedDescription)")
+            getChannel.error = "Request failed: \(error.localizedDescription)"
+            return getChannel
+        }
+
+        guard let data = result.data else {
+            getChannel.error = "Request failed: empty response"
+            return getChannel
+        }
+
+        guard let responseValue = try? JSONDecoder().decode(GetChannelDec.self, from: data) else {
+            getChannel.error = "decode_error"
+            return getChannel
+        }
+
+        let statusCode = result.response?.statusCode ?? 0
+        if let error = responseValue.error {
+            if error == "channel_not_found", statusCode == 400, !self.defaultChannel.isEmpty {
+                getChannel.channel = self.defaultChannel
+                getChannel.status = "default"
+                return getChannel
             }
+            getChannel.error = error
+            getChannel.message = responseValue.message ?? ""
+            return getChannel
+        }
+
+        if statusCode < 200 || statusCode >= 300 {
+            getChannel.message = responseValue.message ?? "Server error: \(statusCode)"
+            getChannel.error = "response_error"
+        } else {
+            getChannel.status = responseValue.status ?? ""
+            getChannel.message = responseValue.message ?? ""
+            getChannel.channel = responseValue.channel ?? ""
+            getChannel.allowSet = responseValue.allowSet ?? true
         }
-        semaphore.wait()
         return getChannel
     }
 
@@ -1798,14 +2158,12 @@ import UIKit
             return listChannels
         }
 
-        let semaphore: DispatchSemaphore = DispatchSemaphore(value: 0)
-
         // Create info object and convert to query parameters
         let infoObject = self.createInfoObject()
 
         // Create query parameters from InfoObject
         var urlComponents = URLComponents(string: self.channelUrl)
-        var queryItems: [URLQueryItem] = []
+        var queryItems: [URLQueryItem] = urlComponents?.queryItems ?? []
 
         // Convert InfoObject to dictionary using Mirror
         let mirror = Mirror(reflecting: infoObject)
@@ -1829,47 +2187,62 @@ import UIKit
             return listChannels
         }
 
-        let request = alamofireSession.request(url, method: .get, requestModifier: { $0.timeoutInterval = self.timeout })
+        guard let request = createRequest(url: url, method: "GET", expectsJSONResponse: true) else {
+            listChannels.error = "Invalid channel URL"
+            return listChannels
+        }
 
-        request.validate().responseDecodable(of: ListChannelsDec.self) { response in
-            defer {
-                semaphore.signal()
-            }
+        let result = performRequest(request, label: "listChannels")
 
-            // Check for 429 rate limit
-            if self.checkAndHandleRateLimitResponse(statusCode: response.response?.statusCode) {
-                listChannels.error = "rate_limit_exceeded"
-                return
-            }
+        if self.checkAndHandleRateLimitResponse(statusCode: result.response?.statusCode) {
+            listChannels.error = "rate_limit_exceeded"
+            return listChannels
+        }
 
-            switch response.result {
-            case .success:
-                if let responseValue = response.value {
-                    // Check for server-side errors
-                    if let error = responseValue.error {
-                        listChannels.error = error
-                        return
-                    }
+        if result.timedOut {
+            listChannels.error = "Request timed out"
+            return listChannels
+        }
 
-                    // Backend returns direct array, so channels should be populated by our custom decoder
-                    if let channels = responseValue.channels {
-                        listChannels.channels = channels.map { channel in
-                            var channelDict: [String: Any] = [:]
-                            channelDict["id"] = channel.id ?? ""
-                            channelDict["name"] = channel.name ?? ""
-                            channelDict["public"] = channel.public ?? false
-                            channelDict["allow_self_set"] = channel.allow_self_set ?? false
-                            return channelDict
-                        }
-                    }
-                }
-            case let .failure(error):
-                self.logger.error("Error listing channels")
-                self.logger.debug("Error: \(error)")
-                listChannels.error = "Request failed: \(error.localizedDescription)"
+        if let error = result.error {
+            self.logger.error("Error listing channels")
+            self.logger.debug("Error: \(error.localizedDescription)")
+            listChannels.error = "Request failed: \(error.localizedDescription)"
+            return listChannels
+        }
+
+        guard let data = result.data else {
+            listChannels.error = "Request failed: empty response"
+            return listChannels
+        }
+
+        guard let responseValue = try? JSONDecoder().decode(ListChannelsDec.self, from: data) else {
+            listChannels.error = "decode_error"
+            return listChannels
+        }
+
+        let statusCode = result.response?.statusCode ?? 0
+        if let error = responseValue.error {
+            listChannels.error = error
+            return listChannels
+        }
+
+        if statusCode < 200 || statusCode >= 300 {
+            listChannels.error = "response_error"
+            return listChannels
+        }
+
+        if let channels = responseValue.channels {
+            listChannels.channels = channels.map { channel in
+                var channelDict: [String: Any] = [:]
+                channelDict["id"] = channel.id ?? ""
+                channelDict["name"] = channel.name ?? ""
+                channelDict["public"] = channel.public ?? false
+                channelDict["allow_self_set"] = channel.allow_self_set ?? false
+                return channelDict
             }
         }
-        semaphore.wait()
+
         return listChannels
     }
 
@@ -2034,13 +2407,12 @@ import UIKit
                 logger.debug("Bundle ID: \(id), Error: \(error.localizedDescription)")
             }
         }
-        UserDefaults.standard.synchronize()
     }
 
     private func setBundleStatus(id: String, status: BundleStatus) {
         logger.info("Setting status for bundle [\(id)] to \(status)")
         let info = self.getBundleInfo(id: id)
-        self.saveBundleInfo(id: id, bundle: info.setStatus(status: status.localizedString))
+        self.saveBundleInfo(id: id, bundle: info.setStatus(status: status.storedValue))
     }
 
     public func getCurrentBundle() -> BundleInfo {