cordova-plugin-hot-updates 2.1.0 → 2.1.2

package/README.md

@@ -1,487 +1,459 @@
-# Cordova Hot Updates Plugin
+# Cordova Hot Updates Plugin v2.1.2
 
-🔥 **Automatic over-the-air (OTA) hot updates for Cordova applications using WebView Reload approach**
+Frontend-controlled manual hot updates for Cordova iOS applications using WebView Reload approach.
 
 [![npm version](https://badge.fury.io/js/cordova-plugin-hot-updates.svg)](https://badge.fury.io/js/cordova-plugin-hot-updates)
 [![License](https://img.shields.io/badge/License-Custom%20Non--Commercial-blue.svg)](#license)
 
-This plugin enables seamless web content updates for your Cordova iOS applications without requiring App Store approval. Updates are downloaded in the background and applied automatically on the next app launch.
+This plugin enables **manual, JavaScript-controlled** web content updates for your Cordova iOS applications without requiring App Store approval. Your frontend code decides when to check, download, and install updates.
 
-## 🚀 Key Features
+## Features
 
-- **🔄 Automatic Background Updates**: Continuously checks for and downloads updates
-- **⚡ Instant Application**: WebView Reload approach for immediate effect
-- **📦 Semantic Versioning**: Smart version comparison and compatibility checks
-- **🛡️ Rollback Support**: Automatic fallback on corrupted updates
-- **⚙️ Configurable**: Customizable server URLs and check intervals
-- **🎯 Zero Configuration**: Works out of the box with sensible defaults
+- **Frontend Control**: JavaScript decides when to update (no automatic background checking)
+- **Two-Step Updates**: Separate download (`getUpdate`) and install (`forceUpdate`) for better UX
+- **Auto-Install on Launch**: If user ignores update prompt, it installs on next app launch
+- **Canary System**: Automatic rollback if update fails to load (20-second timeout)
+- **IgnoreList**: Tracks problematic versions (information only, does NOT block installation)
+- **Instant Effect**: WebView Reload approach - no app restart needed
+- **Cache Management**: Clears WKWebView cache (disk, memory, Service Worker) before reload
 
-## 📋 Table of Contents
-
-- [Installation](#-installation)
-- [Quick Start](#-quick-start)
-- [Configuration](#-configuration)
-- [API Reference](#-api-reference)
-- [Server Implementation](#-server-implementation)
-- [How It Works](#-how-it-works)
-- [Troubleshooting](#-troubleshooting)
-- [Contributing](#-contributing)
-- [License](#-license)
-
-## 📦 Installation
-
-### Standard Installation (Recommended)
+## Installation
 
 ```bash
-# Install from npm registry
+# Install from npm
 cordova plugin add cordova-plugin-hot-updates
 
-# Install CocoaPods dependencies (iOS)
+# Install CocoaPods dependencies (required)
 cd platforms/ios
 pod install
 ```
 
-### Alternative Installation Methods
+Or install from local directory:
 
 ```bash
-# Install from GitHub
-cordova plugin add https://github.com/vladimirDarksy/Cordova_hot_update.git
-
-# Install from local path
 cordova plugin add /path/to/cordova-plugin-hot-updates
+```
 
-# Install specific version
-cordova plugin add cordova-plugin-hot-updates@1.0.0
+Or install from GitHub:
+
+```bash
+cordova plugin add https://github.com/vladimirDarksy/Cordova_hot_update.git
 ```
 
-### Installation with pnpm
+**Requirements:**
+- Cordova >= 7.0.0
+- cordova-ios >= 4.4.0
+- iOS >= 11.2
+- CocoaPods (for SSZipArchive dependency)
 
-If your project uses pnpm, you may need additional configuration:
+## Quick Start
 
-1. Create or update `.npmrc` in your project root:
+### 1. Minimal Integration
 
-```
-public-hoist-pattern[]=cordova-plugin-*
-shamefully-hoist=true
-auto-install-peers=true
+```javascript
+document.addEventListener('deviceready', function() {
+    // CRITICAL: Confirm successful bundle load within 20 seconds
+    var currentVersion = localStorage.getItem('app_version') || '1.0.0';
+    window.hotUpdate.canary(currentVersion);
+
+    // Check for updates
+    checkForUpdates();
+}, false);
+
+function checkForUpdates() {
+    fetch('https://your-server.com/api/check-update?version=1.0.0')
+        .then(response => response.json())
+        .then(data => {
+            if (data.hasUpdate) {
+                downloadAndInstall(data.downloadUrl, data.version);
+            }
+        });
+}
+
+function downloadAndInstall(url, version) {
+    window.hotUpdate.getUpdate({url: url, version: version}, function(error) {
+        if (!error) {
+            if (confirm('Update available. Install now?')) {
+                localStorage.setItem('app_version', version);
+                window.hotUpdate.forceUpdate(function(error) {
+                    // WebView will reload, canary() will be called in deviceready
+                });
+            }
+            // If user declines, update auto-installs on next launch
+        }
+    });
+}
 ```
 
-2. Then install the plugin:
+## API Reference
 
-```bash
-cordova plugin add cordova-plugin-hot-updates
-```
+All API methods are available via `window.hotUpdate` after the `deviceready` event.
 
-**Note**: Cordova CLI internally uses npm, which can sometimes conflict with pnpm's node_modules structure. The above configuration helps resolve this.
+### window.hotUpdate.getUpdate(options, callback)
 
-## 🚀 Quick Start
+Downloads update from server.
 
-### 1. Configure Your Server URL
+Downloads ZIP from provided URL and saves to two locations:
+- `temp_downloaded_update` (for immediate installation via `forceUpdate()`)
+- `pending_update` (for auto-installation on next app launch)
 
-Add to your `config.xml`:
+If version already downloaded, returns success without re-downloading.
 
-```xml
-<preference name="hot_updates_server_url" value="https://your-server.com/api/updates" />
-<preference name="hot_updates_check_interval" value="300000" />
-```
+**Does NOT check ignoreList** - JavaScript controls all installation decisions.
 
-### 2. Basic Usage
+**Parameters:**
+- `options` (Object):
+  - `url` (string, required) - URL to download ZIP archive
+  - `version` (string, optional) - Version string
+- `callback` (Function) - `callback(error)`
+  - `null` on success
+  - `{error: {message?: string}}` on error
 
+**Example:**
 ```javascript
-// Check current version
-HotUpdates.getCurrentVersion(
-  function(version) {
-    console.log('Current version:', version);
-  },
-  function(error) {
-    console.error('Error:', error);
-  }
-);
-
-// Check for pending updates
-HotUpdates.getPendingUpdateInfo(
-  function(info) {
-    if (info.hasPendingUpdate) {
-      console.log('Update ready:', info.pendingVersion);
-      alert('New update will be applied on next app restart');
+window.hotUpdate.getUpdate({
+    url: 'https://your-server.com/updates/2.0.0.zip',
+    version: '2.0.0'
+}, function(error) {
+    if (error) {
+        console.error('Download failed:', error);
+    } else {
+        console.log('Update downloaded successfully');
     }
-  },
-  function(error) {
-    console.error('Error:', error);
-  }
-);
-
-// Manually check for updates
-HotUpdates.checkForUpdates(
-  function(result) {
-    if (result.hasUpdate) {
-      console.log('Update available:', result.availableVersion);
-      // Optionally download manually
-      HotUpdates.downloadUpdate(
-        result.downloadURL,
-        result.availableVersion,
-        function() {
-          console.log('Download completed');
-        },
-        function(error) {
-          console.error('Download failed:', error);
-        }
-      );
-    }
-  },
-  function(error) {
-    console.error('Check failed:', error);
-  }
-);
+});
 ```
 
-## ⚙️ Configuration
+---
+
+### window.hotUpdate.forceUpdate(callback)
+
+Installs downloaded update immediately and reloads WebView.
 
-### config.xml Preferences
+**Process:**
+1. Backup current version to `www_previous`
+2. Copy downloaded update to `Documents/www`
+3. Clear WebView cache (disk, memory, Service Worker)
+4. Reload WebView
+5. Start 20-second canary timer
 
-| Preference | Default | Description |
-|------------|---------|-------------|
-| `hot_updates_server_url` | `https://your-server.com/api/updates` | Update server endpoint |
-| `hot_updates_check_interval` | `300000` | Check interval in milliseconds (5 minutes) |
-| `hot_updates_auto_download` | `true` | Enable automatic download |
-| `hot_updates_auto_install` | `true` | Enable automatic installation on restart |
+**IMPORTANT:** JavaScript MUST call `canary(version)` within 20 seconds after reload to confirm successful bundle load. Otherwise automatic rollback occurs.
 
-### Example Configuration
+**Does NOT check ignoreList** - JavaScript decides what to install.
 
-```xml
-<widget id="com.yourcompany.yourapp" version="1.0.0">
-  <!-- Hot Updates Configuration -->
-  <preference name="hot_updates_server_url" value="https://updates.yourapp.com/api/check" />
-  <preference name="hot_updates_check_interval" value="600000" />
-  <preference name="hot_updates_auto_download" value="true" />
-  <preference name="hot_updates_auto_install" value="true" />
+**Parameters:**
+- `callback` (Function) - `callback(error)`
+  - `null` on success (before WebView reload)
+  - `{error: {message?: string}}` on error
 
-  <!-- Your other configurations... -->
-</widget>
+**Example:**
+```javascript
+window.hotUpdate.forceUpdate(function(error) {
+    if (error) {
+        console.error('Install failed:', error);
+    } else {
+        console.log('Update installing, WebView will reload...');
+    }
+});
 ```
 
-## 📚 API Reference
+---
+
+### window.hotUpdate.canary(version, callback)
+
+Confirms successful bundle load after update.
 
-### Methods
+**MUST be called within 20 seconds** after `forceUpdate()` to stop canary timer and prevent automatic rollback.
 
-#### `getCurrentVersion(successCallback, errorCallback)`
+**If not called within 20 seconds:**
+- Automatic rollback to previous version
+- Failed version added to ignoreList
+- WebView reloaded with previous version
 
-Gets the currently active version string.
+**Parameters:**
+- `version` (string) - Version that loaded successfully
+- `callback` (Function, optional) - Not used, method is synchronous
 
+**Example:**
 ```javascript
-HotUpdates.getCurrentVersion(
-  function(version) {
-    console.log('Current version:', version); // "1.2.3"
-  },
-  function(error) {
-    console.error('Error getting version:', error);
-  }
-);
+document.addEventListener('deviceready', function() {
+    var version = localStorage.getItem('app_version') || '1.0.0';
+    window.hotUpdate.canary(version);
+}, false);
 ```
 
-#### `getPendingUpdateInfo(successCallback, errorCallback)`
+---
 
-Gets information about downloaded updates waiting to be installed.
+### window.hotUpdate.getIgnoreList(callback)
 
-```javascript
-HotUpdates.getPendingUpdateInfo(
-  function(info) {
-    // info object contains:
-    // - hasPendingUpdate: boolean
-    // - pendingVersion: string
-    // - appBundleVersion: string
-    // - installedVersion: string
-    // - message: string
-  },
-  function(error) {
-    console.error('Error getting update info:', error);
-  }
-);
-```
+Returns list of problematic versions (information only).
 
-#### `checkForUpdates(successCallback, errorCallback)`
+**This is an INFORMATION-ONLY system** - native does NOT block installation. JavaScript should read this list and decide whether to skip these versions.
 
-Manually triggers an update check.
+Native automatically adds versions to this list when rollback occurs.
 
+**Parameters:**
+- `callback` (Function) - `callback(result)`
+  - `result`: `{versions: string[]}` - Array of problematic version strings
+
+**Example:**
 ```javascript
-HotUpdates.checkForUpdates(
-  function(result) {
-    // result object contains:
-    // - hasUpdate: boolean
-    // - currentVersion: string
-    // - availableVersion: string (if hasUpdate is true)
-    // - downloadURL: string (if hasUpdate is true)
-    // - minAppVersion: string (if specified)
-  },
-  function(error) {
-    console.error('Update check failed:', error);
-  }
-);
+window.hotUpdate.getIgnoreList(function(result) {
+    console.log('Problematic versions:', result.versions);
+
+    if (result.versions.includes(newVersion)) {
+        console.log('Skipping known problematic version');
+    }
+});
 ```
 
-#### `downloadUpdate(downloadURL, version, successCallback, errorCallback, progressCallback)`
+---
 
-Manually downloads a specific update.
+## Complete Update Flow
 
 ```javascript
-HotUpdates.downloadUpdate(
-  'https://server.com/updates/v2.0.0.zip',
-  '2.0.0',
-  function() {
-    console.log('Download completed');
-  },
-  function(error) {
-    console.error('Download failed:', error);
-  },
-  function(progress) {
-    console.log('Download progress:', progress + '%');
-  }
-);
+// Step 1: Check for updates on your server
+function checkForUpdates() {
+    var currentVersion = localStorage.getItem('app_version') || '1.0.0';
+
+    fetch('https://your-server.com/api/check-update?version=' + currentVersion)
+        .then(response => response.json())
+        .then(data => {
+            if (data.hasUpdate) {
+                // Step 2: Check ignoreList
+                window.hotUpdate.getIgnoreList(function(ignoreList) {
+                    if (ignoreList.versions.includes(data.version)) {
+                        console.log('Skipping problematic version');
+                        return;
+                    }
+
+                    // Step 3: Download
+                    window.hotUpdate.getUpdate({
+                        url: data.downloadUrl,
+                        version: data.version
+                    }, function(error) {
+                        if (!error) {
+                            // Step 4: Prompt user
+                            if (confirm('Update available. Install now?')) {
+                                // Save version for canary check
+                                localStorage.setItem('app_version', data.version);
+
+                                // Step 5: Install
+                                window.hotUpdate.forceUpdate(function(error) {
+                                    // WebView will reload
+                                });
+                            }
+                            // If declined, auto-installs on next launch
+                        }
+                    });
+                });
+            }
+        });
+}
+
+// Step 6: After reload, confirm success
+document.addEventListener('deviceready', function() {
+    var version = localStorage.getItem('app_version') || '1.0.0';
+    window.hotUpdate.canary(version); // Must call within 20 seconds!
+
+    initApp();
+}, false);
 ```
 
-#### `getConfiguration(successCallback, errorCallback)`
+## How It Works
 
-Gets the current plugin configuration.
+### Update Flow
+
+1. **Download** (`getUpdate()`):
+   - Downloads ZIP from URL
+   - Validates `www` folder structure
+   - Saves to TWO locations:
+     - `temp_downloaded_update` (for immediate install)
+     - `pending_update` (for auto-install on next launch)
+
+2. **Installation Options**:
+   - **Immediate**: User clicks "Update" → `forceUpdate()` installs now
+   - **Deferred**: User ignores → Auto-installs on next app launch
+
+3. **Rollback Protection**:
+   - Previous version backed up before installation
+   - 20-second canary timer starts after reload
+   - If `canary()` not called → automatic rollback
+   - Failed version added to ignoreList
+
+4. **IgnoreList System**:
+   - Native tracks failed versions
+   - JavaScript reads via `getIgnoreList()`
+   - **Does NOT block** - JS decides what to install
+
+### Storage Structure
 
-```javascript
-HotUpdates.getConfiguration(
-  function(config) {
-    // config object contains:
-    // - serverURL: string
-    // - checkInterval: number (milliseconds)
-    // - appBundleVersion: string
-    // - autoDownload: boolean
-  },
-  function(error) {
-    console.error('Error getting config:', error);
-  }
-);
+```
+Documents/
+├── www/                    // Active version
+├── www_previous/           // Previous version (rollback)
+├── pending_update/         // Next launch auto-install
+└── temp_downloaded_update/ // Immediate install
 ```
 
-## 🖥️ Server Implementation
+### Version Management
 
-Your update server should implement the following API:
+- **appBundleVersion** - Native app version from Info.plist
+- **installedVersion** - Current hot update version
+- **previousVersion** - Last working version (rollback)
 
-### Check for Updates Endpoint
+## Update Server API
 
-**GET** `/check?version={currentVersion}&platform=ios`
+Your server should provide:
 
-**Response** (when update available):
-```json
-{
-  "hasUpdate": true,
-  "version": "1.2.0",
-  "downloadURL": "https://yourserver.com/updates/v1.2.0.zip",
-  "minAppVersion": "1.0.0",
-  "releaseNotes": "Bug fixes and improvements"
-}
+**Check API:**
 ```
+GET https://your-server.com/api/check-update?version=1.0.0&platform=ios
 
-**Response** (when no update available):
-```json
+Response:
 {
-  "hasUpdate": false,
-  "message": "No updates available"
+  "hasUpdate": true,
+  "version": "2.0.0",
+  "downloadUrl": "https://your-server.com/updates/2.0.0.zip",
+  "minAppVersion": "2.7.0",
+  "releaseNotes": "Bug fixes"
 }
 ```
 
-### Update Package Format
-
-Your update ZIP file should contain a `www` folder with your web content:
-
+**Update ZIP Structure:**
 ```
 update.zip
 └── www/
     ├── index.html
     ├── js/
     ├── css/
-    ├── img/
     └── ...
 ```
 
-### Example Server Implementation (Node.js)
+## Best Practices
 
-```javascript
-const express = require('express');
-const app = express();
-
-app.get('/api/updates/check', (req, res) => {
-  const { version, platform } = req.query;
-  const currentVersion = version || '1.0.0';
-  const latestVersion = '1.2.0'; // Your latest version
-
-  if (compareVersions(currentVersion, latestVersion) < 0) {
-    res.json({
-      hasUpdate: true,
-      version: latestVersion,
-      downloadURL: `https://yourserver.com/updates/v${latestVersion}.zip`,
-      minAppVersion: '1.0.0',
-      releaseNotes: 'Bug fixes and improvements'
-    });
-  } else {
-    res.json({
-      hasUpdate: false,
-      message: 'No updates available'
-    });
-  }
-});
-
-function compareVersions(version1, version2) {
-  const v1parts = version1.split('.').map(Number);
-  const v2parts = version2.split('.').map(Number);
-
-  for (let i = 0; i < Math.max(v1parts.length, v2parts.length); i++) {
-    const v1part = v1parts[i] || 0;
-    const v2part = v2parts[i] || 0;
-
-    if (v1part < v2part) return -1;
-    if (v1part > v2part) return 1;
-  }
+### 1. Always Call Canary
 
-  return 0;
-}
-
-app.listen(3000, () => {
-  console.log('Update server running on port 3000');
-});
+```javascript
+document.addEventListener('deviceready', function() {
+    var version = localStorage.getItem('app_version');
+    window.hotUpdate.canary(version); // Within 20 seconds!
+}, false);
 ```
 
-## 🔧 How It Works
-
-### WebView Reload Approach
+### 2. Check IgnoreList
 
-1. **Startup Check**: On app launch, the plugin checks for pending updates
-2. **Installation**: If found, updates are installed to `Documents/www`
-3. **WebView Switch**: The WebView is configured to load from `Documents/www` instead of bundle
-4. **Background Process**: Automatic checking and downloading runs in background
-5. **Next Launch**: New updates are applied on next app restart
-
-### File Structure
-
-```
-Documents/
-├── www/                     # Updated web content (active)
-├── pending_update/          # Downloaded update waiting for installation
-│   └── www/                 # New web content
-└── www_backup/              # Backup of previous version (for rollback)
+```javascript
+window.hotUpdate.getIgnoreList(function(result) {
+    if (result.versions.includes(newVersion)) {
+        console.log('Known problematic version');
+    }
+});
 ```
 
-### Update Lifecycle
+### 3. Handle Errors
 
+```javascript
+window.hotUpdate.getUpdate(options, function(error) {
+    if (error) {
+        analytics.track('update_failed', {error: error.message});
+        showUserMessage('Update failed');
+    }
+});
 ```
-[Bundle] -> [Check] -> [Download] -> [Prepare] -> [Install] -> [Reload]
-   ↑                                                             ↓
-   └─────────────────── [Next App Launch] ←──────────────────────┘
-```
-
-## 🐛 Troubleshooting
 
-### Common Issues
+### 4. Store Version
 
-**Plugin installation fails or plugin not found**
-- **npm registry**: Ensure plugin is published to npm
-- **pnpm users**: Add hoisting configuration to `.npmrc` (see Installation with pnpm section)
-- **Git installation**: Use full GitHub URL: `cordova plugin add https://github.com/vladimirDarksy/Cordova_hot_update.git`
-- **Verify installation**: Run `cordova plugin list` to check if plugin is installed
-
-**pnpm + Cordova compatibility issues**
-If you're using pnpm and Cordova can't find the plugin:
-
-1. Add to your project's `.npmrc`:
-   ```
-   public-hoist-pattern[]=cordova-plugin-*
-   shamefully-hoist=true
-   ```
-
-2. Remove and reinstall:
-   ```bash
-   cordova plugin remove cordova-plugin-hot-updates
-   rm -rf node_modules
-   pnpm install
-   cordova plugin add cordova-plugin-hot-updates
-   ```
+```javascript
+// Before forceUpdate
+localStorage.setItem('app_version', newVersion);
 
-3. If still not working, check that Cordova CLI can access the plugin:
-   ```bash
-   ls node_modules/cordova-plugin-hot-updates
-   ```
+// After reload
+var version = localStorage.getItem('app_version');
+window.hotUpdate.canary(version);
+```
 
-**Updates not downloading**
-- Check your server URL in config.xml
-- Verify server is returning correct JSON format
-- Check device network connectivity
-- Enable debugging with `cordova run ios --device --debug`
+## Troubleshooting
 
-**WebView not reloading updated content**
-- Ensure `Documents/www/index.html` exists
-- Check iOS device logs for WebView errors
-- Verify ZIP package contains `www` folder
+### Update doesn't install
 
-**CocoaPods issues**
-- Run `pod install` in `platforms/ios` directory
-- Update CocoaPods: `sudo gem install cocoapods`
-- Clean and rebuild: `cordova clean ios && cordova build ios`
+- Check ZIP structure (must have `www/` folder)
+- Check URL accessibility
+- Check Xcode console: `[HotUpdates] ...`
 
-### Debug Logging
+### Automatic rollback
 
-The plugin provides extensive console logging. To view:
+**Cause:** `canary()` not called within 20 seconds
 
-```bash
-# iOS Simulator
-cordova run ios --debug
-
-# iOS Device
-# Use Xcode console or Safari Web Inspector
+**Solution:** Call immediately in `deviceready`:
+```javascript
+document.addEventListener('deviceready', function() {
+    window.hotUpdate.canary(version); // First thing!
+}, false);
 ```
 
-### Reset Plugin State
+### window.hotUpdate is undefined
+
+**Cause:** Called before `deviceready`
 
+**Solution:**
 ```javascript
-// Clear all plugin data (for testing)
-localStorage.removeItem('hot_updates_installed_version');
-localStorage.removeItem('hot_updates_pending_version');
-localStorage.removeItem('hot_updates_has_pending');
+document.addEventListener('deviceready', function() {
+    console.log(window.hotUpdate); // Now available
+}, false);
 ```
 
-## ⚠️ Important Notes
+## Migration from v1.0.0
 
-- **iOS Only**: Currently supports iOS platform only
-- **HTTPS Required**: Update server should use HTTPS in production
-- **App Store Compliance**: Only update web content, not native code
-- **Testing**: Test thoroughly on real devices before production
-- **Rollback**: Keep ability to rollback via App Store if needed
+**Removed methods:**
+- `getCurrentVersion()` - Manage in JS
+- `getPendingUpdateInfo()` - Not needed
+- `checkForUpdates()` - Frontend controls
+- `downloadUpdate()` - Use `getUpdate()`
+- `installUpdate()` - Use `forceUpdate()`
 
-## 📄 Requirements
+**New API:**
+- `window.hotUpdate.getUpdate({url, version?}, callback)`
+- `window.hotUpdate.forceUpdate(callback)`
+- `window.hotUpdate.canary(version, callback)`
+- `window.hotUpdate.getIgnoreList(callback)`
 
-- **Cordova**: >= 7.0.0
-- **cordova-ios**: >= 4.4.0
-- **iOS**: >= 11.0
-- **CocoaPods**: For SSZipArchive dependency
+**Changes:**
+- API via `window.hotUpdate` (not `window.HotUpdates`)
+- Callback signature: `callback(error)` pattern
+- No automatic background checking
 
-## 🤝 Contributing
+## Changelog
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+### v2.1.2 (2025-11-13)
 
-1. Fork the repository
-2. Create your feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
+**Breaking Changes:**
+- Changed API from `window.HotUpdates` to `window.hotUpdate`
+- Removed automatic update checking
+- Simplified to 4 methods: `getUpdate`, `forceUpdate`, `canary`, `getIgnoreList`
 
-## 📝 License
+**New Features:**
+- Frontend-controlled manual updates
+- Two-step update flow
+- 20-second canary timer
+- IgnoreList system
+- Auto-install on next launch
+- WebView cache clearing
 
-This project is licensed under the Custom Non-Commercial License - see the [LICENSE](LICENSE) file for details.
+### v1.0.0
 
-**⚠️ Commercial use is strictly prohibited without explicit written permission from the copyright holder.**
+- Initial release
 
-For commercial licensing inquiries, please contact: **Mustafin Vladimir**
+## License
 
-## 🙋‍♂️ Support
+Custom Non-Commercial License - See [LICENSE](LICENSE) file
 
-- **Issues**: [GitHub Issues](https://github.com/vladimirDarksy/Cordova_hot_update/issues)
-- **Documentation**: This README and inline code documentation
-- **Discussions**: [GitHub Discussions](https://github.com/vladimirDarksy/Cordova_hot_update/discussions)
+## Author
 
----
+**Mustafin Vladimir**
+- GitHub: [@vladimirDarksy](https://github.com/vladimirDarksy)
+- Email: outvova.gor@gmail.com
+
+## Support
 
-**Made with ❤️ by [Mustafin Vladimir](https://github.com/vladimirDarksy)**
+- Issues: https://github.com/vladimirDarksy/Cordova_hot_update/issues
+- Repository: https://github.com/vladimirDarksy/Cordova_hot_update