[WIP] dotnet tool exec <package[@version]> one-shot execution

src/Cli/dotnet/CliStrings.resx

@@ -803,4 +803,10 @@ For a list of locations searched, specify the "-d" option before the tool name.<
     <value>Cannot specify --version when the package argument already contains a version.</value>
     <comment>{Locked="--version"}</comment>
   </data>
+  <data name="YesOptionDescription" xml:space="preserve">
+    <value>Overrides confirmation prompt with "yes" value. </value>
+  </data>
+  <data name="NoOptionDescription" xml:space="preserve">
+    <value>Overrides confirmation prompt with "no" value.</value>
+  </data>
 </root>

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -2062,6 +2062,9 @@ If you would like to create a manifest, use the `--create-manifest-if-needed` fl
   <data name="ToolRunCommandDescription" xml:space="preserve">
     <value>Run a local tool. Note that this command cannot be used to run a global tool. </value>
   </data>
+  <data name="ToolRunArguementsDescription" xml:space="preserve">
+    <value>Arguments forwarded to the tool</value>
+  </data>
   <data name="ToolSearchCommandDescription" xml:space="preserve">
     <value>Search dotnet tools in nuget.org</value>
   </data>
@@ -2483,6 +2486,18 @@ 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="ToolExecuteCommandDescription" xml:space="preserve">
+    <value>Executes a tool from source without permanently installing it.</value>
+  </data>
+  <data name="ToolExecuteCommandMissingPackageId" xml:space="preserve">
+    <value>Missing package ID</value>
+  </data>
+  <data name="ToolRunFromSourceUserConfirmationPrompt" xml:space="preserve">
+    <value>Tool not found on the system. Do you want to run it from source? [y/n]</value>
+  </data>
+  <data name="ToolRunFromSourceUserConfirmationFailed" xml:space="preserve">
+    <value>Run from source approval denied by the user</value>
+  </data>
   <data name="SolutionAddReferencedProjectsOptionDescription" xml:space="preserve">
     <value>Recursively add projects' ReferencedProjects to solution</value>
   </data>

src/Cli/dotnet/Commands/Tool/Execute/ToolExecuteCommand.cs

@@ -0,0 +1,106 @@
+// 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.Cli.CommandFactory;
+using Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
+using Microsoft.DotNet.Cli.Commands.Tool.Install;
+using Microsoft.DotNet.Cli.ToolPackage;
+using Microsoft.DotNet.Cli.Utils;
+using NuGet.Common;
+using NuGet.Packaging.Core;
+using NuGet.Versioning;
+
+namespace Microsoft.DotNet.Cli.Commands.Tool.Execute
+{
+    internal class ToolExecuteCommand(ParseResult result) : CommandBase(result)
+    {
+        private readonly PackageIdentity? _packageToolIdentityArgument = result.GetValue(ToolExecuteCommandParser.PackageIdentityArgument);
+        private readonly IEnumerable<string> _forwardArguments = result.GetValue(ToolExecuteCommandParser.CommandArgument) ?? [];
+        private readonly bool _allowRollForward = result.GetValue(ToolExecuteCommandParser.RollForwardOption);
+        private readonly string? _configFile = result.GetValue(ToolExecuteCommandParser.ConfigOption);
+        private readonly string[] _sources = result.GetValue(ToolExecuteCommandParser.SourceOption) ?? [];
+        private readonly string[] _addSource = result.GetValue(ToolExecuteCommandParser.AddSourceOption) ?? [];
+        private readonly bool _ignoreFailedSources = result.GetValue(ToolCommandRestorePassThroughOptions.IgnoreFailedSourcesOption);
+        private readonly bool _interactive = result.GetValue(ToolExecuteCommandParser.InteractiveOption);
+        private readonly VerbosityOptions _verbosity = result.GetValue(ToolExecuteCommandParser.VerbosityOption);
+        private readonly bool _yes = result.GetValue(ToolExecuteCommandParser.YesOption);
+        private readonly bool _prerelease = result.GetValue(ToolExecuteCommandParser.PrereleaseOption);
+
+        public override int Execute()
+        {
+            if (_packageToolIdentityArgument is null)
+            {
+                // System.CommandLine will throw an error if the argument is not provided, but we can still check here for clarity.
+                return 1;
+            }
+
+            if (!UserAgreedToRunFromSource())
+            {
+                throw new GracefulException(CliCommandStrings.ToolRunFromSourceUserConfirmationFailed, isUserError: true);
+            }
+
+            if (_allowRollForward)
+            {
+                _forwardArguments.Append("--allow-roll-forward");
+            }
+
+            PackageId packageId = new PackageId(_packageToolIdentityArgument.Id);
+
+            VersionRange versionRange = _parseResult.GetVersionRange();
+
+            string tempDirectory = NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp);
+
+            ToolPackageStoreAndQuery toolPackageStoreAndQuery = new(new(tempDirectory));
+            ToolPackageDownloader toolPackageDownloader = new(toolPackageStoreAndQuery);
+
+            IToolPackage toolPackage = toolPackageDownloader.InstallPackage(
+                new PackageLocation(
+                    nugetConfig: _configFile != null ? new(_configFile) : null,
+                    sourceFeedOverrides: _sources,
+                    additionalFeeds: _addSource),
+                packageId: packageId,
+                verbosity: _verbosity,
+                versionRange: versionRange,
+                isGlobalToolRollForward: _allowRollForward, // Needed to update .runtimeconfig.json
+                restoreActionConfig: new(
+                    IgnoreFailedSources: _ignoreFailedSources,
+                    Interactive: _interactive));
+
+            CommandSpec commandSpec = MuxerCommandSpecMaker.CreatePackageCommandSpecUsingMuxer(toolPackage.Command.Executable.ToString(), _forwardArguments);
+            var command = CommandFactoryUsingResolver.Create(commandSpec);
+            var result = command.Execute();
+            return result.ExitCode;
+        }
+
+        private bool UserAgreedToRunFromSource()
+        {
+            if (_yes)
+            {
+                return true;
+            }
+
+            if (!_interactive)
+            {
+                return false;
+            }
+
+            // TODO: Use a better way to ask for user input
+            Console.Write(CliCommandStrings.ToolRunFromSourceUserConfirmationPrompt);
+            bool userAccepted = Console.ReadKey().Key == ConsoleKey.Y;
+
+            if (_verbosity >= VerbosityOptions.detailed)
+            {
+                Console.WriteLine();
+                Console.WriteLine(new String('-', CliCommandStrings.ToolRunFromSourceUserConfirmationPrompt.Length));
+            }
+            else
+            {
+                // Clear the line
+                Console.Write("\r" + new string(' ', CliCommandStrings.ToolRunFromSourceUserConfirmationPrompt.Length + 1) + "\r");
+            }
+
+            return userAccepted;
+        }
+    }
+}

src/Cli/dotnet/Commands/Tool/Execute/ToolExecuteCommandParser.cs

@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Text;
+using Microsoft.DotNet.Cli.Commands.Tool.Install;
+using NuGet.Packaging.Core;
+
+namespace Microsoft.DotNet.Cli.Commands.Tool.Execute
+{
+    internal static class ToolExecuteCommandParser
+
+    {
+        public static readonly Argument<PackageIdentity?> PackageIdentityArgument = ToolInstallCommandParser.PackageIdentityArgument;
+
+        public static readonly Argument<IEnumerable<string>> CommandArgument = new("commandArguments")
+        {
+            Description = CliCommandStrings.ToolRunArguementsDescription
+        };
+
+        public static readonly Option<string> VersionOption = ToolInstallCommandParser.VersionOption;
+        public static readonly Option<bool> RollForwardOption = ToolInstallCommandParser.RollForwardOption;
+        public static readonly Option<bool> PrereleaseOption = ToolInstallCommandParser.PrereleaseOption;
+        public static readonly Option<string> ConfigOption = ToolInstallCommandParser.ConfigOption;
+        public static readonly Option<string[]> SourceOption = ToolInstallCommandParser.SourceOption;
+        public static readonly Option<string[]> AddSourceOption = ToolInstallCommandParser.AddSourceOption;
+        public static readonly Option<bool> IgnoreFailedSourcesOption = ToolCommandRestorePassThroughOptions.IgnoreFailedSourcesOption;
+        public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveOption();
+        public static readonly Option<bool> YesOption = CommonOptions.YesOption;
+        public static readonly Option<VerbosityOptions> VerbosityOption = ToolInstallCommandParser.VerbosityOption;
+
+
+        public static readonly Command Command = ConstructCommand();
+        public static Command GetCommand()
+        {
+            return Command;
+        }
+
+        private static Command ConstructCommand()
+        {
+            Command command = new("execute", CliCommandStrings.ToolExecuteCommandDescription);
+
+            command.Aliases.Add("exec");
+
+            command.Arguments.Add(PackageIdentityArgument);
+            command.Arguments.Add(CommandArgument);
+
+            command.Options.Add(VersionOption);
+            command.Options.Add(RollForwardOption);
+            command.Options.Add(PrereleaseOption);
+            command.Options.Add(ConfigOption);
+            command.Options.Add(SourceOption);
+            command.Options.Add(AddSourceOption);
+            command.Options.Add(IgnoreFailedSourcesOption);
+            command.Options.Add(InteractiveOption);
+            command.Options.Add(YesOption);
+            command.Options.Add(VerbosityOption);
+
+            command.SetAction((parseResult) => new ToolExecuteCommand(parseResult).Execute());
+
+            return command;
+        }
+    }
+}

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

@@ -13,8 +13,17 @@ internal static class ParseResultExtension
 {
     public static VersionRange GetVersionRange(this ParseResult parseResult)
     {
-        string packageVersion = parseResult.GetValue(ToolInstallCommandParser.PackageIdentityArgument)?.Version?.ToString() ??
-            parseResult.GetValue(ToolInstallCommandParser.VersionOption);
+        var packageVersionFromIdentityArgument = parseResult.GetValue(ToolInstallCommandParser.PackageIdentityArgument)?.Version?.ToString();
+        var packageVersionFromVersionOption = parseResult.GetValue(ToolInstallCommandParser.VersionOption);
+
+        // Check that only one of these has a value
+        if (!string.IsNullOrEmpty(packageVersionFromIdentityArgument) && !string.IsNullOrEmpty(packageVersionFromVersionOption))
+        {
+            throw new GracefulException(CliStrings.PackageIdentityArgumentVersionOptionConflict);
+        }
+
+        string packageVersion = packageVersionFromIdentityArgument ?? packageVersionFromVersionOption;
+
         bool prerelease = parseResult.GetValue(ToolInstallCommandParser.PrereleaseOption);
 
         if (!string.IsNullOrEmpty(packageVersion) && prerelease)

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

@@ -21,15 +21,6 @@ internal class ToolInstallCommand(
     private readonly string _framework = parseResult.GetValue(ToolInstallCommandParser.FrameworkOption);
 
 
-    internal static void EnsureNoConflictPackageIdentityVersionOption(ParseResult parseResult)
-    {
-        if (!string.IsNullOrEmpty(parseResult.GetValue(ToolInstallCommandParser.PackageIdentityArgument)?.Version?.ToString()) &&
-            !string.IsNullOrEmpty(parseResult.GetValue(ToolInstallCommandParser.VersionOption)))
-        {
-            throw new GracefulException(CliStrings.PackageIdentityArgumentVersionOptionConflict);
-        }
-    }
-
     public override int Execute()
     {
         ToolAppliedOption.EnsureNoConflictGlobalLocalToolPathOption(
@@ -39,8 +30,6 @@ public override int Execute()
         ToolAppliedOption.EnsureToolManifestAndOnlyLocalFlagCombination(
             _parseResult);
 
-        EnsureNoConflictPackageIdentityVersionOption(_parseResult);
-
         if (_global || !string.IsNullOrWhiteSpace(_toolPath))
         {
             return (_toolInstallGlobalOrToolPathCommand ?? new ToolInstallGlobalOrToolPathCommand(_parseResult)).Execute();

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

@@ -6,7 +6,10 @@
 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.NuGetPackageDownloader;
 using Microsoft.DotNet.Cli.ToolManifest;
+using Microsoft.DotNet.Cli.ToolPackage;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.Extensions.EnvironmentAbstractions;
 
@@ -18,27 +21,27 @@ internal class ToolRunCommand(
     ToolManifestFinder toolManifest = null) : CommandBase(result)
 {
     private readonly string _toolCommandName = result.GetValue(ToolRunCommandParser.CommandNameArgument);
-    private readonly LocalToolsCommandResolver _localToolsCommandResolver = localToolsCommandResolver ?? new LocalToolsCommandResolver();
     private readonly IEnumerable<string> _forwardArgument = result.GetValue(ToolRunCommandParser.CommandArgument);
+
+    private readonly LocalToolsCommandResolver _localToolsCommandResolver = localToolsCommandResolver ?? new LocalToolsCommandResolver(toolManifest);
     public bool _allowRollForward = result.GetValue(ToolRunCommandParser.RollForwardOption);
-    private readonly ToolManifestFinder _toolManifest = toolManifest ?? new ToolManifestFinder(new DirectoryPath(Directory.GetCurrentDirectory()));
 
     public override int Execute()
     {
-        CommandSpec commandspec = _localToolsCommandResolver.ResolveStrict(new CommandResolverArguments()
+        CommandSpec commandSpec = _localToolsCommandResolver.ResolveStrict(new CommandResolverArguments()
         {
             // since LocalToolsCommandResolver is a resolver, and all resolver input have dotnet-
             CommandName = $"dotnet-{_toolCommandName}",
             CommandArguments = _forwardArgument,
 
         }, _allowRollForward);
 
-        if (commandspec == null)
+        if (commandSpec == null)
         {
             throw new GracefulException([string.Format(CliCommandStrings.CannotFindCommandName, _toolCommandName)], isUserError: false);
         }
 
-        var result = CommandFactoryUsingResolver.Create(commandspec).Execute();
+        var result = CommandFactoryUsingResolver.Create(commandSpec).Execute();
         return result.ExitCode;
     }
 }

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

@@ -17,7 +17,7 @@ internal static class ToolRunCommandParser
 
     public static readonly Argument<IEnumerable<string>> CommandArgument = new("toolArguments")
     {
-        Description = "arguments forwarded to the tool"
+        Description = CliCommandStrings.ToolRunArguementsDescription
     };
 
     public static readonly Option<bool> RollForwardOption = new("--allow-roll-forward")

src/Cli/dotnet/Commands/Tool/ToolCommandParser.cs

@@ -4,6 +4,7 @@
 #nullable disable
 
 using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Tool.Execute;
 using Microsoft.DotNet.Cli.Commands.Tool.Install;
 using Microsoft.DotNet.Cli.Commands.Tool.List;
 using Microsoft.DotNet.Cli.Commands.Tool.Restore;
@@ -37,6 +38,7 @@ private static Command ConstructCommand()
         command.Subcommands.Add(ToolRunCommandParser.GetCommand());
         command.Subcommands.Add(ToolSearchCommandParser.GetCommand());
         command.Subcommands.Add(ToolRestoreCommandParser.GetCommand());
+        command.Subcommands.Add(ToolExecuteCommandParser.GetCommand());
 
         command.SetAction((parseResult) => parseResult.HandleMissingCommand());