@revopush/react-native-code-push 2.6.0-rc.4 → 2.6.1

package/.claude/settings.local.json

@@ -3,7 +3,11 @@
     "allow": [
       "Bash(git:*)",
       "Bash(echo \"EXIT:$?\")",
-      "Bash(find:*)"
+      "Bash(find:*)",
+      "Bash(cd ios/CodePush)",
+      "Bash(grep -rln \"finalizePatchAndZip\\\\|DiffDownloadHandler\\\\|HDIFF\\\\|hpatch\\\\|createZipFileAtPath\\\\|bundleDiffBlob\" .)",
+      "Bash(grep -rln \"finalizePatchAndZip\\\\|DiffDownloadHandler\\\\|hpatch\\\\|HDIFF\\\\|createZipFileAtPath\" ios)",
+      "Bash(grep -v \".framework/DiffUpdates$\")"
     ]
   }
 }

package/android/build.gradle

@@ -43,12 +43,20 @@ android {
     lint {
         abortOnError = false
     }
+
+    testOptions {
+        unitTests.returnDefaultValues = true
+        unitTests.all {
+            testLogging { events "passed", "skipped", "failed" }
+        }
+    }
 }
 
 dependencies {
     if (boolProp("REACT_NATIVE_REVOPUSH_DEV_MODE", false)) {
         // for local dev only
         implementation("org.revopush:revopush-diff")
+        // @react-native/gradle-plugin in package.json must use this same version
         implementation 'com.facebook.react:react-android:0.79.6'
         // end of local dev only
     } else {
@@ -56,9 +64,12 @@ dependencies {
         // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
         //noinspection GradleDynamicVersion
 
-        implementation "org.revopush:revopush-diff:0.0.7"
+        implementation "org.revopush:revopush-diff:0.0.9"
         implementation "com.facebook.react:react-native:+"
     }
+
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'org.json:json:20231013'
 }
 
 def getExtOrIntegerDefault(name, defaultValue) {

package/android/codepush.gradle

@@ -5,7 +5,6 @@ import java.nio.file.Paths;
 def config = project.extensions.findByName("react") ?: [:]
 def bundleAssetName = config.bundleAssetName ? config.bundleAssetName.get() : "index.android.bundle"
 
-// because elvis operator
 def elvisFile(thing) {
     return thing ? file(thing) : null;
 }
@@ -18,30 +17,12 @@ void runBefore(String dependentTaskName, Task task) {
 }
 
 /**
- * Finds the path of the installed npm package with the given name using Node's
- * module resolution algorithm, which searches "node_modules" directories up to
- * the file system root. This handles various cases, including:
- *
- *   - Working in the open-source RN repo:
- *       Gradle: /path/to/react-native/ReactAndroid
- *       Node module: /path/to/react-native/node_modules/[package]
- *
- *   - Installing RN as a dependency of an app and searching for hoisted
- *     dependencies:
- *       Gradle: /path/to/app/node_modules/react-native/ReactAndroid
- *       Node module: /path/to/app/node_modules/[package]
- *
- *   - Working in a larger repo (e.g., Facebook) that contains RN:
- *       Gradle: /path/to/repo/path/to/react-native/ReactAndroid
- *       Node module: /path/to/repo/node_modules/[package]
- *
- * The search begins at the given base directory (a File object). The returned
- * path is a string.
+ * Resolves an installed npm package the way Node does: walk up from baseDir looking for
+ * node_modules/<packageName>. Covers app, hoisted and monorepo layouts alike.
  */
 static def findNodeModulePath(baseDir, packageName) {
     def basePath = baseDir.toPath().normalize()
-    // Node's module resolution algorithm searches up to the root directory,
-    // after which the base path will be null
+    // null once the walk passes the filesystem root
     while (basePath) {
         def candidatePath = Paths.get(basePath.toString(), "node_modules", packageName)
         if (candidatePath.toFile().exists()) {
@@ -56,7 +37,6 @@ gradle.projectsEvaluated {
     def debuggableVariants = config.debuggableVariants ? config.debuggableVariants.get() : ['debug']
 
     android.applicationVariants.all { variant ->
-        // No code push for debuggable variants
         if (debuggableVariants.contains(variant.name)) {
             return;
         }
@@ -75,11 +55,9 @@ gradle.projectsEvaluated {
         def resourcesDir;
         def jsBundleFile;
 
-        // Additional node commandline arguments
         def nodeExecutableAndArgs = config.nodeExecutableAndArgs ? config.nodeExecutableAndArgs.get() : ["node"]
         def extraPackagerArgs = config.extraPackagerArgs ? config.extraPackagerArgs.get() : []
 
-        // Make this task run right after the bundle task
         def generateBundledResourcesHash;
 
         def reactBundleTask = tasks.findByName("createBundle${targetName}JsAndAssets")
@@ -99,8 +77,6 @@ gradle.projectsEvaluated {
                     name: "generateBundledResourcesHash${targetName}",
                     type: Exec) {
                 commandLine(*nodeExecutableAndArgs, "${nodeModulesPath}/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir)
-
-                enabled !debuggableVariants.contains(variant.name) ?: targetName.toLowerCase().contains("release")
             }
 
             runBefore("merge${targetName}Resources", generateBundledResourcesHash)
@@ -114,9 +90,7 @@ gradle.projectsEvaluated {
             resourcesDir = elvisFile(config."${resourcesDirConfigName}") ? elvisFile(config."${resourcesDirConfigName}").get() :
                     file("$buildDir/intermediates/res/merged/${targetPath}")
 
-            // In case version of 'Android Plugin for Gradle'' is lower than 1.3.0
-            // '$buildDir' has slightly different structure - 'merged' folder
-            // does not exists so '${targetPath}' folder contains directly in 'res' folder.
+            // AGP below 1.3.0 had no 'merged' folder: res/${targetPath} directly.
             if (!resourcesDir.exists() && file("$buildDir/intermediates/res/${targetPath}").exists()) {
                 resourcesDir = file("$buildDir/intermediates/res/${targetPath}")
             }
@@ -131,7 +105,6 @@ gradle.projectsEvaluated {
                 commandLine(*nodeExecutableAndArgs, "${nodeModulesPath}/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir, resourcesMapTempFileName)
             }
 
-            // Make this task run right before the bundle task
             def recordFilesBeforeBundleCommand = tasks.create(
                     name: "recordFilesBeforeBundleCommand${targetName}",
                     type: Exec) {
@@ -142,7 +115,7 @@ gradle.projectsEvaluated {
             recordFilesBeforeBundleCommand.dependsOn("merge${targetName}Assets")
             runBefore("bundle${targetName}JsAndAssets", recordFilesBeforeBundleCommand)
 
-            // We need to generate and record the resources map, but we use it to generate the bundle hash
+            // the map recorded before bundling is the input to the hash
             generateBundledResourcesHash.dependsOn("recordFilesBeforeBundleCommand${targetName}")
         }
 
@@ -155,20 +128,24 @@ gradle.projectsEvaluated {
     }
 }
 
-project.extensions.findByName("androidComponents")?.finalizeDsl { extension ->
-    // This disables density-based APK splitting for the App Bundle
-    extension.bundle.density.enableSplit = false
+// withPlugin, not findByName: applying this script above the Android plugin would otherwise
+// silently ship an APK with no CODE_PUSH_APK_BUILD_TIME.
+project.pluginManager.withPlugin("com.android.application") {
+    project.extensions.getByName("androidComponents").finalizeDsl { extension ->
+        // One density bucket per device would make the build-time resources hash unreproducible.
+        extension.bundle.density.enableSplit = false
 
-    extension.androidResources.noCompress += "png"
+        extension.androidResources.noCompress.add("png")
 
-    extension.buildTypes.all { buildType ->
-        // disable PNG crunching for release builds to align APK resources with what Metro builds
-        if(!buildType.debuggable){
-            crunchPngs = false
-        }
+        extension.buildTypes.all { buildType ->
+            // crunching would change the bytes Metro already hashed
+            if (!buildType.debuggable) {
+                buildType.crunchPngs = false
+            }
 
-        // to prevent incorrect long value restoration from strings.xml we need to wrap it with double quotes
-        // https://github.com/microsoft/cordova-plugin-code-push/issues/264
-        buildType.resValue('string', "CODE_PUSH_APK_BUILD_TIME", String.format("\"%d\"", System.currentTimeMillis()))
+            // quoted, or the long is restored incorrectly from strings.xml
+            // https://github.com/microsoft/cordova-plugin-code-push/issues/264
+            buildType.resValue('string', "CODE_PUSH_APK_BUILD_TIME", String.format("\"%d\"", System.currentTimeMillis()))
+        }
     }
 }

package/android/gradle.properties

@@ -18,3 +18,5 @@
 # org.gradle.parallel=true
 
 #android.useDeprecatedNdk=true
+
+android.useAndroidX=true

package/android/settings.gradle

@@ -1,3 +1,5 @@
+// Only used when this directory is its own Gradle build root (standalone or monorepo).
+// Autolinked apps include it as a subproject, so their settings file is used instead.
 pluginManagement {
     repositories {
         mavenCentral()
@@ -10,22 +12,19 @@ pluginManagement {
         id("com.android.library") version "8.8.2" apply false
     }
 
-    // to satisfy apply plugin: "com.facebook.react" as a part of monorepo
-    def gradlePluginPath = getProperty("REACT_NATIVE_GRADLE_PLUGIN_PATH")
-    if (gradlePluginPath != null) {
+    // Inline, not via a helper: method calls inside pluginManagement {} bind to the block's
+    // delegate and never reach this script's own methods. Property access on `settings` does.
+    def gradlePluginPath = (settings.hasProperty("REACT_NATIVE_GRADLE_PLUGIN_PATH") ? settings["REACT_NATIVE_GRADLE_PLUGIN_PATH"] : null) ?: System.getenv("REACT_NATIVE_GRADLE_PLUGIN_PATH")
+    if (gradlePluginPath) {
         includeBuild(gradlePluginPath)
     }
 }
 
-def diffPath = getProperty("REACT_NATIVE_REVOPUSH_DIFF_PATH")
-if (diffPath != null) {
+def diffPath = (settings.hasProperty("REACT_NATIVE_REVOPUSH_DIFF_PATH") ? settings["REACT_NATIVE_REVOPUSH_DIFF_PATH"] : null) ?: System.getenv("REACT_NATIVE_REVOPUSH_DIFF_PATH")
+if (diffPath) {
     includeBuild(diffPath) {
         dependencySubstitution {
             substitute(module("org.revopush:revopush-diff")).using(project(":revopush-diff"))
         }
     }
 }
-
-def getProperty(propName) {
-    return settings[propName] ?: System.getenv(propName)
-}

package/android/src/main/java/com/microsoft/codepush/react/BaseBundleStore.java

@@ -0,0 +1,78 @@
+package com.microsoft.codepush.react;
+
+import static org.revopush.ota.utils.FileUtils.copyFileIfExists;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+
+/** Bundles kept as diff bases, named by the package hash of the release they came from. */
+public class BaseBundleStore {
+
+    public static final int MAX_SAVED_BASES = 3;
+
+    private final File mBasesDir;
+
+    public BaseBundleStore(String basesDirPath) {
+        mBasesDir = new File(basesDirPath);
+    }
+
+    public File lookup(String packageHash) {
+        if (!isValidEntryName(packageHash)) return null;
+        File file = new File(mBasesDir, packageHash);
+        return file.isFile() ? file : null;
+    }
+
+    /**
+     * Copies the bundle into the store, so it outlives its package folder. A hard link would
+     * be cheaper, but SELinux denies untrusted_app the link permission on its own files.
+     * Never fails an update.
+     */
+    public boolean save(File sourceBundle, String packageHash) {
+        if (sourceBundle == null || !sourceBundle.isFile()) return false;
+        if (!isValidEntryName(packageHash)) return false;
+
+        File dest = new File(mBasesDir, packageHash);
+        if (dest.isFile()) {
+            // Saving is the moment the base gets used, so this keeps evict() ordered by last use.
+            dest.setLastModified(System.currentTimeMillis());
+            return true;
+        }
+
+        // Copied aside and renamed: a copy cut short by process death must not leave a truncated
+        // file under the hash, which lookup() would hand out forever.
+        File temp = new File(mBasesDir, packageHash + ".tmp");
+        try {
+            if (!copyFileIfExists(sourceBundle, temp) || !temp.renameTo(dest)) {
+                FileUtils.deleteFileOrFolderSilently(temp);
+                return false;
+            }
+        } catch (IOException e) {
+            CodePushUtils.log("Could not save base bundle: " + e.getMessage());
+            FileUtils.deleteFileOrFolderSilently(temp);
+            return false;
+        }
+        evict();
+        return true;
+    }
+
+    /** The hash names a file directly inside the store, so it may not steer out of it. */
+    private static boolean isValidEntryName(String packageHash) {
+        return packageHash != null
+                && !packageHash.isEmpty()
+                && !packageHash.equals(".")
+                && !packageHash.equals("..")
+                && packageHash.indexOf('/') < 0
+                && packageHash.indexOf('\\') < 0;
+    }
+
+    /** Keeps the MAX_SAVED_BASES most recently used entries. */
+    private void evict() {
+        File[] files = mBasesDir.listFiles();
+        if (files == null || files.length <= MAX_SAVED_BASES) return;
+        Arrays.sort(files, (a, b) -> Long.compare(a.lastModified(), b.lastModified()));
+        for (int i = 0; i < files.length - MAX_SAVED_BASES; i++) {
+            FileUtils.deleteFileOrFolderSilently(files[i]);
+        }
+    }
+}

package/android/src/main/java/com/microsoft/codepush/react/CodePush.java

@@ -4,6 +4,7 @@ import android.content.Context;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.res.Resources;
+import android.os.Build;
 
 import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceManager;
@@ -83,11 +84,13 @@ public class CodePush implements ReactPackage {
         mSettingsManager = new SettingsManager(mContext);
         bundleMetadataManager = new NativeBundleManager(mContext);
 
-        if (sAppVersion == null) {
+        // Guarded per value: overrideAppVersion is documented to run before this constructor, and
+        // must not stop the build number from being read (and vice versa).
+        if (sAppVersion == null || sBuildNumber == null) {
             try {
                 PackageInfo pInfo = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
-                sAppVersion = pInfo.versionName;
-                sBuildNumber = String.valueOf(pInfo.versionCode);
+                if (sAppVersion == null) sAppVersion = pInfo.versionName;
+                if (sBuildNumber == null) sBuildNumber = String.valueOf(getVersionCode(pInfo));
             } catch (PackageManager.NameNotFoundException e) {
                 throw new CodePushUnknownException("Unable to get package info for " + mContext.getPackageName(), e);
             }
@@ -127,6 +130,14 @@ public class CodePush implements ReactPackage {
         mServerUrl = serverUrl;
     }
 
+    // versionCode is only the low half of the version code once versionCodeMajor is set.
+    private static long getVersionCode(PackageInfo packageInfo) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            return packageInfo.getLongVersionCode();
+        }
+        return packageInfo.versionCode;
+    }
+
     private String getPublicKeyByResourceDescriptor(int publicKeyResourceDescriptor) {
         String publicKey;
         try {

package/android/src/main/java/com/microsoft/codepush/react/CodePushConstants.java

@@ -18,6 +18,8 @@ public class CodePushConstants {
     public static final String ASSET_DOWNLOAD_URL_KEY = "assetDownloadUrl";
     public static final String BUNDLE_DOWNLOAD_URL_KEY = "bundleBlobUrl";
     public static final String BUNDLE_DIFF_DOWNLOAD_URL_KEY = "bundleDiffBlobUrl";
+    public static final String BASE_PACKAGE_KEY = "basePackage";
+    public static final String BASES_FOLDER_NAME = "bases";
 
     public static final String FAILED_UPDATES_KEY = "CODE_PUSH_FAILED_UPDATES";
     public static final String PACKAGE_FILE_NAME = BundleManager.PACKAGE_FILE_NAME;

package/android/src/main/java/com/microsoft/codepush/react/CodePushNativeModule.java

@@ -123,9 +123,9 @@ public class CodePushNativeModule extends BaseJavaModule {
 
     private boolean detectExpoEnvironment() {
         try {
-            Class.forName("expo.modules.ReactNativeHostWrapper");
+            Class.forName("expo.modules.ReactNativeHostWrapper", false, getClass().getClassLoader());
             return true;
-        } catch (ClassNotFoundException e) {
+        } catch (Throwable e) {
             return false;
         }
     }
@@ -217,7 +217,7 @@ public class CodePushNativeModule extends BaseJavaModule {
                 String latestJSBundleFile = mCodePush.getJSBundleFileInternal(mCodePush.getAssetsBundleFileName());
 
                 try {
-                    if (!mIsExpoApp && reactHost instanceof ReactHostImpl) {
+                    if (reactHost instanceof ReactHostImpl) {
                         ReactHostDelegate delegate = getReactHostDelegate((ReactHostImpl) reactHost);
                         if (delegate != null) {
                             // #2) Update the locally stored JS bundle file path

package/android/src/main/java/com/microsoft/codepush/react/CodePushUpdateManager.java

@@ -43,6 +43,10 @@ public class CodePushUpdateManager {
         return appendPathComponent(getCodePushPath(), CodePushConstants.UNZIPPED_FOLDER_NAME);
     }
 
+    private BaseBundleStore getBaseBundleStore() {
+        return new BaseBundleStore(appendPathComponent(getCodePushPath(), CodePushConstants.BASES_FOLDER_NAME));
+    }
+
     private String getDocumentsDirectory() {
         return mDocumentsDirectory;
     }
@@ -94,22 +98,22 @@ public class CodePushUpdateManager {
     }
 
     public String getCurrentPackageBundlePath(String bundleFileName) {
-        String packageFolder = getCurrentPackageFolderPath();
-        if (packageFolder == null) {
+        return getPackageBundlePath(getCurrentPackageHash(), bundleFileName);
+    }
+
+    private String getPackageBundlePath(String packageHash, String bundleFileName) {
+        if (packageHash == null) {
             return null;
         }
 
-        JSONObject currentPackage = getCurrentPackage();
-        if (currentPackage == null) {
+        JSONObject packageMetadata = getPackage(packageHash);
+        if (packageMetadata == null) {
             return null;
         }
 
-        String relativeBundlePath = currentPackage.optString(CodePushConstants.RELATIVE_BUNDLE_PATH_KEY, null);
-        if (relativeBundlePath == null) {
-            return appendPathComponent(packageFolder, bundleFileName);
-        } else {
-            return appendPathComponent(packageFolder, relativeBundlePath);
-        }
+        String relativeBundlePath = packageMetadata.optString(CodePushConstants.RELATIVE_BUNDLE_PATH_KEY, null);
+        return appendPathComponent(getPackageFolderPath(packageHash),
+                relativeBundlePath != null ? relativeBundlePath : bundleFileName);
     }
 
     public String getPackageFolderPath(String packageHash) {
@@ -154,7 +158,47 @@ public class CodePushUpdateManager {
         }
     }
 
+    /** A base bundle on disk, and the package hash it is stored under. */
+    private static final class BaseBundle {
+        final File file;
+        final String packageHash;
+
+        BaseBundle(File file, String packageHash) {
+            this.file = file;
+            this.packageHash = packageHash;
+        }
+    }
+
+    /** The base named by basePackage: the saved copy, else that package's own bundle. */
+    private BaseBundle findBaseBundle(JSONObject updatePackage, String expectedBundleFileName) {
+        JSONObject basePackage = updatePackage.optJSONObject(CodePushConstants.BASE_PACKAGE_KEY);
+        if (basePackage == null) {
+            return null;
+        }
+        String packageHash = basePackage.optString(CODE_PUSH_PACKAGE_HASH, null);
+        if (packageHash == null || packageHash.isEmpty()) {
+            // Named a base with no hash: server and SDK disagree on the field name.
+            CodePushUtils.log("basePackage has no packageHash; patching against the binary.");
+            return null;
+        }
+        File bundle = getBaseBundleStore().lookup(packageHash);
+        if (bundle == null) {
+            String bundlePath = getPackageBundlePath(packageHash, expectedBundleFileName);
+            bundle = bundlePath == null ? null : new File(bundlePath);
+        }
+        if (bundle == null || !bundle.isFile()) {
+            CodePushUtils.log("Base " + packageHash + " not held; patching against the binary.");
+            return null;
+        }
+        return new BaseBundle(bundle, packageHash);
+    }
+
     public void downloadPackage(JSONObject updatePackage, String expectedBundleFileName, DownloadProgressCallback progressCallback, String stringPublicKey) throws IOException {
+        BaseBundle base = findBaseBundle(updatePackage, expectedBundleFileName);
+        if (base != null) {
+            getBaseBundleStore().save(base.file, base.packageHash);
+        }
+
         UpdatePackage updatePack = fromJson(updatePackage);
 
         String newUpdateFolderPath = getPackageFolderPath(updatePack.getNewUpdateHash());
@@ -164,7 +208,8 @@ public class CodePushUpdateManager {
                 expectedBundleFileName, // exp bundle filename
                 stringPublicKey, // pub key
                 updatePack.getNewUpdateHash(), // new update hash
-                getCurrentPackage() // current package
+                getCurrentPackage(), // current package
+                base == null ? null : base.file.getAbsolutePath() // base bundle
         );
 
 

package/android/src/main/java/com/microsoft/codepush/react/FileUtils.java

@@ -27,11 +27,13 @@ public class FileUtils {
     public static void deleteFileOrFolderSilently(File file) {
         if (file.isDirectory()) {
             File[] files = file.listFiles();
-            for (File fileEntry : files) {
-                if (fileEntry.isDirectory()) {
-                    deleteFileOrFolderSilently(fileEntry);
-                } else {
-                    fileEntry.delete();
+            if (files != null) {
+                for (File fileEntry : files) {
+                    if (fileEntry.isDirectory()) {
+                        deleteFileOrFolderSilently(fileEntry);
+                    } else {
+                        fileEntry.delete();
+                    }
                 }
             }
         }

package/ios/CodePush/CodePush.h

@@ -136,6 +136,7 @@
                        error:(NSError **)error;
 
 + (NSString *)getPackageFolderPath:(NSString *)packageHash;
++ (NSString *)getCodePushPath;
 
 + (BOOL)installPackage:(NSDictionary *)updatePackage
    removePendingUpdate:(BOOL)removePendingUpdate
@@ -149,6 +150,19 @@
 
 @end
 
+/**
+ * Bundles kept as diff bases, named by the package hash of the release they came from.
+ * A base a package folder no longer holds is still findable here.
+ */
+@interface CodePushBaseBundleStore : NSObject
+
+/** Path of the retained bundle for this package hash, or nil if the store does not hold it. */
++ (NSString *)lookup:(NSString *)packageHash;
+
++ (BOOL)save:(NSString *)sourceBundlePath forPackageHash:(NSString *)packageHash;
+
+@end
+
 @interface CodePushTelemetryManager : NSObject
 
 + (NSDictionary *)getBinaryUpdateReport:(NSString *)appVersion;

package/ios/CodePush/CodePushBaseBundleStore.m

@@ -0,0 +1,104 @@
+#import "CodePush.h"
+
+// CPLog
+#import <DiffUpdates/DiffUpdates.h>
+
+@implementation CodePushBaseBundleStore
+
+static NSString *const BasesFolderName = @"bases";
+static const NSUInteger MaxSavedBases = 3;
+
++ (NSString *)lookup:(NSString *)packageHash
+{
+    NSString *path = [self pathForPackageHash:packageHash];
+    return path && [[NSFileManager defaultManager] fileExistsAtPath:path] ? path : nil;
+}
+
+/**
+ * Copies the bundle into the store so it outlives its package folder: installPackage deletes the
+ * previous package on every install, but the server can still name that release as a diff base.
+ * Never fails an update - a base we could not save is simply one we do not hold.
+ */
++ (BOOL)save:(NSString *)sourceBundlePath forPackageHash:(NSString *)packageHash
+{
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSString *destinationPath = [self pathForPackageHash:packageHash];
+    if (!destinationPath || ![fileManager fileExistsAtPath:sourceBundlePath]) {
+        return NO;
+    }
+
+    if ([fileManager fileExistsAtPath:destinationPath]) {
+        [self touch:destinationPath];
+        return YES;
+    }
+
+    // Copied aside and renamed: a copy cut short by process death must not leave a truncated file
+    // under the hash, which lookup would then hand out forever.
+    NSString *tempPath = [destinationPath stringByAppendingPathExtension:@"tmp"];
+    [fileManager removeItemAtPath:tempPath error:nil];
+
+    NSError *error = nil;
+    if (![fileManager createDirectoryAtPath:[self basesFolderPath] withIntermediateDirectories:YES attributes:nil error:&error]
+            || ![fileManager copyItemAtPath:sourceBundlePath toPath:tempPath error:&error]
+            || ![fileManager moveItemAtPath:tempPath toPath:destinationPath error:&error]) {
+        CPLog(@"Could not save base bundle %@: %@", packageHash, error);
+        [fileManager removeItemAtPath:tempPath error:nil];
+        return NO;
+    }
+
+    [self touch:destinationPath];
+    [self evict];
+    return YES;
+}
+
++ (NSString *)basesFolderPath
+{
+    return [[CodePushPackage getCodePushPath] stringByAppendingPathComponent:BasesFolderName];
+}
+
+/** An entry is named by its hash alone, so a hash naming anything else is refused. */
++ (NSString *)pathForPackageHash:(NSString *)packageHash
+{
+    if (packageHash.length == 0
+            || [packageHash isEqualToString:@".."]
+            || ![packageHash isEqualToString:packageHash.lastPathComponent]) {
+        return nil;
+    }
+
+    return [[self basesFolderPath] stringByAppendingPathComponent:packageHash];
+}
+
+// A copy keeps the source's timestamp and reuse has to count as use, so the store stamps every
+// save itself. evict orders by this.
++ (void)touch:(NSString *)path
+{
+    [[NSFileManager defaultManager] setAttributes:@{NSFileModificationDate: [NSDate date]}
+                                     ofItemAtPath:path
+                                            error:nil];
+}
+
+/** Keeps the MaxSavedBases most recently saved entries. */
++ (void)evict
+{
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSArray<NSURL *> *entries = [fileManager contentsOfDirectoryAtURL:[NSURL fileURLWithPath:[self basesFolderPath]]
+                                          includingPropertiesForKeys:@[NSURLContentModificationDateKey]
+                                                             options:0
+                                                               error:nil];
+    if (entries.count <= MaxSavedBases) {
+        return;
+    }
+
+    NSArray<NSURL *> *oldestFirst = [entries sortedArrayUsingComparator:^(NSURL *a, NSURL *b) {
+        NSDate *dateA = nil, *dateB = nil;
+        [a getResourceValue:&dateA forKey:NSURLContentModificationDateKey error:nil];
+        [b getResourceValue:&dateB forKey:NSURLContentModificationDateKey error:nil];
+        return [dateA compare:dateB];
+    }];
+
+    for (NSUInteger i = 0; i < oldestFirst.count - MaxSavedBases; i++) {
+        [fileManager removeItemAtURL:oldestFirst[i] error:nil];
+    }
+}
+
+@end