@viettelpost/react-native-ota 0.1.0

package/ios/OTAUpdateMetadata.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+struct OTAUpdateMetadata: Codable {
+  var schemaVersion: Int
+  var embeddedBundleVersion: String
+  var activeBundleVersion: String
+  var previousBundleVersion: String?
+  var pendingBundleVersion: String?
+  var failedBundleVersion: String?
+  var runningBundleVersion: String
+  var status: String
+  var launchCountForPending: Int
+  var lastSuccessfulLaunchAt: String?
+  var lastFailureReason: String?
+
+  static func `default`() -> OTAUpdateMetadata {
+    OTAUpdateMetadata(
+      schemaVersion: 1,
+      embeddedBundleVersion: "embedded",
+      activeBundleVersion: "embedded",
+      previousBundleVersion: nil,
+      pendingBundleVersion: nil,
+      failedBundleVersion: nil,
+      runningBundleVersion: "embedded",
+      status: "active",
+      launchCountForPending: 0,
+      lastSuccessfulLaunchAt: nil,
+      lastFailureReason: nil
+    )
+  }
+
+  static func metadataParseFailed() -> OTAUpdateMetadata {
+    OTAUpdateMetadata(
+      schemaVersion: 1,
+      embeddedBundleVersion: "embedded",
+      activeBundleVersion: "embedded",
+      previousBundleVersion: nil,
+      pendingBundleVersion: nil,
+      failedBundleVersion: nil,
+      runningBundleVersion: "embedded",
+      status: "failed",
+      launchCountForPending: 0,
+      lastSuccessfulLaunchAt: nil,
+      lastFailureReason: "metadata_parse_failed"
+    )
+  }
+}

package/ios/OTAUpdateModule.mm

@@ -0,0 +1,190 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <ReactCommon/RCTTurboModule.h>
+#import "ReactNativeOta-Swift.h"
+#import <ReactNativeOtaSpec/ReactNativeOtaSpec.h>
+
+@interface OTAUpdateModule : NSObject <NativeOTAUpdateSpec>
+@end
+
+@implementation OTAUpdateModule
+
+RCT_EXPORT_MODULE(OTAUpdate)
+
+static NSString *OTARejectCodeFromError(NSError *error, NSString *fallbackCode)
+{
+  NSString *code = error.userInfo[@"otaCode"];
+  if (code.length > 0) {
+    return code;
+  }
+  return fallbackCode;
+}
+
+static NSString *OTARejectMessageFromError(NSError *error, NSString *fallbackMessage)
+{
+  NSString *code = OTARejectCodeFromError(error, @"");
+  if ([code isEqualToString:@"OTA_SIGNATURE_INVALID"]) {
+    return @"OTA signature mismatch. Check that version, platform, fileName, lowercase sha256, and assetsSha256 when assets are included match the signed payload exactly.";
+  }
+
+  NSString *message = error.userInfo[NSLocalizedDescriptionKey];
+  if (message.length > 0) {
+    return message;
+  }
+  return fallbackMessage;
+}
+
+- (void)getMetadata:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSString *metadata = [[OTAUpdateStorage shared] getMetadataJSONStringAndReturnError:&error];
+  if (error != nil || metadata == nil) {
+    reject(@"OTA_GET_METADATA_FAILED", @"Failed to read OTA metadata", error);
+    return;
+  }
+
+  resolve(metadata);
+}
+
+- (void)resetMetadata:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSNumber *didReset = [[OTAUpdateStorage shared] resetMetadataAndReturnError:&error];
+  if (error != nil || didReset == nil) {
+    reject(@"OTA_RESET_METADATA_FAILED", @"Failed to reset OTA metadata", error);
+    return;
+  }
+
+  resolve(didReset);
+}
+
+- (void)getOTADirectory:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSString *directory = [[OTAUpdateBundleResolver shared] getOTADirectoryPathAndReturnError:&error];
+  if (error != nil || directory == nil) {
+    reject(@"OTA_GET_DIRECTORY_FAILED", @"Failed to read OTA directory", error);
+    return;
+  }
+
+  resolve(directory);
+}
+
+- (void)prepareManualInstall:(NSString *)bundleVersion resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSNumber *didPrepare = [[OTAUpdateBundleResolver shared] prepareManualInstall:bundleVersion error:&error];
+  if (error != nil || didPrepare == nil) {
+    NSString *code = @"OTA_PREPARE_MANUAL_INSTALL_FAILED";
+    if (error.code == 1) {
+      code = @"OTA_INVALID_BUNDLE_VERSION";
+    } else if (error.code == 2) {
+      code = @"OTA_BUNDLE_FILE_NOT_FOUND";
+    }
+    reject(code, @"Failed to prepare OTA manual install", error);
+    return;
+  }
+
+  resolve(didPrepare);
+}
+
+- (void)markSuccess:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSNumber *didMarkSuccess = [[OTAUpdateBundleResolver shared] markSuccessAndReturnError:&error];
+  if (error != nil || didMarkSuccess == nil) {
+    reject(@"OTA_MARK_SUCCESS_FAILED", @"Failed to mark OTA success", error);
+    return;
+  }
+
+  resolve(didMarkSuccess);
+}
+
+- (void)copyBundleFromDocuments:(NSString *)bundleVersion fileName:(NSString *)fileName resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSNumber *didCopy = [[OTAUpdateBundleResolver shared] copyBundleFromDocuments:bundleVersion fileName:fileName error:&error];
+  if (error != nil || didCopy == nil) {
+    NSString *code = @"OTA_COPY_FROM_DOCUMENTS_FAILED";
+    if (error.code == 1) {
+      code = @"OTA_INVALID_BUNDLE_VERSION";
+    } else if (error.code == 2) {
+      code = @"OTA_BUNDLE_FILE_NOT_FOUND";
+    }
+    reject(code, @"Failed to copy OTA bundle from Documents", error);
+    return;
+  }
+
+  resolve(didCopy);
+}
+
+- (void)getCurrentBundleInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSString *bundleInfo = [[OTAUpdateBundleResolver shared] getCurrentBundleInfoJSONStringAndReturnError:&error];
+  if (error != nil || bundleInfo == nil) {
+    reject(@"OTA_GET_CURRENT_BUNDLE_INFO_FAILED", @"Failed to read OTA bundle info", error);
+    return;
+  }
+
+  resolve(bundleInfo);
+}
+
+- (void)downloadAndInstallBundle:(NSString *)updateJson resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [[OTAUpdateDownloader shared] downloadAndInstallBundle:updateJson completion:^(NSNumber *didInstall, NSError *error) {
+    if (error != nil || didInstall == nil) {
+      reject(OTARejectCodeFromError(error, @"OTA_DOWNLOAD_AND_INSTALL_FAILED"), OTARejectMessageFromError(error, @"Failed to download and install OTA bundle"), error);
+      return;
+    }
+
+    resolve(didInstall);
+  }];
+}
+
+- (void)getDownloadInfo:(NSString *)version resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSString *downloadInfo = [[OTAUpdateDownloader shared] getDownloadInfo:version error:&error];
+  if (error != nil || downloadInfo == nil) {
+    reject(OTARejectCodeFromError(error, @"OTA_GET_DOWNLOAD_INFO_FAILED"), @"Failed to read OTA download info", error);
+    return;
+  }
+
+  resolve(downloadInfo);
+}
+
+- (void)getOTADiskUsage:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSString *diskUsage = [[OTAUpdateCleanup shared] getOTADiskUsageJSONStringAndReturnError:&error];
+  if (error != nil || diskUsage == nil) {
+    reject(@"OTA_GET_DISK_USAGE_FAILED", @"Failed to read OTA disk usage", error);
+    return;
+  }
+
+  resolve(diskUsage);
+}
+
+- (void)cleanupOTAStorage:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  NSError *error = nil;
+  NSNumber *didCleanup = [[OTAUpdateCleanup shared] cleanupOTAStorageAndReturnError:&error];
+  if (error != nil || didCleanup == nil) {
+    reject(@"OTA_CLEANUP_STORAGE_FAILED", @"Failed to cleanup OTA storage", error);
+    return;
+  }
+
+  resolve(didCleanup);
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeOTAUpdateSpecJSI>(params);
+}
+
+@end
+#endif

package/ios/OTAUpdateSignatureVerifier.swift

@@ -0,0 +1,81 @@
+import Foundation
+import Security
+
+enum OTAUpdateSignatureVerifier {
+  static func canonicalPayload(
+    version: String,
+    platform: String,
+    fileName: String,
+    sha256: String,
+    assetsSha256: String? = nil
+  ) -> String {
+    var lines = [
+      "version=\(version)",
+      "platform=\(platform)",
+      "fileName=\(fileName)",
+      "sha256=\(sha256)",
+    ]
+    if let assetsSha256 = assetsSha256?.trimmingCharacters(in: .whitespacesAndNewlines), !assetsSha256.isEmpty {
+      lines.append("assetsSha256=\(assetsSha256.lowercased())")
+    }
+    return lines.joined(separator: "\n")
+  }
+
+  static func verifySignature(canonicalPayload: String, base64Signature: String) throws -> Bool {
+    let publicKey = try loadPublicKey()
+    guard let signatureData = Data(base64Encoded: base64Signature, options: [.ignoreUnknownCharacters]) else {
+      return false
+    }
+    guard let payloadData = canonicalPayload.data(using: .utf8) else {
+      return false
+    }
+
+    var error: Unmanaged<CFError>?
+    let isValid = SecKeyVerifySignature(
+      publicKey,
+      .rsaSignatureMessagePKCS1v15SHA256,
+      payloadData as CFData,
+      signatureData as CFData,
+      &error
+    )
+    if let error = error {
+      throw error.takeRetainedValue() as Error
+    }
+    return isValid
+  }
+
+  private static func loadPublicKey() throws -> SecKey {
+    let url = Bundle.main.url(forResource: "ota_public_key", withExtension: "pem")
+      ?? Bundle(for: OTAUpdateStorage.self).url(forResource: "ota_public_key", withExtension: "pem")
+
+    guard let url = url else {
+      throw OTAUpdateDownloaderError(code: "OTA_PUBLIC_KEY_NOT_FOUND", message: "OTA public key resource was not found")
+    }
+
+    let pem = try String(contentsOf: url, encoding: .utf8)
+    let normalizedPem = pem
+      .replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----", with: "")
+      .replacingOccurrences(of: "-----END PUBLIC KEY-----", with: "")
+      .components(separatedBy: .whitespacesAndNewlines)
+      .joined()
+
+    guard let keyData = Data(base64Encoded: normalizedPem) else {
+      throw OTAUpdateDownloaderError(code: "OTA_PUBLIC_KEY_INVALID", message: "OTA public key PEM is invalid")
+    }
+
+    let attributes: [String: Any] = [
+      kSecAttrKeyType as String: kSecAttrKeyTypeRSA,
+      kSecAttrKeyClass as String: kSecAttrKeyClassPublic,
+      kSecAttrKeySizeInBits as String: 2048,
+    ]
+
+    var error: Unmanaged<CFError>?
+    guard let key = SecKeyCreateWithData(keyData as CFData, attributes as CFDictionary, &error) else {
+      if let error = error {
+        throw error.takeRetainedValue() as Error
+      }
+      throw OTAUpdateDownloaderError(code: "OTA_PUBLIC_KEY_INVALID", message: "Unable to create OTA public key")
+    }
+    return key
+  }
+}

package/ios/OTAUpdateStorage.swift

@@ -0,0 +1,83 @@
+import Foundation
+
+@objc(OTAUpdateStorage)
+final class OTAUpdateStorage: NSObject {
+  @objc static let shared = OTAUpdateStorage()
+
+  private let encoder: JSONEncoder
+  private let decoder: JSONDecoder
+  private let fileManager: FileManager
+
+  override init() {
+    encoder = JSONEncoder()
+    decoder = JSONDecoder()
+    fileManager = FileManager.default
+    super.init()
+  }
+
+  @objc func getMetadataJSONString() throws -> String {
+    let metadata = try readMetadata()
+    let data = try encoder.encode(metadata)
+    guard let jsonString = String(data: data, encoding: .utf8) else {
+      throw OTAUpdateStorageError.jsonEncodingFailed
+    }
+    return jsonString
+  }
+
+  @objc func resetMetadata() throws -> NSNumber {
+    try writeMetadata(.default())
+    return true as NSNumber
+  }
+
+  func readMetadata() throws -> OTAUpdateMetadata {
+    let url = try metadataURL()
+    guard fileManager.fileExists(atPath: url.path) else {
+      let metadata = OTAUpdateMetadata.default()
+      try writeMetadata(metadata)
+      return metadata
+    }
+
+    do {
+      let data = try Data(contentsOf: url)
+      return try decoder.decode(OTAUpdateMetadata.self, from: data)
+    } catch {
+      let fallback = OTAUpdateMetadata.metadataParseFailed()
+      try writeMetadata(fallback)
+      return fallback
+    }
+  }
+
+  func writeMetadata(_ metadata: OTAUpdateMetadata) throws {
+    let url = try metadataURL()
+    let directoryURL = url.deletingLastPathComponent()
+    try fileManager.createDirectory(
+      at: directoryURL,
+      withIntermediateDirectories: true,
+      attributes: nil
+    )
+
+    let data = try encoder.encode(metadata)
+    let tempURL = directoryURL.appendingPathComponent("metadata.json.tmp")
+    try data.write(to: tempURL, options: .atomic)
+
+    if fileManager.fileExists(atPath: url.path) {
+      try fileManager.removeItem(at: url)
+    }
+    try fileManager.moveItem(at: tempURL, to: url)
+  }
+
+  private func metadataURL() throws -> URL {
+    let supportURL = try fileManager.url(
+      for: .applicationSupportDirectory,
+      in: .userDomainMask,
+      appropriateFor: nil,
+      create: true
+    )
+    return supportURL.appendingPathComponent("OTA", isDirectory: true)
+      .appendingPathComponent("metadata.json")
+  }
+}
+
+enum OTAUpdateStorageError: Error {
+  case jsonEncodingFailed
+}

package/ios/OTAZipUtils.swift

@@ -0,0 +1,103 @@
+import Foundation
+import ZIPFoundation
+
+enum OTAZipUtils {
+  private static let requiredRootDirectory = "assets"
+  private static let blockedRootDirectories: Set<String> = ["proc", "sys", "data", "etc"]
+
+  static func validate(zipURL: URL) throws {
+    let archive = try openArchive(zipURL: zipURL)
+    var entryCount = 0
+
+    for entry in archive {
+      try validateEntryPath(entry.path)
+      entryCount += 1
+    }
+
+    guard entryCount > 0 else {
+      throw zipError("OTA assets ZIP is empty")
+    }
+  }
+
+  static func unzip(zipURL: URL, destinationURL: URL) throws {
+    let archive = try openArchive(zipURL: zipURL)
+    let fileManager = FileManager.default
+    try fileManager.createDirectory(at: destinationURL, withIntermediateDirectories: true, attributes: nil)
+
+    var entryCount = 0
+    for entry in archive {
+      entryCount += 1
+      let targetURL = try safeDestinationURL(for: entry.path, destinationURL: destinationURL)
+
+      switch entry.type {
+      case .directory:
+        try fileManager.createDirectory(at: targetURL, withIntermediateDirectories: true, attributes: nil)
+      case .file:
+        let parentURL = targetURL.deletingLastPathComponent()
+        try fileManager.createDirectory(at: parentURL, withIntermediateDirectories: true, attributes: nil)
+        _ = try archive.extract(entry, to: targetURL)
+      default:
+        throw zipError("OTA assets ZIP contains unsupported entry type at \(entry.path)")
+      }
+    }
+
+    guard entryCount > 0 else {
+      throw zipError("OTA assets ZIP is empty")
+    }
+  }
+
+  private static func openArchive(zipURL: URL) throws -> Archive {
+    guard let archive = Archive(url: zipURL, accessMode: .read) else {
+      throw zipError("OTA assets ZIP could not be opened")
+    }
+    return archive
+  }
+
+  private static func safeDestinationURL(for entryPath: String, destinationURL: URL) throws -> URL {
+    try validateEntryPath(entryPath)
+
+    let rootPath = destinationURL.standardizedFileURL.path
+    let targetURL = destinationURL.appendingPathComponent(entryPath).standardizedFileURL
+    let targetPath = targetURL.path
+    guard targetPath == rootPath || targetPath.hasPrefix(rootPath + "/") else {
+      throw zipError("OTA assets ZIP entry escapes destination: \(entryPath)")
+    }
+    return targetURL
+  }
+
+  private static func validateEntryPath(_ entryPath: String) throws {
+    var normalizedPath = entryPath.trimmingCharacters(in: .whitespacesAndNewlines)
+    while normalizedPath.hasSuffix("/") {
+      normalizedPath.removeLast()
+    }
+
+    guard !normalizedPath.isEmpty else {
+      throw zipError("OTA assets ZIP contains an empty path")
+    }
+    guard !normalizedPath.hasPrefix("/") && !normalizedPath.hasPrefix("\\") else {
+      throw zipError("OTA assets ZIP contains an absolute path: \(entryPath)")
+    }
+    guard !normalizedPath.contains("\\") else {
+      throw zipError("OTA assets ZIP contains a backslash path: \(entryPath)")
+    }
+
+    let components = normalizedPath.split(separator: "/", omittingEmptySubsequences: false).map(String.init)
+    guard let firstComponent = components.first?.lowercased(),
+          !blockedRootDirectories.contains(firstComponent) else {
+      throw zipError("OTA assets ZIP contains a blocked root directory: \(entryPath)")
+    }
+    guard firstComponent == requiredRootDirectory else {
+      throw zipError("OTA assets ZIP entries must be under assets/: \(entryPath)")
+    }
+
+    for component in components {
+      if component.isEmpty || component == "." || component == ".." {
+        throw zipError("OTA assets ZIP contains an unsafe path: \(entryPath)")
+      }
+    }
+  }
+
+  private static func zipError(_ message: String) -> OTAUpdateDownloaderError {
+    OTAUpdateDownloaderError(code: "OTA_ASSETS_ZIP_INVALID", message: message)
+  }
+}

package/ios/ota_public_key.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA8FidxBN6K3wQeyIGkv0l
+NvxrpkruxpTZgF10Eb2mDVcahDZqZVvEaFELhmz7++nfPdHoE1cuyoki2uLkZVeT
+thAeD2+KMwHtocnn9uELySbm25bf4/ZtvdpaTeiq+qrm9bpgdsFc+GIdGu3P2xmJ
+y/RZu9J6zcjV7SHPgPgRJ0yFXwhecmGfbVKoMYg4NWWAABR6Sr+2JoVmQRKYLkgj
+VVEZgbmS9vrDcxOpbNXILsWWEk4deiGHF/8A2JkTYA17ZFm8swNPnrBjWy+23huA
+UQoDtywNreXJLyh3+R8LAkVF+vplGQXEKViD29ZgJ2Y1xl3k1LzUMp37Qmz2zsGr
+LQIDAQAB
+-----END PUBLIC KEY-----

package/lib/NativeOTAUpdate.d.ts

@@ -0,0 +1,77 @@
+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 declare function getOTAMetadata(): Promise<OTAMetadata>;
+export declare function resetOTAMetadata(): Promise<boolean>;
+export declare function getOTADirectory(): Promise<string>;
+export declare function prepareManualInstall(bundleVersion: string): Promise<boolean>;
+export declare function markOTASuccess(): Promise<boolean>;
+export declare function copyBundleFromDocuments(bundleVersion: string, fileName: string): Promise<boolean>;
+export declare function getCurrentBundleInfo(): Promise<OTABundleInfo>;
+export declare function downloadAndInstallBundle(update: OTAUpdatePayload): Promise<boolean>;
+export declare function getDownloadInfo(version: string): Promise<OTADownloadInfo>;
+export declare function getOTADiskUsage(): Promise<OTADiskUsage>;
+export declare function cleanupOTAStorage(): Promise<boolean>;

package/lib/NativeOTAUpdate.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupOTAStorage = exports.getOTADiskUsage = exports.getDownloadInfo = exports.downloadAndInstallBundle = exports.getCurrentBundleInfo = exports.copyBundleFromDocuments = exports.markOTASuccess = exports.prepareManualInstall = exports.getOTADirectory = exports.resetOTAMetadata = exports.getOTAMetadata = void 0;
+const react_native_1 = require("react-native");
+const NativeOTAUpdate_1 = __importDefault(require("./spec/NativeOTAUpdate"));
+async function getOTAMetadata() {
+    const metadata = await NativeOTAUpdate_1.default.getMetadata();
+    return JSON.parse(metadata);
+}
+exports.getOTAMetadata = getOTAMetadata;
+async function resetOTAMetadata() {
+    return NativeOTAUpdate_1.default.resetMetadata();
+}
+exports.resetOTAMetadata = resetOTAMetadata;
+async function getOTADirectory() {
+    return NativeOTAUpdate_1.default.getOTADirectory();
+}
+exports.getOTADirectory = getOTADirectory;
+async function prepareManualInstall(bundleVersion) {
+    return NativeOTAUpdate_1.default.prepareManualInstall(bundleVersion);
+}
+exports.prepareManualInstall = prepareManualInstall;
+async function markOTASuccess() {
+    return NativeOTAUpdate_1.default.markSuccess();
+}
+exports.markOTASuccess = markOTASuccess;
+async function copyBundleFromDocuments(bundleVersion, fileName) {
+    if (react_native_1.Platform.OS !== 'ios') {
+        return false;
+    }
+    return NativeOTAUpdate_1.default.copyBundleFromDocuments(bundleVersion, fileName);
+}
+exports.copyBundleFromDocuments = copyBundleFromDocuments;
+async function getCurrentBundleInfo() {
+    const bundleInfo = await NativeOTAUpdate_1.default.getCurrentBundleInfo();
+    return JSON.parse(bundleInfo);
+}
+exports.getCurrentBundleInfo = getCurrentBundleInfo;
+async function downloadAndInstallBundle(update) {
+    return NativeOTAUpdate_1.default.downloadAndInstallBundle(JSON.stringify(update));
+}
+exports.downloadAndInstallBundle = downloadAndInstallBundle;
+async function getDownloadInfo(version) {
+    const downloadInfo = await NativeOTAUpdate_1.default.getDownloadInfo(version);
+    return JSON.parse(downloadInfo);
+}
+exports.getDownloadInfo = getDownloadInfo;
+async function getOTADiskUsage() {
+    const diskUsage = await NativeOTAUpdate_1.default.getOTADiskUsage();
+    return JSON.parse(diskUsage);
+}
+exports.getOTADiskUsage = getOTADiskUsage;
+async function cleanupOTAStorage() {
+    return NativeOTAUpdate_1.default.cleanupOTAStorage();
+}
+exports.cleanupOTAStorage = cleanupOTAStorage;

package/lib/OTAClient.d.ts

@@ -0,0 +1,27 @@
+import { type OTABundleInfo, type OTAMetadata } from './NativeOTAUpdate';
+import { type OTAConfig } from './config';
+export type OTACheckUpdateResponse = {
+    version: string;
+    bundleUrl: string;
+    fileName: string;
+    platform: 'android' | 'ios';
+    sha256: string;
+    signature: string;
+    assetsUrl?: string;
+    assetsSha256?: string;
+};
+export type OTAUpdateResult = {
+    success: true;
+    version: string;
+    alreadyUpToDate?: boolean;
+} | {
+    success: false;
+    code: string;
+    message: string;
+};
+export declare function checkAndInstallOTA(otaBaseURL: string, options?: Pick<OTAConfig, 'headers' | 'checkUpdatePath'>): Promise<OTAUpdateResult>;
+export declare function sync(): Promise<OTAUpdateResult>;
+export declare function getCurrentOTAStatus(): Promise<{
+    metadata: OTAMetadata;
+    bundleInfo: OTABundleInfo;
+}>;