@appspacer/react-native 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AppSpacer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# @appspacer/react-native
+
+Production-grade OTA update SDK for React Native — push JavaScript bundle updates directly to users' devices with reliability and safety.
+
+**[Full Documentation →](https://docs.appspacer.com)**
+
+## Installation
+
+```bash
+npm install @appspacer/react-native
+cd ios && pod install
+```
+
+### 2. iOS — Update AppDelegate
+
+```objc
+#import <AppSpacerModule.h>
+
+- (NSURL *)bundleURL {
+  return [AppSpacerModule bundleURL];
+}
+```
+
+### 3. Android — Update MainApplication
+
+```java
+import com.appspacer.AppSpacerModule;
+import com.appspacer.AppSpacerPackage;
+
+// In getPackages():
+packages.add(new AppSpacerPackage());
+
+// In getJSBundleFile():
+String customBundle = AppSpacerModule.getCustomBundlePath(this);
+if (customBundle != null) return customBundle;
+return super.getJSBundleFile();
+```
+
+## Usage
+
+### Simple (CodePush-style HOC)
+
+The easiest way to use AppSpacer is to wrap your root component with the `withAppSpacer` Higher-Order Component. This automatically checks for updates on app start and resume, and seamlessly shows a native "Update Available" popup if you enable `updateDialog`.
+
+```tsx
+import { withAppSpacer } from '@appspacer/react-native';
+
+function App() {
+  return <MainApp />;
+}
+
+export default withAppSpacer({
+  deploymentKey: 'sk_YOUR_DEPLOYMENT_KEY',
+  appVersion: '1.0.0',
+  updateDialog: true, // Shows a native alert to the user when an update is found
+})(App);
+```
+
+### With UI control
+
+```tsx
+import { useAppSpacerUpdate, UpdateStatus, InstallMode } from '@appspacer/react-native';
+import { Button, Text, View } from 'react-native';
+
+function App() {
+  const { status, update, sync, restartApp } = useAppSpacerUpdate();
+
+  useEffect(() => {
+    sync({ installMode: InstallMode.ON_NEXT_RESTART });
+  }, []);
+
+  return (
+    <View>
+      {status === UpdateStatus.INSTALLED && (
+        <Button title="Restart to apply update" onPress={restartApp} />
+      )}
+      {status === UpdateStatus.UPDATE_AVAILABLE && update && (
+        <Text>Update available: {update.description}</Text>
+      )}
+      <MainApp />
+    </View>
+  );
+}
+```
+
+## API
+
+| Method | Description |
+|---|---|
+| `withAppSpacer(config)` | HOC to initialize and auto-sync SDK |
+| `AppSpacer.checkForUpdate()` | Check server for updates |
+| `AppSpacer.downloadUpdate()` | Download and verify pending update |
+| `AppSpacer.restartApp()` | Reload app with new bundle |
+| `AppSpacer.sync(opts?)` | Check + download + install lifecycle |
+| `AppSpacer.notifyAppReady()` | Mark update as successful (rollback protection) |
+| `useAppSpacerUpdate()` | React hook for management |
+
+For the full API reference, configuration options, and advanced usage see the **[AppSpacer Documentation](https://docs.appspacer.com)**.
+
+## Safety Features
+
+- **SHA256 Verification**: Every package is verified before extraction.
+- **Rollback Protection**: If an update crashes during boot, the SDK automatically rolls back to the previous stable version.
+- **Install Reporting**: Adoption tracking and successful install analytics are automatically reported to your AppSpacer dashboard.
+
+## License
+
+MIT — see [LICENSE](LICENSE)

package/android/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.appspacer"
+    compileSdkVersion 34
+
+    defaultConfig {
+        minSdkVersion 23
+        targetSdkVersion 34
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs = ['src/main/java']
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android:+'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/appspacer/AppSpacerCrashHandler.java

@@ -0,0 +1,128 @@
+package com.appspacer;
+
+import android.content.Context;
+import android.os.Build;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public class AppSpacerCrashHandler implements Thread.UncaughtExceptionHandler {
+    private static final String TAG = "AppSpacerCrashHandler";
+    private static final int MAX_BREADCRUMBS = 50;
+    
+    private final Thread.UncaughtExceptionHandler defaultHandler;
+    private final Context context;
+    private static boolean isInitialized = false;
+    
+    // Static buffer for diagnostic context
+    private static final List<String> breadcrumbs = Collections.synchronizedList(new ArrayList<String>());
+    private static String userId = null;
+    private static String userMetadata = null;
+
+    private AppSpacerCrashHandler(Context context) {
+        this.context = context.getApplicationContext();
+        this.defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(this);
+    }
+
+    public static synchronized void init(Context context) {
+        if (!isInitialized) {
+            new AppSpacerCrashHandler(context);
+            isInitialized = true;
+            Log.i(TAG, "AppSpacerCrashHandler initialized via context: " + context.getClass().getSimpleName());
+        }
+    }
+
+    public static void addBreadcrumb(String message) {
+        synchronized (breadcrumbs) {
+            if (breadcrumbs.size() >= MAX_BREADCRUMBS) {
+                breadcrumbs.remove(0);
+            }
+            String timestamp = new java.text.SimpleDateFormat("HH:mm:ss.SSS", java.util.Locale.US).format(new java.util.Date());
+            breadcrumbs.add("[" + timestamp + "] " + message);
+        }
+    }
+
+    public static void setUserIdentity(String id, String metadata) {
+        userId = id;
+        userMetadata = metadata;
+    }
+
+    @Override
+    public void uncaughtException(Thread thread, Throwable throwable) {
+        try {
+            Log.e(TAG, "Uncaught native exception captured! Processing...");
+            
+            // 1. Gather stack trace
+            StringWriter sw = new StringWriter();
+            PrintWriter pw = new PrintWriter(sw);
+            throwable.printStackTrace(pw);
+            String stackTrace = sw.toString();
+
+            // 2. Format as JSON payload
+            JSONObject crashData = new JSONObject();
+            String id = "native-" + System.currentTimeMillis() + "-" + UUID.randomUUID().toString().substring(0, 5);
+            crashData.put("id", id);
+            crashData.put("type", "native");
+            
+            JSONObject payload = new JSONObject();
+            payload.put("message", throwable.getMessage() != null ? throwable.getMessage() : throwable.getClass().getName());
+            payload.put("stack", stackTrace);
+            payload.put("isFatal", true);
+            crashData.put("payload", payload.toString());
+            
+            // Enriched Device Info
+            JSONObject device = new JSONObject();
+            device.put("os", "android");
+            device.put("os_version", Build.VERSION.RELEASE);
+            device.put("model", Build.MODEL);
+            device.put("manufacturer", Build.MANUFACTURER);
+            device.put("sdk_int", Build.VERSION.SDK_INT);
+            device.put("brand", Build.BRAND);
+            crashData.put("device", device);
+
+            // Breadcrumbs
+            JSONArray breadcrumbsArray = new JSONArray();
+            synchronized (breadcrumbs) {
+                for (String b : breadcrumbs) {
+                    breadcrumbsArray.put(b);
+                }
+            }
+            crashData.put("breadcrumbs", breadcrumbsArray);
+            
+            // ISO 8601 timestamp
+            crashData.put("timestamp", new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", java.util.Locale.US).format(new java.util.Date()));
+
+            // User Identity
+            if (userId != null) {
+                crashData.put("user_id", userId);
+            }
+            if (userMetadata != null) {
+                try {
+                    crashData.put("user_metadata", new JSONObject(userMetadata));
+                } catch (Exception ignore) {}
+            }
+
+            // 3. Save to disk synchronously
+            Log.d(TAG, "Saving native crash " + id + " to disk synchronously");
+            AppSpacerModule.saveCrashToDiskSync(context, id, crashData.toString());
+            Log.i(TAG, "Native crash saved. App will now terminate.");
+        } catch (Exception e) {
+            Log.e(TAG, "Error during crash processing", e);
+        }
+
+        // 4. Call default handler
+        if (defaultHandler != null) {
+            defaultHandler.uncaughtException(thread, throwable);
+        }
+    }
+}