@viettelpost/react-native-ota 0.1.0

package/lib/OTAClient.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentOTAStatus = exports.sync = exports.checkAndInstallOTA = void 0;
+const react_native_1 = require("react-native");
+const NativeOTAUpdate_1 = require("./NativeOTAUpdate");
+const config_1 = require("./config");
+function buildCheckUpdateURL(baseURL, currentVersion, checkUpdatePath = '/api/ota/check-update') {
+    const platform = react_native_1.Platform.OS === 'ios' ? 'ios' : 'android';
+    const normalizedBaseURL = baseURL.replace(/\/+$/, '');
+    const normalizedPath = checkUpdatePath.startsWith('/')
+        ? checkUpdatePath
+        : `/${checkUpdatePath}`;
+    return `${normalizedBaseURL}${normalizedPath}?platform=${platform}&currentVersion=${encodeURIComponent(currentVersion)}`;
+}
+async function fetchUpdateMetadata(url, headers) {
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json', ...headers },
+    });
+    if (response.status === 204) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`OTA check-update failed: HTTP ${response.status}`);
+    }
+    const data = (await response.json());
+    const required = ['version', 'bundleUrl', 'fileName', 'platform', 'sha256', 'signature'];
+    for (const field of required) {
+        if (typeof data[field] !== 'string' || !data[field].trim()) {
+            throw new Error(`OTA check-update response missing required field: ${field}`);
+        }
+    }
+    return data;
+}
+function toPayload(r) {
+    return {
+        version: r.version,
+        bundleUrl: r.bundleUrl,
+        platform: r.platform,
+        fileName: r.fileName,
+        sha256: r.sha256,
+        signature: r.signature,
+        assetsUrl: r.assetsUrl,
+        assetsSha256: r.assetsSha256,
+    };
+}
+async function checkAndInstallOTA(otaBaseURL, options = {}) {
+    try {
+        const metadata = await (0, NativeOTAUpdate_1.getOTAMetadata)();
+        const currentVersion = metadata.activeBundleVersion || metadata.embeddedBundleVersion;
+        const url = buildCheckUpdateURL(otaBaseURL, currentVersion, options.checkUpdatePath);
+        const update = await fetchUpdateMetadata(url, await (0, config_1.resolveHeaders)(options.headers));
+        if (!update) {
+            return { success: true, version: currentVersion, alreadyUpToDate: true };
+        }
+        const expectedPlatform = react_native_1.Platform.OS === 'ios' ? 'ios' : 'android';
+        if (update.platform !== expectedPlatform) {
+            return {
+                success: false,
+                code: 'OTA_PLATFORM_MISMATCH',
+                message: `Server returned platform=${update.platform}, expected ${expectedPlatform}`,
+            };
+        }
+        if (metadata.activeBundleVersion === update.version) {
+            return { success: true, version: update.version, alreadyUpToDate: true };
+        }
+        const didInstall = await (0, NativeOTAUpdate_1.downloadAndInstallBundle)(toPayload(update));
+        if (!didInstall) {
+            return {
+                success: false,
+                code: 'OTA_INSTALL_FAILED',
+                message: `Failed to install OTA update version ${update.version}`,
+            };
+        }
+        return { success: true, version: update.version };
+    }
+    catch (error) {
+        return {
+            success: false,
+            code: 'OTA_SERVICE_ERROR',
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+exports.checkAndInstallOTA = checkAndInstallOTA;
+async function sync() {
+    const config = (0, config_1.getConfig)();
+    return checkAndInstallOTA(config.baseURL, {
+        headers: config.headers,
+        checkUpdatePath: config.checkUpdatePath,
+    });
+}
+exports.sync = sync;
+async function getCurrentOTAStatus() {
+    const [metadata, bundleInfo] = await Promise.all([
+        (0, NativeOTAUpdate_1.getOTAMetadata)(),
+        (0, NativeOTAUpdate_1.getCurrentBundleInfo)(),
+    ]);
+    return { metadata, bundleInfo };
+}
+exports.getCurrentOTAStatus = getCurrentOTAStatus;

package/lib/config.d.ts

@@ -0,0 +1,14 @@
+export type OTAHeaders = Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+export type OTAConfig = {
+    baseURL: string;
+    headers?: OTAHeaders;
+    checkUpdatePath?: string;
+    publicKey?: string;
+    policy?: {
+        autoInstall?: boolean;
+        restart?: 'manual' | 'immediate';
+    };
+};
+export declare function configure(config: OTAConfig): void;
+export declare function getConfig(): OTAConfig;
+export declare function resolveHeaders(headers?: OTAHeaders): Promise<Record<string, string>>;

package/lib/config.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHeaders = exports.getConfig = exports.configure = void 0;
+let currentConfig = null;
+function configure(config) {
+    if (!config.baseURL || !config.baseURL.trim()) {
+        throw new Error('OTA.configure requires a non-empty baseURL');
+    }
+    currentConfig = {
+        ...config,
+        baseURL: config.baseURL.replace(/\/+$/, ''),
+        checkUpdatePath: config.checkUpdatePath || '/api/ota/check-update',
+    };
+}
+exports.configure = configure;
+function getConfig() {
+    if (!currentConfig) {
+        throw new Error('OTA is not configured. Call OTA.configure({ baseURL }) before syncing.');
+    }
+    return currentConfig;
+}
+exports.getConfig = getConfig;
+async function resolveHeaders(headers) {
+    if (!headers) {
+        return {};
+    }
+    return typeof headers === 'function' ? headers() : headers;
+}
+exports.resolveHeaders = resolveHeaders;

package/lib/devtools.d.ts

@@ -0,0 +1,10 @@
+import { type OTAUpdatePayload } from './NativeOTAUpdate';
+export declare function logOTAInfo(): Promise<{
+    directory: string;
+    metadata: import("./NativeOTAUpdate").OTAMetadata;
+    bundleInfo: import("./NativeOTAUpdate").OTABundleInfo;
+}>;
+export declare function confirmOTASuccess(): Promise<boolean>;
+export declare function downloadAndInstallOTA(update: OTAUpdatePayload): Promise<boolean>;
+export declare function logOTADiskUsage(): Promise<import("./NativeOTAUpdate").OTADiskUsage>;
+export declare function cleanupOTADevStorage(): Promise<boolean>;

package/lib/devtools.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupOTADevStorage = exports.logOTADiskUsage = exports.downloadAndInstallOTA = exports.confirmOTASuccess = exports.logOTAInfo = void 0;
+const NativeOTAUpdate_1 = require("./NativeOTAUpdate");
+function warnIfNotDev() {
+    if (!__DEV__) {
+        console.warn('OTADevTools is intended only for manual OTA testing.');
+    }
+}
+async function logOTAInfo() {
+    warnIfNotDev();
+    const [directory, metadata, bundleInfo] = await Promise.all([
+        (0, NativeOTAUpdate_1.getOTADirectory)(),
+        (0, NativeOTAUpdate_1.getOTAMetadata)(),
+        (0, NativeOTAUpdate_1.getCurrentBundleInfo)(),
+    ]);
+    console.log('OTA directory:', directory);
+    console.log('OTA metadata:', metadata);
+    console.log('OTA bundle info:', bundleInfo);
+    return { directory, metadata, bundleInfo };
+}
+exports.logOTAInfo = logOTAInfo;
+async function confirmOTASuccess() {
+    warnIfNotDev();
+    const didMarkSuccess = await (0, NativeOTAUpdate_1.markOTASuccess)();
+    console.log('OTA success marked:', didMarkSuccess);
+    return didMarkSuccess;
+}
+exports.confirmOTASuccess = confirmOTASuccess;
+async function downloadAndInstallOTA(update) {
+    warnIfNotDev();
+    const didInstall = await (0, NativeOTAUpdate_1.downloadAndInstallBundle)(update);
+    const downloadInfo = await (0, NativeOTAUpdate_1.getDownloadInfo)(update.version);
+    console.log('OTA downloaded install prepared:', didInstall, update.version);
+    console.log('OTA download info:', downloadInfo);
+    return didInstall;
+}
+exports.downloadAndInstallOTA = downloadAndInstallOTA;
+async function logOTADiskUsage() {
+    warnIfNotDev();
+    const diskUsage = await (0, NativeOTAUpdate_1.getOTADiskUsage)();
+    console.log('OTA disk usage:', diskUsage);
+    return diskUsage;
+}
+exports.logOTADiskUsage = logOTADiskUsage;
+async function cleanupOTADevStorage() {
+    warnIfNotDev();
+    const didCleanup = await (0, NativeOTAUpdate_1.cleanupOTAStorage)();
+    const diskUsage = await (0, NativeOTAUpdate_1.getOTADiskUsage)();
+    console.log('OTA cleanup completed:', didCleanup);
+    console.log('OTA disk usage after cleanup:', diskUsage);
+    return didCleanup;
+}
+exports.cleanupOTADevStorage = cleanupOTADevStorage;

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+import { configure, getConfig, type OTAConfig } from './config';
+import { checkAndInstallOTA, getCurrentOTAStatus, sync, type OTACheckUpdateResponse, type OTAUpdateResult } from './OTAClient';
+import { cleanupOTAStorage, copyBundleFromDocuments, downloadAndInstallBundle, getCurrentBundleInfo, getDownloadInfo, getOTADirectory, getOTADiskUsage, getOTAMetadata, markOTASuccess, prepareManualInstall, resetOTAMetadata, type OTABundleInfo, type OTADiskUsage, type OTADownloadInfo, type OTAMetadata, type OTAStatus, type OTAUpdatePayload } from './NativeOTAUpdate';
+export type { OTAConfig, OTACheckUpdateResponse, OTAUpdateResult, OTABundleInfo, OTADiskUsage, OTADownloadInfo, OTAMetadata, OTAStatus, OTAUpdatePayload, };
+export { checkAndInstallOTA, cleanupOTAStorage, configure, copyBundleFromDocuments, downloadAndInstallBundle, getConfig, getCurrentBundleInfo, getCurrentOTAStatus, getDownloadInfo, getOTADirectory, getOTADiskUsage, getOTAMetadata, markOTASuccess, prepareManualInstall, resetOTAMetadata, sync, };
+export declare const OTA: {
+    configure: typeof configure;
+    sync: typeof sync;
+    checkAndInstall: typeof checkAndInstallOTA;
+    markSuccess: typeof markOTASuccess;
+    getMetadata: typeof getOTAMetadata;
+    getCurrentBundleInfo: typeof getCurrentBundleInfo;
+    getCurrentStatus: typeof getCurrentOTAStatus;
+    cleanupStorage: typeof cleanupOTAStorage;
+};

package/lib/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTA = exports.sync = exports.resetOTAMetadata = exports.prepareManualInstall = exports.markOTASuccess = exports.getOTAMetadata = exports.getOTADiskUsage = exports.getOTADirectory = exports.getDownloadInfo = exports.getCurrentOTAStatus = exports.getCurrentBundleInfo = exports.getConfig = exports.downloadAndInstallBundle = exports.copyBundleFromDocuments = exports.configure = exports.cleanupOTAStorage = exports.checkAndInstallOTA = void 0;
+const config_1 = require("./config");
+Object.defineProperty(exports, "configure", { enumerable: true, get: function () { return config_1.configure; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
+const OTAClient_1 = require("./OTAClient");
+Object.defineProperty(exports, "checkAndInstallOTA", { enumerable: true, get: function () { return OTAClient_1.checkAndInstallOTA; } });
+Object.defineProperty(exports, "getCurrentOTAStatus", { enumerable: true, get: function () { return OTAClient_1.getCurrentOTAStatus; } });
+Object.defineProperty(exports, "sync", { enumerable: true, get: function () { return OTAClient_1.sync; } });
+const NativeOTAUpdate_1 = require("./NativeOTAUpdate");
+Object.defineProperty(exports, "cleanupOTAStorage", { enumerable: true, get: function () { return NativeOTAUpdate_1.cleanupOTAStorage; } });
+Object.defineProperty(exports, "copyBundleFromDocuments", { enumerable: true, get: function () { return NativeOTAUpdate_1.copyBundleFromDocuments; } });
+Object.defineProperty(exports, "downloadAndInstallBundle", { enumerable: true, get: function () { return NativeOTAUpdate_1.downloadAndInstallBundle; } });
+Object.defineProperty(exports, "getCurrentBundleInfo", { enumerable: true, get: function () { return NativeOTAUpdate_1.getCurrentBundleInfo; } });
+Object.defineProperty(exports, "getDownloadInfo", { enumerable: true, get: function () { return NativeOTAUpdate_1.getDownloadInfo; } });
+Object.defineProperty(exports, "getOTADirectory", { enumerable: true, get: function () { return NativeOTAUpdate_1.getOTADirectory; } });
+Object.defineProperty(exports, "getOTADiskUsage", { enumerable: true, get: function () { return NativeOTAUpdate_1.getOTADiskUsage; } });
+Object.defineProperty(exports, "getOTAMetadata", { enumerable: true, get: function () { return NativeOTAUpdate_1.getOTAMetadata; } });
+Object.defineProperty(exports, "markOTASuccess", { enumerable: true, get: function () { return NativeOTAUpdate_1.markOTASuccess; } });
+Object.defineProperty(exports, "prepareManualInstall", { enumerable: true, get: function () { return NativeOTAUpdate_1.prepareManualInstall; } });
+Object.defineProperty(exports, "resetOTAMetadata", { enumerable: true, get: function () { return NativeOTAUpdate_1.resetOTAMetadata; } });
+exports.OTA = {
+    configure: config_1.configure,
+    sync: OTAClient_1.sync,
+    checkAndInstall: OTAClient_1.checkAndInstallOTA,
+    markSuccess: NativeOTAUpdate_1.markOTASuccess,
+    getMetadata: NativeOTAUpdate_1.getOTAMetadata,
+    getCurrentBundleInfo: NativeOTAUpdate_1.getCurrentBundleInfo,
+    getCurrentStatus: OTAClient_1.getCurrentOTAStatus,
+    cleanupStorage: NativeOTAUpdate_1.cleanupOTAStorage,
+};

package/lib/spec/NativeOTAUpdate.d.ts

@@ -0,0 +1,16 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    getMetadata(): Promise<string>;
+    resetMetadata(): Promise<boolean>;
+    getOTADirectory(): Promise<string>;
+    prepareManualInstall(bundleVersion: string): Promise<boolean>;
+    markSuccess(): Promise<boolean>;
+    copyBundleFromDocuments(bundleVersion: string, fileName: string): Promise<boolean>;
+    getCurrentBundleInfo(): Promise<string>;
+    downloadAndInstallBundle(updateJson: string): Promise<boolean>;
+    getDownloadInfo(version: string): Promise<string>;
+    getOTADiskUsage(): Promise<string>;
+    cleanupOTAStorage(): Promise<boolean>;
+}
+declare const _default: Spec;
+export default _default;

package/lib/spec/NativeOTAUpdate.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.TurboModuleRegistry.getEnforcing('OTAUpdate');

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@viettelpost/react-native-ota",
+  "version": "0.1.0",
+  "description": "ViettelPost React Native OTA runtime and deploy CLI",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "android",
+    "bin",
+    "docs",
+    "ios",
+    "lib",
+    "scripts",
+    "src",
+    "react-native-ota.podspec",
+    "README.md"
+  ],
+  "bin": {
+    "ota": "bin/ota.js"
+  },
+  "scripts": {
+    "build": "node scripts/run-bin.js tsc -p tsconfig.build.json",
+    "prepack": "yarn build",
+    "test": "node scripts/run-bin.js jest",
+    "typecheck": "node scripts/run-bin.js tsc --noEmit",
+    "ota": "node bin/ota.js"
+  },
+  "dependencies": {
+    "archiver": "^8.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.77.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.13",
+    "@types/react": "^18.2.6",
+    "@types/react-native": "^0.72.8",
+    "jest": "^29.6.3",
+    "typescript": "5.0.4"
+  },
+  "codegenConfig": {
+    "name": "ReactNativeOtaSpec",
+    "type": "modules",
+    "jsSrcsDir": "src/spec",
+    "android": {
+      "javaPackageName": "com.viettelpost.otakit"
+    },
+    "ios": {
+      "modulesProvider": {
+        "OTAUpdate": "OTAUpdateModule"
+      }
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED",
+  "directories": {
+    "doc": "docs",
+    "example": "example",
+    "lib": "lib"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/InfinityX-Solutions/react-native-ota.git"
+  },
+  "keywords": [
+    "react-native-ota",
+    "viettelpost",
+    "ota-update"
+  ],
+  "author": "tranduc.250901@gmail.com",
+  "bugs": {
+    "url": "https://github.com/InfinityX-Solutions/react-native-ota/issues"
+  },
+  "homepage": "https://github.com/InfinityX-Solutions/react-native-ota#readme"
+}

package/react-native-ota.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-ota"
+  s.module_name  = "ReactNativeOta"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://www.npmjs.com/package/@viettelpost/react-native-ota"
+  s.license      = { :type => "UNLICENSED" }
+  s.author       = { "ViettelPost" => "dev@viettelpost.vn" }
+  s.platforms    = { :ios => "13.4" }
+  s.source       = { :http => "https://registry.npmjs.org/@viettelpost/react-native-ota/-/react-native-ota-#{s.version}.tgz" }
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.resources    = "ios/ota_public_key.pem"
+  s.swift_version = "5.0"
+  s.requires_arc = true
+
+  install_modules_dependencies(s)
+end

package/scripts/run-bin.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const BIN_MODULES = {
+  jest: 'jest/bin/jest.js',
+  tsc: 'typescript/bin/tsc',
+};
+
+function resolveBinExecutable(command, base) {
+  const binName = process.platform === 'win32' ? `${command}.cmd` : command;
+  const binPath = path.join(base, 'node_modules', '.bin', binName);
+  try {
+    require('fs').accessSync(binPath);
+    return binPath;
+  } catch {
+    return null;
+  }
+}
+
+function resolveBin(command) {
+  const modulePath = BIN_MODULES[command];
+  if (!modulePath) {
+    throw new Error(`Unsupported package script command: ${command}`);
+  }
+
+  const searchPaths = [
+    process.cwd(),
+    path.resolve(process.cwd(), '..'),
+  ];
+
+  for (const base of searchPaths) {
+    const binPath = resolveBinExecutable(command, base);
+    if (binPath) {
+      return { command: binPath, args: [] };
+    }
+
+    try {
+      return {
+        command: process.execPath,
+        args: [require.resolve(modulePath, { paths: [base] })],
+      };
+    } catch {
+      // Continue searching. This package is built both standalone and inside the app repo.
+    }
+  }
+
+  throw new Error(`Unable to resolve ${modulePath}. Run yarn install before executing this script.`);
+}
+
+const [, , command, ...args] = process.argv;
+
+if (!command) {
+  console.error('Usage: node scripts/run-bin.js <jest|tsc> [...args]');
+  process.exit(1);
+}
+
+const resolved = resolveBin(command);
+const result = spawnSync(
+  resolved.command,
+  [...resolved.args, ...args],
+  { cwd: process.cwd(), stdio: 'inherit' },
+);
+
+process.exit(result.status === null ? 1 : result.status);

package/src/NativeOTAUpdate.ts

@@ -0,0 +1,144 @@
+import { Platform } from 'react-native';
+import NativeOTAUpdate from './spec/NativeOTAUpdate';
+
+export type OTAStatus =
+  | 'active'
+  | 'downloading'
+  | 'download_failed'
+  | 'downloaded'
+  | 'verifying'
+  | 'verified'
+  | 'verify_failed'
+  | 'pending'
+  | 'failed'
+  | 'rolled_back';
+
+export type OTAMetadata = {
+  schemaVersion: number;
+  embeddedBundleVersion: string;
+  activeBundleVersion: string;
+  previousBundleVersion: string | null;
+  pendingBundleVersion: string | null;
+  failedBundleVersion: string | null;
+  runningBundleVersion: string;
+  status: OTAStatus;
+  launchCountForPending: number;
+  lastSuccessfulLaunchAt: string | null;
+  lastFailureReason: string | null;
+};
+
+export type OTABundleInfo = {
+  runningBundleVersion: string;
+  activeBundleVersion: string;
+  pendingBundleVersion: string | null;
+  status: OTAStatus;
+  bundlePath: string | null;
+  assetsDirectoryPath?: string | null;
+  assetsDirectoryExists?: boolean;
+  isEmbedded: boolean;
+};
+
+export type OTAUpdatePayload = {
+  version: string;
+  bundleUrl: string;
+  platform: 'android' | 'ios';
+  fileName: string;
+  sha256: string;
+  signature: string;
+  assetsUrl?: string;
+  assetsSha256?: string;
+};
+
+export type OTADownloadInfo = {
+  version: string;
+  tempBundlePath: string;
+  finalBundlePath: string;
+  tempAssetsZipPath: string;
+  finalAssetsDirectoryPath: string;
+  tempExists: boolean;
+  finalExists: boolean;
+  tempAssetsZipExists: boolean;
+  finalAssetFileCount: number;
+  tempSize: number;
+  finalSize: number;
+  tempAssetsZipSize: number;
+  finalAssetsSize: number;
+  tempSha256: string | null;
+  finalSha256: string | null;
+  tempAssetsSha256: string | null;
+  signatureRequired: boolean;
+};
+
+export type OTADiskUsage = {
+  otaRootPath: string;
+  totalBytes: number;
+  tmpBytes: number;
+  bundlesBytes: number;
+  bundles: Array<{
+    version: string;
+    bytes: number;
+    isActive: boolean;
+    isPending: boolean;
+    isFailed: boolean;
+  }>;
+};
+
+export async function getOTAMetadata(): Promise<OTAMetadata> {
+  const metadata = await NativeOTAUpdate.getMetadata();
+  return JSON.parse(metadata) as OTAMetadata;
+}
+
+export async function resetOTAMetadata(): Promise<boolean> {
+  return NativeOTAUpdate.resetMetadata();
+}
+
+export async function getOTADirectory(): Promise<string> {
+  return NativeOTAUpdate.getOTADirectory();
+}
+
+export async function prepareManualInstall(
+  bundleVersion: string,
+): Promise<boolean> {
+  return NativeOTAUpdate.prepareManualInstall(bundleVersion);
+}
+
+export async function markOTASuccess(): Promise<boolean> {
+  return NativeOTAUpdate.markSuccess();
+}
+
+export async function copyBundleFromDocuments(
+  bundleVersion: string,
+  fileName: string,
+): Promise<boolean> {
+  if (Platform.OS !== 'ios') {
+    return false;
+  }
+  return NativeOTAUpdate.copyBundleFromDocuments(bundleVersion, fileName);
+}
+
+export async function getCurrentBundleInfo(): Promise<OTABundleInfo> {
+  const bundleInfo = await NativeOTAUpdate.getCurrentBundleInfo();
+  return JSON.parse(bundleInfo) as OTABundleInfo;
+}
+
+export async function downloadAndInstallBundle(
+  update: OTAUpdatePayload,
+): Promise<boolean> {
+  return NativeOTAUpdate.downloadAndInstallBundle(JSON.stringify(update));
+}
+
+export async function getDownloadInfo(
+  version: string,
+): Promise<OTADownloadInfo> {
+  const downloadInfo = await NativeOTAUpdate.getDownloadInfo(version);
+  return JSON.parse(downloadInfo) as OTADownloadInfo;
+}
+
+export async function getOTADiskUsage(): Promise<OTADiskUsage> {
+  const diskUsage = await NativeOTAUpdate.getOTADiskUsage();
+  return JSON.parse(diskUsage) as OTADiskUsage;
+}
+
+export async function cleanupOTAStorage(): Promise<boolean> {
+  return NativeOTAUpdate.cleanupOTAStorage();
+}