@fireota/cli 0.2.0 → 0.4.0

package/README.md

@@ -63,7 +63,8 @@ Paste `fireota-public.pem` into the dashboard (app → Code signing), pass the s
 ## Commands
 
 ```text
-fireota publish  --app <appId> --platform <android|ios|all> --runtime <x.y.z> --message "…"
+fireota init     [--app <appId>] [--server-url <url>] [--channel production] [--dry-run]
+fireota publish  --app <appId> --platform <android|ios|all> [--runtime <x.y.z>] --message "…"
                  [--channel production] [--rollout 10] [--version <label>] [--mandatory] [--native ">=1.4.0"]
                  [--file update.fota] [--private-key key.pem] [--json]
 fireota bundle   --platform <android|ios> [--entry index.js] [--out update.fota] [--hermes auto|on|off]

package/bin/fireota.mjs

@@ -11,16 +11,22 @@ import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { join, relative, resolve } from "node:path";
 
 import { detectCi } from "../lib/ci.mjs";
+import { runInit } from "../lib/init.mjs";
 import { packDirectory } from "../lib/package.mjs";
+import { isExpoProject, readExpoAppJson, storeVersion } from "../lib/project.mjs";
 import { generateKeys, loadPrivateKey, signUpdate } from "../lib/signing.mjs";
 
 const HELP = `FireOTA CLI
 
 Usage:
-  fireota publish  --app <appId> --platform <android|ios|all> --runtime <x.y.z> --message "What changed"
+  fireota init     [--app <appId>] [--server-url <url>] [--channel production] [--dry-run] [--force]
+                   One-time setup: creates fireota.config.js, wraps your root component with the
+                   built-in update UI, and wires MainApplication / AppDelegate for release builds.
+  fireota publish  --app <appId> --platform <android|ios|all> [--runtime <x.y.z>] --message "What changed"
                    [--channel production] [--rollout 10] [--version <label>] [--mandatory] [--native ">=1.4.0"]
                    [--file update.fota] [--private-key fireota-private.pem] [--json]
                    Builds (unless --file), uploads to your Firebase Storage and publishes.
@@ -37,7 +43,9 @@ Usage:
   fireota releases [--app <appId>] [--json]
 
 Updates are identified by their ID (like Expo): --version is only an optional label, and
---runtime must equal the runtime version of the store build the update is for.
+--runtime must equal the runtime version of the store build the update is for. Without
+--runtime, the app's store version is used (android/app/build.gradle versionName, iOS
+MARKETING_VERSION) — the same default the SDK uses.
 
 Environment: FIREOTA_URL, FIREOTA_API_KEY (required); FIREOTA_APP_ID, FIREOTA_CHANNEL,
 FIREOTA_RUNTIME, FIREOTA_SIGNING_KEY / FIREOTA_SIGNING_KEY_PATH (optional).
@@ -94,6 +102,11 @@ function groupIdFrom(seed) {
 function hermesEnabled(platform, mode) {
   if (mode === "on") return true;
   if (mode === "off") return false;
+  // Expo without android/ or ios/ yet: the engine is set in app.json (Hermes unless "jsEngine": "jsc").
+  if (isExpoProject() && !existsSync(platform === "android" ? "android" : "ios")) {
+    const expo = readExpoAppJson() ?? {};
+    return (expo[platform]?.jsEngine ?? expo.jsEngine ?? "hermes") !== "jsc";
+  }
   if (platform === "android") {
     const props = existsSync("android/gradle.properties") ? readFileSync("android/gradle.properties", "utf8") : "";
     return !/^\s*hermesEnabled\s*=\s*false/m.test(props);
@@ -120,17 +133,29 @@ function bundle(flags, platformOverride) {
   if (!existsSync("package.json") || !existsSync(join("node_modules", "react-native"))) {
     fail("Run this from your React Native project root (react-native must be installed).");
   }
-  const entry = flags.entry ? String(flags.entry) : existsSync("index.js") ? "index.js" : "index.ts";
+  const expo = isExpoProject();
+  // Expo apps bundle exactly like their native build does: Expo's entry resolver (expo-router/entry,
+  // registerRootComponent in index.ts, …) and `expo export:embed` instead of `react-native bundle`.
+  const entry = flags.entry
+    ? String(flags.entry)
+    : expo
+      ? execFileSync(process.execPath, ["-e", "require('expo/scripts/resolveAppEntry')", process.cwd(), platform, "absolute"]).toString().trim()
+      : existsSync("index.js")
+        ? "index.js"
+        : "index.ts";
+  const bundler = expo
+    ? [createRequire(resolve("package.json")).resolve("@expo/cli", { paths: [createRequire(resolve("package.json")).resolve("expo/package.json")] }), "export:embed"]
+    : [join("node_modules", "react-native", "cli.js"), "bundle"];
   const bundleName = platform === "android" ? "index.android.bundle" : "main.jsbundle";
   const work = mkdtempSync(join(tmpdir(), "fireota-"));
   const out = join(work, "package");
   try {
     const jsOut = join(work, "bundle.js");
-    log(`Bundling ${entry} for ${platform}…`);
+    log(`Bundling ${relative(".", entry) || entry} for ${platform}${expo ? " (Expo)" : ""}…`);
     // Run the project's own React Native CLI through Node: no shell, same on every OS.
     execFileSync(
       process.execPath,
-      [join("node_modules", "react-native", "cli.js"), "bundle", "--platform", platform, "--dev", "false", "--minify", "false", "--entry-file", entry, "--bundle-output", jsOut, "--assets-dest", out],
+      [...bundler, "--platform", platform, "--dev", "false", "--minify", "false", "--entry-file", entry, "--bundle-output", jsOut, "--assets-dest", out],
       { stdio: jsonMode ? ["ignore", "ignore", "inherit"] : "inherit" },
     );
     // The bundler only creates the assets folder when the app has images.
@@ -182,6 +207,15 @@ async function api(method, path, body, extraHeaders = {}) {
   return json.data;
 }
 
+/** --runtime / FIREOTA_RUNTIME, else the app's store version for that platform. */
+function runtimeFor(flags, platform) {
+  const explicit = flags.runtime ?? process.env.FIREOTA_RUNTIME;
+  if (explicit && explicit !== true) return String(explicit);
+  const detected = storeVersion(platform);
+  if (!detected) fail(`Could not read the ${platform} app version; pass --runtime <x.y.z>.`);
+  return detected;
+}
+
 async function createRelease(flags, platform, extra = {}) {
   const ci = detectCi();
   const message = flags.message ?? flags.notes;
@@ -189,7 +223,7 @@ async function createRelease(flags, platform, extra = {}) {
     appId: need(flags, "app", "FIREOTA_APP_ID"),
     channel: String(flags.channel ?? process.env.FIREOTA_CHANNEL ?? "production"),
     platform,
-    runtimeVersion: need(flags, "runtime", "FIREOTA_RUNTIME"),
+    runtimeVersion: runtimeFor(flags, platform),
     ...(flags.version && flags.version !== true ? { version: String(flags.version) } : {}),
     ...(message && message !== true ? { releaseNotes: String(message) } : {}),
     ...(flags.mandatory ? { mandatory: true } : {}),
@@ -231,7 +265,7 @@ async function releaseAction(releaseId, body) {
 async function publishOne(flags, platform, file, extra, privateKey) {
   const release = await createRelease(flags, platform, extra);
   if (["draft", "failed", "uploading"].includes(release.status)) {
-    await uploadRelease(release.id, file, privateKey ? { key: privateKey, runtimeVersion: need(flags, "runtime", "FIREOTA_RUNTIME"), platform } : null);
+    await uploadRelease(release.id, file, privateKey ? { key: privateKey, runtimeVersion: runtimeFor(flags, platform), platform } : null);
   } else {
     log(`Bundle already uploaded (status ${release.status}); skipping upload.`);
   }
@@ -258,6 +292,25 @@ async function main() {
     bundle(parseArgs(process.argv.slice(3)).flags);
     return;
   }
+  if (command === "init") {
+    const all = parseArgs(process.argv.slice(3)).flags;
+    const result = await runInit(all, { api, log, fail });
+    console.log(result.dry ? "\nFireOTA init (dry run — nothing written):\n" : "\nFireOTA is set up:\n");
+    for (const [mark, text] of result.results) console.log(`  ${mark} ${text}`);
+    const versions = [
+      result.runtime.android ? `Android ${result.runtime.android}` : null,
+      result.runtime.ios ? `iOS ${result.runtime.ios}` : null,
+    ].filter(Boolean);
+    console.log(`
+Runtime version: ${versions.join(", ") || "unknown"} (your store version — bump it when native code changes).
+
+Next:
+  1. Rebuild the app once (release build / store build): ${result.expo ? "npx expo run:android --variant release  (or EAS Build) — prebuild applies the FireOTA plugin" : `npx react-native run-android --mode release${result.runtime.ios ? "\n     iOS: cd ios && pod install" : ""}`}
+  2. Publish an update:  FIREOTA_URL=${result.serverUrl} FIREOTA_API_KEY=… npm run ota:publish -- --message "What changed"
+  3. Optional: show <UpdateScreen /> from '@fireota/react-native' in your settings.`);
+    if (result.results.some(([mark]) => mark === "!")) console.log("\nSteps marked ! need a manual change — see https://github.com/Sujay-Dynamisch/FireOTA#readme");
+    return;
+  }
   if (command === "whoami") {
     const me = await api("GET", "/me");
     if (jsonMode) {
@@ -312,7 +365,7 @@ Next:
     // Android + iOS built from the same commit form one update group (Expo-style).
     const extra =
       platform === "all"
-        ? { groupId: groupIdFrom(platforms.map((p) => sha256(readFileSync(files[p]))).join(":") + String(all.runtime ?? process.env.FIREOTA_RUNTIME)) }
+        ? { groupId: groupIdFrom(platforms.map((p) => `${sha256(readFileSync(files[p]))}@${runtimeFor(all, p)}`).join(":")) }
         : {};
     const results = [];
     for (const p of platforms) results.push(await publishOne(all, p, files[p], extra, privateKey));

package/lib/init.mjs

@@ -0,0 +1,334 @@
+/**
+ * `npx fireota init` — wires FireOTA into a React Native project in one step:
+ *   fireota.config.js   app ID, server URL, channel (no secrets; safe to commit)
+ *   index.js            wraps the root component with withFireOTA(App, config)
+ *   MainApplication     release builds load the latest verified OTA bundle (Android)
+ *   AppDelegate         release builds load the latest verified OTA bundle (iOS)
+ *   package.json        "ota:publish" script
+ *   .gitignore          update packages and the code signing private key
+ * Every step is idempotent and skipped when already done; nothing is overwritten.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { createInterface } from "node:readline/promises";
+
+import { findFile, isExpoProject, storeVersion } from "./project.mjs";
+
+const IMPORT_SDK = "dev.fireota.reactnative.FireOTA";
+
+/** Finds the ")" that closes the "(" at `open`. */
+function closingParen(text, open) {
+  let depth = 0;
+  for (let i = open; i < text.length; i += 1) {
+    if (text[i] === "(") depth += 1;
+    else if (text[i] === ")") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+function addKotlinImport(source) {
+  if (source.includes(`import ${IMPORT_SDK}`)) return source;
+  const imports = [...source.matchAll(/^import .+$/gm)];
+  const last = imports.at(-1);
+  if (!last) return source.replace(/^(package .+)$/m, `$1\n\nimport ${IMPORT_SDK}`);
+  const at = last.index + last[0].length;
+  return `${source.slice(0, at)}\nimport ${IMPORT_SDK}${source.slice(at)}`;
+}
+
+/** Returns the patched MainApplication source, or null when no known template matched. */
+function addHostOverride(source) {
+  const host = /object\s*:\s*DefaultReactNativeHost\(this\)\s*\{/.exec(source);
+  if (!host) return null;
+  const at = host.index + host[0].length;
+  const method =
+    "\n        // FireOTA: release builds load the latest verified OTA bundle.\n" +
+    "        override fun getJSBundleFile(): String? =\n" +
+    "          if (BuildConfig.DEBUG) super.getJSBundleFile()\n" +
+    "          else FireOTA.getJSBundleFile(applicationContext) ?: super.getJSBundleFile()\n";
+  return addKotlinImport(source.slice(0, at) + method + source.slice(at));
+}
+
+// Keep in sync with packages/react-native/plugin/patches.js (the Expo config plugin);
+// tests/sdk/expo-plugin.test.ts checks both produce the same output.
+export function patchMainApplication(source, isKotlin) {
+  if (source.includes("FireOTA.getJSBundleFile")) return { source, status: "already" };
+  if (isKotlin) {
+    // Expo SDK 50–55: ReactNativeHostWrapper(this, object : DefaultReactNativeHost(this) { … }), and the host
+    // factory of those SDKs takes no jsBundleFilePath — override getJSBundleFile() on the wrapped host.
+    // Expo SDK 56+ calls ExpoReactHostFactory.getDefaultReactHost(context = …, packageList = …), which accepts
+    // jsBundleFilePath like React Native's own factory, so it falls through to the branch below.
+    if (source.includes("ReactNativeHostWrapper")) {
+      const patched = addHostOverride(source);
+      if (patched) return { source: patched, status: "patched" };
+    }
+    // React Native 0.76+: getDefaultReactHost(context = …, packageList = …)
+    const call = source.indexOf("getDefaultReactHost(");
+    if (call !== -1) {
+      const open = call + "getDefaultReactHost".length;
+      const close = closingParen(source, open);
+      if (close !== -1) {
+        let head = source.slice(0, close).replace(/\s+$/, "");
+        if (!head.endsWith(",") && !head.endsWith("(")) head += ",";
+        const patched =
+          `${head}\n      // FireOTA: release builds load the latest verified OTA bundle (null = bundle in the APK).\n` +
+          `      jsBundleFilePath = if (BuildConfig.DEBUG) null else FireOTA.getJSBundleFile(applicationContext),\n    ` +
+          source.slice(close);
+        return { source: addKotlinImport(patched), status: "patched" };
+      }
+    }
+    // Older templates: object : DefaultReactNativeHost(this) { … }
+    const patched = addHostOverride(source);
+    return patched ? { source: patched, status: "patched" } : { source, status: "unknown" };
+  }
+  const host = /new\s+DefaultReactNativeHost\(this\)\s*\{/.exec(source);
+  if (!host) return { source, status: "unknown" };
+  const at = host.index + host[0].length;
+  const method =
+    "\n        // FireOTA: release builds load the latest verified OTA bundle.\n" +
+    "        @Override\n        protected String getJSBundleFile() {\n" +
+    "          if (BuildConfig.DEBUG) return super.getJSBundleFile();\n" +
+    "          String ota = FireOTA.getJSBundleFile(getApplicationContext());\n" +
+    "          return ota != null ? ota : super.getJSBundleFile();\n        }\n";
+  let patched = source.slice(0, at) + method + source.slice(at);
+  if (!patched.includes(`import ${IMPORT_SDK};`)) patched = patched.replace(/^(package .+;)$/m, `$1\n\nimport ${IMPORT_SDK};`);
+  return { source: patched, status: "patched" };
+}
+
+const SWIFT_HELPER = `
+
+/// FireOTA: the latest verified OTA bundle, or nil to use the one in the app binary.
+/// Looked up at runtime, so no bridging header is needed.
+private func fireOTABundleURL() -> URL? {
+  guard let fireOTA: AnyClass = NSClassFromString("FireOTA") else { return nil }
+  return (fireOTA as AnyObject).perform(NSSelectorFromString("bundleURL"))?.takeUnretainedValue() as? URL
+}
+`;
+
+export function patchAppDelegate(source, isSwift) {
+  if (source.includes("fireOTABundleURL") || source.includes("[FireOTA bundleURL]")) return { source, status: "already" };
+  if (isSwift) {
+    const target = 'Bundle.main.url(forResource: "main", withExtension: "jsbundle")';
+    if (!source.includes(target)) return { source, status: "unknown" };
+    return { source: source.replace(target, `fireOTABundleURL() ?? ${target}`) + SWIFT_HELPER, status: "patched" };
+  }
+  const target = '[[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"]';
+  if (!source.includes(target)) return { source, status: "unknown" };
+  let patched = source.replace(target, `[FireOTA bundleURL] ?: ${target}`);
+  patched = patched.replace(/^(#import .+)$/m, `$1\n#import <FireOTA.h>`);
+  return { source: patched, status: "patched" };
+}
+
+/** Wraps AppRegistry.registerComponent(name, () => App) with withFireOTA(App, fireotaConfig). */
+export function patchEntry(source, configImport) {
+  if (source.includes("withFireOTA")) return { source, status: "already" };
+  if (source.includes("FireOTA.configure")) return { source, status: "manual-configure" };
+  const re = /AppRegistry\.registerComponent\(\s*([^,]+?)\s*,\s*\(\)\s*=>\s*([A-Za-z_$][\w$]*)\s*\)/;
+  if (!re.test(source)) return { source, status: "unknown" };
+  let patched = source.replace(re, "AppRegistry.registerComponent($1, () => withFireOTA($2, fireotaConfig))");
+  const imports = [...patched.matchAll(/^import .+$/gm)];
+  const last = imports.at(-1);
+  const lines = `import { withFireOTA } from '@fireota/react-native';\nimport fireotaConfig from '${configImport}';`;
+  patched = last ? `${patched.slice(0, last.index + last[0].length)}\n${lines}${patched.slice(last.index + last[0].length)}` : `${lines}\n${patched}`;
+  return { source: patched, status: "patched" };
+}
+
+function addEntryImports(source, configImport) {
+  const lines = `import { withFireOTA } from '@fireota/react-native';\nimport fireotaConfig from '${configImport}';`;
+  const imports = [...source.matchAll(/^import .+$/gm)];
+  const last = imports.at(-1);
+  return last ? `${source.slice(0, last.index + last[0].length)}\n${lines}${source.slice(last.index + last[0].length)}` : `${lines}\n${source}`;
+}
+
+/** Expo (no router): registerRootComponent(App) -> registerRootComponent(withFireOTA(App, fireotaConfig)). */
+export function patchRegisterRootComponent(source, configImport) {
+  if (source.includes("withFireOTA")) return { source, status: "already" };
+  const re = /registerRootComponent\(\s*([A-Za-z_$][\w$]*)\s*\)/;
+  if (!re.test(source)) return { source, status: "unknown" };
+  const patched = source.replace(re, "registerRootComponent(withFireOTA($1, fireotaConfig))");
+  return { source: addEntryImports(patched, configImport), status: "patched" };
+}
+
+/** expo-router: wrap the root layout (app/_layout.tsx) — it is the root component of the app. */
+export function patchExpoRouterLayout(source, configImport) {
+  if (source.includes("withFireOTA")) return { source, status: "already" };
+  const named = /export\s+default\s+function\s+([A-Za-z_$][\w$]*)\s*\(/.exec(source);
+  if (named) {
+    const name = named[1];
+    const patched = `${source.replace(named[0], `function ${name}(`).replace(/\s*$/, "")}\n\nexport default withFireOTA(${name}, fireotaConfig);\n`;
+    return { source: addEntryImports(patched, configImport), status: "patched" };
+  }
+  const reexport = /export\s+default\s+([A-Za-z_$][\w$]*)\s*;?\s*$/m.exec(source);
+  if (reexport) {
+    const patched = source.replace(reexport[0], `export default withFireOTA(${reexport[1]}, fireotaConfig);`);
+    return { source: addEntryImports(patched, configImport), status: "patched" };
+  }
+  return { source, status: "unknown" };
+}
+
+/** Adds "@fireota/react-native" to expo.plugins in app.json. */
+export function addExpoPlugin(appJsonText) {
+  const json = JSON.parse(appJsonText);
+  const expo = json.expo ?? json;
+  const plugins = Array.isArray(expo.plugins) ? expo.plugins : [];
+  const has = plugins.some((p) => (Array.isArray(p) ? p[0] : p) === "@fireota/react-native");
+  if (has) return { source: appJsonText, status: "already" };
+  expo.plugins = [...plugins, "@fireota/react-native"];
+  return { source: `${JSON.stringify(json, null, 2)}\n`, status: "patched" };
+}
+
+function configFile({ appId, serverUrl, channel, certificate }) {
+  return `// FireOTA settings — created by \`npx fireota init\`. No secrets here; safe to commit.
+// runtimeVersion defaults to the app's store version (Android versionName / iOS
+// CFBundleShortVersionString): bump that version whenever native code changes.
+
+/** @type {import('@fireota/react-native').FireOTAConfig} */
+const fireotaConfig = {
+  appId: '${appId}',
+  serverUrl: '${serverUrl}',
+  channel: __DEV__ ? 'development' : '${channel}',
+  checkOnAppStart: true,
+  installMode: 'nextRestart', // normal updates apply on the next launch (with a "Restart" prompt)
+  mandatoryInstallMode: 'immediate',${certificate ? `\n  codeSigningCertificate: \`${certificate.trim()}\`,` : ""}
+};
+
+export default fireotaConfig;
+`;
+}
+
+async function ask(question) {
+  if (!process.stdin.isTTY) return "";
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+export async function runInit(flags, { api, log, fail }) {
+  if (!existsSync("package.json") || !existsSync(join("node_modules", "react-native"))) {
+    fail("Run this from your React Native project root (react-native must be installed).");
+  }
+  if (!existsSync(join("node_modules", "@fireota", "react-native"))) {
+    fail("Install the SDK first: npm install @fireota/react-native");
+  }
+  const dry = Boolean(flags["dry-run"]);
+  const results = [];
+  const write = (path, content, label) => {
+    if (!dry) writeFileSync(path, content);
+    results.push(["✓", label]);
+  };
+
+  // 1. Settings ------------------------------------------------------------
+  let serverUrl = String(flags["server-url"] ?? process.env.FIREOTA_URL ?? "").replace(/\/+$/, "");
+  let appId = String(flags.app ?? process.env.FIREOTA_APP_ID ?? "");
+  if (!appId && process.env.FIREOTA_API_KEY && serverUrl) {
+    const me = await api("GET", "/me");
+    if (me.apps.length === 1) appId = me.apps[0].id;
+    else if (me.apps.length > 1) {
+      log("Applications in this workspace:");
+      for (const app of me.apps) log(`  ${app.id}  ${app.name}`);
+    }
+  }
+  if (!serverUrl) serverUrl = (await ask("FireOTA URL (e.g. https://fireota.example.com): ")).replace(/\/+$/, "");
+  if (!appId) appId = await ask("App ID (Dashboard → Applications → your app): ");
+  if (!serverUrl || !appId) fail("Pass --server-url and --app (or set FIREOTA_URL and FIREOTA_APP_ID).");
+  const channel = String(flags.channel ?? "production");
+
+  const configPath = "fireota.config.js";
+  const certificatePath = join("fireota-keys", "fireota-public.pem");
+  const certificate = existsSync(certificatePath) ? readFileSync(certificatePath, "utf8") : null;
+  if (existsSync(configPath) && !flags.force) results.push(["–", `${configPath} exists (kept; --force to rewrite)`]);
+  else write(configPath, configFile({ appId, serverUrl, channel, certificate }), `${configPath} created${certificate ? " (with code signing certificate)" : ""}`);
+
+  // 2. JS entry ------------------------------------------------------------
+  const expo = isExpoProject();
+  const pkgMain = JSON.parse(readFileSync("package.json", "utf8")).main ?? "";
+  const entry = ["index.js", "index.ts", "index.tsx"].find((f) => existsSync(f));
+  if (expo && /expo-router\/entry/.test(pkgMain)) {
+    // expo-router: the root layout is the app's root component.
+    const layout = ["app", join("src", "app")]
+      .flatMap((dir) => ["_layout.tsx", "_layout.jsx", "_layout.ts", "_layout.js"].map((f) => join(dir, f)))
+      .find((f) => existsSync(f));
+    if (!layout) results.push(["!", "expo-router: no app/_layout.tsx found — wrap your root layout: export default withFireOTA(RootLayout, fireotaConfig)"]);
+    else {
+      const configImport = relative(dirname(layout), "fireota.config").split(sep).join("/");
+      const res = patchExpoRouterLayout(readFileSync(layout, "utf8"), configImport.startsWith(".") ? configImport : `./${configImport}`);
+      const rel = relative(".", layout);
+      if (res.status === "patched") write(layout, res.source, `${rel}: root layout wrapped with withFireOTA()`);
+      else if (res.status === "already") results.push(["–", `${rel} already uses withFireOTA`]);
+      else results.push(["!", `${rel}: wrap your root layout manually: export default withFireOTA(RootLayout, fireotaConfig)`]);
+    }
+  } else if (!entry) results.push(["!", "No index.js found — wrap your root component: withFireOTA(App, fireotaConfig)"]);
+  else if (expo && /registerRootComponent\(/.test(readFileSync(entry, "utf8"))) {
+    const res = patchRegisterRootComponent(readFileSync(entry, "utf8"), "./fireota.config");
+    if (res.status === "patched") write(entry, res.source, `${entry}: root component wrapped with withFireOTA()`);
+    else if (res.status === "already") results.push(["–", `${entry} already uses withFireOTA`]);
+    else results.push(["!", `${entry}: wrap your root component manually: registerRootComponent(withFireOTA(App, fireotaConfig))`]);
+  } else {
+    const res = patchEntry(readFileSync(entry, "utf8"), "./fireota.config");
+    if (res.status === "patched") write(entry, res.source, `${entry}: root component wrapped with withFireOTA()`);
+    else if (res.status === "already") results.push(["–", `${entry} already uses withFireOTA`]);
+    else if (res.status === "manual-configure") results.push(["–", `${entry} already calls FireOTA.configure() (left as is)`]);
+    else results.push(["!", `${entry}: wrap your root component manually: withFireOTA(App, fireotaConfig)`]);
+  }
+
+  // 3. Expo config plugin --------------------------------------------------
+  // `expo prebuild` / EAS Build regenerate android/ and ios/, so the plugin re-applies the native changes.
+  if (expo) {
+    if (existsSync("app.json")) {
+      const res = addExpoPlugin(readFileSync("app.json", "utf8"));
+      if (res.status === "patched") write("app.json", res.source, 'app.json: added the "@fireota/react-native" config plugin');
+      else results.push(["–", "app.json already uses the FireOTA config plugin"]);
+    } else {
+      results.push(["!", 'app.config.js/ts: add "@fireota/react-native" to plugins (dynamic configs are not edited)']);
+    }
+    const deps = JSON.parse(readFileSync("package.json", "utf8"));
+    if (deps.dependencies?.["expo-updates"] || deps.devDependencies?.["expo-updates"]) {
+      results.push(["!", "expo-updates is installed — remove it (npm uninstall expo-updates); it cannot run alongside FireOTA"]);
+    }
+  }
+
+  // 4. Android -------------------------------------------------------------
+  const mainApp = findFile(join("android", "app", "src", "main"), (n) => n === "MainApplication.kt" || n === "MainApplication.java");
+  if (!mainApp && expo) results.push(["–", "Android: no android/ folder yet — the config plugin wires it on expo prebuild / EAS Build"]);
+  else if (!mainApp) results.push(["!", "Android: MainApplication not found — see the Android setup docs"]);
+  else {
+    const res = patchMainApplication(readFileSync(mainApp, "utf8"), mainApp.endsWith(".kt"));
+    const rel = relative(".", mainApp);
+    if (res.status === "patched") write(mainApp, res.source, `${rel}: loads the OTA bundle in release builds`);
+    else if (res.status === "already") results.push(["–", `${rel} already loads FireOTA`]);
+    else results.push(["!", `${rel}: unknown template — add FireOTA.getJSBundleFile() as in the Android setup docs`]);
+  }
+
+  // 5. iOS -----------------------------------------------------------------
+  const delegate = findFile("ios", (n) => n === "AppDelegate.swift" || n === "AppDelegate.mm" || n === "AppDelegate.m", 3);
+  if (!delegate && expo) results.push(["–", "iOS: no ios/ folder yet — the config plugin wires it on expo prebuild / EAS Build"]);
+  else if (!delegate) results.push(["–", "iOS: no AppDelegate found (skipped)"]);
+  else {
+    const res = patchAppDelegate(readFileSync(delegate, "utf8"), delegate.endsWith(".swift"));
+    const rel = relative(".", delegate);
+    if (res.status === "patched") write(delegate, res.source, `${rel}: loads the OTA bundle in release builds (run pod install)`);
+    else if (res.status === "already") results.push(["–", `${rel} already loads FireOTA`]);
+    else results.push(["!", `${rel}: unknown template — return [FireOTA bundleURL] in bundleURL (see iOS setup docs)`]);
+  }
+
+  // 6. package.json script + .gitignore ------------------------------------
+  const pkg = JSON.parse(readFileSync("package.json", "utf8"));
+  pkg.scripts ??= {};
+  if (pkg.scripts["ota:publish"]) results.push(["–", 'package.json already has "ota:publish"']);
+  else {
+    pkg.scripts["ota:publish"] = "fireota publish --platform all";
+    write("package.json", `${JSON.stringify(pkg, null, 2)}\n`, 'package.json: added "ota:publish" script');
+  }
+  const ignore = existsSync(".gitignore") ? readFileSync(".gitignore", "utf8") : "";
+  const missing = ["*.fota", "fireota-keys/fireota-private.pem"].filter((line) => !ignore.split(/\r?\n/).includes(line));
+  if (missing.length === 0) results.push(["–", ".gitignore already covers FireOTA files"]);
+  else write(".gitignore", `${ignore.replace(/\s*$/, "\n")}\n# FireOTA\n${missing.join("\n")}\n`, `.gitignore: ignores ${missing.join(", ")}`);
+
+  const runtime = { android: storeVersion("android"), ios: storeVersion("ios") };
+  return { results, dry, appId, serverUrl, channel, runtime, expo };
+}

package/lib/project.mjs

@@ -0,0 +1,78 @@
+/** Reads facts about the React Native project the CLI runs in. */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/** android/app/build.gradle(.kts): versionName "1.3.3" / versionName = "1.3.3" */
+export function androidVersionName(root = ".") {
+  for (const file of ["android/app/build.gradle", "android/app/build.gradle.kts"]) {
+    const path = join(root, file);
+    if (!existsSync(path)) continue;
+    const match = /versionName\s*=?\s*["']([^"']+)["']/.exec(readFileSync(path, "utf8"));
+    if (match) return match[1];
+  }
+  return undefined;
+}
+
+/** ios/<App>.xcodeproj/project.pbxproj MARKETING_VERSION, or a literal CFBundleShortVersionString. */
+export function iosMarketingVersion(root = ".") {
+  const ios = join(root, "ios");
+  if (!existsSync(ios)) return undefined;
+  for (const entry of readdirSync(ios)) {
+    if (!entry.endsWith(".xcodeproj")) continue;
+    const pbx = join(ios, entry, "project.pbxproj");
+    if (!existsSync(pbx)) continue;
+    const match = /MARKETING_VERSION\s*=\s*"?([0-9][^";]*)"?;/.exec(readFileSync(pbx, "utf8"));
+    if (match) return match[1].trim();
+  }
+  for (const entry of readdirSync(ios)) {
+    const plist = join(ios, entry, "Info.plist");
+    if (!existsSync(plist)) continue;
+    const match = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<$]+)<\/string>/.exec(readFileSync(plist, "utf8"));
+    if (match) return match[1].trim();
+  }
+  return undefined;
+}
+
+/** True for Expo projects (the `expo` package is a dependency). */
+export function isExpoProject(root = ".") {
+  const path = join(root, "package.json");
+  if (!existsSync(path)) return false;
+  const pkg = JSON.parse(readFileSync(path, "utf8"));
+  return Boolean(pkg.dependencies?.expo ?? pkg.devDependencies?.expo);
+}
+
+/** The `expo` object of app.json, or null (no app.json, or a dynamic app.config.js / .ts). */
+export function readExpoAppJson(root = ".") {
+  const path = join(root, "app.json");
+  if (!existsSync(path)) return null;
+  const json = JSON.parse(readFileSync(path, "utf8"));
+  return json.expo ?? json;
+}
+
+/** Expo writes `expo.version` into versionName / CFBundleShortVersionString at prebuild. */
+export function expoVersion(root = ".") {
+  const version = readExpoAppJson(root)?.version;
+  return typeof version === "string" && version ? version : undefined;
+}
+
+/** The app's store version for a platform — FireOTA's default runtime version. */
+export function storeVersion(platform, root = ".") {
+  const native = platform === "ios" ? iosMarketingVersion(root) : androidVersionName(root);
+  // Expo projects without android/ or ios/ yet (Continuous Native Generation): use app.json.
+  return native ?? (isExpoProject(root) ? expoVersion(root) : undefined);
+}
+
+/** Recursively finds the first file matching a name test below a directory. */
+export function findFile(dir, test, depth = 6) {
+  if (!existsSync(dir) || depth < 0) return undefined;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === "build" || entry.name === "Pods" || entry.name.startsWith(".")) continue;
+    const path = join(dir, entry.name);
+    if (entry.isFile() && test(entry.name)) return path;
+    if (entry.isDirectory()) {
+      const found = findFile(path, test, depth - 1);
+      if (found) return found;
+    }
+  }
+  return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireota/cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Build FireOTA update packages and publish React Native OTA releases from a terminal or CI.",
   "license": "MIT",
   "type": "module",