feat: Windows optional features toggle tab

CHANGELOG.md

@@ -6,6 +6,15 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.46.0] - 2026-05-13
+
+### Added
+- **Windows Features tab** — list, enable, and disable Windows optional
+  features (Hyper-V, WSL, .NET 3.5, Telnet, etc.) directly from SysManager.
+  Features are categorized (Virtualization, Networking, Development, Media,
+  Legacy). Toggle requires admin. Shows reboot-required status. Includes
+  search/filter. Closes #5.
+
 ## [0.45.0] - 2026-05-13
 
 ### Added

README.md

@@ -43,7 +43,7 @@ implemented; 12 are work-in-progress placeholders marked with ⚙️:
 | Group | Tabs |
 |-------|------|
 | 🏠 Dashboard | Dashboard |
-| 🔧 System | System Health · Windows Update · Performance Mode · Services · Startup Manager · Windows Features ⚙️ |
+| 🔧 System | System Health · Windows Update · Performance Mode · Services · Startup Manager · Windows Features |
 | 📊 Monitor | Process Manager · Resource History ⚙️ · App Alerts · Privacy Monitor ⚙️ |
 | 🧹 Cleanup | Quick Cleanup · Deep Cleanup · Shortcut Cleaner · File Shredder ⚙️ |
 | 💾 Storage | Disk Analyzer · Duplicate Finder |
@@ -142,6 +142,14 @@ long-running operation, so you always know which tab is working.
 - Shows name, publisher, command, and enabled/disabled status
 - Open file location in Explorer
 
+### Windows Features
+- Lists all Windows optional features with current state (Enabled/Disabled)
+- Toggle enable/disable per feature with confirmation dialog
+- Categorized: Virtualization, Networking, Development, Media & Print, Legacy
+- Shows reboot-required status after toggling
+- Search/filter across all features
+- Requires administrator privileges for modifications
+
 ### Duplicate File Finder
 - Two-pass scan: group by size, then SHA-256 hash only size-matched files
 - Duplicate groups sorted by wasted space (descending)

SysManager/SysManager.Tests/WindowsFeaturesTests.cs

@@ -0,0 +1,132 @@
+// SysManager · WindowsFeaturesTests
+// Author: laurentiu021 · https://github.com/laurentiu021/SystemManager
+// License: MIT
+
+using SysManager.Models;
+using SysManager.Services;
+using SysManager.ViewModels;
+using Xunit;
+
+namespace SysManager.Tests;
+
+/// <summary>
+/// Tests for <see cref="WindowsFeaturesService"/> and <see cref="WindowsFeaturesViewModel"/>.
+/// </summary>
+public class WindowsFeaturesTests
+{
+    // ── ParseFeatureList ──
+
+    [Fact]
+    public void ParseFeatureList_EmptyInput_ReturnsEmpty()
+    {
+        var result = WindowsFeaturesService.ParseFeatureList(new List<string>());
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void ParseFeatureList_ValidLines_ParsesCorrectly()
+    {
+        var lines = new List<string>
+        {
+            "Microsoft-Hyper-V-All|Enabled",
+            "TelnetClient|Disabled",
+            "NetFx3|Enabled"
+        };
+
+        var result = WindowsFeaturesService.ParseFeatureList(lines);
+
+        Assert.Equal(3, result.Count);
+        var hyperV = result.First(f => f.Name == "Microsoft-Hyper-V-All");
+        Assert.True(hyperV.IsEnabled);
+        Assert.Equal("Virtualization", hyperV.Category);
+
+        var telnet = result.First(f => f.Name == "TelnetClient");
+        Assert.False(telnet.IsEnabled);
+        Assert.Equal("Networking", telnet.Category);
+    }
+
+    [Fact]
+    public void ParseFeatureList_SkipsBlankLines()
+    {
+        var lines = new List<string>
+        {
+            "",
+            "  ",
+            "SomeFeature|Disabled",
+            ""
+        };
+
+        var result = WindowsFeaturesService.ParseFeatureList(lines);
+        Assert.Single(result);
+    }
+
+    [Fact]
+    public void ParseFeatureList_SkipsInvalidLines()
+    {
+        var lines = new List<string>
+        {
+            "NoSeparator",
+            "|Enabled",
+            "ValidFeature|Disabled"
+        };
+
+        var result = WindowsFeaturesService.ParseFeatureList(lines);
+        Assert.Single(result);
+        Assert.Equal("ValidFeature", result[0].Name);
+    }
+
+    // ── CategorizeFeature ──
+
+    [Theory]
+    [InlineData("Microsoft-Hyper-V-All", "Virtualization")]
+    [InlineData("VirtualMachinePlatform", "Virtualization")]
+    [InlineData("Microsoft-Windows-Subsystem-Linux", "Virtualization")]
+    [InlineData("Containers", "Virtualization")]
+    [InlineData("Windows-Sandbox", "Virtualization")]
+    [InlineData("TelnetClient", "Networking")]
+    [InlineData("IIS-WebServer", "Networking")]
+    [InlineData("SMB1Protocol", "Networking")]
+    [InlineData("NetFx3", "Development")]
+    [InlineData("Microsoft-Windows-Developer-Mode", "Development")]
+    [InlineData("OpenSSH-Client", "Development")]
+    [InlineData("MediaPlayback", "Media & Print")]
+    [InlineData("Printing-XPSServices-Features", "Media & Print")]
+    [InlineData("DirectPlay", "Legacy")]
+    [InlineData("SomeRandomFeature", "Other")]
+    public void CategorizeFeature_AssignsCorrectCategory(string featureName, string expected)
+    {
+        Assert.Equal(expected, WindowsFeature.CategorizeFeature(featureName));
+    }
+
+    [Fact]
+    public void CategorizeFeature_NullOrEmpty_ReturnsOther()
+    {
+        Assert.Equal("Other", WindowsFeature.CategorizeFeature(null!));
+        Assert.Equal("Other", WindowsFeature.CategorizeFeature(""));
+        Assert.Equal("Other", WindowsFeature.CategorizeFeature("   "));
+    }
+
+    // ── HumanizeName ──
+
+    [Theory]
+    [InlineData("Microsoft-Hyper-V-All", "Microsoft Hyper V All")]
+    [InlineData("TelnetClient", "TelnetClient")]
+    [InlineData("Some_Feature_Name", "Some Feature Name")]
+    public void HumanizeName_ReplacesDelimiters(string input, string expected)
+    {
+        Assert.Equal(expected, WindowsFeaturesService.HumanizeName(input));
+    }
+
+    // ── ViewModel ──
+
+    [Fact]
+    public void ViewModel_InitialState_IsCorrect()
+    {
+        var vm = new WindowsFeaturesViewModel(new PowerShellRunner());
+        Assert.Empty(vm.AllFeatures);
+        Assert.Empty(vm.FilteredFeatures);
+        Assert.Equal("", vm.FilterText);
+        Assert.Equal(0, vm.FeatureCount);
+        Assert.False(vm.PendingReboot);
+    }
+}

SysManager/SysManager/Models/WindowsFeature.cs

@@ -0,0 +1,55 @@
+// SysManager · WindowsFeature — model for Windows optional features
+// Author: laurentiu021 · https://github.com/laurentiu021/SystemManager
+// License: MIT
+
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace SysManager.Models;
+
+/// <summary>
+/// Represents a Windows optional feature with its current state.
+/// </summary>
+public partial class WindowsFeature : ObservableObject
+{
+    [ObservableProperty] private string _name = "";
+    [ObservableProperty] private string _displayName = "";
+    [ObservableProperty] private bool _isEnabled;
+    [ObservableProperty] private bool _requiresReboot;
+    [ObservableProperty] private string _category = "Other";
+    [ObservableProperty] private string _status = "";
+
+    /// <summary>Category assignment based on feature name patterns.</summary>
+    public static string CategorizeFeature(string featureName)
+    {
+        if (string.IsNullOrWhiteSpace(featureName)) return "Other";
+
+        var name = featureName.ToUpperInvariant();
+
+        if (name.Contains("HYPER") || name.Contains("VIRTUAL") ||
+            name.Contains("CONTAINER") || name.Contains("SANDBOX") ||
+            name.Contains("WSL") || name.Contains("LINUX"))
+            return "Virtualization";
+
+        if (name.Contains("IIS") || name.Contains("INTERNET") ||
+            name.Contains("TFTP") || name.Contains("TELNET") ||
+            name.Contains("SMB") || name.Contains("NFS") ||
+            name.Contains("SNMP") || name.Contains("RIP"))
+            return "Networking";
+
+        if (name.Contains("NETFX") || name.Contains(".NET") ||
+            name.Contains("DEVELOPER") || name.Contains("POWERSHELL") ||
+            name.Contains("OPENSSH") || name.Contains("BASH"))
+            return "Development";
+
+        if (name.Contains("MEDIA") || name.Contains("PRINT") ||
+            name.Contains("XPS") || name.Contains("PDF") ||
+            name.Contains("SCAN") || name.Contains("FAX"))
+            return "Media & Print";
+
+        if (name.Contains("LEGACY") || name.Contains("DIRECTPLAY") ||
+            name.Contains("INDEXING") || name.Contains("WORK"))
+            return "Legacy";
+
+        return "Other";
+    }
+}

SysManager/SysManager/ServiceRegistration.cs

@@ -53,6 +53,8 @@ public static IServiceCollection ConfigureServices(this IServiceCollection servi
         services.AddSingleton<ServicesViewModel>();
         services.AddSingleton<AppAlertsViewModel>();
         services.AddSingleton<ShortcutCleanerViewModel>();
+        services.AddSingleton<WindowsFeaturesService>();
+        services.AddSingleton<WindowsFeaturesViewModel>();
         services.AddSingleton<AppBlockerViewModel>();
 
         return services;

SysManager/SysManager/Services/WindowsFeaturesService.cs

@@ -0,0 +1,161 @@
+// SysManager · WindowsFeaturesService — list and toggle Windows optional features
+// Author: laurentiu021 · https://github.com/laurentiu021/SystemManager
+// License: MIT
+
+using System.Text.RegularExpressions;
+using Serilog;
+using SysManager.Models;
+
+namespace SysManager.Services;
+
+/// <summary>
+/// Wraps PowerShell commands to list, enable, and disable Windows optional features.
+/// Requires administrator privileges for enable/disable operations.
+/// </summary>
+public sealed partial class WindowsFeaturesService
+{
+    private readonly PowerShellRunner _runner;
+
+    public WindowsFeaturesService(PowerShellRunner runner) => _runner = runner;
+
+    /// <summary>
+    /// Lists all Windows optional features with their current state.
+    /// Uses Get-WindowsOptionalFeature -Online.
+    /// </summary>
+    public async Task<List<WindowsFeature>> ListFeaturesAsync(CancellationToken ct = default)
+    {
+        var captured = new List<string>();
+        void Collect(PowerShellLine l)
+        {
+            if (l.Kind == OutputKind.Output) captured.Add(l.Text);
+        }
+
+        _runner.LineReceived += Collect;
+        try
+        {
+            await _runner.RunProcessAsync("powershell",
+                "-NoProfile -Command \"Get-WindowsOptionalFeature -Online | " +
+                "Select-Object FeatureName, State | " +
+                "ForEach-Object { $_.FeatureName + '|' + $_.State }\"", ct);
+        }
+        finally { _runner.LineReceived -= Collect; }
+
+        return ParseFeatureList(captured);
+    }
+
+    /// <summary>
+    /// Enables a Windows optional feature. Requires admin.
+    /// Returns true if successful, false otherwise.
+    /// </summary>
+    public async Task<(bool Success, bool RebootRequired)> EnableFeatureAsync(
+        string featureName, CancellationToken ct = default)
+    {
+        if (string.IsNullOrWhiteSpace(featureName) || !FeatureNamePattern().IsMatch(featureName))
+            throw new ArgumentException("Invalid feature name.", nameof(featureName));
+
+        Log.Information("Enabling Windows feature: {Feature}", featureName);
+
+        var captured = new List<string>();
+        void Collect(PowerShellLine l)
+        {
+            if (l.Kind == OutputKind.Output) captured.Add(l.Text);
+        }
+
+        _runner.LineReceived += Collect;
+        try
+        {
+            var code = await _runner.RunProcessAsync("powershell",
+                $"-NoProfile -Command \"Enable-WindowsOptionalFeature -Online " +
+                $"-FeatureName '{featureName}' -NoRestart -All | " +
+                $"Select-Object RestartNeeded | ForEach-Object {{ $_.RestartNeeded }}\"", ct);
+
+            var reboot = captured.Any(l =>
+                l.Contains("True", StringComparison.OrdinalIgnoreCase));
+
+            return (code == 0, reboot);
+        }
+        finally { _runner.LineReceived -= Collect; }
+    }
+
+    /// <summary>
+    /// Disables a Windows optional feature. Requires admin.
+    /// Returns true if successful, false otherwise.
+    /// </summary>
+    public async Task<(bool Success, bool RebootRequired)> DisableFeatureAsync(
+        string featureName, CancellationToken ct = default)
+    {
+        if (string.IsNullOrWhiteSpace(featureName) || !FeatureNamePattern().IsMatch(featureName))
+            throw new ArgumentException("Invalid feature name.", nameof(featureName));
+
+        Log.Information("Disabling Windows feature: {Feature}", featureName);
+
+        var captured = new List<string>();
+        void Collect(PowerShellLine l)
+        {
+            if (l.Kind == OutputKind.Output) captured.Add(l.Text);
+        }
+
+        _runner.LineReceived += Collect;
+        try
+        {
+            var code = await _runner.RunProcessAsync("powershell",
+                $"-NoProfile -Command \"Disable-WindowsOptionalFeature -Online " +
+                $"-FeatureName '{featureName}' -NoRestart | " +
+                $"Select-Object RestartNeeded | ForEach-Object {{ $_.RestartNeeded }}\"", ct);
+
+            var reboot = captured.Any(l =>
+                l.Contains("True", StringComparison.OrdinalIgnoreCase));
+
+            return (code == 0, reboot);
+        }
+        finally { _runner.LineReceived -= Collect; }
+    }
+
+    /// <summary>Parses the pipe-delimited feature list output.</summary>
+    internal static List<WindowsFeature> ParseFeatureList(List<string> lines)
+    {
+        var features = new List<WindowsFeature>();
+
+        foreach (var line in lines)
+        {
+            if (string.IsNullOrWhiteSpace(line)) continue;
+
+            var parts = line.Split('|', 2);
+            if (parts.Length < 2) continue;
+
+            var name = parts[0].Trim();
+            var state = parts[1].Trim();
+
+            if (string.IsNullOrWhiteSpace(name)) continue;
+
+            var isEnabled = state.Equals("Enabled", StringComparison.OrdinalIgnoreCase);
+
+            features.Add(new WindowsFeature
+            {
+                Name = name,
+                DisplayName = HumanizeName(name),
+                IsEnabled = isEnabled,
+                Category = WindowsFeature.CategorizeFeature(name)
+            });
+        }
+
+        return features.OrderBy(f => f.Category)
+                       .ThenBy(f => f.DisplayName)
+                       .ToList();
+    }
+
+    /// <summary>
+    /// Converts PascalCase feature names to human-readable form.
+    /// e.g. "Microsoft-Hyper-V-All" → "Microsoft Hyper-V All"
+    /// </summary>
+    internal static string HumanizeName(string featureName)
+    {
+        return featureName.Replace('-', ' ').Replace('_', ' ');
+    }
+
+    /// <summary>
+    /// Validates feature names: alphanumeric, hyphens, underscores, dots. Max 128 chars.
+    /// </summary>
+    [GeneratedRegex(@"^[\w.\-]{1,128}$")]
+    private static partial Regex FeatureNamePattern();
+}