Hot Updater

The @hot-updater/expo plugin provides the following capabilities:

• Uses Expo's expo export:embed command for bundling.
• Automatically detects Hermes configuration from app.json.
• Supports both managed and bare Expo workflows.
• Compatible with expo prebuild for native builds.
• Automatically configures the bundler based on your existing Expo settings.

The @hot-updater/bare plugin provides the following capabilities:

• Metro Bundler Integration: Uses the standard React Native CLI's Metro bundler.
• Hermes Support: Provides automatic Hermes bytecode compilation when enableHermes is set to true.
• Optimized Minification: Minification is automatically handled by Hermes when enabled (standard minification is disabled in this mode).
• Customization: Supports specifying custom entry files and output directories.

Hot Updater provides several core capabilities for managing mobile app updates:

• Self-Hosting: Complete control over your update infrastructure.
• Multi-Platform: Support for both iOS and Android.
• Web Console: A management interface for overseeing updates.
• Version Control: Robust versioning including semantic versioning support.
• Forced Updates: The ability to push critical updates that users must install.
• Channel Management: Environment separation (e.g., dev, staging, production).
• Fingerprint Strategy: Automatic checking to ensure updates are compatible with the current native code.

Prerequisites

• A React Native project with android/ and ios/ directories tracked.
• hot-updater.config.ts must define at least one scheme for nativeBuild.android and/or nativeBuild.ios.
• Local platform toolchains installed (gradlew, xcodebuild, CocoaPods/Bundler, devicectl/simctl).
• Run hot-updater channel set <channel> so HOT_UPDATER_CHANNEL is present in Info.plist/strings.xml.
• An active update strategy (appVersion or fingerprint) configured.

Artifact Storage

By default, artifacts are stored in .hot-updater/output/build/<platform>/<scheme>. This directory is recreated on every run. If you need to persist older artifacts for CI/CD, use the -o flag to point to a different directory.

The project is organized as follows:

• src/index.ts: Main server entry point.
• src/db.ts: Database setup (PGlite + Kysely + Hot Updater schema).
• src/routes.ts: API route definitions.
• data/: PGlite database files (stored at ./data/hot-updater.db). This directory is gitignored.

Database Details

The server uses PGlite for file-based persistence. The database schema is generated from Hot Updater's versioned schema and is migrated through the Hot Updater CLI. The schema is initialized automatically on the first run.

The supabaseStorage plugin implements two distinct storage profiles to handle different parts of the Hot Updater lifecycle:

• node profile: Used during CLI or Console workflows. It handles uploading, deleting, and downloading files to/from the local filesystem.
• runtime profile: Used by the client application. It creates signed download URLs and reads small metadata files directly through the Supabase Storage API.

Note for Supabase Edge Functions: If you are running in a Supabase Edge Function environment, ensure you use the runtime-specific storage export. This allows update checks to resolve downloads without requiring local filesystem APIs.

Hot Updater automatically includes artifacts for bundle diffing with every deployment. If the app runtime supports manifest-based diffing, the client will only download changed files instead of the entire archive.

Hermes bsdiff Patches

If you enable patch.enabled: true in your hot-updater.config.ts, the deployment process will also attempt to prepare compatible bsdiff patches for the Hermes bundle.

Note: Patch generation is best-effort. If a patch fails to generate, the deployment will still succeed using the standard archive update.

The reloadOnForceUpdate option determines if the app automatically reloads after a force update bundle is downloaded.

• If true (default): The app reloads automatically.
• If false: The app will not reload automatically, but shouldForceUpdate will be returned as true in the onUpdateProcessCompleted callback, allowing you to trigger a reload manually via HotUpdater.reload().

// Example without auto-reload
export default HotUpdater.wrap({
  baseURL: "<your-update-server-url>",
  updateStrategy: "appVersion",
  reloadOnForceUpdate: false, // The app won't reload on force updates
  onUpdateProcessCompleted: ({ status, shouldForceUpdate, id, message }) => {
    console.log("Bundle updated:", status, shouldForceUpdate, id, message);
    if (shouldForceUpdate) {
      // Manually reload if needed
      await HotUpdater.reload();
    }
  },
})(App);