@bravemobile/react-native-code-push 13.1.0-beta.4 → 13.1.0-beta.6

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

@@ -0,0 +1,133 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { createReleaseHistory } from "./createReleaseHistory.js";
+import { updateReleaseHistory } from "../updateHistoryCommand/updateReleaseHistory.js";
+
+/**
+ * Covers where the release history is staged before the config is handed it.
+ *
+ * The config receives a path rather than the history itself, so the command has to put the
+ * file somewhere first. Two releases of one app for different platforms are the same binary
+ * version, so a staging path derived from that version alone is the same path for both, and
+ * they overwrite each other's contents before either has read its own.
+ */
+
+const BINARY_VERSION = "1.0.0";
+
+let workingDir: string;
+let previousCwd: string;
+
+beforeEach(() => {
+    previousCwd = process.cwd();
+    workingDir = fs.mkdtempSync(path.join(os.tmpdir(), "codepush-history-staging-"));
+    process.chdir(workingDir);
+});
+
+afterEach(() => {
+    process.chdir(previousCwd);
+    fs.rmSync(workingDir, { recursive: true, force: true });
+    jest.restoreAllMocks();
+});
+
+function stagedPath(platform: "ios" | "android"): string {
+    return path.join(workingDir, "codepush-release-history", platform, `${BINARY_VERSION}.json`);
+}
+
+/**
+ * Turns the command's own exit into a throw, so a staging failure fails the test instead
+ * of taking the worker down with it.
+ */
+function failOnExit(): void {
+    jest.spyOn(process, "exit").mockImplementation((code) => {
+        throw new Error(`the command exited with code ${String(code)}`);
+    });
+    jest.spyOn(console, "error").mockImplementation(() => undefined);
+    jest.spyOn(console, "log").mockImplementation(() => undefined);
+}
+
+describe("staging the release history a config is handed", () => {
+    it("gives each platform writing at the same time a file of its own", async () => {
+        failOnExit();
+
+        const staged: Record<string, { jsonFilePath: string; contents: string }> = {};
+        const setReleaseHistory = async (
+            _binaryVersion: string,
+            jsonFilePath: string,
+            _releaseInfo: unknown,
+            platform: "ios" | "android",
+        ): Promise<void> => {
+            // Yields once, which is all it takes for the other platform to reach its own
+            // write and its own clean-up while this one still holds only a path.
+            await Promise.resolve();
+            staged[platform] = { jsonFilePath, contents: fs.readFileSync(jsonFilePath, "utf8") };
+        };
+
+        await Promise.all([
+            createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840"),
+            createReleaseHistory(BINARY_VERSION, setReleaseHistory, "android", "RN0840"),
+        ]);
+
+        expect(staged.ios.jsonFilePath).not.toBe(staged.android.jsonFilePath);
+    });
+
+    it("hands each platform the history that platform released", async () => {
+        failOnExit();
+
+        const released: Record<string, string> = {
+            ios: JSON.stringify({ [BINARY_VERSION]: { enabled: true, mandatory: false, downloadUrl: "", packageHash: "" }, "1.0.1": { enabled: true, mandatory: true, downloadUrl: "ios-url", packageHash: "ios-hash" } }),
+            android: JSON.stringify({ [BINARY_VERSION]: { enabled: true, mandatory: false, downloadUrl: "", packageHash: "" }, "1.0.1": { enabled: true, mandatory: true, downloadUrl: "android-url", packageHash: "android-hash" } }),
+        };
+
+        const staged: Record<string, string> = {};
+        const getReleaseHistory = async (
+            _binaryVersion: string,
+            platform: "ios" | "android",
+        ) => JSON.parse(released[platform]);
+        const setReleaseHistory = async (
+            _binaryVersion: string,
+            jsonFilePath: string,
+            _releaseInfo: unknown,
+            platform: "ios" | "android",
+        ): Promise<void> => {
+            await Promise.resolve();
+            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),
+        ]);
+
+        expect(staged.ios).toContain("ios-url");
+        expect(staged.ios).not.toContain("android-url");
+        expect(staged.android).toContain("android-url");
+        expect(staged.android).not.toContain("ios-url");
+    });
+
+    it("takes the file away once the config has stored the history", async () => {
+        failOnExit();
+
+        const setReleaseHistory = async (): Promise<void> => undefined;
+        await createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840");
+
+        expect(fs.existsSync(stagedPath("ios"))).toBe(false);
+    });
+
+    it("leaves the file behind when the config could not store the history", async () => {
+        failOnExit();
+
+        const setReleaseHistory = async (): Promise<void> => {
+            throw new Error("the storage backend rejected the history");
+        };
+
+        await expect(createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840")).rejects.toThrow(
+            "the command exited with code 1",
+        );
+
+        // What the release tried to store is worth reading back, so a failed release keeps
+        // its history at a path that is the same on every run.
+        expect(Object.keys(JSON.parse(fs.readFileSync(stagedPath("ios"), "utf8")))).toEqual([BINARY_VERSION]);
+    });
+});

package/cli/commands/createHistoryCommand/createReleaseHistory.ts

@@ -1,6 +1,5 @@
-import fs from "fs";
-import path from "path";
 import type { CliConfigInterface, ReleaseHistoryInterface, ReleaseInfo } from "../../../typings/react-native-code-push.d.ts";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 
 export async function createReleaseHistory(
     targetVersion: string,
@@ -20,15 +19,8 @@ export async function createReleaseHistory(
     };
 
     try {
-        const JSON_FILE_NAME = `${targetVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(INITIAL_HISTORY, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(INITIAL_HISTORY));
-
-        await setReleaseHistory(targetVersion, JSON_FILE_PATH, INITIAL_HISTORY, platform, identifier)
-
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(targetVersion, INITIAL_HISTORY, platform, (jsonFilePath) =>
+            setReleaseHistory(targetVersion, jsonFilePath, INITIAL_HISTORY, platform, identifier));
     } catch (error) {
         console.error('Error occurred while creating new history:', error);
         process.exit(1)

package/cli/commands/releaseCommand/addToReleaseHistory.ts

@@ -1,6 +1,5 @@
-import path from "path";
-import fs from "fs";
 import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 
 export async function addToReleaseHistory(
     appVersion: string,
@@ -51,15 +50,8 @@ export async function addToReleaseHistory(
     }
 
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(newReleaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(newReleaseHistory));
-
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, newReleaseHistory, platform, identifier)
-
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, newReleaseHistory, platform, (jsonFilePath) =>
+            setReleaseHistory(binaryVersion, jsonFilePath, newReleaseHistory, platform, identifier));
     } catch (error) {
         console.error('Error occurred while updating history:', error);
         process.exit(1)

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

@@ -206,9 +206,9 @@ beforeEach(() => {
 
 afterEach(() => {
     jest.restoreAllMocks();
-    // addToReleaseHistory writes its JSON next to the invocation, and only removes it
-    // when the history was stored successfully.
-    fs.rmSync(path.resolve(process.cwd(), `${BINARY_VERSION}.json`), { force: true });
+    // addToReleaseHistory writes its JSON under the directory it was invoked in, and only
+    // removes it when the history was stored successfully.
+    fs.rmSync(path.resolve(process.cwd(), "codepush-release-history"), { recursive: true, force: true });
 });
 
 describe("release without --binary-bundle-path", () => {

package/cli/commands/updateHistoryCommand/updateReleaseHistory.ts

@@ -1,6 +1,5 @@
-import fs from "fs";
-import path from "path";
 import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 
 export async function updateReleaseHistory(
     appVersion: string,
@@ -23,15 +22,8 @@ export async function updateReleaseHistory(
     if (typeof rollout === "number") updateInfo.rollout = rollout;
 
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(releaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
-
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier)
-
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, (jsonFilePath) =>
+            setReleaseHistory(binaryVersion, jsonFilePath, releaseHistory, platform, identifier));
     } catch (error) {
         console.error('Error occurred while updating history:', error);
         process.exit(1)

package/cli/dist/commands/buildPatchToolsCommand/buildPatchTools.js

@@ -0,0 +1,34 @@
+import { spawnSync } from "child_process";
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { TOOLS_DIR_ENV_NAME } from "../../utils/binaryPatch.js";
+/**
+ * Runs the build script with the install directory the caller chose.
+ *
+ * The script's output goes straight to the terminal: a first build clones and compiles
+ * HDiffPatch, which takes minutes, and a silent wait would look like a hang. So when the
+ * script fails, its own message has already been shown, and the error raised here only
+ * has to say that it did.
+ */
+export function buildPatchTools({ buildScriptPath, toolsDir, force }) {
+    const result = spawnSync(buildScriptPath, force ? ['--force'] : [], {
+        stdio: 'inherit',
+        env: { ...process.env, [TOOLS_DIR_ENV_NAME]: toolsDir },
+    });
+    if (result.error) {
+        throw new Error(`failed to run ${buildScriptPath}: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        const reason = result.status === null ? `signal ${result.signal}` : `exit code ${result.status}`;
+        throw new Error(`${path.basename(buildScriptPath)} failed with ${reason}`);
+    }
+}
+/**
+ * SHA-256 of the build script's bytes, for keying a CI cache of the installed tools. The
+ * script pins the sources and the build flags, so it changes whenever the tools it would
+ * build do.
+ */
+export function hashBuildScript(buildScriptPath) {
+    return crypto.createHash('sha256').update(fs.readFileSync(buildScriptPath)).digest('hex');
+}

package/cli/dist/commands/buildPatchToolsCommand/buildPatchTools.test.js

@@ -0,0 +1,88 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
+import { buildPatchTools, hashBuildScript } from "./buildPatchTools.js";
+/**
+ * The command is a thin wrapper around the build script this package ships. What it has
+ * to get right is what it hands the script: the directory the CLI will later look in, and
+ * `--force` when asked. A script that records what it was handed proves both without
+ * cloning and compiling HDiffPatch. The shipped script is run once at the end, against an
+ * install it already finds complete, to show the wrapper speaks its actual interface.
+ */
+const REPO_ROOT = path.resolve(__dirname, "..", "..", "..");
+const SHIPPED_BUILD_SCRIPT = path.join(REPO_ROOT, "scripts", "binary-patch", "build-hdiffpatch.sh");
+/** Where `jest.globalSetup.ts` built the tools for this run. */
+const INSTALLED_TOOLS_DIR = process.env.HDIFFPATCH_TOOLS_DIR || path.join(REPO_ROOT, ".hdiffpatch-tools");
+let workDir;
+beforeEach(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "build-patch-tools-"));
+});
+afterEach(() => {
+    fs.rmSync(workDir, { recursive: true, force: true });
+});
+function writeScript(body) {
+    const scriptPath = path.join(workDir, "build.sh");
+    fs.writeFileSync(scriptPath, `#!/bin/sh\n${body}\n`, { mode: 0o755 });
+    return scriptPath;
+}
+/** A script that writes the install directory it was given, then each argument, one per line. */
+function writeRecordingScript() {
+    return writeScript('printf \'%s\\n\' "$HDIFFPATCH_TOOLS_DIR" "$@" > "$HDIFFPATCH_TOOLS_DIR/invocation"');
+}
+function readInvocation(toolsDir) {
+    return fs.readFileSync(path.join(toolsDir, "invocation"), "utf8").trimEnd().split("\n");
+}
+describe("buildPatchTools", () => {
+    it("runs the build script against the tools directory it was given, without forcing a rebuild", () => {
+        const toolsDir = path.join(workDir, "tools");
+        fs.mkdirSync(toolsDir);
+        buildPatchTools({ buildScriptPath: writeRecordingScript(), toolsDir, force: false });
+        expect(readInvocation(toolsDir)).toEqual([toolsDir]);
+    });
+    it("asks the build script to rebuild when forced", () => {
+        const toolsDir = path.join(workDir, "tools");
+        fs.mkdirSync(toolsDir);
+        buildPatchTools({ buildScriptPath: writeRecordingScript(), toolsDir, force: true });
+        expect(readInvocation(toolsDir)).toEqual([toolsDir, "--force"]);
+    });
+    it("fails with the exit code when the build script fails", () => {
+        const buildScriptPath = writeScript("exit 3");
+        expect(() => buildPatchTools({ buildScriptPath, toolsDir: workDir, force: false })).toThrow(/exit code 3/);
+    });
+    it("fails naming the script when it cannot be started", () => {
+        const buildScriptPath = path.join(workDir, "no-such-script.sh");
+        expect(() => buildPatchTools({ buildScriptPath, toolsDir: workDir, force: false })).toThrow(/no-such-script\.sh/);
+    });
+    it("succeeds against an install the shipped script already finds complete", () => {
+        // Without an install the shipped script clones and compiles for minutes, and
+        // `spawnSync` holds the worker past any jest timeout. `jest.globalSetup.ts`
+        // provides the install; this says so when it did not.
+        const missing = ["hdiffz", "hpatchz"].filter((tool) => !fs.existsSync(path.join(INSTALLED_TOOLS_DIR, tool)));
+        if (missing.length > 0) {
+            throw new Error(`${missing.join(", ")} not installed in ${INSTALLED_TOOLS_DIR}: jest.globalSetup.ts should have built the tools first`);
+        }
+        expect(() => buildPatchTools({ buildScriptPath: SHIPPED_BUILD_SCRIPT, toolsDir: INSTALLED_TOOLS_DIR, force: false })).not.toThrow();
+    });
+});
+/**
+ * A CI cache of the installed tools is keyed by this hash, so it has to stay the same for as
+ * long as the script would build the same tools, and change as soon as it would not.
+ */
+describe("hashBuildScript", () => {
+    it("hashes two scripts with the same contents to the same hex digest", () => {
+        const first = path.join(workDir, "first.sh");
+        const second = path.join(workDir, "second.sh");
+        fs.writeFileSync(first, "#!/bin/sh\nHDIFFPATCH_TAG=v5.1.3\n");
+        fs.writeFileSync(second, "#!/bin/sh\nHDIFFPATCH_TAG=v5.1.3\n");
+        expect(hashBuildScript(first)).toBe(hashBuildScript(second));
+        expect(hashBuildScript(first)).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it("hashes a script whose pinned version changed to a different value", () => {
+        const before = path.join(workDir, "before.sh");
+        const after = path.join(workDir, "after.sh");
+        fs.writeFileSync(before, "#!/bin/sh\nHDIFFPATCH_TAG=v5.1.3\n");
+        fs.writeFileSync(after, "#!/bin/sh\nHDIFFPATCH_TAG=v5.1.4\n");
+        expect(hashBuildScript(after)).not.toBe(hashBuildScript(before));
+    });
+});

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

@@ -0,0 +1,32 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { program } from "commander";
+import { TOOLS_DIR_ENV_NAME, TOOLS_DIR_NAME } from "../../utils/binaryPatch.js";
+import { buildPatchTools, hashBuildScript } from "./buildPatchTools.js";
+/**
+ * The CLI runs compiled, from `cli/dist/commands/buildPatchToolsCommand/`, which puts the
+ * package root - and the script shipped under it - four levels up.
+ */
+const BUILD_SCRIPT_PATH = fileURLToPath(new URL("../../../../scripts/binary-patch/build-hdiffpatch.sh", import.meta.url));
+/**
+ * Installs where `release` will look: `HDIFFPATCH_TOOLS_DIR` when it is set, and otherwise
+ * a `.hdiffpatch-tools` directory in the working directory, the first place the lookup
+ * checks before walking up.
+ */
+const DEFAULT_TOOLS_DIR = process.env[TOOLS_DIR_ENV_NAME] || path.resolve(process.cwd(), TOOLS_DIR_NAME);
+program.command('build-patch-tools')
+    .description('Builds hdiffz and hpatchz from source and installs them where `release --binary-bundle-path` looks for them.\nThe build clones the pinned HDiffPatch sources, so it needs git, make, a C/C++ compiler and network access. It does nothing when the tools are already installed.')
+    .option('--tools-dir <path>', 'directory to install the tools into', DEFAULT_TOOLS_DIR)
+    .option('--force', 'rebuild even when the tools are already installed', false)
+    .option('--print-hash', 'print a hash of the build script, for keying a CI cache of the tools, and exit without building', false)
+    .action((options) => {
+    if (options.printHash) {
+        console.log(hashBuildScript(BUILD_SCRIPT_PATH));
+        return;
+    }
+    buildPatchTools({
+        buildScriptPath: BUILD_SCRIPT_PATH,
+        toolsDir: path.resolve(options.toolsDir),
+        force: options.force,
+    });
+});

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

@@ -1,5 +1,4 @@
-import fs from "fs";
-import path from "path";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function createReleaseHistory(targetVersion, setReleaseHistory, platform, identifier) {
     const BINARY_RELEASE = {
         enabled: true,
@@ -11,12 +10,7 @@ export async function createReleaseHistory(targetVersion, setReleaseHistory, pla
         [targetVersion]: BINARY_RELEASE
     };
     try {
-        const JSON_FILE_NAME = `${targetVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(INITIAL_HISTORY, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(INITIAL_HISTORY));
-        await setReleaseHistory(targetVersion, JSON_FILE_PATH, INITIAL_HISTORY, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(targetVersion, INITIAL_HISTORY, platform, (jsonFilePath) => setReleaseHistory(targetVersion, jsonFilePath, INITIAL_HISTORY, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while creating new history:', error);

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

@@ -0,0 +1,95 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { createReleaseHistory } from "./createReleaseHistory.js";
+import { updateReleaseHistory } from "../updateHistoryCommand/updateReleaseHistory.js";
+/**
+ * Covers where the release history is staged before the config is handed it.
+ *
+ * The config receives a path rather than the history itself, so the command has to put the
+ * file somewhere first. Two releases of one app for different platforms are the same binary
+ * version, so a staging path derived from that version alone is the same path for both, and
+ * they overwrite each other's contents before either has read its own.
+ */
+const BINARY_VERSION = "1.0.0";
+let workingDir;
+let previousCwd;
+beforeEach(() => {
+    previousCwd = process.cwd();
+    workingDir = fs.mkdtempSync(path.join(os.tmpdir(), "codepush-history-staging-"));
+    process.chdir(workingDir);
+});
+afterEach(() => {
+    process.chdir(previousCwd);
+    fs.rmSync(workingDir, { recursive: true, force: true });
+    jest.restoreAllMocks();
+});
+function stagedPath(platform) {
+    return path.join(workingDir, "codepush-release-history", platform, `${BINARY_VERSION}.json`);
+}
+/**
+ * Turns the command's own exit into a throw, so a staging failure fails the test instead
+ * of taking the worker down with it.
+ */
+function failOnExit() {
+    jest.spyOn(process, "exit").mockImplementation((code) => {
+        throw new Error(`the command exited with code ${String(code)}`);
+    });
+    jest.spyOn(console, "error").mockImplementation(() => undefined);
+    jest.spyOn(console, "log").mockImplementation(() => undefined);
+}
+describe("staging the release history a config is handed", () => {
+    it("gives each platform writing at the same time a file of its own", async () => {
+        failOnExit();
+        const staged = {};
+        const setReleaseHistory = async (_binaryVersion, jsonFilePath, _releaseInfo, platform) => {
+            // Yields once, which is all it takes for the other platform to reach its own
+            // write and its own clean-up while this one still holds only a path.
+            await Promise.resolve();
+            staged[platform] = { jsonFilePath, contents: fs.readFileSync(jsonFilePath, "utf8") };
+        };
+        await Promise.all([
+            createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840"),
+            createReleaseHistory(BINARY_VERSION, setReleaseHistory, "android", "RN0840"),
+        ]);
+        expect(staged.ios.jsonFilePath).not.toBe(staged.android.jsonFilePath);
+    });
+    it("hands each platform the history that platform released", async () => {
+        failOnExit();
+        const released = {
+            ios: JSON.stringify({ [BINARY_VERSION]: { enabled: true, mandatory: false, downloadUrl: "", packageHash: "" }, "1.0.1": { enabled: true, mandatory: true, downloadUrl: "ios-url", packageHash: "ios-hash" } }),
+            android: JSON.stringify({ [BINARY_VERSION]: { enabled: true, mandatory: false, downloadUrl: "", packageHash: "" }, "1.0.1": { enabled: true, mandatory: true, downloadUrl: "android-url", packageHash: "android-hash" } }),
+        };
+        const staged = {};
+        const getReleaseHistory = async (_binaryVersion, platform) => JSON.parse(released[platform]);
+        const setReleaseHistory = async (_binaryVersion, jsonFilePath, _releaseInfo, platform) => {
+            await Promise.resolve();
+            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),
+        ]);
+        expect(staged.ios).toContain("ios-url");
+        expect(staged.ios).not.toContain("android-url");
+        expect(staged.android).toContain("android-url");
+        expect(staged.android).not.toContain("ios-url");
+    });
+    it("takes the file away once the config has stored the history", async () => {
+        failOnExit();
+        const setReleaseHistory = async () => undefined;
+        await createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840");
+        expect(fs.existsSync(stagedPath("ios"))).toBe(false);
+    });
+    it("leaves the file behind when the config could not store the history", async () => {
+        failOnExit();
+        const setReleaseHistory = async () => {
+            throw new Error("the storage backend rejected the history");
+        };
+        await expect(createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840")).rejects.toThrow("the command exited with code 1");
+        // What the release tried to store is worth reading back, so a failed release keeps
+        // its history at a path that is the same on every run.
+        expect(Object.keys(JSON.parse(fs.readFileSync(stagedPath("ios"), "utf8")))).toEqual([BINARY_VERSION]);
+    });
+});

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

@@ -1,5 +1,4 @@
-import path from "path";
-import fs from "fs";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownloadUrl, binaryPatchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout, diffPackages) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
@@ -28,12 +27,7 @@ export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownl
         newReleaseHistory[appVersion].rollout = rollout;
     }
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(newReleaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(newReleaseHistory));
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, newReleaseHistory, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, newReleaseHistory, platform, (jsonFilePath) => setReleaseHistory(binaryVersion, jsonFilePath, newReleaseHistory, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while updating history:', error);

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

@@ -119,9 +119,9 @@ beforeEach(() => {
 });
 afterEach(() => {
     jest.restoreAllMocks();
-    // addToReleaseHistory writes its JSON next to the invocation, and only removes it
-    // when the history was stored successfully.
-    fs.rmSync(path.resolve(process.cwd(), `${BINARY_VERSION}.json`), { force: true });
+    // addToReleaseHistory writes its JSON under the directory it was invoked in, and only
+    // removes it when the history was stored successfully.
+    fs.rmSync(path.resolve(process.cwd(), "codepush-release-history"), { recursive: true, force: true });
 });
 describe("release without --binary-bundle-path", () => {
     it("keeps existing three-argument uploaders callable", async () => {

package/cli/dist/commands/updateHistoryCommand/updateReleaseHistory.js

@@ -1,5 +1,4 @@
-import fs from "fs";
-import path from "path";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function updateReleaseHistory(appVersion, binaryVersion, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
@@ -12,12 +11,7 @@ export async function updateReleaseHistory(appVersion, binaryVersion, getRelease
     if (typeof rollout === "number")
         updateInfo.rollout = rollout;
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(releaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, (jsonFilePath) => setReleaseHistory(binaryVersion, jsonFilePath, releaseHistory, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while updating history:', error);

package/cli/dist/functions/stageReleaseHistoryFile.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+import path from "path";
+const STAGING_DIR_NAME = 'codepush-release-history';
+/**
+ * Writes the release history to a file for the config to read, and takes it away again
+ * once the config has stored it.
+ *
+ * Written under a directory of the platform's own rather than straight into the directory
+ * the command ran in. The name follows from the binary version alone, so two commands
+ * releasing the same version of one app for different platforms shared one path: whichever
+ * finished first took the file away while the other was still about to read it, and before
+ * that each had overwritten the other's contents. The name itself is kept as it was,
+ * because the name is part of what the config is handed.
+ *
+ * A file whose history was never stored is left where it was written, so a release that
+ * failed can be read back from a path that is the same on every run.
+ */
+export async function stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, store) {
+    const jsonFileName = `${binaryVersion}.json`;
+    const stagingDir = path.resolve(process.cwd(), STAGING_DIR_NAME, platform);
+    const jsonFilePath = path.join(stagingDir, jsonFileName);
+    fs.mkdirSync(stagingDir, { recursive: true });
+    console.log(`log: creating JSON file... ("${jsonFileName}")\n`, JSON.stringify(releaseHistory, null, 2));
+    fs.writeFileSync(jsonFilePath, JSON.stringify(releaseHistory));
+    const stored = await store(jsonFilePath);
+    fs.rmSync(jsonFilePath, { force: true });
+    return stored;
+}

package/cli/dist/index.js

@@ -26,6 +26,10 @@ import "./commands/showHistoryCommand/index.js";
  * npx code-push init
  */
 import "./commands/initCommand/index.js";
+/**
+ * npx code-push build-patch-tools
+ */
+import "./commands/buildPatchToolsCommand/index.js";
 shell.set("-e");
 shell.set("+v");
 program

package/cli/dist/utils/binaryPatch.js

@@ -31,14 +31,17 @@ export const BINARY_PATCH_ALGORITHM = 'hdiffpatch-m-zstd';
 export const BINARY_PATCH_FORMAT_VERSION = 1;
 const HDIFFZ_OPTIONS = ['-f', '-m-6', '-c-zstd-21-24'];
 const HPATCHZ_OPTIONS = ['-f', '-m'];
-const TOOLS_DIR_ENV_NAME = 'HDIFFPATCH_TOOLS_DIR';
-const TOOLS_DIR_NAME = '.hdiffpatch-tools';
-const BUILD_SCRIPT_PATH = 'scripts/binary-patch/build-hdiffpatch.sh';
+export const TOOLS_DIR_ENV_NAME = 'HDIFFPATCH_TOOLS_DIR';
+export const TOOLS_DIR_NAME = '.hdiffpatch-tools';
+const BUILD_COMMAND = 'npx code-push build-patch-tools';
 /**
  * Finds the hdiffz/hpatchz executable, looking at `HDIFFPATCH_TOOLS_DIR` first and
  * then at a `.hdiffpatch-tools` directory in the working directory or any directory
  * above it. The tools are built from source rather than installed as a package
  * dependency, so the error explains how to get them.
+ *
+ * `build-patch-tools` (`cli/commands/buildPatchToolsCommand/index.ts`) installs into the
+ * first place this looks; a change to the lookup order has to be mirrored there.
  */
 export function resolveBinaryPatchTool(tool) {
     const configuredDir = process.env[TOOLS_DIR_ENV_NAME];
@@ -48,7 +51,7 @@ export function resolveBinaryPatchTool(tool) {
             return configured;
         }
         throw new Error(`${TOOLS_DIR_ENV_NAME} is set to '${configuredDir}' but it does not contain '${tool}'. ` +
-            `Build the tools with '${BUILD_SCRIPT_PATH}'.`);
+            `Build the tools with '${BUILD_COMMAND}'.`);
     }
     let directory = path.resolve(process.cwd());
     for (;;) {
@@ -63,7 +66,7 @@ export function resolveBinaryPatchTool(tool) {
         directory = parent;
     }
     throw new Error(`'${tool}' not found in any '${TOOLS_DIR_NAME}' directory at or above '${process.cwd()}'. ` +
-        `Build it with '${BUILD_SCRIPT_PATH}', or set ${TOOLS_DIR_ENV_NAME} to a directory that contains it.`);
+        `Build it with '${BUILD_COMMAND}', or set ${TOOLS_DIR_ENV_NAME} to a directory that contains it.`);
 }
 /** Writes the patch that turns the bundle at `basePath` into the one at `targetPath`. */
 export function generatePatch(basePath, targetPath, patchPath) {

package/cli/dist/utils/binaryPatch.test.js

@@ -82,7 +82,7 @@ describe("generatePatch/applyPatch", () => {
         const previous = process.env.HDIFFPATCH_TOOLS_DIR;
         process.env.HDIFFPATCH_TOOLS_DIR = workPath("no-such-dir");
         try {
-            expect(() => resolveBinaryPatchTool("hdiffz")).toThrow(/build-hdiffpatch\.sh/);
+            expect(() => resolveBinaryPatchTool("hdiffz")).toThrow(/npx code-push build-patch-tools/);
         }
         finally {
             if (previous === undefined) {