Add .NET tool helpers

Author: Lamparter

src/roslyn/Riverside.CompilerPlatform.Extensions/Helpers/NETCoreToolHelpers.cs

@@ -0,0 +1,74 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Riverside.CompilerPlatform.Helpers;
+
+/// <summary>
+/// Provides helpers for installing and locating .NET tools installed to a specific tool-path directory.
+/// </summary>
+public static class NETCoreToolHelpers
+{
+	/// <summary>
+	/// Returns the full path to the tool executable expected in <paramref name="toolDirectory"/>.
+	/// Appends <c>.exe</c> on Windows; uses the bare name on all other platforms.
+	/// </summary>
+	/// <param name="toolDirectory">The directory the tool was installed into via <c>--tool-path</c>.</param>
+	/// <param name="toolName">The tool executable name (e.g. <c>kiota</c>).</param>
+	/// <returns>The full path including the platform-appropriate extension.</returns>
+	public static string GetExecutablePath(string toolDirectory, string toolName)
+		=> Path.Combine(
+			toolDirectory,
+			Environment.OSVersion.Platform == PlatformID.Win32NT ? toolName + ".exe" : toolName);
+
+	/// <summary>
+	/// Ensures the specified .NET tool is available in <paramref name="toolDirectory"/>.
+	/// </summary>
+	/// <remarks>
+	/// <list type="bullet">
+	///		<item>If the executable already exists and no specific <paramref name="version"/> is requested, the tool is reused immediately.</item>
+	///		<item>Otherwise <c>dotnet tool install</c> is attempted. If it fails because the tool is already installed, <c>dotnet tool update</c> is tried instead.</item>
+	///		<item>Installation succeeds when the executable is present after the above steps.</item>
+	/// </list>
+	/// </remarks>
+	/// <param name="toolName">The NuGet package ID of the tool (e.g. <c>Riverside.JsonBinder.Console</c>).</param>
+	/// <param name="toolDirectory">The directory to install the tool into, passed to <c>--tool-path</c>.</param>
+	/// <param name="version">
+	/// A specific version to pin. Pass <see langword="null"/> to install or keep the latest.
+	/// </param>
+	/// <param name="timeout">Maximum wait time per install or update process. Defaults to 5 minutes.</param>
+	/// <returns>
+	/// A tuple where <c>Success</c> is <see langword="true"/> when the executable is available, and <c>Error</c> carries the captured stderr when installation fails.
+	/// </returns>
+	public static async Task<(bool Success, string? Error)> EnsureToolAsync(
+		string toolName,
+		string toolDirectory,
+		string? version = null,
+		TimeSpan? timeout = null)
+	{
+		var exe = GetExecutablePath(toolDirectory, toolName);
+		var effectiveTimeout = timeout ?? TimeSpan.FromMinutes(5);
+
+		Directory.CreateDirectory(toolDirectory);
+
+		if (File.Exists(exe) && string.IsNullOrWhiteSpace(version))
+			return (true, null);
+
+		var toolPathArg = $"--tool-path \"{toolDirectory}\"";
+		var versionArg = string.IsNullOrWhiteSpace(version) ? string.Empty : $" --version {version}";
+
+		var installResult = await ProcessHelpers.RunNETCoreCliAsync(
+			$"tool install {toolName} {toolPathArg}{versionArg}", effectiveTimeout);
+
+		if (installResult.ExitCode == 0)
+			return (true, null);
+
+		// install exits non-zero when the tool is already present; attempt an update instead
+		var updateResult = await ProcessHelpers.RunNETCoreCliAsync(
+			$"tool update {toolName} {toolPathArg}{versionArg}", effectiveTimeout);
+
+		return File.Exists(exe)
+			? (true, null)
+			: (false, updateResult.StandardError);
+	}
+}

src/roslyn/Riverside.CompilerPlatform.Extensions/Helpers/ProcessHelpers.cs

@@ -49,8 +49,7 @@ public class ProcessOutput(int code, string stdout, string stderr)
 	/// A tuple containing the process exit code, the captured standard output, and the captured standard error.
 	/// If the process times out, the exit code is <c>-1</c> and the standard error includes a timeout message.
 	/// </returns>
-	public static async Task<ProcessOutput>
-		RunProcess(string fileName, string arguments, TimeSpan timeout)
+	public static async Task<ProcessOutput> RunProcess(string fileName, string arguments, TimeSpan timeout)
 	{
 		var psi = new ProcessStartInfo
 		{
@@ -82,4 +81,14 @@ public static async Task<ProcessOutput>
 
 		return new(proc.ExitCode, outputSb.ToString(), errorSb.ToString());
 	}
+
+	/// <summary>
+	/// Runs a <c>dotnet</c> command asynchronously with the specified arguments and timeout,
+	/// capturing its exit code, standard output, and standard error.
+	/// </summary>
+	/// <param name="arguments">The arguments to pass after <c>dotnet</c> (e.g. <c>tool install Riverside.JsonBinder.Console ...</c>).</param>
+	/// <param name="timeout">The maximum duration to wait before forcibly terminating the process.</param>
+	/// <returns>A <see cref="ProcessOutput"/> containing the exit code and captured streams.</returns>
+	public static Task<ProcessOutput> RunNETCoreCliAsync(string arguments, TimeSpan timeout)
+		=> RunProcess("dotnet", arguments, timeout);
 }