fix(shell): add 10s/30s kill-on-timeout to ShellRunner.Run/RunPowerShell

Prevents auditpol.exe and other system tools from hanging the test host
indefinitely on Intune/corporate machines. Process tree is killed after
the timeout and (-1, string.Empty, 'timeout') is returned.

Also removes [Fact(Skip=...)] from ToolVersionChecker_CheckAll_ReturnsResults:
test gracefully handles missing tools (returns IsInstalled=false per tool)
and passes on CI without any tools installed. Timeout raised 10s->60s.

Total: 7,479 tweaks, 3,231 tests (0 failures, 0 skipped)

Author: RajwanYair

src/RegiLattice.Core/Services/ShellRunner.cs

@@ -12,7 +12,7 @@ namespace RegiLattice.Core;
 /// </summary>
 public static class ShellRunner
 {
-    /// <summary>Run a process with explicit argument list.</summary>
+    /// <summary>Run a process with explicit argument list. Kills the process if <paramref name="ct"/> is cancelled.</summary>
     public static async Task<(int ExitCode, string StdOut, string StdErr)> RunAsync(
         string fileName,
         IEnumerable<string> args,
@@ -38,18 +38,50 @@ public static class ShellRunner
         proc.Start();
         var stdoutTask = proc.StandardOutput.ReadToEndAsync(ct);
         var stderrTask = proc.StandardError.ReadToEndAsync(ct);
-        await proc.WaitForExitAsync(ct).ConfigureAwait(false);
+        try
+        {
+            await proc.WaitForExitAsync(ct).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            try { proc.Kill(entireProcessTree: true); } catch (InvalidOperationException) { }
+            return (-1, string.Empty, "timeout");
+        }
         return (proc.ExitCode, await stdoutTask.ConfigureAwait(false), await stderrTask.ConfigureAwait(false));
     }
 
     /// <summary>Run a PowerShell -Command script.</summary>
     public static Task<(int ExitCode, string StdOut, string StdErr)> RunPowerShellAsync(string script, CancellationToken ct = default) =>
         RunAsync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], ct);
 
-    /// <summary>Synchronous wrapper for RunAsync (used by TweakDef delegates).</summary>
-    public static (int ExitCode, string StdOut, string StdErr) Run(string fileName, IEnumerable<string> args) =>
-        RunAsync(fileName, args).GetAwaiter().GetResult();
+    /// <summary>
+    /// Synchronous wrapper for RunAsync (used by TweakDef delegates).
+    /// Kills the process after <paramref name="timeoutMs"/> milliseconds (default 10 s).
+    /// </summary>
+    public static (int ExitCode, string StdOut, string StdErr) Run(string fileName, IEnumerable<string> args, int timeoutMs = 10_000)
+    {
+        using var cts = new CancellationTokenSource(timeoutMs);
+        try
+        {
+            return RunAsync(fileName, args, cts.Token).GetAwaiter().GetResult();
+        }
+        catch (OperationCanceledException)
+        {
+            return (-1, string.Empty, "timeout");
+        }
+    }
 
-    /// <summary>Synchronous wrapper for RunPowerShellAsync.</summary>
-    public static (int ExitCode, string StdOut, string StdErr) RunPowerShell(string script) => RunPowerShellAsync(script).GetAwaiter().GetResult();
+    /// <summary>Synchronous wrapper for RunPowerShellAsync (default 30 s timeout).</summary>
+    public static (int ExitCode, string StdOut, string StdErr) RunPowerShell(string script, int timeoutMs = 30_000)
+    {
+        using var cts = new CancellationTokenSource(timeoutMs);
+        try
+        {
+            return RunPowerShellAsync(script, cts.Token).GetAwaiter().GetResult();
+        }
+        catch (OperationCanceledException)
+        {
+            return (-1, string.Empty, "timeout");
+        }
+    }
 }

tests/RegiLattice.GUI.Tests/PackageManagerValidationTests.cs

@@ -108,14 +108,15 @@ public void ToolInfo_NotInstalled_NullVersion()
         Assert.False(info.IsInstalled);
     }
 
-    // Integration test — spawns 16 real processes; excluded from normal test runs.
-    [Fact(Skip = "Integration: spawns 16 real processes to detect installed tool versions. Run manually only.")]
+    // Budget: 60s — spawns 16 parallel process checks; all return quickly even when
+    // tools are not installed (gracefully returns ToolInfo with IsInstalled=false).
+    [Fact]
     public async Task ToolVersionChecker_CheckAll_ReturnsResults()
     {
-        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
         var results = await ToolVersionChecker.CheckAllAsync(cts.Token);
         Assert.NotEmpty(results);
-        Assert.Equal(16, results.Count);
+        Assert.Equal(16, results.Count); // 16 entries in CheckAllAsync — update if tool list changes
         Assert.All(results, r => Assert.NotNull(r.Name));
     }