@hot-updater/react-native 1.0.0-rc.2 → 1.0.0-rc.22

package/ios/HotUpdater/Internal/ArchiveExtractionUtilities.swift

@@ -1,178 +0,0 @@
-import Foundation
-
-enum ArchiveExtractionUtilities {
-    static let bufferSize = 64 * 1024
-
-    static func readUpToCount(from handle: FileHandle, count: Int) throws -> Data? {
-        guard count >= 0 else {
-            throw NSError(
-                domain: "ArchiveExtractionUtilities",
-                code: 5,
-                userInfo: [NSLocalizedDescriptionKey: "Invalid read size: \(count)"]
-            )
-        }
-
-        if count == 0 {
-            return Data()
-        }
-
-        if #available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *) {
-            return try handle.read(upToCount: count)
-        }
-
-        return handle.readData(ofLength: count)
-    }
-
-    static func readExactly(from handle: FileHandle, count: Int) throws -> Data {
-        guard count >= 0 else {
-            throw NSError(
-                domain: "ArchiveExtractionUtilities",
-                code: 1,
-                userInfo: [NSLocalizedDescriptionKey: "Invalid read size: \(count)"]
-            )
-        }
-
-        if count == 0 {
-            return Data()
-        }
-
-        guard let data = try readUpToCount(from: handle, count: count), data.count == count else {
-            throw NSError(
-                domain: "ArchiveExtractionUtilities",
-                code: 2,
-                userInfo: [NSLocalizedDescriptionKey: "Unexpected end of archive while reading \(count) bytes"]
-            )
-        }
-
-        return data
-    }
-
-    static func currentOffset(for handle: FileHandle) -> UInt64 {
-        if #available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *) {
-            return (try? handle.offset()) ?? 0
-        }
-
-        return handle.offsetInFile
-    }
-
-    static func seek(_ handle: FileHandle, to offset: UInt64) throws {
-        if #available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *) {
-            try handle.seek(toOffset: offset)
-            return
-        }
-
-        handle.seek(toFileOffset: offset)
-    }
-
-    static func skipBytes(_ byteCount: UInt64, in handle: FileHandle) throws {
-        guard byteCount > 0 else {
-            return
-        }
-
-        let offset = currentOffset(for: handle)
-        let (targetOffset, overflowed) = offset.addingReportingOverflow(byteCount)
-
-        guard !overflowed else {
-            throw NSError(
-                domain: "ArchiveExtractionUtilities",
-                code: 6,
-                userInfo: [NSLocalizedDescriptionKey: "Archive offset overflow while skipping \(byteCount) bytes from offset \(offset)"]
-            )
-        }
-
-        try seek(handle, to: targetOffset)
-    }
-
-    static func normalizedRelativePath(from rawPath: String) -> String? {
-        let candidate = rawPath.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !candidate.isEmpty,
-              !candidate.contains("\0"),
-              !candidate.contains("\\"),
-              !candidate.hasPrefix("/"),
-              candidate.range(of: #"^[A-Za-z]:"#, options: .regularExpression) == nil
-        else {
-            return nil
-        }
-
-        let components = candidate
-            .split(separator: "/")
-            .map(String.init)
-
-        guard !components.isEmpty else {
-            return nil
-        }
-
-        guard components.count == candidate.split(separator: "/", omittingEmptySubsequences: false).count,
-              !components.contains(".."),
-              !components.contains(".") else {
-            return nil
-        }
-
-        return components.joined(separator: "/")
-    }
-
-    static func extractionURL(for relativePath: String, destinationRoot: String) throws -> URL {
-        let rootURL = URL(fileURLWithPath: destinationRoot, isDirectory: true)
-        let targetURL = rootURL.appendingPathComponent(relativePath)
-        let standardizedRoot = rootURL.standardizedFileURL.path
-        let standardizedTarget = targetURL.standardizedFileURL.path
-
-        guard standardizedTarget == standardizedRoot ||
-                standardizedTarget.hasPrefix(standardizedRoot + "/") else {
-            throw NSError(
-                domain: "ArchiveExtractionUtilities",
-                code: 3,
-                userInfo: [NSLocalizedDescriptionKey: "Path traversal attempt detected: \(relativePath)"]
-            )
-        }
-
-        return targetURL
-    }
-
-    static func ensureDirectory(at url: URL, fileManager: FileManager = .default) throws {
-        var isDirectory = ObjCBool(false)
-        if fileManager.fileExists(atPath: url.path, isDirectory: &isDirectory) {
-            if isDirectory.boolValue {
-                return
-            }
-
-            try fileManager.removeItem(at: url)
-        }
-
-        try fileManager.createDirectory(at: url, withIntermediateDirectories: true, attributes: nil)
-    }
-
-    static func createOutputFile(at url: URL, fileManager: FileManager = .default) throws -> FileHandle {
-        try ensureDirectory(at: url.deletingLastPathComponent(), fileManager: fileManager)
-
-        if fileManager.fileExists(atPath: url.path) {
-            try fileManager.removeItem(at: url)
-        }
-
-        guard fileManager.createFile(atPath: url.path, contents: nil) else {
-            throw NSError(
-                domain: "ArchiveExtractionUtilities",
-                code: 4,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to create output file at \(url.path)"]
-            )
-        }
-
-        return try FileHandle(forWritingTo: url)
-    }
-}
-
-extension Data {
-    func archiveUInt16LE(at offset: Int) -> UInt16 {
-        let byte0 = UInt16(self[offset])
-        let byte1 = UInt16(self[offset + 1]) << 8
-        return byte0 | byte1
-    }
-
-    func archiveUInt32LE(at offset: Int) -> UInt32 {
-        let byte0 = UInt32(self[offset])
-        let byte1 = UInt32(self[offset + 1]) << 8
-        let byte2 = UInt32(self[offset + 2]) << 16
-        let byte3 = UInt32(self[offset + 3]) << 24
-        return byte0 | byte1 | byte2 | byte3
-    }
-}

package/ios/HotUpdater/Internal/DecompressService.swift

@@ -1,112 +0,0 @@
-import Foundation
-
-/**
- * Unified decompression service that uses Strategy pattern to handle multiple compression formats.
- * Automatically detects format by trying each strategy's validation and delegates to appropriate decompression strategy.
- */
-class DecompressService {
-    /// Strategies with reliable file signatures that can be validated cheaply.
-    private let signatureStrategies: [DecompressionStrategy]
-    /// TAR.BR has no reliable magic bytes, so it is attempted as the final fallback.
-    private let tarBrStrategy: DecompressionStrategy
-
-    init() {
-        // Order matters: Try ZIP first (clear magic bytes), then TAR.GZ (GZIP magic bytes).
-        // TAR.BR is attempted only after signature-based formats are ruled out.
-        self.signatureStrategies = [
-            ZipDecompressionStrategy(),
-            TarGzDecompressionStrategy()
-        ]
-        self.tarBrStrategy = TarBrDecompressionStrategy()
-    }
-
-    /**
-     * Extracts a compressed file to the destination directory.
-     * Automatically detects compression format by trying each strategy's validation.
-     * @param file Path to the compressed file
-     * @param destination Path to the destination directory
-     * @param progressHandler Callback for progress updates (0.0 - 1.0)
-     * @throws Error if decompression fails or no valid strategy found
-     */
-    func unzip(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
-        // Collect file information for better error messages
-        let fileURL = URL(fileURLWithPath: file)
-        let fileName = fileURL.lastPathComponent
-        let fileSize = (try? FileManager.default.attributesOfItem(atPath: file)[.size] as? UInt64) ?? 0
-
-        // Try each signature-based strategy first.
-        for strategy in signatureStrategies {
-            if strategy.isValid(file: file) {
-                NSLog("[DecompressService] Using strategy for \(fileName)")
-                try strategy.decompress(file: file, to: destination, progressHandler: progressHandler)
-                return
-            }
-        }
-
-        NSLog("[DecompressService] No ZIP/TAR.GZ signature matched for \(fileName), trying TAR.BR fallback")
-
-        do {
-            try tarBrStrategy.decompress(file: file, to: destination, progressHandler: progressHandler)
-            NSLog("[DecompressService] Using TAR.BR fallback for \(fileName)")
-            return
-        } catch {
-            let invalidArchiveError = createInvalidArchiveError(
-                fileName: fileName,
-                fileSize: fileSize,
-                underlyingError: error
-            )
-            NSLog("[DecompressService] \(invalidArchiveError.localizedDescription)")
-            throw invalidArchiveError
-        }
-    }
-
-    /**
-     * Extracts a compressed file to the destination directory (without progress tracking).
-     * @param file Path to the compressed file
-     * @param destination Path to the destination directory
-     * @throws Error if decompression fails or no valid strategy found
-     */
-    func unzip(file: String, to destination: String) throws {
-        try unzip(file: file, to: destination, progressHandler: { _ in })
-    }
-
-    /**
-     * Validates if a file matches one of the signature-based archive formats.
-     * @param file Path to the file to validate
-     * @return true if the file is valid for any strategy
-     */
-    func isValid(file: String) -> Bool {
-        for strategy in signatureStrategies {
-            if strategy.isValid(file: file) {
-                return true
-            }
-        }
-        NSLog("[DecompressService] No ZIP/TAR.GZ signature matched for file: \(file). TAR.BR is handled during extraction fallback.")
-        return false
-    }
-
-    private func createInvalidArchiveError(fileName: String, fileSize: UInt64, underlyingError: Error? = nil) -> NSError {
-        let errorMessage = """
-The downloaded bundle file is not a valid compressed archive: \(fileName) (\(fileSize) bytes)
-
-Supported formats:
-- ZIP archives (.zip)
-- GZIP compressed TAR archives (.tar.gz)
-- Brotli compressed TAR archives (.tar.br)
-"""
-
-        var userInfo: [String: Any] = [
-            NSLocalizedDescriptionKey: errorMessage
-        ]
-
-        if let underlyingError {
-            userInfo[NSUnderlyingErrorKey] = underlyingError
-        }
-
-        return NSError(
-            domain: "DecompressService",
-            code: 1,
-            userInfo: userInfo
-        )
-    }
-}

package/ios/HotUpdater/Internal/DecompressionStrategy.swift

@@ -1,22 +0,0 @@
-import Foundation
-
-/**
- * Protocol for decompression strategies
- */
-protocol DecompressionStrategy {
-    /**
-     * Validates if a file can be decompressed by this strategy
-     * @param file Path to the file to validate
-     * @return true if the file is valid for this strategy
-     */
-    func isValid(file: String) -> Bool
-
-    /**
-     * Decompresses a file to the destination directory
-     * @param file Path to the compressed file
-     * @param destination Path to the destination directory
-     * @param progressHandler Callback for progress updates (0.0 - 1.0)
-     * @throws Error if decompression fails
-     */
-    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws
-}

package/ios/HotUpdater/Internal/StreamingTarArchiveExtractor.swift

@@ -1,370 +0,0 @@
-import Compression
-import Foundation
-import zlib
-
-enum CompressedTarAlgorithm {
-    case gzip
-    case brotli
-}
-
-enum StreamingTarArchiveExtractor {
-    private static let bufferSize = 64 * 1024
-    private static let decompressionProgressWeight = 0.45
-
-    static func extractCompressedTar(
-        file: String,
-        to destination: String,
-        algorithm: CompressedTarAlgorithm,
-        progressHandler: @escaping (Double) -> Void
-    ) throws {
-        try withTemporaryTarFile { temporaryTarURL in
-            switch algorithm {
-            case .gzip:
-                try decompressGzipArchive(
-                    from: file,
-                    to: temporaryTarURL.path,
-                    progressHandler: { progress in
-                        progressHandler(progress * decompressionProgressWeight)
-                    }
-                )
-            case .brotli:
-                try decompressBrotliArchive(
-                    from: file,
-                    to: temporaryTarURL.path,
-                    progressHandler: { progress in
-                        progressHandler(progress * decompressionProgressWeight)
-                    }
-                )
-            }
-
-            try extractTarArchive(
-                from: temporaryTarURL.path,
-                to: destination,
-                progressHandler: { progress in
-                    let extractionStart = decompressionProgressWeight
-                    let extractionWeight = 1.0 - decompressionProgressWeight
-                    progressHandler(extractionStart + (progress * extractionWeight))
-                }
-            )
-        }
-    }
-
-    static func decompressBrotliFile(
-        from sourcePath: String,
-        to outputPath: String
-    ) throws {
-        try decompressBrotliArchive(
-            from: sourcePath,
-            to: outputPath,
-            progressHandler: { _ in }
-        )
-    }
-
-    static func containsTarEntries(file: String, algorithm: CompressedTarAlgorithm) -> Bool {
-        do {
-            return try withTemporaryTarFile { temporaryTarURL in
-                switch algorithm {
-                case .gzip:
-                    try decompressGzipArchive(
-                        from: file,
-                        to: temporaryTarURL.path,
-                        progressHandler: { _ in }
-                    )
-                case .brotli:
-                    try decompressBrotliArchive(
-                        from: file,
-                        to: temporaryTarURL.path,
-                        progressHandler: { _ in }
-                    )
-                }
-
-                return try tarArchiveHasEntries(at: temporaryTarURL.path)
-            }
-        } catch {
-            NSLog("[TarStreamExtractor] Validation failed: \(error.localizedDescription)")
-            return false
-        }
-    }
-
-    private static func withTemporaryTarFile<T>(
-        perform: (URL) throws -> T
-    ) throws -> T {
-        let temporaryTarURL = FileManager.default.temporaryDirectory
-            .appendingPathComponent("hot-updater-\(UUID().uuidString)")
-            .appendingPathExtension("tar")
-
-        defer {
-            try? FileManager.default.removeItem(at: temporaryTarURL)
-        }
-
-        return try perform(temporaryTarURL)
-    }
-
-    private static func tarArchiveHasEntries(at tarPath: String) throws -> Bool {
-        try TarArchiveExtractor.containsEntries(at: tarPath)
-    }
-
-    private static func extractTarArchive(
-        from tarPath: String,
-        to destination: String,
-        progressHandler: @escaping (Double) -> Void
-    ) throws {
-        try TarArchiveExtractor.extract(
-            from: tarPath,
-            to: destination,
-            progressHandler: progressHandler
-        )
-    }
-
-    private static func decompressGzipArchive(
-        from sourcePath: String,
-        to outputPath: String,
-        progressHandler: @escaping (Double) -> Void
-    ) throws {
-        let totalSourceSize = try fileSize(atPath: sourcePath)
-        try prepareEmptyFile(at: outputPath)
-
-        let outputHandle = try FileHandle(forWritingTo: URL(fileURLWithPath: outputPath))
-
-        defer {
-            try? outputHandle.close()
-        }
-
-        guard let gzipFile = sourcePath.withCString({ pathPointer in
-            "rb".withCString { modePointer in
-                gzopen(pathPointer, modePointer)
-            }
-        }) else {
-            throw NSError(
-                domain: "StreamingTarArchiveExtractor",
-                code: 5,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to open gzip archive"]
-            )
-        }
-
-        defer {
-            gzclose(gzipFile)
-        }
-
-        var buffer = [UInt8](repeating: 0, count: bufferSize)
-
-        while true {
-            let bytesRead = gzread(gzipFile, &buffer, UInt32(buffer.count))
-
-            if bytesRead > 0 {
-                outputHandle.write(Data(buffer[0..<Int(bytesRead)]))
-
-                if totalSourceSize > 0 {
-                    let compressedOffset = max(Int64(gzoffset(gzipFile)), 0)
-                    let progress = min(Double(compressedOffset) / Double(totalSourceSize), 1.0)
-                    progressHandler(progress)
-                }
-
-                continue
-            }
-
-            if bytesRead == 0 {
-                progressHandler(1.0)
-                return
-            }
-
-            var errorCode: Int32 = 0
-            let messagePointer = gzerror(gzipFile, &errorCode)
-            let message = messagePointer.map { String(cString: $0) } ?? "Unknown gzip error"
-
-            throw NSError(
-                domain: "StreamingTarArchiveExtractor",
-                code: Int(errorCode),
-                userInfo: [NSLocalizedDescriptionKey: "GZIP decompression failed: \(message)"]
-            )
-        }
-    }
-
-    private static func decompressBrotliArchive(
-        from sourcePath: String,
-        to outputPath: String,
-        progressHandler: @escaping (Double) -> Void
-    ) throws {
-        let totalSourceSize = try fileSize(atPath: sourcePath)
-        try prepareEmptyFile(at: outputPath)
-
-        let inputHandle = try FileHandle(forReadingFrom: URL(fileURLWithPath: sourcePath))
-        let outputHandle = try FileHandle(forWritingTo: URL(fileURLWithPath: outputPath))
-
-        defer {
-            try? inputHandle.close()
-            try? outputHandle.close()
-        }
-
-        var stream = compression_stream(
-            dst_ptr: UnsafeMutablePointer<UInt8>(bitPattern: 1)!,
-            dst_size: 0,
-            src_ptr: UnsafePointer<UInt8>(bitPattern: 1)!,
-            src_size: 0,
-            state: nil
-        )
-        let status = compression_stream_init(&stream, COMPRESSION_STREAM_DECODE, COMPRESSION_BROTLI)
-
-        guard status == COMPRESSION_STATUS_OK else {
-            throw NSError(
-                domain: "StreamingTarArchiveExtractor",
-                code: 6,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to initialize Brotli decompression stream"]
-            )
-        }
-
-        defer {
-            compression_stream_destroy(&stream)
-        }
-
-        let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
-
-        defer {
-            outputBuffer.deallocate()
-        }
-
-        var processedSourceBytes: UInt64 = 0
-        var reachedStreamEnd = false
-
-        while !reachedStreamEnd {
-            let chunk = try ArchiveExtractionUtilities.readUpToCount(
-                from: inputHandle,
-                count: bufferSize
-            ) ?? Data()
-            processedSourceBytes += UInt64(chunk.count)
-
-            let streamStatus: compression_status
-            if chunk.isEmpty {
-                stream.src_ptr = UnsafePointer<UInt8>(bitPattern: 1)!
-                stream.src_size = 0
-                streamStatus = try flushCompressionStream(
-                    &stream,
-                    into: outputHandle,
-                    outputBuffer: outputBuffer,
-                    finalize: true
-                )
-            } else {
-                streamStatus = try chunk.withUnsafeBytes { rawBuffer in
-                    guard let baseAddress = rawBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
-                        return COMPRESSION_STATUS_OK
-                    }
-
-                    stream.src_ptr = baseAddress
-                    stream.src_size = chunk.count
-
-                    return try flushCompressionStream(
-                        &stream,
-                        into: outputHandle,
-                        outputBuffer: outputBuffer,
-                        finalize: false
-                    )
-                }
-            }
-
-            if totalSourceSize > 0 {
-                let progress = min(Double(processedSourceBytes) / Double(totalSourceSize), 1.0)
-                progressHandler(progress)
-            }
-
-            if streamStatus == COMPRESSION_STATUS_END {
-                reachedStreamEnd = true
-            } else if chunk.isEmpty {
-                throw NSError(
-                    domain: "StreamingTarArchiveExtractor",
-                    code: 7,
-                    userInfo: [NSLocalizedDescriptionKey: "Brotli decompression ended before reaching the end of stream"]
-                )
-            }
-        }
-
-        progressHandler(1.0)
-    }
-
-    private static func flushCompressionStream(
-        _ stream: inout compression_stream,
-        into outputHandle: FileHandle,
-        outputBuffer: UnsafeMutablePointer<UInt8>,
-        finalize: Bool
-    ) throws -> compression_status {
-        let flags = finalize ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
-        var lastStatus = COMPRESSION_STATUS_OK
-
-        repeat {
-            let previousSourceSize = stream.src_size
-
-            stream.dst_ptr = outputBuffer
-            stream.dst_size = bufferSize
-
-            lastStatus = compression_stream_process(&stream, flags)
-
-            switch lastStatus {
-            case COMPRESSION_STATUS_OK, COMPRESSION_STATUS_END:
-                let producedBytes = bufferSize - stream.dst_size
-                if producedBytes > 0 {
-                    outputHandle.write(
-                        Data(bytes: outputBuffer, count: producedBytes)
-                    )
-                }
-
-                if finalize,
-                   lastStatus == COMPRESSION_STATUS_OK,
-                   producedBytes == 0,
-                   previousSourceSize == stream.src_size {
-                    throw NSError(
-                        domain: "StreamingTarArchiveExtractor",
-                        code: 8,
-                        userInfo: [NSLocalizedDescriptionKey: "Brotli decompression stalled before reaching the end of stream"]
-                    )
-                }
-
-            default:
-                throw NSError(
-                    domain: "StreamingTarArchiveExtractor",
-                    code: 9,
-                    userInfo: [NSLocalizedDescriptionKey: "Brotli decompression failed"]
-                )
-            }
-        } while stream.src_size > 0 || stream.dst_size == 0 || (finalize && lastStatus == COMPRESSION_STATUS_OK)
-
-        return lastStatus
-    }
-
-    private static func prepareEmptyFile(at path: String) throws {
-        let fileManager = FileManager.default
-        let parentDirectory = (path as NSString).deletingLastPathComponent
-
-        if !fileManager.fileExists(atPath: parentDirectory) {
-            try fileManager.createDirectory(
-                atPath: parentDirectory,
-                withIntermediateDirectories: true,
-                attributes: nil
-            )
-        }
-
-        if fileManager.fileExists(atPath: path) {
-            try fileManager.removeItem(atPath: path)
-        }
-
-        guard fileManager.createFile(atPath: path, contents: nil) else {
-            throw NSError(
-                domain: "StreamingTarArchiveExtractor",
-                code: 10,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to create temporary archive file"]
-            )
-        }
-    }
-
-    private static func fileSize(atPath path: String) throws -> UInt64 {
-        let attributes = try FileManager.default.attributesOfItem(atPath: path)
-        if let value = attributes[.size] as? NSNumber {
-            return value.uint64Value
-        }
-
-        if let value = attributes[.size] as? UInt64 {
-            return value
-        }
-
-        return 0
-    }
-
-}