@onekeyfe/react-native-bundle-update 3.0.63 → 3.0.65

package/android/src/main/java/com/margelo/nitro/reactnativebundleupdate/ReactNativeBundleUpdate.kt

@@ -1013,16 +1013,26 @@ object BundleUpdateStoreAndroid {
         }
     }
 
-    private fun deleteDirectory(directory: File) {
-        if (directory.exists()) {
-            directory.listFiles()?.forEach { file ->
-                if (file.isDirectory) deleteDirectory(file) else file.delete()
-            }
-            directory.delete()
+    /**
+     * Recursively deletes [directory], returning true only when nothing is left
+     * behind. An already-missing entry counts as success (tolerates concurrent
+     * removal); a child that fails to delete makes the whole call return false
+     * so callers never report a half-deleted tree as a clean delete.
+     */
+    private fun deleteDirectory(directory: File): Boolean {
+        if (!directory.exists()) return true
+        var allDeleted = true
+        directory.listFiles()?.forEach { file ->
+            val ok = if (file.isDirectory) deleteDirectory(file) else (!file.exists() || file.delete())
+            if (!ok) allDeleted = false
         }
+        // delete() on a non-empty dir returns false, so a child failure above
+        // naturally propagates here too.
+        val dirDeleted = !directory.exists() || directory.delete()
+        return allDeleted && dirDeleted
     }
 
-    fun deleteDir(dir: File) = deleteDirectory(dir)
+    fun deleteDir(dir: File): Boolean = deleteDirectory(dir)
 
     private const val MAX_UNZIPPED_SIZE = 512L * 1024 * 1024  // 512 MB limit
 
@@ -1757,6 +1767,148 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
         }
     }
 
+    /**
+     * Prunes every artifact whose appVersion != the running native binary
+     * version: stale onekey-bundle/<v> dirs, onekey-bundle-download/<v> stages
+     * (.zip / .partial / .progress / .resume), orphan asc signatures, and
+     * lingering fallback entries. Hard-refuses to delete the current
+     * appVersion's artifacts and the active currentBundleVersion. Tolerates
+     * already-missing files. Returns the count of deleted version directories.
+     *
+     * appVersion is parsed from the "{appVersion}-{bundleVersion}" stem using
+     * the SAME last-dash split as listLocalBundles / the installBundle fallback
+     * logic, so behavior matches the rest of the module.
+     */
+    override fun pruneStaleAppVersionBundles(): Promise<Double> {
+        BundleUpdateStoreAndroid.invalidateValidatedBundleInfoCache()
+        return Promise.async {
+            val context = getContext()
+            val currentAppV = BundleUpdateStoreAndroid.getAppVersion(context) ?: ""
+            // Safety net: never delete the bundle backing the active pointer.
+            val currentBundleVersion = BundleUpdateStoreAndroid.getCurrentBundleVersion(context)
+            OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: currentAppV=$currentAppV, currentBundleVersion=$currentBundleVersion")
+
+            // Without a known native version we cannot decide what is stale;
+            // bail out rather than risk deleting the wrong artifacts.
+            if (currentAppV.isEmpty()) {
+                OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: empty currentAppV, skipping")
+                return@async 0.0
+            }
+
+            // Parses an "{appVersion}-{bundleVersion}" stem into its appVersion
+            // component using the same last-dash split as listLocalBundles.
+            // Returns null for stems without a dash or with an empty appVersion.
+            fun appVersionFromStem(stem: String): String? {
+                val lastDash = stem.lastIndexOf('-')
+                if (lastDash <= 0) return null
+                val appV = stem.substring(0, lastDash)
+                return if (appV.isEmpty()) null else appV
+            }
+
+            // True when this entry stem must be kept: its appVersion matches the
+            // running binary, it IS the active currentBundleVersion, or it is
+            // unparseable (leave foreign names alone).
+            fun shouldKeep(stem: String): Boolean {
+                if (currentBundleVersion != null && stem == currentBundleVersion) return true
+                val appV = appVersionFromStem(stem) ?: return true
+                return appV == currentAppV
+            }
+
+            var deletedDirCount = 0
+
+            // 1. onekey-bundle/* extracted dirs
+            val bundleDir = File(BundleUpdateStoreAndroid.getBundleDir(context))
+            if (bundleDir.exists() && bundleDir.isDirectory) {
+                bundleDir.listFiles()?.forEach { child ->
+                    if (!child.isDirectory) return@forEach
+                    val name = child.name
+                    // Skip non-version entries (asc dir, fallback json, etc.)
+                    if (name == "asc" || name == "fallbackUpdateBundleData.json") return@forEach
+                    if (shouldKeep(name)) return@forEach
+                    try {
+                        if (BundleUpdateStoreAndroid.deleteDir(child)) {
+                            deletedDirCount++
+                            OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: deleted stale bundle dir $name")
+                        } else {
+                            OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: incomplete delete of bundle dir $name (left behind)")
+                        }
+                    } catch (e: Exception) {
+                        OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: failed to delete bundle dir $name: ${e.message}")
+                    }
+                }
+            }
+
+            // 2. onekey-bundle-download/* stages (zip / partial / progress / resume)
+            val downloadDir = File(BundleUpdateStoreAndroid.getDownloadBundleDir(context))
+            if (downloadDir.exists() && downloadDir.isDirectory) {
+                downloadDir.listFiles()?.forEach { file ->
+                    val name = file.name
+                    // Strip the trailing extension chain to recover the
+                    // "{appV}-{bV}" stem (e.g. "6.3.0-123.zip.partial").
+                    var stem = name
+                    for (suffix in listOf(".resume", ".progress", ".partial", ".zip")) {
+                        if (stem.endsWith(suffix)) {
+                            stem = stem.substring(0, stem.length - suffix.length)
+                        }
+                    }
+                    if (shouldKeep(stem)) return@forEach
+                    try {
+                        val deleted = if (file.isDirectory) {
+                            BundleUpdateStoreAndroid.deleteDir(file)
+                        } else {
+                            !file.exists() || file.delete()
+                        }
+                        if (deleted) {
+                            OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: deleted stale download $name")
+                        } else {
+                            OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: failed to delete download $name")
+                        }
+                    } catch (e: Exception) {
+                        OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: failed to delete download $name: ${e.message}")
+                    }
+                }
+            }
+
+            // 3. onekey-bundle/asc/*-signature.asc orphan signatures
+            val ascDir = File(BundleUpdateStoreAndroid.getAscDir(context))
+            if (ascDir.exists() && ascDir.isDirectory) {
+                val suffix = "-signature.asc"
+                ascDir.listFiles()?.forEach { file ->
+                    val name = file.name
+                    if (!name.endsWith(suffix)) return@forEach
+                    val stem = name.substring(0, name.length - suffix.length)
+                    if (shouldKeep(stem)) return@forEach
+                    try {
+                        file.delete()
+                        OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: deleted orphan asc $name")
+                    } catch (e: Exception) {
+                        OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: failed to delete asc $name: ${e.message}")
+                    }
+                }
+            }
+
+            // 4. Persisted fallback list: drop entries whose appVersion != currentAppV.
+            // Fixes the latent leak where stale fallback entries linger after a
+            // native upgrade. Reuses the existing read/write helpers.
+            try {
+                val fallbackData = BundleUpdateStoreAndroid.readFallbackUpdateBundleDataFile(context)
+                val prunedFallback = fallbackData.filter { entry ->
+                    val appV = entry["appVersion"]
+                    appV.isNullOrEmpty() || appV == currentAppV
+                }
+                if (prunedFallback.size != fallbackData.size) {
+                    BundleUpdateStoreAndroid.writeFallbackUpdateBundleDataFile(prunedFallback, context)
+                    OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: pruned fallback entries ${fallbackData.size} -> ${prunedFallback.size}")
+                }
+            } catch (e: Exception) {
+                OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: fallback prune error: ${e.message}")
+            }
+
+            OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: completed, deletedDirCount=$deletedDirCount")
+            deletedDirCount.toDouble()
+        }
+    }
+
     override fun resetToBuiltInBundle(): Promise<Unit> {
         BundleUpdateStoreAndroid.invalidateValidatedBundleInfoCache()
         return Promise.async {

package/ios/ReactNativeBundleUpdate.swift

@@ -1725,6 +1725,130 @@ class ReactNativeBundleUpdate: HybridReactNativeBundleUpdateSpec {
         }
     }
 
+    /// Parses an "{appVersion}-{bundleVersion}" folder/file stem into its
+    /// appVersion component using the SAME last-dash split as listLocalBundles
+    /// and the installBundle fallback logic. Returns nil when the stem has no
+    /// dash or an empty appVersion, so callers leave unrecognized entries
+    /// untouched.
+    private static func appVersionFromStem(_ stem: String) -> String? {
+        guard let lastDash = stem.range(of: "-", options: .backwards),
+              lastDash.lowerBound > stem.startIndex else { return nil }
+        let appVersion = String(stem[stem.startIndex..<lastDash.lowerBound])
+        return appVersion.isEmpty ? nil : appVersion
+    }
+
+    /// Prunes every artifact whose appVersion != the running native binary
+    /// version: stale onekey-bundle/* dirs, onekey-bundle-download/* stages
+    /// (.zip / .partial / .progress / .resume), orphan asc signatures, and
+    /// lingering fallback entries. Hard-refuses to delete the current
+    /// appVersion's artifacts and the active currentBundleVersion. Tolerates
+    /// already-missing files. Returns the count of deleted version directories.
+    func pruneStaleAppVersionBundles() throws -> Promise<Double> {
+        BundleUpdateStore.invalidateValidatedBundleInfoCache()
+        return Promise.async {
+            let fm = FileManager.default
+            let currentAppV = BundleUpdateStore.getCurrentNativeVersion()
+            // Safety net: never delete the bundle backing the active pointer.
+            let currentBundleVersion = BundleUpdateStore.currentBundleVersion()
+            OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: currentAppV=\(currentAppV), currentBundleVersion=\(currentBundleVersion ?? "nil")")
+
+            // Without a known native version we cannot decide what is stale;
+            // bail out rather than risk deleting the wrong artifacts.
+            guard !currentAppV.isEmpty else {
+                OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: empty currentAppV, skipping")
+                return 0
+            }
+
+            /// True when this entry stem must be kept: its appVersion matches
+            /// the running binary, it IS the active currentBundleVersion, or it
+            /// is unparseable (leave foreign names alone).
+            func shouldKeep(stem: String) -> Bool {
+                if let active = currentBundleVersion, stem == active { return true }
+                guard let appV = Self.appVersionFromStem(stem) else { return true }
+                return appV == currentAppV
+            }
+
+            var deletedDirCount = 0
+
+            // 1. onekey-bundle/* extracted dirs
+            let bundleDir = BundleUpdateStore.bundleDir()
+            if let contents = try? fm.contentsOfDirectory(atPath: bundleDir) {
+                for name in contents {
+                    // Skip non-version entries (asc dir, fallback json, etc.)
+                    if name == "asc" || name == "fallbackUpdateBundleData.json" { continue }
+                    let fullPath = (bundleDir as NSString).appendingPathComponent(name)
+                    var isDir: ObjCBool = false
+                    guard fm.fileExists(atPath: fullPath, isDirectory: &isDir), isDir.boolValue else { continue }
+                    if shouldKeep(stem: name) { continue }
+                    do {
+                        try fm.removeItem(atPath: fullPath)
+                        deletedDirCount += 1
+                        OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: deleted stale bundle dir \(name)")
+                    } catch {
+                        OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: failed to delete bundle dir \(name): \(error)")
+                    }
+                }
+            }
+
+            // 2. onekey-bundle-download/* stages (zip / partial / progress / resume)
+            let downloadDir = BundleUpdateStore.downloadBundleDir()
+            if let contents = try? fm.contentsOfDirectory(atPath: downloadDir) {
+                for name in contents {
+                    // Strip the trailing extension chain to recover the
+                    // "{appV}-{bV}" stem (e.g. "6.3.0-123.zip.partial").
+                    var stem = name
+                    for suffix in [".resume", ".progress", ".partial", ".zip"] {
+                        if stem.hasSuffix(suffix) {
+                            stem = String(stem.dropLast(suffix.count))
+                        }
+                    }
+                    if shouldKeep(stem: stem) { continue }
+                    let fullPath = (downloadDir as NSString).appendingPathComponent(name)
+                    do {
+                        try fm.removeItem(atPath: fullPath)
+                        OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: deleted stale download \(name)")
+                    } catch {
+                        OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: failed to delete download \(name): \(error)")
+                    }
+                }
+            }
+
+            // 3. onekey-bundle/asc/*-signature.asc orphan signatures
+            let ascDir = BundleUpdateStore.ascDir()
+            if let contents = try? fm.contentsOfDirectory(atPath: ascDir) {
+                let suffix = "-signature.asc"
+                for name in contents {
+                    guard name.hasSuffix(suffix) else { continue }
+                    let stem = String(name.dropLast(suffix.count))
+                    if shouldKeep(stem: stem) { continue }
+                    let fullPath = (ascDir as NSString).appendingPathComponent(name)
+                    do {
+                        try fm.removeItem(atPath: fullPath)
+                        OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: deleted orphan asc \(name)")
+                    } catch {
+                        OneKeyLog.warn("BundleUpdate", "pruneStaleAppVersionBundles: failed to delete asc \(name): \(error)")
+                    }
+                }
+            }
+
+            // 4. Persisted fallback list: drop entries whose appVersion != currentAppV.
+            // Fixes the latent leak where stale fallback entries linger after a
+            // native upgrade. Reuses the existing read/write helpers.
+            let fallbackData = BundleUpdateStore.readFallbackUpdateBundleDataFile()
+            let prunedFallback = fallbackData.filter { entry in
+                guard let appV = entry["appVersion"], !appV.isEmpty else { return true }
+                return appV == currentAppV
+            }
+            if prunedFallback.count != fallbackData.count {
+                BundleUpdateStore.writeFallbackUpdateBundleDataFile(prunedFallback)
+                OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: pruned fallback entries \(fallbackData.count) -> \(prunedFallback.count)")
+            }
+
+            OneKeyLog.info("BundleUpdate", "pruneStaleAppVersionBundles: completed, deletedDirCount=\(deletedDirCount)")
+            return Double(deletedDirCount)
+        }
+    }
+
     func resetToBuiltInBundle() throws -> Promise<Void> {
         BundleUpdateStore.invalidateValidatedBundleInfoCache()
         return Promise.async {

package/lib/typescript/src/ReactNativeBundleUpdate.nitro.d.ts

@@ -81,6 +81,7 @@ export interface ReactNativeBundleUpdate extends HybridObject<{
     clearBundle(): Promise<void>;
     clearAllJSBundleData(): Promise<TestResult>;
     resetToBuiltInBundle(): Promise<void>;
+    pruneStaleAppVersionBundles(): Promise<number>;
     getFallbackUpdateBundleData(): Promise<FallbackBundleInfo[]>;
     setCurrentUpdateBundleData(params: BundleSwitchParams): Promise<void>;
     getWebEmbedPath(): string;

package/nitrogen/generated/android/c++/JHybridReactNativeBundleUpdateSpec.cpp

@@ -233,6 +233,22 @@ namespace margelo::nitro::reactnativebundleupdate {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<double>> JHybridReactNativeBundleUpdateSpec::pruneStaleAppVersionBundles() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("pruneStaleAppVersionBundles");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
   std::shared_ptr<Promise<std::vector<FallbackBundleInfo>>> JHybridReactNativeBundleUpdateSpec::getFallbackUpdateBundleData() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getFallbackUpdateBundleData");
     auto __result = method(_javaPart);

package/nitrogen/generated/android/c++/JHybridReactNativeBundleUpdateSpec.hpp

@@ -63,6 +63,7 @@ namespace margelo::nitro::reactnativebundleupdate {
     std::shared_ptr<Promise<void>> clearBundle() override;
     std::shared_ptr<Promise<TestResult>> clearAllJSBundleData() override;
     std::shared_ptr<Promise<void>> resetToBuiltInBundle() override;
+    std::shared_ptr<Promise<double>> pruneStaleAppVersionBundles() override;
     std::shared_ptr<Promise<std::vector<FallbackBundleInfo>>> getFallbackUpdateBundleData() override;
     std::shared_ptr<Promise<void>> setCurrentUpdateBundleData(const BundleSwitchParams& params) override;
     std::string getWebEmbedPath() override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativebundleupdate/HybridReactNativeBundleUpdateSpec.kt

@@ -82,6 +82,10 @@ abstract class HybridReactNativeBundleUpdateSpec: HybridObject() {
   @Keep
   abstract fun resetToBuiltInBundle(): Promise<Unit>
   
+  @DoNotStrip
+  @Keep
+  abstract fun pruneStaleAppVersionBundles(): Promise<Double>
+  
   @DoNotStrip
   @Keep
   abstract fun getFallbackUpdateBundleData(): Promise<Array<FallbackBundleInfo>>

package/nitrogen/generated/ios/ReactNativeBundleUpdate-Swift-Cxx-Bridge.cpp

@@ -46,6 +46,14 @@ namespace margelo::nitro::reactnativebundleupdate::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(double /* result */)>
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeBundleUpdate::Func_void_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::vector<FallbackBundleInfo>& /* result */)>
   Func_void_std__vector_FallbackBundleInfo_ create_Func_void_std__vector_FallbackBundleInfo_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeBundleUpdate::Func_void_std__vector_FallbackBundleInfo_::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/ReactNativeBundleUpdate-Swift-Cxx-Bridge.hpp

@@ -174,6 +174,40 @@ namespace margelo::nitro::reactnativebundleupdate::bridge::swift {
     return Func_void_TestResult_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<double>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<double>>`.
+   */
+  using std__shared_ptr_Promise_double__ = std::shared_ptr<Promise<double>>;
+  inline std::shared_ptr<Promise<double>> create_std__shared_ptr_Promise_double__() noexcept {
+    return Promise<double>::create();
+  }
+  inline PromiseHolder<double> wrap_std__shared_ptr_Promise_double__(std::shared_ptr<Promise<double>> promise) noexcept {
+    return PromiseHolder<double>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(double /* result */)>
+  /**
+   * Specialized version of `std::function<void(double)>`.
+   */
+  using Func_void_double = std::function<void(double /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_Wrapper final {
+  public:
+    explicit Func_void_double_Wrapper(std::function<void(double /* result */)>&& func): _function(std::make_unique<std::function<void(double /* result */)>>(std::move(func))) {}
+    inline void call(double result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
+    return Func_void_double_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::vector<FallbackBundleInfo>
   /**
    * Specialized version of `std::vector<FallbackBundleInfo>`.
@@ -438,6 +472,15 @@ namespace margelo::nitro::reactnativebundleupdate::bridge::swift {
     return Result<std::shared_ptr<Promise<TestResult>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<double>>>
+  using Result_std__shared_ptr_Promise_double___ = Result<std::shared_ptr<Promise<double>>>;
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::shared_ptr<Promise<double>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<double>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<double>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<FallbackBundleInfo>>>>
   using Result_std__shared_ptr_Promise_std__vector_FallbackBundleInfo____ = Result<std::shared_ptr<Promise<std::vector<FallbackBundleInfo>>>>;
   inline Result_std__shared_ptr_Promise_std__vector_FallbackBundleInfo____ create_Result_std__shared_ptr_Promise_std__vector_FallbackBundleInfo____(const std::shared_ptr<Promise<std::vector<FallbackBundleInfo>>>& value) noexcept {

package/nitrogen/generated/ios/c++/HybridReactNativeBundleUpdateSpecSwift.hpp

@@ -170,6 +170,14 @@ namespace margelo::nitro::reactnativebundleupdate {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<double>> pruneStaleAppVersionBundles() override {
+      auto __result = _swiftPart.pruneStaleAppVersionBundles();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<std::vector<FallbackBundleInfo>>> getFallbackUpdateBundleData() override {
       auto __result = _swiftPart.getFallbackUpdateBundleData();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/Func_void_double.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_double.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: Double) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_double {
+  public typealias bridge = margelo.nitro.reactnativebundleupdate.bridge.swift
+
+  private let closure: (_ value: Double) -> Void
+
+  public init(_ closure: @escaping (_ value: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: Double) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_double`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_double {
+    return Unmanaged<Func_void_double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridReactNativeBundleUpdateSpec.swift

@@ -23,6 +23,7 @@ public protocol HybridReactNativeBundleUpdateSpec_protocol: HybridObject {
   func clearBundle() throws -> Promise<Void>
   func clearAllJSBundleData() throws -> Promise<TestResult>
   func resetToBuiltInBundle() throws -> Promise<Void>
+  func pruneStaleAppVersionBundles() throws -> Promise<Double>
   func getFallbackUpdateBundleData() throws -> Promise<[FallbackBundleInfo]>
   func setCurrentUpdateBundleData(params: BundleSwitchParams) throws -> Promise<Void>
   func getWebEmbedPath() throws -> String

package/nitrogen/generated/ios/swift/HybridReactNativeBundleUpdateSpec_cxx.swift

@@ -288,6 +288,25 @@ open class HybridReactNativeBundleUpdateSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func pruneStaleAppVersionBundles() -> bridge.Result_std__shared_ptr_Promise_double___ {
+    do {
+      let __result = try self.__implementation.pruneStaleAppVersionBundles()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_double__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_double__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getFallbackUpdateBundleData() -> bridge.Result_std__shared_ptr_Promise_std__vector_FallbackBundleInfo____ {
     do {

package/nitrogen/generated/shared/c++/HybridReactNativeBundleUpdateSpec.cpp

@@ -23,6 +23,7 @@ namespace margelo::nitro::reactnativebundleupdate {
       prototype.registerHybridMethod("clearBundle", &HybridReactNativeBundleUpdateSpec::clearBundle);
       prototype.registerHybridMethod("clearAllJSBundleData", &HybridReactNativeBundleUpdateSpec::clearAllJSBundleData);
       prototype.registerHybridMethod("resetToBuiltInBundle", &HybridReactNativeBundleUpdateSpec::resetToBuiltInBundle);
+      prototype.registerHybridMethod("pruneStaleAppVersionBundles", &HybridReactNativeBundleUpdateSpec::pruneStaleAppVersionBundles);
       prototype.registerHybridMethod("getFallbackUpdateBundleData", &HybridReactNativeBundleUpdateSpec::getFallbackUpdateBundleData);
       prototype.registerHybridMethod("setCurrentUpdateBundleData", &HybridReactNativeBundleUpdateSpec::setCurrentUpdateBundleData);
       prototype.registerHybridMethod("getWebEmbedPath", &HybridReactNativeBundleUpdateSpec::getWebEmbedPath);

package/nitrogen/generated/shared/c++/HybridReactNativeBundleUpdateSpec.hpp

@@ -95,6 +95,7 @@ namespace margelo::nitro::reactnativebundleupdate {
       virtual std::shared_ptr<Promise<void>> clearBundle() = 0;
       virtual std::shared_ptr<Promise<TestResult>> clearAllJSBundleData() = 0;
       virtual std::shared_ptr<Promise<void>> resetToBuiltInBundle() = 0;
+      virtual std::shared_ptr<Promise<double>> pruneStaleAppVersionBundles() = 0;
       virtual std::shared_ptr<Promise<std::vector<FallbackBundleInfo>>> getFallbackUpdateBundleData() = 0;
       virtual std::shared_ptr<Promise<void>> setCurrentUpdateBundleData(const BundleSwitchParams& params) = 0;
       virtual std::string getWebEmbedPath() = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-bundle-update",
-  "version": "3.0.63",
+  "version": "3.0.65",
   "description": "react-native-bundle-update",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/ReactNativeBundleUpdate.nitro.ts

@@ -99,6 +99,10 @@ export interface ReactNativeBundleUpdate
   clearBundle(): Promise<void>;
   clearAllJSBundleData(): Promise<TestResult>;
   resetToBuiltInBundle(): Promise<void>;
+  // Prune every artifact whose appVersion differs from the running native
+  // binary version (stale OTA dirs, download stages, orphan asc, lingering
+  // fallback entries). Returns the count of deleted version directories.
+  pruneStaleAppVersionBundles(): Promise<number>;
 
   // Bundle data
   getFallbackUpdateBundleData(): Promise<FallbackBundleInfo[]>;