@swiftpatch/react-native 2.0.0

package/src/core/Downloader.ts

@@ -0,0 +1,74 @@
+import NativeSwiftPatch, {
+  onDownloadProgress,
+} from '../native/NativeSwiftPatch';
+import { logger } from '../utils/logger';
+import type { ReleaseInfo, DownloadProgress } from '../types';
+
+export interface DownloadOptions {
+  url: string;
+  expectedHash: string;
+  isPatch: boolean;
+  signature: string | null;
+}
+
+/**
+ * Core module responsible for downloading OTA bundles or patches.
+ *
+ * Delegates to the native module for actual download + disk I/O.
+ * Provides progress tracking and cancellation.
+ */
+export class Downloader {
+  private unsubscribeProgress: (() => void) | null = null;
+
+  /**
+   * Download a bundle or patch from the given options.
+   */
+  async download(options: DownloadOptions): Promise<void> {
+    logger.info(
+      `Downloading ${options.isPatch ? 'patch' : 'full bundle'}: ${options.expectedHash}`
+    );
+
+    await NativeSwiftPatch.downloadUpdate(
+      options.url,
+      options.expectedHash,
+      options.isPatch,
+      options.signature
+    );
+
+    logger.info('Download complete');
+  }
+
+  /**
+   * Convenience: download a release (extracts fields from ReleaseInfo).
+   */
+  async downloadRelease(release: ReleaseInfo): Promise<void> {
+    await this.download({
+      url: release.downloadUrl,
+      expectedHash: release.bundleHash,
+      isPatch: release.isPatch,
+      signature: release.signature || null,
+    });
+  }
+
+  /**
+   * Register a callback for download progress events.
+   * Returns an unsubscribe function.
+   */
+  onProgress(callback: (progress: DownloadProgress) => void): () => void {
+    this.unsubscribeProgress = onDownloadProgress(callback);
+    return () => {
+      if (this.unsubscribeProgress) {
+        this.unsubscribeProgress();
+        this.unsubscribeProgress = null;
+      }
+    };
+  }
+
+  /**
+   * Cancel an in-progress download.
+   */
+  async cancel(): Promise<void> {
+    logger.info('Cancelling download');
+    await NativeSwiftPatch.cancelDownload();
+  }
+}

package/src/core/Installer.ts

@@ -0,0 +1,38 @@
+import NativeSwiftPatch from '../native/NativeSwiftPatch';
+import { logger } from '../utils/logger';
+
+/**
+ * Core module responsible for installing verified bundles.
+ *
+ * Delegates to the native module for atomic file operations
+ * and pending install tracking.
+ */
+export class Installer {
+  /**
+   * Install a downloaded and verified bundle by its hash.
+   * The native module handles moving the file to the correct location
+   * and setting it as the pending bundle.
+   */
+  async install(bundleHash: string): Promise<void> {
+    logger.info(`Installing bundle: ${bundleHash}`);
+    await NativeSwiftPatch.installUpdate(bundleHash);
+    logger.info('Bundle installed, restart required to activate');
+  }
+
+  /**
+   * Confirm the current installation as stable.
+   * Call this after the app has been running without crashes
+   * for the crash detection window period.
+   */
+  async confirm(): Promise<void> {
+    logger.info('Confirming installation as stable');
+    await NativeSwiftPatch.confirmInstall();
+  }
+
+  /**
+   * Check if there is a pending installation awaiting restart.
+   */
+  async hasPending(): Promise<boolean> {
+    return NativeSwiftPatch.hasPendingInstall();
+  }
+}

package/src/core/Rollback.ts

@@ -0,0 +1,28 @@
+import NativeSwiftPatch from '../native/NativeSwiftPatch';
+import { logger } from '../utils/logger';
+
+/**
+ * Core module responsible for rollback operations.
+ *
+ * Delegates to the native module for reverting to the
+ * previous bundle version and clearing pending updates.
+ */
+export class Rollback {
+  /**
+   * Rollback to the previous bundle version.
+   * The native module restores the prior known-good bundle.
+   */
+  async rollback(): Promise<void> {
+    logger.info('Rolling back to previous bundle');
+    await NativeSwiftPatch.rollback();
+    logger.info('Rollback complete');
+  }
+
+  /**
+   * Clear any pending update that has not yet been activated.
+   */
+  async clearPending(): Promise<void> {
+    logger.info('Clearing pending update');
+    await NativeSwiftPatch.clearPendingUpdate();
+  }
+}

package/src/core/UpdateChecker.ts

@@ -0,0 +1,70 @@
+import { Platform } from 'react-native';
+import NativeSwiftPatch from '../native/NativeSwiftPatch';
+import { checkForUpdateAPI } from '../utils/api';
+import { logger } from '../utils/logger';
+import { SDK_VERSION } from '../constants';
+import type { ReleaseInfo } from '../types';
+
+export interface UpdateCheckOptions {
+  serverUrl: string;
+  deploymentKey: string;
+  customHeaders?: Record<string, string>;
+}
+
+export interface UpdateCheckResult {
+  updateAvailable: boolean;
+  release?: ReleaseInfo;
+  reason?: string;
+}
+
+/**
+ * Core module responsible for checking for available OTA updates.
+ *
+ * Gathers device info from the native module and calls the
+ * server's check-update endpoint.
+ */
+export class UpdateChecker {
+  private options: UpdateCheckOptions;
+
+  constructor(options: UpdateCheckOptions) {
+    this.options = options;
+  }
+
+  /**
+   * Check the server for an available update.
+   * Gathers appVersion, currentBundleHash, deviceId from native module.
+   */
+  async check(): Promise<UpdateCheckResult> {
+    const appVersion = await NativeSwiftPatch.getAppVersion();
+    const currentBundle = await NativeSwiftPatch.getCurrentBundle();
+    const deviceId = await NativeSwiftPatch.getDeviceId();
+
+    logger.debug(
+      `Checking for update: appVersion=${appVersion}, platform=${Platform.OS}, sdkVersion=${SDK_VERSION}`
+    );
+
+    const result = await checkForUpdateAPI({
+      serverUrl: this.options.serverUrl,
+      deploymentKey: this.options.deploymentKey,
+      appVersion,
+      currentBundleHash: currentBundle?.hash || null,
+      platform: Platform.OS as 'ios' | 'android',
+      deviceId,
+      customHeaders: this.options.customHeaders,
+    });
+
+    if (result.updateAvailable && result.release) {
+      logger.info(`Update available: ${result.release.version}`);
+      return {
+        updateAvailable: true,
+        release: result.release,
+      };
+    }
+
+    logger.debug('No update available');
+    return {
+      updateAvailable: false,
+      reason: (result as any).reason || 'NO_UPDATE',
+    };
+  }
+}

package/src/core/Verifier.ts

@@ -0,0 +1,92 @@
+import NativeSwiftPatch from '../native/NativeSwiftPatch';
+import { logger } from '../utils/logger';
+import type { ReleaseInfo } from '../types';
+
+/**
+ * Core module responsible for verifying downloaded bundles.
+ *
+ * 4-step verification pipeline:
+ * 1. Apply patch if isPatch (via native bspatch)
+ * 2. Compute SHA-256 hash of the resulting bundle (via native)
+ * 3. Verify hash matches release.bundleHash
+ * 4. Verify RSA signature if provided (via native)
+ */
+export class Verifier {
+  private publicKey: string | null = null;
+
+  /**
+   * Set the RSA public key for signature verification.
+   */
+  setPublicKey(key: string | null): void {
+    this.publicKey = key;
+  }
+
+  /**
+   * Run the full verification pipeline on a downloaded bundle/patch.
+   *
+   * @param downloadedPath  Path to the downloaded file on disk
+   * @param release         Release metadata from the server
+   * @param currentBundlePath  Path to the current bundle (needed if isPatch)
+   * @returns The path to the final verified bundle
+   */
+  async verify(
+    downloadedPath: string,
+    release: ReleaseInfo,
+    currentBundlePath?: string
+  ): Promise<string> {
+    let bundlePath = downloadedPath;
+
+    // Step 1: Apply patch if this is a diff patch
+    if (release.isPatch) {
+      if (!currentBundlePath) {
+        throw new Error('Current bundle path required to apply patch');
+      }
+
+      logger.info('Applying binary patch...');
+      const outputPath = `${downloadedPath}.patched`;
+      bundlePath = await NativeSwiftPatch.applyPatch(
+        currentBundlePath,
+        downloadedPath,
+        outputPath
+      );
+      logger.info('Patch applied successfully');
+    }
+
+    // Step 2: Compute SHA-256 hash
+    logger.debug('Computing bundle hash...');
+    const computedHash = await NativeSwiftPatch.computeHash(bundlePath);
+
+    // Step 3: Verify hash matches expected
+    if (computedHash !== release.bundleHash) {
+      throw new Error(
+        `Hash mismatch: expected ${release.bundleHash}, got ${computedHash}`
+      );
+    }
+    logger.info('Hash verified successfully');
+
+    // Step 4: Verify RSA signature if provided
+    if (release.signature && this.publicKey) {
+      logger.debug('Verifying RSA signature...');
+      const isValid = await NativeSwiftPatch.verifySignature(
+        computedHash,
+        release.signature,
+        this.publicKey
+      );
+
+      if (!isValid) {
+        throw new Error('RSA signature verification failed');
+      }
+      logger.info('Signature verified successfully');
+    }
+
+    return bundlePath;
+  }
+
+  /**
+   * Quick hash-only verification.
+   */
+  async verifyHash(bundlePath: string, expectedHash: string): Promise<boolean> {
+    const hash = await NativeSwiftPatch.computeHash(bundlePath);
+    return hash === expectedHash;
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,11 @@
+export { UpdateChecker } from './UpdateChecker';
+export type { UpdateCheckOptions, UpdateCheckResult } from './UpdateChecker';
+
+export { Downloader } from './Downloader';
+export type { DownloadOptions } from './Downloader';
+
+export { Verifier } from './Verifier';
+
+export { Installer } from './Installer';
+
+export { Rollback } from './Rollback';

package/src/index.ts

@@ -0,0 +1,64 @@
+// Provider
+export { SwiftPatchProvider } from './SwiftPatchProvider';
+
+// Hooks
+export { useSwiftPatch, useSwiftPatchUpdate } from './useSwiftPatch';
+export { useSwiftPatchModal } from './modal/useSwiftPatchModal';
+
+// HOC
+export { withSwiftPatch } from './withSwiftPatch';
+
+// Imperative API (for non-React usage)
+export { SwiftPatch } from './SwiftPatchCore';
+
+// Modal component
+export { SwiftPatchModal } from './modal/SwiftPatchModal';
+
+// Types
+export type {
+  SwiftPatchConfig,
+  SwiftPatchState,
+  SwiftPatchActions,
+  UseSwiftPatchReturn,
+  UseSwiftPatchUpdateReturn,
+  UseSwiftPatchModalReturn,
+  ReleaseInfo,
+  BundleInfo,
+  DownloadProgress,
+  SwiftPatchError,
+  SlotMetadata,
+  SwiftPatchEvent,
+} from './types';
+
+// Enums
+export {
+  UpdateStatus,
+  InstallMode,
+  SwiftPatchErrorCode,
+  SlotState,
+  EnvironmentMode,
+  SwiftPatchEventType,
+} from './types';
+
+// Native module (for advanced usage)
+export { default as NativeSwiftPatch } from './native/NativeSwiftPatch';
+
+// Core modules (for advanced/custom usage)
+export {
+  UpdateChecker,
+  Downloader,
+  Verifier,
+  Installer,
+  Rollback,
+} from './core';
+export type {
+  UpdateCheckOptions,
+  UpdateCheckResult,
+  DownloadOptions,
+} from './core';
+
+// Utility: restart the app
+export function restart(): void {
+  const NativeModule = require('./native/NativeSwiftPatch').default;
+  NativeModule.restart();
+}