react-native-bspatch 1.0.0

package/src/ota/otaLogger.ts

@@ -0,0 +1,72 @@
+/**
+ * OTA Structured Event Logger
+ *
+ * Provides a centralized logging system for all OTA operations.
+ * Events can be forwarded to external analytics via the `onEvent` callback in OtaConfig.
+ */
+
+import NativeBsPatch from '../NativeBsPatch';
+
+export enum OtaEvent {
+  CHECK_UPDATE = 'check_update',
+  DOWNLOAD_START = 'download_start',
+  DOWNLOAD_SUCCESS = 'download_success',
+  DOWNLOAD_FAIL = 'download_fail',
+  PATCH_START = 'patch_start',
+  PATCH_SUCCESS = 'patch_success',
+  PATCH_FAIL = 'patch_fail',
+  HASH_VERIFY_START = 'hash_verify_start',
+  HASH_VERIFY_SUCCESS = 'hash_verify_success',
+  HASH_MISMATCH = 'hash_mismatch',
+  ROLLBACK = 'rollback',
+  FALLBACK_FULL_BUNDLE = 'fallback_full_bundle',
+  MARK_HEALTHY = 'mark_healthy',
+  RESET_FACTORY = 'reset_factory',
+  VERSION_INCOMPATIBLE = 'version_incompatible',
+  SIGNATURE_INVALID = 'signature_invalid',
+  DECOMPRESS_START = 'decompress_start',
+  DECOMPRESS_SUCCESS = 'decompress_success',
+}
+
+export type OtaLogEntry = {
+  event: OtaEvent;
+  timestamp: number;
+  version?: number;
+  message?: string;
+  durationMs?: number;
+  sizeKB?: number;
+  error?: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type OtaEventCallback = (entry: OtaLogEntry) => void;
+
+/**
+ * Creates an OTA logger instance bound to an optional external callback.
+ */
+export const createOtaLogger = (onEvent?: OtaEventCallback) => {
+  const emit = (
+    event: OtaEvent,
+    details?: Omit<OtaLogEntry, 'event' | 'timestamp'>,
+  ) => {
+    const entry: OtaLogEntry = {
+      event,
+      timestamp: Date.now(),
+      ...details,
+    };
+
+    // Always log to console for debugging
+    const logStr = `[OTA:${event}] ${JSON.stringify(entry)}`;
+    console.log(logStr);
+
+    // Also log to native for physical device debugging (visible in Xcode)
+    if (NativeBsPatch && NativeBsPatch.logNative) {
+      NativeBsPatch.logNative(logStr);
+    }
+
+    // Forward to external analytics if configured
+    onEvent?.(entry);
+  };
+
+  return { emit };
+};

package/src/ota/otaMetadata.ts

@@ -0,0 +1,149 @@
+import { Platform } from 'react-native';
+import ReactNativeBlobUtil from 'react-native-blob-util';
+import { OtaMetadata } from './types';
+
+const OTA_DIR = `${ReactNativeBlobUtil.fs.dirs.DocumentDir}/ota`;
+const METADATA_PATH = `${OTA_DIR}/metadata.json`;
+
+/** Promise-based lock to prevent concurrent metadata writes (double-tap guard). */
+let saveLock: Promise<void> = Promise.resolve();
+
+/**
+ * Ensures the OTA root directory exists.
+ */
+export const ensureOtaDir = async (): Promise<void> => {
+    if (!(await ReactNativeBlobUtil.fs.exists(OTA_DIR))) {
+        await ReactNativeBlobUtil.fs.mkdir(OTA_DIR);
+    }
+};
+
+/**
+ * Loads the current OTA metadata from the local filesystem.
+ *
+ * @param defaultVersion - The version to return if no metadata exists (usually baseAppVersion).
+ * @returns The persisted metadata or a default if loading fails.
+ */
+export const loadMetadata = async (
+    defaultVersion: number,
+): Promise<OtaMetadata> => {
+    try {
+        if (await ReactNativeBlobUtil.fs.exists(METADATA_PATH)) {
+            const content = await ReactNativeBlobUtil.fs.readFile(
+                METADATA_PATH,
+                'utf8',
+            );
+            return JSON.parse(content);
+        }
+    } catch (e) {
+        console.warn('[otaMetadata] Failed to load metadata:', e);
+    }
+
+    return {
+        currentVersion: defaultVersion,
+        previousVersions: [],
+        rollbackCount: 0,
+        lastLaunchSuccessful: true,
+    };
+};
+
+/**
+ * Persists OTA metadata to the local filesystem.
+ *
+ * @param metadata - The metadata object to save.
+ */
+export const saveMetadata = async (metadata: OtaMetadata): Promise<void> => {
+    // Wait for any in-flight save to complete before starting our own
+    const prevLock = saveLock;
+    let settleFn: (() => void) | undefined;
+    saveLock = new Promise<void>(resolve => { settleFn = resolve; });
+
+    try {
+        await prevLock;
+        await ensureOtaDir();
+        await ReactNativeBlobUtil.fs.writeFile(
+            METADATA_PATH,
+            JSON.stringify(metadata, null, 2),
+            'utf8',
+        );
+    } catch (e) {
+        console.error('[otaMetadata] Failed to save metadata:', e);
+        throw new Error(`Failed to save metadata: ${(e as Error).message}`);
+    } finally {
+        settleFn!();
+    }
+};
+
+/** Maximum number of previous versions kept in history for rollback. */
+export const MAX_VERSION_HISTORY = 3;
+
+/**
+ * Rotates OTA versions for auditing and rollback capabilities.
+ * Pushes the current version to the history and limits history to MAX_VERSION_HISTORY.
+ *
+ * @param metadata - Current metadata object.
+ * @param newVersion - The newly applied OTA version.
+ * @returns Updated metadata object.
+ */
+export const registerNewVersion = (
+    metadata: OtaMetadata,
+    newVersion: number,
+): OtaMetadata => {
+    const versions = [
+        metadata.currentVersion,
+        ...(metadata.previousVersions || []),
+    ];
+    // Keep internal history unique and capped
+    const uniquePrevious = Array.from(new Set(versions))
+        .filter(v => v !== newVersion)
+        .slice(0, MAX_VERSION_HISTORY);
+
+    return {
+        ...metadata,
+        currentVersion: newVersion,
+        previousVersions: uniquePrevious,
+        rollbackCount: 0,
+        lastLaunchSuccessful: true, // Native layer will set to false on next boot until JS marks healthy
+    };
+};
+
+/**
+ * Marks the current session as healthy, indicating a successful boot.
+ * This prevents the native bridge from rolling back the version on the next launch.
+ *
+ * @param defaultVersion - Base version for metadata lookup fallback.
+ * @returns The updated metadata.
+ */
+export const markHealthy = async (
+    defaultVersion: number,
+): Promise<OtaMetadata> => {
+    const metadata = await loadMetadata(defaultVersion);
+    const updated: OtaMetadata = {
+        ...metadata,
+        lastLaunchSuccessful: true,
+        rollbackCount: 0,
+    };
+    await saveMetadata(updated);
+    return updated;
+};
+
+/**
+ * Resolves the absolute path to the JS bundle for a specific version.
+ *
+ * @param version - The OTA version number.
+ * @param baseVersion - The app's base version (bundled).
+ * @returns Absolute path to the bundle or null if it refers to the base bundle.
+ */
+export const getBundlePath = (
+    version: number,
+    baseVersion: number,
+): string | null => {
+    if (version === baseVersion) {
+        return null;
+    }
+    const filename = Platform.select({
+        android: 'index.android.bundle',
+        ios: 'main.jsbundle',
+        default: 'index.android.bundle',
+    });
+    return `${OTA_DIR}/v${version}/${filename}`;
+};

package/src/ota/storage/CustomStorage.ts

@@ -0,0 +1,143 @@
+import { Platform } from 'react-native';
+import ReactNativeBlobUtil from 'react-native-blob-util';
+import type { OtaPatch, OtaConfig, OtaStorageProvider } from '../types';
+
+interface TokenCache {
+    token: string;
+    expiresAt: number;
+}
+
+/** Cache tokens per server endpoint so switching configs invalidates stale tokens. */
+const tokenCache = new Map<string, TokenCache>();
+
+/**
+ * Implementation for the custom MinIO-based storage server.
+ */
+export class CustomStorageProvider implements OtaStorageProvider {
+  private getEndpoint(config: OtaConfig, key: 'login' | 'genDownloadLink' | 'downloadFile', fallback: string): string {
+    return config.customServer?.endpoints?.[key] ?? fallback;
+  }
+
+  private async getAccessToken(config: OtaConfig): Promise<string> {
+    if (!config.customServer) {
+      throw new Error('customServer configuration missing');
+    }
+
+    const { baseUrl, username, password } = config.customServer;
+    const cacheKey = `${baseUrl}|${username}`;
+    const now = Date.now();
+
+    const cached = tokenCache.get(cacheKey);
+    if (cached && now < cached.expiresAt - 30000) {
+      return cached.token;
+    }
+
+    const loginPath = this.getEndpoint(config, 'login', 'public/authen/login');
+    const loginUrl = baseUrl.endsWith('/') ? `${baseUrl}${loginPath}` : `${baseUrl}/${loginPath}`;
+
+    try {
+      const res = await ReactNativeBlobUtil.fetch(
+        'POST',
+        loginUrl,
+        { 'Content-Type': 'application/json; charset=utf-8' },
+        JSON.stringify({ username, password })
+      );
+
+      const json = JSON.parse(res.data);
+      const token = json.data?.accessTokenInfo?.accessToken;
+
+      if (!token) throw new Error('Login failed: token not found');
+
+      tokenCache.set(cacheKey, { token, expiresAt: now + 3600000 }); // 1 hour
+      return token;
+    } catch (error) {
+      throw new Error(`Authentication failed: ${(error as Error).message}`);
+    }
+  }
+
+  async fetchManifest(config: OtaConfig): Promise<OtaPatch[]> {
+    if (!config.customServer) return config.bundledPatches || [];
+
+    const { baseUrl, channel, baseFolder = 'bspatch' } = config.customServer;
+    const registryPath = `${baseFolder}/ota_registry.json`;
+
+    try {
+      const token = await this.getAccessToken(config);
+      const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+      const genLinkPath = this.getEndpoint(config, 'genDownloadLink', 'api/minio/gen-download-link');
+      const genLinkUrl = `${normalizedBaseUrl}/${genLinkPath}?pathFile=${encodeURIComponent(registryPath)}`;
+
+      const linkRes = await ReactNativeBlobUtil.fetch('GET', genLinkUrl, {
+        Authorization: `Bearer ${token}`,
+      });
+      const linkJson = JSON.parse(linkRes.data);
+      const registryUrl = linkJson.data;
+      if (!registryUrl) throw new Error('Failed to generate registry download link');
+
+      const registryRes = await ReactNativeBlobUtil.fetch('GET', registryUrl);
+      if (registryRes.respInfo.status !== 200) {
+        throw new Error(`Registry fetch failed with status ${registryRes.respInfo.status}`);
+      }
+
+      const registry = JSON.parse(registryRes.data);
+      const appGroup = registry?.apps?.[config.appVersion];
+      const flavorGroup = appGroup?.flavors?.[channel.toLowerCase()];
+
+      if (!flavorGroup || !flavorGroup.patches?.length) {
+        return config.bundledPatches || [];
+      }
+
+      return (flavorGroup.patches || []).filter((p: OtaPatch) => p.platform === Platform.OS);
+    } catch (error) {
+      console.warn('[CustomStorage] Manifest fetch error:', (error as Error).message);
+      return config.bundledPatches || [];
+    }
+  }
+
+  async getUpdateFileUrl(filename: string, config: OtaConfig): Promise<string> {
+    if (!config.customServer) throw new Error('customServer config missing');
+
+    const { baseUrl, baseFolder = 'bspatch', useMinio } = config.customServer;
+    const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    const channel = config.customServer.channel.toLowerCase();
+    const remotePath = `${baseFolder}/${config.appVersion}/${channel}/${filename}`;
+
+    if (useMinio) {
+      const token = await this.getAccessToken(config);
+      const genLinkPath = this.getEndpoint(config, 'genDownloadLink', 'api/minio/gen-download-link');
+      const genLinkUrl = `${normalizedBaseUrl}/${genLinkPath}?pathFile=${encodeURIComponent(remotePath)}`;
+      const res = await ReactNativeBlobUtil.fetch('GET', genLinkUrl, {
+        Authorization: `Bearer ${token}`,
+      });
+      const json = JSON.parse(res.data);
+      if (!json.data) throw new Error(`Failed to generate link for: ${filename}`);
+      return json.data;
+    }
+
+    const downloadPath = this.getEndpoint(config, 'downloadFile', 'files/downloadStreamFile');
+    return `${normalizedBaseUrl}/${downloadPath}?filepath=${encodeURIComponent(remotePath)}`;
+  }
+
+  async getAssetUrl(hash: string, ext: string, config: OtaConfig): Promise<string> {
+    if (!config.customServer) return '';
+
+    const { baseUrl, baseFolder = 'bspatch', useMinio } = config.customServer;
+    const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    const filename = `${hash}.${ext}`;
+    const remotePath = `${baseFolder}/assets/${filename}`;
+
+    if (useMinio) {
+      const token = await this.getAccessToken(config);
+      const genLinkPath = this.getEndpoint(config, 'genDownloadLink', 'api/minio/gen-download-link');
+      const genLinkUrl = `${normalizedBaseUrl}/${genLinkPath}?pathFile=${encodeURIComponent(remotePath)}`;
+      const res = await ReactNativeBlobUtil.fetch('GET', genLinkUrl, {
+        Authorization: `Bearer ${token}`,
+      });
+      const json = JSON.parse(res.data);
+      return json.data || '';
+    }
+
+    const downloadPath = this.getEndpoint(config, 'downloadFile', 'files/downloadStreamFile');
+    return `${normalizedBaseUrl}/${downloadPath}?filepath=${encodeURIComponent(remotePath)}`;
+  }
+}

package/src/ota/storage/GitHubReleaseStorage.ts

@@ -0,0 +1,98 @@
+/**
+ * GitHub Releases Storage Provider
+ *
+ * Reads the OTA registry from a GitHub Release asset and resolves download URLs
+ * directly from the release. Supports both public and token-authenticated repos.
+ *
+ * Registry format:
+ * - Expected at: `https://raw.githubusercontent.com/{owner}/{repo}/{tag}/{registryPath}`
+ * - Asset download: `https://github.com/{owner}/{repo}/releases/download/{tag}/{filename}`
+ */
+
+import { Platform } from 'react-native';
+import ReactNativeBlobUtil from 'react-native-blob-util';
+import type { OtaPatch, OtaConfig, OtaStorageProvider } from '../types';
+
+export class GitHubReleaseStorageProvider implements OtaStorageProvider {
+    private getRawRegistryUrl(config: OtaConfig): string {
+        const { repo, tag, registryPath = 'ota_registry.json' } = config.githubRelease!;
+        return `https://raw.githubusercontent.com/${repo}/${tag}/${registryPath}`;
+    }
+
+    private getAssetDownloadUrl(config: OtaConfig, filename: string): string {
+        const { repo, tag } = config.githubRelease!;
+        return `https://github.com/${repo}/releases/download/${tag}/${filename}`;
+    }
+
+    private authHeaders(token?: string): Record<string, string> {
+        if (!token) return {};
+        return { Authorization: `Bearer ${token}` };
+    }
+
+    async fetchManifest(config: OtaConfig): Promise<OtaPatch[]> {
+        if (!config.githubRelease) return config.bundledPatches || [];
+
+        const { token } = config.githubRelease;
+        const url = this.getRawRegistryUrl(config);
+
+        try {
+            const res = await ReactNativeBlobUtil.fetch(
+                'GET',
+                url,
+                this.authHeaders(token),
+            );
+
+            if (res.respInfo.status !== 200) {
+                throw new Error(`Registry fetch failed with status ${res.respInfo.status}`);
+            }
+
+            const registry =
+                typeof res.data === 'string'
+                    ? JSON.parse(res.data)
+                    : JSON.parse(JSON.stringify(res.data));
+
+            // Support both flat array (legacy) and structured format
+            if (Array.isArray(registry)) {
+                return registry.filter(
+                    (p: OtaPatch) => !p.platform || p.platform === Platform.OS,
+                );
+            }
+
+            // Structured: apps["1.0.0"].channels["production"].patches[]
+            const appGroup = registry?.apps?.[config.appVersion];
+            const channelGroup = appGroup?.channels?.[config.githubRelease.repo] // use repo as channel fallback
+                ?? appGroup?.channels?.production
+                ?? appGroup?.flavors?.production;
+
+            if (!channelGroup?.patches?.length) {
+                return config.bundledPatches || [];
+            }
+
+            return channelGroup.patches.filter(
+                (p: OtaPatch) => !p.platform || p.platform === Platform.OS,
+            );
+        } catch (error) {
+            console.warn('[GitHubStorage] Manifest fetch error:', (error as Error).message);
+            return config.bundledPatches || [];
+        }
+    }
+
+    async getUpdateFileUrl(filename: string, config: OtaConfig): Promise<string> {
+        if (!config.githubRelease) throw new Error('githubRelease config missing');
+        return this.getAssetDownloadUrl(config, filename);
+    }
+
+    async getAssetUrl(hash: string, ext: string, config: OtaConfig): Promise<string> {
+        if (!config.githubRelease) return '';
+
+        const { assetBaseUrl, tag, repo } = config.githubRelease;
+
+        // If a custom CDN/base is provided, use it
+        if (assetBaseUrl) {
+            return `${assetBaseUrl}/${hash}.${ext}`;
+        }
+
+        // Fallback: serve from GitHub raw with optional token
+        return `https://raw.githubusercontent.com/${repo}/${tag}/assets/${hash}.${ext}`;
+    }
+}

package/src/ota/types.ts

@@ -0,0 +1,211 @@
+/**
+ * OTA Data Types
+ */
+
+import type { OtaEventCallback } from './otaLogger';
+
+export interface OtaStorageProvider {
+    /**
+     * Fetch the list of available patches for the current configuration.
+     */
+    fetchManifest(config: OtaConfig): Promise<OtaPatch[]>;
+
+    /**
+     * Get a signed download URL for a version-specific update file (patch or full bundle).
+     */
+    getUpdateFileUrl(filename: string, config: OtaConfig): Promise<string>;
+
+    /**
+     * Get a signed download URL for a content-addressed asset.
+     */
+    getAssetUrl(hash: string, ext: string, config: OtaConfig): Promise<string>;
+}
+
+export enum OtaUpdateMode {
+    MANUAL = 'MANUAL',
+    ON_APP_START = 'ON_APP_START',
+    ON_APP_FOREGROUND = 'ON_APP_FOREGROUND',
+    BACKGROUND_DOWNLOAD = 'BACKGROUND_DOWNLOAD',
+}
+
+export enum OtaStorageType {
+    /** Custom storage server (primary) */
+    CUSTOM = 'CUSTOM',
+    /** GitHub Releases — public or token-authenticated */
+    GITHUB = 'GITHUB',
+}
+
+export type OtaPatch = {
+    /** Unique ID: `v{from}-to-v{to}` */
+    id: string;
+    /** Human-readable label shown in UI */
+    label: string;
+    /** App version this patch belongs to */
+    appVersion: string;
+    /** Release tag (legacy, keep for type compatibility) */
+    releaseTag?: string;
+    /** Filename on the server (e.g. "v1-to-v3.patch") */
+    filename: string;
+    /** Version the app must be at to apply this patch */
+    fromVersion: number;
+    /** Version this patch upgrades to */
+    toVersion: number;
+    /** Integrity hashes (optional for legacy support) */
+    baseHash?: string;
+    /** Hash of the bundle after patching */
+    bundleHash?: string;
+    /** Minimum native app version required (semver) */
+    minAppVersion?: string;
+    /** URL for full bundle download (fallback when patch fails) */
+    fullBundleUrl?: string;
+    /** Whether the patch/bundle is gzip compressed */
+    compressed?: boolean;
+    /** HMAC-SHA256 signature for security verification */
+    signature?: string;
+    /** Whether this update is mandatory */
+    mandatory?: boolean;
+    /** URL to the asset manifest JSON for this version */
+    assetManifestUrl?: string;
+    /** Target platform for this patch */
+    platform?: string;
+};
+
+/**
+ * A single content-addressed asset from the OTA asset store.
+ */
+export type OtaAsset = {
+    /** SHA-256 hash of the file (used as filename: `{hash}.{ext}`) */
+    hash: string;
+    /** File extension without dot (e.g. "jpg", "png") */
+    ext: string;
+    /** Original relative path as Metro knows it (e.g. "drawable-mdpi/assets_images_foo.jpg") */
+    originalPath: string;
+};
+
+export type OtaRemotePatch = {
+    version: number;
+    minAppVersion: string;
+    patchUrl: string;
+    bundleHash: string;
+    baseHash: string;
+    mandatory: boolean;
+};
+
+export type OtaMetadata = {
+    currentVersion: number;
+    previousVersions: number[];
+    rollbackCount: number;
+    lastLaunchSuccessful: boolean;
+};
+
+export type OtaMetrics = {
+    patchSizeKB: number;
+    downloadMs: number;
+    applyMs: number;
+    totalMs: number;
+    fromCache: boolean;
+};
+
+export type OtaNetworkStrategy = {
+    retry?: number;
+    timeoutMs?: number;
+    wifiOnly?: boolean;
+};
+
+export type OtaConfig = {
+    /** Current app versionName (e.g. "1.0.0") */
+    appVersion: string;
+    /** Initial version baked into the APK (usually 1) */
+    baseAppVersion: number;
+    /** Default patches if manifest fetch fails */
+    bundledPatches?: OtaPatch[];
+
+    /** Enterprise configurations */
+    updateMode?: OtaUpdateMode;
+    maxRollback?: number;
+    network?: OtaNetworkStrategy;
+
+    /** Telemetry: structured event callback for analytics */
+    onEvent?: OtaEventCallback;
+    /** Public key for signature verification (base64) */
+    publicKey?: string;
+    /** Base URL for the shared hashed asset store (e.g. a GitHub release URL) */
+    assetBaseUrl?: string;
+
+    /** Storage strategy */
+    storageType?: OtaStorageType;
+
+    /** GitHub Releases configuration (used when storageType === GITHUB) */
+    githubRelease?: {
+        /** Owner / repo in the format "owner/repo" */
+        repo: string;
+        /** Tag name of the release to fetch updates from */
+        tag: string;
+        /**
+         * Path inside the release where ota_registry.json lives.
+         * If your release contains the file at root, set to "ota_registry.json".
+         * If it's inside a folder "ota/", set to "ota/ota_registry.json".
+         */
+        registryPath?: string;
+        /**
+         * Optional GitHub personal access token for private repos or higher rate limits.
+         * For public repos this is optional.
+         */
+        token?: string;
+        /**
+         * Asset base URL for content-addressed assets.
+         * Supports CDN URLs (jsDelivr, GitHub raw) or a custom base.
+         * Example: "https://cdn.jsdelivr.net/gh/owner/repo@tag/assets"
+         */
+        assetBaseUrl?: string;
+    };
+
+    /** Custom storage server configuration */
+    customServer?: {
+        baseUrl: string;
+        username: string;
+        password: string;
+        channel: string;
+        baseFolder?: string;
+        useMinio?: boolean;
+        /** Override default API endpoints for non-standard servers */
+        endpoints?: {
+            /** Auth login endpoint (default: /public/authen/login) */
+            login?: string;
+            /** Generate download link endpoint (default: /api/minio/gen-download-link) */
+            genDownloadLink?: string;
+            /** Direct file download endpoint (default: /files/downloadStreamFile) */
+            downloadFile?: string;
+        };
+    };
+
+    /** Storage provider instance (optional, defaults to CustomStorageProvider) */
+    storage?: OtaStorageProvider;
+};
+
+export enum OtaStatus {
+    IDLE = 'IDLE',
+    CHECKING = 'CHECKING',
+    UPDATE_AVAILABLE = 'UPDATE_AVAILABLE',
+    UP_TO_DATE = 'UP_TO_DATE',
+    DOWNLOADING = 'DOWNLOADING',
+    APPLYING = 'APPLYING',
+    SYNCING_ASSETS = 'SYNCING_ASSETS',
+    SUCCESS = 'SUCCESS',
+    ERROR = 'ERROR',
+}
+
+export type OtaState = {
+    status: OtaStatus;
+    message: string;
+    progress: number; // 0-100
+    currentVersion: number;
+    latestVersion: number;
+    pendingCount: number;
+    isChecking: boolean;
+    metrics: OtaMetrics | null;
+    applyUpdate: () => Promise<void>;
+    resetToFactory: () => Promise<void>;
+    markAsHealthy: () => Promise<void>;
+    checkUpdate: () => Promise<void>;
+};