Expo

Run this in your Expo project. fireota init detects Expo and wires everything for you:

npx expo install @fireota/react-native
npm install --save-dev @fireota/cli
npx fireota init --app YOUR_APP_ID --server-url https://fireota.example.com

• fireota.config.js — app ID, server URL and channel (no secrets).
• app.json — adds the "@fireota/react-native" config plugin.
• Your root component — with expo-router the root layout (app/_layout.tsx), otherwise registerRootComponent(App) — is wrapped with withFireOTA, which checks for updates and shows the update prompt.
• package.json — an ota:publish script; .gitignore — update packages and the signing key.

Prefer to see every change? These are the only two edits FireOTA needs in an Expo app.

1. 1
   Add the plugin to app.json. The runtime version is your expo.version (Expo writes it into the native project), so bump it whenever native code changes:

   jsonCopy

   {
     "expo": {
       "version": "1.0.0",
       "plugins": [
         "expo-router",
         "@fireota/react-native"
       ]
     }
   }

2. 2
   Wrap your root component. With expo-router:

   tsxCopy

   // src/app/_layout.tsx (or app/_layout.tsx)
   import { Stack } from "expo-router";
   import { withFireOTA } from "@fireota/react-native";
   import fireotaConfig from "../../fireota.config";
   
   function RootLayout() {
     return <Stack />;
   }
   
   export default withFireOTA(RootLayout, fireotaConfig);

   Without expo-router:

   tsxCopy

   // index.ts (apps without expo-router)
   import { registerRootComponent } from "expo";
   import { withFireOTA } from "@fireota/react-native";
   import fireotaConfig from "./fireota.config";
   import App from "./App";
   
   registerRootComponent(withFireOTA(App, fireotaConfig));

On prebuild, the plugin makes release builds load the latest verified OTA bundle: on Android it passes jsBundleFilePath to ExpoReactHostFactory (older SDKs: overrides getJSBundleFile()); on iOS bundleURL() returns FireOTA's bundle. Debug builds keep using Metro.

Make one release build so the app contains the SDK and the plugin's change:

# Local release build (Android): prebuild runs the FireOTA plugin
npx expo run:android --variant release

# Or EAS Build: the plugin runs on EAS's servers too
eas build --platform all --profile production

After that, ship JavaScript changes as updates. The CLI bundles Expo apps with expo export:embed and the same entry point your native build uses (expo-router included), then compiles Hermes bytecode unless "jsEngine": "jsc":

# Bundles with Expo (expo export:embed + Hermes), exactly like the store build
FIREOTA_URL=https://fireota.example.com FIREOTA_API_KEY=fota_sk_... \
  npm run ota:publish -- --message "Fix checkout crash"

Already using expo-updates? You can keep it and point it at FireOTA instead of EAS Update. You don't need the FireOTA SDK or any native change. Bundles are stored in your own Firebase Storage, and you still get channels, rollouts and rollbacks.

1. 1
   Remove expo-updates and its config:

   bashCopy

   npm uninstall expo-updates
   # remove "updates" and "runtimeVersion" from app.json, then rebuild
   npx expo prebuild --clean

2. 2
   Run npx fireota init … as above and ship a new store build. Users on old builds keep receiving EAS updates until they install it.
3. 3
   Map EAS channels to FireOTA channels (production, beta, …). Keep FireOTA runtime versions equal to expo.version.

• Build fails with “expo-updates is installed” — remove it (see above); FireOTA cannot run next to it.
• Prebuild warns “could not find the expected code” — your MainApplication or AppDelegate was customised. Apply the change from Android setup / iOS setup in your own config plugin.
• Update downloads but never applies — you're running a debug build or Expo Go; test with npx expo run:android --variant release.
• “No compatible update” — expo.version of the installed build must equal the update's runtime version.