Support RID-specific .NET Tool packages

eng/dogfood.ps1

@@ -47,6 +47,7 @@ try {
 
   $env:PATH = "$TestDotnetRoot;$env:Path"
   $env:DOTNET_ROOT = $TestDotnetRoot
+  $env:DOTNET_ADD_GLOBAL_TOOLS_TO_PATH="0"
 
   # Avoid downloading Microsoft.Net.Sdk.Compilers.Toolset from feed
   # Locally built SDK package version is Major.Minor.0-dev, which won't be available.

eng/dogfood.sh

@@ -25,4 +25,5 @@ export MicrosoftNETBuildExtensionsTargets="$artifacts_dir/bin/$configuration/Sdk
 
 export PATH=$testDotnetRoot:$PATH
 export DOTNET_ROOT=$testDotnetRoot
+export DOTNET_ADD_GLOBAL_TOOLS_TO_PATH=0
 export PS1="(dogfood) $PS1"

eng/restore-toolset.ps1

@@ -51,6 +51,7 @@ set DOTNET_MSBUILD_SDK_RESOLVER_CLI_DIR=$env:DOTNET_INSTALL_DIR
 
 set PATH=$env:DOTNET_INSTALL_DIR;%PATH%
 set NUGET_PACKAGES=$env:NUGET_PACKAGES
+set DOTNET_ADD_GLOBAL_TOOLS_TO_PATH=0
 
 DOSKEY killdotnet=taskkill /F /IM dotnet.exe /T ^& taskkill /F /IM VSTest.Console.exe /T ^& taskkill /F /IM msbuild.exe /T
 "@
@@ -70,6 +71,7 @@ DOSKEY killdotnet=taskkill /F /IM dotnet.exe /T ^& taskkill /F /IM VSTest.Consol
 
 `$env:PATH="$env:DOTNET_INSTALL_DIR;" + `$env:PATH
 `$env:NUGET_PACKAGES="$env:NUGET_PACKAGES"
+`$env:DOTNET_ADD_GLOBAL_TOOLS_TO_PATH="0"
 
 function killdotnet {
   taskkill /F /IM dotnet.exe /T

eng/restore-toolset.sh

@@ -61,6 +61,7 @@ export DOTNET_MSBUILD_SDK_RESOLVER_CLI_DIR=$DOTNET_INSTALL_DIR
 
 export PATH=$DOTNET_INSTALL_DIR:\$PATH
 export NUGET_PACKAGES=$NUGET_PACKAGES
+export DOTNET_ADD_GLOBAL_TOOLS_TO_PATH=0
 "
 
   echo "$scriptContents" > ${scriptPath}

src/Cli/dotnet/CliStrings.resx

@@ -319,6 +319,9 @@
   <data name="ToolSettingsUnsupportedRunner" xml:space="preserve">
     <value>Command '{0}' uses unsupported runner '{1}'."</value>
   </data>
+  <data name="ToolUnsupportedRuntimeIdentifier" xml:space="preserve">
+    <value>The tool does not support the current architecture or operating system ({0}). Supported runtimes: {1}</value>
+  </data>
   <data name="ShellShimConflict" xml:space="preserve">
     <value>Command '{0}' conflicts with an existing command from another tool.</value>
   </data>
@@ -413,6 +416,9 @@ setx PATH "%PATH%;{0}"
   <data name="ToolPackageConflictPackageId" xml:space="preserve">
     <value>Tool '{0}' (version '{1}') is already installed.</value>
   </data>
+  <data name="ToolPackageNotATool" xml:space="preserve">
+    <value>Package {0} is not a .NET tool.</value>
+  </data>
   <data name="FailedToFindStagedToolPackage" xml:space="preserve">
     <value>Failed to find staged tool package '{0}'.</value>
   </data>
@@ -435,7 +441,10 @@ setx PATH "%PATH%;{0}"
     <value>More than one packaged shim is available: {0}.</value>
   </data>
   <data name="FailedToReadNuGetLockFile" xml:space="preserve">
-    <value>Failed to read NuGet LockFile for tool package '{0}': {1}</value>
+    <value>Failed to read NuGet assets file for tool package '{0}': {1}</value>
+  </data>
+  <data name="FailedToFindLibraryInAssetsFile" xml:space="preserve">
+    <value>Failed to find library in NuGet assets file for tool package '{0}': {1}</value>
   </data>
   <data name="LevelArgumentName" xml:space="preserve">
     <value>LEVEL</value>

src/Cli/dotnet/CommandFactory/CommandResolution/LocalToolsCommandResolver.cs

@@ -7,6 +7,7 @@
 using Microsoft.DotNet.Cli.ToolPackage;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.Extensions.EnvironmentAbstractions;
+using NuGet.DependencyResolver;
 using NuGet.Frameworks;
 
 namespace Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
@@ -82,22 +83,39 @@ private CommandSpec GetPackageCommandSpecUsingMuxer(CommandResolverArguments arg
                 NuGetFramework.Parse(BundledTargetFramework.GetTargetFrameworkMoniker()),
                 Constants.AnyRid,
                 toolCommandName),
-            out var restoredCommand))
+            out var toolCommand))
         {
-            if (!_fileSystem.File.Exists(restoredCommand.Executable.Value))
+            if (!_fileSystem.File.Exists(toolCommand.Executable.Value))
             {
                 throw new GracefulException(string.Format(CliStrings.NeedRunToolRestore,
                     toolCommandName.ToString()));
             }
 
-            if (toolManifestPackage.RollForward || allowRollForward)
+            if (toolCommand.Runner == "dotnet")
             {
-                arguments.CommandArguments = ["--allow-roll-forward", .. arguments.CommandArguments];
+                if (toolManifestPackage.RollForward || allowRollForward)
+                {
+                    arguments.CommandArguments = ["--allow-roll-forward", .. arguments.CommandArguments];
+                }
+
+                return MuxerCommandSpecMaker.CreatePackageCommandSpecUsingMuxer(
+                    toolCommand.Executable.Value,
+                    arguments.CommandArguments);
             }
+            else if (toolCommand.Runner == "executable")
+            {
+                var escapedArgs = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(
+                    arguments.CommandArguments);
 
-            return MuxerCommandSpecMaker.CreatePackageCommandSpecUsingMuxer(
-                restoredCommand.Executable.Value,
-                arguments.CommandArguments);
+                return new CommandSpec(
+                    toolCommand.Executable.Value,
+                    escapedArgs);
+            }
+            else
+            {
+                throw new GracefulException(string.Format(CliStrings.ToolSettingsUnsupportedRunner,
+                    toolCommand.Name, toolCommand.Runner));
+            }
         }
         else
         {

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -1938,16 +1938,6 @@ Your project targets multiple frameworks. Specify which framework to run using '
   <data name="ToolInstallationFailedContactAuthor" xml:space="preserve">
     <value>Tool '{0}' failed to install. Contact the tool author for assistance.</value>
   </data>
-  <data name="ToolInstallationFailedWithRestoreGuidance" xml:space="preserve">
-    <value>Tool '{0}' failed to install. This failure may have been caused by:
-
-* You are attempting to install a preview release and did not use the --version option to specify the version.
-* A package by this name was found, but it was not a .NET tool.
-* The required NuGet feed cannot be accessed, perhaps because of an Internet connection problem.
-* You mistyped the name of the tool.
-
-For more reasons, including package naming enforcement, visit https://aka.ms/failure-installing-tool</value>
-  </data>
   <data name="ToolInstallationRestoreFailed" xml:space="preserve">
     <value>The tool package could not be restored.</value>
   </data>
@@ -2486,4 +2476,4 @@ To display a value, specify the corresponding command-line option without provid
   <data name="SolutionAddReferencedProjectsOptionDescription" xml:space="preserve">
     <value>Recursively add projects' ReferencedProjects to solution</value>
   </data>
-</root>
+</root>

src/Cli/dotnet/Commands/Pack/PackCommandParser.cs

@@ -84,7 +84,10 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.VersionSuffixOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
-        RestoreCommandParser.AddImplicitRestoreOptions(command, includeRuntimeOption: true, includeNoDependenciesOption: true);
+
+        // Don't include runtime option because we want to include it specifically and allow the short version ("-r") to be used
+        RestoreCommandParser.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);
+        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
 
         command.SetAction(PackCommand.Run);
 

src/Cli/dotnet/Commands/Tool/Install/LocalToolsResolverCacheExtensions.cs

@@ -33,7 +33,7 @@ public static void SaveToolPackage(
         }
 
         localToolsResolverCache.Save(
-            new Dictionary<RestoredCommandIdentifier, RestoredCommand>
+            new Dictionary<RestoredCommandIdentifier, ToolCommand>
             {
                 [new RestoredCommandIdentifier(
                         toolDownloadedPackage.Id,

src/Cli/dotnet/Commands/Tool/Install/ToolInstallCommandLowLevelErrorConverter.cs

@@ -12,12 +12,7 @@ internal static class InstallToolCommandLowLevelErrorConverter
 {
     public static IEnumerable<string> GetUserFacingMessages(Exception ex, PackageId packageId)
     {
-        if (ex is ToolPackageException)
-        {
-            yield return ex.Message;
-            yield return string.Format(CliCommandStrings.ToolInstallationFailedWithRestoreGuidance, packageId);
-        }
-        else if (ex is ToolConfigurationException)
+        if (ex is ToolConfigurationException)
         {
             yield return string.Format(CliCommandStrings.InvalidToolConfiguration, ex.Message);
             yield return string.Format(CliCommandStrings.ToolInstallationFailedContactAuthor, packageId);
@@ -31,8 +26,7 @@ public static IEnumerable<string> GetUserFacingMessages(Exception ex, PackageId
 
     public static bool ShouldConvertToUserFacingError(Exception ex)
     {
-        return ex is ToolPackageException
-               || ex is ToolConfigurationException
+        return ex is ToolConfigurationException
                || ex is ShellShimException;
     }
 }

src/Cli/dotnet/Commands/Tool/Install/ToolInstallGlobalOrToolPathCommand.cs

@@ -91,7 +91,7 @@ public ToolInstallGlobalOrToolPathCommand(
         var tempDir = new DirectoryPath(PathUtilities.CreateTempSubdirectory());
         var configOption = parseResult.GetValue(ToolInstallCommandParser.ConfigOption);
         var sourceOption = parseResult.GetValue(ToolInstallCommandParser.AddSourceOption);
-        var packageSourceLocation = new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), additionalSourceFeeds: sourceOption);
+        var packageSourceLocation = new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), additionalSourceFeeds: sourceOption, basePath: _currentWorkingDirectory);
         restoreActionConfig = new RestoreActionConfig(DisableParallel: parseResult.GetValue(ToolCommandRestorePassThroughOptions.DisableParallelOption),
             NoCache: parseResult.GetValue(ToolCommandRestorePassThroughOptions.NoCacheOption) || parseResult.GetValue(ToolCommandRestorePassThroughOptions.NoHttpCacheOption),
             IgnoreFailedSources: parseResult.GetValue(ToolCommandRestorePassThroughOptions.IgnoreFailedSourcesOption),
@@ -175,15 +175,13 @@ private int ExecuteInstallCommand(PackageId packageId)
             }   
         }
 
-        using (var scope = new TransactionScope(
-            TransactionScopeOption.Required,
-            TimeSpan.Zero))
+        TransactionalAction.Run(() =>
         {
             if (oldPackageNullable != null)
             {
                 RunWithHandlingUninstallError(() =>
                 {
-                    shellShimRepository.RemoveShim(oldPackageNullable.Command.Name);
+                    shellShimRepository.RemoveShim(oldPackageNullable.Command);
                     toolPackageUninstaller.Uninstall(oldPackageNullable.PackageDirectory);
                 }, packageId);
             }
@@ -219,7 +217,7 @@ private int ExecuteInstallCommand(PackageId packageId)
                 }
                 string appHostSourceDirectory = _shellShimTemplateFinder.ResolveAppHostSourceDirectoryAsync(_architectureOption, framework, RuntimeInformation.ProcessArchitecture).Result;
 
-                shellShimRepository.CreateShim(newInstalledPackage.Command.Executable, newInstalledPackage.Command.Name, newInstalledPackage.PackagedShims);
+                shellShimRepository.CreateShim(newInstalledPackage.Command, newInstalledPackage.PackagedShims);
 
                 foreach (string w in newInstalledPackage.Warnings)
                 {
@@ -232,10 +230,7 @@ private int ExecuteInstallCommand(PackageId packageId)
 
                 PrintSuccessMessage(oldPackageNullable, newInstalledPackage);
             }, packageId);
-
-            scope.Complete();
-
-        }
+        });
         return 0;
     }
 

src/Cli/dotnet/Commands/Tool/Install/ToolInstallLocalInstaller.cs

@@ -66,11 +66,17 @@ public IToolPackage Install(FilePath manifestFile, PackageId packageId)
 
         try
         {
+            //  NOTE: The manifest file may or may not be under a .config folder.  If it is, we will use
+            //  that directory as the root config directory.  This should be OK, as usually there won't be
+            //  a NuGet.config in the .config folder, and if there is it's better to use it than to go one
+            //  more level up and miss the root repo folder if the manifest file is not under a .config folder.
+            var rootConfigDirectory = manifestFile.GetDirectoryPath();
+
             IToolPackage toolDownloadedPackage = _toolPackageDownloader.InstallPackage(
                     new PackageLocation(
                         nugetConfig: configFile,
                         additionalFeeds: _sources,
-                        rootConfigDirectory: manifestFile.GetDirectoryPath().GetParentPath()),
+                        rootConfigDirectory: rootConfigDirectory),
                     packageId,
                     verbosity: _verbosity,
                     versionRange,

src/Cli/dotnet/Commands/Tool/Restore/ToolRestoreCommand.cs

@@ -108,7 +108,7 @@ [.. packagesFromManifest
                 .AsEnumerable()
                 .Select(package => InstallPackages(package, configFile))];
 
-        Dictionary<RestoredCommandIdentifier, RestoredCommand> downloaded =
+        Dictionary<RestoredCommandIdentifier, ToolCommand> downloaded =
             toolRestoreResults.SelectMany(result => result.SaveToCache)
                 .ToDictionary(pair => pair.Item1, pair => pair.Item2);
 
@@ -216,7 +216,7 @@ private int PrintConclusionAndReturn(ToolRestoreResult[] toolRestoreResults)
 
     private static bool ManifestCommandMatchesActualInPackage(
         ToolCommandName[] commandsFromManifest,
-        IReadOnlyList<RestoredCommand> toolPackageCommands)
+        IReadOnlyList<ToolCommand> toolPackageCommands)
     {
         ToolCommandName[] commandsFromPackage = [.. toolPackageCommands.Select(t => t.Name)];
         foreach (var command in commandsFromManifest)
@@ -251,8 +251,8 @@ private bool PackageHasBeenRestored(
 
         return _localToolsResolverCache.TryLoad(
                    sampleRestoredCommandIdentifierOfThePackage,
-                   out var restoredCommand)
-               && _fileSystem.File.Exists(restoredCommand.Executable.Value);
+                   out var toolCommand)
+               && _fileSystem.File.Exists(toolCommand.Executable.Value);
     }
 
     private FilePath? GetCustomManifestFileLocation()
@@ -271,7 +271,7 @@ private bool PackageHasBeenRestored(
         return customManifestFileLocation;
     }
 
-    private static void EnsureNoCommandNameCollision(Dictionary<RestoredCommandIdentifier, RestoredCommand> dictionary)
+    private static void EnsureNoCommandNameCollision(Dictionary<RestoredCommandIdentifier, ToolCommand> dictionary)
     {
         string[] errors = [.. dictionary
             .Select(pair => (pair.Key.PackageId, pair.Key.CommandName))
@@ -308,12 +308,12 @@ private static VersionRange ToVersionRangeWithOnlyOneVersion(NuGetVersion versio
 
     private struct ToolRestoreResult
     {
-        public (RestoredCommandIdentifier, RestoredCommand)[] SaveToCache { get; }
+        public (RestoredCommandIdentifier, ToolCommand)[] SaveToCache { get; }
         public bool IsSuccess { get; }
         public string Message { get; }
 
         private ToolRestoreResult(
-            (RestoredCommandIdentifier, RestoredCommand)[] saveToCache,
+            (RestoredCommandIdentifier, ToolCommand)[] saveToCache,
             bool isSuccess, string message)
         {
             if (string.IsNullOrWhiteSpace(message))
@@ -327,7 +327,7 @@ private ToolRestoreResult(
         }
 
         public static ToolRestoreResult Success(
-            (RestoredCommandIdentifier, RestoredCommand)[] saveToCache,
+            (RestoredCommandIdentifier, ToolCommand)[] saveToCache,
             string message)
         {
             return new ToolRestoreResult(saveToCache, true, message);

src/Cli/dotnet/Commands/Tool/Uninstall/ToolUninstallGlobalOrToolPathCommand.cs

@@ -70,16 +70,12 @@ public override int Execute()
 
         try
         {
-            using (var scope = new TransactionScope(
-                TransactionScopeOption.Required,
-                TimeSpan.Zero))
+            TransactionalAction.Run(() =>
             {
-                shellShimRepository.RemoveShim(package.Command.Name);
+                shellShimRepository.RemoveShim(package.Command);
 
                 toolPackageUninstaller.Uninstall(package.PackageDirectory);
-
-                scope.Complete();
-            }
+            });
 
             _reporter.WriteLine(
                 string.Format(