From 373e72578360e59fe75fd817815ef3149497bb94 Mon Sep 17 00:00:00 2001 From: GabrielDuf Date: Wed, 18 Nov 2026 16:20:36 -0500 Subject: [PATCH 1/2] Explain WinGet updates the publisher refuses and offer to ignore them Packages such as MSYS2 publish `UpgradeBehavior: deny`, so `winget upgrade` always fails with 0x8A150114 (INSTALL_UPGRADE_NOT_SUPPORTED). UniGetUI still listed the update, showed a generic failure and offered retries that could never succeed (#5597). - Operation helpers gain `UpdateWasRefusedByPublisher`; the WinGet helper recognises 0x8A150114 and explains the failure through the existing `GetFailureExplanation` hook, so PackageOperations stays manager-agnostic. - A refused update hides that version through the stuck-update suppression (#5158), so automatic updates stop retrying it; a newer version is offered again. - The failure dialog's main action becomes "Ignore updates for this package", with Retry kept in its drop-down; the operation panel menu offers it too, "Retry failed" skips these operations, and IPC operation payloads carry `updateRefusedByPublisher`. - Ignoring updates goes through one `UpgradablePackagesLoader.IgnoreUpdatesAsync` helper, used by the dialog, panel, Updates page and TUI. It resolves the row the loader actually lists, so ignoring from another copy of the package removes the right row. Bundled Pinget does not enforce `UpgradeBehavior: deny` and runs the installer, so there is no Pinget refusal to detect. Verified against real WinGet with MSYS2 20260611 installed: winget returns 0x8A150114, the dev build shows the new message, sets the IPC flag and drops the update from the list, and the dialog's Ignore action works. Co-Authored-By: Claude Opus 5.5 --- docs/IPC.md | 4 + src/Languages/lang_en.json | 1 + .../AvaloniaOperationRegistry.cs | 4 +- .../DialogPages/OperationViewModel.cs | 5 + .../OperationFailedDialog.axaml.cs | 33 +++++- .../SoftwarePages/SoftwareUpdatesPage.cs | 18 +-- .../IpcOperationApi.cs | 5 + .../ManagerHelpers/IPackageOperationHelper.cs | 2 + .../Helpers/WinGetPkgOperationHelper.cs | 33 ++++++ .../PackageOperations.cs | 12 ++ .../UpgradablePackagesLoader.cs | 10 ++ .../Manager/Classes/NullPackageManager.cs | 3 + .../Manager/Helpers/BasePkgOperationHelper.cs | 3 + .../UpgradablePackagesLoaderTests.cs | 47 ++++++++ .../WinGetManagerTests.cs | 106 ++++++++++++++++++ .../Infrastructure/TuiOperationRegistry.cs | 3 +- .../Infrastructure/TuiPackageActions.cs | 16 +-- 17 files changed, 273 insertions(+), 32 deletions(-) diff --git a/docs/IPC.md b/docs/IPC.md index 04cdd84761..c4722107f9 100644 --- a/docs/IPC.md +++ b/docs/IPC.md @@ -259,6 +259,10 @@ Every operation payload carries `systemRestartRequired`: `true` when the operati the machine must be restarted before the change takes effect. See [Pending machine restarts](#pending-machine-restarts). +A failed update also carries `updateRefusedByPublisher`: `true` when the package manager refused the +update because the package's publisher requires it to be updated another way (WinGet's +`UpgradeBehavior: deny`). Retrying cannot succeed; `package ignored add` stops it from being offered. + | Method | Path | Auth | Parameters/body | CLI equivalent | | --- | --- | --- | --- | --- | | `GET` | `/uniget/v1/operations` | Yes | None | `operation list` | diff --git a/src/Languages/lang_en.json b/src/Languages/lang_en.json index 2307718e9d..4d55d3b4ae 100644 --- a/src/Languages/lang_en.json +++ b/src/Languages/lang_en.json @@ -1318,6 +1318,7 @@ "{package} may already be up to date, or no installer matches this system": "{package} may already be up to date, or no installer matches this system", "{package} could not be updated because its package source was busy or unreachable. Try again in a few minutes": "{package} could not be updated because its package source was busy or unreachable. Try again in a few minutes", "{package} is currently running. Close it and try again": "{package} is currently running. Close it and try again", + "WinGet cannot update {package}. Its publisher requires updating it another way, for example from within the app itself": "WinGet cannot update {package}. Its publisher requires updating it another way, for example from within the app itself", "{package} Uninstall": "{package} Uninstall", "{0} is being uninstalled": "{0} is being uninstalled", "Uninstall succeeded": "Uninstall succeeded", diff --git a/src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs b/src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs index 664d017e5d..f97285963d 100644 --- a/src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs +++ b/src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs @@ -13,6 +13,7 @@ using UniGetUI.Interface; using UniGetUI.PackageEngine.Classes.Packages.Classes; using UniGetUI.PackageEngine.Enums; +using UniGetUI.PackageEngine.Operations; using UniGetUI.PackageEngine.Operations.History; using UniGetUI.PackageOperations; @@ -118,7 +119,8 @@ public static void Add(AbstractOperation op) public static void RetryFailed() { var failed = OperationViewModels - .Where(vm => vm.Operation.Status is OperationStatus.Failed) + .Where(vm => vm.Operation.Status is OperationStatus.Failed + && PackageOperation.IsWorthRetryingInBulk(vm.Operation)) .ToList(); foreach (var vm in failed) vm.Operation.Retry(AbstractOperation.RetryMode.Retry); diff --git a/src/UniGetUI.Avalonia/ViewModels/DialogPages/OperationViewModel.cs b/src/UniGetUI.Avalonia/ViewModels/DialogPages/OperationViewModel.cs index 60566359f0..5df45f3ca1 100644 --- a/src/UniGetUI.Avalonia/ViewModels/DialogPages/OperationViewModel.cs +++ b/src/UniGetUI.Avalonia/ViewModels/DialogPages/OperationViewModel.cs @@ -19,6 +19,7 @@ using UniGetUI.PackageEngine.Enums; using UniGetUI.PackageEngine.Operations; using UniGetUI.PackageEngine.PackageClasses; +using UniGetUI.PackageEngine.PackageLoader; using UniGetUI.PackageOperations; namespace UniGetUI.Avalonia.ViewModels; @@ -293,6 +294,10 @@ private void RebuildMenu(OperationStatus status) } else { + if (Operation is PackageOperation ignorableOp && PackageOperation.CanIgnoreUpdatesAfterFailure(ignorableOp)) + OpMenu.Items.Add(Item("Ignore updates for this package", "pin.svg", true, + () => _ = UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(ignorableOp.Package))); + OpMenu.Items.Add(Item("Retry", "reload.svg", true, () => Operation.Retry(AbstractOperation.RetryMode.Retry))); diff --git a/src/UniGetUI.Avalonia/Views/DialogPages/OperationFailedDialog.axaml.cs b/src/UniGetUI.Avalonia/Views/DialogPages/OperationFailedDialog.axaml.cs index a9c4b4b343..8b58dfa678 100644 --- a/src/UniGetUI.Avalonia/Views/DialogPages/OperationFailedDialog.axaml.cs +++ b/src/UniGetUI.Avalonia/Views/DialogPages/OperationFailedDialog.axaml.cs @@ -8,6 +8,7 @@ using UniGetUI.Core.Tools; using UniGetUI.PackageEngine.Enums; using UniGetUI.PackageEngine.Operations; +using UniGetUI.PackageEngine.PackageLoader; using UniGetUI.PackageOperations; namespace UniGetUI.Avalonia.Views.DialogPages; @@ -41,11 +42,13 @@ public OperationFailedDialog(AbstractOperation operation) }; closeButton.Click += (_, _) => Close(); - var retryButton = BuildRetryButton(operation); + var primaryButton = operation is PackageOperation pkgOp && PackageOperation.CanIgnoreUpdatesAfterFailure(pkgOp) + ? BuildIgnoreUpdatesButton(pkgOp) + : BuildRetryButton(operation); - ButtonsLayout.Children.Add(retryButton); + ButtonsLayout.Children.Add(primaryButton); ButtonsLayout.Children.Add(closeButton); - Grid.SetColumn(retryButton, 0); + Grid.SetColumn(primaryButton, 0); Grid.SetColumn(closeButton, 1); } @@ -82,6 +85,30 @@ protected override void OnOpened(EventArgs e) Dispatcher.UIThread.Post(OutputText.ScrollToBottom, DispatcherPriority.Background); } + private Control BuildIgnoreUpdatesButton(PackageOperation operation) + { + var button = new SplitButton + { + Content = CoreTools.Translate("Ignore updates for this package"), + HorizontalAlignment = HorizontalAlignment.Stretch, + HorizontalContentAlignment = HorizontalAlignment.Center, + Classes = { "operation-dialog-action" }, + }; + button.Click += async (_, _) => + { + Close(); + await UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(operation.Package); + }; + + var flyout = new MenuFlyout(); + flyout.Items.Add(MenuItem(CoreTools.Translate("Retry"), + () => { operation.Retry(AbstractOperation.RetryMode.Retry); Close(); })); + foreach (var item in CollectRetryMenuItems(operation)) + flyout.Items.Add(item); + button.Flyout = flyout; + return button; + } + private Control BuildRetryButton(AbstractOperation operation) { var retryOptions = CollectRetryMenuItems(operation); diff --git a/src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs b/src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs index 1196bf1702..aaf568908c 100644 --- a/src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs +++ b/src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs @@ -114,11 +114,7 @@ protected override void GenerateToolBar(PackagesPageViewModel vm) if (MainWindow.Instance is not { } window || !await IgnoreUpdatesConfirmationDialog.ConfirmAsync(window, packages)) return; foreach (var pkg in packages) - { - await pkg.AddToIgnoredUpdatesAsync(); - UpgradablePackagesLoader.Instance.Remove(pkg); - UpgradablePackagesLoader.Instance.IgnoredPackages[pkg.Id] = pkg; - } + await UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(pkg); }); EnableWhen(ignoreButton, () => HasCheckedPackages); ViewModel.AddToolbarButton("clipboard_list", CoreTools.Translate("Manage ignored updates"), @@ -208,9 +204,7 @@ protected override void GenerateToolBar(PackagesPageViewModel vm) { var pkg = SelectedItem; if (pkg is null) return; - _ = pkg.AddToIgnoredUpdatesAsync(); - UpgradablePackagesLoader.Instance.Remove(pkg); - UpgradablePackagesLoader.Instance.IgnoredPackages[pkg.Id] = pkg; + _ = UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(pkg); }; var menuSkipVersion = new MenuItem @@ -222,9 +216,7 @@ protected override void GenerateToolBar(PackagesPageViewModel vm) { var pkg = SelectedItem; if (pkg is null) return; - _ = pkg.AddToIgnoredUpdatesAsync(pkg.NewVersionString); - UpgradablePackagesLoader.Instance.Remove(pkg); - UpgradablePackagesLoader.Instance.IgnoredPackages[pkg.Id] = pkg; + _ = UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(pkg, pkg.NewVersionString); }; // ── Pause updates submenu ────────────────────────────────────────── @@ -251,9 +243,7 @@ protected override void GenerateToolBar(PackagesPageViewModel vm) { var pkg = SelectedItem; if (pkg is null) return; - _ = pkg.AddToIgnoredUpdatesAsync("<" + t.GetDateFromNow()); - UpgradablePackagesLoader.Instance.IgnoredPackages[pkg.Id] = pkg; - UpgradablePackagesLoader.Instance.Remove(pkg); + _ = UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(pkg, "<" + t.GetDateFromNow()); }; menuPause.Items.Add(item); } diff --git a/src/UniGetUI.Interface.IpcApi/IpcOperationApi.cs b/src/UniGetUI.Interface.IpcApi/IpcOperationApi.cs index 22d9e59314..37e06e5c09 100644 --- a/src/UniGetUI.Interface.IpcApi/IpcOperationApi.cs +++ b/src/UniGetUI.Interface.IpcApi/IpcOperationApi.cs @@ -27,6 +27,7 @@ public class IpcOperationInfo public bool CanForget { get; set; } public IReadOnlyList AvailableQueueActions { get; set; } = []; public IReadOnlyList AvailableRetryModes { get; set; } = []; + public bool UpdateRefusedByPublisher { get; set; } public IpcPackageInfo? Package { get; set; } public string ManagerName { get; set; } = ""; public string SourceName { get; set; } = ""; @@ -217,6 +218,7 @@ public static IpcOperationDetails GetOperation(string operationId) CanForget = info.CanForget, AvailableQueueActions = info.AvailableQueueActions, AvailableRetryModes = info.AvailableRetryModes, + UpdateRefusedByPublisher = info.UpdateRefusedByPublisher, Package = info.Package, ManagerName = info.ManagerName, SourceName = info.SourceName, @@ -359,6 +361,9 @@ private static IpcOperationInfo CreateOperationInfo(TrackedOperation tracked) ? ["run-now", "run-next", "run-last"] : [], AvailableRetryModes = !IsActive(operation.Status) ? GetRetryModes(operation) : [], + UpdateRefusedByPublisher = + operation is PackageOperation packageOperation + && PackageOperation.CanIgnoreUpdatesAfterFailure(packageOperation), Package = GetOperationPackage(operation), ManagerName = GetManagerName(operation), SourceName = GetSourceName(operation), diff --git a/src/UniGetUI.PackageEngine.Interfaces/ManagerHelpers/IPackageOperationHelper.cs b/src/UniGetUI.PackageEngine.Interfaces/ManagerHelpers/IPackageOperationHelper.cs index c8e570abf8..c09a115be4 100644 --- a/src/UniGetUI.PackageEngine.Interfaces/ManagerHelpers/IPackageOperationHelper.cs +++ b/src/UniGetUI.PackageEngine.Interfaces/ManagerHelpers/IPackageOperationHelper.cs @@ -71,5 +71,7 @@ OperationType operation ); public string? GetReinstallRefusal(IPackage package, InstallOptions options); + + public bool UpdateWasRefusedByPublisher(IReadOnlyList processOutput, int returnCode); } } diff --git a/src/UniGetUI.PackageEngine.Managers.WinGet/Helpers/WinGetPkgOperationHelper.cs b/src/UniGetUI.PackageEngine.Managers.WinGet/Helpers/WinGetPkgOperationHelper.cs index 6c764de96e..7d2067e91e 100644 --- a/src/UniGetUI.PackageEngine.Managers.WinGet/Helpers/WinGetPkgOperationHelper.cs +++ b/src/UniGetUI.PackageEngine.Managers.WinGet/Helpers/WinGetPkgOperationHelper.cs @@ -660,6 +660,19 @@ operation is OperationType.Uninstall return OperationVeredict.Failure; } + if (ReportedUpdateNotSupported(returnCode)) + { + if (operation is OperationType.Update) + { + Logger.Warn( + $"WinGet refuses to update {package.Id}: its manifest says it must be updated another way; " + + $"hiding the update to {package.NewVersionString} until a newer version is available" + ); + SuppressPhantomUpgrade(package); + } + return OperationVeredict.Failure; + } + if (ReportedUpdateNotApplicable(processOutput, returnCode)) { // The update is not applicable to the platform // The scope/architecture we forced may exclude the only installer the package ships @@ -941,6 +954,26 @@ internal static bool ReportedDifferentInstallTechnology(IEnumerable proc ) ); + internal static bool ReportedUpdateNotSupported(int returnCode) => + (uint)returnCode is 0x8A150114; + + public override bool UpdateWasRefusedByPublisher(IReadOnlyList processOutput, int returnCode) => + ReportedUpdateNotSupported(returnCode); + + public override string? GetFailureExplanation( + IPackage package, + OperationType operation, + IReadOnlyList processOutput, + int returnCode, + InstallOptions? options = null + ) => + operation is OperationType.Update && ReportedUpdateNotSupported(returnCode) + ? CoreTools.Translate( + "WinGet cannot update {package}. Its publisher requires updating it another way, for example from within the app itself", + new Dictionary { { "package", package.Name } } + ) + : null; + internal static bool ReportedApplicationCurrentlyRunning(int returnCode) => (uint)returnCode is 0x8A150101 or 0x8A150103 or 0x8A150111; diff --git a/src/UniGetUI.PackageEngine.Operations/PackageOperations.cs b/src/UniGetUI.PackageEngine.Operations/PackageOperations.cs index 83a09fc668..ec2793241b 100644 --- a/src/UniGetUI.PackageEngine.Operations/PackageOperations.cs +++ b/src/UniGetUI.PackageEngine.Operations/PackageOperations.cs @@ -104,6 +104,7 @@ internal void AdoptReinstallStepFailure() } internal bool IsReinstallStep { get; init; } public bool FailedBecauseApplicationRunning { get; private set; } + public bool FailedBecauseUpdateNotSupported { get; private set; } public Task SuccessHandled { get; private set; } = Task.CompletedTask; private IReadOnlyList _closeRunningAppProcessNames = []; private readonly List _brokerKillBeforeOperationAdded = []; @@ -1225,6 +1226,7 @@ List Output ); FailedBecauseApplicationRunning = false; + FailedBecauseUpdateNotSupported = false; Metadata.FailureTitle = _genericFailureTitle; Metadata.FailureMessage = _genericFailureMessage; if (veredict is OperationVeredict.Failure) @@ -1241,7 +1243,11 @@ List Output ) Metadata.FailureMessage = explanation; if (CommandRole is OperationType.Update) + { ExplainNotApplicableUpdate(Output, ReturnCode); + FailedBecauseUpdateNotSupported = + Package.Manager.OperationHelper.UpdateWasRefusedByPublisher(Output, ReturnCode); + } ExplainInstallerHashMismatch(ReturnCode); ExplainApplicationCurrentlyRunning(Output, ReturnCode); ExplainFileInUse(Output); @@ -1465,6 +1471,12 @@ private void ExplainNotApplicableUpdate(List output, int returnCode) #endif } + public static bool CanIgnoreUpdatesAfterFailure(PackageOperation operation) => + operation.FailedBecauseUpdateNotSupported; + + public static bool IsWorthRetryingInBulk(AbstractOperation operation) => + operation is not PackageOperation { FailedBecauseUpdateNotSupported: true }; + private void ExplainInstallerHashMismatch(int returnCode) { #if WINDOWS diff --git a/src/UniGetUI.PackageEngine.PackageLoader/UpgradablePackagesLoader.cs b/src/UniGetUI.PackageEngine.PackageLoader/UpgradablePackagesLoader.cs index f25cf45bdd..5686cb3c2a 100644 --- a/src/UniGetUI.PackageEngine.PackageLoader/UpgradablePackagesLoader.cs +++ b/src/UniGetUI.PackageEngine.PackageLoader/UpgradablePackagesLoader.cs @@ -30,6 +30,16 @@ public UpgradablePackagesLoader(IReadOnlyList managers) Instance = this; } + public async Task IgnoreUpdatesAsync(IPackage package, string version = "*") + { + await package.AddToIgnoredUpdatesAsync(version); + if (GetEquivalentPackage(package) is not { } upgradable) + return; + + IgnoredPackages[upgradable.Id] = upgradable; + Remove(upgradable); + } + protected override async Task IsPackageValid(IPackage package) { if (package.VersionString == package.NewVersionString) diff --git a/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes/NullPackageManager.cs b/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes/NullPackageManager.cs index df2b50e6f2..29895382f2 100644 --- a/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes/NullPackageManager.cs +++ b/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes/NullPackageManager.cs @@ -226,5 +226,8 @@ OperationType operation ) => null; public string? GetReinstallRefusal(IPackage package, InstallOptions options) => null; + + public bool UpdateWasRefusedByPublisher(IReadOnlyList processOutput, int returnCode) => + false; } } diff --git a/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers/BasePkgOperationHelper.cs b/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers/BasePkgOperationHelper.cs index 08342392c0..cf13d72555 100644 --- a/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers/BasePkgOperationHelper.cs +++ b/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers/BasePkgOperationHelper.cs @@ -180,4 +180,7 @@ OperationType operation ) => null; public virtual string? GetReinstallRefusal(IPackage package, InstallOptions options) => null; + + public virtual bool UpdateWasRefusedByPublisher(IReadOnlyList processOutput, int returnCode) => + false; } diff --git a/src/UniGetUI.PackageEngine.Tests/UpgradablePackagesLoaderTests.cs b/src/UniGetUI.PackageEngine.Tests/UpgradablePackagesLoaderTests.cs index 946eebef3a..0057019cf0 100644 --- a/src/UniGetUI.PackageEngine.Tests/UpgradablePackagesLoaderTests.cs +++ b/src/UniGetUI.PackageEngine.Tests/UpgradablePackagesLoaderTests.cs @@ -198,6 +198,53 @@ await installedLoader.AddForeign( Assert.False(await loader.EvaluatePackageAsync(supersededPackage)); } + [Fact] + public async Task IgnoreUpdatesAsync_RemovesTheListedUpdateWhenGivenAnotherInstanceOfIt() + { + var manager = new PackageManagerBuilder().Build(); + _ = new InstalledPackagesLoader([manager]); + _ = new DiscoverablePackagesLoader([manager]); + var loader = new TestUpgradablePackagesLoader([manager]); + var listed = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.Tool") + .WithVersion("1.0.0") + .WithNewVersion("2.0.0") + .Build(); + var installed = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.Tool") + .WithVersion("1.0.0") + .Build(); + await loader.AddForeign(listed); + + await loader.IgnoreUpdatesAsync(installed); + + Assert.False(loader.Contains(listed)); + Assert.Same(listed, loader.IgnoredPackages["Contoso.Tool"]); + Assert.True(await listed.HasUpdatesIgnoredAsync()); + } + + [Fact] + public async Task IgnoreUpdatesAsync_RecordsTheRuleEvenWhenNoUpdateIsListed() + { + var manager = new PackageManagerBuilder().Build(); + _ = new InstalledPackagesLoader([manager]); + _ = new DiscoverablePackagesLoader([manager]); + var loader = new TestUpgradablePackagesLoader([manager]); + var installed = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.Tool") + .WithVersion("1.0.0") + .Build(); + + await loader.IgnoreUpdatesAsync(installed, "2.0.0"); + + Assert.Empty(loader.IgnoredPackages); + Assert.True(await installed.HasUpdatesIgnoredAsync("2.0.0")); + Assert.False(await installed.HasUpdatesIgnoredAsync("3.0.0")); + } + // Regression test for issue #5293: the installed version carried a Homebrew build revision // ("18.4_1"), which the version parser read as 18.41. That compared as greater than the // available 18.6, so the loader discarded the update and it never reached the UI. diff --git a/src/UniGetUI.PackageEngine.Tests/WinGetManagerTests.cs b/src/UniGetUI.PackageEngine.Tests/WinGetManagerTests.cs index 2ca413ec29..877ec18620 100644 --- a/src/UniGetUI.PackageEngine.Tests/WinGetManagerTests.cs +++ b/src/UniGetUI.PackageEngine.Tests/WinGetManagerTests.cs @@ -4365,6 +4365,112 @@ public async Task WinGetFailureWithBareExitCode26KeepsTheDefaultMessage() Assert.Equal(defaultMessage, operation.Metadata.FailureMessage); Assert.False(operation.FailedBecauseApplicationRunning); Assert.False(PackageOperation.CanRetryClosingRunningApp(operation)); + Assert.False(PackageOperation.CanIgnoreUpdatesAfterFailure(operation)); + } + + [Fact] + public void WinGetRecognisesOnlyTheUpgradeNotSupportedCode() + { + Assert.True(WinGetPkgOperationHelper.ReportedUpdateNotSupported(unchecked((int)0x8A150114))); + Assert.False(WinGetPkgOperationHelper.ReportedUpdateNotSupported(unchecked((int)0x8A150014))); + Assert.False(WinGetPkgOperationHelper.ReportedUpdateNotSupported(0)); + } + + [Fact] + public async Task WinGetUpdateNotSupportedExplainsTheFailureAndOffersToIgnoreUpdates() + { + var manager = new WinGet(); + var package = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.SelfUpdatingTool") + .WithName("MSYS2") + .WithVersion("20260611") + .WithNewVersion("20260927") + .Build(); + using var operation = new VeredictProbingUpdateOperation(package, new InstallOptions()); + string defaultMessage = operation.Metadata.FailureMessage; + + var veredict = await operation.ProbeProcessVeredict( + unchecked((int)0x8A150114), + [ + "Found MSYS2 [Contoso.SelfUpdatingTool] Version 20260927", + "The package cannot be upgraded using winget. Please use the method provided by the publisher for upgrading this package.", + ] + ); + + OperationAssert.HasVeredict(veredict, OperationVeredict.Failure); + Assert.NotEqual(defaultMessage, operation.Metadata.FailureMessage); + Assert.Contains("MSYS2", operation.Metadata.FailureMessage); + Assert.False(operation.Metadata.FailureMessage.EndsWith('.')); + Assert.True(operation.FailedBecauseUpdateNotSupported); + Assert.True(PackageOperation.CanIgnoreUpdatesAfterFailure(operation)); + Assert.False(PackageOperation.IsWorthRetryingInBulk(operation)); + Assert.False(operation.FailedBecauseApplicationRunning); + Assert.True(WinGetPkgOperationHelper.IsStuckUpgradeLoop(package)); + + veredict = await operation.ProbeProcessVeredict(26, []); + + OperationAssert.HasVeredict(veredict, OperationVeredict.Failure); + Assert.Equal(defaultMessage, operation.Metadata.FailureMessage); + Assert.False(PackageOperation.CanIgnoreUpdatesAfterFailure(operation)); + Assert.True(PackageOperation.IsWorthRetryingInBulk(operation)); + } + + [Fact] + public void WinGetHidesARefusedUpdateOnlyUntilANewerVersionIsOffered() + { + var manager = new WinGet(); + var refused = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.RefusedUpdate") + .WithVersion("20260611") + .WithNewVersion("20260927") + .Build(); + var newer = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.RefusedUpdate") + .WithVersion("20260611") + .WithNewVersion("20261025") + .Build(); + Assert.False(WinGetPkgOperationHelper.IsStuckUpgradeLoop(refused)); + + var veredict = manager.OperationHelper.GetResult( + refused, + OperationType.Update, + [], + unchecked((int)0x8A150114) + ); + + OperationAssert.HasVeredict(veredict, OperationVeredict.Failure); + Assert.True(WinGetPkgOperationHelper.IsStuckUpgradeLoop(refused)); + Assert.False(WinGetPkgOperationHelper.IsStuckUpgradeLoop(newer)); + } + + [Fact] + public void WinGetDoesNotHideAnythingWhenAnInstallIsRefused() + { + var manager = new WinGet(); + var package = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.RefusedInstall") + .WithVersion("20260611") + .WithNewVersion("20260927") + .Build(); + + var veredict = manager.OperationHelper.GetResult( + package, + OperationType.Install, + [], + unchecked((int)0x8A150114) + ); + + OperationAssert.HasVeredict(veredict, OperationVeredict.Failure); + Assert.False(WinGetPkgOperationHelper.IsStuckUpgradeLoop(package)); + Assert.Null( + manager.OperationHelper.GetFailureExplanation(package, OperationType.Install, [], unchecked((int)0x8A150114)) + ); + Assert.True(manager.OperationHelper.UpdateWasRefusedByPublisher([], unchecked((int)0x8A150114))); + Assert.False(manager.OperationHelper.UpdateWasRefusedByPublisher([], unchecked((int)0x8A150014))); } [Fact] diff --git a/src/UniGetUI.Tui/Infrastructure/TuiOperationRegistry.cs b/src/UniGetUI.Tui/Infrastructure/TuiOperationRegistry.cs index cb2f7de654..c9963b798e 100644 --- a/src/UniGetUI.Tui/Infrastructure/TuiOperationRegistry.cs +++ b/src/UniGetUI.Tui/Infrastructure/TuiOperationRegistry.cs @@ -3,6 +3,7 @@ using UniGetUI.Core.SettingsEngine; using UniGetUI.Core.Tools; using UniGetUI.PackageEngine.Enums; +using UniGetUI.PackageEngine.Operations; using UniGetUI.PackageEngine.Operations.History; using UniGetUI.PackageOperations; @@ -119,7 +120,7 @@ public static void ClearFinished() => RemoveWhere(o => o.Status is OperationStat public static void RetryFailed() { - foreach (var op in Snapshot().Where(o => o.Status is OperationStatus.Failed)) + foreach (var op in Snapshot().Where(o => o.Status is OperationStatus.Failed && PackageOperation.IsWorthRetryingInBulk(o))) op.Retry(AbstractOperation.RetryMode.Retry); } diff --git a/src/UniGetUI.Tui/Infrastructure/TuiPackageActions.cs b/src/UniGetUI.Tui/Infrastructure/TuiPackageActions.cs index 61a6e3414d..64958cdbec 100644 --- a/src/UniGetUI.Tui/Infrastructure/TuiPackageActions.cs +++ b/src/UniGetUI.Tui/Infrastructure/TuiPackageActions.cs @@ -170,12 +170,8 @@ public static string DefaultDownloadDirectory() // ─── Ignored updates ──────────────────────────────────────────────────── - public static async Task IgnoreUpdatesAsync(IPackage package, string version = "*") - { - await package.AddToIgnoredUpdatesAsync(version); - UpgradablePackagesLoader.Instance.IgnoredPackages[package.Id] = package; - UpgradablePackagesLoader.Instance.Remove(package); - } + public static Task IgnoreUpdatesAsync(IPackage package, string version = "*") => + UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(package, version); public static Task SkipVersionAsync(IPackage package) => IgnoreUpdatesAsync(package, package.NewVersionString); @@ -197,13 +193,7 @@ public static async Task ToggleIgnoreUpdatesAsync(IPackage package) return false; } - await package.AddToIgnoredUpdatesAsync(); - if (package.GetUpgradablePackage() is { } upgradable) - { - UpgradablePackagesLoader.Instance.IgnoredPackages[upgradable.Id] = upgradable; - UpgradablePackagesLoader.Instance.Remove(upgradable); - } - + await UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(package); return true; } From 930318f667649cd8bb252d12f5b4b03139dc12f6 Mon Sep 17 00:00:00 2001 From: GabrielDuf Date: Wed, 18 Nov 2026 16:31:31 -0500 Subject: [PATCH 2/2] Keep refused WinGet updates hidden when the installed version is unknown When WinGet's CLI lists an update with an `Unknown` installed version, ParseAvailableUpdates skipped ConsumeAlreadyUpgradedSuppression entirely to keep the one-shot "already upgraded" mark from being cleared. That also skipped the persistent IsStuckUpgradeLoop check, which the COM listing paths apply unconditionally. A refused update (0x8A150114) therefore reappeared on the next CLI reload and automatic updates retried it every cycle. Unknown-version rows now still check IsStuckUpgradeLoop; only the one-shot mark is left alone. The bypass predates this branch (#5167) and also let #5158's stuck-update suppression slip through for such rows. Co-Authored-By: Claude Opus 5.5 --- .../ClientHelpers/WinGetCliHelper.cs | 10 +++---- .../WinGetCliParsingTests.cs | 29 +++++++++++++++++++ 2 files changed, 34 insertions(+), 5 deletions(-) diff --git a/src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers/WinGetCliHelper.cs b/src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers/WinGetCliHelper.cs index b7a77bbeb8..9b92a7ea6d 100644 --- a/src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers/WinGetCliHelper.cs +++ b/src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers/WinGetCliHelper.cs @@ -160,17 +160,17 @@ WinGetTable table in WinGetTableLayout.ReadTables( InstalledVersionIsUnverified = versionUnknown, }; // Skip one-shot suppression for unknown versions so the restored mark isn't cleared. - if ( - versionUnknown - || !WinGetPkgOperationHelper.ConsumeAlreadyUpgradedSuppression(package) - ) + bool suppressed = versionUnknown + ? WinGetPkgOperationHelper.IsStuckUpgradeLoop(package) + : WinGetPkgOperationHelper.ConsumeAlreadyUpgradedSuppression(package); + if (!suppressed) { packages.Add(package); } else { Logger.Warn( - $"WinGet package {package.Id} not being shown as an updated as this version has already been marked as installed" + $"WinGet package {package.Id} not being shown as an update to {package.NewVersionString}, since it is suppressed" ); } } diff --git a/src/UniGetUI.PackageEngine.Tests/WinGetCliParsingTests.cs b/src/UniGetUI.PackageEngine.Tests/WinGetCliParsingTests.cs index cb69d36422..e60161391c 100644 --- a/src/UniGetUI.PackageEngine.Tests/WinGetCliParsingTests.cs +++ b/src/UniGetUI.PackageEngine.Tests/WinGetCliParsingTests.cs @@ -313,6 +313,35 @@ 利用可能なアップグレードが 1 件あります。 Assert.Same(manager.MicrosoftStoreSource, packages[3].Source); } + [Fact] + public void ParseAvailableUpdatesKeepsARefusedUpdateHiddenWhenTheInstalledVersionIsUnknown() + { + var manager = new WinGet(); + var refused = new PackageBuilder() + .WithManager(manager) + .WithId("Fabrikam.Refused") + .WithVersion("Unknown") + .WithNewVersion("2.0.0") + .Build(); + string[] listing = Lines( + """ + Name Id Version Available Source + -------------------------------------------------- + Refused Fabrikam.Refused Unknown 2.0.0 winget + Other Fabrikam.Other Unknown 2.0.0 winget + """ + ); + + Assert.Equal(2, WinGetCliHelper.ParseAvailableUpdates(manager, listing).Count); + + manager.OperationHelper.GetResult(refused, OperationType.Update, [], unchecked((int)0x8A150114)); + + IReadOnlyList relisted = WinGetCliHelper.ParseAvailableUpdates(manager, listing); + Assert.Single(relisted); + Assert.Equal("Fabrikam.Other", relisted[0].Id); + Assert.Single(WinGetCliHelper.ParseAvailableUpdates(manager, listing)); + } + [Fact] public void ParseInstalledPackagesFlagsRowsWhoseVersionWinGetCouldNotRead() {