35 implement update logic to update the application from GitHub (#43)

* Add initial SVG icon for TSS

* Replace original logo.svg with new SVG logo for TSS

* feat: Implement auto-update system for Trial Submission Studio

- Added `tss-updater` crate for managing updates.
- Implemented GitHub client for checking and downloading updates.
- Added platform detection for macOS, Windows, and Linux.
- Created structures for GitHub releases and assets.
- Implemented semantic versioning support for version comparisons.
- Added checksum verification for downloaded updates.
- Included example usage in documentation.
- Added macOS packaging files including Info.plist and entitlements.plist.
- Added Windows icon and macOS app icon.

* Refactor update error handling and remove installer module

- Simplified `UpdateError` enum by changing error variants to use strings instead of specific error types.
- Removed the `installer.rs` module, consolidating update installation logic into the `UpdateService`.
- Updated `lib.rs` to reflect changes in the update service structure and removed unnecessary modules.
- Streamlined the update process by utilizing the `self_update` crate for downloading and installing updates.
- Removed platform detection logic and related tests, as they are no longer needed with the new update handling approach.
- Updated `release.rs` to simplify the `UpdateInfo` structure, focusing on essential fields for UI display.

Author: rubentalstra

.github/workflows/release.yml

@@ -8,19 +8,21 @@ members = [
     "crates/tss-output",
     "crates/tss-standards",
     "crates/tss-transform",
+    "crates/tss-updater",
     "crates/tss-validate",
     "crates/tss-xpt",
 ]
 resolver = "3"
 
 [workspace.package]
-version = "0.1.0"
+version = "0.0.1"
 edition = "2024"
 rust-version = "1.92"
+license = "MIT"
 
 [workspace.dependencies]
 anyhow = "1.0.100"
-chrono = "0.4.42"
+chrono = { version = "0.4.42", features = ["serde"] }
 csv = "1.4.0"
 hex = "0.4.3"
 insta = { version = "1.45.1", features = ["json"] }

Cargo.lock

@@ -30,6 +30,7 @@ tss-transform = { path = "../tss-transform" }
 tss-validate = { path = "../tss-validate" }
 tss-output = { path = "../tss-output" }
 tss-xpt = { path = "../tss-xpt" }
+tss-updater = { path = "../tss-updater" }
 
 # Common dependencies
 anyhow.workspace = true
@@ -41,18 +42,20 @@ tracing-subscriber.workspace = true
 chrono.workspace = true
 
 # GUI-specific
-rfd = "0.16.0"           # Native file dialogs
-egui-phosphor = "0.11.0" # Icon set
+rfd = "0.16.0"             # Native file dialogs
+egui-phosphor = "0.11.0"   # Icon set
+egui_commonmark = "0.22.0" # Markdown rendering
+open = "5.3"               # Open URLs in browser
 
 # Settings & menu
-directories = "6.0"      # Cross-platform app directories
-toml = "0.9.8"           # Config file format
-muda = "0.17.1"          # Native menu bar (by Tauri team)
+directories = "6.0"          # Cross-platform app directories
+toml = "0.9.8"               # Config file format
+muda = "0.17.1"              # Native menu bar (by Tauri team)
 crossbeam-channel = "0.5.15" # For muda menu events
 
 # Platform-specific
 [target.'cfg(target_os = "macos")'.dependencies]
-winit = "0.30.12"        # Needed for EventLoopBuilderExtMacOS trait
+winit = "0.30.12" # Needed for EventLoopBuilderExtMacOS trait
 
 [lints]
 workspace = true

Cargo.toml

@@ -4,11 +4,25 @@ use crate::menu;
 use crate::services::StudyLoader;
 use crate::settings::ui::{SettingsResult, SettingsWindow};
 use crate::settings::{load_settings, save_settings};
-use crate::state::{AppState, EditorTab, View};
-use crate::views::{DomainEditorView, ExportView, HomeAction, HomeView};
+use crate::state::{AppState, EditorTab, UpdateDialogState, View};
+use crate::views::{
+    CommonMarkCache, DomainEditorView, ExportView, HomeAction, HomeView, UpdateDialogAction,
+    show_about_dialog, show_update_dialog,
+};
 use crossbeam_channel::Receiver;
 use eframe::egui;
 use muda::{Menu, MenuEvent};
+use std::sync::mpsc;
+use std::thread;
+use tss_updater::UpdateService;
+
+/// Message sent from update background thread.
+enum UpdateMessage {
+    /// Update check completed: Ok(Some((version, changelog))) if available, Ok(None) if up-to-date.
+    CheckResult(Result<Option<(String, String)>, String>),
+    /// Install failed with error (success means app restarted).
+    InstallFailed(String),
+}
 
 /// Main application struct
 pub struct CdiscApp {
@@ -19,6 +33,14 @@ pub struct CdiscApp {
     menu: Menu,
     /// Settings window UI component
     settings_window: SettingsWindow,
+    /// Markdown cache for rendering changelogs
+    markdown_cache: CommonMarkCache,
+    /// Whether we've performed the startup update check
+    startup_check_done: bool,
+    /// Channel for receiving update messages from background threads
+    update_receiver: mpsc::Receiver<UpdateMessage>,
+    /// Sender for update messages (cloned for background threads)
+    update_sender: mpsc::Sender<UpdateMessage>,
 }
 
 impl CdiscApp {
@@ -37,11 +59,18 @@ impl CdiscApp {
         let settings = load_settings();
         tracing::info!("Loaded settings: dark_mode={}", settings.general.dark_mode);
 
+        // Create update message channel
+        let (update_sender, update_receiver) = mpsc::channel();
+
         Self {
             state: AppState::new(settings),
             menu_receiver,
             menu,
             settings_window: SettingsWindow::default(),
+            markdown_cache: CommonMarkCache::default(),
+            startup_check_done: false,
+            update_receiver,
+            update_sender,
         }
     }
 }
@@ -51,12 +80,18 @@ impl eframe::App for CdiscApp {
         // Handle preview results from background threads
         self.handle_preview_results(ctx);
 
+        // Handle update messages from background threads
+        self.handle_update_messages(ctx);
+
         // Handle menu events
         self.handle_menu_events(ctx);
 
         // Handle keyboard shortcuts
         self.handle_shortcuts(ctx);
 
+        // Perform startup update check if needed
+        self.maybe_startup_update_check(ctx);
+
         // Track home view action
         let mut home_action = HomeAction::None;
 
@@ -82,6 +117,14 @@ impl eframe::App for CdiscApp {
             }
         }
 
+        // Show update dialog if open
+        let update_action =
+            show_update_dialog(ctx, &mut self.state.ui.update, &mut self.markdown_cache);
+        self.handle_update_action(update_action, ctx);
+
+        // Show about dialog if open
+        show_about_dialog(ctx, &mut self.state.ui.about);
+
         // Main panel
         egui::CentralPanel::default().show(ctx, |ui| match self.state.view.clone() {
             View::Home => {
@@ -129,8 +172,10 @@ impl CdiscApp {
                     ctx.send_viewport_cmd(egui::ViewportCommand::Close);
                 }
                 menu::ids::ABOUT => {
-                    // TODO: Show about dialog
-                    tracing::info!("About clicked");
+                    self.state.ui.about.open();
+                }
+                menu::ids::CHECK_UPDATES => {
+                    self.start_update_check(ctx);
                 }
                 _ => {
                     tracing::debug!("Unknown menu event: {}", id);
@@ -287,3 +332,153 @@ impl CdiscApp {
         }
     }
 }
+
+impl CdiscApp {
+    /// Handle update messages from background threads.
+    fn handle_update_messages(&mut self, ctx: &egui::Context) {
+        while let Ok(msg) = self.update_receiver.try_recv() {
+            match msg {
+                UpdateMessage::CheckResult(result) => {
+                    match result {
+                        Ok(Some((version, changelog))) => {
+                            tracing::info!("Update available: {}", version);
+                            self.state.ui.update =
+                                UpdateDialogState::UpdateAvailable { version, changelog };
+                        }
+                        Ok(None) => {
+                            tracing::info!("No update available");
+                            // Show "up to date" only if dialog was opened (manual check)
+                            if self.state.ui.update.is_open() {
+                                self.state.ui.update = UpdateDialogState::NoUpdate;
+                            }
+                        }
+                        Err(e) => {
+                            tracing::error!("Update check failed: {}", e);
+                            // Show error only if dialog is open (manual check)
+                            if self.state.ui.update.is_open() {
+                                self.state.ui.update = UpdateDialogState::Error(e);
+                            }
+                        }
+                    }
+                    // Record check time
+                    self.state.settings.updates.record_check();
+                    if let Err(e) = save_settings(&self.state.settings) {
+                        tracing::error!("Failed to save settings: {}", e);
+                    }
+                }
+                UpdateMessage::InstallFailed(error) => {
+                    tracing::error!("Update installation failed: {}", error);
+                    self.state.ui.update = UpdateDialogState::Error(error);
+                }
+            }
+            ctx.request_repaint();
+        }
+    }
+
+    /// Perform startup update check if settings allow it.
+    fn maybe_startup_update_check(&mut self, ctx: &egui::Context) {
+        if self.startup_check_done {
+            return;
+        }
+        self.startup_check_done = true;
+
+        // Check if we should perform an automatic check
+        if !self.state.settings.updates.should_check_now() {
+            tracing::debug!("Skipping startup update check (disabled or recently checked)");
+            return;
+        }
+
+        tracing::info!("Performing startup update check");
+        self.start_update_check_background(ctx);
+    }
+
+    /// Start an update check (opens dialog for manual check).
+    fn start_update_check(&mut self, ctx: &egui::Context) {
+        // Check rate limiting for manual checks
+        if !self.state.settings.updates.can_check_manually() {
+            if let Some(secs) = self
+                .state
+                .settings
+                .updates
+                .seconds_until_manual_check_allowed()
+            {
+                tracing::info!("Manual check rate limited, {} seconds until allowed", secs);
+            }
+            return;
+        }
+
+        self.state.ui.update = UpdateDialogState::Checking;
+        self.start_update_check_background(ctx);
+    }
+
+    /// Start update check in background thread.
+    fn start_update_check_background(&mut self, ctx: &egui::Context) {
+        let sender = self.update_sender.clone();
+        let settings = self.state.settings.updates.clone();
+        let ctx = ctx.clone();
+
+        thread::spawn(move || {
+            let result = match UpdateService::check_for_update(&settings) {
+                Ok(Some(info)) => Ok(Some((info.version, info.changelog))),
+                Ok(None) => Ok(None),
+                Err(e) => Err(e.to_string()),
+            };
+
+            let _ = sender.send(UpdateMessage::CheckResult(result));
+            ctx.request_repaint();
+        });
+    }
+
+    /// Handle actions from the update dialog.
+    fn handle_update_action(&mut self, action: UpdateDialogAction, ctx: &egui::Context) {
+        match action {
+            UpdateDialogAction::None => {}
+            UpdateDialogAction::SkipVersion => {
+                // Extract version from current state
+                if let UpdateDialogState::UpdateAvailable { ref version, .. } = self.state.ui.update
+                {
+                    self.state.settings.updates.skipped_version = Some(version.clone());
+                    if let Err(e) = save_settings(&self.state.settings) {
+                        tracing::error!("Failed to save settings: {}", e);
+                    }
+                }
+                self.state.ui.update.close();
+            }
+            UpdateDialogAction::RemindLater => {
+                self.state.ui.update.close();
+            }
+            UpdateDialogAction::InstallAndRestart => {
+                self.start_install(ctx);
+            }
+            UpdateDialogAction::Cancel => {
+                self.state.ui.update.close();
+            }
+        }
+    }
+
+    /// Download, install update, and restart the application.
+    ///
+    /// Uses self_update for the entire process. On success, the app will restart.
+    fn start_install(&mut self, ctx: &egui::Context) {
+        self.state.ui.update = UpdateDialogState::Installing;
+
+        let sender = self.update_sender.clone();
+        let ctx = ctx.clone();
+
+        thread::spawn(move || {
+            // Download and install - self_update handles everything
+            if let Err(e) = UpdateService::download_and_install() {
+                let _ = sender.send(UpdateMessage::InstallFailed(e.to_string()));
+                ctx.request_repaint();
+                return;
+            }
+
+            // Restart the application
+            if let Err(e) = UpdateService::restart() {
+                let _ = sender.send(UpdateMessage::InstallFailed(e.to_string()));
+                ctx.request_repaint();
+            }
+            // On success, the app restarts and this thread ends
+        });
+    }
+}

crates/tss-gui/Cargo.toml

@@ -13,6 +13,7 @@ use muda::{
 pub mod ids {
     pub const OPEN_STUDY: &str = "open_study";
     pub const SETTINGS: &str = "settings";
+    pub const CHECK_UPDATES: &str = "check_updates";
     pub const ABOUT: &str = "about";
     pub const EXIT: &str = "exit";
 }
@@ -43,6 +44,20 @@ pub fn create_menu() -> Menu {
             .append(&PredefinedMenuItem::separator())
             .expect("Failed to add separator");
 
+        // Check for Updates
+        app_menu
+            .append(&MenuItem::with_id(
+                ids::CHECK_UPDATES,
+                "Check for Updates...",
+                true,
+                None,
+            ))
+            .expect("Failed to add Check for Updates menu item");
+
+        app_menu
+            .append(&PredefinedMenuItem::separator())
+            .expect("Failed to add separator");
+
         // Settings (Cmd+,)
         app_menu
             .append(&MenuItem::with_id(
@@ -135,6 +150,19 @@ pub fn create_menu() -> Menu {
 
     #[cfg(not(target_os = "macos"))]
     {
+        help_menu
+            .append(&MenuItem::with_id(
+                ids::CHECK_UPDATES,
+                "Check for Updates...",
+                true,
+                None,
+            ))
+            .expect("Failed to add Check for Updates menu item");
+
+        help_menu
+            .append(&PredefinedMenuItem::separator())
+            .expect("Failed to add separator");
+
         help_menu
             .append(&MenuItem::with_id(ids::ABOUT, "About", true, None))
             .expect("Failed to add About menu item");

crates/tss-gui/src/app.rs

@@ -17,6 +17,9 @@ use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 
+// Re-export update settings from tss-updater
+pub use tss_updater::{UpdateChannel, UpdateCheckFrequency, UpdateSettings};
+
 // ============================================================================
 // Main Settings Struct
 // ============================================================================
@@ -31,6 +34,7 @@ pub struct Settings {
     pub export: ExportSettings,
     pub display: DisplaySettings,
     pub shortcuts: ShortcutSettings,
+    pub updates: UpdateSettings,
 
     /// Recent study folders (persisted for convenience).
     #[serde(default)]
@@ -46,6 +50,7 @@ impl Default for Settings {
             export: ExportSettings::default(),
             display: DisplaySettings::default(),
             shortcuts: ShortcutSettings::default(),
+            updates: UpdateSettings::default(),
             recent_studies: Vec::new(),
         }
     }