Implement programmatic elevation and improve backup button clarity

Programmatic Elevation (inspired by anthonysimmon.com/programmatically-elevate-dotnet-app-on-any-platform/):
- Added Utilities/ElevationHelper.cs for cross-platform elevation detection and relaunching
- Modified App.xaml.cs to automatically detect if not elevated and relaunch with UAC
- Changed app.manifest from requireAdministrator to asInvoker (elevation now programmatic)
- This allows 'dotnet run' to work properly - app will prompt for UAC and relaunch elevated
- Graceful degradation: warns user if UAC declined but continues with limited functionality

Backup Button Improvements:
- Context Menus tab: Button now says "Backup Context Menus" (was "Backup Registry Entries")
- Startup Programs tab: Button now says "Backup Startup Items" (was "Backup Registry Entries")
- Makes it immediately clear what each backup button will save
- Dialog titles were already context-specific, now buttons match

Helper Scripts (legacy support):
- Added run.ps1, run-elevated.ps1, run.cmd for manual elevation
- These are now optional since the app handles elevation automatically

Benefits:
- 'dotnet run' now works seamlessly with elevation
- No need to run VS Code as administrator
- Better user experience with automatic UAC prompt
- Clearer UI for backup operations on each tab

Technical Details:
- Uses WindowsIdentity/WindowsPrincipal to detect admin rights
- ProcessStartInfo with Verb="runas" for UAC elevation
- Passes original command-line args to elevated instance
- Handles Win32Exception when user declines UAC

Author: mtg-eagletg

App.xaml.cs

@@ -13,6 +13,26 @@ protected override void OnStartup(StartupEventArgs e)
     {
         base.OnStartup(e);
 
+        // Check if running with administrator privileges, relaunch if needed
+        if (ElevationHelper.TryRelaunchElevated(e.Args))
+        {
+            // Elevated process was launched, shut down this instance
+            Shutdown();
+            return;
+        }
+        
+        // If we get here, we're either elevated or user declined UAC
+        if (!ElevationHelper.IsElevated())
+        {
+            // User declined elevation - show warning and continue (limited functionality)
+            MessageBox.Show(
+                "Context Menu Editor requires administrator privileges to modify registry entries.\n\n" +
+                "The application will start, but registry operations may fail.",
+                "Administrator Rights Required",
+                MessageBoxButton.OK,
+                MessageBoxImage.Warning);
+        }
+        
         // Initialize theme manager (dark mode by default)
         _ = ThemeManager.Instance;
 

Utilities/ElevationHelper.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Security.Principal;
+
+namespace ContextMenuEditor.Utilities;
+
+/// <summary>
+/// Helper class for detecting and requesting elevation (admin rights).
+/// Based on: https://anthonysimmon.com/programmatically-elevate-dotnet-app-on-any-platform/
+/// </summary>
+public static class ElevationHelper
+{
+    /// <summary>
+    /// Checks if the current process is running with administrator privileges.
+    /// </summary>
+    /// <returns>True if elevated, false otherwise.</returns>
+    public static bool IsElevated()
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            using var identity = WindowsIdentity.GetCurrent();
+            var principal = new WindowsPrincipal(identity);
+            return principal.IsInRole(WindowsBuiltInRole.Administrator);
+        }
+
+        // On Linux/macOS, check if running as root (UID 0)
+        // Not applicable for this Windows-only WPF app, but included for completeness
+        return geteuid() == 0;
+    }
+
+    /// <summary>
+    /// Attempts to restart the current application with elevated privileges.
+    /// Returns true if the restart was initiated, false if already elevated or failed.
+    /// </summary>
+    /// <param name="args">Command-line arguments to pass to the elevated instance.</param>
+    /// <returns>True if relaunch initiated (caller should exit), false if already elevated.</returns>
+    public static bool TryRelaunchElevated(string[] args)
+    {
+        if (IsElevated())
+        {
+            return false; // Already elevated, no need to relaunch
+        }
+
+        try
+        {
+            var currentProcessPath = Environment.ProcessPath 
+                ?? throw new InvalidOperationException("Cannot determine current process path");
+
+            var startInfo = new ProcessStartInfo
+            {
+                UseShellExecute = true,
+                FileName = currentProcessPath,
+                Verb = "runas" // Windows UAC elevation
+            };
+
+            // Pass along original command-line arguments
+            foreach (var arg in args)
+            {
+                startInfo.ArgumentList.Add(arg);
+            }
+
+            Process.Start(startInfo);
+            return true; // Successfully started elevated process, caller should exit
+        }
+        catch (System.ComponentModel.Win32Exception)
+        {
+            // User declined UAC prompt
+            return false;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Failed to elevate: {ex.Message}");
+            return false;
+        }
+    }
+
+    // P/Invoke for Unix systems (not used in this Windows-only app, but included for reference)
+    [DllImport("libc", SetLastError = true)]
+    private static extern uint geteuid();
+}

Views/MainWindow.xaml

@@ -89,7 +89,7 @@
                                     Command="{Binding DeleteCommand}"
                                     IsEnabled="{Binding HasSelection}"/>
                             <Separator Margin="0,8"/>
-                            <Button Content="Backup Registry Entries" 
+                            <Button Content="Backup Context Menus" 
                                     Command="{Binding BackupCommand}"/>
                         </StackPanel>
                     </Border>

Views/StartupView.xaml

@@ -67,7 +67,7 @@
                             Command="{Binding DeleteCommand}"
                             IsEnabled="{Binding HasSelection}"/>
                     <Separator Margin="0,8"/>
-                    <Button Content="Backup Registry Entries" 
+                    <Button Content="Backup Startup Items" 
                             Command="{Binding BackupCommand}"/>
                 </StackPanel>
             </Border>

app.manifest

@@ -6,18 +6,11 @@
     <security>
       <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
         <!-- UAC Manifest Options
-             If you want to change the Windows User Account Control level replace the 
-             requestedExecutionLevel node with one of the following.
-
-        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
-        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
-        <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
-
-             Specifying requestedExecutionLevel element will disable file and registry virtualization. 
-             Remove this element if your application requires this virtualization for backwards
-             compatibility.
+             Changed to asInvoker because elevation is now handled programmatically in App.xaml.cs
+             The application will detect if it's not elevated and relaunch itself with admin rights.
+             This allows 'dotnet run' to work properly during development.
         -->
-        <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
+        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
       </requestedPrivileges>
     </security>
   </trustInfo>

run-elevated.ps1

@@ -0,0 +1,22 @@
+# Run Context Menu Editor with Administrator privileges
+# This script builds and runs the application with UAC elevation
+
+Write-Host "Building Context Menu Editor..." -ForegroundColor Cyan
+dotnet build
+
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "Build successful! Launching with administrator privileges..." -ForegroundColor Green
+    
+    # Get the executable path
+    $exePath = ".\bin\Debug\net8.0-windows\win-x64\ContextMenuEditor.exe"
+    
+    if (Test-Path $exePath) {
+        Start-Process -FilePath $exePath -Verb RunAs
+        Write-Host "Application launched." -ForegroundColor Green
+    } else {
+        Write-Host "Error: Executable not found at $exePath" -ForegroundColor Red
+        Write-Host "Try running 'dotnet build' first." -ForegroundColor Yellow
+    }
+} else {
+    Write-Host "Build failed. Please fix errors and try again." -ForegroundColor Red
+}

run.cmd

@@ -0,0 +1,11 @@
+@echo off
+REM Build and run Context Menu Editor with elevation
+echo Building...
+dotnet build
+if %ERRORLEVEL% EQU 0 (
+    echo Launching with administrator privileges...
+    powershell -Command "Start-Process '.\bin\Debug\net8.0-windows\win-x64\ContextMenuEditor.exe' -Verb RunAs"
+) else (
+    echo Build failed.
+    exit /b 1
+)

run.ps1

@@ -0,0 +1,12 @@
+# Quick run - just launch the already-built executable with elevation
+# Use this if you've already built the app and just want to run it
+
+$exePath = ".\bin\Debug\net8.0-windows\win-x64\ContextMenuEditor.exe"
+
+if (Test-Path $exePath) {
+    Write-Host "Launching Context Menu Editor with administrator privileges..." -ForegroundColor Cyan
+    Start-Process -FilePath $exePath -Verb RunAs
+} else {
+    Write-Host "Error: Executable not found." -ForegroundColor Red
+    Write-Host "Run './run-elevated.ps1' to build and run." -ForegroundColor Yellow
+}