From 0e0ce0c9f3a5403014b6459290b0994099404275 Mon Sep 17 00:00:00 2001
From: Owen McGirr <o.a.mcgirr@gmail.com>
Date: Tue, 21 Jul 2026 11:18:25 +0100
Subject: [PATCH] Add one-click update installation

---
 src/SwitchifyPc.App/App.xaml.cs               |  14 +-
 src/SwitchifyPc.App/MainWindow.xaml           |   3 +-
 src/SwitchifyPc.App/MainWindow.xaml.cs        |  42 ++-
 src/SwitchifyPc.App/SettingsWindow.xaml       |  19 +-
 src/SwitchifyPc.App/SettingsWindow.xaml.cs    |  50 ++--
 src/SwitchifyPc.Core/Ui/MainWindowCopy.cs     |  50 +++-
 .../Ui/MainWindowViewModel.cs                 |   5 +-
 src/SwitchifyPc.Core/Ui/SettingsController.cs |   7 +
 src/SwitchifyPc.Core/Ui/SettingsViewModel.cs  |  64 ++++-
 src/SwitchifyPc.Core/Ui/UpdateUiCopy.cs       |  37 +++
 src/SwitchifyPc.Core/Updates/UpdateModels.cs  |  43 ++-
 src/SwitchifyPc.Core/Updates/UpdateService.cs | 132 ++++++++-
 src/SwitchifyPc.Tests/MainWindowCopyTests.cs  |  50 +++-
 src/SwitchifyPc.Tests/MainWindowTests.cs      |  51 ++++
 .../MainWindowViewModelTests.cs               |   3 +-
 .../SettingsControllerTests.cs                |  43 +++
 .../SettingsViewModelTests.cs                 |  65 ++++-
 src/SwitchifyPc.Tests/SettingsWindowTests.cs  |  33 +++
 src/SwitchifyPc.Tests/UpdateServiceTests.cs   | 271 +++++++++++++++++-
 19 files changed, 914 insertions(+), 68 deletions(-)
 create mode 100644 src/SwitchifyPc.Core/Ui/UpdateUiCopy.cs

diff --git a/src/SwitchifyPc.App/App.xaml.cs b/src/SwitchifyPc.App/App.xaml.cs
index e1ca353..17a2796 100644
--- a/src/SwitchifyPc.App/App.xaml.cs
+++ b/src/SwitchifyPc.App/App.xaml.cs
@@ -182,7 +182,7 @@ private Window CreateMainWindow()
             mainWindowViewModel,
             ShowSettingsWindow,
             ShowSetupGuideWindow,
-            ShowSettingsWindow,
+            InstallAvailableUpdateAsync,
             DisconnectBluetoothDevices,
             AcceptPairingApprovalAsync,
             RejectPairingApproval);
@@ -325,6 +325,12 @@ private UpdateService CreateUpdateService()
             OnStateChanged: UpdateMainWindowState));
     }
 
+    private Task<UpdateApplyResult> InstallAvailableUpdateAsync()
+    {
+        return updateService?.InstallAvailableUpdateAsync()
+            ?? Task.FromResult(UpdateApplyResult.DownloadFailure(UpdateFailureReason.NotAvailable));
+    }
+
     private PairingApprovalManager CreatePairingApprovalManager()
     {
         return new PairingApprovalManager(new JsonPairingStore(Path.Combine(UserDataDirectory(), "pairing-state.json")));
@@ -743,7 +749,11 @@ private static bool IsInstalledApp()
     private void UpdateMainWindowState(UpdateState state)
     {
         RecordUpdateStateDiagnostic(state);
-        Dispatcher.BeginInvoke(() => mainWindowViewModel.SetUpdateState(state));
+        Dispatcher.BeginInvoke(() =>
+        {
+            mainWindowViewModel.SetUpdateState(state);
+            settingsWindow?.ApplyUpdateState(state);
+        });
     }
 
     private void UpdateBluetoothState(BluetoothStatus status)
diff --git a/src/SwitchifyPc.App/MainWindow.xaml b/src/SwitchifyPc.App/MainWindow.xaml
index 4e03297..98a1b4b 100644
--- a/src/SwitchifyPc.App/MainWindow.xaml
+++ b/src/SwitchifyPc.App/MainWindow.xaml
@@ -314,7 +314,8 @@
                             <Button Grid.Column="1"
                                     Margin="16,0,0,0"
                                     Content="{Binding UpdateBannerButtonText}"
-                                    Click="OpenUpdates_Click" />
+                                    IsEnabled="{Binding IsUpdateBannerButtonEnabled}"
+                                    Click="InstallUpdate_Click" />
                         </Grid>
                     </Border>
 
diff --git a/src/SwitchifyPc.App/MainWindow.xaml.cs b/src/SwitchifyPc.App/MainWindow.xaml.cs
index 49295ac..49944de 100644
--- a/src/SwitchifyPc.App/MainWindow.xaml.cs
+++ b/src/SwitchifyPc.App/MainWindow.xaml.cs
@@ -1,5 +1,7 @@
 using System.Windows;
 using SwitchifyPc.Core.Ui;
+using SwitchifyPc.Core.Updates;
+using WpfMessageBox = System.Windows.MessageBox;
 
 namespace SwitchifyPc.App;
 
@@ -7,23 +9,24 @@ public partial class MainWindow : Window
 {
     private readonly Action? openSettings;
     private readonly Action? openSetupGuide;
-    private readonly Action? openUpdates;
+    private readonly Func<Task<UpdateApplyResult>>? installUpdate;
     private readonly Action? disconnectDevices;
     private readonly Func<string, Task>? acceptPairingApproval;
     private readonly Action<string>? rejectPairingApproval;
+    private bool isInstallingUpdate;
 
     public MainWindow(
         MainWindowViewModel? viewModel = null,
         Action? openSettings = null,
         Action? openSetupGuide = null,
-        Action? openUpdates = null,
+        Func<Task<UpdateApplyResult>>? installUpdate = null,
         Action? disconnectDevices = null,
         Func<string, Task>? acceptPairingApproval = null,
         Action<string>? rejectPairingApproval = null)
     {
         this.openSettings = openSettings;
         this.openSetupGuide = openSetupGuide;
-        this.openUpdates = openUpdates;
+        this.installUpdate = installUpdate;
         this.disconnectDevices = disconnectDevices;
         this.acceptPairingApproval = acceptPairingApproval;
         this.rejectPairingApproval = rejectPairingApproval;
@@ -41,9 +44,38 @@ private void OpenSetupGuide_Click(object sender, RoutedEventArgs e)
         openSetupGuide?.Invoke();
     }
 
-    private void OpenUpdates_Click(object sender, RoutedEventArgs e)
+    private async void InstallUpdate_Click(object sender, RoutedEventArgs e)
     {
-        openUpdates?.Invoke();
+        if (installUpdate is null || isInstallingUpdate) return;
+
+        isInstallingUpdate = true;
+        try
+        {
+            UpdateApplyResult result = await installUpdate();
+            if (!result.Ok)
+            {
+                WpfMessageBox.Show(
+                    UpdateUiCopy.ApplyFailureMessage(result),
+                    "Update installer",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Warning);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+        }
+        catch
+        {
+            WpfMessageBox.Show(
+                "The update could not be installed.",
+                "Update installer",
+                MessageBoxButton.OK,
+                MessageBoxImage.Warning);
+        }
+        finally
+        {
+            isInstallingUpdate = false;
+        }
     }
 
     private void Disconnect_Click(object sender, RoutedEventArgs e)
diff --git a/src/SwitchifyPc.App/SettingsWindow.xaml b/src/SwitchifyPc.App/SettingsWindow.xaml
index 79c3599..7b99159 100644
--- a/src/SwitchifyPc.App/SettingsWindow.xaml
+++ b/src/SwitchifyPc.App/SettingsWindow.xaml
@@ -727,7 +727,7 @@
                             <StackPanel>
                                 <TextBlock Text="Updates" Style="{StaticResource SectionTitle}" />
                                 <TextBlock Margin="0,6,0,0"
-                                           Text="Check, download, and open Switchify PC updates."
+                                           Text="Check for and install Switchify PC updates."
                                            Style="{StaticResource MutedText}" />
                                 <Border Margin="0,16,0,0" Style="{StaticResource SubtlePanel}">
                                     <StackPanel>
@@ -744,18 +744,17 @@
                                                        Style="{StaticResource MutedText}" />
                                         </StackPanel>
                                         <WrapPanel Margin="0,14,0,0">
-                                            <Button Content="Check for updates"
+                                            <Button Content="{Binding UpdateCheckActionText}"
                                                     Margin="0,0,10,8"
-                                                    Click="CheckForUpdates_Click" />
-                                            <Button Content="Download update"
+                                                    Click="CheckForUpdates_Click"
+                                                    IsEnabled="{Binding CanCheckForUpdates}"
+                                                    Visibility="{Binding IsCheckUpdateActionVisible, Converter={StaticResource BooleanToVisibilityConverter}}" />
+                                            <Button Content="{Binding UpdatePrimaryActionText}"
                                                     Margin="0,0,10,8"
-                                                    Click="DownloadUpdate_Click"
-                                                    IsEnabled="{Binding CanDownloadUpdate}" />
-                                            <Button Content="Install update"
-                                                    Margin="0,0,10,8"
-                                                    Click="InstallUpdate_Click"
+                                                    Click="InstallAvailableUpdate_Click"
                                                     Style="{StaticResource PrimaryButton}"
-                                                    IsEnabled="{Binding CanInstallUpdate}" />
+                                                    IsEnabled="{Binding CanRunUpdatePrimaryAction}"
+                                                    Visibility="{Binding IsInstallUpdateActionVisible, Converter={StaticResource BooleanToVisibilityConverter}}" />
                                         </WrapPanel>
                                     </StackPanel>
                                 </Border>
diff --git a/src/SwitchifyPc.App/SettingsWindow.xaml.cs b/src/SwitchifyPc.App/SettingsWindow.xaml.cs
index cbaa81b..915f617 100644
--- a/src/SwitchifyPc.App/SettingsWindow.xaml.cs
+++ b/src/SwitchifyPc.App/SettingsWindow.xaml.cs
@@ -14,6 +14,7 @@ public partial class SettingsWindow : Window
     private bool isLoaded;
     private bool isApplyingSettings;
     private bool settingsLoaded;
+    private bool isInstallingUpdate;
 
     public SettingsWindow(SettingsController controller) : this(controller.ViewModel)
     {
@@ -190,30 +191,41 @@ await RunActionAsync(
             "Updates could not be checked.");
     }
 
-    private async void DownloadUpdate_Click(object sender, RoutedEventArgs e)
+    private async void InstallAvailableUpdate_Click(object sender, RoutedEventArgs e)
     {
-        if (controller is null) return;
-        await RunActionAsync(
-            () => controller.DownloadUpdateAsync(),
-            "The update could not be downloaded.");
+        if (controller is null || isInstallingUpdate) return;
+
+        isInstallingUpdate = true;
+        try
+        {
+            await RunActionAsync(async () =>
+            {
+                UpdateApplyResult result = await controller.InstallAvailableUpdateAsync();
+                if (!result.Ok)
+                {
+                    WpfMessageBox.Show(
+                        UpdateUiCopy.ApplyFailureMessage(result),
+                        "Update installer",
+                        MessageBoxButton.OK,
+                        MessageBoxImage.Warning);
+                }
+            }, "The update could not be installed.");
+        }
+        finally
+        {
+            isInstallingUpdate = false;
+        }
     }
 
-    private async void InstallUpdate_Click(object sender, RoutedEventArgs e)
+    public void ApplyUpdateState(UpdateState state)
     {
-        if (controller is null) return;
-
-        await RunActionAsync(async () =>
+        if (!Dispatcher.CheckAccess())
         {
-            UpdateInstallResult result = await controller.InstallDownloadedUpdateAsync();
-            if (!result.Ok)
-            {
-                WpfMessageBox.Show(
-                    SettingsViewModel.InstallMessage(result.Reason),
-                    "Update installer",
-                    MessageBoxButton.OK,
-                    MessageBoxImage.Warning);
-            }
-        }, "The update installer could not be opened.");
+            Dispatcher.BeginInvoke(() => ApplyUpdateState(state));
+            return;
+        }
+
+        controller?.ApplyUpdateState(state);
     }
 
     private void SaveIfReady(Action save)
diff --git a/src/SwitchifyPc.Core/Ui/MainWindowCopy.cs b/src/SwitchifyPc.Core/Ui/MainWindowCopy.cs
index 4e28669..ba1c1b1 100644
--- a/src/SwitchifyPc.Core/Ui/MainWindowCopy.cs
+++ b/src/SwitchifyPc.Core/Ui/MainWindowCopy.cs
@@ -15,7 +15,7 @@ public enum DesktopUiState
 
 public sealed record BluetoothPrimaryCopy(string Title, string Body, string Tone);
 
-public sealed record UpdateBannerCopy(string Title, string Body, string Tone, string ButtonText);
+public sealed record UpdateBannerCopy(string Title, string Body, string Tone, string ButtonText, bool ButtonEnabled);
 
 public static class MainWindowCopy
 {
@@ -249,22 +249,64 @@ public static string BluetoothRecentError(BluetoothStatus? status)
     public static UpdateBannerCopy? UpdateBanner(UpdateState? state)
     {
         if (state is null) return null;
+        if (state.IsApplyingUpdate && state.Download.Status == UpdateDownloadStatus.Downloaded)
+        {
+            return new UpdateBannerCopy(
+                "Installing update...",
+                "The update installer is opening. Switchify PC will restart when installation finishes.",
+                "downloaded",
+                "Installing...",
+                false);
+        }
+
+        if (state.Download.Status == UpdateDownloadStatus.Downloading)
+        {
+            return new UpdateBannerCopy(
+                "Downloading update...",
+                "Switchify PC is downloading the update.",
+                "available",
+                "Downloading...",
+                false);
+        }
+
+        if (state.LastApplyResult is { Ok: false, FailureStage: UpdateApplyFailureStage.Install } failure)
+        {
+            return new UpdateBannerCopy(
+                "Update installation failed",
+                UpdateUiCopy.ApplyFailureMessage(failure),
+                "available",
+                "Retry update",
+                !state.IsApplyingUpdate);
+        }
+
+        if (state.Download.Status == UpdateDownloadStatus.DownloadFailed)
+        {
+            return new UpdateBannerCopy(
+                "Update download failed",
+                "The update could not be downloaded. Try again.",
+                "available",
+                "Retry update",
+                !state.IsApplyingUpdate);
+        }
+
         if (state.Download.Status == UpdateDownloadStatus.Downloaded)
         {
             return new UpdateBannerCopy(
                 "Update ready to install",
                 "The update has been downloaded and is ready to install.",
                 "downloaded",
-                "Open updates");
+                "Install update",
+                !state.IsApplyingUpdate);
         }
 
         if (state.Info.Status == UpdateCheckStatus.UpdateAvailable)
         {
             return new UpdateBannerCopy(
                 "Update available",
-                "A new Switchify PC update is ready to download.",
+                "A new Switchify PC update is ready to install.",
                 "available",
-                "Open updates");
+                "Install update",
+                !state.IsApplyingUpdate);
         }
 
         return null;
diff --git a/src/SwitchifyPc.Core/Ui/MainWindowViewModel.cs b/src/SwitchifyPc.Core/Ui/MainWindowViewModel.cs
index 5f32f65..23fe802 100644
--- a/src/SwitchifyPc.Core/Ui/MainWindowViewModel.cs
+++ b/src/SwitchifyPc.Core/Ui/MainWindowViewModel.cs
@@ -61,7 +61,9 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged
 
     public string UpdateBannerBody => MainWindowCopy.UpdateBanner(updateState)?.Body ?? "";
 
-    public string UpdateBannerButtonText => MainWindowCopy.UpdateBanner(updateState)?.ButtonText ?? "Open updates";
+    public string UpdateBannerButtonText => MainWindowCopy.UpdateBanner(updateState)?.ButtonText ?? "Install update";
+
+    public bool IsUpdateBannerButtonEnabled => MainWindowCopy.UpdateBanner(updateState)?.ButtonEnabled ?? false;
 
     public string UpdateBannerTone => MainWindowCopy.UpdateBanner(updateState)?.Tone ?? "";
 
@@ -83,6 +85,7 @@ public void SetUpdateState(UpdateState state)
         OnPropertyChanged(nameof(UpdateBannerTitle));
         OnPropertyChanged(nameof(UpdateBannerBody));
         OnPropertyChanged(nameof(UpdateBannerButtonText));
+        OnPropertyChanged(nameof(IsUpdateBannerButtonEnabled));
         OnPropertyChanged(nameof(UpdateBannerTone));
     }
 
diff --git a/src/SwitchifyPc.Core/Ui/SettingsController.cs b/src/SwitchifyPc.Core/Ui/SettingsController.cs
index 58f7f51..249bd00 100644
--- a/src/SwitchifyPc.Core/Ui/SettingsController.cs
+++ b/src/SwitchifyPc.Core/Ui/SettingsController.cs
@@ -147,6 +147,13 @@ public async Task<UpdateInstallResult> InstallDownloadedUpdateAsync(Cancellation
         return result;
     }
 
+    public async Task<UpdateApplyResult> InstallAvailableUpdateAsync(CancellationToken cancellationToken = default)
+    {
+        UpdateApplyResult result = await updates.InstallAvailableUpdateAsync(cancellationToken).ConfigureAwait(false);
+        viewModel.SetUpdateState(updates.GetState());
+        return result;
+    }
+
     public void ApplyUpdateState(UpdateState state)
     {
         viewModel.SetUpdateState(state);
diff --git a/src/SwitchifyPc.Core/Ui/SettingsViewModel.cs b/src/SwitchifyPc.Core/Ui/SettingsViewModel.cs
index 5bef975..45c9c6f 100644
--- a/src/SwitchifyPc.Core/Ui/SettingsViewModel.cs
+++ b/src/SwitchifyPc.Core/Ui/SettingsViewModel.cs
@@ -172,7 +172,10 @@ public string StartWithSystemMessage
 
     public string UpdateStatusMessage => UpdateCheckMessage(updateState.Info);
 
-    public string? UpdateDownloadMessage => DownloadMessage(updateState.Download);
+    public string? UpdateDownloadMessage =>
+        updateState.LastApplyResult is { Ok: false, FailureStage: UpdateApplyFailureStage.Install } failure
+            ? UpdateUiCopy.ApplyFailureMessage(failure)
+            : DownloadMessage(updateState.Download);
 
     public bool IsUpdateDownloading => updateState.Download.Status == UpdateDownloadStatus.Downloading;
 
@@ -182,11 +185,50 @@ public string StartWithSystemMessage
 
     public string UpdateDownloadProgressText => DownloadProgressText(updateState.Download);
 
+    public string UpdatePrimaryActionText
+    {
+        get
+        {
+            if (updateState.Download.Status == UpdateDownloadStatus.Downloading) return "Downloading...";
+            if (updateState.IsApplyingUpdate && updateState.Download.Status == UpdateDownloadStatus.Downloaded) return "Installing...";
+            if (updateState.LastApplyResult is { Ok: false, FailureStage: UpdateApplyFailureStage.Install }) return "Retry update";
+            if (updateState.Download.Status == UpdateDownloadStatus.DownloadFailed) return "Retry update";
+            return "Install update";
+        }
+    }
+
+    public string UpdateCheckActionText =>
+        updateState.Info.Status == UpdateCheckStatus.Checking ? "Checking..." : "Check for updates";
+
+    public bool CanRunUpdatePrimaryAction
+    {
+        get
+        {
+            if (updateState.IsApplyingUpdate) return false;
+            if (updateState.Download.Status == UpdateDownloadStatus.Downloading) return false;
+            return updateState.Info.Status == UpdateCheckStatus.UpdateAvailable ||
+                updateState.Download.Status is UpdateDownloadStatus.DownloadFailed or UpdateDownloadStatus.Downloaded;
+        }
+    }
+
+    public bool IsInstallUpdateAction =>
+        updateState.Info.Status == UpdateCheckStatus.UpdateAvailable ||
+        updateState.Download.Status is UpdateDownloadStatus.Downloading or UpdateDownloadStatus.DownloadFailed or UpdateDownloadStatus.Downloaded ||
+        updateState.IsApplyingUpdate;
+
+    public bool IsCheckUpdateActionVisible => !IsInstallUpdateAction;
+
+    public bool IsInstallUpdateActionVisible => IsInstallUpdateAction;
+
+    public bool CanCheckForUpdates =>
+        IsCheckUpdateActionVisible && updateState.Info.Status != UpdateCheckStatus.Checking;
+
     public bool CanDownloadUpdate =>
+        !updateState.IsApplyingUpdate &&
         updateState.Info.Status == UpdateCheckStatus.UpdateAvailable &&
         updateState.Download.Status is UpdateDownloadStatus.Idle or UpdateDownloadStatus.DownloadFailed;
 
-    public bool CanInstallUpdate => updateState.Download.Status == UpdateDownloadStatus.Downloaded;
+    public bool CanInstallUpdate => !updateState.IsApplyingUpdate && updateState.Download.Status == UpdateDownloadStatus.Downloaded;
 
     public void SetStartupSettings(SystemStartupSettings settings)
     {
@@ -278,6 +320,13 @@ public void SetUpdateState(UpdateState state)
         OnPropertyChanged(nameof(IsUpdateDownloadIndeterminate));
         OnPropertyChanged(nameof(UpdateDownloadPercent));
         OnPropertyChanged(nameof(UpdateDownloadProgressText));
+        OnPropertyChanged(nameof(UpdatePrimaryActionText));
+        OnPropertyChanged(nameof(UpdateCheckActionText));
+        OnPropertyChanged(nameof(CanRunUpdatePrimaryAction));
+        OnPropertyChanged(nameof(IsInstallUpdateAction));
+        OnPropertyChanged(nameof(IsCheckUpdateActionVisible));
+        OnPropertyChanged(nameof(IsInstallUpdateActionVisible));
+        OnPropertyChanged(nameof(CanCheckForUpdates));
         OnPropertyChanged(nameof(CanDownloadUpdate));
         OnPropertyChanged(nameof(CanInstallUpdate));
     }
@@ -353,16 +402,7 @@ public static string DownloadProgressText(UpdateDownloadProgress download)
 
     public static string InstallMessage(UpdateInstallFailureReason? reason)
     {
-        return reason switch
-        {
-            UpdateInstallFailureReason.NotDownloaded => "The update is not downloaded yet.",
-            UpdateInstallFailureReason.NotPackaged => "Updates are only available in the installed app.",
-            UpdateInstallFailureReason.NotSupported => "Updates are only supported on Windows.",
-            UpdateInstallFailureReason.Cancelled => "The update was cancelled.",
-            UpdateInstallFailureReason.InstallerUnavailable => "The downloaded installer could not be found. Download the update again.",
-            UpdateInstallFailureReason.InstallerLaunchFailed => "The update installer could not be opened. Download the update again or run the installer manually.",
-            _ => "The update installer could not be opened."
-        };
+        return UpdateUiCopy.InstallFailureMessage(reason);
     }
 
     private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
diff --git a/src/SwitchifyPc.Core/Ui/UpdateUiCopy.cs b/src/SwitchifyPc.Core/Ui/UpdateUiCopy.cs
new file mode 100644
index 0000000..b10bdc5
--- /dev/null
+++ b/src/SwitchifyPc.Core/Ui/UpdateUiCopy.cs
@@ -0,0 +1,37 @@
+using SwitchifyPc.Core.Updates;
+
+namespace SwitchifyPc.Core.Ui;
+
+public static class UpdateUiCopy
+{
+    public static string ApplyFailureMessage(UpdateApplyResult result)
+    {
+        if (result.FailureStage == UpdateApplyFailureStage.Download)
+        {
+            return result.DownloadFailureReason switch
+            {
+                UpdateFailureReason.NotPackaged => "Updates are only available in the installed app.",
+                UpdateFailureReason.NotSupported => "Updates are only supported on Windows.",
+                UpdateFailureReason.NotAvailable => "No update is currently available.",
+                UpdateFailureReason.InvalidUpdate => "The downloaded update was invalid. Try again.",
+                _ => "The update could not be downloaded. Check your connection and try again."
+            };
+        }
+
+        return InstallFailureMessage(result.InstallFailureReason);
+    }
+
+    public static string InstallFailureMessage(UpdateInstallFailureReason? reason)
+    {
+        return reason switch
+        {
+            UpdateInstallFailureReason.NotDownloaded => "The update is not downloaded yet.",
+            UpdateInstallFailureReason.NotPackaged => "Updates are only available in the installed app.",
+            UpdateInstallFailureReason.NotSupported => "Updates are only supported on Windows.",
+            UpdateInstallFailureReason.Cancelled => "The update was cancelled.",
+            UpdateInstallFailureReason.InstallerUnavailable => "The downloaded installer could not be found. Try the update again.",
+            UpdateInstallFailureReason.InstallerLaunchFailed => "The update installer could not be opened. Try again.",
+            _ => "The update installer could not be opened."
+        };
+    }
+}
diff --git a/src/SwitchifyPc.Core/Updates/UpdateModels.cs b/src/SwitchifyPc.Core/Updates/UpdateModels.cs
index 829eafb..050dae5 100644
--- a/src/SwitchifyPc.Core/Updates/UpdateModels.cs
+++ b/src/SwitchifyPc.Core/Updates/UpdateModels.cs
@@ -36,6 +36,12 @@ public enum UpdateInstallFailureReason
     InstallerLaunchFailed
 }
 
+public enum UpdateApplyFailureStage
+{
+    Download,
+    Install
+}
+
 public sealed record UpdateInfo(
     string CurrentVersion,
     string? LatestVersion,
@@ -52,7 +58,11 @@ public sealed record UpdateDownloadProgress(
     int? Percent,
     UpdateFailureReason? Reason = null);
 
-public sealed record UpdateState(UpdateInfo Info, UpdateDownloadProgress Download)
+public sealed record UpdateState(
+    UpdateInfo Info,
+    UpdateDownloadProgress Download,
+    bool IsApplyingUpdate = false,
+    UpdateApplyResult? LastApplyResult = null)
 {
     public static UpdateState CreateInitial(string currentVersion) =>
         new(
@@ -91,6 +101,37 @@ public sealed record UpdateInstallResult(bool Ok, UpdateInstallFailureReason? Re
     public static UpdateInstallResult Failure(UpdateInstallFailureReason reason) => new(false, reason);
 }
 
+public sealed record UpdateApplyResult
+{
+    private UpdateApplyResult(
+        bool ok,
+        UpdateApplyFailureStage? failureStage = null,
+        UpdateFailureReason? downloadFailureReason = null,
+        UpdateInstallFailureReason? installFailureReason = null)
+    {
+        Ok = ok;
+        FailureStage = failureStage;
+        DownloadFailureReason = downloadFailureReason;
+        InstallFailureReason = installFailureReason;
+    }
+
+    public bool Ok { get; }
+
+    public UpdateApplyFailureStage? FailureStage { get; }
+
+    public UpdateFailureReason? DownloadFailureReason { get; }
+
+    public UpdateInstallFailureReason? InstallFailureReason { get; }
+
+    public static UpdateApplyResult Success() => new(true);
+
+    public static UpdateApplyResult DownloadFailure(UpdateFailureReason reason) =>
+        new(false, UpdateApplyFailureStage.Download, downloadFailureReason: reason);
+
+    public static UpdateApplyResult InstallFailure(UpdateInstallFailureReason reason) =>
+        new(false, UpdateApplyFailureStage.Install, installFailureReason: reason);
+}
+
 public sealed record UpdateInstallerLaunchResult(bool Ok, UpdateInstallFailureReason? Reason = null)
 {
     public static UpdateInstallerLaunchResult Success() => new(true);
diff --git a/src/SwitchifyPc.Core/Updates/UpdateService.cs b/src/SwitchifyPc.Core/Updates/UpdateService.cs
index b079297..98d662c 100644
--- a/src/SwitchifyPc.Core/Updates/UpdateService.cs
+++ b/src/SwitchifyPc.Core/Updates/UpdateService.cs
@@ -34,6 +34,8 @@ public interface IUpdateSettingsService
     Task<UpdateState> DownloadUpdateAsync(CancellationToken cancellationToken = default);
 
     Task<UpdateInstallResult> InstallDownloadedUpdateAsync(CancellationToken cancellationToken = default);
+
+    Task<UpdateApplyResult> InstallAvailableUpdateAsync(CancellationToken cancellationToken = default);
 }
 
 public sealed class TimerUpdatePollScheduler : IUpdatePollScheduler
@@ -75,6 +77,7 @@ public sealed class UpdateService : IUpdateSettingsService
     private AvailableUpdate? availableUpdate;
     private Task<UpdateState>? checkingTask;
     private Task<UpdateState>? downloadTask;
+    private Task<UpdateApplyResult>? applyTask;
     private UpdateOperation operation = UpdateOperation.Idle;
     private IDisposable? initialPoll;
     private IDisposable? recurringPoll;
@@ -148,6 +151,7 @@ public Task<UpdateState> CheckForUpdatesAsync(CancellationToken cancellationToke
 
         lock (gate)
         {
+            if (state.IsApplyingUpdate) return Task.FromResult(state);
             if (checkingTask is { IsCompleted: false }) return checkingTask;
             checkingTask = null;
             operation = UpdateOperation.Checking;
@@ -164,7 +168,8 @@ public Task<UpdateState> CheckForUpdatesAsync(CancellationToken cancellationToke
                     Status = UpdateCheckStatus.Checking,
                     Reason = null
                 },
-                Download = UpdateState.CreateIdleDownload()
+                Download = UpdateState.CreateIdleDownload(),
+                LastApplyResult = null
             };
             onStateChanged(state);
             checkingTask = RunCheckAsync(cancellationToken);
@@ -183,7 +188,8 @@ public Task<UpdateState> DownloadUpdateAsync(CancellationToken cancellationToken
                 {
                     Status = UpdateDownloadStatus.DownloadFailed,
                     Reason = unsupported
-                }
+                },
+                LastApplyResult = null
             });
             return Task.FromResult(GetState());
         }
@@ -200,7 +206,8 @@ public Task<UpdateState> DownloadUpdateAsync(CancellationToken cancellationToken
                     {
                         Status = UpdateDownloadStatus.DownloadFailed,
                         Reason = UpdateFailureReason.NotAvailable
-                    }
+                    },
+                    LastApplyResult = null
                 };
                 onStateChanged(state);
                 return Task.FromResult(state);
@@ -210,7 +217,8 @@ public Task<UpdateState> DownloadUpdateAsync(CancellationToken cancellationToken
             downloadedInstallerPath = null;
             state = state with
             {
-                Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloading, 0, null, null)
+                Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloading, 0, null, null),
+                LastApplyResult = null
             };
             onStateChanged(state);
             downloadTask = RunDownloadAsync(availableUpdate, cancellationToken);
@@ -239,6 +247,33 @@ public async Task<UpdateInstallResult> InstallDownloadedUpdateAsync(Cancellation
             : UpdateInstallResult.Failure(result.Reason ?? UpdateInstallFailureReason.InstallerLaunchFailed);
     }
 
+    public Task<UpdateApplyResult> InstallAvailableUpdateAsync(CancellationToken cancellationToken = default)
+    {
+        UpdateFailureReason? unsupported = UnsupportedReason();
+        if (unsupported is not null)
+        {
+            return Task.FromResult(UpdateApplyResult.DownloadFailure(unsupported.Value));
+        }
+
+        lock (gate)
+        {
+            if (applyTask is { IsCompleted: false }) return applyTask;
+            applyTask = null;
+
+            bool isDownloaded = state.Download.Status == UpdateDownloadStatus.Downloaded;
+            if (!isDownloaded && (state.Info.Status != UpdateCheckStatus.UpdateAvailable || availableUpdate is null))
+            {
+                return Task.FromResult(UpdateApplyResult.DownloadFailure(UpdateFailureReason.NotAvailable));
+            }
+
+            operation = UpdateOperation.Applying;
+            state = state with { IsApplyingUpdate = true, LastApplyResult = null };
+            onStateChanged(state);
+            applyTask = RunApplyAsync(cancellationToken);
+            return applyTask;
+        }
+    }
+
     private async Task<UpdateState> RunCheckAsync(CancellationToken cancellationToken)
     {
         try
@@ -294,6 +329,24 @@ private async Task<UpdateState> RunCheckAsync(CancellationToken cancellationToke
             });
             return GetState();
         }
+        catch (OperationCanceledException)
+        {
+            SetState(GetState() with
+            {
+                Info = GetState().Info with
+                {
+                    LatestVersion = null,
+                    ReleaseName = null,
+                    ReleaseNotes = null,
+                    CheckedAt = null,
+                    Status = UpdateCheckStatus.NotChecked,
+                    Reason = null
+                },
+                Download = UpdateState.CreateIdleDownload(),
+                LastApplyResult = null
+            });
+            throw;
+        }
         catch
         {
             SetState(GetState() with
@@ -368,6 +421,19 @@ private async Task<UpdateState> RunDownloadAsync(AvailableUpdate update, Cancell
             });
             return GetState();
         }
+        catch (OperationCanceledException)
+        {
+            lock (gate)
+            {
+                downloadedInstallerPath = null;
+            }
+
+            SetState(GetState() with
+            {
+                Download = UpdateState.CreateIdleDownload()
+            });
+            throw;
+        }
         catch
         {
             lock (gate)
@@ -395,11 +461,64 @@ private async Task<UpdateState> RunDownloadAsync(AvailableUpdate update, Cancell
         }
     }
 
+    private async Task<UpdateApplyResult> RunApplyAsync(CancellationToken cancellationToken)
+    {
+        UpdateApplyResult? completedResult = null;
+        try
+        {
+            await Task.Yield();
+
+            if (GetState().Download.Status != UpdateDownloadStatus.Downloaded)
+            {
+                UpdateState downloaded = await DownloadUpdateAsync(cancellationToken).ConfigureAwait(false);
+                if (downloaded.Download.Status != UpdateDownloadStatus.Downloaded)
+                {
+                    completedResult = UpdateApplyResult.DownloadFailure(
+                        downloaded.Download.Reason ?? UpdateFailureReason.InvalidUpdate);
+                    return completedResult;
+                }
+            }
+
+            UpdateInstallResult installed = await InstallDownloadedUpdateAsync(cancellationToken).ConfigureAwait(false);
+            completedResult = installed.Ok
+                ? UpdateApplyResult.Success()
+                : UpdateApplyResult.InstallFailure(
+                    installed.Reason ?? UpdateInstallFailureReason.InstallerLaunchFailed);
+
+            if (installed.Reason == UpdateInstallFailureReason.InstallerUnavailable)
+            {
+                lock (gate)
+                {
+                    downloadedInstallerPath = null;
+                    state = state with { Download = UpdateState.CreateIdleDownload() };
+                }
+            }
+
+            return completedResult;
+        }
+        finally
+        {
+            UpdateState next;
+            lock (gate)
+            {
+                operation = UpdateOperation.Idle;
+                state = state with
+                {
+                    IsApplyingUpdate = false,
+                    LastApplyResult = completedResult is { Ok: false } ? completedResult : null
+                };
+                next = state;
+            }
+
+            onStateChanged(next);
+        }
+    }
+
     private async Task RunAutomaticUpdateCheckAsync()
     {
         lock (gate)
         {
-            if (operation != UpdateOperation.Idle) return;
+            if (operation != UpdateOperation.Idle || state.IsApplyingUpdate) return;
             if (state.Download.Status is UpdateDownloadStatus.Downloading or UpdateDownloadStatus.Downloaded) return;
         }
 
@@ -427,7 +546,8 @@ private enum UpdateOperation
     {
         Idle,
         Checking,
-        Downloading
+        Downloading,
+        Applying
     }
 
     private sealed class InlineProgress<T>(Action<T> handler) : IProgress<T>
diff --git a/src/SwitchifyPc.Tests/MainWindowCopyTests.cs b/src/SwitchifyPc.Tests/MainWindowCopyTests.cs
index aebd0fb..197fb72 100644
--- a/src/SwitchifyPc.Tests/MainWindowCopyTests.cs
+++ b/src/SwitchifyPc.Tests/MainWindowCopyTests.cs
@@ -116,14 +116,60 @@ public void ShowsUpdateBannerForAvailableOrDownloadedUpdates()
 
         Assert.NotNull(availableCopy);
         Assert.Equal("Update available", availableCopy.Title);
-        Assert.Equal("A new Switchify PC update is ready to download.", availableCopy.Body);
-        Assert.Equal("Open updates", availableCopy.ButtonText);
+        Assert.Equal("A new Switchify PC update is ready to install.", availableCopy.Body);
+        Assert.Equal("Install update", availableCopy.ButtonText);
+        Assert.True(availableCopy.ButtonEnabled);
         Assert.NotNull(downloadedCopy);
         Assert.Equal("Update ready to install", downloadedCopy.Title);
         Assert.Equal("The update has been downloaded and is ready to install.", downloadedCopy.Body);
+        Assert.Equal("Install update", downloadedCopy.ButtonText);
+        Assert.True(downloadedCopy.ButtonEnabled);
         Assert.Null(MainWindowCopy.UpdateBanner(UpdateState.CreateInitial("0.1.20")));
     }
 
+    [Fact]
+    public void ShowsUpdateBannerForOneClickOperationStates()
+    {
+        UpdateState initial = UpdateState.CreateInitial("0.1.20");
+        UpdateState available = initial with
+        {
+            Info = initial.Info with { Status = UpdateCheckStatus.UpdateAvailable, LatestVersion = "0.2.0" }
+        };
+
+        UpdateBannerCopy downloading = Assert.IsType<UpdateBannerCopy>(MainWindowCopy.UpdateBanner(available with
+        {
+            IsApplyingUpdate = true,
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloading, 10, 100, 10)
+        }));
+        Assert.Equal("Downloading...", downloading.ButtonText);
+        Assert.False(downloading.ButtonEnabled);
+
+        UpdateBannerCopy failed = Assert.IsType<UpdateBannerCopy>(MainWindowCopy.UpdateBanner(available with
+        {
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.DownloadFailed, 10, 100, 10, UpdateFailureReason.NetworkError)
+        }));
+        Assert.Equal("Retry update", failed.ButtonText);
+        Assert.True(failed.ButtonEnabled);
+
+        UpdateBannerCopy installing = Assert.IsType<UpdateBannerCopy>(MainWindowCopy.UpdateBanner(available with
+        {
+            IsApplyingUpdate = true,
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloaded, 100, 100, 100)
+        }));
+        Assert.Equal("Installing...", installing.ButtonText);
+        Assert.False(installing.ButtonEnabled);
+
+        UpdateBannerCopy installFailed = Assert.IsType<UpdateBannerCopy>(MainWindowCopy.UpdateBanner(available with
+        {
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloaded, 100, 100, 100),
+            LastApplyResult = UpdateApplyResult.InstallFailure(UpdateInstallFailureReason.InstallerLaunchFailed)
+        }));
+        Assert.Equal("Update installation failed", installFailed.Title);
+        Assert.Equal("The update installer could not be opened. Try again.", installFailed.Body);
+        Assert.Equal("Retry update", installFailed.ButtonText);
+        Assert.True(installFailed.ButtonEnabled);
+    }
+
     private static BluetoothSystemStatus BluetoothSystemOn() =>
         BluetoothStatusModel.DefaultSystemStatus with
         {
diff --git a/src/SwitchifyPc.Tests/MainWindowTests.cs b/src/SwitchifyPc.Tests/MainWindowTests.cs
index 95aa4c8..702a391 100644
--- a/src/SwitchifyPc.Tests/MainWindowTests.cs
+++ b/src/SwitchifyPc.Tests/MainWindowTests.cs
@@ -9,6 +9,7 @@
 using SwitchifyPc.App.Themes;
 using SwitchifyPc.Core.Bluetooth;
 using SwitchifyPc.Core.Ui;
+using SwitchifyPc.Core.Updates;
 using WpfButton = System.Windows.Controls.Button;
 using WpfColor = System.Windows.Media.Color;
 
@@ -17,6 +18,43 @@ namespace SwitchifyPc.Tests;
 [Collection(WpfTestCollection.Name)]
 public sealed class MainWindowTests
 {
+    [Fact]
+    public void UpdateBannerRunsInstallActionDirectly()
+    {
+        RunOnSta(() =>
+        {
+            WpfTestApplication.ApplyTheme(AppTheme.Light);
+            MainWindowViewModel viewModel = new();
+            UpdateState initial = UpdateState.CreateInitial("0.2.0");
+            viewModel.SetUpdateState(initial with
+            {
+                Info = initial.Info with { Status = UpdateCheckStatus.UpdateAvailable, LatestVersion = "0.2.1" }
+            });
+            int calls = 0;
+            MainWindow window = new(
+                viewModel,
+                installUpdate: () =>
+                {
+                    calls++;
+                    return Task.FromResult(UpdateApplyResult.Success());
+                });
+            try
+            {
+                window.Show();
+                window.UpdateLayout();
+                WpfButton button = Assert.IsType<WpfButton>(ButtonByContent(window, "Install update"));
+
+                button.RaiseEvent(new RoutedEventArgs(WpfButton.ClickEvent));
+
+                Assert.Equal(1, calls);
+            }
+            finally
+            {
+                window.Close();
+            }
+        });
+    }
+
     [Fact]
     public void MainWindowShowsSetupGuideEntryWithoutLegacyDownloadCard()
     {
@@ -190,6 +228,19 @@ private static IReadOnlyList<string> ButtonContent(DependencyObject root)
         return content;
     }
 
+    private static WpfButton? ButtonByContent(DependencyObject root, string content)
+    {
+        WpfButton? result = null;
+        Collect(root, node =>
+        {
+            if (result is null && node is WpfButton { Content: string text } button && text == content)
+            {
+                result = button;
+            }
+        });
+        return result;
+    }
+
     private static FrameworkElement? ElementByAutomationId(DependencyObject root, string automationId)
     {
         FrameworkElement? result = null;
diff --git a/src/SwitchifyPc.Tests/MainWindowViewModelTests.cs b/src/SwitchifyPc.Tests/MainWindowViewModelTests.cs
index f81b3d5..18c9bad 100644
--- a/src/SwitchifyPc.Tests/MainWindowViewModelTests.cs
+++ b/src/SwitchifyPc.Tests/MainWindowViewModelTests.cs
@@ -111,7 +111,8 @@ public void UpdatesUpdateBannerProperties()
 
         Assert.True(viewModel.HasUpdateBanner);
         Assert.Equal("Update available", viewModel.UpdateBannerTitle);
-        Assert.Equal("Open updates", viewModel.UpdateBannerButtonText);
+        Assert.Equal("Install update", viewModel.UpdateBannerButtonText);
+        Assert.True(viewModel.IsUpdateBannerButtonEnabled);
         Assert.Contains(nameof(MainWindowViewModel.HasUpdateBanner), changed);
         Assert.Contains(nameof(MainWindowViewModel.UpdateBannerTitle), changed);
     }
diff --git a/src/SwitchifyPc.Tests/SettingsControllerTests.cs b/src/SwitchifyPc.Tests/SettingsControllerTests.cs
index 59f3a13..c45ad3d 100644
--- a/src/SwitchifyPc.Tests/SettingsControllerTests.cs
+++ b/src/SwitchifyPc.Tests/SettingsControllerTests.cs
@@ -191,6 +191,36 @@ public async Task UpdateActionsDelegateAndRefreshViewModel()
         Assert.True(viewModel.CanInstallUpdate);
     }
 
+    [Fact]
+    public async Task InstallAvailableUpdateAppliesLatestServiceState()
+    {
+        SettingsViewModel viewModel = new();
+        UpdateState available = UpdateState.CreateInitial("0.2.0") with
+        {
+            Info = UpdateState.CreateInitial("0.2.0").Info with
+            {
+                Status = UpdateCheckStatus.UpdateAvailable,
+                LatestVersion = "0.2.1"
+            }
+        };
+        UpdateState downloaded = available with
+        {
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloaded, 100, 100, 100)
+        };
+        FakeUpdates updates = new(available)
+        {
+            ApplyResult = UpdateApplyResult.Success(),
+            ApplyState = downloaded
+        };
+        SettingsController controller = CreateController(viewModel, updates: updates);
+
+        UpdateApplyResult result = await controller.InstallAvailableUpdateAsync();
+
+        Assert.True(result.Ok);
+        Assert.Equal(1, updates.ApplyCalls);
+        Assert.Equal("Install update", viewModel.UpdatePrimaryActionText);
+    }
+
     [Fact]
     public async Task ForgetPairedDeviceRemovesPersistedDeviceAndRefreshesViewModel()
     {
@@ -351,8 +381,14 @@ private sealed class FakeUpdates(UpdateState initial) : IUpdateSettingsService
 
         public UpdateInstallResult InstallResult { get; init; } = UpdateInstallResult.Failure(UpdateInstallFailureReason.NotDownloaded);
 
+        public UpdateApplyResult ApplyResult { get; init; } = UpdateApplyResult.DownloadFailure(UpdateFailureReason.NotAvailable);
+
+        public UpdateState? ApplyState { get; init; }
+
         public int InstallCalls { get; private set; }
 
+        public int ApplyCalls { get; private set; }
+
         public UpdateState GetState() => state;
 
         public Task<UpdateState> CheckForUpdatesAsync(CancellationToken cancellationToken = default)
@@ -372,5 +408,12 @@ public Task<UpdateInstallResult> InstallDownloadedUpdateAsync(CancellationToken
             InstallCalls++;
             return Task.FromResult(InstallResult);
         }
+
+        public Task<UpdateApplyResult> InstallAvailableUpdateAsync(CancellationToken cancellationToken = default)
+        {
+            ApplyCalls++;
+            if (ApplyState is not null) state = ApplyState;
+            return Task.FromResult(ApplyResult);
+        }
     }
 }
diff --git a/src/SwitchifyPc.Tests/SettingsViewModelTests.cs b/src/SwitchifyPc.Tests/SettingsViewModelTests.cs
index 425fff3..d93fd3c 100644
--- a/src/SwitchifyPc.Tests/SettingsViewModelTests.cs
+++ b/src/SwitchifyPc.Tests/SettingsViewModelTests.cs
@@ -233,6 +233,67 @@ public void MapsUpdateMessagesAndActions()
         Assert.True(viewModel.CanInstallUpdate);
     }
 
+    [Fact]
+    public void MapsOneClickUpdateActionStateMatrix()
+    {
+        SettingsViewModel viewModel = new();
+        UpdateState initial = UpdateState.CreateInitial("0.2.0");
+        UpdateState available = initial with
+        {
+            Info = initial.Info with { Status = UpdateCheckStatus.UpdateAvailable, LatestVersion = "0.2.1" }
+        };
+
+        viewModel.SetUpdateState(initial);
+        Assert.Equal("Check for updates", viewModel.UpdateCheckActionText);
+        Assert.True(viewModel.IsCheckUpdateActionVisible);
+        Assert.False(viewModel.IsInstallUpdateActionVisible);
+        Assert.True(viewModel.CanCheckForUpdates);
+        Assert.False(viewModel.CanRunUpdatePrimaryAction);
+
+        viewModel.SetUpdateState(initial with { Info = initial.Info with { Status = UpdateCheckStatus.Checking } });
+        Assert.Equal("Checking...", viewModel.UpdateCheckActionText);
+        Assert.True(viewModel.IsCheckUpdateActionVisible);
+        Assert.False(viewModel.CanCheckForUpdates);
+
+        viewModel.SetUpdateState(available);
+        Assert.Equal("Install update", viewModel.UpdatePrimaryActionText);
+        Assert.False(viewModel.IsCheckUpdateActionVisible);
+        Assert.True(viewModel.IsInstallUpdateActionVisible);
+        Assert.True(viewModel.CanRunUpdatePrimaryAction);
+        Assert.False(viewModel.CanCheckForUpdates);
+
+        viewModel.SetUpdateState(available with
+        {
+            IsApplyingUpdate = true,
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloading, 10, 100, 10)
+        });
+        Assert.Equal("Downloading...", viewModel.UpdatePrimaryActionText);
+        Assert.False(viewModel.CanRunUpdatePrimaryAction);
+
+        viewModel.SetUpdateState(available with
+        {
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.DownloadFailed, 10, 100, 10, UpdateFailureReason.NetworkError)
+        });
+        Assert.Equal("Retry update", viewModel.UpdatePrimaryActionText);
+
+        viewModel.SetUpdateState(available with
+        {
+            IsApplyingUpdate = true,
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloaded, 100, 100, 100)
+        });
+        Assert.Equal("Installing...", viewModel.UpdatePrimaryActionText);
+        Assert.False(viewModel.CanRunUpdatePrimaryAction);
+
+        viewModel.SetUpdateState(available with
+        {
+            Download = new UpdateDownloadProgress(UpdateDownloadStatus.Downloaded, 100, 100, 100),
+            LastApplyResult = UpdateApplyResult.InstallFailure(UpdateInstallFailureReason.InstallerLaunchFailed)
+        });
+        Assert.Equal("The update installer could not be opened. Try again.", viewModel.UpdateDownloadMessage);
+        Assert.Equal("Retry update", viewModel.UpdatePrimaryActionText);
+        Assert.True(viewModel.CanRunUpdatePrimaryAction);
+    }
+
     [Fact]
     public void ShowsDeterminateDownloadProgress()
     {
@@ -311,10 +372,10 @@ public void MapsUpdateInstallFailureMessages()
         Assert.Equal("Updates are only supported on Windows.", SettingsViewModel.InstallMessage(UpdateInstallFailureReason.NotSupported));
         Assert.Equal("The update was cancelled.", SettingsViewModel.InstallMessage(UpdateInstallFailureReason.Cancelled));
         Assert.Equal(
-            "The downloaded installer could not be found. Download the update again.",
+            "The downloaded installer could not be found. Try the update again.",
             SettingsViewModel.InstallMessage(UpdateInstallFailureReason.InstallerUnavailable));
         Assert.Equal(
-            "The update installer could not be opened. Download the update again or run the installer manually.",
+            "The update installer could not be opened. Try again.",
             SettingsViewModel.InstallMessage(UpdateInstallFailureReason.InstallerLaunchFailed));
         Assert.Equal("The update installer could not be opened.", SettingsViewModel.InstallMessage(null));
     }
diff --git a/src/SwitchifyPc.Tests/SettingsWindowTests.cs b/src/SwitchifyPc.Tests/SettingsWindowTests.cs
index b0cee38..7162791 100644
--- a/src/SwitchifyPc.Tests/SettingsWindowTests.cs
+++ b/src/SwitchifyPc.Tests/SettingsWindowTests.cs
@@ -16,6 +16,29 @@ namespace SwitchifyPc.Tests;
 [Collection(WpfTestCollection.Name)]
 public sealed class SettingsWindowTests
 {
+    [Fact]
+    public void SettingsWindowUsesOneClickUpdateCopy()
+    {
+        RunOnSta(() =>
+        {
+            WpfTestApplication.ApplyTheme(AppTheme.Light);
+            SettingsWindow window = new(new SettingsViewModel());
+            try
+            {
+                window.Show();
+                window.UpdateLayout();
+
+                Assert.Contains("Check for and install Switchify PC updates.", TextBlocks(window));
+                Assert.Contains("Check for updates", ButtonContent(window));
+                Assert.DoesNotContain("Download update", ButtonContent(window));
+            }
+            finally
+            {
+                window.Close();
+            }
+        });
+    }
+
     [Fact]
     public void SettingsWindowLoadsWithUpdateDownloadProgress()
     {
@@ -247,6 +270,16 @@ private static IReadOnlyList<string> RadioButtonContent(DependencyObject root)
         return content;
     }
 
+    private static IReadOnlyList<string> ButtonContent(DependencyObject root)
+    {
+        List<string> content = [];
+        Collect(root, node =>
+        {
+            if (node is WpfButton { Content: string text }) content.Add(text);
+        });
+        return content;
+    }
+
     private static void Collect(DependencyObject node, Action<DependencyObject> visit)
     {
         visit(node);
diff --git a/src/SwitchifyPc.Tests/UpdateServiceTests.cs b/src/SwitchifyPc.Tests/UpdateServiceTests.cs
index fb15115..30b8951 100644
--- a/src/SwitchifyPc.Tests/UpdateServiceTests.cs
+++ b/src/SwitchifyPc.Tests/UpdateServiceTests.cs
@@ -129,6 +129,255 @@ public async Task InstallReturnsLauncherFailure()
         Assert.Equal(UpdateInstallFailureReason.InstallerLaunchFailed, result.Reason);
     }
 
+    [Fact]
+    public async Task InstallAvailableUpdateDownloadsAndLaunchesInstaller()
+    {
+        FakeUpdateBackend backend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null)),
+            DownloadOutcome = UpdateDownloadOutcome.Downloaded(@"C:\cache\setup.exe")
+        };
+        FakeInstallerLauncher launcher = new();
+        List<UpdateState> changes = [];
+        UpdateService service = CreateService(backend, launcher, onStateChanged: changes.Add);
+        await service.CheckForUpdatesAsync();
+
+        UpdateApplyResult result = await service.InstallAvailableUpdateAsync();
+
+        Assert.True(result.Ok);
+        Assert.Equal(1, backend.DownloadCalls);
+        Assert.Equal(1, launcher.LaunchCalls);
+        Assert.Contains(changes, state => state.IsApplyingUpdate);
+        Assert.False(service.GetState().IsApplyingUpdate);
+    }
+
+    [Fact]
+    public async Task InstallAvailableUpdateSkipsDownloadWhenAlreadyDownloaded()
+    {
+        FakeUpdateBackend backend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null))
+        };
+        FakeInstallerLauncher launcher = new();
+        UpdateService service = CreateService(backend, launcher);
+        await service.CheckForUpdatesAsync();
+        await service.DownloadUpdateAsync();
+
+        UpdateApplyResult result = await service.InstallAvailableUpdateAsync();
+
+        Assert.True(result.Ok);
+        Assert.Equal(1, backend.DownloadCalls);
+        Assert.Equal(1, launcher.LaunchCalls);
+    }
+
+    [Fact]
+    public async Task ConcurrentInstallAvailableCallsShareDownloadAndLaunch()
+    {
+        FakeUpdateBackend backend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null)),
+            CompleteDownloadsManually = true
+        };
+        FakeInstallerLauncher launcher = new();
+        UpdateService service = CreateService(backend, launcher);
+        await service.CheckForUpdatesAsync();
+
+        Task<UpdateApplyResult> first = service.InstallAvailableUpdateAsync();
+        Task<UpdateApplyResult> second = service.InstallAvailableUpdateAsync();
+        await backend.WaitForDownloadStartAsync();
+        backend.CompletePendingDownload(UpdateDownloadOutcome.Downloaded(@"C:\cache\setup.exe"));
+
+        UpdateApplyResult[] results = await Task.WhenAll(first, second);
+        Assert.All(results, result => Assert.True(result.Ok));
+        Assert.Equal(1, backend.DownloadCalls);
+        Assert.Equal(1, launcher.LaunchCalls);
+    }
+
+    [Fact]
+    public async Task ApplyRemainsDeduplicatedUntilFinalStateCallbackReturns()
+    {
+        FakeUpdateBackend backend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null))
+        };
+        FakeInstallerLauncher launcher = new();
+        using ManualResetEventSlim finalStateEntered = new();
+        using ManualResetEventSlim releaseFinalState = new();
+        UpdateService service = CreateService(backend, launcher, onStateChanged: state =>
+        {
+            if (!state.IsApplyingUpdate && state.Download.Status == UpdateDownloadStatus.Downloaded)
+            {
+                finalStateEntered.Set();
+                releaseFinalState.Wait(TimeSpan.FromSeconds(10));
+            }
+        });
+        await service.CheckForUpdatesAsync();
+
+        Task<UpdateApplyResult> first = service.InstallAvailableUpdateAsync();
+        Assert.True(finalStateEntered.Wait(TimeSpan.FromSeconds(10)));
+
+        Task<UpdateApplyResult> second = service.InstallAvailableUpdateAsync();
+
+        Assert.Same(first, second);
+        Assert.Equal(1, backend.DownloadCalls);
+        Assert.Equal(1, launcher.LaunchCalls);
+        releaseFinalState.Set();
+        UpdateApplyResult[] results = await Task.WhenAll(first, second);
+        Assert.All(results, result => Assert.True(result.Ok));
+    }
+
+    [Fact]
+    public async Task InstallAvailableUpdateDistinguishesDownloadAndInstallFailures()
+    {
+        FakeUpdateBackend downloadBackend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null)),
+            DownloadOutcome = UpdateDownloadOutcome.Failed(UpdateFailureReason.NetworkError)
+        };
+        UpdateService downloadService = CreateService(downloadBackend);
+        await downloadService.CheckForUpdatesAsync();
+
+        UpdateApplyResult downloadFailure = await downloadService.InstallAvailableUpdateAsync();
+
+        Assert.Equal(UpdateApplyFailureStage.Download, downloadFailure.FailureStage);
+        Assert.Equal(UpdateFailureReason.NetworkError, downloadFailure.DownloadFailureReason);
+        Assert.Null(downloadFailure.InstallFailureReason);
+        Assert.Equal(UpdateDownloadStatus.DownloadFailed, downloadService.GetState().Download.Status);
+
+        FakeUpdateBackend installBackend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null))
+        };
+        FakeInstallerLauncher launcher = new()
+        {
+            Result = UpdateInstallerLaunchResult.Failure(UpdateInstallFailureReason.InstallerLaunchFailed)
+        };
+        UpdateService installService = CreateService(installBackend, launcher);
+        await installService.CheckForUpdatesAsync();
+
+        UpdateApplyResult installFailure = await installService.InstallAvailableUpdateAsync();
+
+        Assert.Equal(UpdateApplyFailureStage.Install, installFailure.FailureStage);
+        Assert.Null(installFailure.DownloadFailureReason);
+        Assert.Equal(UpdateInstallFailureReason.InstallerLaunchFailed, installFailure.InstallFailureReason);
+        Assert.Equal(UpdateDownloadStatus.Downloaded, installService.GetState().Download.Status);
+        Assert.Equal(UpdateApplyFailureStage.Install, installService.GetState().LastApplyResult?.FailureStage);
+        Assert.Equal(
+            UpdateInstallFailureReason.InstallerLaunchFailed,
+            installService.GetState().LastApplyResult?.InstallFailureReason);
+    }
+
+    [Fact]
+    public async Task RetryAfterLaunchFailureReusesDownloadedInstaller()
+    {
+        FakeUpdateBackend backend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null))
+        };
+        FakeInstallerLauncher launcher = new()
+        {
+            Result = UpdateInstallerLaunchResult.Failure(UpdateInstallFailureReason.InstallerLaunchFailed)
+        };
+        UpdateService service = CreateService(backend, launcher);
+        await service.CheckForUpdatesAsync();
+        await service.InstallAvailableUpdateAsync();
+        launcher.Result = UpdateInstallerLaunchResult.Success();
+
+        UpdateApplyResult retry = await service.InstallAvailableUpdateAsync();
+
+        Assert.True(retry.Ok);
+        Assert.Equal(1, backend.DownloadCalls);
+        Assert.Equal(2, launcher.LaunchCalls);
+    }
+
+    [Fact]
+    public async Task RetryAfterInstallerBecomesUnavailableDownloadsItAgain()
+    {
+        FakeUpdateBackend backend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null))
+        };
+        FakeInstallerLauncher launcher = new()
+        {
+            Result = UpdateInstallerLaunchResult.Failure(UpdateInstallFailureReason.InstallerUnavailable)
+        };
+        UpdateService service = CreateService(backend, launcher);
+        await service.CheckForUpdatesAsync();
+
+        UpdateApplyResult first = await service.InstallAvailableUpdateAsync();
+
+        Assert.Equal(UpdateInstallFailureReason.InstallerUnavailable, first.InstallFailureReason);
+        Assert.Equal(UpdateDownloadStatus.Idle, service.GetState().Download.Status);
+        Assert.Equal(UpdateInstallFailureReason.InstallerUnavailable, service.GetState().LastApplyResult?.InstallFailureReason);
+
+        launcher.Result = UpdateInstallerLaunchResult.Success();
+        UpdateApplyResult retry = await service.InstallAvailableUpdateAsync();
+
+        Assert.True(retry.Ok);
+        Assert.Equal(2, backend.DownloadCalls);
+        Assert.Equal(2, launcher.LaunchCalls);
+        Assert.Null(service.GetState().LastApplyResult);
+    }
+
+    [Fact]
+    public async Task InstallAvailableUpdateReportsUnsupportedAndUnavailable()
+    {
+        UpdateApplyResult unsupported = await CreateService(new FakeUpdateBackend(), isPackaged: false)
+            .InstallAvailableUpdateAsync();
+        UpdateApplyResult unavailable = await CreateService(new FakeUpdateBackend())
+            .InstallAvailableUpdateAsync();
+
+        Assert.Equal(UpdateApplyFailureStage.Download, unsupported.FailureStage);
+        Assert.Equal(UpdateFailureReason.NotPackaged, unsupported.DownloadFailureReason);
+        Assert.Equal(UpdateFailureReason.NotAvailable, unavailable.DownloadFailureReason);
+    }
+
+    [Fact]
+    public async Task InstallAvailableUpdateCancellationClearsApplyingAndDownloadState()
+    {
+        FakeUpdateBackend backend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null)),
+            CompleteDownloadsManually = true
+        };
+        UpdateService service = CreateService(backend);
+        await service.CheckForUpdatesAsync();
+        using CancellationTokenSource cancellation = new();
+
+        Task<UpdateApplyResult> applying = service.InstallAvailableUpdateAsync(cancellation.Token);
+        await backend.WaitForDownloadStartAsync();
+        cancellation.Cancel();
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => applying);
+        Assert.False(service.GetState().IsApplyingUpdate);
+        Assert.Equal(UpdateDownloadStatus.Idle, service.GetState().Download.Status);
+        Assert.Null(service.GetState().Download.Reason);
+    }
+
+    [Fact]
+    public async Task AutomaticAndManualChecksSkipWhileApplying()
+    {
+        FakeUpdateBackend backend = new()
+        {
+            CheckOutcome = UpdateCheckOutcome.Available(new AvailableUpdate("0.2.0", null, null)),
+            CompleteDownloadsManually = true
+        };
+        FakeUpdateScheduler scheduler = new();
+        UpdateService service = CreateService(backend, scheduler: scheduler);
+        await service.CheckForUpdatesAsync();
+        service.StartAutomaticUpdateChecks();
+
+        Task<UpdateApplyResult> applying = service.InstallAvailableUpdateAsync();
+        await backend.WaitForDownloadStartAsync();
+        await scheduler.Recurring[0].RunAsync();
+        UpdateState manual = await service.CheckForUpdatesAsync();
+
+        Assert.True(manual.IsApplyingUpdate);
+        Assert.Equal(1, backend.CheckCalls);
+        backend.CompletePendingDownload(UpdateDownloadOutcome.Downloaded(@"C:\cache\setup.exe"));
+        await applying;
+    }
+
     [Fact]
     public async Task AutomaticPollingRunsInitialAndHourlyChecks()
     {
@@ -248,11 +497,14 @@ private sealed class FakeUpdateBackend : IUpdateBackend
         public int CheckCalls { get; private set; }
         public int DownloadCalls { get; private set; }
         public UpdateCheckOutcome CheckOutcome { get; init; } = UpdateCheckOutcome.UpToDate();
-        public UpdateDownloadOutcome DownloadOutcome { get; init; } = UpdateDownloadOutcome.Downloaded(@"C:\cache\setup.exe");
+        public UpdateDownloadOutcome DownloadOutcome { get; set; } = UpdateDownloadOutcome.Downloaded(@"C:\cache\setup.exe");
         public bool CompleteChecksManually { get; init; }
+        public bool CompleteDownloadsManually { get; init; }
 
         private TaskCompletionSource<UpdateCheckOutcome>? pendingCheck;
+        private TaskCompletionSource<UpdateDownloadOutcome>? pendingDownload;
         private readonly TaskCompletionSource checkStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        private readonly TaskCompletionSource downloadStarted = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
         public Task<UpdateCheckOutcome> CheckForUpdatesAsync(string currentVersion, CancellationToken cancellationToken = default)
         {
@@ -284,8 +536,23 @@ public Task<UpdateDownloadOutcome> DownloadUpdateAsync(
         {
             DownloadCalls++;
             progress.Report(new UpdateDownloadSnapshot(40, 100, 40));
+            downloadStarted.TrySetResult();
+            if (CompleteDownloadsManually)
+            {
+                pendingDownload = new TaskCompletionSource<UpdateDownloadOutcome>(TaskCreationOptions.RunContinuationsAsynchronously);
+                cancellationToken.Register(() => pendingDownload.TrySetCanceled(cancellationToken));
+                return pendingDownload.Task;
+            }
+
             return Task.FromResult(DownloadOutcome);
         }
+
+        public Task WaitForDownloadStartAsync() => downloadStarted.Task;
+
+        public void CompletePendingDownload(UpdateDownloadOutcome outcome)
+        {
+            pendingDownload?.TrySetResult(outcome);
+        }
     }
 
     private sealed class FakeInstallerLauncher : IUpdateInstallerLauncher
@@ -293,7 +560,7 @@ private sealed class FakeInstallerLauncher : IUpdateInstallerLauncher
         public int LaunchCalls { get; private set; }
         public string? LastInstallerPath { get; private set; }
         public UpdateInstallerLaunchOptions? LastOptions { get; private set; }
-        public UpdateInstallerLaunchResult Result { get; init; } = UpdateInstallerLaunchResult.Success();
+        public UpdateInstallerLaunchResult Result { get; set; } = UpdateInstallerLaunchResult.Success();
 
         public Task<UpdateInstallerLaunchResult> LaunchAsync(
             string? installerPath,