Show release notes in a dialog before updating UniGetUI (#5697)

Author: GabrielDuf

src/Languages/lang_en.json

@@ -2341,6 +2341,17 @@
   "Manage the Python environment at {0}": "Manage the Python environment at {0}",
   "Unrecognized Python": "Unrecognized Python",
   "The environment variable {0} was updated": "The environment variable {0} was updated",
+  "UniGetUI {0} is available": "UniGetUI {0} is available",
+  "Download the installer in my browser": "Download the installer in my browser",
+  "UniGetUI will update when you quit it": "UniGetUI will update when you quit it",
+  "Update when I quit UniGetUI": "Update when I quit UniGetUI",
+  "More update options": "More update options",
+  "See what's new and choose when to update": "See what's new and choose when to update",
+  "What's new": "What's new",
+  "Preparing UniGetUI {0}": "Preparing UniGetUI {0}",
+  "Nothing will be installed until you choose to update": "Nothing will be installed until you choose to update",
+  "It will be installed when UniGetUI is idle in the background": "It will be installed when UniGetUI is idle in the background",
+  "You have {0} → {1}": "You have {0} → {1}",
   "Agent Skills": "Agent Skills",
   "Skills and plugins for your AI tools": "Skills and plugins for your AI tools",
   "{0} could not be changed": "{0} could not be changed",

src/Shared/AutoUpdater.Helpers.cs

@@ -236,6 +236,32 @@ internal static bool VersionsMatch(string? a, string? b)
         return string.Equals(sa, sb, StringComparison.OrdinalIgnoreCase);
     }
 
+    internal enum SelfUpdateConsent
+    {
+        Waiting,
+        Install,
+        Decline,
+        Skip,
+    }
+
+    internal static SelfUpdateConsent ResolveSelfUpdateConsent(
+        bool installRequested,
+        bool installOnQuitRequested,
+        bool appIsQuitting,
+        bool skipRequested)
+    {
+        if (skipRequested)
+            return SelfUpdateConsent.Skip;
+        if (installRequested)
+            return SelfUpdateConsent.Install;
+        if (appIsQuitting)
+            return installOnQuitRequested ? SelfUpdateConsent.Install : SelfUpdateConsent.Decline;
+        return SelfUpdateConsent.Waiting;
+    }
+
+    internal static bool IsSkippedVersion(string? skippedVersion, string candidateVersion) =>
+        !string.IsNullOrWhiteSpace(skippedVersion) && VersionsMatch(skippedVersion, candidateVersion);
+
     internal static bool IsPreReleaseVersion(string? rawVersion) =>
         TryParseUpdaterVersion(rawVersion, out SemanticVersion parsed) && parsed.IsPreRelease;
 

src/UniGetUI.Avalonia/App.axaml.cs

@@ -20,6 +20,7 @@
 using UniGetUI.Avalonia.Views.DialogPages;
 using UniGetUI.Core.Data;
 using UniGetUI.Core.Logging;
+using UniGetUI.Interface.Enums;
 using UniGetUI.PackageEngine;
 using CoreSettings = global::UniGetUI.Core.SettingsEngine.Settings;
 
@@ -315,9 +316,23 @@ private static async Task StartupAsync(MainWindow mainWindow, string[] args)
             return;
         }
 
+        RouteSelfUpdateToastAction(args);
         await StartupArgumentProcessor.ProcessAsync(args);
     }
 
+    private static void RouteSelfUpdateToastAction(string[] args)
+    {
+        foreach (string arg in args)
+        {
+            string? action = WindowsAppNotificationBridge.TryParseToastLaunchArgument(arg);
+            if (string.Equals(action, NotificationArguments.ShowSelfUpdate, StringComparison.OrdinalIgnoreCase))
+            {
+                WindowsAppNotificationBridge.RaiseActivation(action);
+                return;
+            }
+        }
+    }
+
     private static void HandleSecondaryInstanceArgs(MainWindow mainWindow, string[] args)
     {
         bool isDaemonLaunch = args.Contains(AvaloniaCliHandler.DAEMON);

src/UniGetUI.Avalonia/Infrastructure/AvaloniaAutoUpdater.cs

@@ -73,7 +73,19 @@ internal static partial class AvaloniaAutoUpdater
     /// Fired on the UI thread when a validated installer is ready.  Argument is the
     /// human-readable version string, e.g. "4.2.1".
     /// </summary>
-    public static event Action<string>? UpdateAvailable;
+    public static event Action<string, bool>? UpdateAvailable;
+
+    public static event Action? PendingUpdateChanged;
+
+    public sealed record PendingSelfUpdate(string VersionName, string InstallerDownloadUrl, long InstallerSizeBytes);
+
+    public static PendingSelfUpdate? PendingUpdate { get; private set; }
+
+    private static void SetPendingUpdate(PendingSelfUpdate? pending)
+    {
+        PendingUpdate = pending;
+        Dispatcher.UIThread.Post(() => PendingUpdateChanged?.Invoke());
+    }
 
     /// <summary>
     /// Fired on the UI thread to surface progress/result of an update check or
@@ -367,15 +379,16 @@ private static void OpenUpdateLog()
 
     private static readonly TimeSpan IdleSampleInterval = TimeSpan.FromSeconds(5);
     private static volatile bool _installRequested;
+    private static volatile bool _installOnQuitRequested;
+    private static volatile bool _skipRequested;
     private static readonly HashSet<string> _backgroundInstallTriedVersions = [];
     private static readonly string[] UniGetUIProcessNames = ["UniGetUI", "uniget", "UniGetUI.Avalonia", "WingetUI"];
     private static string? _pendingInstallerPath;
 
     /// <summary>
     /// Set to <c>true</c> when the main window is closing (user quit or hidden path).
-    /// Mirrors WinUI's <c>AutoUpdater.ReleaseLockForAutoupdate_Window</c> — once set,
-    /// a pending installer is allowed to launch even if the user has not yet clicked
-    /// the banner (e.g. user quits via tray while an update is ready).
+    /// Once set, a pending installer launches only if the user asked to update when
+    /// UniGetUI quits; otherwise the pending update is dropped without installing.
     /// </summary>
     public static bool ReleaseLockForAutoupdate_Window;
 
@@ -393,6 +406,25 @@ public static void TriggerInstall()
         LogUpdateInfo("Auto-updater: TriggerInstall invoked (user clicked Update now).");
         _installRequested = true;
     }
+
+    public static bool IsInstallOnQuitRequested => _installOnQuitRequested;
+
+    public static void RequestInstallOnQuit()
+    {
+        LogUpdateInfo("Auto-updater: the user asked to install the update when UniGetUI quits.");
+        _installOnQuitRequested = true;
+        Dispatcher.UIThread.Post(() => PendingUpdateChanged?.Invoke());
+    }
+
+    public static void SkipVersion(string versionName)
+    {
+        LogUpdateInfo($"Auto-updater: the user skipped version {versionName}.");
+        Settings.SetValue(Settings.K.SkippedUniGetUIVersion, versionName);
+        _installOnQuitRequested = false;
+        _skipRequested = true;
+        DismissUpdateBanner();
+        SetPendingUpdate(null);
+    }
     public static async Task UpdateCheckLoopAsync()
     {
         if (Settings.Get(Settings.K.DisableAutoUpdateWingetUI))
@@ -462,7 +494,7 @@ internal static Task<bool> CheckAndInstallUpdatesAsync(bool autoLaunch = false,
             onJoinedActiveAttempt: () =>
                 LogUpdateInfo("Auto-updater: an update attempt is already in progress; reusing active attempt."),
             onManualJoinWhileAwaitingConsent: versionName =>
-                Dispatcher.UIThread.Post(() => UpdateAvailable?.Invoke(versionName)),
+                Dispatcher.UIThread.Post(() => UpdateAvailable?.Invoke(versionName, true)),
             onManualJoinWhileBusy: () =>
                 RaiseStatus(
                     CoreTools.Translate("We are checking for updates."),
@@ -553,6 +585,15 @@ bool IsChannelObsolete() =>
             RecordTargetVersion(candidate.VersionName);
             LogUpdateInfo($"Update to UniGetUI {candidate.VersionName} is available.");
 
+            if (!IsManual() && AutoUpdaterHelpers.IsSkippedVersion(Settings.GetValue(Settings.K.SkippedUniGetUIVersion), candidate.VersionName))
+            {
+                LogUpdateInfo($"Auto-updater: version {candidate.VersionName} was skipped by the user, not offering it.");
+                if (OperatingSystem.IsWindows())
+                    WindowsAppNotificationBridge.RemoveSelfUpdateAvailableNotification();
+                MarkAttemptFinished("version skipped by the user");
+                return true;
+            }
+
             if (OperatingSystem.IsMacOS() && ReportMacUpdateTargetIfBlocked(ResolveMacUpdateTarget()))
             {
                 return false;
@@ -584,7 +625,7 @@ bool IsChannelObsolete() =>
                     message => LogUpdateWarn(message)
                 );
                 LogUpdateInfo("Cached valid installer found, preparing to launch...");
-                return await PrepareAndLaunchAsync(attempt, installerPath, candidate.InstallerHash, candidate.VersionName, autoLaunch, IsManual());
+                return await PrepareAndLaunchAsync(attempt, installerPath, candidate.InstallerHash, candidate.VersionName, candidate.InstallerDownloadUrl, autoLaunch, IsManual());
             }
 
             string installerValidationFailureMarkerPath =
@@ -619,9 +660,11 @@ bool IsChannelObsolete() =>
 
             RaiseStatus(
                 CoreTools.Translate(
-                    "UniGetUI version {0} is being downloaded.",
+                    "Preparing UniGetUI {0}",
                     candidate.VersionName.ToString(CultureInfo.InvariantCulture)),
-                CoreTools.Translate("This may take a minute or two"),
+                Settings.Get(Settings.K.InstallUniGetUIUpdatesWhenIdle)
+                    ? CoreTools.Translate("It will be installed when UniGetUI is idle in the background")
+                    : CoreTools.Translate("Nothing will be installed until you choose to update"),
                 InfoBarSeverity.Informational,
                 isClosable: false);
 
@@ -664,7 +707,7 @@ await CheckInstallerHashAsync(downloadedInstallerPath, candidate.InstallerHash,
                     message => LogUpdateWarn(message)
                 );
                 LogUpdateInfo("Downloaded installer is valid, preparing to launch...");
-                return await PrepareAndLaunchAsync(attempt, installerPath, candidate.InstallerHash, candidate.VersionName, autoLaunch, IsManual());
+                return await PrepareAndLaunchAsync(attempt, installerPath, candidate.InstallerHash, candidate.VersionName, candidate.InstallerDownloadUrl, autoLaunch, IsManual());
             }
 
             UpdaterDownloadEngine.RecordFailure(
@@ -759,6 +802,7 @@ private static async Task<bool> PrepareAndLaunchAsync(
         string installerPath,
         string installerHash,
         string versionName,
+        string installerDownloadUrl,
         bool autoLaunch,
         bool manualCheck)
     {
@@ -775,10 +819,13 @@ bool IsChannelObsolete() =>
 
         _pendingInstallerPath = installerPath;
         _installRequested = false;
+        _installOnQuitRequested = false;
+        _skipRequested = false;
         ReleaseLockForAutoupdate_Notification = false;
+        SetPendingUpdate(new PendingSelfUpdate(versionName, installerDownloadUrl, GetFileSize(installerPath)));
 
         // Notify UI (update banner + toast)
-        Dispatcher.UIThread.Post(() => UpdateAvailable?.Invoke(versionName));
+        Dispatcher.UIThread.Post(() => UpdateAvailable?.Invoke(versionName, manualCheck));
         if (OperatingSystem.IsWindows())
             WindowsAppNotificationBridge.ShowSelfUpdateAvailableNotification(versionName);
         else if (OperatingSystem.IsMacOS())
@@ -817,8 +864,28 @@ bool IsChannelObsolete() =>
                     int idleChecks = 0;
                     DateTime nextIdleSample = DateTime.UtcNow + IdleSampleInterval;
 
-                    while (!_installRequested && !ReleaseLockForAutoupdate_Window && !ReleaseLockForAutoupdate_Notification)
+                    while (true)
                     {
+                        AutoUpdaterHelpers.SelfUpdateConsent consent = AutoUpdaterHelpers.ResolveSelfUpdateConsent(
+                            _installRequested || ReleaseLockForAutoupdate_Notification,
+                            _installOnQuitRequested,
+                            ReleaseLockForAutoupdate_Window,
+                            _skipRequested);
+                        if (consent is AutoUpdaterHelpers.SelfUpdateConsent.Install)
+                            break;
+                        if (consent is AutoUpdaterHelpers.SelfUpdateConsent.Skip)
+                        {
+                            MarkAttemptFinished("version skipped by the user");
+                            return true;
+                        }
+                        if (consent is AutoUpdaterHelpers.SelfUpdateConsent.Decline)
+                        {
+                            LogUpdateInfo("Auto-updater: UniGetUI is quitting and the user did not ask to update — not installing.");
+                            DismissUpdateBanner();
+                            MarkAttemptFinished("not installed - the user did not ask to update before quitting");
+                            return true;
+                        }
+
                         if (IsChannelObsolete())
                         {
                             LogUpdateInfo("Auto-updater: update channel changed while waiting for user — aborting.");
@@ -907,6 +974,20 @@ bool IsChannelObsolete() =>
             if (installingInBackground)
                 AbstractOperation.HoldNewOperations = false;
             InstallerHandoffs.Complete(handoff);
+            SetPendingUpdate(null);
+        }
+    }
+
+    private static long GetFileSize(string path)
+    {
+        try
+        {
+            return new FileInfo(path).Length;
+        }
+        catch (Exception ex)
+        {
+            LogUpdateWarn($"Could not read the size of {path}: {ex.Message}");
+            return 0;
         }
     }
 

src/UniGetUI.Avalonia/Infrastructure/MacOsNotificationBridge.cs

@@ -160,7 +160,8 @@ public static void ShowSelfUpdateAvailableNotification(string newVersion)
             DeliverNotification(
                 CoreTools.Translate("{0} can be updated to version {1}", "UniGetUI", newVersion),
                 CoreTools.Translate("You have currently version {0} installed", CoreData.VersionName),
-                MainWindow.RuntimeNotificationLevel.Success);
+                MainWindow.RuntimeNotificationLevel.Success,
+                allowInAppFallback: false);
         }
         catch (Exception ex)
         {

src/UniGetUI.Avalonia/Infrastructure/ReleaseNotesLinks.cs

@@ -0,0 +1,42 @@
+using UniGetUI.Core.Data;
+
+namespace UniGetUI.Avalonia.Infrastructure;
+
+internal static class ReleaseNotesLinks
+{
+    public static Uri PageUri(bool darkTheme) =>
+        new($"{CoreData.ReleaseNotesUrl}?theme={Theme(darkTheme)}");
+
+    public static Uri UpdateDialogUri(bool darkTheme) =>
+        new($"{CoreData.ReleaseNotesUrl}?theme={Theme(darkTheme)}&utm_source=unigetui&utm_medium=app&utm_campaign=self-update");
+
+    private static string Theme(bool darkTheme) => darkTheme ? "dark-neutral" : "light";
+
+    public static bool IsReleaseNotesPage(Uri? uri)
+    {
+        if (uri is null || !uri.IsAbsoluteUri)
+            return false;
+
+        Uri page = new(CoreData.ReleaseNotesUrl);
+        return string.Equals(uri.Scheme, page.Scheme, StringComparison.OrdinalIgnoreCase)
+            && string.Equals(uri.Host, page.Host, StringComparison.OrdinalIgnoreCase)
+            && string.Equals(uri.AbsolutePath, page.AbsolutePath, StringComparison.OrdinalIgnoreCase);
+    }
+
+    public static string BrowserDownloadUrl(string versionName, string installerDownloadUrl, bool isWindows) =>
+        isWindows && !string.IsNullOrWhiteSpace(installerDownloadUrl)
+            ? installerDownloadUrl
+            : CoreData.GetGitHubReleasePageUrlFromTag(CoreData.GetGitHubReleaseTag(ShortVersion(versionName)));
+
+    public static string ShortVersion(string versionName)
+    {
+        string trimmed = versionName.Trim();
+        return Version.TryParse(trimmed, out Version? parsed) && parsed.Revision == 0
+            ? $"{parsed.Major}.{parsed.Minor}.{parsed.Build}"
+            : trimmed;
+    }
+
+    public static bool CanOpenInBrowser(Uri? uri) =>
+        uri is { IsAbsoluteUri: true }
+        && (uri.Scheme == Uri.UriSchemeHttps || uri.Scheme == Uri.UriSchemeHttp);
+}

src/UniGetUI.Avalonia/Infrastructure/WindowsAppNotificationBridge.cs

@@ -233,7 +233,8 @@ public static void ShowSelfUpdateAvailableNotification(string newVersion)
                 CoreTools.Translate("{0} can be updated to version {1}", "UniGetUI", newVersion),
                 CoreTools.Translate("You have currently version {0} installed", CoreData.VersionName),
                 MainWindow.RuntimeNotificationLevel.Success,
-                launchAction: NotificationArguments.Show,
+                launchAction: NotificationArguments.ShowSelfUpdate,
+                allowInAppFallback: false,
                 tag: SelfUpdateToastTag);
         }
         catch (Exception ex)