react-native-stallion 2.3.0-alpha.4 → 2.3.0-alpha.6

package/ios/main/StallionExceptionHandler.mm

@@ -0,0 +1,379 @@
+//
+//  StallionExceptionHandler.mm
+//  react-native-stallion
+//
+//  Created by Thor963 on 29/01/25.
+//
+
+#import "StallionExceptionHandler.h"
+#import "StallionStateManager.h"
+#import "StallionEventHandler.h"
+#import "StallionSlotManager.h"
+#import "StallionMeta.h"
+#import "StallionMetaConstants.h"
+#import "StallionObjConstants.h"
+#import "StallionFileManager.h"
+#import <signal.h>
+#import <unistd.h>
+#import <fcntl.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#include <atomic>
+
+// Forward declarations
+void handleException(NSException *exception);
+void handleSignal(int signal, siginfo_t *info, void *context);
+static void performStallionRollback(NSString *errorString);
+static void setupSignalHandlers(void);
+static void processNativeCrashMarkerIfPresent(void);
+
+// Async-signal-safe crash marker storage
+static char g_marker_path[512];
+static char g_mount_marker_path[512];
+
+@implementation StallionExceptionHandler
+
+NSUncaughtExceptionHandler *_defaultExceptionHandler;
+static std::atomic<bool> exceptionAlertDismissed(false);
+static std::atomic<bool> exceptionAlertShowing(false);
+static std::atomic<bool> rollbackPerformed(false);
+static std::atomic<bool> hasProcessedNativeCrashMarker(false);
+static struct sigaction _previousHandlers[32]; // Store previous handlers for chaining
+
++ (void)initExceptionHandler {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        // Reset rollback flag when initializing exception handler
+        [self resetRollbackFlag];
+        
+        // Store and set Objective-C exception handler
+        if (!_defaultExceptionHandler) {
+            _defaultExceptionHandler = NSGetUncaughtExceptionHandler();
+        }
+        NSSetUncaughtExceptionHandler(&handleException);
+        
+        // Setup signal handlers using sigaction with chaining
+        setupSignalHandlers();
+        
+        // Initialize JavaScript exception handler
+        [self initJavaScriptExceptionHandler];
+        
+        // Process any crash marker from previous session
+        processNativeCrashMarkerIfPresent();
+    });
+}
+
++ (void)initJavaScriptExceptionHandler {
+    // Handle fatal JavaScript errors that cause app crashes
+    RCTSetLogFunction(^(RCTLogLevel level, RCTLogSource source, NSString *fileName, NSNumber *lineNumber, NSString *message) {
+        // Rollback only for fatal errors that crash the app
+        if (level >= RCTLogLevelFatal) {
+            NSString *errorString = [NSString stringWithFormat:@"Fatal JS Error in %@:%@ - %@", fileName, lineNumber, message];
+            performStallionRollback(errorString);
+        }
+    });
+}
+
++ (void)resetRollbackFlag {
+    rollbackPerformed.store(false);
+}
+
+@end
+
+#pragma mark - Shared Rollback Logic
+
+static void performStallionRollback(NSString *errorString) {
+    
+    StallionStateManager *stateManager = [StallionStateManager sharedInstance];
+    StallionMeta *meta = stateManager.stallionMeta;
+    BOOL isAutoRollback = !stateManager.isMounted;
+  
+  
+  // Only prevent multiple executions for auto rollback cases
+  // Launch crashes (when mounted) can continue to be registered
+  if (isAutoRollback) {
+    // Use compare-and-swap to atomically check and set the flag
+    bool expected = false;
+    if (!rollbackPerformed.compare_exchange_strong(expected, true)) {
+      // Flag was already true, skip duplicate rollback
+      return;
+    }
+  }
+  
+  if (errorString.length > 900) {
+    errorString = [errorString substringToIndex:900];
+  }
+
+  if (meta.switchState == SwitchStateProd) {
+    NSString *currentHash = [meta getActiveReleaseHash] ?: @"";
+
+    [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_prod_event
+          eventPayload:@{
+              @"meta": errorString,
+              StallionObjConstants.release_hash_key: currentHash,
+              StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
+          }];
+        if (isAutoRollback) {
+            [StallionSlotManager rollbackProdWithAutoRollback:YES errorString:errorString];
+        }
+
+  } else if (meta.switchState == SwitchStateStage) {
+    NSString *currentStageHash = meta.stageNewHash ?: @"";
+    
+    // Emit exception event before rollback (consistent with PROD and Android)
+    [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_stage_event
+          eventPayload:@{
+              @"meta": errorString,
+              StallionObjConstants.release_hash_key: currentStageHash,
+              StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
+          }];
+    
+    if(isAutoRollback) {
+      [StallionSlotManager rollbackStage];
+    }
+
+      // Check if alert is already showing (atomic check to prevent duplicates)
+      bool expectedShowing = false;
+      if (exceptionAlertShowing.compare_exchange_strong(expectedShowing, true)) {
+        // We successfully claimed the right to show the alert
+        UIAlertController *alert = [UIAlertController alertControllerWithTitle:@"Stallion Exception Handler"
+           message:[NSString stringWithFormat:@"%@\n%@",
+                    @"A crash occurred in the app. Build was rolled back. Check crash report below. Continue crash to invoke other exception handlers. \n \n",
+                    errorString]
+          preferredStyle:UIAlertControllerStyleAlert];
+
+        [alert addAction:[UIAlertAction actionWithTitle:@"Continue Crash"
+                                                  style:UIAlertActionStyleDefault
+                                                handler:^(UIAlertAction *action) {
+                                                    // Set flag to true only when button is pressed
+                                                    exceptionAlertDismissed.store(true);
+                                                }]];
+
+        UIApplication *app = [UIApplication sharedApplication];
+        UIViewController *rootViewController = app.delegate.window.rootViewController;
+
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [rootViewController presentViewController:alert animated:YES completion:nil];
+        });
+
+        // Wait for user to press the button (exceptionAlertDismissed becomes true)
+        while (!exceptionAlertDismissed.load()) {
+            [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+        }
+      }
+    }
+}
+
+#pragma mark - Signal Handler Setup
+
+// Async-signal-safe function to check if mount marker exists
+static int is_mounted_safe(void) {
+    int fd = open(g_mount_marker_path, O_RDONLY);
+    if (fd >= 0) {
+        close(fd);
+        return 1; // Mounted
+    }
+    return 0; // Not mounted
+}
+
+// Async-signal-safe JSON writing (minimal JSON for crash marker)
+static void write_crash_marker_json_safe(int signal, int mounted) {
+    int fd = open(g_marker_path, O_CREAT | O_WRONLY | O_TRUNC, 0600);
+    if (fd >= 0) {
+        // Write JSON: {"signal":X,"isAutoRollback":true/false,"crashLog":"signal=X\n"}
+        // isAutoRollback = !mounted (auto rollback if not mounted)
+        int autoRollback = !mounted;
+        char json[512];
+        int len = snprintf(json, sizeof(json),
+            "{\"signal\":%d,\"isAutoRollback\":%s,\"crashLog\":\"signal=%d\\n\"}",
+            signal, autoRollback ? "true" : "false", signal);
+        if (len > 0 && len < (int)sizeof(json)) {
+            (void)write(fd, json, len);
+        }
+        close(fd);
+    }
+}
+
+static void setupSignalHandlers(void) {
+    // Initialize marker paths from StallionStateManager
+    StallionStateManager *stateManager = [StallionStateManager sharedInstance];
+    NSString *filesDir = stateManager.stallionConfig.filesDirectory;
+    if (filesDir) {
+        const char *path = [filesDir UTF8String];
+        snprintf(g_marker_path, sizeof(g_marker_path), "%s/%s", path, "stallion_crash.marker");
+        snprintf(g_mount_marker_path, sizeof(g_mount_marker_path), "%s/%s", path, "stallion_mount.marker");
+    }
+    
+    struct sigaction action;
+    sigemptyset(&action.sa_mask);
+    action.sa_flags = SA_SIGINFO;
+    action.sa_sigaction = handleSignal;
+    
+    // List of signals to catch - comprehensive coverage
+    int signals[] = {
+        SIGABRT,   // Abort signal
+        SIGILL,    // Illegal instruction
+        SIGSEGV,   // Segmentation violation
+        SIGFPE,    // Floating point exception
+        SIGBUS,    // Bus error
+        SIGTRAP,   // Trace/breakpoint trap
+        SIGPIPE,   // Broken pipe
+        SIGSYS,    // Bad system call
+    };
+    
+    int signalCount = sizeof(signals) / sizeof(signals[0]);
+    
+    for (int i = 0; i < signalCount; i++) {
+        int sig = signals[i];
+        // Store previous handler before installing ours (for chaining)
+        sigaction(sig, NULL, &_previousHandlers[sig]);
+        // Now install our handler
+        sigaction(sig, &action, NULL);
+    }
+}
+
+void handleException(NSException *exception) {
+    NSString *readableError = [exception reason] ?: @"Unknown exception";
+    NSString *name = [exception name] ?: @"Unknown";
+    NSString *callStack = [[exception callStackSymbols] componentsJoinedByString:@"\n"];
+    NSString *fullError = [NSString stringWithFormat:@"Exception: %@\nReason: %@\nStack:\n%@", name, readableError, callStack];
+    
+    performStallionRollback(fullError);
+
+    // Chain to default exception handler if available
+    if (_defaultExceptionHandler) {
+        _defaultExceptionHandler(exception);
+    }
+}
+
+void handleSignal(int signalVal, siginfo_t *info, void *context) {
+
+    if (!rollbackPerformed.load()) {
+        // Async-signal-safe operations only
+        // Read mount state at crash time (async-signal-safe)
+        int mounted = is_mounted_safe();
+        // Write JSON marker with crash info and autoRollback flag
+        write_crash_marker_json_safe(signalVal, mounted);
+    }
+    
+    // Chain to previous handler if it exists and is valid (bubble up)
+    if (signalVal >= 0 && signalVal < 32) {
+        struct sigaction *prev = &_previousHandlers[signalVal];
+        if (prev->sa_handler != SIG_DFL && prev->sa_handler != SIG_IGN && prev->sa_handler != NULL) {
+            // Prevent infinite loop - don't call ourselves
+            if (prev->sa_sigaction != handleSignal) {
+                if (prev->sa_flags & SA_SIGINFO) {
+                    prev->sa_sigaction(signalVal, info, context);
+                } else if (prev->sa_handler != SIG_DFL && prev->sa_handler != SIG_IGN) {
+                    prev->sa_handler(signalVal);
+                }
+            }
+        }
+    }
+    
+    // Restore default and raise to proceed with crash
+    signal(signalVal, SIG_DFL);
+    raise(signalVal);
+}
+
+#pragma mark - Crash Marker Processing
+
+static void processNativeCrashMarkerIfPresent(void) {
+    @try {
+        if (hasProcessedNativeCrashMarker.load()) {
+            return;
+        }
+        
+        StallionStateManager *stateManager = [StallionStateManager sharedInstance];
+        NSString *filesDir = stateManager.stallionConfig.filesDirectory;
+        NSString *markerPath = [NSString stringWithFormat:@"%@/stallion_crash.marker", filesDir];
+        
+        NSFileManager *fileManager = [NSFileManager defaultManager];
+        if ([fileManager fileExistsAtPath:markerPath]) {
+            NSError *error = nil;
+            NSString *jsonContent = [NSString stringWithContentsOfFile:markerPath
+                                                              encoding:NSUTF8StringEncoding
+                                                                 error:&error];
+            
+            if (jsonContent && !error) {
+                NSString *stackTraceString = @"";
+                BOOL isAutoRollback = NO;
+                
+                @try {
+                    // Parse JSON from previous crash
+                    NSData *jsonData = [jsonContent dataUsingEncoding:NSUTF8StringEncoding];
+                    NSDictionary *crashMarker = [NSJSONSerialization JSONObjectWithData:jsonData
+                                                                                options:0
+                                                                                  error:&error];
+                    if (crashMarker && !error) {
+                        // Extract crash log and autoRollback flag from marker
+                        stackTraceString = crashMarker[@"crashLog"] ?: @"";
+                        // Use the autoRollback flag that was determined at crash time (previous session)
+                        isAutoRollback = [crashMarker[@"isAutoRollback"] boolValue];
+                    }
+                } @catch (NSException *e) {
+                    // Fallback for old format (non-JSON)
+                    stackTraceString = jsonContent;
+                    // Default to true for old format (conservative approach)
+                    isAutoRollback = YES;
+                }
+                
+                if (stackTraceString.length > 900) {
+                    stackTraceString = [stackTraceString substringToIndex:900];
+                }
+                
+                StallionMeta *meta = stateManager.stallionMeta;
+                SwitchState switchState = meta.switchState;
+                
+                if (switchState == SwitchStateProd) {
+                    NSString *currentHash = [meta getActiveReleaseHash] ?: @"";
+                    // Use isAutoRollback from previous crash, not current session state
+                    @try {
+                        [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_prod_event
+                                                              eventPayload:@{
+                                                                  @"meta": stackTraceString,
+                                                                  StallionObjConstants.release_hash_key: currentHash,
+                                                                  StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
+                                                              }];
+                    } @catch (NSException *e) { }
+                    
+                    if (isAutoRollback) {
+                        // Only prevent multiple executions for auto rollback cases
+                        bool expected = false;
+                        if (rollbackPerformed.compare_exchange_strong(expected, true)) {
+                            @try {
+                                [StallionSlotManager rollbackProdWithAutoRollback:YES errorString:stackTraceString];
+                            } @catch (NSException *e) { }
+                        }
+                    }
+                } else if (switchState == SwitchStateStage) {
+                    NSString *currentStageHash = meta.stageNewHash ?: @"";
+                    // Use isAutoRollback from previous crash, not current session state
+                    @try {
+                        [[StallionEventHandler sharedInstance] cacheEvent:StallionObjConstants.exception_stage_event
+                                                              eventPayload:@{
+                                                                  @"meta": stackTraceString,
+                                                                  StallionObjConstants.release_hash_key: currentStageHash,
+                                                                  StallionObjConstants.is_auto_rollback_key: isAutoRollback ? @"true" : @"false"
+                                                              }];
+                    } @catch (NSException *e) { }
+                    
+                    if (isAutoRollback) {
+                        // Only prevent multiple executions for auto rollback cases
+                        bool expected = false;
+                        if (rollbackPerformed.compare_exchange_strong(expected, true)) {
+                            @try {
+                                [StallionSlotManager rollbackStage];
+                            } @catch (NSException *e) { }
+                        }
+                    }
+                }
+                
+                // Delete marker
+                [StallionFileManager deleteFileOrFolderSilently:markerPath];
+                hasProcessedNativeCrashMarker.store(true);
+            }
+        }
+    } @catch (NSException *e) { }
+}
+

package/ios/main/StallionFileDownloader.swift

@@ -17,6 +17,7 @@ class StallionFileDownloader: NSObject {
     private var _reject: RCTPromiseRejectBlock?
     private var _onProgress: ((Float) -> Void)?
     private var lastSentProgress: Float = 0
+    private var lastProgressEmitTime: TimeInterval = 0
     private var _downloadDirectory: String?
     
     private let queue = DispatchQueue(label: "com.stallion.networkmanager", qos: .background)
@@ -116,13 +117,20 @@ class StallionFileDownloader: NSObject {
         guard bytesRead == headerSize else { return false }
         return header == [0x50, 0x4B, 0x03, 0x04] // PKZIP magic number
     }
+    
+    private func shouldEmitProgress(currentTime: TimeInterval) -> Bool {
+        return currentTime - self.lastProgressEmitTime >= StallionConstants.PROGRESS_THROTTLE_INTERVAL_MS
+    }
 }
 
 extension StallionFileDownloader: URLSessionDownloadDelegate {
     func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
         let progress = Float(totalBytesWritten) / Float(totalBytesExpectedToWrite)
-      if progress - self.lastSentProgress > StallionConstants.PROGRESS_EVENT_THRESHOLD {
+        let currentTime = Date().timeIntervalSince1970
+        
+        if shouldEmitProgress(currentTime: currentTime) {
             self.lastSentProgress = progress
+            self.lastProgressEmitTime = currentTime
             self._onProgress?(progress)
         }
     }

package/ios/main/StallionMeta.h

@@ -20,10 +20,21 @@
 @property (nonatomic, copy) NSString *prodNewHash;
 @property (nonatomic, copy) NSString *prodStableHash;
 @property (nonatomic, copy) NSString *lastRolledBackHash;
+@property (nonatomic, assign) NSTimeInterval lastRolledBackAt;
+@property (nonatomic, assign) NSInteger successfulLaunchCount;
+@property (nonatomic, copy) NSString *lastSuccessfulLaunchHash;
+
++ (NSInteger)maxSuccessLaunchThreshold;
++ (NSTimeInterval)lastRolledBackTTL;
 
 - (void)reset;
 - (NSDictionary *)toDictionary;
+- (NSString *)getHashAtCurrentProdSlot;
 - (NSString *)getActiveReleaseHash;
+- (NSString *)getLastRolledBackHash;
+- (void)setLastRolledBackHashWithTimestamp:(NSString *)lastRolledBackHash;
+- (void)markSuccessfulLaunch:(NSString *)releaseHash;
+- (NSInteger)getSuccessfulLaunchCount:(NSString *)releaseHash;
 + (instancetype)fromDictionary:(NSDictionary *)dict;
 
 @end

package/ios/main/StallionMeta.m

@@ -9,6 +9,14 @@
 
 @implementation StallionMeta
 
++ (NSInteger)maxSuccessLaunchThreshold {
+    return 3;
+}
+
++ (NSTimeInterval)lastRolledBackTTL {
+    return 6 * 60 * 60; // 6 hours in seconds
+}
+
 - (instancetype)init {
     self = [super init];
     if (self) [self reset];
@@ -26,6 +34,9 @@
     self.prodNewHash = @"";
     self.prodStableHash = @"";
     self.lastRolledBackHash = @"";
+     self.lastRolledBackAt = 0.0;
+     self.successfulLaunchCount = 0;
+     self.lastSuccessfulLaunchHash = @"";
 }
 
 - (NSDictionary *)toDictionary {
@@ -43,7 +54,10 @@
                     @"stableHash": self.prodStableHash ?: @"",
                     @"currentSlot": [StallionMetaConstants stringFromSlotState:self.currentProdSlot] ?: @""
             },
-            @"lastRolledBackHash": self.lastRolledBackHash ?: @""
+             @"lastRolledBackHash": self.lastRolledBackHash ?: @"",
+             @"lastRolledBackAt": @(self.lastRolledBackAt),
+             @"successfulLaunchCount": @(self.successfulLaunchCount),
+             @"lastSuccessfulLaunchHash": self.lastSuccessfulLaunchHash ?: @""
         };
     } @catch (NSException *exception) {
         NSLog(@"Error in toDictionary: %@", exception.reason);
@@ -87,6 +101,9 @@
         meta.currentProdSlot = [StallionMetaConstants slotStateFromString:prodSlot[@"currentSlot"] ?: @"default_slot"];
 
         meta.lastRolledBackHash = dict[@"lastRolledBackHash"] ?: @"";
+         meta.lastRolledBackAt = [dict[@"lastRolledBackAt"] doubleValue];
+         meta.successfulLaunchCount = [dict[@"successfulLaunchCount"] integerValue];
+         meta.lastSuccessfulLaunchHash = dict[@"lastSuccessfulLaunchHash"] ?: @"";
 
         return meta;
     } @catch (NSException *exception) {
@@ -95,4 +112,62 @@
     }
 }
 
+ - (NSString *)getHashAtCurrentProdSlot {
+     switch (self.currentProdSlot) {
+         case SlotStateNewSlot:
+             return self.prodNewHash;
+         case SlotStateStableSlot:
+             return self.prodStableHash;
+         default:
+             return @"";
+     }
+ }
+
+ - (NSString *)getLastRolledBackHash {
+     [self enforceLastRolledBackExpiry];
+     return self.lastRolledBackHash;
+ }
+
+- (void)setLastRolledBackHashWithTimestamp:(NSString *)lastRolledBackHash {
+    NSString *hashValue = lastRolledBackHash ?: @"";
+    self.lastRolledBackHash = hashValue;
+    self.lastRolledBackAt = [hashValue isEqualToString:@""] ? 0.0 : [[NSDate date] timeIntervalSince1970];
+}
+
+ - (void)enforceLastRolledBackExpiry {
+     if (!self.lastRolledBackHash || [self.lastRolledBackHash isEqualToString:@""]) {
+         return;
+     }
+     if (self.lastRolledBackAt <= 0.0) {
+         return;
+     }
+     NSTimeInterval now = [[NSDate date] timeIntervalSince1970];
+     if (now - self.lastRolledBackAt >= [StallionMeta lastRolledBackTTL]) {
+         self.lastRolledBackHash = @"";
+         self.lastRolledBackAt = 0.0;
+     }
+ }
+
+ - (void)markSuccessfulLaunch:(NSString *)releaseHash {
+     if (!releaseHash || [releaseHash isEqualToString:@""]) {
+         return;
+     }
+     if (![releaseHash isEqualToString:self.lastSuccessfulLaunchHash]) {
+         self.successfulLaunchCount = 0;
+         self.lastSuccessfulLaunchHash = releaseHash;
+     }
+     if (self.successfulLaunchCount < 3) { // MAX_SUCCESS_LAUNCH_THRESHOLD
+         self.successfulLaunchCount += 1;
+     }
+ }
+
+ - (NSInteger)getSuccessfulLaunchCount:(NSString *)releaseHash {
+     NSString *currentHash = releaseHash ?: @"";
+     if (![currentHash isEqualToString:self.lastSuccessfulLaunchHash]) {
+         return 0;
+     } else {
+         return self.successfulLaunchCount;
+     }
+ }
+
 @end

package/ios/main/StallionSlotManager.m

@@ -74,7 +74,7 @@
       NSString *newSlotPath = [NSString stringWithFormat:@"%@/%@/%@", baseFolderPath, StallionObjConstants.prod_directory, StallionObjConstants.new_folder_slot];
       NSString *stableSlotPath = [NSString stringWithFormat:@"%@/%@/%@", baseFolderPath, StallionObjConstants.prod_directory, StallionObjConstants.stable_folder_slot];
 
-      [StallionFileManager copyFileOrDirectoryFrom:newSlotPath to:stableSlotPath];
+      [StallionFileManager moveFileFrom:newSlotPath to:stableSlotPath];
 
         NSString *newReleaseHash = stateManager.stallionMeta.prodNewHash;
         [stateManager.stallionMeta setProdStableHash:newReleaseHash];
@@ -96,7 +96,7 @@
 
     if (isAutoRollback) {
         StallionStateManager *stateManager = [StallionStateManager sharedInstance];
-        [stateManager.stallionMeta setLastRolledBackHash:rolledBackReleaseHash];
+        [stateManager.stallionMeta setLastRolledBackHashWithTimestamp:rolledBackReleaseHash];
         [stateManager syncStallionMeta];
     }
 

package/ios/main/StallionStateManager.m

@@ -44,6 +44,9 @@ static StallionStateManager *_instance = nil;
         _isMounted = NO;
         _pendingReleaseUrl = @"";
         _pendingReleaseHash = @"";
+        
+        // Reset mount state on initialization (ensures mount marker file is deleted for new session)
+        [self setIsMounted:NO];
     }
     return self;
 }
@@ -70,6 +73,32 @@ static StallionStateManager *_instance = nil;
     [self syncStallionMeta];
 }
 
+- (void)setIsMounted:(BOOL)isMounted {
+    _isMounted = isMounted;
+    // Write mount state to a simple file that signal handler can read (async-signal-safe)
+    NSString *filesDir = self.stallionConfig.filesDirectory;
+    NSString *mountMarkerPath = [NSString stringWithFormat:@"%@/stallion_mount.marker", filesDir];
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    
+    if (isMounted) {
+        // Create file to indicate mounted (file existence = mounted)
+        @try {
+            [fileManager createFileAtPath:mountMarkerPath contents:nil attributes:nil];
+        } @catch (NSException *e) {
+            // Silently ignore errors
+        }
+    } else {
+        // Delete file to indicate not mounted (no file = not mounted)
+        @try {
+            if ([fileManager fileExistsAtPath:mountMarkerPath]) {
+                [fileManager removeItemAtPath:mountMarkerPath error:nil];
+            }
+        } @catch (NSException *e) {
+            // Silently ignore errors
+        }
+    }
+}
+
 #pragma mark - Local Storage Methods
 
 - (NSString *)getStringForKey:(NSString *)key defaultValue:(NSString *)defaultValue {

package/ios/main/StallionSyncHandler.swift

@@ -46,6 +46,7 @@ class StallionSyncHandler {
                       "platform": StallionConstants.PlatformValue,
                       "projectId": projectId,
                       "appliedBundleHash": appliedBundleHash,
+                      "deviceMeta": StallionDeviceInfo.getDeviceMetaJson(config)
                   ]
 
                   // Make API call using URLSession
@@ -151,7 +152,7 @@ class StallionSyncHandler {
               !newReleaseHash.isEmpty else { return }
 
         let stateManager = StallionStateManager.sharedInstance()
-        let lastRolledBackHash = stateManager?.stallionMeta?.lastRolledBackHash ?? ""
+        let lastRolledBackHash = stateManager?.stallionMeta?.getLastRolledBackHash() ?? ""
         let lastUnverifiedHash = stateManager?.stallionConfig?.lastUnverifiedHash ?? ""
 
         if newReleaseHash != lastRolledBackHash && newReleaseHash != lastUnverifiedHash {
@@ -190,7 +191,7 @@ class StallionSyncHandler {
         url: fromUrl,
         downloadDirectory: downloadPath,
         onProgress: { progress in
-          // Handle progress updates if necessary
+          emitDownloadProgress(releaseHash: newReleaseHash, progress: progress)
         },
         resolve: { _ in
           completeDownload()
@@ -278,5 +279,16 @@ class StallionSyncHandler {
                              shouldCache: true
       )
     }
+
+    private static func emitDownloadProgress(releaseHash: String, progress: Float) {
+        let progressPayload: NSDictionary = [
+            "releaseHash": releaseHash,
+            "progress": "\(progress)"
+        ]
+        Stallion.sendEventToRn(eventName: StallionConstants.NativeEventTypesProd.DOWNLOAD_PROGRESS_PROD,
+                               eventBody: progressPayload,
+                               shouldCache: false
+        )
+    }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-stallion",
-  "version": "2.3.0-alpha.4",
+  "version": "2.3.0-alpha.6",
   "description": "Offical React Native SDK for Stallion",
   "main": "index",
   "types": "types/index.d.ts",

package/react-native-stallion.podspec

@@ -3,6 +3,28 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 
+# Generate StallionVersion.h during pod install
+version_header_path = File.join(__dir__, "ios/main/StallionVersion.h")
+version_header_content = <<~HEADER
+  //
+  //  StallionVersion.h
+  //  react-native-stallion
+  //
+  //  Auto-generated from package.json during pod install
+  //  Do not edit this file manually
+  //
+
+  #ifndef StallionVersion_h
+  #define StallionVersion_h
+
+  #define STALLION_SDK_VERSION @"#{package["version"]}"
+
+  #endif /* StallionVersion_h */
+HEADER
+
+File.write(version_header_path, version_header_content)
+puts "Stallion: Generated StallionVersion.h with version #{package["version"]}"
+
 Pod::Spec.new do |s|
   s.name         = "react-native-stallion"
   s.version      = package["version"]