feat: add automatic update checker for Tauri desktop app

zeroCoder1 · zeroCoder1 · commit d487f3296c4f · 2026-03-02T02:12:08.000+05:30
- Add Rust backend commands: check_for_updates and get_app_version
- Implement HTTP version checking against kromacut.com/version.json
- Add UpdateChecker React component with dismissible notification
- Check for updates on startup and every 4 hours
- Add reqwest (HTTP client) and tokio (async runtime) dependencies
- Synchronize version to 2.2.0 across package.json and Cargo.toml
- Create UPDATE_CHECKER.md with comprehensive documentation
- Include example version.json file structure
- Update docs with automatic updates feature description
diff --git a/TAURI.md b/TAURI.md
@@ -1,173 +1,72 @@
 # Kromacut Native App (Tauri)
 
-Kromacut can now be built as a native Mac application using Tauri, offering better performance than the web version.
-
-## Why Tauri?
-
-- **Smaller app size:** 2-3 MB vs 100+ MB with Electron
-- **Better performance:** Uses native macOS WebKit instead of bundling Chromium
-- **Lower memory usage:** More efficient resource utilization
-- **Native integration:** Better macOS integration and feel
+Kromacut can be built as a native application for macOS, Windows, and Linux using Tauri.
 
 ## Prerequisites
 
-- **Rust:** Required for building native components
+- Rust
   ```bash
   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
   source "$HOME/.cargo/env"
   ```
-
-- **Node.js:** Already required for the web version
+- Node.js
 
 ## Development
 
-Run the app in development mode:
-
 ```bash
 npm run tauri:dev
 ```
 
-This will:
-1. Start the Vite dev server on port 5173
-2. Launch the native app window
-3. Enable hot-reload for fast development
-
-## Building for Production
-
-Build the native Mac app:
+## Production Build
 
 ```bash
 npm run tauri:build
 ```
 
-This creates two bundles:
-1. **Kromacut.app** - Standard macOS application bundle
-   - Location: `src-tauri/target/release/bundle/macos/Kromacut.app`
-   - Double-click to run
-   
-2. **Kromacut_0.1.0_aarch64.dmg** - DMG installer
-   - Location: `src-tauri/target/release/bundle/dmg/Kromacut_0.1.0_aarch64.dmg`
-   - Distributable installer for Apple Silicon Macs
+Build artifacts are created under `src-tauri/target/release/bundle/`.
 
 ## Configuration
 
-Key Tauri settings in [src-tauri/tauri.conf.json](src-tauri/tauri.conf.json):
-
-- **Window size:** 1400x900 (min: 1000x700) - optimized for the 2-pane layout
-- **Bundle identifier:** `com.kromacut.lithophane`
-- **Base path:** Automatically switches between `/` (Tauri) and `/Kromacut/` (GitHub Pages)
-
-## Performance Benefits
-
-The native app benefits from:
-- **Direct GPU access** for Three.js rendering
-- **Native file system** for faster image loading
-- **No browser overhead** for better memory management
-- **macOS optimization** for M1/M2 chip acceleration
-
-## Web vs Native
-
-Both versions are maintained:
-- **Web (GitHub Pages):** `npm run build` → Deploy to https://zeroCoder1.github.io/Kromacut/
-- **Native (Tauri):** `npm run tauri:build` → Create Mac app bundle
-
-The codebase is shared; vite.config.ts automatically adapts the base path based on the build target.
-
-## Distribution
-
-### Local Distribution
+Main config file: `src-tauri/tauri.conf.json`
 
-To share the app:
-1. Use the `.dmg` file from `src-tauri/target/release/bundle/dmg/`
-2. Recipients can drag Kromacut.app to their Applications folder
-3. **Remove the quarantine attribute** (required for unsigned apps):
-   ```bash
-   sudo xattr -d com.apple.quarantine /Applications/Kromacut.app
-   ```
-4. Launch the app
+- Window defaults are set for Kromacut’s two-pane layout.
+- Bundle identifier is configured in the same file.
 
-**If users see "Kromacut is damaged" error:**
-This happens because the app isn't code-signed. The fix is to remove the quarantine flag that macOS adds to downloaded files:
-```bash
-sudo xattr -d com.apple.quarantine /Applications/Kromacut.app
-```
-Enter your password when prompted.
+## Versioning and Release
 
-### Automated Releases (GitHub)
+When releasing a new version:
 
-The project includes a GitHub Action that automatically builds and releases the Mac app:
+1. Update `package.json` version.
+2. Update `src-tauri/tauri.conf.json` version.
+3. Commit and tag the release.
 
-**To create a new release:**
+Example:
 
 ```bash
-# Update version in both files
-# 1. package.json - "version": "0.2.0"
-# 2. src-tauri/tauri.conf.json - "version": "0.2.0"
-
-# Commit the changes
 git add package.json src-tauri/tauri.conf.json
-git commit -m "Bump version to 0.2.0"
-
-# Create and push a version tag
-git tag v0.2.0
+git commit -m "Bump version to vX.Y.Z"
+git tag vX.Y.Z
 git push origin main
-git push origin v0.2.0
+git push origin vX.Y.Z
 ```
 
-The workflow will automatically:
-1. Build for both Apple Silicon (M1/M2/M3) and Intel Macs
-2. Create a GitHub release with the tag name
-3. Upload both DMG files as release assets
-4. Include installation instructions in the release notes
-
-**Manual trigger:**
-You can also trigger the workflow manually from the Actions tab on GitHub.
-
-**Release artifacts:**
-- `Kromacut_VERSION_aarch64.dmg` - Apple Silicon (M1/M2/M3)
-- `Kromacut_VERSION_x86_64.dmg` - Intel Macs
+The GitHub Actions workflow will automatically build native applications for:
+- **macOS**: Apple Silicon (M1/M2/M3) and Intel
+- **Windows**: x64 installer
+- **Linux**: AppImage and .deb package
 
-### Code Signing & Notarization (Future Enhancement)
+All artifacts are attached to the GitHub release.
 
-Currently, the app is **ad-hoc signed** (configured with `signingIdentity: "-"` in tauri.conf.json). This allows the app to run but users must remove the quarantine attribute after downloading.
+## Distribution Notes
 
-**To eliminate the quarantine requirement entirely**, you would need to:
+**macOS:** Unsigned builds require removing quarantine:
 
-1. **Enroll in Apple Developer Program** ($99/year)
-   - Visit: https://developer.apple.com/programs/
-
-2. **Obtain a Developer ID Application certificate**
-   - Issued through your Apple Developer account
-   - Allows distribution outside the Mac App Store
-
-3. **Configure Tauri with your signing identity**
-   ```json
-   "macOS": {
-     "signingIdentity": "Developer ID Application: Your Name (TEAM_ID)",
-     "entitlements": "path/to/entitlements.plist"
-   }
-   ```
-
-4. **Notarize the app with Apple**
-   - Apple scans the app for malicious content
-   - Adds a "ticket" that tells Gatekeeper the app is safe
-   - Required for apps distributed outside the App Store as of macOS 10.15+
-
-**Benefits of notarization:**
-- ✅ No quarantine warnings for users
-- ✅ No `xattr` command needed
-- ✅ Professional distribution
-- ✅ Users can simply double-click to install
-- ✅ Better trust and user experience
+```bash
+sudo xattr -d com.apple.quarantine /Applications/Kromacut.app
+```
 
-**Current state (v2.1):**
-- Ad-hoc signing is enabled
-- Users must run: `sudo xattr -d com.apple.quarantine /Applications/Kromacut.app`
-- This is acceptable for personal use and small-scale distribution
+For notarized distribution, configure a Developer ID signing identity in `tauri.conf.json`.
 
-## Updating
+**Windows:** The `.msi` installer may trigger Windows SmartScreen for unsigned builds. Users can click "More info" → "Run anyway".
 
-When the app version changes:
-1. Update version in [package.json](package.json)
-2. Update version in [src-tauri/tauri.conf.json](src-tauri/tauri.conf.json)
-3. Rebuild: `npm run tauri:build`
+**Linux:** AppImage bundles are portable and require no installation. `.deb` packages integrate with the system package manager.
diff --git a/UPDATE_CHECKER.md b/UPDATE_CHECKER.md
@@ -0,0 +1,60 @@
+# Update Checking System
+
+Kromacut includes an automatic update checker for the Tauri desktop app.
+
+## How It Works
+
+1. **Version Check**: The app periodically checks `https://kromacut.com/version.json` for the latest version.
+2. **Comparison**: The fetched version is compared with the installed version.
+3. **Notification**: If a newer version is available, a notification appears in the bottom-right corner.
+4. **User Action**: Users can download the update or dismiss the notification.
+
+## Version File Format
+
+The `version.json` file should be hosted at `https://kromacut.com/version.json` with the following structure:
+
+```json
+{
+  "version": "2.2.0",
+  "download_url": "https://github.com/vycdev/Kromacut/releases/latest",
+  "release_notes": "Bug fixes and performance improvements"
+}
+```
+
+### Fields
+
+- `version` (required): The latest version number (semver format recommended)
+- `download_url` (optional): Direct link to download the update
+- `release_notes` (optional): Brief description of what's new
+
+## Update Frequency
+
+- **On Startup**: Checks for updates when the app launches
+- **Periodic**: Re-checks every 4 hours while the app is running
+- **Non-blocking**: Version checks happen in the background
+
+## Version Synchronization
+
+The version number is managed in multiple places and should be kept in sync:
+
+1. `package.json` - `version` field
+2. `src-tauri/tauri.conf.json` - `version` field
+3. `src-tauri/Cargo.toml` - `version` field under `[package]`
+
+When releasing a new version, update all three files.
+
+## Disabling Update Checks
+
+Update checks only run in the Tauri desktop environment. The web version is unaffected. To disable update checks in the desktop app, simply don't include the UpdateChecker component.
+
+## Testing
+
+To test the update checker locally:
+
+1. Change the version in `public/version.json` to a higher version
+2. Build and run the Tauri app: `npm run tauri:dev`
+3. The update notification should appear after a few seconds
+
+## Privacy
+
+The update checker makes a single HTTP GET request to the version endpoint. No user data or telemetry is collected or transmitted.
diff --git a/package-lock.json b/package-lock.json
diff --git a/public/version.json b/public/version.json
@@ -0,0 +1,5 @@
+{
+  "version": "2.2.0",
+  "download_url": "https://github.com/vycdev/Kromacut/releases/latest",
+  "release_notes": "Latest release with new features and improvements"
+}
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "app"
-version = "0.1.0"
-description = "A Tauri App"
-authors = ["you"]
+version = "2.2.0"
+description = "Kromacut - Multi-color lithophane 3D print generator"
+authors = ["vycdev"]
 license = ""
 repository = ""
 edition = "2021"
@@ -23,3 +23,5 @@ serde = { version = "1.0", features = ["derive"] }
 log = "0.4"
 tauri = { version = "2.10.0", features = [] }
 tauri-plugin-log = "2"
+reqwest = { version = "0.12", features = ["json"] }
+tokio = { version = "1", features = ["full"] }
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
@@ -1,6 +1,48 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+struct VersionInfo {
+    version: String,
+    download_url: Option<String>,
+    release_notes: Option<String>,
+}
+
+#[tauri::command]
+async fn check_for_updates(current_version: String) -> Result<Option<VersionInfo>, String> {
+    // Try to fetch version info from kromacut.com/version.json
+    let url = "https://kromacut.com/version.json";
+    
+    match reqwest::get(url).await {
+        Ok(response) => {
+            if response.status().is_success() {
+                match response.json::<VersionInfo>().await {
+                    Ok(version_info) => {
+                        // Compare versions (simple string comparison for now)
+                        if version_info.version != current_version {
+                            Ok(Some(version_info))
+                        } else {
+                            Ok(None)
+                        }
+                    }
+                    Err(e) => Err(format!("Failed to parse version info: {}", e)),
+                }
+            } else {
+                Err(format!("Server returned status: {}", response.status()))
+            }
+        }
+        Err(e) => Err(format!("Failed to check for updates: {}", e)),
+    }
+}
+
+#[tauri::command]
+fn get_app_version() -> String {
+    env!("CARGO_PKG_VERSION").to_string()
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
   tauri::Builder::default()
+    .invoke_handler(tauri::generate_handler![check_for_updates, get_app_version])
     .setup(|app| {
       if cfg!(debug_assertions) {
         app.handle().plugin(
diff --git a/src/App.tsx b/src/App.tsx
@@ -27,6 +27,7 @@ import { useBuildWarning } from './hooks/useBuildWarning';
 import ResizableSplitter from './components/ResizableSplitter';
 import { ControlsPanel } from './components/ControlsPanel';
 import { usePaletteManager } from './hooks/usePaletteManager';
+import { UpdateChecker } from './components/UpdateChecker';
 import {
     AlertDialog,
     AlertDialogContent,
@@ -587,6 +588,9 @@ function App(): React.ReactElement | null {
                     </AlertDialogFooter>
                 </AlertDialogContent>
             </AlertDialog>
+
+            {/* Update checker for Tauri desktop app */}
+            <UpdateChecker />
         </div>
     );
 }
diff --git a/src/components/UpdateChecker.tsx b/src/components/UpdateChecker.tsx
