Port CLI improvements to latest main

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: mamoreau-devolutions

.github/workflows/cli-headless-e2e.yml

@@ -0,0 +1,70 @@
+name: CLI Headless E2E
+
+on:
+  push:
+    paths:
+      - 'src/**/*.cs'
+      - 'src/**/*.csproj'
+      - 'src/**/*.props'
+      - 'src/**/*.targets'
+      - 'src/**/*.sln'
+      - 'src/**/*.slnx'
+      - 'testing/automation/**'
+      - '.github/workflows/cli-headless-e2e.yml'
+      - 'global.json'
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - 'src/**/*.cs'
+      - 'src/**/*.csproj'
+      - 'src/**/*.props'
+      - 'src/**/*.targets'
+      - 'src/**/*.sln'
+      - 'src/**/*.slnx'
+      - 'testing/automation/**'
+      - '.github/workflows/cli-headless-e2e.yml'
+      - 'global.json'
+  workflow_dispatch:
+
+jobs:
+  cli-headless-e2e:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, macos-latest, ubuntu-latest]
+
+    runs-on: ${{ matrix.os }}
+    env:
+      CONFIGURATION: Release
+      NUGET_PACKAGES: ${{ github.workspace }}/.nuget/packages
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v5
+        with:
+          global-json-file: global.json
+
+      - name: Cache NuGet packages
+        uses: actions/cache@v5
+        with:
+          path: ${{ env.NUGET_PACKAGES }}
+          key: ${{ runner.os }}-nuget-e2e-${{ hashFiles('global.json', 'src/**/*.csproj', 'src/**/*.props', 'src/**/*.targets', 'src/**/*.sln', 'src/**/*.slnx') }}
+          restore-keys: |
+            ${{ runner.os }}-nuget-e2e-
+
+      - name: Restore Avalonia solution
+        working-directory: src
+        run: dotnet restore UniGetUI.Avalonia.slnx
+
+      - name: Build headless daemon and CLI
+        working-directory: src
+        run: |
+          dotnet build UniGetUI.Avalonia/UniGetUI.Avalonia.csproj --no-restore --configuration ${{ env.CONFIGURATION }} --verbosity minimal
+          dotnet build UniGetUI.Cli/UniGetUI.Cli.csproj --no-restore --configuration ${{ env.CONFIGURATION }} --verbosity minimal
+
+      - name: Run headless CLI E2E
+        shell: pwsh
+        run: ./testing/automation/run-cli-e2e.ps1

cli-arguments.md

@@ -225,6 +225,10 @@
       <Platform Solution="*|x64" Project="x64" />
     </Project>
   </Folder>
+  <Project Path="UniGetUI.Cli/UniGetUI.Cli.csproj">
+    <Platform Solution="*|arm64" Project="arm64" />
+    <Platform Solution="*|x64" Project="x64" />
+  </Project>
   <Folder Name="/UniGetUI.PackageEngine.Tests/">
     <Project Path="UniGetUI.PackageEngine.Tests/UniGetUI.PackageEngine.Tests.csproj">
       <Platform Solution="*|arm64" Project="arm64" />

src/UniGetUI.Avalonia.slnx

@@ -6,6 +6,9 @@
 using Avalonia.Platform;
 using Avalonia.Styling;
 using Avalonia.Threading;
+#if AVALONIA_DIAGNOSTICS_ENABLED
+using Avalonia.Diagnostics;
+#endif
 using UniGetUI.Avalonia.Infrastructure;
 using UniGetUI.Avalonia.Views;
 using UniGetUI.Avalonia.Views.DialogPages;
@@ -55,12 +58,16 @@ public override void OnFrameworkInitializationCompleted()
         {
             if (OperatingSystem.IsMacOS())
             {
-                ExpandMacOSPath();
+                ProcessEnvironmentConfigurator.PrepareForCurrentPlatform();
                 using var stream = AssetLoader.Open(new Uri("avares://UniGetUI.Avalonia/Assets/icon.png"));
                 using var ms = new MemoryStream();
                 stream.CopyTo(ms);
                 MacOsNotificationBridge.SetDockIcon(ms.ToArray());
             }
+            else
+            {
+                ProcessEnvironmentConfigurator.ApplyProxySettingsToProcess();
+            }
             PEInterface.LoadLoaders();
             ApplyTheme(CoreSettings.GetValue(CoreSettings.K.PreferredTheme));
             var mainWindow = new MainWindow();

src/UniGetUI.Avalonia/App.axaml.cs

@@ -12,6 +12,7 @@
 using UniGetUI.Interface.Telemetry;
 using UniGetUI.PackageEngine;
 using UniGetUI.PackageEngine.Classes.Manager.Classes;
+using UniGetUI.PackageEngine.Interfaces;
 
 namespace UniGetUI.Avalonia.Infrastructure;
 
@@ -96,7 +97,7 @@ private static async Task ShowMissingDependencyDialogAsync(
     private static Task InitializeSharedServicesAsync()
     {
         CoreTools.ReloadLanguageEngineInstance();
-        MainWindow.ApplyProxyVariableToProcess();
+        ProcessEnvironmentConfigurator.ApplyProxySettingsToProcess();
         _ = Task.Run(AvaloniaAutoUpdater.UpdateCheckLoopAsync)
             .ContinueWith(
                 t => Logger.Error(t.Exception!),
@@ -153,6 +154,14 @@ private static async Task InitializeBackgroundApiAsync()
                 return;
 
             _backgroundApi = new BackgroundApiRunner();
+            _backgroundApi.AppInfoProvider = () =>
+                Dispatcher.UIThread.InvokeAsync(GetAppInfo).GetAwaiter().GetResult();
+            _backgroundApi.ShowAppHandler = () =>
+                Dispatcher.UIThread.InvokeAsync(ShowApp).GetAwaiter().GetResult();
+            _backgroundApi.NavigateAppHandler = request =>
+                Dispatcher.UIThread.InvokeAsync(() => NavigateApp(request)).GetAwaiter().GetResult();
+            _backgroundApi.QuitAppHandler = () =>
+                Dispatcher.UIThread.InvokeAsync(QuitApp).GetAwaiter().GetResult();
 
             _backgroundApi.OnOpenWindow += (_, _) =>
                 Dispatcher.UIThread.Post(() => MainWindow.Instance?.ShowFromTray());
@@ -186,6 +195,111 @@ private static async Task InitializeBackgroundApiAsync()
 
     public static void StopBackgroundApi() => _backgroundApi?.Stop();
 
+    private static AutomationAppInfo GetAppInfo()
+    {
+        MainWindow? window = MainWindow.Instance;
+        return new AutomationAppInfo
+        {
+            Headless = false,
+            WindowAvailable = window is not null,
+            WindowVisible = window?.IsVisible ?? false,
+            CanShowWindow = window is not null,
+            CanNavigate = window is not null,
+            CanQuit = true,
+            CurrentPage = window is null ? "" : AutomationAppPages.ToPageName(window.CurrentPage.ToString()),
+            SupportedPages = AutomationAppPages.SupportedPages,
+        };
+    }
+
+    private static BackgroundApiCommandResult ShowApp()
+    {
+        MainWindow window = MainWindow.Instance
+            ?? throw new InvalidOperationException("The application window is not available.");
+        window.ShowFromTray();
+        return BackgroundApiCommandResult.Success("show-app");
+    }
+
+    private static BackgroundApiCommandResult NavigateApp(AutomationAppNavigateRequest request)
+    {
+        MainWindow window = MainWindow.Instance
+            ?? throw new InvalidOperationException("The application window is not available.");
+        string page = AutomationAppPages.NormalizePageName(request.Page);
+        var manager = ResolveManager(request.ManagerName);
+
+        switch (page)
+        {
+            case "discover":
+                window.Navigate(PageType.Discover);
+                break;
+            case "updates":
+                window.Navigate(PageType.Updates);
+                break;
+            case "installed":
+                window.Navigate(PageType.Installed);
+                break;
+            case "bundles":
+                window.Navigate(PageType.Bundles);
+                break;
+            case "settings":
+                window.Navigate(PageType.Settings);
+                break;
+            case "managers":
+                window.OpenManagerSettings(manager);
+                break;
+            case "own-log":
+                window.Navigate(PageType.OwnLog);
+                break;
+            case "manager-log":
+                window.OpenManagerLogs(manager);
+                break;
+            case "operation-history":
+                window.Navigate(PageType.OperationHistory);
+                break;
+            case "help":
+                window.ShowHelp(request.HelpAttachment ?? "");
+                break;
+            case "release-notes":
+                window.Navigate(PageType.ReleaseNotes);
+                break;
+            case "about":
+                window.Navigate(PageType.About);
+                break;
+            default:
+                throw new InvalidOperationException(
+                    $"Unsupported app page \"{request.Page}\"."
+                );
+        }
+
+        window.ShowFromTray();
+        return BackgroundApiCommandResult.Success("navigate-app");
+    }
+
+    private static BackgroundApiCommandResult QuitApp()
+    {
+        MainWindow window = MainWindow.Instance
+            ?? throw new InvalidOperationException("The application window is not available.");
+        _ = Task.Run(async () =>
+        {
+            await Task.Delay(150);
+            await Dispatcher.UIThread.InvokeAsync(window.QuitApplication);
+        });
+        return BackgroundApiCommandResult.Success("quit-app");
+    }
+
+    private static IPackageManager? ResolveManager(string? managerName)
+    {
+        if (string.IsNullOrWhiteSpace(managerName))
+        {
+            return null;
+        }
+
+        return PEInterface.Managers.FirstOrDefault(manager =>
+            manager.Name.Equals(managerName, StringComparison.OrdinalIgnoreCase))
+            ?? throw new InvalidOperationException(
+                $"Unknown manager \"{managerName}\"."
+            );
+    }
+
     private static async Task LoadElevatorAsync()
     {
         try

src/UniGetUI.Avalonia/Infrastructure/AvaloniaBootstrapper.cs

@@ -10,6 +10,7 @@
 using UniGetUI.Core.Logging;
 using UniGetUI.Core.SettingsEngine;
 using UniGetUI.Core.Tools;
+using UniGetUI.Interface;
 using UniGetUI.PackageEngine.Classes.Packages.Classes;
 using UniGetUI.PackageEngine.Enums;
 using UniGetUI.PackageOperations;
@@ -40,6 +41,7 @@ public static class AvaloniaOperationRegistry
     /// </summary>
     public static void Add(AbstractOperation op)
     {
+        AutomationOperationApi.Track(op);
         var vm = new OperationViewModel(op);
 
         Dispatcher.UIThread.Post(() =>
@@ -143,6 +145,10 @@ public static void Remove(OperationViewModel vm)
             UpdateTrayStatus();
         });
         while (AbstractOperation.OperationQueue.Remove(vm.Operation)) ;
+        if (vm.Operation.Status is not (OperationStatus.InQueue or OperationStatus.Running))
+        {
+            AutomationOperationApi.ForgetTracking(vm.Operation.Metadata.Identifier);
+        }
     }
 
     private static async Task RemoveAfterDelayAsync(AbstractOperation op, int milliseconds)
@@ -158,6 +164,11 @@ private static async Task RemoveAfterDelayAsync(AbstractOperation op, int millis
             if (vm is not null) OperationViewModels.Remove(vm);
             Operations.Remove(op);
             UpdateTrayStatus();
+            if (op.Status is not (OperationStatus.InQueue or OperationStatus.Running))
+            {
+                AutomationOperationApi.ForgetTracking(op.Metadata.Identifier);
+            }
+            UpdateTrayStatus();
         });
     }
 

src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs

@@ -0,0 +1,103 @@
+using UniGetUI.Core.Logging;
+using UniGetUI.Interface;
+using UniGetUI.PackageEngine;
+
+namespace UniGetUI.Avalonia.Infrastructure;
+
+internal static class HeadlessDaemonHost
+{
+    public static async Task<int> RunAsync(string[] args)
+    {
+        BackgroundApiRunner? backgroundApi = null;
+        using var shutdown = new CancellationTokenSource();
+        void RequestShutdown()
+        {
+            if (!shutdown.IsCancellationRequested)
+            {
+                shutdown.Cancel();
+            }
+        }
+
+        ConsoleCancelEventHandler cancelHandler = (_, eventArgs) =>
+        {
+            eventArgs.Cancel = true;
+            RequestShutdown();
+        };
+        Console.CancelKeyPress += cancelHandler;
+
+        EventHandler processExitHandler = (_, _) => RequestShutdown();
+        AppDomain.CurrentDomain.ProcessExit += processExitHandler;
+
+        try
+        {
+            Logger.Info("Starting UniGetUI headless daemon");
+
+            ProcessEnvironmentConfigurator.PrepareForCurrentPlatform();
+            PEInterface.LoadLoaders();
+            await Task.Run(PEInterface.LoadManagers);
+
+            backgroundApi = new BackgroundApiRunner();
+            backgroundApi.AppInfoProvider = () =>
+                new AutomationAppInfo
+                {
+                    Headless = true,
+                    WindowAvailable = false,
+                    WindowVisible = false,
+                    CanShowWindow = false,
+                    CanNavigate = false,
+                    CanQuit = true,
+                    SupportedPages = AutomationAppPages.SupportedPages,
+                };
+            backgroundApi.ShowAppHandler = () =>
+                throw new InvalidOperationException(
+                    "The current UniGetUI session is running headless and has no window to show."
+                );
+            backgroundApi.NavigateAppHandler = _ =>
+                throw new InvalidOperationException(
+                    "The current UniGetUI session is running headless and cannot navigate UI pages."
+                );
+            backgroundApi.QuitAppHandler = () =>
+            {
+                _ = Task.Run(async () =>
+                {
+                    await Task.Delay(150);
+                    shutdown.Cancel();
+                });
+                return BackgroundApiCommandResult.Success("quit-app");
+            };
+            await backgroundApi.Start();
+
+            Logger.Info("UniGetUI headless daemon is ready");
+            await WaitForShutdownAsync(shutdown.Token);
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Logger.Error("UniGetUI headless daemon failed to start");
+            Logger.Error(ex);
+            return ex.HResult != 0 ? ex.HResult : 1;
+        }
+        finally
+        {
+            AppDomain.CurrentDomain.ProcessExit -= processExitHandler;
+            Console.CancelKeyPress -= cancelHandler;
+
+            if (backgroundApi is not null)
+            {
+                await backgroundApi.Stop();
+            }
+        }
+    }
+
+    private static Task WaitForShutdownAsync(CancellationToken cancellationToken)
+    {
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return Task.CompletedTask;
+        }
+
+        var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        cancellationToken.Register(() => completion.TrySetResult());
+        return completion.Task;
+    }
+}