Add UI to check for and trigger updates (#2083)

* Initial plan

* Add update checking UI with dialog and backend service

Co-authored-by: myieye <[email protected]>

* Improve event handling to avoid stale events and clarify messages

Co-authored-by: myieye <[email protected]>

* Expose better api for update checking UI

* Refactor UpdateDialog to use new CheckForUpdate/ApplyUpdate API

- Removed complex event subscription logic
- Use direct API calls: checkForUpdates() returns IAvailableUpdate | null
- Use supportsAutoUpdate flag to show Install button vs download link
- Simplified state management and UI logic
- All functionality contained within dialog (no external notifications)

Co-authored-by: myieye <[email protected]>

* Simplify UpdateDialog state with promises and implement cache

Backend:
- Implement 5-minute memory cache for update checks
- Cache both "update available" and "no update" results

Frontend:
- Replace boolean flags (checking, installing, checkComplete, errorMessage) with promise-based state
- Use Svelte's {#await} blocks to handle async states declaratively
- Remove "Check Again" buttons - main button changes based on state
- Use Button's built-in loading and icon props (removed manual mr-2, i-mdi-loading)
- Remove unused context="module" script tag and cn import
- Fix platform display (removed .toString())

State reduced from 6 variables to 3:
- checkPromise: handles check states (pending/fulfilled/rejected)
- installPromise: handles install states
- installSuccess: tracks successful installation

Co-authored-by: myieye <[email protected]>

* Use standard .NET MemoryCache instead of custom cache

- Replace custom cache fields (_cachedUpdate, _cacheTime) with IMemoryCache
- Inject IMemoryCache via constructor dependency injection
- Use GetOrCreateAsync pattern for cleaner cache logic
- Add AddMemoryCache() to FwLiteSharedKernel service registration
- Maintain same 5-minute cache duration behavior

Co-authored-by: myieye <[email protected]>

* Add FwLiteRelease to AppUpdateEvent

* Return UpdateResult

* Use actual download URL instead of download page url

* Make release downloading reusable

* Tweak cache key and duration

* Finalize UI and add stories

* Add Updates dialog to project view

* Add install progress percentage

* Fix story naming and location

* Fix test failing on demo rejected promise

* Prevent showing 0% until we know it works

* Add download page link and download update as install fallback

* Show platform in troubleshoot dialog

* Fix demo page

* Remove "or Download Update"
It's confusing and there's a link to the app/downloads anyway

* Simplify Download page url

* Keep po source references sorted

* Standardize text anchor styling

* PR feedback

* Move update calls off of main thread

* i18n:extract with added context

* Fix lint error

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: myieye <[email protected]>
Co-authored-by: Tim Haasdyk <[email protected]>

Author: Copilot

backend/FwLite/FwLiteMaui/Platforms/Windows/AppUpdateService.cs

@@ -1,17 +1,15 @@
-using System.Buffers;
-using System.Net.Http.Json;
 using System.Text.Json;
 using Windows.Management.Deployment;
 using Windows.Networking.Connectivity;
 using LexCore.Entities;
 using Microsoft.Extensions.Logging;
 using Microsoft.Toolkit.Uwp.Notifications;
-using FwLiteMaui.Services;
 using FwLiteShared.AppUpdate;
+using FwLiteShared.Events;
 
 namespace FwLiteMaui;
 
-public class AppUpdateService(ILogger<AppUpdateService> logger, IPreferences preferences)
+public class AppUpdateService(ILogger<AppUpdateService> logger, IPreferences preferences, GlobalEventBus eventBus)
     : IMauiInitializeService, IPlatformUpdateService
 {
     private const string LastUpdateCheckKey = "lastUpdateChecked";
@@ -118,6 +116,7 @@ private async Task<UpdateResult> ApplyUpdate(FwLiteRelease latestRelease, bool q
             });
         asyncOperation.Progress = (info, progressInfo) =>
         {
+            NotifyInstallProgress(progressInfo.percentage, latestRelease);
             if (progressInfo.state == DeploymentProgressState.Queued)
             {
                 logger.LogInformation("Queued update");
@@ -146,6 +145,11 @@ private async Task<UpdateResult> ApplyUpdate(FwLiteRelease latestRelease, bool q
         return UpdateResult.Started;
     }
 
+    private void NotifyInstallProgress(uint percentage, FwLiteRelease release)
+    {
+        eventBus.PublishEvent(new AppUpdateProgressEvent(percentage, release));
+    }
+
     public DateTime LastUpdateCheck
     {
         get => preferences.Get(LastUpdateCheckKey, DateTime.MinValue);

backend/FwLite/FwLiteShared/AppUpdate/IPlatformUpdateService.cs

@@ -19,5 +19,6 @@ public enum UpdateResult
     Success,
     Failed,
     Started,
-    ManualUpdateRequired
+    ManualUpdateRequired,
+    Disallowed
 }

backend/FwLite/FwLiteShared/AppUpdate/UpdateChecker.cs

@@ -1,49 +1,73 @@
 using System.Net.Http.Json;
 using FwLiteShared.Events;
 using LexCore.Entities;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
 namespace FwLiteShared.AppUpdate;
 
+public record AvailableUpdate(FwLiteRelease Release, bool SupportsAutoUpdate);
+
 public class UpdateChecker(
     IHttpClientFactory httpClientFactory,
     ILogger<UpdateChecker> logger,
     IOptions<FwLiteConfig> config,
     GlobalEventBus eventBus,
-    IPlatformUpdateService platformUpdateService): BackgroundService
+    IPlatformUpdateService platformUpdateService,
+    IMemoryCache cache) : BackgroundService
 {
+    private const string CacheKey = "ManualUpdateCheck";
+    private static readonly TimeSpan CacheDuration = TimeSpan.FromMinutes(2);
+
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         await TryUpdate();
     }
 
-    public async Task TryUpdate(bool forceCheck = false)
+    public async Task<UpdateResult?> TryUpdate()
+    {
+        if (!ShouldCheckForUpdate()) return null;
+        var update = await CheckForUpdate();
+        if (update is null) return null;
+        return await ApplyUpdate(update.Release);
+    }
+
+    public async Task<AvailableUpdate?> CheckForUpdate()
     {
-        if (!ShouldCheckForUpdate() && !forceCheck) return;
-        var response = await ShouldUpdateAsync();
+        return await cache.GetOrCreateAsync(CacheKey, async entry =>
+        {
+            entry.AbsoluteExpirationRelativeToNow = CacheDuration;
+            var response = await ShouldUpdateAsync();
+            platformUpdateService.LastUpdateCheck = DateTime.UtcNow;
+            return response.Update
+                ? new AvailableUpdate(response.Release, platformUpdateService.SupportsAutoUpdate)
+                : null;
+        });
+    }
 
-        platformUpdateService.LastUpdateCheck = DateTime.UtcNow;
-        if (!response.Update) return;
+    public async Task<UpdateResult> ApplyUpdate(FwLiteRelease release)
+    {
         if (ShouldPromptBeforeUpdate() &&
-            !await platformUpdateService.RequestPermissionToUpdate(response.Release))
+            !await platformUpdateService.RequestPermissionToUpdate(release))
         {
-            return;
+            return UpdateResult.Disallowed;
         }
 
-        UpdateResult updateResult = UpdateResult.ManualUpdateRequired;
+        var updateResult = UpdateResult.ManualUpdateRequired;
         if (platformUpdateService.SupportsAutoUpdate)
         {
-            updateResult = await platformUpdateService.ApplyUpdate(response.Release);
+            updateResult = await platformUpdateService.ApplyUpdate(release);
         }
 
-        NotifyResult(updateResult);
+        NotifyResult(updateResult, release);
+        return updateResult;
     }
 
-    private void NotifyResult(UpdateResult result)
+    private void NotifyResult(UpdateResult result, FwLiteRelease release)
     {
-        eventBus.PublishEvent(new AppUpdateEvent(result));
+        eventBus.PublishEvent(new AppUpdateEvent(result, release));
     }
 
     private bool ShouldCheckForUpdate()

backend/FwLite/FwLiteShared/Events/AppUpdateEvent.cs

@@ -1,10 +1,12 @@
 using FwLiteShared.AppUpdate;
+using LexCore.Entities;
 
 namespace FwLiteShared.Events;
 
-public class AppUpdateEvent(UpdateResult result) : IFwEvent
+public class AppUpdateEvent(UpdateResult result, FwLiteRelease release) : IFwEvent
 {
     public UpdateResult Result { get; } = result;
+    public FwLiteRelease Release { get; } = release;
     public FwEventType Type => FwEventType.AppUpdate;
     public bool IsGlobal => true;
 }

backend/FwLite/FwLiteShared/Events/AppUpdateProgressEvent.cs

@@ -0,0 +1,11 @@
+using LexCore.Entities;
+
+namespace FwLiteShared.Events;
+
+public class AppUpdateProgressEvent(uint percentage, FwLiteRelease release) : IFwEvent
+{
+    public uint Percentage { get; } = percentage;
+    public FwLiteRelease Release { get; } = release;
+    public FwEventType Type => FwEventType.AppUpdateProgress;
+    public bool IsGlobal => true;
+}

backend/FwLite/FwLiteShared/Events/IFwEvent.cs

@@ -9,6 +9,7 @@ namespace FwLiteShared.Events;
 [JsonDerivedType(typeof(AuthenticationChangedEvent), nameof(AuthenticationChangedEvent))]
 [JsonDerivedType(typeof(SyncEvent), nameof(SyncEvent))]
 [JsonDerivedType(typeof(AppUpdateEvent), nameof(AppUpdateEvent))]
+[JsonDerivedType(typeof(AppUpdateProgressEvent), nameof(AppUpdateProgressEvent))]
 public interface IFwEvent
 {
     FwEventType Type { get; }
@@ -25,4 +26,5 @@ public enum FwEventType
     EntryDeleted,
     Sync,
     AppUpdate,
+    AppUpdateProgress,
 }

backend/FwLite/FwLiteShared/FwLiteSharedKernel.cs

@@ -22,6 +22,7 @@ public static class FwLiteSharedKernel
 {
     public static IServiceCollection AddFwLiteShared(this IServiceCollection services, IHostEnvironment environment)
     {
+        services.AddMemoryCache();
         services.AddHttpClient();
         services.AddAuthHelpers(environment);
         services.AddLcmCrdtClient();
@@ -46,6 +47,7 @@ public static IServiceCollection AddFwLiteShared(this IServiceCollection service
         services.AddSingleton<UpdateChecker>();
         services.AddSingleton<IHostedService>(s => s.GetRequiredService<UpdateChecker>());
         services.TryAddSingleton<IPlatformUpdateService, CorePlatformUpdateService>();
+        services.AddSingleton<UpdateService>();
         services.AddSingleton<TestingService>();
         services.AddOptions<FwLiteConfig>().BindConfiguration("FwLite");
         services.DecorateConstructor<IJSRuntime>((provider, runtime) =>

backend/FwLite/FwLiteShared/Services/FwLiteProvider.cs

@@ -35,6 +35,7 @@ IServiceProvider services
         DotnetService.MultiWindowService,
         DotnetService.JsEventListener,
         DotnetService.JsInvokableLogger,
+        DotnetService.UpdateService,
     ];
 
     public static Type GetServiceType(DotnetService service) => service switch
@@ -53,6 +54,7 @@ IServiceProvider services
         DotnetService.MultiWindowService => typeof(IMultiWindowService),
         DotnetService.JsEventListener => typeof(JsEventListener),
         DotnetService.JsInvokableLogger => typeof(JsInvokableLogger),
+        DotnetService.UpdateService => typeof(UpdateService),
         _ => throw new ArgumentOutOfRangeException(nameof(service), service, null)
     };
 
@@ -111,4 +113,5 @@ public enum DotnetService
     MultiWindowService,
     JsEventListener,
     JsInvokableLogger,
+    UpdateService,
 }

backend/FwLite/FwLiteShared/Services/UpdateService.cs

@@ -0,0 +1,21 @@
+using FwLiteShared.AppUpdate;
+using Microsoft.JSInterop;
+using Reinforced.Typings.Attributes;
+
+namespace FwLiteShared.Services;
+
+public class UpdateService(UpdateChecker updateChecker)
+{
+    [JSInvokable]
+    [TsFunction(Type = "Promise<IAvailableUpdate | null>")]
+    public Task<AvailableUpdate?> CheckForUpdates()
+    {
+        return Task.Run(async () => await updateChecker.CheckForUpdate());
+    }
+
+    [JSInvokable]
+    public Task<UpdateResult> ApplyUpdate(AvailableUpdate update)
+    {
+        return Task.Run(async () => await updateChecker.ApplyUpdate(update.Release));
+    }
+}

backend/FwLite/FwLiteShared/TypeGen/ReinforcedFwLiteTypingConfig.cs

@@ -174,7 +174,9 @@ private static void ConfigureFwLiteSharedTypes(ConfigurationBuilder builder)
             typeof(IChange),
             typeof(CommitMetadata),
             typeof(ObjectSnapshot),
-            typeof(ProjectScope)
+            typeof(ProjectScope),
+            typeof(FwLiteRelease),
+            typeof(AvailableUpdate),
         ], exportBuilder => exportBuilder.WithPublicProperties());
 
         builder.ExportAsEnum<FwEventType>().UseString();