pushkoncept-react-native 0.0.0-stage → 1.0.0

package/OTAUpdate.js

@@ -0,0 +1,161 @@
+// React Native OTA SDK
+import { Platform, DevSettings } from 'react-native';
+import RNFS from 'react-native-fs';
+
+class OTAClient {
+  constructor() {
+    this.config = {
+      serverUrl: null,
+      appId: null,
+      appToken: null,
+      apiKey: null,
+      channel: 'production'
+    };
+  }
+
+  /**
+   * Initialize the SDK with your App ID, Server URL, and API Key / App Token.
+   * You get the App ID and Token from your OTA Dashboard.
+   */
+  configure(options) {
+    if (!options.serverUrl || !options.appId) {
+      console.error('[OTA] Missing serverUrl or appId in configuration!');
+      return;
+    }
+    this.config = { ...this.config, ...options };
+    console.log('[OTA] Configured for App ID:', this.config.appId);
+  }
+
+  /**
+   * Returns current active OTA version if any, or the default version.
+   */
+  async getCurrentVersion(defaultVersion) {
+    try {
+      const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+      const savedVersion = await AsyncStorage.getItem('@ota_bundle_version');
+      return savedVersion || defaultVersion;
+    } catch (e) {
+      return defaultVersion;
+    }
+  }
+
+  /**
+   * Checks the server to see if a new update is available.
+   * @param {string} currentVersion - The base version of your app (e.g., '1.0.0')
+   */
+  async checkForUpdate(currentVersion) {
+    if (!this.config.serverUrl) throw new Error('[OTA] You must call OTA.configure() first!');
+    
+    try {
+      const activeVersion = await this.getCurrentVersion(currentVersion);
+      const deviceId = await this._getDeviceId();
+      const url = new URL(`${this.config.serverUrl}/api/update/check`);
+      url.searchParams.set('app_id', this.config.appId);
+      url.searchParams.set('version', activeVersion);
+      url.searchParams.set('app_version', currentVersion);
+      url.searchParams.set('channel', this.config.channel);
+      url.searchParams.set('device_id', deviceId);
+      url.searchParams.set('platform', Platform.OS); // 'ios' or 'android'
+      url.searchParams.set('os', Platform.OS); // 'ios' or 'android'
+      
+      const token = this.config.apiKey || this.config.appToken || this.config.token;
+      if (token) url.searchParams.set('token', token);
+
+      const headers = { 'ngrok-skip-browser-warning': 'true' };
+      if (token) headers['x-api-key'] = token;
+
+      const response = await fetch(url.toString(), { headers });
+      const data = await response.json();
+      
+      return data.update_available ? data : null;
+    } catch (error) {
+      console.warn('[OTA] Update check failed:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Downloads and verifies the update bundle.
+   */
+  async downloadAndApplyUpdate(update, onProgress) {
+    if (!update?.bundle_url) return false;
+    
+    const destPath = RNFS.DocumentDirectoryPath + '/ota_update.bundle';
+    
+    try {
+      const result = await RNFS.downloadFile({
+        fromUrl: update.bundle_url,
+        toFile: destPath,
+        headers: {
+          'ngrok-skip-browser-warning': 'true',
+        },
+        progress: (res) => {
+          const pct = Math.round(res.bytesWritten / res.contentLength * 100);
+          if (onProgress) onProgress(pct);
+        },
+      }).promise;
+      
+      if (result.statusCode !== 200) throw new Error(`Download failed: ${result.statusCode}`);
+      
+      if (update.bundle_hash) {
+        const fileHash = await RNFS.hash(destPath, 'sha256');
+        if (fileHash !== update.bundle_hash) {
+          await RNFS.unlink(destPath);
+          throw new Error('Hash mismatch - bundle corrupted');
+        }
+      }
+      
+      await this._reportDownload(update.release_id, 'success');
+
+      // ✅ Bundle path save karo taake next launch par use ho
+      try {
+        const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+        await AsyncStorage.setItem('@ota_bundle_path', destPath);
+        await AsyncStorage.setItem('@ota_bundle_version', update.version);
+      } catch(e) {}
+
+      // ✅ App reload karo naya bundle apply karne ke liye
+      setTimeout(() => {
+        try { DevSettings.reload(); } catch(e) {}
+      }, 500);
+
+      return true;
+      
+    } catch (error) {
+      console.error('[OTA] Download failed:', error.message);
+      await this._reportDownload(update.release_id, 'failed');
+      try { await RNFS.unlink(destPath); } catch(e) {}
+      return false;
+    }
+  }
+
+  async _reportDownload(releaseId, status) {
+    try {
+      await fetch(`${this.config.serverUrl}/api/update/download-${status}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'ngrok-skip-browser-warning': 'true', // ngrok fix
+        },
+        body: JSON.stringify({ release_id: releaseId, platform: Platform.OS }),
+      });
+    } catch (e) {}
+  }
+
+  async _getDeviceId() {
+    try {
+      const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+      let deviceId = await AsyncStorage.getItem('@ota_device_id');
+      if (!deviceId) {
+        deviceId = Math.random().toString(36).slice(2) + Date.now().toString(36);
+        await AsyncStorage.setItem('@ota_device_id', deviceId);
+      }
+      return deviceId;
+    } catch (e) {
+      return 'unknown';
+    }
+  }
+}
+
+// Export a single instance to be used throughout the app
+export default new OTAClient();

package/README.md

@@ -1,3 +1,94 @@
-# Temporary Holding Version
+# 🚀 PushKoncept React Native SDK
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Seamless, instant Over-The-Air (OTA) updates for React Native apps. Push JavaScript bundle updates and assets directly to users' devices without waiting for App Store or Google Play approval.
+
+---
+
+## 📦 Installation
+
+```bash
+# Using npm
+npm install pushkoncept-react-native react-native-fs @react-native-async-storage/async-storage
+
+# Or using yarn
+yarn add pushkoncept-react-native react-native-fs @react-native-async-storage/async-storage
+```
+
+> **iOS Note**: Run `cd ios && pod install` after installation.
+
+---
+
+## ⚡ Quick Start (1 Line Integration)
+
+Wrap your root `App` component with `withPushKoncept`:
+
+```jsx
+import React from 'react';
+import { View, Text } from 'react-native';
+import { withPushKoncept } from 'pushkoncept-react-native';
+
+const App = () => {
+  return (
+    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
+      <Text>Welcome to My App!</Text>
+    </View>
+  );
+};
+
+// Wrap your root component with PushKoncept
+export default withPushKoncept(App, {
+  serverUrl: 'http://localhost:3001', // Your PushKoncept Server URL
+  appId: 'YOUR_APP_ID',              // Found in PushKoncept Portal
+  appToken: 'YOUR_APP_TOKEN',        // Found in App Settings
+  channel: 'production'              // 'production' | 'staging' | 'beta'
+});
+```
+
+That's it! Your app will now:
+1. Automatically check for OTA updates on app launch and resume.
+2. Silently download and apply updates in the background.
+3. Automatically prompt and show a progress modal for mandatory / force updates.
+
+---
+
+## 🛠️ Manual / Custom Control (CodePush Style)
+
+If you want fine-grained control over when updates are checked and applied:
+
+```javascript
+import PushKoncept, { InstallMode } from 'pushkoncept-react-native';
+
+// 1. Configure during app startup (e.g. index.js or App.js)
+PushKoncept.configure({
+  serverUrl: 'http://localhost:3001',
+  appId: 'YOUR_APP_ID',
+  appToken: 'YOUR_APP_TOKEN',
+  channel: 'production'
+});
+
+// 2. Check and Sync
+async function handleCheckUpdate() {
+  const update = await PushKoncept.checkForUpdate('1.0.0');
+  if (update) {
+    console.log('Update found! Version:', update.version);
+    
+    await PushKoncept.downloadAndApplyUpdate(update, {
+      installMode: InstallMode.IMMEDIATE, // or InstallMode.ON_NEXT_RESUME
+      onProgress: (pct) => {
+        console.log(`Downloading: ${pct}%`);
+      }
+    });
+  }
+}
+```
+
+---
+
+## 💻 Deploying Updates with PushKoncept CLI
+
+Deploy updates directly from your terminal in 1 command without creating zip bundles manually:
+
+```bash
+# In your React Native project root:
+pushkoncept release-react --app "My App" --version 1.0.1
+```

package/index.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+
+export declare const InstallMode: {
+  readonly IMMEDIATE: 'IMMEDIATE';
+  readonly ON_NEXT_RESUME: 'ON_NEXT_RESUME';
+  readonly ON_NEXT_RESTART: 'ON_NEXT_RESTART';
+};
+
+export interface PushKonceptConfig {
+  serverUrl: string;
+  appId: string;
+  appToken?: string;
+  apiKey?: string;
+  channel?: 'production' | 'staging' | 'beta' | string;
+  debug?: boolean;
+  appVersion?: string;
+}
+
+export interface UpdateInfo {
+  update_available: boolean;
+  version: string;
+  build_number: number;
+  bundle_url: string;
+  bundle_hash: string;
+  bundle_size: number;
+  release_notes?: string;
+  rollout_percentage: number;
+  is_mandatory: boolean;
+  release_id: string;
+}
+
+export interface SyncOptions {
+  appVersion?: string;
+  installMode?: keyof typeof InstallMode;
+  onProgress?: (percentage: number) => void;
+  onMandatoryUpdate?: (update: UpdateInfo, proceed: () => void) => void;
+}
+
+export declare class PushKonceptClient {
+  configure(options: PushKonceptConfig): void;
+  getCurrentVersion(baseVersion?: string): Promise<string>;
+  checkForUpdate(currentAppVersion?: string): Promise<UpdateInfo | null>;
+  downloadAndApplyUpdate(update: UpdateInfo, options?: SyncOptions): Promise<boolean>;
+  sync(options?: SyncOptions): Promise<void>;
+  reloadApp(): void;
+}
+
+export declare const PushKoncept: PushKonceptClient;
+
+export declare function withPushKoncept<P extends object>(
+  WrappedComponent: React.ComponentType<P>,
+  config: PushKonceptConfig
+): React.ComponentType<P>;
+
+export default PushKoncept;

package/index.js

@@ -0,0 +1,348 @@
+/**
+ * PushKoncept React Native SDK
+ * Fast, reliable Over-The-Air (OTA) updates for React Native apps.
+ */
+
+import React, { useEffect, useState } from 'react';
+import { Platform, DevSettings, Alert, AppState, View, Text, Modal, ActivityIndicator, StyleSheet } from 'react-native';
+import RNFS from 'react-native-fs';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export const InstallMode = {
+  IMMEDIATE: 'IMMEDIATE',
+  ON_NEXT_RESUME: 'ON_NEXT_RESUME',
+  ON_NEXT_RESTART: 'ON_NEXT_RESTART'
+};
+
+class PushKonceptClient {
+  constructor() {
+    this.config = {
+      serverUrl: null,
+      appId: null,
+      appToken: null,
+      channel: 'production',
+      debug: false
+    };
+    this._isSyncing = false;
+    this._hasPendingUpdate = false;
+  }
+
+  log(...args) {
+    if (this.config.debug) {
+      console.log('[PushKoncept]', ...args);
+    }
+  }
+
+  /**
+   * Configure the SDK with your App ID and Server URL
+   */
+  configure(options = {}) {
+    if (!options.serverUrl || !options.appId) {
+      console.error('[PushKoncept] Error: serverUrl and appId are required.');
+      return;
+    }
+    this.config = { ...this.config, ...options };
+    this.log('Configured for App ID:', this.config.appId, 'Channel:', this.config.channel);
+  }
+
+  /**
+   * Get active OTA version from local storage or fallback to base
+   */
+  async getCurrentVersion(baseVersion = '1.0.0') {
+    try {
+      const savedVersion = await AsyncStorage.getItem('@pushkoncept_bundle_version');
+      return savedVersion || baseVersion;
+    } catch (e) {
+      return baseVersion;
+    }
+  }
+
+  /**
+   * Check if an update is available on the PushKoncept server
+   */
+  async checkForUpdate(currentAppVersion = '1.0.0') {
+    if (!this.config.serverUrl || !this.config.appId) {
+      throw new Error('[PushKoncept] You must call PushKoncept.configure() first.');
+    }
+
+    try {
+      const activeVersion = await this.getCurrentVersion(currentAppVersion);
+      const deviceId = await this._getDeviceId();
+
+      const url = new URL(`${this.config.serverUrl.replace(/\/$/, '')}/api/update/check`);
+      url.searchParams.set('app_id', this.config.appId);
+      url.searchParams.set('version', activeVersion);
+      url.searchParams.set('app_version', currentAppVersion);
+      url.searchParams.set('channel', this.config.channel || 'production');
+      url.searchParams.set('device_id', deviceId);
+      url.searchParams.set('platform', Platform.OS);
+
+      const token = this.config.appToken || this.config.apiKey || this.config.token;
+      if (token) {
+        url.searchParams.set('token', token);
+      }
+
+      const headers = { 'ngrok-skip-browser-warning': 'true' };
+      if (token) headers['x-api-key'] = token;
+
+      this.log('Checking for update at:', url.toString());
+      const response = await fetch(url.toString(), { headers });
+      const data = await response.json();
+
+      if (data && data.update_available) {
+        this.log('Update found! Version:', data.version, 'Mandatory:', data.is_mandatory);
+        return data;
+      }
+
+      this.log('App is up to date.');
+      return null;
+    } catch (error) {
+      console.warn('[PushKoncept] Update check failed:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Download and install a bundle update
+   */
+  async downloadAndApplyUpdate(update, options = {}) {
+    if (!update?.bundle_url) return false;
+
+    const onProgress = options.onProgress || (() => {});
+    const installMode = options.installMode || (update.is_mandatory ? InstallMode.IMMEDIATE : InstallMode.ON_NEXT_RESUME);
+
+    const destPath = `${RNFS.DocumentDirectoryPath}/pushkoncept_update.bundle`;
+
+    try {
+      this.log('Starting bundle download from:', update.bundle_url);
+      const result = await RNFS.downloadFile({
+        fromUrl: update.bundle_url,
+        toFile: destPath,
+        headers: { 'ngrok-skip-browser-warning': 'true' },
+        progress: (res) => {
+          const pct = Math.round((res.bytesWritten / res.contentLength) * 100);
+          onProgress(pct);
+        }
+      }).promise;
+
+      if (result.statusCode !== 200) {
+        throw new Error(`Download failed with HTTP ${result.statusCode}`);
+      }
+
+      // SHA-256 Hash verification
+      if (update.bundle_hash) {
+        const fileHash = await RNFS.hash(destPath, 'sha256');
+        if (fileHash !== update.bundle_hash) {
+          await RNFS.unlink(destPath).catch(() => {});
+          throw new Error('Hash mismatch: bundle may be corrupted.');
+        }
+        this.log('SHA-256 Hash verified successfully.');
+      }
+
+      // Record successful download
+      await this._reportDownload(update.release_id, 'success');
+
+      // Save version and path metadata
+      await AsyncStorage.setItem('@pushkoncept_bundle_path', destPath);
+      await AsyncStorage.setItem('@pushkoncept_bundle_version', update.version);
+      this._hasPendingUpdate = true;
+
+      this.log('Update installed successfully! InstallMode:', installMode);
+
+      if (installMode === InstallMode.IMMEDIATE) {
+        setTimeout(() => {
+          this.reloadApp();
+        }, 300);
+      }
+
+      return true;
+    } catch (error) {
+      console.error('[PushKoncept] Download failed:', error.message);
+      await this._reportDownload(update.release_id, 'failed');
+      await RNFS.unlink(destPath).catch(() => {});
+      return false;
+    }
+  }
+
+  /**
+   * Reload app to activate new JavaScript bundle
+   */
+  reloadApp() {
+    try {
+      if (DevSettings && DevSettings.reload) {
+        DevSettings.reload();
+      }
+    } catch (e) {
+      console.warn('[PushKoncept] Unable to auto-reload. Update will apply on next restart.');
+    }
+  }
+
+  /**
+   * One-line CodePush style sync method
+   */
+  async sync(options = {}) {
+    if (this._isSyncing) return;
+    this._isSyncing = true;
+
+    try {
+      const update = await this.checkForUpdate(options.appVersion || '1.0.0');
+      if (!update) {
+        this._isSyncing = false;
+        return;
+      }
+
+      if (update.is_mandatory && options.onMandatoryUpdate) {
+        options.onMandatoryUpdate(update, async () => {
+          await this.downloadAndApplyUpdate(update, options);
+        });
+      } else {
+        await this.downloadAndApplyUpdate(update, options);
+      }
+    } finally {
+      this._isSyncing = false;
+    }
+  }
+
+  async _reportDownload(releaseId, status) {
+    try {
+      await fetch(`${this.config.serverUrl.replace(/\/$/, '')}/api/update/download-${status}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'ngrok-skip-browser-warning': 'true'
+        },
+        body: JSON.stringify({ release_id: releaseId, platform: Platform.OS })
+      });
+    } catch (e) {}
+  }
+
+  async _getDeviceId() {
+    try {
+      let deviceId = await AsyncStorage.getItem('@pushkoncept_device_id');
+      if (!deviceId) {
+        deviceId = 'pk_' + Math.random().toString(36).slice(2) + Date.now().toString(36);
+        await AsyncStorage.setItem('@pushkoncept_device_id', deviceId);
+      }
+      return deviceId;
+    } catch (e) {
+      return 'device_' + Platform.OS;
+    }
+  }
+}
+
+export const PushKoncept = new PushKonceptClient();
+
+/**
+ * Higher-Order Component (HOC) to wrap your root App component
+ * Automatically checks for updates on launch and app resume!
+ */
+export function withPushKoncept(WrappedComponent, config = {}) {
+  return function PushKonceptRoot(props) {
+    const [downloading, setDownloading] = useState(false);
+    const [progress, setProgress] = useState(0);
+    const [mandatory, setMandatory] = useState(false);
+
+    useEffect(() => {
+      PushKoncept.configure(config);
+
+      const performSync = () => {
+        PushKoncept.sync({
+          appVersion: config.appVersion || '1.0.0',
+          onProgress: (pct) => {
+            setProgress(pct);
+          },
+          onMandatoryUpdate: (update, proceed) => {
+            setMandatory(true);
+            setDownloading(true);
+            proceed();
+          }
+        });
+      };
+
+      performSync();
+
+      const subscription = AppState.addEventListener('change', (nextState) => {
+        if (nextState === 'active') {
+          performSync();
+        }
+      });
+
+      return () => {
+        if (subscription && subscription.remove) {
+          subscription.remove();
+        }
+      };
+    }, []);
+
+    return (
+      <View style={{ flex: 1 }}>
+        <WrappedComponent {...props} />
+        {downloading && (
+          <Modal transparent visible={downloading} animationType="fade">
+            <View style={styles.overlay}>
+              <View style={styles.dialog}>
+                <ActivityIndicator size="large" color="#00E5FF" />
+                <Text style={styles.title}>
+                  {mandatory ? 'Critical Update Required' : 'Installing Update'}
+                </Text>
+                <Text style={styles.subtitle}>
+                  Downloading latest improvements ({progress}%)...
+                </Text>
+                <View style={styles.progressBarBg}>
+                  <View style={[styles.progressBarFill, { width: `${progress}%` }]} />
+                </View>
+              </View>
+            </View>
+          </Modal>
+        )}
+      </View>
+    );
+  };
+}
+
+const styles = StyleSheet.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: 'rgba(10, 14, 26, 0.85)',
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 24
+  },
+  dialog: {
+    width: '100%',
+    maxWidth: 340,
+    backgroundColor: '#121829',
+    borderRadius: 16,
+    padding: 24,
+    alignItems: 'center',
+    borderWidth: 1,
+    borderColor: 'rgba(0, 229, 255, 0.3)'
+  },
+  title: {
+    color: '#EAF0FF',
+    fontSize: 18,
+    fontWeight: 'bold',
+    marginTop: 16,
+    marginBottom: 6,
+    textAlign: 'center'
+  },
+  subtitle: {
+    color: '#8A94AD',
+    fontSize: 13,
+    marginBottom: 16,
+    textAlign: 'center'
+  },
+  progressBarBg: {
+    width: '100%',
+    height: 6,
+    backgroundColor: 'rgba(255, 255, 255, 0.1)',
+    borderRadius: 3,
+    overflow: 'hidden'
+  },
+  progressBarFill: {
+    height: '100%',
+    backgroundColor: '#00E5FF'
+  }
+});
+
+export default PushKoncept;

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "pushkoncept-react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Official PushKoncept React Native SDK for seamless Over-The-Air (OTA) updates and hotfixes",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "pushkoncept",
+    "ota",
+    "codepush",
+    "react-native",
+    "hotfix",
+    "live-update",
+    "over-the-air"
+  ],
+  "author": "PushKoncept",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-fs": ">=2.18.0",
+    "@react-native-async-storage/async-storage": ">=1.15.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pushkoncept/Push-Koncept.git",
+    "directory": "sdk/react-native"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}