@bravemobile/react-native-code-push 13.1.0 → 13.3.0

package/README.md

@@ -394,7 +394,18 @@ module.exports = Config;
   - Modifying an existing release history with the `update-history` command.
 
 
-**(2) For `code-push.config.ts` (TypeScript) to work properly, you may need to update your `tsconfig.json`.**
+**(2) A `code-push.config.ts` (TypeScript) file needs a loader installed.**
+
+Install `tsx`, which requires no further setup:
+
+```bash
+npm install --save-dev tsx
+```
+
+`ts-node` also keeps working, and is used when `tsx` is not installed. Note that `ts-node` is no
+longer maintained, so support for it is **deprecated and will be removed in a future major
+version** — please migrate to `tsx`. Until then, `ts-node` needs the following `tsconfig.json`
+setup:
 
 ```diff
   {
@@ -414,6 +425,8 @@ module.exports = Config;
 
 ```
 
+A `code-push.config.js` (JavaScript) file needs neither.
+
 
 ### 6. Diff Updates (Optional)
 
@@ -488,6 +501,8 @@ npx code-push release --framework expo --binary-version 1.0.0 --app-version 1.0.
 > `--app-version` should be greater than `--binary-version` (SemVer comparison).
 
 - `--rollout`: The rollout percentage for the update. (0~100, inclusive)
+- `--minimum-background-duration`: The number of seconds the app must have been in the background before this update is applied on resume, for `ON_NEXT_RESUME` and `ON_NEXT_SUSPEND` installs only. (whole seconds, 0 or greater)
+  - The value set on the release takes precedence over the `minimumBackgroundDuration` passed to `sync`, and `0` applies the update on the next resume.
 
 #### `update-history`
 
@@ -496,6 +511,8 @@ Update the release history for a specific CodePush update.
 - Use the `--mandatory` option to make the update as mandatory or optional.
 - Use the `--rollout` option to change the rollout percentage of the update. (0~100, inclusive)
   - If the rollout percentage is reduced, users who fall outside the new target will have their rollout canceled and rollback to the previous latest version.
+- Use the `--minimum-background-duration` option to change how many seconds the app must have been in the background before the update is applied on resume, for `ON_NEXT_RESUME` and `ON_NEXT_SUSPEND` installs only. (whole seconds, 0 or greater)
+  - It can be lowered after a release has gone out - setting it to `0`, for example, applies the update on the next resume instead of waiting.
 
 **Example:**
 - Rollback the CodePush update `1.0.1` (targeting the binary app version `1.0.0`).

package/android/app/proguard-rules.pro

@@ -21,10 +21,6 @@
     private final ** mBundleLoader;
 }
 # bridgeless
--keepclassmembers class com.facebook.react.defaults.DefaultReactHostDelegate {
-    private ** jsBundleLoader;
-}
-# bridgeless
 -keepclassmembers class * extends com.facebook.react.runtime.ReactHostDelegate {
     private ** jsBundleLoader;
     private ** _jsBundleLoader;
@@ -35,9 +31,6 @@
     private final ** reactHostDelegate; # RN 0.81+
 }
 
-# Can't find referenced class org.bouncycastle.**
--dontwarn com.nimbusds.jose.**
-
 # The binary patch applier is found by name from the native library.
 -keepclasseswithmembernames class com.microsoft.codepush.react.HDiffPatchNative {
     native <methods>;

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

@@ -51,6 +51,9 @@ public class CodePush extends TurboReactPackage {
         return mServerUrl;
     }
 
+    /**
+     * Entry point used by React Native autolinking to create and retain the package instance.
+     */
     public static synchronized CodePush getInstance(Context context, boolean isDebugMode) {
         if (mCurrentInstance == null) {
             mCurrentInstance = new CodePush(context, isDebugMode);

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

@@ -59,6 +59,15 @@ public class CodePushNativeModule extends NativeCodePushSpec {
     private  boolean _restartInProgress = false;
     private  ArrayList<Boolean> _restartQueue = new ArrayList<>();
 
+    /**
+     * Whether the React Native instance this module was created for is still the one running.
+     *
+     * A reload replaces the instance while work this module started can still be in flight,
+     * and a frame callback posted to the process-wide choreographer outlives the executor
+     * this module shuts down. Read from whichever thread that work is on, so it is volatile.
+     */
+    private volatile boolean mGenerationAlive = true;
+
     public CodePushNativeModule(ReactApplicationContext reactContext, CodePush codePush, CodePushUpdateManager codePushUpdateManager, CodePushTelemetryManager codePushTelemetryManager, SettingsManager settingsManager) {
         super(reactContext);
 
@@ -85,6 +94,7 @@ public class CodePushNativeModule extends NativeCodePushSpec {
 
     @Override
     public void invalidate() {
+        mGenerationAlive = false;
         clearLifecycleEventListener();
         mBackgroundExecutor.shutdownNow();
         super.invalidate();
@@ -264,6 +274,14 @@ public class CodePushNativeModule extends NativeCodePushSpec {
     }
 
     private void emitDownloadProgressEvent(DownloadProgress downloadProgress) {
+        // Every progress event arrives here, including the ones a frame callback delivers
+        // after this module was invalidated: shutting the executor down does not cancel a
+        // callback already posted to the choreographer, and the context it would emit
+        // through has been destroyed by then.
+        if (!mGenerationAlive) {
+            return;
+        }
+
         if (mEventEmitterCallback != null) {
             emitOnDownloadProgress(downloadProgress.createWritableMap());
             return;
@@ -275,6 +293,13 @@ public class CodePushNativeModule extends NativeCodePushSpec {
     }
 
     private void restartAppInternal(boolean onlyIfUpdateIsPending) {
+        // A restart requested by an instance that has been replaced would reload the one
+        // that replaced it, which nobody asked for.
+        if (!mGenerationAlive) {
+            CodePushUtils.log("Ignoring a restart requested by a React Native instance that is no longer running");
+            return;
+        }
+
         if (this._restartInProgress) {
             CodePushUtils.log("Restart request queued until the current restart is completed");
             this._restartQueue.add(onlyIfUpdateIsPending);

package/cli/commands/createHistoryCommand/createReleaseHistory.test.ts

@@ -96,8 +96,8 @@ describe("staging the release history a config is handed", () => {
         };
 
         await Promise.all([
-            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "ios", "RN0840", undefined, false, undefined),
-            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "android", "RN0840", undefined, false, undefined),
+            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "ios", "RN0840", undefined, false, undefined, undefined),
+            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "android", "RN0840", undefined, false, undefined, undefined),
         ]);
 
         expect(staged.ios).toContain("ios-url");

package/cli/commands/releaseCommand/addToReleaseHistory.ts

@@ -15,6 +15,7 @@ export async function addToReleaseHistory(
     enable: boolean,
     rollout: number | undefined,
     diffPackages: Record<string, string> | undefined,
+    minimumBackgroundDuration: number | undefined,
 ): Promise<void> {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
 
@@ -49,6 +50,11 @@ export async function addToReleaseHistory(
         newReleaseHistory[appVersion].rollout = rollout;
     }
 
+    // An entry without it leaves the wait to the sync option, so 0 has to be written.
+    if (typeof minimumBackgroundDuration === 'number') {
+        newReleaseHistory[appVersion].minimumBackgroundDuration = minimumBackgroundDuration;
+    }
+
     try {
         await stageReleaseHistoryFile(binaryVersion, newReleaseHistory, platform, (jsonFilePath) =>
             setReleaseHistory(binaryVersion, jsonFilePath, newReleaseHistory, platform, identifier));

package/cli/commands/releaseCommand/index.test.ts

@@ -32,6 +32,7 @@ const ARG_INDEX = {
     onOversizedPatch: 20,
     bundleDownloader: 21,
     diffBaseCount: 22,
+    minimumBackgroundDuration: 23,
 } as const;
 
 /**
@@ -147,4 +148,32 @@ describe("release command options", () => {
         const { release } = await import("./release.js");
         expect(jest.mocked(release)).not.toHaveBeenCalled();
     });
+
+    it("passes the chosen minimum background duration through to the release", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1', '--minimum-background-duration', '600']);
+
+        expect(args[ARG_INDEX.minimumBackgroundDuration]).toBe(600);
+    });
+
+    it("leaves the minimum background duration unset when the option is not given, so the sync option decides", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1']);
+
+        expect(args[ARG_INDEX.minimumBackgroundDuration]).toBeUndefined();
+    });
+
+    it.each([
+        ['is negative', '-1'],
+        ['is not a number at all', 'soon'],
+    ])("rejects a minimum background duration that %s", async (_caseName, value) => {
+        jest.spyOn(console, 'error').mockImplementation(() => {});
+        jest.spyOn(process, 'exit').mockImplementation(((code?: number) => {
+            throw new Error(`process.exit(${code})`);
+        }) as never);
+
+        await expect(parseReleaseCommand(['-b', '1.0.0', '-v', '1.0.1', '--minimum-background-duration', value]))
+            .rejects.toThrow('process.exit(1)');
+
+        const { release } = await import("./release.js");
+        expect(jest.mocked(release)).not.toHaveBeenCalled();
+    });
 });

package/cli/commands/releaseCommand/index.ts

@@ -31,6 +31,7 @@ type Options = {
     binaryBundlePath?: string;
     onOversizedPatch: OversizedPatchPolicy;
     diffBaseCount: number;
+    minimumBackgroundDuration?: number;
 }
 
 program.command('release')
@@ -57,6 +58,7 @@ program.command('release')
         .choices(OVERSIZED_PATCH_POLICIES)
         .default(DEFAULT_OVERSIZED_PATCH_POLICY))
     .option('--diff-base-count <number>', 'how many recent releases to build asset diff archives against (0 disables). Requires `bundleDownloader` in the config file.', parseDecimalInt, DEFAULT_DIFF_BASE_COUNT)
+    .option('--minimum-background-duration <seconds>', 'seconds the app must have been in the background before this update is applied on resume. Overrides the minimumBackgroundDuration sync option.', parseDecimalInt)
     .action(async (options: Options) => {
         const config = findAndReadConfigFile(process.cwd(), options.config);
 
@@ -70,6 +72,12 @@ program.command('release')
             process.exit(1);
         }
 
+        if (options.minimumBackgroundDuration !== undefined
+            && (!Number.isInteger(options.minimumBackgroundDuration) || options.minimumBackgroundDuration < 0)) {
+            console.error('--minimum-background-duration must be a whole number of seconds, 0 or greater.');
+            process.exit(1);
+        }
+
         if (options.hashCalc && !options.skipBundle) {
             console.error('--hash-calc option can be used only when --skip-bundle is set to true.');
             process.exit(1);
@@ -102,6 +110,7 @@ program.command('release')
             options.onOversizedPatch,
             config.bundleDownloader,
             options.diffBaseCount,
+            options.minimumBackgroundDuration,
         )
 
         console.log('🚀 Release completed.')

package/cli/commands/releaseCommand/release.test.ts

@@ -142,6 +142,7 @@ type ReleaseOverrides = {
     releaseHistory?: ReleaseHistoryInterface;
     bundleDownloader?: CliConfigInterface['bundleDownloader'];
     diffBaseCount?: number;
+    minimumBackgroundDuration?: number;
 };
 
 async function runRelease(staged: StagedBundle, overrides: ReleaseOverrides = {}) {
@@ -176,6 +177,7 @@ async function runRelease(staged: StagedBundle, overrides: ReleaseOverrides = {}
         overrides.onOversizedPatch,
         overrides.bundleDownloader,
         overrides.diffBaseCount,
+        overrides.minimumBackgroundDuration,
     );
 
     return { uploads, releaseHistories: history.saved, uploadCountsWhenHistorySaved };
@@ -829,3 +831,29 @@ describe("release with asset diff bases", () => {
         expect(path.basename(uploads[0].filePath)).toBe(staged.bundleFileName);
     });
 });
+
+describe("release --minimum-background-duration", () => {
+    it("records the background wait on the release it publishes", async () => {
+        const staged = await stageBundleOutput("minimum-background-duration");
+
+        const { releaseHistories } = await runRelease(staged, { minimumBackgroundDuration: 600 });
+
+        expect(releaseHistories[0][APP_VERSION].minimumBackgroundDuration).toBe(600);
+    });
+
+    it("releases a background wait of zero seconds as zero, not as an unset option", async () => {
+        const staged = await stageBundleOutput("zero-minimum-background-duration");
+
+        const { releaseHistories } = await runRelease(staged, { minimumBackgroundDuration: 0 });
+
+        expect(releaseHistories[0][APP_VERSION].minimumBackgroundDuration).toBe(0);
+    });
+
+    it("leaves the release saying nothing about the background wait when the option is not given", async () => {
+        const staged = await stageBundleOutput("no-minimum-background-duration");
+
+        const { releaseHistories } = await runRelease(staged);
+
+        expect(releaseHistories[0][APP_VERSION]).not.toHaveProperty('minimumBackgroundDuration');
+    });
+});

package/cli/commands/releaseCommand/release.ts

@@ -49,6 +49,7 @@ export async function release(
     onOversizedPatch: OversizedPatchPolicy = DEFAULT_OVERSIZED_PATCH_POLICY,
     bundleDownloader?: CliConfigInterface['bundleDownloader'],
     diffBaseCount: number = DEFAULT_DIFF_BASE_COUNT,
+    minimumBackgroundDuration?: number,
 ): Promise<void> {
     if (baseBundlePath) {
         // Checked before the bundler runs, so the wrong base bundle costs a second rather
@@ -167,6 +168,7 @@ export async function release(
         enable,
         rollout,
         Object.keys(diffPackages).length > 0 ? diffPackages : undefined,
+        minimumBackgroundDuration,
     )
 
     if (!skipCleanup) {

package/cli/commands/updateHistoryCommand/index.test.ts

@@ -0,0 +1,129 @@
+import fs from "fs";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+import type { CliConfigInterface, ReleaseHistoryInterface } from "../../../typings/react-native-code-push.d.ts";
+
+/**
+ * Checks the command definition against the entry it saves. Everything this command does
+ * ends up in the release history the config is handed, so an option that never reaches it
+ * leaves the release exactly as it was - which the command still reports as a success.
+ */
+
+const BINARY_VERSION = '1.0.0';
+const APP_VERSION = '1.0.1';
+
+let mockConfig: CliConfigInterface;
+
+jest.mock("../../utils/fsUtils.js", () => ({
+    findAndReadConfigFile: () => mockConfig,
+}));
+
+/**
+ * Puts one released version in the config's history and records every history it is
+ * handed back, so a case can read the entry as the consumer would store it.
+ */
+function stageReleaseHistory(): ReleaseHistoryInterface[] {
+    const releaseHistory: ReleaseHistoryInterface = {
+        [APP_VERSION]: {
+            enabled: true,
+            mandatory: false,
+            downloadUrl: 'https://cdn.example.com/bundle',
+            packageHash: 'a3f1c0',
+        },
+    };
+    const saved: ReleaseHistoryInterface[] = [];
+
+    mockConfig = {
+        bundleUploader: async () => ({ downloadUrl: 'https://cdn.example.com/bundle' }),
+        getReleaseHistory: async () => releaseHistory,
+        // The command edits the history in place, so what it saved is copied out here.
+        setReleaseHistory: async (_binaryVersion, _jsonFilePath, releaseInfo) => {
+            saved.push(structuredClone(releaseInfo));
+        },
+    };
+
+    return saved;
+}
+
+/**
+ * Parses an `update-history` invocation against the real command definition. Commander is
+ * asked to throw instead of exiting, and to keep its diagnostics to itself, so a rejected
+ * option can be asserted on without ending the worker or the output.
+ */
+async function parseUpdateHistoryCommand(args: string[]): Promise<void> {
+    const { program } = await import("commander");
+    await import("./index.js");
+
+    const updateHistoryCommand = program.commands.find((command) => command.name() === 'update-history');
+    updateHistoryCommand?.exitOverride();
+    updateHistoryCommand?.configureOutput({ writeErr: () => {} });
+
+    await program.parseAsync(['update-history', ...args], { from: 'user' });
+}
+
+async function runUpdateHistoryCommand(args: string[]): Promise<void> {
+    await parseUpdateHistoryCommand(['-b', BINARY_VERSION, '-v', APP_VERSION, ...args]);
+}
+
+let saved: ReleaseHistoryInterface[];
+
+beforeEach(() => {
+    jest.resetModules();
+    saved = stageReleaseHistory();
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    jest.spyOn(process, 'exit').mockImplementation(((code?: number) => {
+        throw new Error(`process.exit(${code})`);
+    }) as never);
+});
+
+afterEach(() => {
+    jest.restoreAllMocks();
+    // The command writes its JSON under the directory it was invoked in.
+    fs.rmSync(path.resolve(process.cwd(), "codepush-release-history"), { recursive: true, force: true });
+});
+
+describe("update-history command options", () => {
+    it("lowers the background wait of a release that is already out to zero seconds", async () => {
+        await runUpdateHistoryCommand(['--minimum-background-duration', '0']);
+
+        expect(saved).toHaveLength(1);
+        expect(saved[0][APP_VERSION].minimumBackgroundDuration).toBe(0);
+    });
+
+    it("leaves the entry saying nothing about the background wait when only --enable is given", async () => {
+        await runUpdateHistoryCommand(['--enable', 'false']);
+
+        expect(saved[0][APP_VERSION].enabled).toBe(false);
+        expect(saved[0][APP_VERSION]).not.toHaveProperty('minimumBackgroundDuration');
+    });
+
+    it("saves the rollout percentage when --rollout is the only option given", async () => {
+        await runUpdateHistoryCommand(['--rollout', '50']);
+
+        expect(saved[0][APP_VERSION].rollout).toBe(50);
+    });
+
+    it("exits without saving anything when no option says what to change", async () => {
+        await expect(runUpdateHistoryCommand([])).rejects.toThrow('process.exit(1)');
+
+        expect(saved).toHaveLength(0);
+    });
+
+    it("rejects a negative background wait and saves nothing", async () => {
+        await expect(runUpdateHistoryCommand(['--minimum-background-duration', '-1']))
+            .rejects.toThrow('process.exit(1)');
+
+        expect(saved).toHaveLength(0);
+    });
+
+    it.each([
+        ['a percentage above 100', '150'],
+        ['a percentage that is not a number', 'abc'],
+    ])("rejects %s and saves nothing", async (_scenario, rollout) => {
+        await expect(runUpdateHistoryCommand(['--rollout', rollout]))
+            .rejects.toThrow('process.exit(1)');
+
+        expect(saved).toHaveLength(0);
+    });
+});

package/cli/commands/updateHistoryCommand/index.ts

@@ -12,6 +12,7 @@ type Options = {
     mandatory?: boolean;
     enable?: boolean;
     rollout?: number;
+    minimumBackgroundDuration?: number;
 }
 
 program.command('update-history')
@@ -24,14 +25,32 @@ program.command('update-history')
     .option('-m, --mandatory <bool>', 'make the release to be mandatory', parseBoolean, undefined)
     .option('-e, --enable <bool>', 'make the release to be enabled', parseBoolean, undefined)
     .option('--rollout <number>', 'rollout percentage (0-100)', parseFloat, undefined)
+    .option('--minimum-background-duration <seconds>', 'seconds the app must have been in the background before this update is applied on resume. Overrides the minimumBackgroundDuration sync option.', parseDecimalInt, undefined)
     .action(async (options: Options) => {
         const config = findAndReadConfigFile(process.cwd(), options.config);
 
-        if (typeof options.mandatory !== "boolean" && typeof options.enable !== "boolean") {
+        if (typeof options.mandatory !== "boolean"
+            && typeof options.enable !== "boolean"
+            && typeof options.rollout !== "number"
+            && typeof options.minimumBackgroundDuration !== "number") {
             console.error('No options specified. Exiting the program.')
             process.exit(1)
         }
 
+        // `Number.isFinite` is what rejects a non-numeric `--rollout`: `parseFloat` turns it into
+        // NaN, and both `NaN < 0` and `NaN > 100` are false.
+        if (options.rollout !== undefined
+            && (!Number.isFinite(options.rollout) || options.rollout < 0 || options.rollout > 100)) {
+            console.error('Rollout percentage number must be between 0 and 100 (inclusive).');
+            process.exit(1);
+        }
+
+        if (options.minimumBackgroundDuration !== undefined
+            && (!Number.isInteger(options.minimumBackgroundDuration) || options.minimumBackgroundDuration < 0)) {
+            console.error('--minimum-background-duration must be a whole number of seconds, 0 or greater.');
+            process.exit(1);
+        }
+
         await updateReleaseHistory(
             options.appVersion,
             options.binaryVersion,
@@ -41,10 +60,17 @@ program.command('update-history')
             options.identifier,
             options.mandatory,
             options.enable,
-            options.rollout
+            options.rollout,
+            options.minimumBackgroundDuration
         )
     });
 
+// Not `parseInt` itself: commander hands a coercion function the current value as its
+// second argument, which `parseInt` reads as the radix.
+function parseDecimalInt(value: string): number {
+    return parseInt(value, 10);
+}
+
 function parseBoolean(value: string) {
     if (value === 'true') return true;
     if (value === 'false') return false;

package/cli/commands/updateHistoryCommand/updateReleaseHistory.ts

@@ -11,6 +11,7 @@ export async function updateReleaseHistory(
     mandatory: boolean | undefined,
     enable: boolean | undefined,
     rollout: number | undefined,
+    minimumBackgroundDuration: number | undefined,
 ): Promise<void> {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
 
@@ -20,6 +21,8 @@ export async function updateReleaseHistory(
     if (typeof mandatory === "boolean") updateInfo.mandatory = mandatory;
     if (typeof enable === "boolean") updateInfo.enabled = enable;
     if (typeof rollout === "number") updateInfo.rollout = rollout;
+    // 0 is what lowers the wait to "apply on the next resume", so truthiness cannot decide here.
+    if (typeof minimumBackgroundDuration === "number") updateInfo.minimumBackgroundDuration = minimumBackgroundDuration;
 
     try {
         await stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, (jsonFilePath) =>

package/cli/dist/commands/createHistoryCommand/createReleaseHistory.test.js

@@ -68,8 +68,8 @@ describe("staging the release history a config is handed", () => {
             staged[platform] = fs.readFileSync(jsonFilePath, "utf8");
         };
         await Promise.all([
-            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "ios", "RN0840", undefined, false, undefined),
-            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "android", "RN0840", undefined, false, undefined),
+            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "ios", "RN0840", undefined, false, undefined, undefined),
+            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "android", "RN0840", undefined, false, undefined, undefined),
         ]);
         expect(staged.ios).toContain("ios-url");
         expect(staged.ios).not.toContain("android-url");

package/cli/dist/commands/releaseCommand/addToReleaseHistory.js

@@ -1,5 +1,5 @@
 import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
-export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownloadUrl, binaryPatchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout, diffPackages) {
+export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownloadUrl, binaryPatchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout, diffPackages, minimumBackgroundDuration) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
     if (updateInfo) {
@@ -26,6 +26,10 @@ export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownl
     if (typeof rollout === 'number') {
         newReleaseHistory[appVersion].rollout = rollout;
     }
+    // An entry without it leaves the wait to the sync option, so 0 has to be written.
+    if (typeof minimumBackgroundDuration === 'number') {
+        newReleaseHistory[appVersion].minimumBackgroundDuration = minimumBackgroundDuration;
+    }
     try {
         await stageReleaseHistoryFile(binaryVersion, newReleaseHistory, platform, (jsonFilePath) => setReleaseHistory(binaryVersion, jsonFilePath, newReleaseHistory, platform, identifier));
     }

package/cli/dist/commands/releaseCommand/index.js

@@ -27,6 +27,7 @@ program.command('release')
     .choices(OVERSIZED_PATCH_POLICIES)
     .default(DEFAULT_OVERSIZED_PATCH_POLICY))
     .option('--diff-base-count <number>', 'how many recent releases to build asset diff archives against (0 disables). Requires `bundleDownloader` in the config file.', parseDecimalInt, DEFAULT_DIFF_BASE_COUNT)
+    .option('--minimum-background-duration <seconds>', 'seconds the app must have been in the background before this update is applied on resume. Overrides the minimumBackgroundDuration sync option.', parseDecimalInt)
     .action(async (options) => {
     const config = findAndReadConfigFile(process.cwd(), options.config);
     if (typeof options.rollout === 'number' && (options.rollout < 0 || options.rollout > 100)) {
@@ -37,13 +38,18 @@ program.command('release')
         console.error('--diff-base-count must be a whole number of releases, 0 or greater.');
         process.exit(1);
     }
+    if (options.minimumBackgroundDuration !== undefined
+        && (!Number.isInteger(options.minimumBackgroundDuration) || options.minimumBackgroundDuration < 0)) {
+        console.error('--minimum-background-duration must be a whole number of seconds, 0 or greater.');
+        process.exit(1);
+    }
     if (options.hashCalc && !options.skipBundle) {
         console.error('--hash-calc option can be used only when --skip-bundle is set to true.');
         process.exit(1);
     }
     // Resolved before bundling so a wrong path fails now rather than after a build.
     const baseBundlePath = resolveBinaryBundlePathOption(options.binaryBundlePath);
-    await release(config.bundleUploader, config.getReleaseHistory, config.setReleaseHistory, options.binaryVersion, options.appVersion, options.framework, options.platform, options.identifier, options.outputPath, options.entryFile, options.jsBundleName, options.mandatory, options.enable, options.rollout, options.skipBundle, options.skipCleanup, `${options.outputPath}/${options.outputBundleDir}`, options.outputMetroDir, options.hashCalc, baseBundlePath, options.onOversizedPatch, config.bundleDownloader, options.diffBaseCount);
+    await release(config.bundleUploader, config.getReleaseHistory, config.setReleaseHistory, options.binaryVersion, options.appVersion, options.framework, options.platform, options.identifier, options.outputPath, options.entryFile, options.jsBundleName, options.mandatory, options.enable, options.rollout, options.skipBundle, options.skipCleanup, `${options.outputPath}/${options.outputBundleDir}`, options.outputMetroDir, options.hashCalc, baseBundlePath, options.onOversizedPatch, config.bundleDownloader, options.diffBaseCount, options.minimumBackgroundDuration);
     console.log('🚀 Release completed.');
 });
 // Not `parseInt` itself: commander hands a coercion function the current value as its

package/cli/dist/commands/releaseCommand/index.test.js

@@ -29,6 +29,7 @@ const ARG_INDEX = {
     onOversizedPatch: 20,
     bundleDownloader: 21,
     diffBaseCount: 22,
+    minimumBackgroundDuration: 23,
 };
 /**
  * Parses a `release` invocation against the real command definition. Commander is asked
@@ -118,4 +119,25 @@ describe("release command options", () => {
         const { release } = await import("./release.js");
         expect(jest.mocked(release)).not.toHaveBeenCalled();
     });
+    it("passes the chosen minimum background duration through to the release", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1', '--minimum-background-duration', '600']);
+        expect(args[ARG_INDEX.minimumBackgroundDuration]).toBe(600);
+    });
+    it("leaves the minimum background duration unset when the option is not given, so the sync option decides", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1']);
+        expect(args[ARG_INDEX.minimumBackgroundDuration]).toBeUndefined();
+    });
+    it.each([
+        ['is negative', '-1'],
+        ['is not a number at all', 'soon'],
+    ])("rejects a minimum background duration that %s", async (_caseName, value) => {
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+        jest.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`process.exit(${code})`);
+        }));
+        await expect(parseReleaseCommand(['-b', '1.0.0', '-v', '1.0.1', '--minimum-background-duration', value]))
+            .rejects.toThrow('process.exit(1)');
+        const { release } = await import("./release.js");
+        expect(jest.mocked(release)).not.toHaveBeenCalled();
+    });
 });

package/cli/dist/commands/releaseCommand/release.js

@@ -9,7 +9,7 @@ import { resolveAssetDiffBases } from "../../functions/resolveAssetDiffBases.js"
 import { BINARY_PATCH_ARCHIVE_SUFFIX, BINARY_PATCH_BASE_RECORD_NAME, DEFAULT_OVERSIZED_PATCH_POLICY, extractCodePushBundleContents, formatBinaryPatchSummary, hashBundleFile, isPatchArchiveOversized, makeBinaryPatchBundle, readBinaryPatchBaseRecord, } from "../../functions/makeBinaryPatchBundle.js";
 /** How many of the most recent releases a release builds asset diff archives against. */
 export const DEFAULT_DIFF_BASE_COUNT = 3;
-export async function release(bundleUploader, getReleaseHistory, setReleaseHistory, binaryVersion, appVersion, framework, platform, identifier, outputPath, entryFile, jsBundleName, mandatory, enable, rollout, skipBundle, skipCleanup, bundleDirectory, outputMetroDir, hashCalc, baseBundlePath, onOversizedPatch = DEFAULT_OVERSIZED_PATCH_POLICY, bundleDownloader, diffBaseCount = DEFAULT_DIFF_BASE_COUNT) {
+export async function release(bundleUploader, getReleaseHistory, setReleaseHistory, binaryVersion, appVersion, framework, platform, identifier, outputPath, entryFile, jsBundleName, mandatory, enable, rollout, skipBundle, skipCleanup, bundleDirectory, outputMetroDir, hashCalc, baseBundlePath, onOversizedPatch = DEFAULT_OVERSIZED_PATCH_POLICY, bundleDownloader, diffBaseCount = DEFAULT_DIFF_BASE_COUNT, minimumBackgroundDuration) {
     if (baseBundlePath) {
         // Checked before the bundler runs, so the wrong base bundle costs a second rather
         // than a full build.
@@ -92,7 +92,7 @@ export async function release(bundleUploader, getReleaseHistory, setReleaseHisto
                 `(${error instanceof Error ? error.message : String(error)}).`);
         }
     }
-    await addToReleaseHistory(appVersion, binaryVersion, downloadUrl, patchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout, Object.keys(diffPackages).length > 0 ? diffPackages : undefined);
+    await addToReleaseHistory(appVersion, binaryVersion, downloadUrl, patchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout, Object.keys(diffPackages).length > 0 ? diffPackages : undefined, minimumBackgroundDuration);
     if (!skipCleanup) {
         cleanUpOutputs(outputPath);
     }