@fireota/cli 0.2.0 → 0.3.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

@@ -14,13 +14,18 @@ import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 
 import { detectCi } from "../lib/ci.mjs";
+import { runInit } from "../lib/init.mjs";
 import { packDirectory } from "../lib/package.mjs";
+import { 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 +42,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).
@@ -182,6 +189,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 +205,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 +247,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 +274,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): 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 +347,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,238 @@
+/**
+ * `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 { join, relative } from "node:path";
+import { createInterface } from "node:readline/promises";
+
+import { androidVersionName, findFile, iosMarketingVersion } 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. */
+export function patchMainApplication(source, isKotlin) {
+  if (source.includes("FireOTA.getJSBundleFile")) return { source, status: "already" };
+  if (isKotlin) {
+    // 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 host = /object\s*:\s*DefaultReactNativeHost\(this\)\s*\{/.exec(source);
+    if (host) {
+      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 { source: addKotlinImport(source.slice(0, at) + method + source.slice(at)), status: "patched" };
+    }
+    return { 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 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 entry = ["index.js", "index.ts", "index.tsx"].find((f) => existsSync(f));
+  if (!entry) results.push(["!", "No index.js found — wrap your root component: 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. Android -------------------------------------------------------------
+  const mainApp = findFile(join("android", "app", "src", "main"), (n) => n === "MainApplication.kt" || n === "MainApplication.java");
+  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`]);
+  }
+
+  // 4. iOS -----------------------------------------------------------------
+  const delegate = findFile("ios", (n) => n === "AppDelegate.swift" || n === "AppDelegate.mm" || n === "AppDelegate.m", 3);
+  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)`]);
+  }
+
+  // 5. 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: androidVersionName(), ios: iosMarketingVersion() };
+  return { results, dry, appId, serverUrl, channel, runtime };
+}

package/lib/project.mjs

@@ -0,0 +1,54 @@
+/** 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;
+}
+
+/** The app's store version for a platform — FireOTA's default runtime version. */
+export function storeVersion(platform, root = ".") {
+  return platform === "ios" ? iosMarketingVersion(root) : androidVersionName(root);
+}
+
+/** 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.3.0",
   "description": "Build FireOTA update packages and publish React Native OTA releases from a terminal or CI.",
   "license": "MIT",
   "type": "module",