Dotnetup: add env command to update PathPreference mode

src/Installer/Microsoft.Dotnet.Installation/DotnetInstallException.cs

@@ -118,6 +118,15 @@ public enum DotnetInstallErrorCode
     /// <summary>An IT-managed policy requires code-signed downloads, so the install was blocked before falling back to the blob feed where only SHA-512 verification is performed.</summary>
     UnsignedDownloadBlockedByPolicy,
 
+    /// <summary>
+    /// The user supplied invalid or mutually-exclusive command-line arguments (for example
+    /// combining <c>--dotnetup-only</c> with <c>--dotnet</c>/<c>--dotnetup</c>, or invoking a
+    /// command that requires an argument with none provided and no stored default). Distinct from
+    /// <see cref="Unknown"/> so the telemetry classifier routes it to the User category — it's
+    /// bad input, not a product failure.
+    /// </summary>
+    InvalidArguments,
+
     /// <summary>
     /// The release exists for the platform but publishes no archive that dotnetup can install
     /// at the user level with only non-installable artifacts such as .exe installers.

src/Installer/dotnetup.Library/Commands/Env/EnvClearCommand.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Tools.Bootstrapper.Shell;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Env;
+
+/// <summary>
+/// Fully removes everything dotnetup wrote into the environment: equivalent to
+/// <c>env set none --dotnetup-on-path false</c>. Removes the managed profile block and the
+/// dotnetup PATH entry, leaving no dotnet access and no dotnetup-on-PATH. The closest thing
+/// to an "env uninstall" since dotnetup has no uninstall command.
+/// </summary>
+internal class EnvClearCommand : CommandBase
+{
+    private readonly IDotnetEnvironmentManager _dotnetEnvironment;
+    private readonly IEnvironmentStateInspector _inspector;
+    private readonly IEnvShellProvider? _shellProvider;
+
+    public EnvClearCommand(ParseResult result, IDotnetEnvironmentManager? dotnetEnvironment = null, IEnvironmentStateInspector? inspector = null) : base(result)
+    {
+        _dotnetEnvironment = dotnetEnvironment ?? new DotnetEnvironmentManager();
+        _inspector = inspector ?? new EnvironmentStateInspector(_dotnetEnvironment);
+        _shellProvider = result.GetValue(CommonOptions.ShellOption);
+    }
+
+    protected override string GetCommandName() => "env clear";
+
+    protected override void ExecuteCore()
+    {
+        EnvSettingsWriter.ApplyAndPersist(
+            DotnetAccessMode.None,
+            targetDotnetupOnPath: false,
+            _dotnetEnvironment,
+            _shellProvider,
+            _inspector);
+    }
+}

src/Installer/dotnetup.Library/Commands/Env/EnvClearCommandParser.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Env;
+
+internal static class EnvClearCommandParser
+{
+    public static Command ConstructCommand()
+    {
+        Command command = new("clear", Strings.EnvClearCommandDescription);
+        command.Options.Add(CommonOptions.ShellOption);
+        command.SetAction(parseResult => new EnvClearCommand(parseResult).Execute());
+        return command;
+    }
+}

src/Installer/dotnetup.Library/Commands/Env/EnvCommandParser.cs

@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Env;
+
+internal static class EnvCommandParser
+{
+    private static readonly Command s_envCommand = ConstructCommand();
+
+    public static Command GetCommand() => s_envCommand;
+
+    private static Command ConstructCommand()
+    {
+        Command command = new("env", Strings.EnvCommandDescription);
+
+        command.Subcommands.Add(EnvSetCommandParser.ConstructCommand());
+        command.Subcommands.Add(EnvClearCommandParser.ConstructCommand());
+        command.Subcommands.Add(EnvShowCommandParser.ConstructCommand());
+        command.Subcommands.Add(EnvScriptCommandParser.ConstructCommand(name: "script"));
+
+        return command;
+    }
+}
+

src/Installer/dotnetup.Library/Commands/Env/EnvDriftAnalyzer.cs

@@ -0,0 +1,64 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Globalization;
+
+namespace Microsoft.DotNet.Tools.Bootstrapper.Commands.Env;
+
+/// <summary>
+/// Comparison of desired versus observed config. Produces human-readable descriptions. Uses unit-testable
+/// snapshots.
+/// </summary>
+internal static class EnvDriftAnalyzer
+{
+    public static IReadOnlyList<string> Compare(DotnetupConfigData config, ObservedEnvironmentState observed)
+    {
+        var drift = new List<string>();
+
+        bool expectsProfileDotnet = config.AccessMode is DotnetAccessMode.Shell or DotnetAccessMode.Everywhere;
+        bool expectsProfileBlock = expectsProfileDotnet || config.DotnetupOnPath;
+        bool expectsDotnetEnvVars = config.AccessMode == DotnetAccessMode.Everywhere;
+
+        // Profile-block presence: only assert when the profile state is known.
+        if (observed.ProfileBlock is not ProfileBlockState.Unknown)
+        {
+            bool profileBlockPresent = observed.ProfileBlock is ProfileBlockState.Present;
+            if (expectsProfileBlock && !profileBlockPresent)
+            {
+                drift.Add(Strings.EnvDriftProfileBlockMissing);
+            }
+            else if (!expectsProfileBlock && profileBlockPresent)
+            {
+                drift.Add(Strings.EnvDriftProfileBlockUnexpected);
+            }
+        }
+
+        if (OperatingSystem.IsWindows())
+        {
+            if (expectsDotnetEnvVars && !observed.DotnetUserEnvVarsComplete)
+            {
+                drift.Add(Strings.EnvDriftEverywhereModeEnvVarsIncomplete);
+            }
+            else if (!expectsDotnetEnvVars && observed.DotnetUserEnvVarsPresent)
+            {
+                drift.Add(string.Format(
+                    CultureInfo.InvariantCulture,
+                    Strings.EnvDriftEverywhereModeEnvVarsUnexpected,
+                    config.AccessMode.ToString().ToLowerInvariant()));
+            }
+
+            // The user-scope PATH is authoritative for dotnetupOnPath on Windows (the profile
+            // block copy is just a convenience).
+            if (config.DotnetupOnPath && !observed.DotnetupOnUserPath)
+            {
+                drift.Add(Strings.EnvDriftDotnetupOnPathMissing);
+            }
+            else if (!config.DotnetupOnPath && observed.DotnetupOnUserPath)
+            {
+                drift.Add(Strings.EnvDriftDotnetupOnPathUnexpected);
+            }
+        }
+
+        return drift;
+    }
+}