[WIP] dotnet run: --from-source

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -2472,4 +2472,7 @@ To display a value, specify the corresponding command-line option without provid
   <data name="ZeroTestsRan" xml:space="preserve">
     <value>Zero tests ran</value>
   </data>
+  <data name="ToolRunFromSourceOptionDescription" xml:space="preserve">
+    <value>Executes a tool from source without permanently installing it. </value>
+  </data>
 </root>

src/Cli/dotnet/Commands/Tool/Run/ToolRunCommand.cs

@@ -4,7 +4,9 @@
 using System.CommandLine;
 using Microsoft.DotNet.Cli.CommandFactory;
 using Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
+using Microsoft.DotNet.Cli.Commands.Tool.Install;
 using Microsoft.DotNet.Cli.ToolManifest;
+using Microsoft.DotNet.Cli.ToolPackage;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.Extensions.EnvironmentAbstractions;
 
@@ -20,7 +22,10 @@ internal class ToolRunCommand(
     private readonly IEnumerable<string> _forwardArgument = result.GetValue(ToolRunCommandParser.CommandArgument);
     public bool _allowRollForward = result.GetValue(ToolRunCommandParser.RollForwardOption);
     private readonly ToolManifestFinder _toolManifest = toolManifest ?? new ToolManifestFinder(new DirectoryPath(Directory.GetCurrentDirectory()));
+    private readonly bool _fromSource = result.GetValue(ToolRunCommandParser.FromSourceOption);
 
+    private readonly IToolManifestEditor _toolManifestEditor = new ToolManifestEditor();
+    private readonly ILocalToolsResolverCache _localToolsResolverCache = new LocalToolsResolverCache();
     public override int Execute()
     {
         CommandSpec commandspec = _localToolsCommandResolver.ResolveStrict(new CommandResolverArguments()
@@ -31,6 +36,11 @@ public override int Execute()
 
         }, _allowRollForward);
 
+        if (commandspec == null && _fromSource)
+        {
+            return ExecuteFromSource();
+        }
+
         if (commandspec == null)
         {
             throw new GracefulException([string.Format(CliCommandStrings.CannotFindCommandName, _toolCommandName)], isUserError: false);
@@ -39,4 +49,45 @@ public override int Execute()
         var result = CommandFactoryUsingResolver.Create(commandspec).Execute();
         return result.ExitCode;
     }
+
+    public int ExecuteFromSource()
+    {
+        string tempDirectory = PathUtilities.CreateTempSubdirectory();
+        FilePath manifestFile = _toolManifest.FindFirst(true);
+        PackageId packageId = new(_toolCommandName);
+
+        ToolInstallLocalInstaller _toolInstaller = new(_parseResult, new ToolPackageDownloader(
+            localToolDownloadDir: tempDirectory,
+            store: new ToolPackageStoreAndQuery(new DirectoryPath(tempDirectory))));
+
+        IToolPackage toolPackage = _toolInstaller.Install(manifestFile, packageId);
+
+        _toolManifestEditor.Add(
+            manifestFile,
+            toolPackage.Id,
+            toolPackage.Version,
+            [toolPackage.Command.Name],
+            _allowRollForward);
+
+        _localToolsResolverCache.SaveToolPackage(
+            toolPackage,
+            _toolInstaller.TargetFrameworkToInstall);
+
+        CommandSpec commandSpec = _localToolsCommandResolver.ResolveStrict(new CommandResolverArguments()
+        {
+            CommandName = $"dotnet-{toolPackage.Command.Name}",
+            CommandArguments = _forwardArgument,
+        }, _allowRollForward);
+
+        if (commandSpec == null)
+        {
+            throw new GracefulException([string.Format(CliCommandStrings.CannotFindCommandName, _toolCommandName)], isUserError: false);
+        }
+
+        var result = CommandFactoryUsingResolver.Create(commandSpec).Execute();
+
+        _toolManifestEditor.Remove(manifestFile, toolPackage.Id);
+
+        return result.ExitCode;
+    }
 }

src/Cli/dotnet/Commands/Tool/Run/ToolRunCommandParser.cs

@@ -24,6 +24,12 @@ internal static class ToolRunCommandParser
         Arity = ArgumentArity.Zero
     };
 
+    public static readonly CliOption<bool> FromSourceOption = new("--from-source")
+    {
+        Description = CliCommandStrings.ToolRunFromSourceOptionDescription,
+        Arity = ArgumentArity.Zero
+    };
+
     private static readonly CliCommand Command = ConstructCommand();
 
     public static CliCommand GetCommand()
@@ -38,6 +44,7 @@ private static CliCommand ConstructCommand()
         command.Arguments.Add(CommandNameArgument);
         command.Arguments.Add(CommandArgument);
         command.Options.Add(RollForwardOption);
+        command.Options.Add(FromSourceOption);
 
         command.SetAction((parseResult) => new ToolRunCommand(parseResult).Execute());
 

src/Cli/dotnet/ToolManifest/ToolManifestFinder.cs

@@ -189,7 +189,7 @@ public FilePath FindFirst(bool createIfNotFound = false)
 
     /*
     The --create-manifest-if-needed will use the following priority to choose the folder where the tool manifest goes:
-        1. Walk up the directory tree searching for one that has a.git subfolder
+        1. Walk up the directory tree searching for one that has a .git subfolder
         2. Walk up the directory tree searching for one that has a .sln(x)/git file in it
         3. Use the current working directory
     */

src/Cli/dotnet/ToolPackage/ToolPackageDownloader.cs

@@ -52,13 +52,14 @@ internal class ToolPackageDownloader : IToolPackageDownloader
     public ToolPackageDownloader(
         IToolPackageStore store,
         string runtimeJsonPathForTests = null,
-        string currentWorkingDirectory = null
+        string currentWorkingDirectory = null,
+        string localToolDownloadDir = null
     )
     {
         _toolPackageStore = store ?? throw new ArgumentNullException(nameof(store));
         _globalToolStageDir = _toolPackageStore.GetRandomStagingDirectory();
         ISettings settings = Settings.LoadDefaultSettings(currentWorkingDirectory ?? Directory.GetCurrentDirectory());
-        _localToolDownloadDir = new DirectoryPath(SettingsUtility.GetGlobalPackagesFolder(settings));
+        _localToolDownloadDir = new DirectoryPath(localToolDownloadDir ?? SettingsUtility.GetGlobalPackagesFolder(settings));
         _currentWorkingDirectory = currentWorkingDirectory;
 
         _localToolAssetDir = new DirectoryPath(PathUtilities.CreateTempSubdirectory());