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

package/cli/commands/releaseCommand/addToReleaseHistory.ts

@@ -0,0 +1,57 @@
+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";
+
+export async function addToReleaseHistory(
+    appVersion: string,
+    binaryVersion: string,
+    bundleDownloadUrl: string,
+    packageHash: string,
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    app: string | undefined,
+    mandatory: boolean,
+    enable: boolean,
+    rollout: number | undefined,
+): Promise<void> {
+    const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier, app);
+
+    const updateInfo = releaseHistory[appVersion]
+    if (updateInfo) {
+        console.error(`v${appVersion} is already released`)
+        process.exit(1)
+    }
+
+    const newReleaseHistory = structuredClone(releaseHistory);
+
+    newReleaseHistory[appVersion] = {
+        enabled: enable,
+        mandatory: mandatory,
+        downloadUrl: bundleDownloadUrl,
+        packageHash: packageHash,
+        createdAt: getTimestamp(),
+        updatedAt: '-',
+    };
+
+    if (typeof rollout === 'number') {
+        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, app)
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while updating history:', error);
+        process.exit(1)
+    }
+}

package/cli/commands/releaseCommand/index.ts

@@ -0,0 +1,90 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { release } from "./release.js";
+import { OUTPUT_BUNDLE_DIR, CONFIG_FILE_NAME, ROOT_OUTPUT_DIR } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    appVersion: string;
+    framework: 'expo' | undefined;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    app?: string;
+    config: string;
+    outputPath: string;
+    entryFile?: string;
+    bundleName: string;
+    mandatory: boolean;
+    enable: boolean;
+    rollout?: number;
+    skipBundle: boolean;
+    skipCleanup: boolean;
+    outputBundleDir: string;
+    outputMetroDir?: string;
+    hashCalc?: boolean;
+}
+
+program.command('release')
+    .description('Deploys a new CodePush update for a target binary app.\nAfter creating the CodePush bundle, it uploads the file and updates the ReleaseHistory information.\n`bundleUploader`, `getReleaseHistory`, and `setReleaseHistory` functions should be implemented in the config file.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version')
+    .requiredOption('-v, --app-version <string>', '(Required) The app version to be released. It must be greater than the binary version.')
+    .addOption(new Option('-f, --framework <type>', 'framework type (expo)').choices(['expo']))
+    .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)
+    .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('-j, --js-bundle-name <string>', 'JS bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
+    .option('-m, --mandatory [bool]', 'make the release to be mandatory', parseBoolean, false)
+    .option('--enable [bool]', 'make the release to be enabled', parseBoolean, true)
+    .option('--rollout <number>', 'rollout percentage (0-100)', parseFloat)
+    .option('--skip-bundle [bool]', 'skip bundle process', parseBoolean, false)
+    .option('--hash-calc [bool]', 'calculates the bundle file hash used for packageHash in the release history (Requires setting --skip-bundle to true)', parseBoolean)
+    .option('--skip-cleanup [bool]', 'skip cleanup process', parseBoolean, false)
+    .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(async (options: Options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        if (typeof options.rollout === 'number' && (options.rollout < 0 || options.rollout > 100)) {
+            console.error('Rollout percentage number must be between 0 and 100 (inclusive).');
+            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);
+        }
+
+        await release(
+            config.bundleUploader,
+            config.getReleaseHistory,
+            config.setReleaseHistory,
+            options.binaryVersion,
+            options.appVersion,
+            options.framework,
+            options.platform,
+            options.identifier,
+            options.app,
+            options.outputPath,
+            options.entryFile,
+            options.bundleName,
+            options.mandatory,
+            options.enable,
+            options.rollout,
+            options.skipBundle,
+            options.skipCleanup,
+            `${options.outputPath}/${options.outputBundleDir}`,
+            options.outputMetroDir,
+            options.hashCalc,
+        )
+
+        console.log('🚀 Release completed.')
+    });
+
+function parseBoolean(value: string): boolean | undefined {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    else return undefined;
+}

package/cli/commands/releaseCommand/release.ts

@@ -0,0 +1,105 @@
+import fs from "fs";
+import path from "path";
+import { bundleCodePush } from "../bundleCommand/bundleCodePush.js";
+import { addToReleaseHistory } from "./addToReleaseHistory.js";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+import { generatePackageHashFromDirectory } from "../../utils/hash-utils.js";
+import { unzip } from "../../utils/unzip.js";
+
+export async function release(
+    bundleUploader: CliConfigInterface['bundleUploader'],
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    binaryVersion: string,
+    appVersion: string,
+    framework: 'expo' | undefined,
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    app: string | undefined,
+    outputPath: string,
+    entryFile: string | undefined,
+    jsBundleName: string,
+    mandatory: boolean,
+    enable: boolean,
+    rollout: number | undefined,
+    skipBundle: boolean,
+    skipCleanup: boolean,
+    bundleDirectory: string,
+    outputMetroDir?: string,
+    hashCalc?: boolean,
+): Promise<void> {
+    const bundleFileName = skipBundle
+        ? readBundleFileNameFrom(bundleDirectory)
+        : await bundleCodePush(framework, platform, outputPath, entryFile, jsBundleName, bundleDirectory, outputMetroDir);
+    const bundleFilePath = `${bundleDirectory}/${bundleFileName}`;
+
+    const packageHash = await (() => {
+        if (skipBundle && hashCalc) {
+            return calcHashFromBundleFile(bundleFilePath);
+        }
+        // If not using --skip-bundle, the bundleFileName represents package hash already.
+        return bundleFileName;
+    })();
+
+    const downloadUrl = await (async () => {
+        try {
+            const { downloadUrl } = await bundleUploader(bundleFilePath, platform, identifier, app);
+            return downloadUrl
+        } catch (error) {
+            console.error('Failed to upload the bundle file. Exiting the program.\n', error)
+            process.exit(1)
+        }
+    })();
+
+    await addToReleaseHistory(
+        appVersion,
+        binaryVersion,
+        downloadUrl,
+        packageHash,
+        getReleaseHistory,
+        setReleaseHistory,
+        platform,
+        identifier,
+        app,
+        mandatory,
+        enable,
+        rollout,
+    )
+
+    if (!skipCleanup) {
+        cleanUpOutputs(outputPath);
+    }
+}
+
+function cleanUpOutputs(dir: string) {
+    fs.rmSync(dir, { recursive: true });
+}
+
+function readBundleFileNameFrom(bundleDirectory: string): string {
+    const files = fs.readdirSync(bundleDirectory);
+    if (files.length !== 1) {
+        console.error('The bundlePath must contain only one file.');
+        process.exit(1);
+    }
+    const bundleFilePath = path.join(bundleDirectory, files[0]);
+    return path.basename(bundleFilePath);
+}
+
+async function calcHashFromBundleFile(bundleFilePath: string): Promise<string> {
+    const tempDir = path.resolve(path.join(path.dirname(bundleFilePath), 'temp_contents_for_hash_calc'));
+    const zipFilePath = path.resolve(bundleFilePath);
+
+    if (fs.existsSync(tempDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    try {
+        await unzip(zipFilePath, tempDir);
+        const hash = await generatePackageHashFromDirectory(tempDir, tempDir);
+        console.log(`log: Calculated package hash from existing bundle file: ${hash}`);
+        return hash;
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+}

package/cli/commands/removePullRequestHistoryCommand/index.ts

@@ -0,0 +1,37 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { removePullRequestHistory } from "./removePullRequestHistory.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    prNumber: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    app?: string;
+    config: string;
+}
+
+program.command('remove-pr-history')
+    .description('Removes a PR preview release history.\n`removeReleaseHistory` function should be implemented in the config file.')
+    .requiredOption('-r, --pr-number <string>', '(Required) The pull request number')
+    .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);
+
+        if (!config.removeReleaseHistory) {
+            console.error('`removeReleaseHistory` function is not implemented in the config file.');
+            process.exit(1);
+        }
+
+        await removePullRequestHistory(
+            config.getReleaseHistory,
+            config.removeReleaseHistory,
+            options.prNumber,
+            options.platform,
+            options.identifier,
+            options.app,
+        );
+    });

package/cli/commands/removePullRequestHistoryCommand/removePullRequestHistory.ts

@@ -0,0 +1,28 @@
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+
+/**
+ * Removes a PR preview release history file.
+ * (typically executed when the pull request is closed/merged)
+ */
+export async function removePullRequestHistory(
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    removeReleaseHistory: NonNullable<CliConfigInterface['removeReleaseHistory']>,
+    prNumber: string,
+    platform: 'ios' | 'android',
+    identifier?: string,
+    app?: string,
+): Promise<void> {
+    const releaseHistory = await getReleaseHistory(prNumber, platform, identifier, app);
+
+    if (!releaseHistory) {
+        console.error(`v${prNumber} is already removed or is not released.`);
+        process.exit(1);
+    }
+
+    try {
+        await removeReleaseHistory(prNumber, platform, identifier, app);
+    } catch (error) {
+        console.error('Error occurred while removing history:', error);
+        process.exit(1);
+    }
+}

package/cli/commands/showHistoryCommand/index.ts

@@ -0,0 +1,31 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    binaryVersion: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    app?: string;
+    config: string;
+}
+
+program.command('show-history')
+    .description('Retrieves and prints the release history of a specific binary version.\n`getReleaseHistory` function should be implemented in the config file.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version for retrieving the release history.')
+    .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>', 'configuration file name (JS/TS)', CONFIG_FILE_NAME)
+    .action(async (options: Options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        const releaseHistory = await config.getReleaseHistory(
+            options.binaryVersion,
+            options.platform,
+            options.identifier,
+            options.app
+        );
+
+        console.log(JSON.stringify(releaseHistory, null, 2));
+    });

package/cli/commands/updateHistoryCommand/index.ts

@@ -0,0 +1,55 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { updateReleaseHistory } from "./updateReleaseHistory.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+
+type Options = {
+    appVersion: string;
+    binaryVersion: string;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    app?: string;
+    config: string;
+    mandatory?: boolean;
+    enable?: boolean;
+    rollout?: number;
+}
+
+program.command('update-history')
+    .description('Updates the release history for a specific binary version.\n`getReleaseHistory`, `setReleaseHistory` functions should be implemented in the config file.')
+    .requiredOption('-v, --app-version <string>', '(Required) The app version for which update information is to be modified.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version of the app for which update information is to be modified.')
+    .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)
+    .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)
+    .action(async (options: Options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        if (typeof options.mandatory !== "boolean" && typeof options.enable !== "boolean") {
+            console.error('No options specified. Exiting the program.')
+            process.exit(1)
+        }
+
+        await updateReleaseHistory(
+            options.appVersion,
+            options.binaryVersion,
+            config.getReleaseHistory,
+            config.setReleaseHistory,
+            options.platform,
+            options.identifier,
+            options.app,
+            options.mandatory,
+            options.enable,
+            options.rollout
+        )
+    });
+
+function parseBoolean(value: string) {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    else return undefined;
+}

package/cli/commands/updateHistoryCommand/updateReleaseHistory.ts

@@ -0,0 +1,42 @@
+import fs from "fs";
+import path from "path";
+import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+import { getTimestamp } from "../../utils/datetime.js";
+
+export async function updateReleaseHistory(
+    appVersion: string,
+    binaryVersion: string,
+    getReleaseHistory: CliConfigInterface['getReleaseHistory'],
+    setReleaseHistory: CliConfigInterface['setReleaseHistory'],
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    app: string | undefined,
+    mandatory: boolean | undefined,
+    enable: boolean | undefined,
+    rollout: number | undefined,
+): Promise<void> {
+    const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier, app);
+
+    const updateInfo = releaseHistory[appVersion]
+    if (!updateInfo) throw new Error(`v${appVersion} is not released`)
+
+    if (typeof mandatory === "boolean") updateInfo.mandatory = mandatory;
+    if (typeof enable === "boolean") updateInfo.enabled = enable;
+    if (typeof rollout === "number") updateInfo.rollout = rollout;
+    updateInfo.updatedAt = 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(releaseHistory, null, 2));
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
+
+        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier, app)
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while updating history:', error);
+        process.exit(1)
+    }
+}

package/cli/constant.ts

@@ -0,0 +1,4 @@
+export const CONFIG_FILE_NAME = "code-push.config.ts";
+export const OUTPUT_BUNDLE_DIR = "bundleOutput";
+export const ROOT_OUTPUT_DIR = "build";
+export const ENTRY_FILE = "index.ts";

package/cli/dist/commands/bundleCommand/bundleCodePush.js

@@ -0,0 +1,65 @@
+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, platform = 'ios', outputRootPath = ROOT_OUTPUT_DIR, entryFile, jsBundleName, // JS bundle file name (not CodePush bundle file)
+bundleDirectory, // CodePush bundle output directory
+outputMetroDir) {
+    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, platform) {
+    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, outputMetroDir, outputContentPath, jsBundleName, sourceMapOutputPath) {
+    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/dist/commands/bundleCommand/index.js

@@ -0,0 +1,15 @@
+import { program, Option } from "commander";
+import { bundleCodePush } from "./bundleCodePush.js";
+import { OUTPUT_BUNDLE_DIR, ROOT_OUTPUT_DIR } from "../../constant.js";
+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) => {
+    bundleCodePush(options.framework, options.platform, options.outputPath, options.entryFile, options.bundleName, `${options.outputPath}/${options.outputBundleDir}`, options.outputMetroDir);
+});

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

@@ -0,0 +1,25 @@
+import fs from "fs";
+import path from "path";
+export async function createReleaseHistory(targetVersion, setReleaseHistory, platform, identifier, app) {
+    const BINARY_RELEASE = {
+        enabled: true,
+        mandatory: false,
+        downloadUrl: "",
+        packageHash: "",
+    };
+    const INITIAL_HISTORY = {
+        [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/dist/commands/createHistoryCommand/createReleaseHistoryList.js

@@ -0,0 +1,27 @@
+import fs from "fs";
+import path from "path";
+/**
+ * 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, getBinaryVersionList, setBinaryVersionList, platform, identifier, app) {
+    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/dist/commands/createHistoryCommand/index.js

@@ -0,0 +1,20 @@
+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";
+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) => {
+    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/dist/commands/createPullRequestHistoryCommand/createPullRequestHistory.js

@@ -0,0 +1,23 @@
+import fs from "fs";
+import path from "path";
+/**
+ * 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, binaryVersion, platform, identifier, app) {
+    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/dist/commands/createPullRequestHistoryCommand/index.js

@@ -0,0 +1,15 @@
+import { program, Option } from "commander";
+import { findAndReadConfigFile } from "../../utils/fsUtils.js";
+import { createPullRequestHistory } from "./createPullRequestHistory.js";
+import { CONFIG_FILE_NAME } from "../../constant.js";
+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) => {
+    const config = findAndReadConfigFile(process.cwd(), options.config);
+    await createPullRequestHistory(config.setReleaseHistory, options.binaryVersion, options.platform, options.identifier, options.app);
+});