Add an optional installer-host column to package lists (#5320)

Author: GabrielDuf

src/Languages/lang_en.json

@@ -998,5 +998,7 @@
   "Name given by the publisher": "Name given by the publisher",
   "Package name and version": "Package name and version",
   "Package identifier and version": "Package identifier and version",
-  "Name given by the publisher, followed by the version": "Name given by the publisher, followed by the version"
+  "Name given by the publisher, followed by the version": "Name given by the publisher, followed by the version",
+  "Installer host": "Installer host",
+  "Show the installer host on package lists": "Show the installer host on package lists"
 }

src/UniGetUI.Avalonia/Infrastructure/SettingsSearchIndex.cs

@@ -54,6 +54,7 @@ private sealed record Entry(string Title, string[] Keywords, Type PageType, stri
         new("Manage UniGetUI autostart behaviour", ["autostart", "run at login", "startup"], typeof(Interface_P), "EditAutostartSettings"),
         new("Show package icons on package lists", ["package icons"], typeof(Interface_P), "InterfacePackageListsCard"),
         new("Show illustrations on package lists", ["illustrations", "package illustrations"], typeof(Interface_P), "PackageIllustrationsCard"),
+        new("Show the installer host on package lists", ["installer host", "download host", "installer url", "column"], typeof(Interface_P), "InstallerHostColumnCard"),
         new("Clear the icon cache", ["icon cache", "clear cache", "cache size"], typeof(Interface_P), "ResetIconCache"),
         new("Select upgradable packages by default", ["select updates", "select upgradable"], typeof(Interface_P), "SelectUpgradableCard"),
         new("User interface preferences", ["interface", "ui"], typeof(Interface_P), null),

src/UniGetUI.Avalonia/Models/PackageCollections.cs

@@ -46,6 +46,15 @@ public sealed class PackageWrapper : INotifyPropertyChanged, IDisposable
     private const int MaxFailedIconEntries = 512;
     private static readonly TimeSpan IconRetryInterval = TimeSpan.FromMinutes(5);
 
+    private const string UnknownInstallerHost = "\u2014";
+    private const int MaxInstallerHostCacheEntries = 1024;
+    private const int MaxUnresolvedInstallerHostEntries = 512;
+    private static readonly TimeSpan InstallerHostRetryInterval = TimeSpan.FromMinutes(5);
+    private static readonly SemaphoreSlim _installerHostSemaphore = new(4, 4);
+    private static readonly object _installerHostCacheLock = new();
+    private static readonly Dictionary<long, (string Host, string Urls)> _installerHostCache = new();
+    private static readonly Dictionary<long, long> _unresolvedInstallerHosts = new();
+
     private static Bitmap? GetCachedIcon(long hash)
     {
         lock (_iconCacheLock)
@@ -178,6 +187,9 @@ public bool IsChecked
     public bool InstallerHostChanged { get; private set; }
     public string InstallerHostChangeTooltip { get; private set; } = "";
 
+    public string InstallerHostText { get; private set; } = "";
+    public string? InstallerHostTooltip { get; private set; }
+
     private CancellationTokenSource? _installerHostCheckCts;
     // Cancels this row's queued/in-flight icon load on disposal so it stops rooting the wrapper.
     private readonly CancellationTokenSource _lifetimeCts = new();
@@ -232,6 +244,161 @@ public Task EnsureIconLoadedAsync()
             return _iconLoadTask ??= LoadIconAsync();
     }
 
+    private int _installerHostLoadStarted;
+
+    public void EnsureInstallerHostLoaded()
+    {
+        if (!_page.InstallerHostColumnVisible) return;
+        if (Interlocked.Exchange(ref _installerHostLoadStarted, 1) != 0) return;
+        _ = LoadInstallerHostAsync();
+    }
+
+    private string InstallerHostVersion =>
+        Package.IsUpgradable ? Package.NewVersionString : Package.VersionString;
+
+    private async Task LoadInstallerHostAsync()
+    {
+        CancellationToken token = _lifetimeCts.Token;
+        long hash = CoreTools.HashStringAsLong(
+            $"{Package.GetVersionedHash()}|{InstallerHostVersion}"
+        );
+        try
+        {
+            if (TryGetCachedInstallerHost(hash, out var cached))
+            {
+                ApplyInstallerHost(cached.Host, cached.Urls);
+                return;
+            }
+
+            if (HasRecentInstallerHostFailure(hash))
+            {
+                ApplyInstallerHost("", "");
+                return;
+            }
+
+            await _installerHostSemaphore.WaitAsync(token).ConfigureAwait(false);
+            (string Host, string Urls) resolved;
+            try
+            {
+                if (!TryGetCachedInstallerHost(hash, out resolved))
+                {
+                    IReadOnlyList<string>? urls = await ResolveInstallerUrlsAsync(token)
+                        .ConfigureAwait(false);
+                    resolved = (
+                        InstallerHostDisplay.FromUrls(urls),
+                        InstallerHostDisplay.JoinUrls(urls)
+                    );
+                    if (resolved.Host.Length > 0)
+                        CacheInstallerHost(hash, resolved.Host, resolved.Urls);
+                    else
+                        MarkInstallerHostUnresolved(hash);
+                }
+            }
+            finally
+            {
+                _installerHostSemaphore.Release();
+            }
+
+            if (token.IsCancellationRequested) return;
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                if (!token.IsCancellationRequested)
+                    ApplyInstallerHost(resolved.Host, resolved.Urls);
+            });
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Could not resolve the installer host for {Package.Id}: {ex.Message}");
+        }
+        finally
+        {
+            Interlocked.Exchange(ref _installerHostLoadStarted, 0);
+        }
+    }
+
+    private async Task<IReadOnlyList<string>?> ResolveInstallerUrlsAsync(CancellationToken token)
+    {
+        token.ThrowIfCancellationRequested();
+#if WINDOWS
+        if (Package.Manager is WinGet)
+        {
+            string version = InstallerHostVersion;
+            return await Task.Run(() => WinGet.TryGetInstallerUrls(Package, version), token)
+                .ConfigureAwait(false);
+        }
+#endif
+        if (!Package.Details.IsPopulated)
+            await Package.Details.Load().ConfigureAwait(false);
+
+        return Package.Details.InstallerUrl is { } url ? [url.ToString()] : null;
+    }
+
+    private void ApplyInstallerHost(string host, string urls)
+    {
+        InstallerHostText = host.Length > 0 ? host : UnknownInstallerHost;
+        InstallerHostTooltip = urls.Length > 0 ? urls : null;
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(InstallerHostText)));
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(InstallerHostTooltip)));
+    }
+
+    private static bool TryGetCachedInstallerHost(long hash, out (string Host, string Urls) entry)
+    {
+        lock (_installerHostCacheLock)
+            return _installerHostCache.TryGetValue(hash, out entry);
+    }
+
+    private static bool HasRecentInstallerHostFailure(long hash)
+    {
+        lock (_installerHostCacheLock)
+        {
+            if (!_unresolvedInstallerHosts.TryGetValue(hash, out long failedAt))
+                return false;
+
+            if (Environment.TickCount64 - failedAt < (long)InstallerHostRetryInterval.TotalMilliseconds)
+                return true;
+
+            _unresolvedInstallerHosts.Remove(hash);
+            return false;
+        }
+    }
+
+    private static void MarkInstallerHostUnresolved(long hash)
+    {
+        lock (_installerHostCacheLock)
+        {
+            long now = Environment.TickCount64;
+            _unresolvedInstallerHosts[hash] = now;
+            if (_unresolvedInstallerHosts.Count <= MaxUnresolvedInstallerHostEntries)
+                return;
+
+            long retryMs = (long)InstallerHostRetryInterval.TotalMilliseconds;
+            foreach (var expired in _unresolvedInstallerHosts.Where(e => now - e.Value >= retryMs).ToArray())
+                _unresolvedInstallerHosts.Remove(expired.Key);
+
+            int excess = _unresolvedInstallerHosts.Count - MaxUnresolvedInstallerHostEntries;
+            if (excess <= 0)
+                return;
+
+            foreach (var oldest in _unresolvedInstallerHosts.OrderBy(e => e.Value).Take(excess).ToArray())
+                _unresolvedInstallerHosts.Remove(oldest.Key);
+        }
+    }
+
+    private static void CacheInstallerHost(long hash, string host, string urls)
+    {
+        lock (_installerHostCacheLock)
+        {
+            if (_installerHostCache.Count >= MaxInstallerHostCacheEntries
+                && !_installerHostCache.ContainsKey(hash))
+            {
+                _installerHostCache.Clear();
+            }
+
+            _installerHostCache[hash] = (host, urls);
+        }
+    }
+
     /// <summary>
     /// For upgradable WinGet packages, asynchronously fetches the installer URL host for
     /// both the installed and the new version, and flags the row when the hosts differ.

src/UniGetUI.Avalonia/ViewModels/SoftwarePages/PackagesPageViewModel.cs

@@ -146,6 +146,7 @@ partial void OnIsFilterPaneOpenChanged(bool value)
     public readonly bool LoadsOnStart;
     public readonly bool RoleIsUpdateLike;
     public bool SimilarSearchEnabled { get; private set; }
+    public bool InstallerHostColumnVisible { get; }
     public readonly string NoPackagesText;
     public readonly string NoMatchesText;
     public readonly string SearchBoxPlaceholder;
@@ -189,6 +190,7 @@ partial void OnIsFilterPaneOpenChanged(bool value)
     [ObservableProperty] private string _versionHeaderText = "";
     [ObservableProperty] private string _newVersionHeaderText = "";
     [ObservableProperty] private string _sourceHeaderText = "";
+    [ObservableProperty] private string _installerHostHeaderText = "";
 
     // ─── Collections ──────────────────────────────────────────────────────────
     public ObservablePackageCollection FilteredPackages { get; } = new();
@@ -248,6 +250,8 @@ public PackagesPageViewModel(PackagesPageData data)
         SimilarSearchEnabled = !data.DisableSuggestedResultsRadio;
         RoleIsUpdateLike = data.PageRole == OperationType.Update;
         NewVersionHeaderVisible = RoleIsUpdateLike;
+        InstallerHostColumnVisible = Settings.Get(Settings.K.ShowInstallerHostColumn)
+            && data.PageRole != OperationType.Uninstall;
         ReloadButtonVisible = !DisableReload;
         SearchBoxPlaceholder = CoreTools.Translate("Search for packages");
 
@@ -899,6 +903,7 @@ public void UpdateHeaderTexts()
         VersionHeaderText = isList ? CoreTools.Translate("Version") : "";
         NewVersionHeaderText = isList ? CoreTools.Translate("New version") : "";
         SourceHeaderText = isList ? CoreTools.Translate("Source") : "";
+        InstallerHostHeaderText = isList ? CoreTools.Translate("Installer host") : "";
     }
 
     public bool IsListViewMode => ViewMode == PackageViewMode.List;

src/UniGetUI.Avalonia/Views/Controls/PackageInstallerHostLoader.cs

@@ -0,0 +1,47 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using UniGetUI.PackageEngine.PackageClasses;
+
+namespace UniGetUI.Avalonia.Views.Controls;
+
+public static class PackageInstallerHostLoader
+{
+    public static readonly AttachedProperty<bool> TrackProperty =
+        AvaloniaProperty.RegisterAttached<Control, bool>("Track", typeof(PackageInstallerHostLoader));
+
+    public static void SetTrack(Control control, bool value) => control.SetValue(TrackProperty, value);
+    public static bool GetTrack(Control control) => control.GetValue(TrackProperty);
+
+    static PackageInstallerHostLoader()
+    {
+        TrackProperty.Changed.AddClassHandler<Control>((control, e) =>
+        {
+            if (e.GetNewValue<bool>())
+            {
+                control.AttachedToVisualTree += OnAttached;
+                control.DataContextChanged += OnDataContextChanged;
+                if (control.IsLoaded) TryLoad(control);
+            }
+            else
+            {
+                control.AttachedToVisualTree -= OnAttached;
+                control.DataContextChanged -= OnDataContextChanged;
+            }
+        });
+    }
+
+    private static void OnAttached(object? sender, VisualTreeAttachmentEventArgs e)
+        => TryLoad((Control)sender!);
+
+    private static void OnDataContextChanged(object? sender, EventArgs e)
+    {
+        var control = (Control)sender!;
+        if (control.IsLoaded) TryLoad(control);
+    }
+
+    private static void TryLoad(Control control)
+    {
+        if (control.DataContext is PackageWrapper wrapper) wrapper.EnsureInstallerHostLoaded();
+    }
+}

src/UniGetUI.Avalonia/Views/Pages/SettingsPages/Interface_P.axaml

@@ -100,6 +100,14 @@
                                    CornerRadius="0"
                                    BorderThickness="1,0,1,1"/>
 
+            <settings:CheckboxCard x:Name="InstallerHostColumnCard"
+                                   SettingName="ShowInstallerHostColumn"
+                                   Text="{t:Translate Show the installer host on package lists}"
+                                   WarningText="{t:Translate Restart UniGetUI to apply this change}"
+                                   StateChangedCommand="{Binding ShowRestartRequiredCommand}"
+                                   CornerRadius="0"
+                                   BorderThickness="1,0,1,1"/>
+
             <settings:ButtonCard x:Name="ResetIconCache"
                                  CornerRadius="0,0,8,8"
                                  BorderThickness="1,0,1,1"

src/UniGetUI.Avalonia/Views/SoftwarePages/AbstractPackagesPage.axaml

@@ -650,6 +650,29 @@
                                         </DataTemplate>
                                     </DataGridTemplateColumn.CellTemplate>
                                 </DataGridTemplateColumn>
+                                <DataGridTemplateColumn CanUserSort="False"
+                                                        Header="{Binding $parent[UserControl].((vm:PackagesPageViewModel)DataContext).InstallerHostHeaderText}"
+                                                        Width="*"
+                                                        IsVisible="{Binding $parent[UserControl].((vm:PackagesPageViewModel)DataContext).InstallerHostColumnVisible}">
+                                    <DataGridTemplateColumn.CellTemplate>
+                                        <DataTemplate x:DataType="pkg:PackageWrapper">
+                                            <StackPanel Orientation="Horizontal" Spacing="6" VerticalAlignment="Center" Margin="4,0"
+                                                        controls:PackageInstallerHostLoader.Track="True">
+                                                <controls:SvgIcon Path="avares://UniGetUI/Assets/Symbols/launch.svg"
+                                                                  Width="24" Height="24" VerticalAlignment="Center"
+                                                                  IsVisible="{Binding !InstallerHostChanged}"/>
+                                                <controls:SvgIcon Path="avares://UniGetUI/Assets/Symbols/warning_filled.svg"
+                                                                  Width="22" Height="22" VerticalAlignment="Center"
+                                                                  Foreground="#F59E0B"
+                                                                  IsVisible="{Binding InstallerHostChanged}"
+                                                                  ToolTip.Tip="{Binding InstallerHostChangeTooltip}"/>
+                                                <TextBlock Text="{Binding InstallerHostText}" VerticalAlignment="Center"
+                                                           TextTrimming="CharacterEllipsis"
+                                                           ToolTip.Tip="{Binding InstallerHostTooltip}"/>
+                                            </StackPanel>
+                                        </DataTemplate>
+                                    </DataGridTemplateColumn.CellTemplate>
+                                </DataGridTemplateColumn>
                             </DataGrid.Columns>
                         </DataGrid>
 

src/UniGetUI.Core.Settings/SettingsEngine_Names.cs

@@ -105,6 +105,7 @@ public enum K
         WinGetDownloadFullManifest,
         InstallerFileNameScheme,
         DisableInstallerHostChangeWarning,
+        ShowInstallerHostColumn,
         BunPreferLatestVersions,
         RedactUsernameInLog,
         DisableReleaseNotesOnUpdate,
@@ -233,6 +234,7 @@ public static string ResolveKey(K key)
             K.WinGetDownloadFullManifest => "WinGetDownloadFullManifest",
             K.InstallerFileNameScheme => "InstallerFileNameScheme",
             K.DisableInstallerHostChangeWarning => "DisableInstallerHostChangeWarning",
+            K.ShowInstallerHostColumn => "ShowInstallerHostColumn",
             K.BunPreferLatestVersions => "BunPreferLatestVersions",
             K.RedactUsernameInLog => "RedactUsernameInLog",
             K.DisableReleaseNotesOnUpdate => "DisableReleaseNotesOnUpdate",