受限环境下配置 Windows 开发工具：WSL2 / Pwsh / Windows Terminal / Docker / Aspire

using System.Diagnostics;
using System.Text;
Console.InputEncoding = Encoding.UTF8;
Console.OutputEncoding = Encoding.UTF8;
return await RunAsync(args);
static async Task<int> RunAsync(string[] arguments)
{
    var normalizedArguments = NormalizeArguments(arguments);
    var redirectInput = Console.IsInputRedirected;
    var redirectOutput = Console.IsOutputRedirected;
    var redirectError = Console.IsErrorRedirected;
    var psi = new ProcessStartInfo
    {
        FileName = "wsl.exe",
        UseShellExecute = false,
        RedirectStandardInput = redirectInput,
        RedirectStandardOutput = redirectOutput,
        RedirectStandardError = redirectError,
    };
    psi.ArgumentList.Add("-d");
    psi.ArgumentList.Add("Ubuntu-24.04");
    psi.ArgumentList.Add("-u");
    psi.ArgumentList.Add("dev");
    psi.ArgumentList.Add("--exec");
    psi.ArgumentList.Add("docker");
    foreach (var arg in normalizedArguments)
    {
        psi.ArgumentList.Add(arg);
    }
    using var process = Process.Start(psi) ?? throw new InvalidOperationException("Failed to start wsl.exe.");
    Task copyStdOut = Task.CompletedTask;
    if (redirectOutput)
    {
        copyStdOut = process.StandardOutput.BaseStream.CopyToAsync(Console.OpenStandardOutput());
    }
    Task copyStdErr = Task.CompletedTask;
    if (redirectError)
    {
        copyStdErr = process.StandardError.BaseStream.CopyToAsync(Console.OpenStandardError());
    }
    Task copyStdIn = Task.CompletedTask;
    if (redirectInput)
    {
        copyStdIn = Console.OpenStandardInput()
            .CopyToAsync(process.StandardInput.BaseStream)
            .ContinueWith(_ => process.StandardInput.Close(), TaskScheduler.Default);
    }
    await Task.WhenAll(copyStdOut, copyStdErr, copyStdIn, process.WaitForExitAsync());
    return process.ExitCode;
}
static string[] NormalizeArguments(string[] arguments)
{
    if (arguments.Length == 0)
    {
        return arguments;
    }
    var normalized = new string[arguments.Length];
    string? command = null;
    for (var i = 0; i < arguments.Length; i++)
    {
        var argument = arguments[i];
        if (command is null && !argument.StartsWith("-", StringComparison.Ordinal))
        {
            command = argument;
            normalized[i] = argument;
            continue;
        }
        var previous = i > 0 ? arguments[i - 1] : null;
        normalized[i] = NormalizeArgument(argument, previous, command);
    }
    return normalized;
}
static string NormalizeArgument(string argument, string? previousArgument, string? command)
{
    if (RequiresPathValue(previousArgument))
    {
        return ConvertWindowsPath(argument);
    }
    if (TryNormalizeFlagAssignment(argument, out var normalizedFlag))
    {
        return normalizedFlag;
    }
    if (TryNormalizeVolume(argument, previousArgument, out var normalizedVolume))
    {
        return normalizedVolume;
    }
    if (TryNormalizeMount(argument, out var normalizedMount))
    {
        return normalizedMount;
    }
    if (IsBuildContext(command, argument))
    {
        return ConvertWindowsPath(argument);
    }
    return ConvertWindowsPath(argument);
}
static bool RequiresPathValue(string? previousArgument) =>
    previousArgument is "-f" or "--file" or "--iidfile" or "--cidfile" or "--env-file" or "--label-file";
static bool TryNormalizeFlagAssignment(string argument, out string normalized)
{
    foreach (var flag in new[] { "--file=", "--iidfile=", "--cidfile=", "--env-file=", "--label-file=" })
    {
        if (argument.StartsWith(flag, StringComparison.Ordinal))
        {
            normalized = flag + ConvertWindowsPath(argument[flag.Length..]);
            return true;
        }
    }
    normalized = argument;
    return false;
}
static bool TryNormalizeVolume(string argument, string? previousArgument, out string normalized)
{
    if (previousArgument is not "-v" and not "--volume")
    {
        normalized = argument;
        return false;
    }
    normalized = NormalizeVolumeSpec(argument);
    return true;
}
static bool TryNormalizeMount(string argument, out string normalized)
{
    const string prefix = "--mount=";
    if (!argument.StartsWith(prefix, StringComparison.Ordinal))
    {
        normalized = argument;
        return false;
    }
    var spec = argument[prefix.Length..];
    var parts = spec.Split(',');
    for (var i = 0; i < parts.Length; i++)
    {
        var separatorIndex = parts[i].IndexOf('=');
        if (separatorIndex <= 0)
        {
            continue;
        }
        var key = parts[i][..separatorIndex];
        if (!key.Equals("src", StringComparison.OrdinalIgnoreCase) &&
            !key.Equals("source", StringComparison.OrdinalIgnoreCase))
        {
            continue;
        }
        var value = parts[i][(separatorIndex + 1)..];
        parts[i] = $"{key}={ConvertWindowsPath(value)}";
    }
    normalized = prefix + string.Join(",", parts);
    return true;
}
static bool IsBuildContext(string? command, string argument) =>
    (string.Equals(command, "build", StringComparison.Ordinal) ||
     string.Equals(command, "buildx", StringComparison.Ordinal)) &&
    IsWindowsPath(argument);
static string NormalizeVolumeSpec(string value)
{
    if (!TrySplitWindowsVolume(value, out var hostPath, out var remainder))
    {
        return value;
    }
    return $"{ConvertWindowsPath(hostPath)}:{remainder}";
}
static bool TrySplitWindowsVolume(string value, out string hostPath, out string remainder)
{
    hostPath = string.Empty;
    remainder = string.Empty;
    if (value.Length < 3 || !char.IsLetter(value[0]) || value[1] != ':' || (value[2] != '\\' && value[2] != '/'))
    {
        return false;
    }
    var separatorIndex = value.IndexOf(':', 3);
    if (separatorIndex < 0)
    {
        return false;
    }
    hostPath = value[..separatorIndex];
    remainder = value[(separatorIndex + 1)..];
    return true;
}
static string ConvertWindowsPath(string value)
{
    if (!IsWindowsPath(value))
    {
        return value;
    }
    var drive = char.ToLowerInvariant(value[0]);
    var path = value[2..].Replace('\\', '/');
    if (!path.StartsWith('/'))
    {
        path = "/" + path;
    }
    return $"/mnt/{drive}{path}";
}
static bool IsWindowsPath(string value) =>
    value.Length >= 3 &&
    char.IsLetter(value[0]) &&
    value[1] == ':' &&
    (value[2] == '\\' || value[2] == '/');