Tauri 2.0 Auto Updates Implementing App Update System

# Generate signing keys for updates
# Install Tauri CLI
cargo install tauri-cli

# Generate key pair
tauri signer generate -w ~/.tauri/myapp.key

# Output:
# Public key: dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6...
# Private key saved to: ~/.tauri/myapp.key
# Password: [enter secure password]

# IMPORTANT: Keep private key secure!
# - Never commit to version control
# - Store in secure location
# - Use environment variables in CI/CD

# src-tauri/tauri.conf.json
# Configure updater
{
  "tauri": {
    "updater": {
      "active": true,
      "endpoints": [
        "https://updates.myapp.com/{{target}}/{{current_version}}"
      ],
      "dialog": true,
      "pubkey": "YOUR_PUBLIC_KEY_HERE"
    },
    "bundle": {
      "identifier": "com.example.myapp"
    }
  },
  "package": {
    "productName": "My App",
    "version": "1.0.0"
  }
}

# Update endpoint format variables:
# {{target}} - Platform target (e.g., "x86_64-pc-windows-msvc")
# {{current_version}} - Current app version
# {{arch}} - Architecture (e.g., "x86_64")
# {{os}} - OS (e.g., "windows", "macos", "linux")

# Example endpoints:
# GitHub Releases:
"https://github.com/user/repo/releases/latest/download/{{target}}"

# Custom server:
"https://api.myapp.com/updates/{{os}}/{{arch}}/{{current_version}}"

# Multiple endpoints (fallback):
"endpoints": [
  "https://updates1.myapp.com/{{target}}/{{current_version}}",
  "https://updates2.myapp.com/{{target}}/{{current_version}}"
]

# Sign updates during build
# Set environment variables
export TAURI_PRIVATE_KEY="$(cat ~/.tauri/myapp.key)"
export TAURI_KEY_PASSWORD="your-secure-password"

# Build with signing
npm run tauri build

# Output includes:
# - Application binary
# - Update signature (.sig file)
# - Update archive (.tar.gz or .zip)

# Windows
set TAURI_PRIVATE_KEY=<private-key-content>
set TAURI_KEY_PASSWORD=your-password
npm run tauri build

// Frontend: Check for updates
import { checkUpdate, installUpdate } from "@tauri-apps/api/updater";
import { relaunch } from "@tauri-apps/api/process";

interface UpdateManifest {
  version: string;
  date: string;
  body?: string;
}

class UpdateService {
  async checkForUpdates(): Promise<{
    shouldUpdate: boolean;
    manifest?: UpdateManifest;
  }> {
    try {
      const { shouldUpdate, manifest } = await checkUpdate();

      if (shouldUpdate) {
        console.log(`Update available: ${manifest?.version}`);
        console.log(`Release notes:\n${manifest?.body}`);
        return { shouldUpdate: true, manifest };
      } else {
        console.log("App is up to date");
        return { shouldUpdate: false };
      }
    } catch (error) {
      console.error("Failed to check for updates:", error);
      return { shouldUpdate: false };
    }
  }

  async promptAndInstall() {
    const { shouldUpdate, manifest } = await this.checkForUpdates();

    if (!shouldUpdate || !manifest) {
      return;
    }

    const message = `
Version ${manifest.version} is available!

${manifest.body || "Bug fixes and improvements"}

Would you like to update now?
    `.trim();

    const shouldInstall = confirm(message);

    if (shouldInstall) {
      await this.downloadAndInstall();
    }
  }

  async downloadAndInstall() {
    try {
      console.log("Downloading update...");
      this.showProgress("Downloading update...");

      await installUpdate();

      console.log("Update installed, restarting...");
      await relaunch();
    } catch (error) {
      console.error("Update failed:", error);
      alert("Failed to install update. Please try again later.");
    }
  }

  private showProgress(message: string) {
    // Show progress UI
    console.log(message);
  }
}

// Usage: Check on startup
const updater = new UpdateService();

window.addEventListener("DOMContentLoaded", async () => {
  // Wait a bit before checking
  setTimeout(async () => {
    await updater.promptAndInstall();
  }, 3000);
});

// Manual check button
document.getElementById("check-updates")?.addEventListener("click", async () => {
  await updater.promptAndInstall();
});

// Rust: Manual update checking
use tauri::updater::{UpdateResponse, UpdaterBuilder};

#[tauri::command]
async fn check_for_updates_manual(
    app: tauri::AppHandle,
) -> Result<String, String> {
    let updater = app.updater();

    match updater.check().await {
        Ok(update) => {
            if update.is_update_available() {
                Ok(format!(
                    "Update available: version {}",
                    update.latest_version()
                ))
            } else {
                Ok("No updates available".to_string())
            }
        }
        Err(e) => Err(format!("Update check failed: {}", e)),
    }
}

#[tauri::command]
async fn get_current_version(
    app: tauri::AppHandle,
) -> String {
    app.package_info().version.to_string()
}

// Rust: Listen to update events
use tauri::updater::UpdaterEvent;

fn setup_updater(app: &tauri::App) {
    let handle = app.handle();

    app.updater()
        .on_update_event(move |event| {
            match event {
                UpdaterEvent::UpdateAvailable { version, date, body } => {
                    println!("Update available: version {}", version);
                    println!("Release date: {}", date);
                    println!("Release notes: {}", body);

                    // Emit to frontend
                    handle
                        .emit_all(
                            "update-available",
                            serde_json::json!({
                                "version": version,
                                "date": date,
                                "body": body,
                            }),
                        )
                        .ok();
                }
                UpdaterEvent::Pending => {
                    println!("Update is pending download...");
                    handle.emit_all("update-pending", ()).ok();
                }
                UpdaterEvent::DownloadProgress {
                    chunk_length,
                    content_length,
                } => {
                    let progress = if let Some(total) = content_length {
                        (chunk_length as f64 / total as f64) * 100.0
                    } else {
                        0.0
                    };

                    println!("Download progress: {:.1}%", progress);

                    handle
                        .emit_all(
                            "update-download-progress",
                            serde_json::json!({
                                "downloaded": chunk_length,
                                "total": content_length,
                                "progress": progress,
                            }),
                        )
                        .ok();
                }
                UpdaterEvent::Downloaded => {
                    println!("Update downloaded successfully");
                    handle.emit_all("update-downloaded", ()).ok();
                }
                UpdaterEvent::Updated => {
                    println!("Update installed, restarting...");
                    handle.emit_all("update-installed", ()).ok();
                }
                UpdaterEvent::AlreadyUpToDate => {
                    println!("App is already up to date");
                    handle.emit_all("update-not-needed", ()).ok();
                }
                UpdaterEvent::Error(error) => {
                    eprintln!("Update error: {}", error);
                    handle
                        .emit_all(
                            "update-error",
                            serde_json::json!({ "error": error }),
                        )
                        .ok();
                }
            }
        });
}

fn main() {
    tauri::Builder::default()
        .setup(|app| {
            setup_updater(app);
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// Frontend: Listen to update events
import { listen } from "@tauri-apps/api/event";

class UpdateProgressUI {
  private progressBar: HTMLProgressElement;
  private statusText: HTMLElement;

  constructor() {
    this.progressBar = document.getElementById(
      "update-progress"
    ) as HTMLProgressElement;
    this.statusText = document.getElementById(
      "update-status"
    ) as HTMLElement;
    this.setupListeners();
  }

  private async setupListeners() {
    await listen("update-available", (event) => {
      const { version, body } = event.payload as any;
      this.showUpdateDialog(version, body);
    });

    await listen("update-pending", () => {
      this.setStatus("Preparing update...");
      this.showProgress();
    });

    await listen("update-download-progress", (event) => {
      const { progress } = event.payload as any;
      this.updateProgress(progress);
      this.setStatus(`Downloading... ${progress.toFixed(1)}%`);
    });

    await listen("update-downloaded", () => {
      this.setStatus("Update downloaded, installing...");
    });

    await listen("update-installed", () => {
      this.setStatus("Update installed! Restarting...");
    });

    await listen("update-error", (event) => {
      const { error } = event.payload as any;
      this.showError(error);
    });
  }

  private showUpdateDialog(version: string, body: string) {
    const dialog = document.getElementById("update-dialog");
    if (dialog) {
      dialog.innerHTML = `
        <h2>Update Available</h2>
        <p>Version ${version} is ready to install</p>
        <pre>${body}</pre>
        <button id="install-update">Install Now</button>
        <button id="remind-later">Remind Me Later</button>
      `;
      dialog.style.display = "block";
    }
  }

  private showProgress() {
    this.progressBar.style.display = "block";
  }

  private updateProgress(percent: number) {
    this.progressBar.value = percent;
  }

  private setStatus(text: string) {
    this.statusText.textContent = text;
  }

  private showError(error: string) {
    alert(`Update failed: ${error}`);
    this.progressBar.style.display = "none";
  }
}

// Initialize
const updateUI = new UpdateProgressUI();

// Update server response format
// https://updates.myapp.com/darwin/1.0.0
{
  "version": "1.0.1",
  "pub_date": "2026-01-28T12:00:00Z",
  "notes": "Bug fixes and performance improvements\n\n- Fixed memory leak\n- Improved startup time\n- Updated dependencies",
  "platforms": {
    "darwin-x86_64": {
      "signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUldTIG...",
      "url": "https://github.com/user/repo/releases/download/v1.0.1/app-x86_64.app.tar.gz"
    },
    "darwin-aarch64": {
      "signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUldTIG...",
      "url": "https://github.com/user/repo/releases/download/v1.0.1/app-aarch64.app.tar.gz"
    },
    "linux-x86_64": {
      "signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUldTIG...",
      "url": "https://github.com/user/repo/releases/download/v1.0.1/app-amd64.AppImage.tar.gz"
    },
    "windows-x86_64": {
      "signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUldTIG...",
      "url": "https://github.com/user/repo/releases/download/v1.0.1/app-x64.msi.zip"
    }
  }
}

// Node.js/Express update server example
const express = require('express');
const app = express();

// Update manifest
const latestVersion = {
  version: '1.0.1',
  pub_date: new Date().toISOString(),
  notes: 'Bug fixes and improvements',
  platforms: {
    'darwin-x86_64': {
      signature: 'SIGNATURE_HERE',
      url: 'https://cdn.myapp.com/releases/v1.0.1/macos-x64.tar.gz',
    },
    'windows-x86_64': {
      signature: 'SIGNATURE_HERE',
      url: 'https://cdn.myapp.com/releases/v1.0.1/windows-x64.msi.zip',
    },
  },
};

// Update endpoint
app.get('/updates/:target/:currentVersion', (req, res) => {
  const { target, currentVersion } = req.params;

  console.log(`Update check: ${target} from ${currentVersion}`);

  // Check if update needed
  if (currentVersion >= latestVersion.version) {
    return res.status(204).send(); // No update
  }

  // Return update manifest
  res.json(latestVersion);
});

app.listen(3000, () => {
  console.log('Update server running on port 3000');
});

// Python/Flask update server
from flask import Flask, jsonify, request
from datetime import datetime

app = Flask(__name__)

LATEST_VERSION = {
    'version': '1.0.1',
    'pub_date': datetime.utcnow().isoformat() + 'Z',
    'notes': 'Bug fixes and improvements',
    'platforms': {
        'darwin-x86_64': {
            'signature': 'SIGNATURE_HERE',
            'url': 'https://cdn.myapp.com/releases/v1.0.1/macos-x64.tar.gz',
        },
        'windows-x86_64': {
            'signature': 'SIGNATURE_HERE',
            'url': 'https://cdn.myapp.com/releases/v1.0.1/windows-x64.msi.zip',
        },
    },
}

@app.route('/updates/<target>/<current_version>')
def check_update(target, current_version):
    print(f'Update check: {target} from {current_version}')

    # Version comparison
    if current_version >= LATEST_VERSION['version']:
        return '', 204  # No update

    return jsonify(LATEST_VERSION)

if __name__ == '__main__':
    app.run(port=3000)

# .github/workflows/release.yml
# GitHub Actions for automated releases

name: Release

on:
  push:
    tags:
      - 'v*'

jobs:
  release:
    permissions:
      contents: write
    strategy:
      fail-fast: false
      matrix:
        platform: [macos-latest, ubuntu-latest, windows-latest]

    runs-on: ${{ matrix.platform }}

    steps:
      - uses: actions/checkout@v3

      - name: Setup Node
        uses: actions/setup-node@v3
        with:
          node-version: 18

      - name: Install Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Install dependencies (Ubuntu)
        if: matrix.platform == 'ubuntu-latest'
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.0-dev \
            libappindicator3-dev librsvg2-dev patchelf

      - name: Install frontend dependencies
        run: npm ci

      - name: Build app
        uses: tauri-apps/tauri-action@v0
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
        with:
          tagName: ${{ github.ref_name }}
          releaseName: 'App v__VERSION__'
          releaseBody: 'See the assets to download this version.'
          releaseDraft: false
          prerelease: false

# Configure updater to use GitHub
# src-tauri/tauri.conf.json
{
  "tauri": {
    "updater": {
      "active": true,
      "endpoints": [
        "https://github.com/username/repo/releases/latest/download/latest.json"
      ],
      "pubkey": "YOUR_PUBLIC_KEY"
    }
  }
}

# The tauri-action automatically:
# - Builds for each platform
# - Signs updates with TAURI_PRIVATE_KEY
# - Creates GitHub Release
# - Uploads platform-specific artifacts
# - Generates latest.json manifest

# Manual release process:
# 1. Update version in tauri.conf.json and package.json
# 2. Commit changes
# 3. Create and push tag
git tag v1.0.1
git push origin v1.0.1

# 4. GitHub Actions builds and creates release automatically

# Store secrets in GitHub repository settings:
# Settings > Secrets and variables > Actions
# - TAURI_PRIVATE_KEY: Your private signing key
# - TAURI_KEY_PASSWORD: Password for the key