@rovq/react-native 0.1.0 → 0.2.1

package/android/src/main/java/com/rovq/engine/UpdateInstaller.kt

@@ -1,13 +1,22 @@
 package com.rovq.engine
 
 import java.io.File
+import java.io.IOException
+import java.io.InputStream
+import java.security.MessageDigest
+
+// Download links last an hour, so they are fetched a few files at a time, just before use.
+private const val LINK_BATCH_SIZE = 20
+private const val BUFFER_SIZE = 64 * 1024
+private const val EMPTY_FILE_HASH = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
 
 /** What the server offered. None of this is trusted until the manifest has been verified. */
 data class OfferedUpdate(
     val manifest: String,
     val signature: String,
     val keyId: String,
-    val downloadUrl: String,
+    /** Only for a ZIP package. A release made of files is fetched file by file. */
+    val downloadUrl: String?,
 )
 
 /** A verified release, fully extracted in its own folder. */
@@ -17,6 +26,18 @@ data class InstalledRelease(
     val bundleFile: File,
 )
 
+/** Asks the server for download links, by hash, for files of one release. */
+fun interface FileLinks {
+    /** @throws IOException if the server cannot be reached or answers with an error. */
+    fun linksFor(releaseId: String, hashes: List<String>): Map<String, String>
+}
+
+/** The app's own copies of package files, which a release made of files can reuse. */
+fun interface BuiltInFiles {
+    /** Opens the app's copy of a package path, or returns null when it has none. */
+    fun open(path: String): InputStream?
+}
+
 /**
  * Takes an offered update to a verified folder on disk, without activating it.
  *
@@ -24,11 +45,13 @@ data class InstalledRelease(
  * path would show old images after a reload. See docs/android-bundle-loading.md.
  *
  * @param rootDir a folder only the engine uses, normally inside the app's private storage.
+ * @param builtInFiles the app's own assets, which can be reused instead of downloaded.
  */
 class UpdateInstaller(
     rootDir: File,
     private val verifier: ManifestVerifier,
     private val downloader: PackageDownloader,
+    private val builtInFiles: BuiltInFiles? = null,
 ) {
     private val updatesDir = File(rootDir, "updates")
     private val workDir = File(rootDir, "work")
@@ -39,12 +62,14 @@ class UpdateInstaller(
 
     /**
      * @param highestSequence the highest sequence this device has accepted in this stream.
+     * @param fileLinks download links for a release made of files.
      * @throws RovqException if any step fails. Nothing is left behind in that case.
      */
     @Synchronized
     fun install(
         offer: OfferedUpdate,
         highestSequence: Long,
+        fileLinks: FileLinks = FileLinks { _, _ -> throw IOException("No way to fetch files") },
         onProgress: (received: Long, total: Long) -> Unit = { _, _ -> },
     ): InstalledRelease {
         // Verified first, so an unsigned update causes no network traffic or disk use.
@@ -53,35 +78,61 @@ class UpdateInstaller(
         val folder = File(updatesDir, manifest.releaseId)
         // Folders appear only through the atomic rename below, so one that exists is complete.
         if (!folder.isDirectory) {
-            install(offer, manifest, folder, onProgress)
+            val files = manifest.files
+            if (files != null) {
+                installFileList(files, manifest.releaseId, folder, fileLinks, onProgress)
+            } else {
+                installZip(offer, manifest, folder, onProgress)
+            }
         }
         return InstalledRelease(manifest, folder, File(folder, PackageRules.BUNDLE_FILE_NAME))
     }
 
-    private fun install(
-        offer: OfferedUpdate,
-        manifest: VerifiedManifest,
-        folder: File,
-        onProgress: (Long, Long) -> Unit,
-    ) {
+    /** Creates an empty work folder for assembling a release, and the folders around it. */
+    private fun startWork(): File {
         // Removes anything an earlier run left when the app was killed or the phone lost power.
         workDir.deleteRecursively()
-        val extracted = File(workDir, "extracted")
-        if (!extracted.mkdirs() ||
+        val assembled = File(workDir, "extracted")
+        if (!assembled.mkdirs() ||
             !(updatesDir.isDirectory || updatesDir.mkdirs()) ||
             !(partialDir.isDirectory || partialDir.mkdirs())
         ) {
             throw RovqException(RovqErrorCode.STORAGE_FAILED, "Could not create the engine folders")
         }
+        return assembled
+    }
+
+    private fun moveIntoPlace(assembled: File, folder: File) {
+        if (!assembled.renameTo(folder)) {
+            throw RovqException(RovqErrorCode.STORAGE_FAILED, "Could not move the release into place")
+        }
+    }
+
+    private fun installZip(
+        offer: OfferedUpdate,
+        manifest: VerifiedManifest,
+        folder: File,
+        onProgress: (Long, Long) -> Unit,
+    ) {
+        val downloadUrl = offer.downloadUrl
+            ?: throw RovqException(RovqErrorCode.DOWNLOAD_FAILED, "The server sent no download URL")
+        val extracted = startWork()
         val packageFile = File(partialDir, "${manifest.packageHash}.zip")
         // Only the current offer is worth finishing.
         partialDir.listFiles()?.filter { it != packageFile }?.forEach { it.delete() }
         try {
-            downloader.download(offer.downloadUrl, manifest, packageFile, onProgress)
+            // Extracting needs room too, and its size is unknown until then, so this asks for
+            // the package twice. A package can still expand further, and extraction reports that.
+            downloader.download(
+                downloadUrl,
+                manifest.packageHash,
+                manifest.packageSize,
+                packageFile,
+                extraSpace = manifest.packageSize,
+                onProgress = onProgress,
+            )
             extractor.extract(packageFile, extracted)
-            if (!extracted.renameTo(folder)) {
-                throw RovqException(RovqErrorCode.STORAGE_FAILED, "Could not move the release into place")
-            }
+            moveIntoPlace(extracted, folder)
             packageFile.delete()
         } catch (error: RovqException) {
             // A file that failed anything but the network is not worth continuing from.
@@ -91,4 +142,206 @@ class UpdateInstaller(
             workDir.deleteRecursively()
         }
     }
+
+    /**
+     * Builds a release from its files: each comes from a kept release, from the app itself, or
+     * from the network, in that order, and only after its content matches the signed hash. See
+     * docs/file-packages.md.
+     */
+    private fun installFileList(
+        list: List<ManifestFile>,
+        releaseId: String,
+        folder: File,
+        fileLinks: FileLinks,
+        onProgress: (Long, Long) -> Unit,
+    ) {
+        val assembled = startWork()
+        try {
+            val wanted = list.map { it.hash }.toSet()
+            // Only the current offer is worth finishing.
+            partialDir.listFiles()?.filter { it.name !in wanted }?.forEach { it.delete() }
+            val root = assembled.canonicalPath + File.separator
+
+            // A hash already placed, so the same content at another path is linked, not fetched.
+            val placed = HashMap<String, File>()
+            // Files with no local copy at their own path. Another path may still provide them.
+            val unresolved = ArrayList<Pair<ManifestFile, File>>()
+
+            for (file in list) {
+                val target = File(assembled, file.path)
+                val parent = target.parentFile ?: assembled
+                if (!(parent.isDirectory || parent.mkdirs())) {
+                    throw RovqException(RovqErrorCode.STORAGE_FAILED, "Could not create a folder")
+                }
+                // A second, independent check: whatever the rules allow, the real path must stay
+                // inside the folder.
+                if (!(parent.canonicalPath + File.separator).startsWith(root)) {
+                    throw RovqException(RovqErrorCode.INVALID_PACKAGE, "The file ${file.path} leaves the folder")
+                }
+                val source = placed[file.hash]
+                when {
+                    source != null -> link(source, target)
+                    file.size == 0L -> {
+                        if (file.hash != EMPTY_FILE_HASH) {
+                            throw RovqException(RovqErrorCode.HASH_MISMATCH, "An empty file does not match its signed hash")
+                        }
+                        if (!target.createNewFile()) {
+                            throw RovqException(RovqErrorCode.STORAGE_FAILED, "Could not create the file")
+                        }
+                        placed[file.hash] = target
+                    }
+                    placeLocalCopy(file, target, folder) -> placed[file.hash] = target
+                    else -> unresolved += file to target
+                }
+            }
+
+            // Files to download, by hash, with every path that needs each one, in manifest order.
+            val targets = LinkedHashMap<String, MutableList<File>>()
+            val missing = ArrayList<ManifestFile>()
+            for ((file, target) in unresolved) {
+                val source = placed[file.hash]
+                when {
+                    source != null -> link(source, target)
+                    targets.containsKey(file.hash) -> targets.getValue(file.hash) += target
+                    else -> {
+                        targets[file.hash] = mutableListOf(target)
+                        missing += file
+                    }
+                }
+            }
+
+            download(missing, targets, releaseId, fileLinks, onProgress)
+            moveIntoPlace(assembled, folder)
+            // Linked into the release, so the content stays where it is needed.
+            missing.forEach { File(partialDir, it.hash).delete() }
+        } finally {
+            workDir.deleteRecursively()
+        }
+    }
+
+    private fun download(
+        missing: List<ManifestFile>,
+        targets: Map<String, List<File>>,
+        releaseId: String,
+        fileLinks: FileLinks,
+        onProgress: (Long, Long) -> Unit,
+    ) {
+        if (missing.isEmpty()) return
+        val total = missing.sumOf { it.size }
+        // Checked for the whole release first, so a full disk fails before any download.
+        val remaining = missing.sumOf { file ->
+            val partial = File(partialDir, file.hash)
+            file.size - (if (partial.isFile) minOf(partial.length(), file.size) else 0L)
+        }
+        if (downloader.freeSpaceIn(partialDir) < remaining) {
+            throw RovqException(RovqErrorCode.STORAGE_FAILED, "Not enough free space for this update")
+        }
+
+        var finished = 0L
+        onProgress(0, total)
+        for (batch in missing.chunked(LINK_BATCH_SIZE)) {
+            val links = try {
+                fileLinks.linksFor(releaseId, batch.map { it.hash })
+            } catch (error: IOException) {
+                throw RovqException(RovqErrorCode.DOWNLOAD_FAILED, error.message ?: "Could not get download links", error)
+            }
+            for (file in batch) {
+                val url = links[file.hash]
+                    ?: throw RovqException(RovqErrorCode.DOWNLOAD_FAILED, "The server sent no link for a file")
+                val partial = File(partialDir, file.hash)
+                val before = finished
+                downloader.download(url, file.hash, file.size, partial) { received, _ ->
+                    onProgress(before + received, total)
+                }
+                finished += file.size
+                targets[file.hash]?.forEach { link(partial, it) }
+            }
+        }
+    }
+
+    /**
+     * Places the same path from a kept release, or from the app itself, if its content is the
+     * signed one. Hashed every time, because reusing a damaged file would break the new release.
+     */
+    private fun placeLocalCopy(file: ManifestFile, target: File, folder: File): Boolean {
+        val kept = updatesDir.listFiles()?.filter { it.isDirectory && it.name != folder.name }.orEmpty()
+        for (release in kept) {
+            val candidate = File(release, file.path)
+            if (candidate.isFile && candidate.length() == file.size && hashOf(candidate) == file.hash) {
+                link(candidate, target)
+                return true
+            }
+        }
+        return copyBuiltIn(file, target)
+    }
+
+    /** Copies the app's own file while hashing it, and keeps the copy only if it matches. */
+    private fun copyBuiltIn(file: ManifestFile, target: File): Boolean {
+        val input = try {
+            builtInFiles?.open(file.path)
+        } catch (error: Exception) {
+            null
+        } ?: return false
+        val digest = MessageDigest.getInstance("SHA-256")
+        var copied = 0L
+        try {
+            input.use { source ->
+                target.outputStream().use { output ->
+                    val buffer = ByteArray(BUFFER_SIZE)
+                    while (true) {
+                        val count = source.read(buffer)
+                        if (count < 0) break
+                        copied += count
+                        if (copied > file.size) break
+                        digest.update(buffer, 0, count)
+                        output.write(buffer, 0, count)
+                    }
+                }
+            }
+        } catch (error: IOException) {
+            target.delete()
+            return false
+        }
+        val matches = copied == file.size && digest.digest().toHex() == file.hash
+        if (!matches) target.delete()
+        return matches
+    }
+
+    private fun hashOf(file: File): String? = try {
+        val digest = MessageDigest.getInstance("SHA-256")
+        file.inputStream().use { input ->
+            val buffer = ByteArray(BUFFER_SIZE)
+            while (true) {
+                val count = input.read(buffer)
+                if (count < 0) break
+                digest.update(buffer, 0, count)
+            }
+        }
+        digest.digest().toHex()
+    } catch (error: IOException) {
+        null
+    }
+
+    private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+
+    /**
+     * A hard link costs no space. Files in a release never change, so sharing them is safe.
+     * Android before 8.0 has no java.nio.file, so it copies instead.
+     */
+    private fun link(source: File, target: File) {
+        val linked = try {
+            java.nio.file.Files.createLink(target.toPath(), source.toPath())
+            true
+        } catch (error: Exception) {
+            false
+        } catch (error: LinkageError) {
+            false
+        }
+        if (linked) return
+        try {
+            source.copyTo(target, overwrite = true)
+        } catch (error: IOException) {
+            throw RovqException(RovqErrorCode.STORAGE_FAILED, "Could not place a file", error)
+        }
+    }
 }

package/android/src/main/java/com/rovq/engine/UpdateService.kt

@@ -42,6 +42,14 @@ interface UpdateService {
 
     /** @throws IOException if the events could not be delivered. */
     fun report(deploymentKey: String, deviceId: String, events: List<QueuedEvent>)
+
+    /**
+     * Download links for files of a release made of files, by hash. Each file is checked against
+     * the signed manifest, so the links are trusted for nothing.
+     *
+     * @throws IOException if the server cannot be reached or answers with an error.
+     */
+    fun fileLinks(deploymentKey: String, deviceId: String, releaseId: String, hashes: List<String>): Map<String, String>
 }
 
 class HttpUpdateService(
@@ -57,6 +65,8 @@ class HttpUpdateService(
             .put("runtimeVersion", request.runtimeVersion)
             .put("binaryVersion", request.binaryVersion)
             .put("highestSequence", request.highestSequence)
+            // Both a ZIP package and a list of files. See docs/file-packages.md.
+            .put("packageFormats", JSONArray().put(1).put(2))
         request.currentReleaseId?.let { body.put("currentReleaseId", it) }
 
         return try {
@@ -71,7 +81,8 @@ class HttpUpdateService(
                             manifest = update.getString("manifest"),
                             signature = update.getString("signature"),
                             keyId = update.getString("keyId"),
-                            downloadUrl = update.getString("downloadUrl"),
+                            // A release made of files has no single download URL.
+                            downloadUrl = update.optString("downloadUrl").ifEmpty { null },
                         ),
                     )
                 }
@@ -111,6 +122,31 @@ class HttpUpdateService(
         )
     }
 
+    override fun fileLinks(
+        deploymentKey: String,
+        deviceId: String,
+        releaseId: String,
+        hashes: List<String>,
+    ): Map<String, String> {
+        val response = post(
+            "/device/updates/files",
+            JSONObject()
+                .put("deploymentKey", deploymentKey)
+                .put("deviceId", deviceId)
+                .put("releaseId", releaseId)
+                .put("hashes", JSONArray(hashes)),
+        )
+        return try {
+            val files = response.getJSONArray("files")
+            (0 until files.length()).associate { index ->
+                val file = files.getJSONObject(index)
+                file.getString("hash") to file.getString("url")
+            }
+        } catch (error: JSONException) {
+            throw IOException("The server sent an unreadable response", error)
+        }
+    }
+
     private fun post(path: String, body: JSONObject): JSONObject {
         val url = URL(apiUrl.trimEnd('/') + path)
         if (url.protocol != "https" && !allowInsecureUrls) {

package/android/src/react/java/com/rovq/engine/react/ResourceFiles.kt

@@ -0,0 +1,52 @@
+package com.rovq.engine.react
+
+import android.content.Context
+import android.util.TypedValue
+import com.rovq.engine.BuiltInFiles
+import java.io.InputStream
+
+// The densities react-native bundle writes drawables for, in dots per inch.
+private val DENSITIES = mapOf(
+    "ldpi" to 120,
+    "mdpi" to 160,
+    "hdpi" to 240,
+    "xhdpi" to 320,
+    "xxhdpi" to 480,
+    "xxxhdpi" to 640,
+)
+
+/**
+ * Reads the app's own copy of a package file, so a release made of files can reuse it instead
+ * of downloading it again. In an APK, react-native bundle's files are resources: a path such as
+ * raw/src_assets_audio_1.mp3 is the raw resource src_assets_audio_1, and drawable-xhdpi/x.png is
+ * the drawable x at 320 dpi.
+ *
+ * Whatever this returns is hashed and compared with the signed hash, so a resource that the
+ * build changed, such as a PNG that was compressed again, is simply downloaded instead.
+ */
+internal class ResourceFiles(private val context: Context) : BuiltInFiles {
+    override fun open(path: String): InputStream? {
+        val segments = path.split('/')
+        if (segments.size != 2) return null
+        val (folder, fileName) = segments
+        val type = folder.substringBefore('-')
+        val name = fileName.substringBeforeLast('.')
+        val resources = context.resources
+        // The only way to find a resource by the name a package uses.
+        @Suppress("DiscouragedApi")
+        val id = resources.getIdentifier(name, type, context.packageName)
+        if (id == 0) return null
+        return when (type) {
+            "raw" -> resources.openRawResource(id)
+            "drawable" -> {
+                val density = DENSITIES[folder.substringAfter('-', "")] ?: return null
+                val value = TypedValue()
+                resources.getValueForDensity(id, density, value, true)
+                val file = value.string?.toString() ?: return null
+                // Works for files stored uncompressed in the APK, which images and audio are.
+                resources.assets.openNonAssetFd(value.assetCookie, file).createInputStream()
+            }
+            else -> null
+        }
+    }
+}

package/android/src/react/java/com/rovq/engine/react/Rovq.kt

@@ -48,6 +48,7 @@ object Rovq {
                 trustedKeys = config.trustedKeys,
                 allowInsecureUrls = config.allowInsecureUrls,
             ),
+            builtInFiles = ResourceFiles(application),
         )
         instance = engine
         application.registerActivityLifecycleCallbacks(BackgroundWatcher(engine))

package/ios/Engine/ManifestVerifier.swift

@@ -3,23 +3,53 @@ import Foundation
 
 private let publicKeySize = 32
 private let signatureSize = 64
-private let manifestVersion: Int64 = 1
 private let platform = "IOS"
-private let manifestFields: Set<String> = [
+private let streamFields: Set<String> = [
     "version", "releaseId", "deploymentKey", "platform", "runtimeVersion", "binaryVersion",
-    "sequence", "mandatory", "package",
+    "sequence", "mandatory",
 ]
+/// Version 1 names one ZIP package. Version 2 lists files. See docs/file-packages.md.
+private let zipManifestFields = streamFields.union(["package"])
+private let filesManifestFields = streamFields.union(["files"])
 private let packageFields: Set<String> = ["hash", "size"]
+private let fileFields: Set<String> = ["path", "hash", "size"]
 private let uuidPattern = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
 private let hashPattern = "^[0-9a-f]{64}$"
 
+/// One file of a release made of files, from a verified manifest.
+public struct ManifestFile: Equatable {
+    public let path: String
+    public let hash: String
+    public let size: Int64
+}
+
 /// Facts from a manifest whose signature has been verified. Nothing else should be trusted.
 public struct VerifiedManifest: Equatable {
     public let releaseId: String
     public let sequence: Int64
     public let mandatory: Bool
+    /// The ZIP package's hash. Empty for a release made of files.
     public let packageHash: String
+    /// The ZIP package's size, or all files together.
     public let packageSize: Int64
+    /// Set for a release made of files, sorted by path. Nil for a ZIP package.
+    public let files: [ManifestFile]?
+
+    init(
+        releaseId: String,
+        sequence: Int64,
+        mandatory: Bool,
+        packageHash: String,
+        packageSize: Int64,
+        files: [ManifestFile]? = nil
+    ) {
+        self.releaseId = releaseId
+        self.sequence = sequence
+        self.mandatory = mandatory
+        self.packageHash = packageHash
+        self.packageSize = packageSize
+        self.files = files
+    }
 }
 
 /// Decodes standard Base64, accepting only one spelling of each value, as the server does.
@@ -118,10 +148,9 @@ public final class ManifestVerifier {
         guard let root = parsed as? [String: Any] else {
             throw invalid("Manifest is not a JSON object")
         }
-        try requireOnlyFields(root, allowed: manifestFields)
-        guard try integerField(root, "version") == manifestVersion else {
-            throw invalid("Unknown manifest version")
-        }
+        let version = try integerField(root, "version")
+        guard version == 1 || version == 2 else { throw invalid("Unknown manifest version") }
+        try requireOnlyFields(root, allowed: version == 1 ? zipManifestFields : filesManifestFields)
 
         let releaseId = try stringField(root, "releaseId")
         // Later used as a folder name, so it must be exactly a UUID.
@@ -135,6 +164,23 @@ public final class ManifestVerifier {
         }
         _ = try stringField(root, "binaryVersion")
 
+        // A valid signature for another deployment, platform or runtime must not install here.
+        try requireMatch("deploymentKey", try stringField(root, "deploymentKey"), deploymentKey)
+        try requireMatch("platform", try stringField(root, "platform"), platform)
+        try requireMatch("runtimeVersion", try stringField(root, "runtimeVersion"), runtimeVersion)
+
+        if version == 2 {
+            let files = try fileList(root["files"])
+            return VerifiedManifest(
+                releaseId: releaseId,
+                sequence: sequence,
+                mandatory: mandatoryNumber.boolValue,
+                packageHash: "",
+                packageSize: files.reduce(0) { $0 + $1.size },
+                files: files
+            )
+        }
+
         guard let package = root["package"] as? [String: Any] else {
             throw invalid("package must be an object")
         }
@@ -144,11 +190,6 @@ public final class ManifestVerifier {
         let size = try integerField(package, "size")
         guard size > 0 else { throw invalid("package size must be positive") }
 
-        // A valid signature for another deployment, platform or runtime must not install here.
-        try requireMatch("deploymentKey", try stringField(root, "deploymentKey"), deploymentKey)
-        try requireMatch("platform", try stringField(root, "platform"), platform)
-        try requireMatch("runtimeVersion", try stringField(root, "runtimeVersion"), runtimeVersion)
-
         return VerifiedManifest(
             releaseId: releaseId,
             sequence: sequence,
@@ -158,6 +199,47 @@ public final class ManifestVerifier {
         )
     }
 
+    /// The same rules as a ZIP package, because each path is written to disk the same way.
+    /// Sorted by UTF-16 code units, as JavaScript sorts, so one set of files has one signed form.
+    private func fileList(_ value: Any?) throws -> [ManifestFile] {
+        guard let list = value as? [Any] else { throw invalid("files must be an array") }
+        if list.isEmpty || list.count > PackageRules.maxEntries {
+            throw invalid("A package must have from 1 to \(PackageRules.maxEntries) files")
+        }
+        var files: [ManifestFile] = []
+        var seen = Set<String>()
+        var total: Int64 = 0
+        for item in list {
+            guard let entry = item as? [String: Any] else { throw invalid("Each file must be an object") }
+            try requireOnlyFields(entry, allowed: fileFields)
+            let path = try stringField(entry, "path")
+            if let problem = PackageRules.findPathProblem(path) {
+                throw invalid("The file \(path) \(problem)")
+            }
+            if let previous = files.last, !Array(previous.path.utf16).lexicographicallyPrecedes(path.utf16) {
+                throw invalid("The files must be sorted by path, each path once")
+            }
+            if !seen.insert(PackageRules.pathIdentity(path)).inserted {
+                throw invalid("The file \(path) differs from another only by letter case")
+            }
+            let hash = try stringField(entry, "hash")
+            guard matches(hash, hashPattern) else { throw invalid("The file \(path) has a malformed hash") }
+            let size = try integerField(entry, "size")
+            // Bounded before adding, because an overflow would stop the app.
+            guard size >= 0, size <= PackageRules.maxTotalSize else {
+                throw invalid("The file \(path) has an invalid size")
+            }
+            total += size
+            if total > PackageRules.maxTotalSize { throw invalid("The files are larger than the allowed total") }
+            files.append(ManifestFile(path: path, hash: hash, size: size))
+        }
+        guard let bundle = files.first(where: { $0.path == PackageRules.bundleFileName }) else {
+            throw invalid("The bundle file is missing")
+        }
+        if bundle.size == 0 { throw invalid("The bundle file is empty") }
+        return files
+    }
+
     private func matches(_ value: String, _ pattern: String) -> Bool {
         value.range(of: pattern, options: .regularExpression) != nil
     }