@appsonair.ir/react-native 1.0.0

package/lib/sync.js

@@ -0,0 +1,728 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMessages = void 0;
+exports.getProgressState = getProgressState;
+exports.subscribeProgress = subscribeProgress;
+exports.hideProgress = hideProgress;
+exports.getMessageForStatus = getMessageForStatus;
+exports.getModalTitle = getModalTitle;
+exports.delay = delay;
+exports.getStoredBundleMeta = getStoredBundleMeta;
+exports.setStoredBundleMeta = setStoredBundleMeta;
+exports.getClientUniqueId = getClientUniqueId;
+exports.clearStoredBundleMeta = clearStoredBundleMeta;
+exports.markRestartPending = markRestartPending;
+exports.shouldSkipSyncAfterRestart = shouldSkipSyncAfterRestart;
+exports.getDeviceAbi = getDeviceAbi;
+exports.checkForUpdate = checkForUpdate;
+exports.getBundleReleaseDir = getBundleReleaseDir;
+exports.getBundleFilePath = getBundleFilePath;
+exports.getApkFilePath = getApkFilePath;
+exports.downloadBundle = downloadBundle;
+exports.verifyBundleHash = verifyBundleHash;
+exports.isSyncInProgress = isSyncInProgress;
+exports.restartApp = restartApp;
+exports.installApk = installApk;
+exports.resumePendingApkInstall = resumePendingApkInstall;
+exports.sync = sync;
+exports.getInstalledBundlePath = getInstalledBundlePath;
+exports.clearUpdate = clearUpdate;
+exports.notifyAppReady = notifyAppReady;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const react_native_1 = require("react-native");
+const react_native_device_info_1 = __importDefault(require("react-native-device-info"));
+const config_1 = require("./config");
+const zipExtract_1 = require("./zipExtract");
+const types_1 = require("./types");
+const initialProgressState = {
+    visible: false,
+    status: types_1.SyncStatus.UP_TO_DATE,
+    progress: 0,
+    message: '',
+};
+let progressState = { ...initialProgressState };
+const progressListeners = new Set();
+function getProgressState() {
+    return progressState;
+}
+function subscribeProgress(listener) {
+    progressListeners.add(listener);
+    return () => progressListeners.delete(listener);
+}
+function setProgressState(partial) {
+    progressState = { ...progressState, ...partial };
+    progressListeners.forEach((listener) => listener(progressState));
+}
+function hideProgress() {
+    progressState = { ...initialProgressState };
+    progressListeners.forEach((listener) => listener(progressState));
+}
+function shouldShowModalForStatus(status) {
+    return (status === types_1.SyncStatus.DOWNLOADING ||
+        status === types_1.SyncStatus.RESTARTING ||
+        status === types_1.SyncStatus.ERROR);
+}
+exports.defaultMessages = {
+    title: 'به\u200cروزرسانی برنامه',
+    checking: 'در حال بررسی به\u200cروزرسانی...',
+    downloading: 'در حال دانلود به\u200cروزرسانی...',
+    installing: 'در حال نصب به\u200cروزرسانی...',
+    restarting: 'در حال راه\u200cاندازی مجدد...',
+    error: 'خطا در به\u200cروزرسانی',
+    upToDate: 'برنامه به\u200cروز است',
+};
+function getMessageForStatus(status, messages = {}) {
+    const m = { ...exports.defaultMessages, ...messages };
+    switch (status) {
+        case types_1.SyncStatus.CHECKING:
+            return m.checking;
+        case types_1.SyncStatus.DOWNLOADING:
+            return m.downloading;
+        case types_1.SyncStatus.INSTALLING:
+            return m.installing;
+        case types_1.SyncStatus.RESTARTING:
+            return m.restarting;
+        case types_1.SyncStatus.ERROR:
+            return m.error;
+        default:
+            return m.upToDate;
+    }
+}
+function getModalTitle(messages = {}) {
+    const m = { ...exports.defaultMessages, ...messages };
+    return m.title;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function showProgress(status, progress, message, extra) {
+    if (progressState.visible &&
+        progressState.status === status &&
+        status === types_1.SyncStatus.DOWNLOADING) {
+        setProgressState({
+            progress,
+            message,
+            error: undefined,
+            ...extra,
+        });
+        return;
+    }
+    setProgressState({
+        visible: true,
+        status,
+        progress,
+        message,
+        error: undefined,
+        ...extra,
+    });
+}
+const STORAGE_KEY = '@appsonair.ir/bundle-meta';
+const CLIENT_ID_KEY = '@appsonair.ir/client-id';
+const NATIVE_VERSION_KEY = '@appsonair.ir/native-version';
+const NATIVE_BUILD_KEY = '@appsonair.ir/native-build';
+const RESTART_COOLDOWN_KEY = '@appsonair.ir/last-restart';
+const RESTART_COOLDOWN_MS = 15000;
+async function getStoredBundleMeta() {
+    const raw = await async_storage_1.default.getItem(STORAGE_KEY);
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function setStoredBundleMeta(meta) {
+    await async_storage_1.default.setItem(STORAGE_KEY, JSON.stringify(meta));
+}
+async function getClientUniqueId() {
+    let id = await async_storage_1.default.getItem(CLIENT_ID_KEY);
+    if (!id) {
+        id = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        await async_storage_1.default.setItem(CLIENT_ID_KEY, id);
+    }
+    return id;
+}
+async function clearStoredBundleMeta() {
+    await async_storage_1.default.removeItem(STORAGE_KEY);
+}
+async function markRestartPending() {
+    await async_storage_1.default.setItem(RESTART_COOLDOWN_KEY, String(Date.now()));
+}
+async function shouldSkipSyncAfterRestart() {
+    const raw = await async_storage_1.default.getItem(RESTART_COOLDOWN_KEY);
+    if (!raw)
+        return false;
+    const elapsed = Date.now() - parseInt(raw, 10);
+    if (elapsed >= RESTART_COOLDOWN_MS) {
+        await async_storage_1.default.removeItem(RESTART_COOLDOWN_KEY);
+        return false;
+    }
+    return elapsed < 3000;
+}
+/** Drop stale JS bundle after native version/build upgrade so OTA can resume. */
+async function clearStaleBundleAfterNativeUpgrade() {
+    const currentVersion = react_native_device_info_1.default.getVersion();
+    const currentBuild = react_native_1.Platform.OS === 'android' ? react_native_device_info_1.default.getBuildNumber() : undefined;
+    const [storedVersion, storedBuild, meta] = await Promise.all([
+        async_storage_1.default.getItem(NATIVE_VERSION_KEY),
+        react_native_1.Platform.OS === 'android'
+            ? async_storage_1.default.getItem(NATIVE_BUILD_KEY)
+            : Promise.resolve(null),
+        getStoredBundleMeta(),
+    ]);
+    const versionChanged = storedVersion != null && storedVersion !== currentVersion;
+    const buildChanged = react_native_1.Platform.OS === 'android' &&
+        storedBuild != null &&
+        currentBuild != null &&
+        storedBuild !== currentBuild;
+    const firstRunWithStaleBundle = storedVersion == null && meta != null;
+    if (versionChanged || buildChanged || firstRunWithStaleBundle) {
+        console.log(`[OTA] Native version changed (${storedVersion ?? 'unknown'} → ${currentVersion}` +
+            (buildChanged ? `, build ${storedBuild} → ${currentBuild}` : '') +
+            '); clearing stale JS bundle.');
+        await clearUpdate();
+    }
+    await async_storage_1.default.setItem(NATIVE_VERSION_KEY, currentVersion);
+    if (react_native_1.Platform.OS === 'android' && currentBuild != null) {
+        await async_storage_1.default.setItem(NATIVE_BUILD_KEY, currentBuild);
+    }
+}
+async function getDeviceAbi() {
+    if (react_native_1.Platform.OS !== 'android')
+        return undefined;
+    if (OTAUpdaterNative?.getDeviceAbi) {
+        try {
+            const abi = await OTAUpdaterNative.getDeviceAbi();
+            return typeof abi === 'string' ? abi : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+async function checkForUpdate(serverUrl, deploymentKey, appVersion, label, packageHash, clientUniqueId, buildNumber, deviceAbi) {
+    const baseUrl = serverUrl.replace(/\/$/, '');
+    const response = await fetch(`${baseUrl}/api/update-check`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Deployment-Key': deploymentKey,
+        },
+        body: JSON.stringify({
+            appVersion,
+            label,
+            packageHash,
+            clientUniqueId,
+            buildNumber,
+            deviceAbi,
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Update check failed (${response.status}): ${text}`);
+    }
+    return response.json();
+}
+function getBundleReleaseDir(label) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const dirs = ReactNativeBlobUtil.fs.dirs;
+    return `${dirs.DocumentDir}/ota-updates/${label}`;
+}
+function getLegacyBundleFilePath(label) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    return `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota-updates/${label}.bundle`;
+}
+function getBundleFilePath(label) {
+    const bundleName = react_native_1.Platform.OS === 'ios' ? 'main.jsbundle' : 'index.android.bundle';
+    return `${getBundleReleaseDir(label)}/${bundleName}`;
+}
+function getBundleZipPath(label) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const dirs = ReactNativeBlobUtil.fs.dirs;
+    return `${dirs.DocumentDir}/ota-updates/${label}.zip`;
+}
+async function removePathRecursive(path) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const exists = await ReactNativeBlobUtil.fs.exists(path);
+    if (!exists) {
+        return;
+    }
+    try {
+        const stat = await ReactNativeBlobUtil.fs.stat(path);
+        if (stat.type === 'directory') {
+            const entries = await ReactNativeBlobUtil.fs.ls(path);
+            for (const entry of entries) {
+                await removePathRecursive(`${path}/${entry}`);
+            }
+        }
+    }
+    catch {
+        // Fall through to unlink.
+    }
+    await ReactNativeBlobUtil.fs.unlink(path);
+}
+async function isZipArchive(filePath) {
+    if (filePath.endsWith('.zip')) {
+        return true;
+    }
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    if (typeof ReactNativeBlobUtil.fs.slice !== 'function') {
+        return false;
+    }
+    const prefixPath = `${filePath}.magic`;
+    try {
+        await ReactNativeBlobUtil.fs.slice(filePath, prefixPath, 0, 4);
+        const b64 = await ReactNativeBlobUtil.fs.readFile(prefixPath, 'base64');
+        await ReactNativeBlobUtil.fs.unlink(prefixPath);
+        const bytes = globalThis.atob
+            ? globalThis.atob(b64)
+            : Buffer.from(b64, 'base64').toString('binary');
+        return bytes.charCodeAt(0) === 0x50 && bytes.charCodeAt(1) === 0x4b;
+    }
+    catch {
+        try {
+            const prefixExists = await ReactNativeBlobUtil.fs.exists(prefixPath);
+            if (prefixExists) {
+                await ReactNativeBlobUtil.fs.unlink(prefixPath);
+            }
+        }
+        catch {
+            // Ignore cleanup errors.
+        }
+        return false;
+    }
+}
+async function shouldExtractZipPackage(downloadedPath, packageFormat) {
+    if (packageFormat === 'zip') {
+        return true;
+    }
+    return isZipArchive(downloadedPath);
+}
+async function resolveBundlePathInDir(releaseDir) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const candidates = react_native_1.Platform.OS === 'ios'
+        ? ['main.jsbundle', 'index.ios.bundle']
+        : ['index.android.bundle'];
+    for (const name of candidates) {
+        const path = `${releaseDir}/${name}`;
+        if (await ReactNativeBlobUtil.fs.exists(path)) {
+            return path;
+        }
+    }
+    try {
+        const entries = await ReactNativeBlobUtil.fs.ls(releaseDir);
+        for (const entry of entries) {
+            const entryPath = `${releaseDir}/${entry}`;
+            const entryStat = await ReactNativeBlobUtil.fs.stat(entryPath);
+            if (entryStat.type !== 'directory') {
+                continue;
+            }
+            for (const name of candidates) {
+                const path = `${entryPath}/${name}`;
+                if (await ReactNativeBlobUtil.fs.exists(path)) {
+                    return path;
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore listing errors and fall through.
+    }
+    throw new Error(`No JS bundle found in ${releaseDir}`);
+}
+async function extractBundleUpdate(label, zipPath) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const releaseDir = getBundleReleaseDir(label);
+    await removePathRecursive(releaseDir);
+    await ReactNativeBlobUtil.fs.mkdir(releaseDir);
+    await (0, zipExtract_1.extractZipToDirectory)(zipPath, releaseDir);
+    const zipExists = await ReactNativeBlobUtil.fs.exists(zipPath);
+    if (zipExists) {
+        await ReactNativeBlobUtil.fs.unlink(zipPath);
+    }
+    return resolveBundlePathInDir(releaseDir);
+}
+function getApkFilePath(label) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const dirs = ReactNativeBlobUtil.fs.dirs;
+    return `${dirs.DocumentDir}/ota-updates/${label}.apk`;
+}
+function getBundleDirectory() {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    return `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota-updates`;
+}
+async function ensureBundleDirectory() {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const dir = getBundleDirectory();
+    const exists = await ReactNativeBlobUtil.fs.exists(dir);
+    if (!exists) {
+        await ReactNativeBlobUtil.fs.mkdir(dir);
+    }
+}
+async function resolveDownloadSize(downloadUrl, deploymentKey, expectedSize, deviceAbi) {
+    if (expectedSize && expectedSize > 0) {
+        return expectedSize;
+    }
+    try {
+        const headers = {
+            'X-Deployment-Key': deploymentKey,
+        };
+        if (deviceAbi) {
+            headers['X-Device-Abi'] = deviceAbi;
+        }
+        const response = await fetch(downloadUrl, {
+            method: 'HEAD',
+            headers,
+        });
+        if (!response.ok) {
+            return expectedSize ?? 0;
+        }
+        const contentLength = response.headers.get('content-length');
+        if (contentLength) {
+            const parsed = parseInt(contentLength, 10);
+            if (parsed > 0)
+                return parsed;
+        }
+        const fallbackLength = response.headers.get('x-content-length');
+        if (fallbackLength) {
+            const parsed = parseInt(fallbackLength, 10);
+            if (parsed > 0)
+                return parsed;
+        }
+    }
+    catch {
+        // HEAD may be blocked by some proxies; fall back to update-check size.
+    }
+    return expectedSize ?? 0;
+}
+async function downloadBundle(downloadUrl, deploymentKey, label, expectedSize, onProgress, extension = 'bundle', deviceAbi, packageFormat = 'bundle', expectedHash) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const isZipBundle = extension === 'bundle' && packageFormat === 'zip';
+    const destPath = isZipBundle
+        ? getBundleZipPath(label)
+        : extension === 'apk'
+            ? getApkFilePath(label)
+            : getLegacyBundleFilePath(label);
+    const totalBytes = await resolveDownloadSize(downloadUrl, deploymentKey, expectedSize, deviceAbi);
+    await ensureBundleDirectory();
+    if (isZipBundle) {
+        await removePathRecursive(getBundleReleaseDir(label));
+    }
+    const destExists = await ReactNativeBlobUtil.fs.exists(destPath);
+    if (destExists) {
+        await ReactNativeBlobUtil.fs.unlink(destPath);
+    }
+    const task = ReactNativeBlobUtil.config({
+        path: destPath,
+        fileCache: false,
+        overwrite: true,
+    }).fetch('GET', downloadUrl, {
+        'X-Deployment-Key': deploymentKey,
+        ...(deviceAbi ? { 'X-Device-Abi': deviceAbi } : {}),
+    });
+    const reportDownloadProgress = (received, total) => {
+        if (!onProgress)
+            return;
+        const resolvedTotal = total > 0 ? total : totalBytes;
+        if (resolvedTotal <= 0)
+            return;
+        onProgress(Math.min(Math.max(received / resolvedTotal, 0), 0.99));
+    };
+    let pollTimer = null;
+    if (onProgress && totalBytes > 0) {
+        pollTimer = setInterval(async () => {
+            try {
+                const exists = await ReactNativeBlobUtil.fs.exists(destPath);
+                if (!exists)
+                    return;
+                const stat = await ReactNativeBlobUtil.fs.stat(destPath);
+                reportDownloadProgress(stat.size, totalBytes);
+            }
+            catch {
+                // Ignore polling errors while the file is being written.
+            }
+        }, 150);
+    }
+    if (onProgress) {
+        task.progress({ interval: 100, count: 10 }, (received, total) => {
+            reportDownloadProgress(received, total);
+        });
+    }
+    try {
+        const response = await task;
+        if (onProgress) {
+            onProgress(1);
+        }
+        const downloadedPath = String(response.path()).replace(/^file:\/\//, '');
+        if (downloadedPath !== destPath) {
+            await ReactNativeBlobUtil.fs.cp(downloadedPath, destPath);
+        }
+        const stat = await ReactNativeBlobUtil.fs.stat(destPath);
+        const minSize = extension === 'apk' ? 1024 * 100 : 1024;
+        if (!stat || stat.size < minSize) {
+            throw new Error(`Downloaded file is too small (${stat?.size ?? 0} bytes)`);
+        }
+        if (expectedHash) {
+            const valid = await verifyBundleHash(destPath, expectedHash);
+            if (!valid) {
+                throw new Error('Package hash verification failed');
+            }
+        }
+        if (extension === 'bundle' && (await shouldExtractZipPackage(destPath, packageFormat))) {
+            return extractBundleUpdate(label, destPath);
+        }
+        return destPath;
+    }
+    finally {
+        if (pollTimer) {
+            clearInterval(pollTimer);
+        }
+    }
+}
+async function verifyBundleHash(filePath, expectedHash) {
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const hash = await ReactNativeBlobUtil.fs.hash(filePath, 'sha256');
+    return hash.toLowerCase() === expectedHash.toLowerCase();
+}
+const { OTAUpdaterNative } = react_native_1.NativeModules;
+let activeSync = null;
+function isSyncInProgress() {
+    return activeSync !== null;
+}
+function shouldShowUI(options) {
+    const config = (0, config_1.getConfig)();
+    return options.showProgressUI ?? config?.showProgressUI ?? false;
+}
+function reportProgress(showUI, messages, onProgress, status, progress = 0, extra) {
+    onProgress?.(status, progress);
+    if (!showUI)
+        return;
+    // Silent phases — never show modal for check / install / up-to-date.
+    if (status === types_1.SyncStatus.CHECKING ||
+        status === types_1.SyncStatus.UP_TO_DATE ||
+        status === types_1.SyncStatus.UPDATE_IGNORED ||
+        status === types_1.SyncStatus.INSTALLING) {
+        return;
+    }
+    if (status === types_1.SyncStatus.ERROR) {
+        showProgress(status, progress, extra?.error ?? getMessageForStatus(status, messages), {
+            error: extra?.error,
+            ...extra,
+        });
+        return;
+    }
+    if (shouldShowModalForStatus(status)) {
+        showProgress(status, progress, getMessageForStatus(status, messages), extra);
+    }
+}
+async function restartApp() {
+    if (OTAUpdaterNative?.restartApp) {
+        await OTAUpdaterNative.restartApp();
+        return;
+    }
+    try {
+        const RNRestart = require('react-native-restart').default;
+        RNRestart.restart();
+    }
+    catch {
+        throw new Error('Cannot restart app. Install react-native-restart or link OTAUpdaterNative module.');
+    }
+}
+async function installApk(apkPath) {
+    if (!OTAUpdaterNative?.installApk) {
+        throw new Error('APK install is not available. Rebuild the Android app with OTAUpdaterNative linked.');
+    }
+    const result = await OTAUpdaterNative.installApk(apkPath);
+    return result === 'permission_required' ? 'permission_required' : 'started';
+}
+async function resumePendingApkInstall() {
+    if (OTAUpdaterNative?.retryPendingApkInstall) {
+        await OTAUpdaterNative.retryPendingApkInstall();
+    }
+}
+async function sync(options = {}, onProgress, messages) {
+    if (activeSync) {
+        return activeSync;
+    }
+    activeSync = performSync(options, onProgress, messages).finally(() => {
+        activeSync = null;
+    });
+    return activeSync;
+}
+async function performSync(options = {}, onProgress, messages) {
+    const config = (0, config_1.getConfig)();
+    if (!config) {
+        throw new Error('OTAUpdater.configure() must be called first');
+    }
+    if (await shouldSkipSyncAfterRestart()) {
+        return { status: types_1.SyncStatus.UP_TO_DATE };
+    }
+    const showUI = shouldShowUI(options);
+    try {
+        onProgress?.(types_1.SyncStatus.CHECKING, 0);
+        await clearStaleBundleAfterNativeUpgrade();
+        const meta = await getStoredBundleMeta();
+        const clientUniqueId = await getClientUniqueId();
+        const enableApkUpdates = options.enableApkUpdates ??
+            config.enableApkUpdates ??
+            react_native_1.Platform.OS === 'android';
+        const buildNumber = enableApkUpdates && react_native_1.Platform.OS === 'android'
+            ? react_native_device_info_1.default.getBuildNumber()
+            : undefined;
+        const deviceAbi = enableApkUpdates && react_native_1.Platform.OS === 'android'
+            ? await getDeviceAbi()
+            : undefined;
+        const update = await checkForUpdate(config.serverUrl, config.deploymentKey, react_native_device_info_1.default.getVersion(), meta?.label, meta?.packageHash, clientUniqueId, buildNumber, deviceAbi);
+        if (!update.updateAvailable || !update.downloadUrl || !update.label || !update.packageHash) {
+            if (update.reason === 'NATIVE_VERSION_MISMATCH') {
+                console.warn(`[OTA] Native version mismatch: device=${update.clientAppVersion ?? 'unknown'}, ` +
+                    `release targets=${update.targetAppVersion ?? update.appVersion ?? 'unknown'}. ` +
+                    'Redeploy with the correct --app-version (must match versionName / MARKETING_VERSION).');
+            }
+            if (showUI)
+                hideProgress();
+            onProgress?.(types_1.SyncStatus.UP_TO_DATE, 1);
+            return { status: types_1.SyncStatus.UP_TO_DATE };
+        }
+        if (update.updateType === 'apk') {
+            return performApkSync(update, showUI, messages, onProgress);
+        }
+        reportProgress(showUI, messages, onProgress, types_1.SyncStatus.DOWNLOADING, 0, {
+            label: update.label,
+            description: update.description,
+        });
+        const bundlePath = await downloadBundle(update.downloadUrl, config.deploymentKey, update.label, update.size, (p) => reportProgress(showUI, messages, onProgress, types_1.SyncStatus.DOWNLOADING, p, {
+            label: update.label,
+            description: update.description,
+        }), 'bundle', undefined, update.packageFormat ?? 'bundle', update.packageHash);
+        onProgress?.(types_1.SyncStatus.INSTALLING, 1);
+        const ReactNativeBlobUtil = require('react-native-blob-util').default;
+        const bundleExists = await ReactNativeBlobUtil.fs.exists(bundlePath);
+        if (!bundleExists) {
+            throw new Error(`Bundle file missing before install: ${bundlePath}`);
+        }
+        if (OTAUpdaterNative?.setBundlePath) {
+            await OTAUpdaterNative.setBundlePath(bundlePath);
+        }
+        await setStoredBundleMeta({
+            label: update.label,
+            packageHash: update.packageHash,
+            installedAt: new Date().toISOString(),
+        });
+        const installMode = options.installMode ?? config.installMode ?? 'immediate';
+        const shouldRestartNow = installMode === 'immediate' || update.isMandatory === true;
+        if (shouldRestartNow) {
+            reportProgress(showUI, messages, onProgress, types_1.SyncStatus.RESTARTING, 1, {
+                label: update.label,
+                description: update.description,
+            });
+            await markRestartPending();
+            await delay(300);
+            await restartApp();
+            return {
+                status: types_1.SyncStatus.UPDATE_INSTALLED,
+                label: update.label,
+                description: update.description,
+            };
+        }
+        if (showUI)
+            hideProgress();
+        return {
+            status: types_1.SyncStatus.UPDATE_INSTALLED,
+            label: update.label,
+            description: update.description,
+        };
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        reportProgress(showUI, messages, onProgress, types_1.SyncStatus.ERROR, 0, {
+            error: err.message,
+        });
+        return {
+            status: types_1.SyncStatus.ERROR,
+            error: err,
+        };
+    }
+}
+async function performApkSync(update, showUI, messages, onProgress) {
+    if (!update.downloadUrl || !update.label || !update.packageHash) {
+        return { status: types_1.SyncStatus.UP_TO_DATE };
+    }
+    try {
+        reportProgress(showUI, messages, onProgress, types_1.SyncStatus.DOWNLOADING, 0, {
+            label: update.label,
+            description: update.description,
+        });
+        const apkPath = await downloadBundle(update.downloadUrl, (0, config_1.getConfig)().deploymentKey, update.label, update.size, (p) => reportProgress(showUI, messages, onProgress, types_1.SyncStatus.DOWNLOADING, p, {
+            label: update.label,
+            description: update.description,
+        }), 'apk', update.deviceAbi);
+        onProgress?.(types_1.SyncStatus.INSTALLING, 1);
+        const valid = await verifyBundleHash(apkPath, update.packageHash);
+        if (!valid) {
+            throw new Error('APK hash verification failed');
+        }
+        // Drop the OTA JS path before opening the installer so the new APK does not
+        // keep loading the previous bundle on first launch after install.
+        await clearUpdate();
+        const installResult = await installApk(apkPath);
+        if (installResult === 'permission_required') {
+            reportProgress(showUI, messages, onProgress, types_1.SyncStatus.INSTALLING, 1, {
+                label: update.label,
+                description: update.description,
+            });
+            return {
+                status: types_1.SyncStatus.APK_INSTALL_PENDING,
+                label: update.label,
+                description: update.description,
+            };
+        }
+        if (showUI)
+            hideProgress();
+        onProgress?.(types_1.SyncStatus.APK_INSTALL_PENDING, 1);
+        return {
+            status: types_1.SyncStatus.APK_INSTALL_PENDING,
+            label: update.label,
+            description: update.description,
+        };
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        reportProgress(showUI, messages, onProgress, types_1.SyncStatus.ERROR, 0, {
+            error: err.message,
+        });
+        return {
+            status: types_1.SyncStatus.ERROR,
+            error: err,
+        };
+    }
+}
+async function getInstalledBundlePath() {
+    const meta = await getStoredBundleMeta();
+    if (!meta)
+        return null;
+    const ReactNativeBlobUtil = require('react-native-blob-util').default;
+    const candidates = [getBundleFilePath(meta.label), getLegacyBundleFilePath(meta.label)];
+    for (const path of candidates) {
+        const exists = await ReactNativeBlobUtil.fs.exists(path);
+        if (exists)
+            return path;
+    }
+    return null;
+}
+async function clearUpdate() {
+    await clearStoredBundleMeta();
+    if (OTAUpdaterNative?.clearBundlePath) {
+        await OTAUpdaterNative.clearBundlePath();
+    }
+}
+async function notifyAppReady() {
+    const meta = await getStoredBundleMeta();
+    return meta ? types_1.SyncStatus.UPDATE_INSTALLED : types_1.SyncStatus.UP_TO_DATE;
+}