@hot-updater/react-native 0.20.14 → 0.21.0

package/ios/HotUpdater/Internal/TarBrDecompressionStrategy.swift

@@ -0,0 +1,229 @@
+import Foundation
+import SWCompression
+import Compression
+
+/**
+ * Strategy for handling TAR+Brotli compressed files
+ */
+class TarBrDecompressionStrategy: DecompressionStrategy {
+    private static let MIN_FILE_SIZE: UInt64 = 10
+
+    func isValid(file: String) -> Bool {
+        guard FileManager.default.fileExists(atPath: file) else {
+            NSLog("[TarBrStrategy] Invalid file: doesn't exist")
+            return false
+        }
+
+        do {
+            let attributes = try FileManager.default.attributesOfItem(atPath: file)
+            guard let fileSize = attributes[.size] as? UInt64, fileSize >= Self.MIN_FILE_SIZE else {
+                NSLog("[TarBrStrategy] Invalid file: too small")
+                return false
+            }
+        } catch {
+            NSLog("[TarBrStrategy] Invalid file: cannot read attributes - \(error.localizedDescription)")
+            return false
+        }
+
+        // Brotli has no standard magic bytes, check file extension
+        let lowercasedPath = file.lowercased()
+        let isBrotli = lowercasedPath.hasSuffix(".tar.br") || lowercasedPath.hasSuffix(".br")
+
+        if !isBrotli {
+            NSLog("[TarBrStrategy] Invalid file: not a .tar.br or .br file")
+        }
+
+        return isBrotli
+    }
+
+    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
+        NSLog("[TarBrStrategy] Starting extraction of \(file) to \(destination)")
+
+        guard let compressedData = try? Data(contentsOf: URL(fileURLWithPath: file)) else {
+            throw NSError(
+                domain: "TarBrDecompressionStrategy",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to read tar.br file at: \(file)"]
+            )
+        }
+
+        progressHandler(0.3)
+        let decompressedData: Data
+        do {
+            decompressedData = try decompressBrotli(compressedData)
+            NSLog("[TarBrStrategy] Brotli decompression successful, size: \(decompressedData.count) bytes")
+            progressHandler(0.6)
+        } catch {
+            throw NSError(
+                domain: "TarBrDecompressionStrategy",
+                code: 2,
+                userInfo: [NSLocalizedDescriptionKey: "Brotli decompression failed: \(error.localizedDescription)"]
+            )
+        }
+
+        let tarEntries: [TarEntry]
+        do {
+            tarEntries = try TarContainer.open(container: decompressedData)
+            NSLog("[TarBrStrategy] Tar extraction successful, found \(tarEntries.count) entries")
+        } catch {
+            throw NSError(
+                domain: "TarBrDecompressionStrategy",
+                code: 3,
+                userInfo: [NSLocalizedDescriptionKey: "Tar extraction failed: \(error.localizedDescription)"]
+            )
+        }
+
+        let destinationURL = URL(fileURLWithPath: destination)
+        let canonicalDestination = destinationURL.standardized.path
+
+        let fileManager = FileManager.default
+        if !fileManager.fileExists(atPath: canonicalDestination) {
+            try fileManager.createDirectory(
+                atPath: canonicalDestination,
+                withIntermediateDirectories: true,
+                attributes: nil
+            )
+        }
+
+        let totalEntries = Double(tarEntries.count)
+        for (index, entry) in tarEntries.enumerated() {
+            try extractTarEntry(entry, to: canonicalDestination)
+            progressHandler(0.6 + (Double(index + 1) / totalEntries * 0.4))
+        }
+
+        NSLog("[TarBrStrategy] Successfully extracted all entries")
+    }
+
+    private func decompressBrotli(_ data: Data) throws -> Data {
+        let bufferSize = 64 * 1024
+        var decompressedData = Data()
+        let count = data.count
+
+        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: "TarBrDecompressionStrategy",
+                code: 5,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to initialize brotli decompression stream"]
+            )
+        }
+
+        defer {
+            compression_stream_destroy(&stream)
+        }
+
+        let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+        defer {
+            outputBuffer.deallocate()
+        }
+
+        data.withUnsafeBytes { (rawBufferPointer: UnsafeRawBufferPointer) in
+            guard let baseAddress = rawBufferPointer.baseAddress else {
+                return
+            }
+
+            stream.src_ptr = baseAddress.assumingMemoryBound(to: UInt8.self)
+            stream.src_size = count
+
+            var processStatus: compression_status
+            repeat {
+                stream.dst_ptr = outputBuffer
+                stream.dst_size = bufferSize
+
+                let flags = (stream.src_size == 0) ? Int32(bitPattern: COMPRESSION_STREAM_FINALIZE.rawValue) : Int32(0)
+                processStatus = compression_stream_process(&stream, flags)
+
+                switch processStatus {
+                case COMPRESSION_STATUS_OK, COMPRESSION_STATUS_END:
+                    let outputSize = bufferSize - stream.dst_size
+                    decompressedData.append(outputBuffer, count: outputSize)
+                case COMPRESSION_STATUS_ERROR:
+                    break
+                default:
+                    break
+                }
+            } while processStatus == COMPRESSION_STATUS_OK
+        }
+
+        if decompressedData.isEmpty && !data.isEmpty {
+            throw NSError(
+                domain: "TarBrDecompressionStrategy",
+                code: 6,
+                userInfo: [NSLocalizedDescriptionKey: "Brotli decompression produced no output"]
+            )
+        }
+
+        return decompressedData
+    }
+
+    private func extractTarEntry(_ entry: TarEntry, to destination: String) throws {
+        let entryInfo = entry.info
+        let entryName = entryInfo.name
+
+        if entryName.isEmpty || entryName == "./" || entryName == "." {
+            return
+        }
+
+        let targetURL = URL(fileURLWithPath: destination).appendingPathComponent(entryName)
+        let targetPath = targetURL.standardized.path
+
+        if !targetPath.hasPrefix(destination) {
+            throw NSError(
+                domain: "TarBrDecompressionStrategy",
+                code: 4,
+                userInfo: [
+                    NSLocalizedDescriptionKey: "Path traversal detected",
+                    "entry": entryName,
+                    "targetPath": targetPath,
+                    "destination": destination
+                ]
+            )
+        }
+
+        let fileManager = FileManager.default
+
+        switch entryInfo.type {
+        case .directory:
+            if !fileManager.fileExists(atPath: targetPath) {
+                try fileManager.createDirectory(
+                    atPath: targetPath,
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+            }
+            NSLog("[TarBrStrategy] Created directory: \(entryName)")
+
+        case .regular:
+            let parentPath = targetURL.deletingLastPathComponent().path
+            if !fileManager.fileExists(atPath: parentPath) {
+                try fileManager.createDirectory(
+                    atPath: parentPath,
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+            }
+
+            if let data = entry.data {
+                try data.write(to: targetURL, options: .atomic)
+                NSLog("[TarBrStrategy] Extracted file: \(entryName) (\(data.count) bytes)")
+            } else {
+                NSLog("[TarBrStrategy] Warning: No data for file entry: \(entryName)")
+            }
+
+        case .symbolicLink:
+            NSLog("[TarBrStrategy] Skipping symbolic link: \(entryName)")
+
+        default:
+            NSLog("[TarBrStrategy] Skipping unsupported entry type: \(entryName)")
+        }
+    }
+}

package/ios/HotUpdater/Internal/TarGzDecompressionStrategy.swift

@@ -0,0 +1,177 @@
+import Foundation
+import SWCompression
+import Compression
+
+/**
+ * Strategy for handling TAR+GZIP compressed files
+ */
+class TarGzDecompressionStrategy: DecompressionStrategy {
+    private static let MIN_FILE_SIZE: UInt64 = 10
+
+    func isValid(file: String) -> Bool {
+        guard FileManager.default.fileExists(atPath: file) else {
+            NSLog("[TarGzStrategy] Invalid file: doesn't exist")
+            return false
+        }
+
+        do {
+            let attributes = try FileManager.default.attributesOfItem(atPath: file)
+            guard let fileSize = attributes[.size] as? UInt64, fileSize >= Self.MIN_FILE_SIZE else {
+                NSLog("[TarGzStrategy] Invalid file: too small")
+                return false
+            }
+        } catch {
+            NSLog("[TarGzStrategy] Invalid file: cannot read attributes - \(error.localizedDescription)")
+            return false
+        }
+
+        // Check GZIP magic bytes (0x1F 0x8B)
+        guard let fileHandle = FileHandle(forReadingAtPath: file) else {
+            NSLog("[TarGzStrategy] Invalid file: cannot open file")
+            return false
+        }
+
+        defer {
+            fileHandle.closeFile()
+        }
+
+        guard let header = try? fileHandle.read(upToCount: 2), header.count == 2 else {
+            NSLog("[TarGzStrategy] Invalid file: cannot read header")
+            return false
+        }
+
+        let isGzip = header[0] == 0x1F && header[1] == 0x8B
+        if !isGzip {
+            NSLog("[TarGzStrategy] Invalid file: wrong magic bytes (expected 0x1F 0x8B, got 0x\(String(format: "%02X", header[0])) 0x\(String(format: "%02X", header[1])))")
+        }
+        return isGzip
+    }
+
+    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
+        NSLog("[TarGzStrategy] Starting extraction of \(file) to \(destination)")
+
+        guard let compressedData = try? Data(contentsOf: URL(fileURLWithPath: file)) else {
+            throw NSError(
+                domain: "TarGzDecompressionStrategy",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to read tar.gz file at: \(file)"]
+            )
+        }
+
+        progressHandler(0.3)
+        let decompressedData: Data
+        do {
+            decompressedData = try decompressGzip(compressedData)
+            NSLog("[TarGzStrategy] GZIP decompression successful, size: \(decompressedData.count) bytes")
+            progressHandler(0.6)
+        } catch {
+            throw NSError(
+                domain: "TarGzDecompressionStrategy",
+                code: 2,
+                userInfo: [NSLocalizedDescriptionKey: "GZIP decompression failed: \(error.localizedDescription)"]
+            )
+        }
+
+        let tarEntries: [TarEntry]
+        do {
+            tarEntries = try TarContainer.open(container: decompressedData)
+            NSLog("[TarGzStrategy] Tar extraction successful, found \(tarEntries.count) entries")
+        } catch {
+            throw NSError(
+                domain: "TarGzDecompressionStrategy",
+                code: 3,
+                userInfo: [NSLocalizedDescriptionKey: "Tar extraction failed: \(error.localizedDescription)"]
+            )
+        }
+
+        let destinationURL = URL(fileURLWithPath: destination)
+        let canonicalDestination = destinationURL.standardized.path
+
+        let fileManager = FileManager.default
+        if !fileManager.fileExists(atPath: canonicalDestination) {
+            try fileManager.createDirectory(
+                atPath: canonicalDestination,
+                withIntermediateDirectories: true,
+                attributes: nil
+            )
+        }
+
+        let totalEntries = Double(tarEntries.count)
+        for (index, entry) in tarEntries.enumerated() {
+            try extractTarEntry(entry, to: canonicalDestination)
+            progressHandler(0.6 + (Double(index + 1) / totalEntries * 0.4))
+        }
+
+        NSLog("[TarGzStrategy] Successfully extracted all entries")
+    }
+
+    private func decompressGzip(_ data: Data) throws -> Data {
+        do {
+            let decompressedData = try GzipArchive.unarchive(archive: data)
+            NSLog("[TarGzStrategy] GZIP decompression successful using SWCompression")
+            return decompressedData
+        } catch {
+            throw NSError(
+                domain: "TarGzDecompressionStrategy",
+                code: 5,
+                userInfo: [NSLocalizedDescriptionKey: "GZIP decompression failed: \(error.localizedDescription)"]
+            )
+        }
+    }
+
+    private func extractTarEntry(_ entry: TarEntry, to destination: String) throws {
+        let fileManager = FileManager.default
+        let entryPath = entry.info.name.trimmingCharacters(in: .init(charactersIn: "/"))
+
+        guard !entryPath.isEmpty,
+              !entryPath.contains(".."),
+              !entryPath.hasPrefix("/") else {
+            NSLog("[TarGzStrategy] Skipping suspicious path: \(entry.info.name)")
+            return
+        }
+
+        let fullPath = (destination as NSString).appendingPathComponent(entryPath)
+        let fullURL = URL(fileURLWithPath: fullPath)
+        let canonicalFullPath = fullURL.standardized.path
+        let canonicalDestination = URL(fileURLWithPath: destination).standardized.path
+
+        guard canonicalFullPath.hasPrefix(canonicalDestination + "/") ||
+              canonicalFullPath == canonicalDestination else {
+            throw NSError(
+                domain: "TarGzDecompressionStrategy",
+                code: 4,
+                userInfo: [NSLocalizedDescriptionKey: "Path traversal attempt detected: \(entry.info.name)"]
+            )
+        }
+
+        if entry.info.type == .directory {
+            if !fileManager.fileExists(atPath: canonicalFullPath) {
+                try fileManager.createDirectory(
+                    atPath: canonicalFullPath,
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+            }
+            return
+        }
+
+        if entry.info.type == .regular {
+            let parentPath = (canonicalFullPath as NSString).deletingLastPathComponent
+            if !fileManager.fileExists(atPath: parentPath) {
+                try fileManager.createDirectory(
+                    atPath: parentPath,
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+            }
+
+            guard let data = entry.data else {
+                NSLog("[TarGzStrategy] Skipping file with no data: \(entry.info.name)")
+                return
+            }
+
+            try data.write(to: URL(fileURLWithPath: canonicalFullPath))
+            NSLog("[TarGzStrategy] Extracted: \(entryPath)")
+        }
+    }
+}

package/ios/HotUpdater/Internal/URLSessionDownloadService.swift

@@ -1,30 +1,70 @@
 import Foundation
 
 protocol DownloadService {
+    /**
+     * Gets the file size from the URL without downloading.
+     * @param url The URL to check
+     * @param completion Callback with file size or error
+     */
+    func getFileSize(from url: URL, completion: @escaping (Result<Int64, Error>) -> Void)
+
     /**
      * Downloads a file from a URL.
      * @param url The URL to download from
      * @param destination The local path to save to
      * @param progressHandler Callback for download progress updates
-     * @param completion Callback with result of the download
+     * @param completion Callback with downloaded file URL or error
      * @return The download task (optional)
      */
     func downloadFile(from url: URL, to destination: String, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask?
 }
 
 
+enum DownloadError: Error {
+    case incompleteDownload
+    case invalidContentLength
+}
+
 class URLSessionDownloadService: NSObject, DownloadService {
     private var session: URLSession!
     private var progressHandlers: [URLSessionTask: (Double) -> Void] = [:]
     private var completionHandlers: [URLSessionTask: (Result<URL, Error>) -> Void] = [:]
     private var destinations: [URLSessionTask: String] = [:]
-    
+
     override init() {
         super.init()
         let configuration = URLSessionConfiguration.default
         session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
     }
-    
+
+    func getFileSize(from url: URL, completion: @escaping (Result<Int64, Error>) -> Void) {
+        var request = URLRequest(url: url)
+        request.httpMethod = "HEAD"
+
+        let task = session.dataTask(with: request) { _, response, error in
+            if let error = error {
+                NSLog("[DownloadService] HEAD request failed: \(error.localizedDescription)")
+                completion(.failure(error))
+                return
+            }
+
+            guard let httpResponse = response as? HTTPURLResponse else {
+                completion(.failure(DownloadError.invalidContentLength))
+                return
+            }
+
+            let contentLength = httpResponse.expectedContentLength
+            if contentLength > 0 {
+                NSLog("[DownloadService] File size from HEAD request: \(contentLength) bytes")
+                completion(.success(contentLength))
+            } else {
+                NSLog("[DownloadService] Invalid content length: \(contentLength)")
+                completion(.failure(DownloadError.invalidContentLength))
+            }
+        }
+        task.resume()
+    }
+
     func downloadFile(from url: URL, to destination: String, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask? {
         let task = session.downloadTask(with: url)
         progressHandlers[task] = progressHandler
@@ -39,24 +79,50 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
     func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
         let completion = completionHandlers[downloadTask]
         let destination = destinations[downloadTask]
-        
+
         defer {
             progressHandlers.removeValue(forKey: downloadTask)
             completionHandlers.removeValue(forKey: downloadTask)
             destinations.removeValue(forKey: downloadTask)
-            
+
             // 다운로드 완료 알림
             NotificationCenter.default.post(name: .downloadDidFinish, object: downloadTask)
         }
-        
+
         guard let destination = destination else {
             completion?(.failure(NSError(domain: "HotUpdaterError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Destination path not found"])))
             return
         }
-        
+
+        // Verify file size
+        let expectedSize = downloadTask.response?.expectedContentLength ?? -1
+        let actualSize: Int64?
+        do {
+            let attributes = try FileManager.default.attributesOfItem(atPath: location.path)
+            actualSize = attributes[.size] as? Int64
+        } catch {
+            NSLog("[DownloadService] Failed to get file attributes: \(error.localizedDescription)")
+            actualSize = nil
+        }
+
+        if expectedSize > 0, let actualSize = actualSize, actualSize != expectedSize {
+            NSLog("[DownloadService] Download incomplete: \(actualSize) / \(expectedSize) bytes")
+            // Delete incomplete file
+            try? FileManager.default.removeItem(at: location)
+            completion?(.failure(DownloadError.incompleteDownload))
+            return
+        }
+
         do {
             let destinationURL = URL(fileURLWithPath: destination)
+
+            // Delete existing file if needed
+            if FileManager.default.fileExists(atPath: destination) {
+                try FileManager.default.removeItem(at: destinationURL)
+            }
+
             try FileManager.default.copyItem(at: location, to: destinationURL)
+            NSLog("[DownloadService] Download completed successfully: \(actualSize ?? 0) bytes")
             completion?(.success(destinationURL))
         } catch {
             NSLog("[DownloadService] Failed to copy downloaded file: \(error.localizedDescription)")

package/ios/HotUpdater/Internal/ZipDecompressionStrategy.swift

@@ -0,0 +1,165 @@
+import Foundation
+import SWCompression
+
+/**
+ * Strategy for handling ZIP compressed files
+ */
+class ZipDecompressionStrategy: DecompressionStrategy {
+    private static let ZIP_MAGIC_NUMBER: [UInt8] = [0x50, 0x4B, 0x03, 0x04]
+    private static let MIN_ZIP_SIZE: UInt64 = 22
+
+    func isValid(file: String) -> Bool {
+        guard FileManager.default.fileExists(atPath: file) else {
+            NSLog("[ZipStrategy] Invalid ZIP: file doesn't exist")
+            return false
+        }
+
+        do {
+            let attributes = try FileManager.default.attributesOfItem(atPath: file)
+            guard let fileSize = attributes[.size] as? UInt64, fileSize >= Self.MIN_ZIP_SIZE else {
+                NSLog("[ZipStrategy] Invalid ZIP: file too small")
+                return false
+            }
+        } catch {
+            NSLog("[ZipStrategy] Invalid ZIP: cannot read attributes - \(error.localizedDescription)")
+            return false
+        }
+
+        guard let fileHandle = FileHandle(forReadingAtPath: file) else {
+            NSLog("[ZipStrategy] Invalid ZIP: cannot open file")
+            return false
+        }
+
+        defer {
+            fileHandle.closeFile()
+        }
+
+        guard let header = try? fileHandle.read(upToCount: 4), header.count == 4 else {
+            NSLog("[ZipStrategy] Invalid ZIP: cannot read header")
+            return false
+        }
+
+        let magicBytes = [UInt8](header)
+        guard magicBytes == Self.ZIP_MAGIC_NUMBER else {
+            NSLog("[ZipStrategy] Invalid ZIP: wrong magic number")
+            return false
+        }
+
+        guard let zipData = try? Data(contentsOf: URL(fileURLWithPath: file)) else {
+            NSLog("[ZipStrategy] Invalid ZIP: cannot read file data")
+            return false
+        }
+
+        do {
+            _ = try ZipContainer.open(container: zipData)
+            return true
+        } catch {
+            NSLog("[ZipStrategy] Invalid ZIP: structure validation failed - \(error.localizedDescription)")
+            return false
+        }
+    }
+
+    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
+        NSLog("[ZipStrategy] Starting extraction of \(file) to \(destination)")
+
+        guard let zipData = try? Data(contentsOf: URL(fileURLWithPath: file)) else {
+            throw NSError(
+                domain: "ZipDecompressionStrategy",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to read ZIP file at: \(file)"]
+            )
+        }
+
+        progressHandler(0.1)
+
+        let zipEntries: [ZipEntry]
+        do {
+            zipEntries = try ZipContainer.open(container: zipData)
+            NSLog("[ZipStrategy] ZIP extraction successful, found \(zipEntries.count) entries")
+        } catch {
+            throw NSError(
+                domain: "ZipDecompressionStrategy",
+                code: 2,
+                userInfo: [NSLocalizedDescriptionKey: "ZIP extraction failed: \(error.localizedDescription)"]
+            )
+        }
+
+        progressHandler(0.2)
+
+        let destinationURL = URL(fileURLWithPath: destination)
+        let canonicalDestination = destinationURL.standardized.path
+
+        let fileManager = FileManager.default
+        if !fileManager.fileExists(atPath: canonicalDestination) {
+            try fileManager.createDirectory(
+                atPath: canonicalDestination,
+                withIntermediateDirectories: true,
+                attributes: nil
+            )
+        }
+
+        let totalEntries = Double(zipEntries.count)
+        for (index, entry) in zipEntries.enumerated() {
+            try extractZipEntry(entry, to: canonicalDestination)
+            progressHandler(0.2 + (Double(index + 1) / totalEntries * 0.8))
+        }
+
+        NSLog("[ZipStrategy] Successfully extracted all entries")
+    }
+
+    private func extractZipEntry(_ entry: ZipEntry, to destination: String) throws {
+        let fileManager = FileManager.default
+        let entryPath = entry.info.name.trimmingCharacters(in: .init(charactersIn: "/"))
+
+        guard !entryPath.isEmpty,
+              !entryPath.contains(".."),
+              !entryPath.hasPrefix("/") else {
+            NSLog("[ZipStrategy] Skipping suspicious path: \(entry.info.name)")
+            return
+        }
+
+        let fullPath = (destination as NSString).appendingPathComponent(entryPath)
+        let fullURL = URL(fileURLWithPath: fullPath)
+        let canonicalFullPath = fullURL.standardized.path
+        let canonicalDestination = URL(fileURLWithPath: destination).standardized.path
+
+        guard canonicalFullPath.hasPrefix(canonicalDestination + "/") ||
+              canonicalFullPath == canonicalDestination else {
+            throw NSError(
+                domain: "ZipDecompressionStrategy",
+                code: 3,
+                userInfo: [NSLocalizedDescriptionKey: "Path traversal attempt detected: \(entry.info.name)"]
+            )
+        }
+
+        if entry.info.type == .directory {
+            if !fileManager.fileExists(atPath: canonicalFullPath) {
+                try fileManager.createDirectory(
+                    atPath: canonicalFullPath,
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+            }
+            return
+        }
+
+        if entry.info.type == .regular {
+            let parentPath = (canonicalFullPath as NSString).deletingLastPathComponent
+            if !fileManager.fileExists(atPath: parentPath) {
+                try fileManager.createDirectory(
+                    atPath: parentPath,
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+            }
+
+            guard let data = entry.data else {
+                NSLog("[ZipStrategy] Skipping file with no data: \(entry.info.name)")
+                return
+            }
+
+            try data.write(to: URL(fileURLWithPath: canonicalFullPath))
+            NSLog("[ZipStrategy] Extracted: \(entryPath)")
+        }
+    }
+}