react-native-custom-ota 0.0.0-stage → 1.0.0

package/bin/custom-ota.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const http = require("http");
+const https = require("https");
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (!command || command === "--help" || command === "help") {
+  console.log(`
+\x1b[35m⚡ REACT NATIVE CUSTOM OTA CLI\x1b[0m
+
+\x1b[33mCú pháp:\x1b[0m
+  npx custom-ota release -p <platform> -v <version> [-a <appId>] [-k <apiKey>] [-s <serverUrl>] [-m <notes>]
+
+\x1b[33mTham số:\x1b[0m
+  -a, --app-id     Mã định danh App (Mặc định: đọc từ app.json / com.otademoapp)
+  -p, --platform   Hệ điều hành: android, ios, all (Bắt buộc)
+  -v, --version    Phiên bản OTA: ví dụ 1.0.4 (Bắt buộc)
+  -k, --api-key    API Key phát hành (Push Key)
+  -s, --server     Địa chỉ OTA Server (Mặc định: http://localhost:4500)
+  -m, --notes      Ghi chú phát hành (Mặc định: "OTA update")
+  -t, --token      Admin secret token (Mặc định: demo-secret)
+  --min-native     Phiên bản native tối thiểu (Mặc định: 1.0.0)
+
+\x1b[33mVí dụ:\x1b[0m
+  npx custom-ota release -a com.company.shop -p ios -v 1.0.4 -m "Fix UI lỗi font"
+  npx custom-ota release -a com.company.rider -p android -v 1.0.4
+  npx custom-ota release -p all -v 1.0.4 -s http://192.168.1.10:4500
+`);
+  process.exit(0);
+}
+
+if (command !== "release") {
+  console.error(`\x1b[31mLệnh không hợp lệ: "${command}". Hãy dùng "release" hoặc "--help"\x1b[0m`);
+  process.exit(1);
+}
+
+function getArgValue(shortKey, longKey, defaultValue = null) {
+  const shortIndex = args.indexOf(shortKey);
+  if (shortIndex !== -1 && args[shortIndex + 1]) return args[shortIndex + 1];
+  const longIndex = args.indexOf(longKey);
+  if (longIndex !== -1 && args[longIndex + 1]) return args[longIndex + 1];
+  return defaultValue;
+}
+
+function detectAppId() {
+  const root = process.cwd();
+  const appJsonPath = path.join(root, "app.json");
+  if (fs.existsSync(appJsonPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(appJsonPath, "utf8"));
+      if (data.name) return String(data.name).toLowerCase();
+    } catch (e) {}
+  }
+
+  const pkgJsonPath = path.join(root, "package.json");
+  if (fs.existsSync(pkgJsonPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+      if (data.name) return String(data.name).toLowerCase();
+    } catch (e) {}
+  }
+
+  return "com.otademoapp";
+}
+
+const appId = getArgValue("-a", "--app-id", detectAppId());
+const platformArg = getArgValue("-p", "--platform");
+const version = getArgValue("-v", "--version");
+const serverUrl = getArgValue("-s", "--server", process.env.OTA_SERVER || "http://localhost:4500");
+const releaseNotes = getArgValue("-m", "--notes", "OTA update");
+const adminToken = getArgValue("-t", "--token", process.env.OTA_ADMIN_TOKEN || "demo-secret");
+const apiKey = getArgValue("-k", "--api-key", process.env.OTA_API_KEY || "");
+const minNativeVersion = getArgValue("--min-native", "--minNativeVersion", "1.0.0");
+
+if (!platformArg || !version) {
+  console.error("\x1b[31m❌ Thiếu tham số -p <platform> hoặc -v <version>!\x1b[0m");
+  process.exit(1);
+}
+
+const platforms = platformArg === "all" ? ["android", "ios"] : [platformArg.toLowerCase()];
+const root = process.cwd();
+
+async function buildAndPublish(p) {
+  console.log(`\n\x1b[36m==================================================\x1b[0m`);
+  console.log(`🚀 Đang đóng gói OTA [${p.toUpperCase()}] v${version}...`);
+  console.log(`\x1b[36m==================================================\x1b[0m`);
+
+  const outDir = path.join(root, ".ota_temp", p, version);
+  fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const bundleFile = p === "android" ? "index.android.bundle" : "main.jsbundle";
+  const bundlePath = path.join(outDir, bundleFile);
+  const assetsDir = path.join(outDir, "assets");
+
+  // 1. Metro Bundle
+  console.log(`📦 [1/3] Đang chạy Metro Bundle...`);
+  const bundleCmd = [
+    "npx react-native bundle",
+    `--platform ${p}`,
+    "--dev false",
+    "--minify true",
+    "--entry-file index.js",
+    `--bundle-output "${bundlePath}"`,
+    `--assets-dest "${assetsDir}"`
+  ].join(" ");
+
+  execSync(bundleCmd, { cwd: root, stdio: "inherit" });
+
+  const sha256 = crypto
+    .createHash("sha256")
+    .update(fs.readFileSync(bundlePath))
+    .digest("hex");
+
+  const manifest = {
+    appId,
+    platform: p,
+    otaVersion: version,
+    bundle: bundleFile,
+    sha256,
+    channel: "production",
+    minNativeVersion,
+    mandatory: false,
+    releaseNotes,
+    createdAt: new Date().toISOString()
+  };
+
+  fs.writeFileSync(path.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+
+  // 2. Package ZIP
+  console.log(`🗜️  [2/3] Đang nén file update.zip...`);
+  const zipPath = path.join(root, ".ota_temp", `${p}-${version}.zip`);
+
+  try {
+    const archiver = require("archiver");
+    await new Promise((resolve, reject) => {
+      const output = fs.createWriteStream(zipPath);
+      const archive = archiver("zip", { zlib: { level: 9 } });
+      output.on("close", resolve);
+      archive.on("error", reject);
+      archive.pipe(output);
+      archive.directory(outDir, false);
+      archive.finalize();
+    });
+  } catch (err) {
+    // Fallback sang công cụ nén zip có sẵn của hệ điều hành
+    if (process.platform === "win32") {
+      execSync(`powershell -command "Compress-Archive -Path '${outDir}/*' -DestinationPath '${zipPath}' -Force"`, { stdio: "ignore" });
+    } else {
+      execSync(`cd "${outDir}" && zip -r -q "${zipPath}" .`, { stdio: "ignore" });
+    }
+  }
+
+  // 3. Publish to OTA Server
+  console.log(`📡 [3/3] Đang upload lên server: ${serverUrl} (App: ${appId})...`);
+  const zipBuffer = fs.readFileSync(zipPath);
+  manifest.size = zipBuffer.length;
+
+  const url = new URL(`/admin/publish/${appId}/${p}/${version}`, serverUrl);
+  const payload = Buffer.from(
+    JSON.stringify({
+      manifest,
+      zipBase64: zipBuffer.toString("base64")
+    })
+  );
+
+  const client = url.protocol === "https:" ? https : http;
+
+  await new Promise((resolve, reject) => {
+    const req = client.request(
+      {
+        method: "POST",
+        hostname: url.hostname,
+        port: url.port || undefined,
+        path: url.pathname,
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": payload.length,
+          "X-OTA-ADMIN-TOKEN": adminToken,
+          ...(apiKey ? { "X-OTA-API-KEY": apiKey } : {})
+        }
+      },
+      (res) => {
+        let body = "";
+        res.on("data", chunk => { body += chunk; });
+        res.on("end", () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            console.log(`\x1b[32m✔ [${p.toUpperCase()}] Phát hành thành công v${version}!\x1b[0m`);
+            resolve();
+          } else {
+            reject(new Error(`Server response ${res.statusCode}: ${body}`));
+          }
+        });
+      }
+    );
+
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+
+  // Cleanup temp files
+  fs.rmSync(path.join(root, ".ota_temp"), { recursive: true, force: true });
+}
+
+(async () => {
+  for (const p of platforms) {
+    await buildAndPublish(p);
+  }
+  console.log("\n\x1b[32m🎉 TẤT CẢ PHIÊN BẢN ĐÃ PHÁT HÀNH THÀNH CÔNG!\x1b[0m\n");
+})();

package/ios/CustomOTABundleResolver.swift

@@ -0,0 +1,79 @@
+import Foundation
+
+@objc(CustomOTABundleResolver)
+public final class CustomOTABundleResolver: NSObject {
+
+    @objc public static func getOTADirectory() -> URL? {
+        FileManager.default.urls(
+            for: .documentDirectory,
+            in: .userDomainMask
+        ).first?.appendingPathComponent("ota")
+    }
+
+    /**
+     * Kiểm tra trạng thái pending trial theo chuẩn CodePush 2-stage boot:
+     * - Lần khởi động đầu tiên của bản mới: Cho phép nạp bundle mới và đánh dấu trial = true.
+     * - Nếu trial == true mà pending vẫn là true -> Nghĩa là lần trước app bị CRASH trước khi gọi markReady() -> ROLLBACK!
+     */
+    @objc public static func checkAndRollbackIfPending() {
+        guard let stateURL = stateURL(), FileManager.default.fileExists(atPath: stateURL.path) else { return }
+        do {
+            let data = try Data(contentsOf: stateURL)
+            guard var json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let pending = json["pending"] as? Bool, pending else { return }
+
+            guard let otaDir = getOTADirectory() else { return }
+            let currentDir = otaDir.appendingPathComponent("current")
+            let backupDir = otaDir.appendingPathComponent("backup")
+
+            let trial = json["trial"] as? Bool ?? false
+            if trial {
+                // Đã thử chạy một lần trước đó mà app bị crash/tắt trước khi markReady() -> ROLLBACK!
+                print("[CustomOTA] Detected crash on pending release! Rolling back to backup...")
+                try? FileManager.default.removeItem(at: currentDir)
+                if FileManager.default.fileExists(atPath: backupDir.path) {
+                    try? FileManager.default.moveItem(at: backupDir, to: currentDir)
+                }
+
+                // Cập nhật failedVersions và lùi version
+                let failedVer = json["currentVersion"] as? String ?? ""
+                var failedVersions = json["failedVersions"] as? [String] ?? []
+                if !failedVer.isEmpty && !failedVersions.contains(failedVer) {
+                    failedVersions.append(failedVer)
+                }
+                json["failedVersions"] = failedVersions
+
+                let prevVer = json["previousVersion"] as? String ?? "0.0.0"
+                json["currentVersion"] = prevVer
+                json["pending"] = false
+                json["trial"] = false
+                json["ready"] = true
+            } else {
+                // Lần khởi động đầu tiên: cho phép nạp bản mới và đánh dấu trial = true
+                json["trial"] = true
+            }
+
+            let updatedData = try JSONSerialization.data(withJSONObject: json, options: [.prettyPrinted])
+            try updatedData.write(to: stateURL)
+        } catch {
+            print("OTA Rollback error: \(error)")
+        }
+    }
+
+    @objc public static func currentBundleURL() -> URL? {
+        checkAndRollbackIfPending()
+
+        guard let otaDir = getOTADirectory() else { return nil }
+        let bundlePath = otaDir.appendingPathComponent("current").appendingPathComponent("main.jsbundle")
+
+        guard FileManager.default.fileExists(atPath: bundlePath.path) else {
+            return nil
+        }
+
+        return bundlePath
+    }
+
+    @objc public static func stateURL() -> URL? {
+        getOTADirectory()?.appendingPathComponent("state.json")
+    }
+}

package/ios/OTAUpdater.m

@@ -0,0 +1,19 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(OTAUpdater, NSObject)
+
+RCT_EXTERN_METHOD(unzip:(NSString *)zipPath
+                  targetDir:(NSString *)targetDir
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(markReady:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getCurrentVersion:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(restart:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/OTAUpdater.swift

@@ -0,0 +1,105 @@
+import Foundation
+import UIKit
+import React
+import SSZipArchive
+
+@objc(OTAUpdater)
+final class OTAUpdater: NSObject, RCTBridgeModule {
+
+    static func moduleName() -> String! {
+        return "OTAUpdater"
+    }
+
+    static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    @objc
+    func unzip(
+        _ zipPath: String,
+        targetDir: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let success = SSZipArchive.unzipFile(atPath: zipPath, toDestination: targetDir)
+        if success {
+            resolve(nil)
+        } else {
+            reject("OTA_UNZIP", "Failed to unzip archive at \(zipPath)", nil)
+        }
+    }
+
+    @objc
+    func markReady(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            guard let stateURL = CustomOTABundleResolver.stateURL() else {
+                resolve(nil)
+                return
+            }
+
+            if FileManager.default.fileExists(atPath: stateURL.path) {
+                var json = try JSONSerialization.jsonObject(
+                    with: Data(contentsOf: stateURL),
+                    options: []
+                ) as? [String: Any] ?? [:]
+
+                json["pending"] = false
+                json["ready"] = true
+                json["trial"] = false
+
+                let data = try JSONSerialization.data(
+                    withJSONObject: json,
+                    options: [.prettyPrinted]
+                )
+
+                try data.write(to: stateURL)
+
+                if let otaDir = CustomOTABundleResolver.getOTADirectory() {
+                    let backup = otaDir.appendingPathComponent("backup")
+                    try? FileManager.default.removeItem(at: backup)
+                }
+            }
+
+            resolve(nil)
+        } catch {
+            reject("OTA_READY", error.localizedDescription, error)
+        }
+    }
+
+    @objc
+    func getCurrentVersion(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            guard let stateURL = CustomOTABundleResolver.stateURL(),
+                  FileManager.default.fileExists(atPath: stateURL.path) else {
+                resolve("0.0.0")
+                return
+            }
+
+            let object = try JSONSerialization.jsonObject(
+                with: Data(contentsOf: stateURL),
+                options: []
+            ) as? [String: Any]
+
+            resolve(object?["currentVersion"] as? String ?? "0.0.0")
+        } catch {
+            reject("OTA_VERSION", error.localizedDescription, error)
+        }
+    }
+
+    @objc
+    func restart(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        resolve(nil)
+        DispatchQueue.main.async {
+            RCTTriggerReloadCommandListeners("OTA Update")
+        }
+    }
+}

package/lib/commonjs/hoc.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withCustomOTA = withCustomOTA;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const manager_1 = require("./manager");
+const types_1 = require("./types");
+function withCustomOTA(options) {
+    return function (WrappedComponent) {
+        return function CustomOTAWrapper(props) {
+            (0, react_1.useEffect)(() => {
+                // Tự động kiểm tra cập nhật khi app khởi động
+                if (options.checkFrequency !== types_1.CheckFrequency.MANUAL) {
+                    manager_1.CustomOTAManager.sync(options);
+                }
+                // Nếu bật kiểm tra khi App Resume từ background
+                if (options.checkFrequency === types_1.CheckFrequency.ON_APP_RESUME) {
+                    const subscription = react_native_1.AppState.addEventListener("change", (nextAppState) => {
+                        if (nextAppState === "active") {
+                            manager_1.CustomOTAManager.sync(options);
+                        }
+                    });
+                    return () => {
+                        subscription.remove();
+                    };
+                }
+            }, []);
+            return react_1.default.createElement(WrappedComponent, { ...props });
+        };
+    };
+}

package/lib/commonjs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const manager_1 = require("./manager");
+const hoc_1 = require("./hoc");
+__exportStar(require("./types"), exports);
+__exportStar(require("./manager"), exports);
+__exportStar(require("./hoc"), exports);
+__exportStar(require("./storage"), exports);
+const CustomOTA = {
+    sync: manager_1.CustomOTAManager.sync.bind(manager_1.CustomOTAManager),
+    checkForUpdate: manager_1.CustomOTAManager.checkForUpdate.bind(manager_1.CustomOTAManager),
+    downloadAndInstall: manager_1.CustomOTAManager.downloadAndInstall.bind(manager_1.CustomOTAManager),
+    restartApp: manager_1.CustomOTAManager.restartApp.bind(manager_1.CustomOTAManager),
+    getUpdateMetadata: manager_1.CustomOTAManager.getUpdateMetadata.bind(manager_1.CustomOTAManager),
+    markReady: manager_1.CustomOTAManager.markReady.bind(manager_1.CustomOTAManager),
+    wrap: hoc_1.withCustomOTA
+};
+exports.default = CustomOTA;