@algocare/react-native-code-push 12.6.4 → 13.0.0-rc.0

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

@@ -1,14 +1,6 @@
 package com.microsoft.codepush.react;
 
 import android.content.Context;
-import android.util.Base64;
-
-import com.nimbusds.jose.JWSVerifier;
-import com.nimbusds.jose.crypto.RSASSAVerifier;
-import com.nimbusds.jwt.SignedJWT;
-
-import java.security.interfaces.*;
-
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -21,14 +13,10 @@ import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.security.DigestInputStream;
-import java.security.KeyFactory;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
-import java.security.PublicKey;
-import java.security.spec.X509EncodedKeySpec;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.Map;
 
 public class CodePushUpdateUtils {
 
@@ -39,13 +27,10 @@ public class CodePushUpdateUtils {
     public static boolean isHashIgnored(String relativeFilePath) {
         final String __MACOSX = "__MACOSX/";
         final String DS_STORE = ".DS_Store";
-        final String CODEPUSH_METADATA = ".codepushrelease";
 
         return relativeFilePath.startsWith(__MACOSX)
                 || relativeFilePath.equals(DS_STORE)
-                || relativeFilePath.endsWith("/" + DS_STORE)
-                || relativeFilePath.equals(CODEPUSH_METADATA)
-                || relativeFilePath.endsWith("/" + CODEPUSH_METADATA);
+                || relativeFilePath.endsWith("/" + DS_STORE);
     }
 
     private static void addContentsOfFolderToManifest(String folderPath, String pathPrefix, ArrayList<String> manifest) {
@@ -86,8 +71,12 @@ public class CodePushUpdateUtils {
             throw new CodePushUnknownException("Unable to compute hash of update contents.", e);
         } finally {
             try {
-                if (digestInputStream != null) digestInputStream.close();
-                if (dataStream != null) dataStream.close();
+                if (digestInputStream != null) {
+                    digestInputStream.close();
+                }
+                if (dataStream != null) {
+                    dataStream.close();
+                }
             } catch (IOException e) {
                 e.printStackTrace();
             }
@@ -98,7 +87,11 @@ public class CodePushUpdateUtils {
     }
 
     public static void copyNecessaryFilesFromCurrentPackage(String diffManifestFilePath, String currentPackageFolderPath, String newPackageFolderPath) throws IOException {
-        FileUtils.copyDirectoryContents(currentPackageFolderPath, newPackageFolderPath);        
+        if (currentPackageFolderPath == null || !new File(currentPackageFolderPath).exists()) {
+            CodePushUtils.log("Unable to copy files from current package during diff update, because currentPackageFolderPath is invalid.");
+            return;
+        }
+        FileUtils.copyDirectoryContents(currentPackageFolderPath, newPackageFolderPath);
         JSONObject diffManifest = CodePushUtils.getJsonObjectFromFile(diffManifestFilePath);
         try {
             JSONArray deletedFiles = diffManifest.getJSONArray("deletedFiles");
@@ -142,11 +135,6 @@ public class CodePushUpdateUtils {
             try {
                 return CodePushUtils.getStringFromInputStream(context.getAssets().open(CodePushConstants.CODE_PUSH_OLD_HASH_FILE_NAME));
             } catch (IOException ex) {
-                if (!isDebugMode) {
-                    // Only print this message in "Release" mode. In "Debug", we may not have the
-                    // hash if the build skips bundling the files.
-                    CodePushUtils.log("Unable to get the hash of the binary's bundled resources - \"codepush.gradle\" may have not been added to the build definition.");
-                }
             }
             return null;
         }
@@ -181,88 +169,4 @@ public class CodePushUpdateUtils {
         CodePushUtils.log("The update contents succeeded the data integrity check.");
     }
 
-    public static Map<String, Object> verifyAndDecodeJWT(String jwt, PublicKey publicKey) {
-        try {
-            SignedJWT signedJWT = SignedJWT.parse(jwt);
-            JWSVerifier verifier = new RSASSAVerifier((RSAPublicKey)publicKey);
-            if (signedJWT.verify(verifier)) {
-                Map<String, Object> claims = signedJWT.getJWTClaimsSet().getClaims();
-                CodePushUtils.log("JWT verification succeeded, payload content: " + claims.toString());
-                return claims;
-            }
-            return null;
-        } catch (Exception ex) {
-            CodePushUtils.log(ex.getMessage());
-            CodePushUtils.log(ex.getStackTrace().toString());
-            return null;
-        }
-    }
-
-    public static PublicKey parsePublicKey(String stringPublicKey) {
-        try {
-            //remove unnecessary "begin/end public key" entries from string
-            stringPublicKey = stringPublicKey
-                    .replace("-----BEGIN PUBLIC KEY-----", "")
-                    .replace("-----END PUBLIC KEY-----", "")
-                    .replace(NEW_LINE, "");
-            byte[] byteKey = Base64.decode(stringPublicKey.getBytes(), Base64.DEFAULT);
-            X509EncodedKeySpec X509Key = new X509EncodedKeySpec(byteKey);
-            KeyFactory kf = KeyFactory.getInstance("RSA");
-
-            return kf.generatePublic(X509Key);
-        } catch (Exception e) {
-            CodePushUtils.log(e.getMessage());
-            CodePushUtils.log(e.getStackTrace().toString());
-            return null;
-        }
-    }
-
-    public static String getSignatureFilePath(String updateFolderPath){
-        return CodePushUtils.appendPathComponent(
-                CodePushUtils.appendPathComponent(updateFolderPath, CodePushConstants.CODE_PUSH_FOLDER_PREFIX),
-                CodePushConstants.BUNDLE_JWT_FILE
-        );
-    }
-
-    public static String getSignature(String folderPath) {
-        final String signatureFilePath = getSignatureFilePath(folderPath);
-
-        try {
-            return FileUtils.readFileToString(signatureFilePath);
-        } catch (IOException e) {
-            CodePushUtils.log(e.getMessage());
-            CodePushUtils.log(e.getStackTrace().toString());
-            return null;
-        }
-    }
-
-    public static void verifyUpdateSignature(String folderPath, String packageHash, String stringPublicKey) throws CodePushInvalidUpdateException {
-        CodePushUtils.log("Verifying signature for folder path: " + folderPath);
-
-        final PublicKey publicKey = parsePublicKey(stringPublicKey);
-        if (publicKey == null) {
-            throw new CodePushInvalidUpdateException("The update could not be verified because no public key was found.");
-        }
-
-        final String signature = getSignature(folderPath);
-        if (signature == null) {
-            throw new CodePushInvalidUpdateException("The update could not be verified because no signature was found.");
-        }
-
-        final Map<String, Object> claims = verifyAndDecodeJWT(signature, publicKey);
-        if (claims == null) {
-            throw new CodePushInvalidUpdateException("The update could not be verified because it was not signed by a trusted party.");
-        }
-
-        final String contentHash = (String)claims.get("contentHash");
-        if (contentHash == null) {
-            throw new CodePushInvalidUpdateException("The update could not be verified because the signature did not specify a content hash.");
-        }
-
-        if (!contentHash.equals(packageHash)) {
-            throw new CodePushInvalidUpdateException("The update contents failed the code signing check.");
-        }
-
-        CodePushUtils.log("The update contents succeeded the code signing check.");
-    }
-}
+}

package/android/build.gradle

@@ -14,6 +14,9 @@ buildscript {
 }
 
 allprojects {
+    android {
+        namespace "com.microsoft.codepush.react"
+    }
     repositories {
         mavenLocal()
         mavenCentral()

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require("./expo/plugin/withCodePush");

package/bin/code-push.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import('../cli/dist/index.js').catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/cli/commands/bundleCommand/bundleCodePush.ts

@@ -0,0 +1,118 @@
+import fs from "fs";
+import path from "path";
+import { prepareToBundleJS } from "../../functions/prepareToBundleJS.js";
+import { runReactNativeBundleCommand } from "../../functions/runReactNativeBundleCommand.js";
+import { runExpoBundleCommand } from "../../functions/runExpoBundleCommand.js";
+import { getReactTempDir } from "../../functions/getReactTempDir.js";
+import { runHermesEmitBinaryCommand } from "../../functions/runHermesEmitBinaryCommand.js";
+import { makeCodePushBundle } from "../../functions/makeCodePushBundle.js";
+import { ROOT_OUTPUT_DIR } from "../../constant.js";
+
+/**
+ * @return {Promise<string>} CodePush bundle file name (equals to packageHash)
+ */
+export async function bundleCodePush(
+  framework: 'expo' | undefined,
+  platform: 'ios' | 'android' = 'ios',
+  outputRootPath: string = ROOT_OUTPUT_DIR,
+  entryFile: string | undefined,
+  jsBundleName: string, // JS bundle file name (not CodePush bundle file)
+  bundleDirectory: string, // CodePush bundle output directory
+  outputMetroDir?: string,
+): Promise<string> {
+    const resolvedEntryFile = resolveEntryFile(entryFile, platform);
+
+    if (fs.existsSync(outputRootPath)) {
+        fs.rmSync(outputRootPath, { recursive: true });
+    }
+
+    const OUTPUT_CONTENT_PATH = `${outputRootPath}/CodePush`;
+    const DEFAULT_JS_BUNDLE_NAME = platform === 'ios' ? 'main.jsbundle' : 'index.android.bundle';
+    const _jsBundleName = jsBundleName || DEFAULT_JS_BUNDLE_NAME; // react-native JS bundle output name
+    const SOURCEMAP_OUTPUT = `${outputRootPath}/${_jsBundleName}.map`;
+
+    prepareToBundleJS({ deleteDirs: [outputRootPath, getReactTempDir()], makeDir: OUTPUT_CONTENT_PATH });
+
+    if (framework === 'expo') {
+      runExpoBundleCommand(
+        _jsBundleName,
+        OUTPUT_CONTENT_PATH,
+        platform,
+        SOURCEMAP_OUTPUT,
+        resolvedEntryFile,
+      );
+    } else {
+      runReactNativeBundleCommand(
+        _jsBundleName,
+        OUTPUT_CONTENT_PATH,
+        platform,
+        SOURCEMAP_OUTPUT,
+        resolvedEntryFile,
+      );
+    }
+
+    console.log('log: JS bundling complete');
+
+    copyMetroOutputsIfNeeded(outputRootPath, outputMetroDir, OUTPUT_CONTENT_PATH, _jsBundleName, SOURCEMAP_OUTPUT);
+
+    await runHermesEmitBinaryCommand(
+      _jsBundleName,
+      OUTPUT_CONTENT_PATH,
+      SOURCEMAP_OUTPUT,
+    );
+    console.log('log: Hermes compilation complete');
+
+    const { bundleFileName: codePushBundleFileName } = await makeCodePushBundle(OUTPUT_CONTENT_PATH, bundleDirectory);
+    console.log(`log: CodePush bundle created (file path: ./${bundleDirectory}/${codePushBundleFileName})`);
+
+    return codePushBundleFileName;
+}
+
+function resolveEntryFile(
+  entryFile: string | undefined,
+  platform: 'ios' | 'android',
+): string {
+    if (entryFile) {
+        if (!fs.existsSync(entryFile)) {
+            throw new Error(`Entry file "${entryFile}" does not exist.`);
+        }
+        return entryFile;
+    }
+
+    // 앱마다 엔트리 파일이 다르다 (index.js / index.ts / index.<platform>.js).
+    // 명시하지 않으면 react-native CLI 관례 순서로 자동 감지한다.
+    const candidates = [`index.${platform}.js`, 'index.js', `index.${platform}.ts`, 'index.ts'];
+    const found = candidates.find((candidate) => fs.existsSync(candidate));
+    if (!found) {
+        throw new Error(
+            `Entry file not found. Tried: ${candidates.join(', ')}. Use -e/--entry-file to specify one.`,
+        );
+    }
+    console.log(`log: entry file auto-detected: ${found}`);
+    return found;
+}
+
+function copyMetroOutputsIfNeeded(
+  outputRootPath: string,
+  outputMetroDir: string | undefined,
+  outputContentPath: string,
+  jsBundleName: string,
+  sourceMapOutputPath: string,
+) {
+    if (!outputMetroDir) {
+        return;
+    }
+
+    const resolvedOutputMetroDir = path.join(outputRootPath, outputMetroDir);
+
+    fs.mkdirSync(resolvedOutputMetroDir, { recursive: true });
+    fs.copyFileSync(
+        path.join(outputContentPath, jsBundleName),
+        path.join(resolvedOutputMetroDir, jsBundleName),
+    );
+    fs.copyFileSync(
+        sourceMapOutputPath,
+        path.join(resolvedOutputMetroDir, path.basename(sourceMapOutputPath)),
+    );
+    console.log(`log: Metro outputs copied to: ${resolvedOutputMetroDir}`);
+}

package/cli/commands/bundleCommand/index.ts

@@ -0,0 +1,34 @@
+import { program, Option } from "commander";
+import { bundleCodePush } from "./bundleCodePush.js";
+import { OUTPUT_BUNDLE_DIR, ROOT_OUTPUT_DIR } from "../../constant.js";
+
+type Options = {
+    framework: 'expo' | undefined;
+    platform: 'ios' | 'android';
+    outputPath: string;
+    entryFile?: string;
+    bundleName: string;
+    outputBundleDir: string;
+    outputMetroDir?: string;
+}
+
+program.command('bundle')
+    .description('Creates a CodePush bundle file (assumes Hermes is enabled).')
+    .addOption(new Option('-f, --framework <type>', 'framework type (expo)').choices(['expo']))
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-o, --output-path <string>', 'path to output root directory', ROOT_OUTPUT_DIR)
+    .option('-e, --entry-file <string>', 'path to JS/TS entry file (default: auto-detect index.<platform>.js → index.js → index.ts)')
+    .option('-b, --bundle-name <string>', 'bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
+    .option('--output-metro-dir <string>', 'name of directory to copy the Metro JS bundle and sourcemap before Hermes compilation')
+    .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
+    .action((options: Options) => {
+        bundleCodePush(
+            options.framework,
+            options.platform,
+            options.outputPath,
+            options.entryFile,
+            options.bundleName,
+            `${options.outputPath}/${options.outputBundleDir}`,
+            options.outputMetroDir,
+        )
+    });

package/cli/commands/createHistoryCommand/createReleaseHistory.ts

@@ -0,0 +1,37 @@
+import fs from "fs";
+import path from "path";
+import type { CliConfigInterface, ReleaseHistoryInterface, ReleaseInfo } from "../../../typings/react-native-code-push.d.ts";
+
+export async function createReleaseHistory(
+    targetVersion: string,
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    platform: 'ios' | 'android',
+    identifier?: string,
+    app?: string,
+): Promise<void> {
+    const BINARY_RELEASE: ReleaseInfo = {
+        enabled: true,
+        mandatory: false,
+        downloadUrl: "",
+        packageHash: "",
+    };
+
+    const INITIAL_HISTORY: ReleaseHistoryInterface = {
+        [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, app)
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while creating new history:', error);
+        process.exit(1)
+    }
+}

package/cli/commands/createHistoryCommand/createReleaseHistoryList.ts

@@ -0,0 +1,40 @@
+import fs from "fs";
+import path from "path";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+
+/**
+ * Adds the new binary version to the binary version list file (`list.json`).
+ *
+ * The list file indexes all binary versions for which a release history exists,
+ * so that deploy pipelines can check for an existing history without listing bucket objects.
+ * (algocare extension — runs only when the config implements `getBinaryVersionList`/`setBinaryVersionList`.)
+ */
+export async function createReleaseHistoryList(
+    targetVersion: string,
+    getBinaryVersionList: NonNullable<CliConfigInterface['getBinaryVersionList']>,
+    setBinaryVersionList: NonNullable<CliConfigInterface['setBinaryVersionList']>,
+    platform: 'ios' | 'android',
+    identifier?: string,
+    app?: string,
+): Promise<void> {
+    try {
+        const JSON_FILE_NAME = 'list.json';
+        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
+
+        const currentList = await getBinaryVersionList(platform, identifier, app);
+
+        if (currentList[targetVersion]) {
+            console.error(`Version ${targetVersion} is already released`);
+            process.exit(1);
+        }
+
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(currentList));
+
+        await setBinaryVersionList(targetVersion, JSON_FILE_PATH, platform, identifier, app);
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while creating new history list:', error);
+        process.exit(1);
+    }
+}

package/cli/commands/createHistoryCommand/index.ts

@@ -0,0 +1,44 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { createReleaseHistory } from "./createReleaseHistory.js";
+import { createReleaseHistoryList } from "./createReleaseHistoryList.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    app?: string;
+    config: string;
+}
+
+program.command('create-history')
+    .description('Creates a new release history for the binary app.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-a, --app <string>', 'target app name for multi-app repositories. (e.g. home-mobile)')
+    .option('-c, --config <path>', 'set config file name (JS/TS)', CONFIG_FILE_NAME)
+    .action(async (options: Options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        await createReleaseHistory(
+            options.binaryVersion,
+            config.setReleaseHistory,
+            options.platform,
+            options.identifier,
+            options.app,
+        );
+
+        // algocare extension: maintain a `list.json` index of binary versions (only when implemented in config)
+        if (config.getBinaryVersionList && config.setBinaryVersionList) {
+            await createReleaseHistoryList(
+                options.binaryVersion,
+                config.getBinaryVersionList,
+                config.setBinaryVersionList,
+                options.platform,
+                options.identifier,
+                options.app,
+            );
+        }
+    });

package/cli/commands/createPullRequestHistoryCommand/createPullRequestHistory.ts

@@ -0,0 +1,33 @@
+import fs from "fs";
+import path from "path";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+
+/**
+ * Creates an empty release history for PR preview releases.
+ *
+ * Unlike `create-history`, this does NOT seed a binary release entry and does NOT
+ * register the version in the `list.json` index, so PR preview histories never
+ * pollute the official binary version index.
+ */
+export async function createPullRequestHistory(
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    binaryVersion: string,
+    platform: 'ios' | 'android',
+    identifier?: string,
+    app?: string,
+): Promise<void> {
+    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({}, null, 2));
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify({}));
+
+        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, {}, platform, identifier, app);
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while creating new pull request history:', error);
+        process.exit(1);
+    }
+}

package/cli/commands/createPullRequestHistoryCommand/index.ts

@@ -0,0 +1,31 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { createPullRequestHistory } from "./createPullRequestHistory.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    app?: string;
+    config: string;
+}
+
+program.command('create-pr-history')
+    .description('Creates a new (empty) release history for PR preview releases.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-a, --app <string>', 'target app name for multi-app repositories. (e.g. home-mobile)')
+    .option('-c, --config <path>', 'set config file name (JS/TS)', CONFIG_FILE_NAME)
+    .action(async (options: Options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        await createPullRequestHistory(
+            config.setReleaseHistory,
+            options.binaryVersion,
+            options.platform,
+            options.identifier,
+            options.app,
+        );
+    });

package/cli/commands/createPullRequestReleaseCommand/addToPullRequestRelease.ts

@@ -0,0 +1,71 @@
+import path from "path";
+import fs from "fs";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+import { getTimestamp } from "../../utils/datetime.js";
+
+/**
+ * Appends a PR preview release entry to the release history.
+ *
+ * PR preview releases are keyed as `{prNumber}-{semver}` (e.g. `1234-1.0.0`) so that
+ * the runtime can filter them by PR number (`SyncOptions.prNumber`) while normal
+ * clients ignore any key containing `-`.
+ */
+export async function addToPullRequestRelease(
+    binaryVersion: string,
+    prNumber: string,
+    bundleDownloadUrl: string,
+    packageHash: string,
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    app: string | undefined,
+    mandatory: boolean,
+    enable: boolean,
+): Promise<void> {
+    const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier, app);
+
+    const releaseHistoryKeysWithPrNumber = Object.keys(releaseHistory)
+        .filter((key) => key.startsWith(`${prNumber}-`));
+
+    const newReleaseVersionKey = getNewReleaseVersionKey(releaseHistoryKeysWithPrNumber, prNumber);
+    const newReleaseHistory = structuredClone(releaseHistory);
+
+    newReleaseHistory[newReleaseVersionKey] = {
+        binaryVersion,
+        enabled: enable,
+        mandatory,
+        downloadUrl: bundleDownloadUrl,
+        packageHash,
+        createdAt: getTimestamp(),
+    };
+
+    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, app);
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while updating history:', error);
+        process.exit(1);
+    }
+}
+
+/**
+ * Determines the next PR release key. (`{prNumber}-1.0.0` → `{prNumber}-2.0.0` → ...)
+ */
+function getNewReleaseVersionKey(releaseHistoryKeysWithPrNumber: string[], prNumber: string): string {
+    const lastKey = releaseHistoryKeysWithPrNumber.at(-1);
+    if (lastKey) {
+        const [, latestVersion] = lastKey.split('-');
+        const latestMajor = parseInt(latestVersion.split('.')[0], 10);
+        return `${prNumber}-${latestMajor + 1}.0.0`;
+    } else {
+        return `${prNumber}-1.0.0`;
+    }
+}