Register autostart for every user on per-machine installs (#5691)

Author: GabrielDuf

UniGetUI.iss

@@ -8,6 +8,9 @@
 #define MyAppExeName "UniGetUI.exe"
 #define MyAppPublisherURL "https://devolutions.net/unigetui/"
 #define MyAppCopyright "Copyright 2021-2026 " + MyAppPublisher
+#define AutostartComponentKey "Software\Microsoft\Active Setup\Installed Components\Devolutions.UniGetUI.Autostart"
+#define AutostartRemovalKey "Software\Microsoft\Active Setup\Installed Components\Devolutions.UniGetUI.Autostart.Removal"
+#define UserRunKey "Software\Microsoft\Windows\CurrentVersion\Run"
 #ifndef InstallerCompression
 #define InstallerCompression "lzma"
 #endif
@@ -86,6 +89,8 @@ AppModifyPath="{app}\UniGetUI.Installer.exe" /silent /NoDeployInstaller
 
 var
   PreserveAutostartDisabled: Boolean;
+  AutostartComponentVersionValue: String;
+  AutostartRegisteredExecutable: String;
   // Set once the marker is written (which happens only after {app} is initialized).
   MarkerWritten: Boolean;
 
@@ -101,6 +106,81 @@ begin
     Result := (Length(Data) >= 1) and ((Ord(Data[1]) and 1) = 1);
 end;
 
+function NewActiveSetupVersion: String;
+begin
+  Result := GetDateTimeString('yyyy,mmdd,hhnn,ss', #0, #0);
+end;
+
+function AutostartStubPath: String;
+begin
+  Result := '"' + ExpandConstant('{app}\{#MyAppExeName}') + '" --register-autostart';
+end;
+
+function ResolveAutostartComponentVersion: String;
+var
+  ExistingVersion, ExistingStubPath: String;
+begin
+  if RegQueryStringValue(HKLM64, '{#AutostartComponentKey}', 'Version', ExistingVersion)
+    and RegQueryStringValue(HKLM64, '{#AutostartComponentKey}', 'StubPath', ExistingStubPath)
+    and (ExistingVersion <> '')
+    and (CompareText(ExistingStubPath, AutostartStubPath) = 0) then
+    Result := ExistingVersion
+  else
+    Result := NewActiveSetupVersion;
+end;
+
+function AutostartComponentVersion(Param: String): String;
+begin
+  if AutostartComponentVersionValue = '' then
+    AutostartComponentVersionValue := ResolveAutostartComponentVersion;
+  Result := AutostartComponentVersionValue;
+end;
+
+function AutostartStubPathValue(Param: String): String;
+begin
+  Result := AutostartStubPath;
+end;
+
+function RegisteredAutostartExecutable: String;
+var
+  StubPath, Rest: String;
+  ClosingQuote: Integer;
+begin
+  Result := '';
+  if not RegQueryStringValue(HKLM64, '{#AutostartComponentKey}', 'StubPath', StubPath) then
+    Exit;
+  if (Length(StubPath) < 2) or (StubPath[1] <> '"') then
+    Exit;
+  Rest := Copy(StubPath, 2, Length(StubPath) - 1);
+  ClosingQuote := Pos('"', Rest);
+  if ClosingQuote > 1 then
+    Result := Copy(Rest, 1, ClosingQuote - 1);
+end;
+
+procedure RegisterAutostartRemovalForAllUsers(const ExecutablePath: String);
+var
+  Reg, Find, Cmd, Command: String;
+begin
+  Reg := '"' + ExpandConstant('{win}\System32\reg.exe') + '"';
+  Find := '"' + ExpandConstant('{win}\System32\find.exe') + '"';
+  Cmd := '"' + ExpandConstant('{win}\System32\cmd.exe') + '"';
+  Command := Cmd + ' /d /c "' + Reg + ' query "HKCU\{#UserRunKey}" /v WingetUI | ' + Find + ' /i "'
+    + ExecutablePath + '" >nul && ' + Reg + ' delete "HKCU\{#UserRunKey}" /v WingetUI /f"';
+  RegWriteStringValue(HKLM64, '{#AutostartRemovalKey}', '', '{#MyAppName}');
+  RegWriteStringValue(HKLM64, '{#AutostartRemovalKey}', 'Version', NewActiveSetupVersion);
+  RegWriteStringValue(HKLM64, '{#AutostartRemovalKey}', 'StubPath', Command);
+  RegWriteDWordValue(HKLM64, '{#AutostartRemovalKey}', 'IsInstalled', 1);
+end;
+
+procedure UnregisterAutostartForAllUsers;
+var
+  ExecutablePath: String;
+begin
+  ExecutablePath := RegisteredAutostartExecutable;
+  if ExecutablePath <> '' then
+    RegisterAutostartRemovalForAllUsers(ExecutablePath);
+end;
+
 procedure InitializeWizard;
 begin
   WizardForm.Bevel.Visible := False;
@@ -182,6 +262,7 @@ function PrepareToInstall(var NeedsRestart: Boolean): String;
 begin
     // Capture before [Registry] rewrites the Run key, so updates keep the user's choice.
     PreserveAutostartDisabled := IsAutostartDisabledByUser;
+    AutostartComponentVersionValue := ResolveAutostartComponentVersion;
     KillRunningApps;
     WriteUpdateMarker;
     Result := '';
@@ -203,7 +284,13 @@ end;
 procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
 begin
     if CurUninstallStep = usUninstall then
+    begin
+        if IsAdminInstallMode then
+            AutostartRegisteredExecutable := RegisteredAutostartExecutable;
         UpdateUnigetPath(False);
+    end;
+    if (CurUninstallStep = usPostUninstall) and (AutostartRegisteredExecutable <> '') then
+        RegisterAutostartRemovalForAllUsers(AutostartRegisteredExecutable);
 end;
 
 function GetCustomSetupExitCode: Integer;
@@ -261,6 +348,16 @@ begin
   Result := CmdLineParamExists('/NoRunOnStartup') or IsMSStoreInstall or PreserveAutostartDisabled;
 end;
 
+function ShouldRegisterAutostartForAllUsers: Boolean;
+begin
+  Result := IsAdminInstallMode and not (CmdLineParamExists('/NoRunOnStartup') or IsMSStoreInstall);
+end;
+
+function ShouldUnregisterAutostartForAllUsers: Boolean;
+begin
+  Result := IsAdminInstallMode and (CmdLineParamExists('/NoRunOnStartup') or IsMSStoreInstall);
+end;
+
 var CustomExitCode: integer;
 
 procedure ExitProcess(exitCode:integer);
@@ -336,6 +433,12 @@ Name: "regularinstall\addtopath"; Description: "{cm:RegAddToPath}";
 [Registry]
 Root: HKCU; Subkey: "SOFTWARE\Microsoft\Windows\CurrentVersion\Run"; ValueType: string; ValueName: "WingetUI"; ValueData: """{app}\UniGetUI.exe"" --daemon"; Flags: uninsdeletevalue noerror; Tasks: regularinstall;
 Root: HKCU; Subkey: "Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run"; ValueType: binary; ValueName: "WingetUI"; ValueData: "03"; Flags: uninsdeletevalue; Tasks: regularinstall; Check: ShouldSuppressRunOnStartup;
+Root: HKLM64; Subkey: "{#AutostartComponentKey}"; ValueType: none; Flags: deletekey; Tasks: regularinstall; Check: ShouldUnregisterAutostartForAllUsers; BeforeInstall: UnregisterAutostartForAllUsers;
+Root: HKLM64; Subkey: "{#AutostartRemovalKey}"; ValueType: none; Flags: deletekey; Tasks: regularinstall; Check: ShouldRegisterAutostartForAllUsers;
+Root: HKLM64; Subkey: "{#AutostartComponentKey}"; ValueType: string; ValueData: "{#MyAppName}"; Flags: uninsdeletekey; Tasks: regularinstall; Check: ShouldRegisterAutostartForAllUsers;
+Root: HKLM64; Subkey: "{#AutostartComponentKey}"; ValueType: string; ValueName: "Version"; ValueData: "{code:AutostartComponentVersion}"; Tasks: regularinstall; Check: ShouldRegisterAutostartForAllUsers;
+Root: HKLM64; Subkey: "{#AutostartComponentKey}"; ValueType: dword; ValueName: "IsInstalled"; ValueData: 1; Tasks: regularinstall; Check: ShouldRegisterAutostartForAllUsers;
+Root: HKLM64; Subkey: "{#AutostartComponentKey}"; ValueType: string; ValueName: "StubPath"; ValueData: "{code:AutostartStubPathValue}"; Tasks: regularinstall; Check: ShouldRegisterAutostartForAllUsers;
 
 // Register the unigetui:// deep link
 Root: HKA; Subkey: "Software\Classes\unigetui"; ValueType: "string"; ValueData: "URL:UniGetUI Protocol"; Flags: uninsdeletekey; Tasks: regularinstall;

docs/CLI.md

@@ -390,6 +390,7 @@ These parameters are accepted by the app executables in addition to the automati
 | `--uninstall-unigetui` | Unregisters UniGetUI from the notification panel and quits. | Historical; only valid for specific old versions. |
 | `--uninstall-wingetui` | Unregisters the legacy WingetUI install from the notification panel and quits. | Historical; used by the WingetUI uninstaller. |
 | `--migrate-wingetui-to-unigetui` | Migrates legacy WingetUI data and shortcuts, then quits. | Migration helper. |
+| `--register-autostart` | Registers UniGetUI to start minimized at login for the current user, then quits. | Windows. Run once per user at logon by per-machine installs; the on/off toggle in Startup Apps is kept. |
 | `--help` / `-h` | Prints CLI help. | For the direct verb-based CLI. |
 | `--import-settings <file>` | Imports settings from a JSON file. | Existing settings are replaced. |
 | `--export-settings <file>` | Exports settings to a JSON file. | Creates or overwrites the file. |
@@ -464,7 +465,7 @@ The installer is Inno Setup based. It supports the standard [Inno Setup command-
 | Parameter | Meaning |
 | --- | --- |
 | `/NoAutoStart` | Do not launch UniGetUI after installation. |
-| `/NoRunOnStartup` | Do not register UniGetUI to start minimized at login. |
+| `/NoRunOnStartup` | Do not register UniGetUI to start minimized at login. On a per-machine install this applies to every user: an earlier all-users registration is removed, and each user's entry from it is deleted at their next logon. |
 | `/NoVCRedist` | Skip installation of the MSVC x64 runtime. |
 | `/NoEdgeWebView` | Skip installation of the Microsoft Edge WebView runtime. |
 | `/NoChocolatey` | Deprecated no-op kept for compatibility. |

src/Shared/SharedPreUiCommandDispatcher.cs

@@ -1,3 +1,4 @@
+using Microsoft.Win32;
 using UniGetUI.Core.Logging;
 using UniGetUI.Core.SettingsEngine;
 using UniGetUI.Core.SettingsEngine.SecureSettings;
@@ -43,6 +44,9 @@ internal static class SharedPreUiCommandDispatcher
     internal const string MigrateWingetUIToUniGetUIArgument = "--migrate-wingetui-to-unigetui";
     internal const string UninstallWingetUIArgument = "--uninstall-wingetui";
     internal const string UninstallUniGetUIArgument = "--uninstall-unigetui";
+    internal const string RegisterAutostartArgument = "--register-autostart";
+    internal const string AutostartRunSubKey = @"Software\Microsoft\Windows\CurrentVersion\Run";
+    internal const string AutostartValueName = "WingetUI";
 
     private const string EnableSecureSettingForUserArgument = SecureSettings.Args.ENABLE_FOR_USER;
     private const string DisableSecureSettingForUserArgument = SecureSettings.Args.DISABLE_FOR_USER;
@@ -131,6 +135,11 @@ public static string[] IgnoreArgumentsInjectedIntoProtocolLaunch(string[] args)
             return MigrateWingetUIToUniGetUI();
         }
 
+        if (args.Contains(RegisterAutostartArgument))
+        {
+            return RegisterAutostart(exitCodes);
+        }
+
         if (args.Contains(UninstallWingetUIArgument) || args.Contains(UninstallUniGetUIArgument))
         {
             return exitCodes.Success;
@@ -349,6 +358,40 @@ SharedPreUiCommandExitCodes exitCodes
         }
     }
 
+    public static int RegisterAutostart(SharedPreUiCommandExitCodes exitCodes)
+    {
+        if (!OperatingSystem.IsWindows() || Environment.ProcessPath is not { Length: > 0 } executablePath)
+        {
+            return exitCodes.Failed;
+        }
+
+        return RegisterAutostart(Registry.CurrentUser, AutostartRunSubKey, executablePath, exitCodes);
+    }
+
+    internal static int RegisterAutostart(
+        RegistryKey root,
+        string runSubKey,
+        string executablePath,
+        SharedPreUiCommandExitCodes exitCodes
+    )
+    {
+        if (!OperatingSystem.IsWindows())
+        {
+            return exitCodes.Failed;
+        }
+
+        try
+        {
+            using RegistryKey runKey = root.CreateSubKey(runSubKey);
+            runKey.SetValue(AutostartValueName, $"\"{executablePath}\" --daemon", RegistryValueKind.String);
+            return exitCodes.Success;
+        }
+        catch (Exception ex)
+        {
+            return ex.HResult;
+        }
+    }
+
     public static int MigrateWingetUIToUniGetUI()
     {
         try

src/UniGetUI.Tests/CLIHandlerTests.cs

@@ -353,6 +353,81 @@ public void DeleteShortcuts_ReportsAnInvalidParameterWhenNoPathIsGiven()
         );
     }
 
+    [Fact]
+    public void RegisterAutostart_WritesTheQuotedDaemonCommandForTheGivenExecutable()
+    {
+        if (!OperatingSystem.IsWindows())
+        {
+            return;
+        }
+
+        string testRoot = $@"Software\UniGetUI.Tests\{Guid.NewGuid():N}";
+        string runSubKey = $@"{testRoot}\Run";
+        try
+        {
+            Assert.Equal(
+                SharedPreUiCommandDispatcher.WindowsCliExitCodes.Success,
+                SharedPreUiCommandDispatcher.RegisterAutostart(
+                    Microsoft.Win32.Registry.CurrentUser,
+                    runSubKey,
+                    @"C:\Program Files\UniGetUI\UniGetUI.exe",
+                    SharedPreUiCommandDispatcher.WindowsCliExitCodes
+                )
+            );
+
+            using Microsoft.Win32.RegistryKey? runKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(runSubKey);
+            Assert.NotNull(runKey);
+            Assert.Equal(
+                Microsoft.Win32.RegistryValueKind.String,
+                runKey.GetValueKind(SharedPreUiCommandDispatcher.AutostartValueName)
+            );
+            Assert.Equal(
+                "\"C:\\Program Files\\UniGetUI\\UniGetUI.exe\" --daemon",
+                runKey.GetValue(SharedPreUiCommandDispatcher.AutostartValueName)
+            );
+        }
+        finally
+        {
+            Microsoft.Win32.Registry.CurrentUser.DeleteSubKeyTree(testRoot, throwOnMissingSubKey: false);
+        }
+    }
+
+    [Fact]
+    public void RegisterAutostart_OverwritesAStaleEntry()
+    {
+        if (!OperatingSystem.IsWindows())
+        {
+            return;
+        }
+
+        string testRoot = $@"Software\UniGetUI.Tests\{Guid.NewGuid():N}";
+        string runSubKey = $@"{testRoot}\Run";
+        try
+        {
+            using (Microsoft.Win32.RegistryKey stale = Microsoft.Win32.Registry.CurrentUser.CreateSubKey(runSubKey))
+            {
+                stale.SetValue(SharedPreUiCommandDispatcher.AutostartValueName, @"C:\Old\WingetUI.exe");
+            }
+
+            SharedPreUiCommandDispatcher.RegisterAutostart(
+                Microsoft.Win32.Registry.CurrentUser,
+                runSubKey,
+                @"D:\Apps\UniGetUI\UniGetUI.exe",
+                SharedPreUiCommandDispatcher.WindowsCliExitCodes
+            );
+
+            using Microsoft.Win32.RegistryKey? runKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(runSubKey);
+            Assert.Equal(
+                "\"D:\\Apps\\UniGetUI\\UniGetUI.exe\" --daemon",
+                runKey?.GetValue(SharedPreUiCommandDispatcher.AutostartValueName)
+            );
+        }
+        finally
+        {
+            Microsoft.Win32.Registry.CurrentUser.DeleteSubKeyTree(testRoot, throwOnMissingSubKey: false);
+        }
+    }
+
     [Theory]
     [InlineData("--help")]
     [InlineData("-h")]