Add support for file-based apps to the XPlat CLI

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/Package/Update/PackageUpdateCommand.cs

@@ -15,9 +15,9 @@ namespace NuGet.CommandLine.XPlat.Commands.Package.Update;
 
 internal static class PackageUpdateCommand
 {
-    internal static void Register(Command packageCommand, Option<bool> interactiveOption)
+    internal static void Register(Command packageCommand, Option<bool> interactiveOption, IVirtualProjectBuilder? virtualProjectBuilder = null)
     {
-        Register(packageCommand, interactiveOption, PackageUpdateCommandRunner.Run);
+        Register(packageCommand, interactiveOption, (args, ct) => PackageUpdateCommandRunner.Run(args, virtualProjectBuilder, ct));
     }
 
     internal static void Register(Command packageCommand, Option<bool> interactiveOption, Func<PackageUpdateArgs, CancellationToken, Task<int>> action)
@@ -32,7 +32,7 @@ internal static void Register(Command packageCommand, Option<bool> interactiveOp
         };
         command.Arguments.Add(packagesArguments);
 
-        var projectOption = new Option<FileSystemInfo>("--project").AcceptExistingOnly();
+        var projectOption = new Option<FileSystemInfo>("--project", "--file").AcceptExistingOnly();
         projectOption.Description = Strings.PackageUpdateCommand_ProjectOptionDescription;
         command.Options.Add(projectOption);
 

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/Package/Update/PackageUpdateCommandRunner.cs

@@ -26,7 +26,7 @@ namespace NuGet.CommandLine.XPlat.Commands.Package.Update;
 internal static class PackageUpdateCommandRunner
 {
     // This overload sets static state, so should not be used in tests.
-    internal static Task<int> Run(PackageUpdateArgs args, CancellationToken cancellationToken)
+    internal static Task<int> Run(PackageUpdateArgs args, IVirtualProjectBuilder? virtualProjectBuilder, CancellationToken cancellationToken)
     {
         ILoggerWithColor logger = new CommandOutputLogger(args.LogLevel)
         {
@@ -39,7 +39,7 @@ internal static Task<int> Run(PackageUpdateArgs args, CancellationToken cancella
         // MSBuildAPIUtility's output is different to what we want for package update.
         // While it would probably be a good idea to align the output of all commands using MSBuildAPIUtility,
         // in order to meet deadlines, we'll suppress its output, and leave improvements for later.
-        MSBuildAPIUtility msBuild = new(NullLogger.Instance);
+        MSBuildAPIUtility msBuild = new(NullLogger.Instance, virtualProjectBuilder);
 
         var restoreHelper = new PackageUpdateIO(args.Project, msBuild, EnvironmentVariableWrapper.Instance);
 

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/Package/Update/PackageUpdateIO.cs

@@ -73,6 +73,18 @@ public void Dispose()
 
             DependencyGraphSpec result = DependencyGraphSpec.Load(tempFile);
 
+            // Fixup virtual project paths.
+            if (_msbuildUtility.VirtualProjectBuilder?.GetVirtualProjectPath(project) is { } virtualProjectPath)
+            {
+                foreach (var packageSpec in result.Projects)
+                {
+                    if (packageSpec.FilePath == virtualProjectPath)
+                    {
+                        packageSpec.FilePath = project;
+                    }
+                }
+            }
+
             return result;
         }
         finally
@@ -86,20 +98,25 @@ bool RunMsbuildTarget(string project, string tempFile)
             // But when NuGet.CommandLine.XPlat is being called directly, call dotnet on the path, so this code is debuggable.
             string dotnetPath = _environmentVariableReader.GetEnvironmentVariable("DOTNET_HOST_PATH") ?? "dotnet";
 
+            bool isFileBasedApp = _msbuildUtility.VirtualProjectBuilder?.IsValidEntryPointPath(project) == true;
+
             // don't redirect stdout or stderr, so errors are output. But use quiet verbosity, so that success has no output.
             ProcessStartInfo processStartInfo = new ProcessStartInfo(dotnetPath)
             {
-                Arguments = $"msbuild " +
+                Arguments = (isFileBasedApp ? "build " : "msbuild ") +
                 $"\"{project}\" " +
-                $"-restore:false " +
-                $"-target:GenerateRestoreGraphFile " +
+                (isFileBasedApp ? "--no-restore " : "-restore:false ") +
+                "-target:GenerateRestoreGraphFile " +
                 $"-property:RestoreGraphOutputPath=\"{tempFile}\" " +
-                $"-property:RestoreRecursive=false " +
-                $"-nologo " +
-                $"-verbosity:quiet " +
-                $"-tl:false " +
-                $"-noautoresponse",
+                "-property:RestoreRecursive=false " +
+                "-nologo " +
+                "-verbosity:quiet " +
+                (!isFileBasedApp ? $"-noautoresponse" : null), // currently not supported for file-based apps
                 UseShellExecute = false,
+                Environment =
+                {
+                    { "MSBUILDTERMINALLOGGER", "off" },
+                },
             };
 
             using var process = Process.Start(processStartInfo);

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/AddPackageReferenceCommand.cs

@@ -15,7 +15,8 @@ namespace NuGet.CommandLine.XPlat
     internal static class AddPackageReferenceCommand
     {
         public static void Register(CommandLineApplication app, Func<ILogger> getLogger,
-            Func<IPackageReferenceCommandRunner> getCommandRunner)
+            Func<IPackageReferenceCommandRunner> getCommandRunner,
+            Func<IVirtualProjectBuilder?>? getVirtualProjectBuilder = null)
         {
             app.Command("add", addpkg =>
             {
@@ -79,9 +80,11 @@ public static void Register(CommandLineApplication app, Func<ILogger> getLogger,
 
                 addpkg.OnExecute(() =>
                 {
+                    var virtualProjectBuilder = getVirtualProjectBuilder?.Invoke();
+
                     ValidateArgument(id, addpkg.Name);
                     ValidateArgument(projectPath, addpkg.Name);
-                    ValidateProjectPath(projectPath, addpkg.Name);
+                    ValidateProjectPath(projectPath, addpkg.Name, virtualProjectBuilder);
                     if (!noRestore.HasValue())
                     {
                         ValidateArgument(dgFilePath, addpkg.Name);
@@ -103,7 +106,7 @@ public static void Register(CommandLineApplication app, Func<ILogger> getLogger,
                         PackageVersion = packageVersion,
                         PackageId = id.Values[0]
                     };
-                    var msBuild = new MSBuildAPIUtility(logger);
+                    var msBuild = new MSBuildAPIUtility(logger, virtualProjectBuilder);
 
                     X509TrustStore.InitializeForDotNetSdk(logger);
 
@@ -132,9 +135,11 @@ private static void ValidateArgument(CommandOption arg, string commandName)
             }
         }
 
-        private static void ValidateProjectPath(CommandOption projectPath, string commandName)
+        private static void ValidateProjectPath(CommandOption projectPath, string commandName, IVirtualProjectBuilder? virtualProjectBuilder)
         {
-            if (!File.Exists(projectPath.Value()) || !projectPath.Value().EndsWith("proj", StringComparison.OrdinalIgnoreCase))
+            if (!File.Exists(projectPath.Value())
+                || (!projectPath.Value().EndsWith("proj", StringComparison.OrdinalIgnoreCase)
+                    && virtualProjectBuilder?.IsValidEntryPointPath(projectPath.Value()) != true))
             {
                 throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
                     Strings.Error_PkgMissingOrInvalidProjectFile,

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/AddPackageReferenceCommandRunner.cs

@@ -78,6 +78,11 @@ public async Task<int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs,
 
             var projectFullPath = Path.GetFullPath(packageReferenceArgs.ProjectPath);
 
+            if (msBuild.VirtualProjectBuilder?.IsValidEntryPointPath(projectFullPath) == true)
+            {
+                projectFullPath = msBuild.VirtualProjectBuilder.GetVirtualProjectPath(projectFullPath);
+            }
+
             var matchingPackageSpecs = dgSpec
                 .Projects
                 .Where(p => p.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference &&
@@ -104,7 +109,7 @@ public async Task<int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs,
             var originalPackageSpec = matchingPackageSpecs.FirstOrDefault();
 
             // Check if the project files are correct for CPM
-            if (originalPackageSpec.RestoreMetadata.CentralPackageVersionsEnabled && !MSBuildAPIUtility.AreCentralVersionRequirementsSatisfied(packageReferenceArgs, originalPackageSpec))
+            if (originalPackageSpec.RestoreMetadata.CentralPackageVersionsEnabled && !msBuild.AreCentralVersionRequirementsSatisfied(packageReferenceArgs, originalPackageSpec))
             {
                 return 1;
             }

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/ListPackage/ListPackageArgs.cs

@@ -119,7 +119,7 @@ private string GetReportParameters()
 
             if (HighestPatch)
             {
-                sb.Append("--highest-patch");
+                sb.Append(" --highest-patch");
             }
 
             return sb.ToString().Trim();

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/ListPackage/ListPackageCommand.cs

@@ -127,7 +127,7 @@ public static void Register(
                         isDeprecated: deprecatedReport.HasValue(),
                         isVulnerable: vulnerableReport.HasValue());
 
-                    IReportRenderer reportRenderer = GetOutputType(outputFormat.Value(), outputVersionOption: outputVersion.Value());
+                    IReportRenderer reportRenderer = GetOutputType(app.Out, app.Error, outputFormat.Value(), outputVersionOption: outputVersion.Value());
                     var provider = new PackageSourceProvider(settings);
                     var packageRefArgs = new ListPackageArgs(
                         path.Value,
@@ -171,7 +171,7 @@ private static ReportType GetReportType(bool isDeprecated, bool isOutdated, bool
             throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.ListPkg_InvalidOptions));
         }
 
-        private static IReportRenderer GetOutputType(string outputFormatOption, string outputVersionOption)
+        private static IReportRenderer GetOutputType(TextWriter consoleOut, TextWriter consoleError, string outputFormatOption, string outputVersionOption)
         {
             ReportOutputFormat outputFormat = ReportOutputFormat.Console;
             if (!string.IsNullOrEmpty(outputFormatOption) &&
@@ -187,7 +187,7 @@ private static IReportRenderer GetOutputType(string outputFormatOption, string o
                 {
                     throw new ArgumentException(string.Format(Strings.ListPkg_OutputVersionNotApplicable));
                 }
-                return new ListPackageConsoleRenderer();
+                return new ListPackageConsoleRenderer(consoleOut, consoleError);
             }
 
             IReportRenderer jsonReportRenderer;
@@ -200,7 +200,7 @@ private static IReportRenderer GetOutputType(string outputFormatOption, string o
             }
             else
             {
-                jsonReportRenderer = new ListPackageJsonRenderer();
+                jsonReportRenderer = new ListPackageJsonRenderer(consoleOut);
             }
 
             return jsonReportRenderer;

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/ListPackage/ListPackageCommandRunner.cs

@@ -31,10 +31,12 @@ internal class ListPackageCommandRunner : IListPackageCommandRunner
         private const string ProjectName = "MSBuildProjectName";
         private const int GenericSuccessExitCode = 0;
         private const int GenericFailureExitCode = 1;
-        private Dictionary<PackageSource, SourceRepository> _sourceRepositoryCache;
+        private readonly MSBuildAPIUtility _msbuildUtility;
+        private readonly Dictionary<PackageSource, SourceRepository> _sourceRepositoryCache;
 
-        public ListPackageCommandRunner()
+        public ListPackageCommandRunner(MSBuildAPIUtility msbuildUtility)
         {
+            _msbuildUtility = msbuildUtility;
             _sourceRepositoryCache = new Dictionary<PackageSource, SourceRepository>();
         }
 
@@ -71,11 +73,9 @@ public async Task<int> ExecuteCommandAsync(ListPackageArgs listPackageArgs)
                     ? MSBuildAPIUtility.GetProjectsFromSolution(listPackageArgs.Path).Where(File.Exists)
                     : [listPackageArgs.Path];
 
-            MSBuildAPIUtility msBuild = listPackageReportModel.MSBuildAPIUtility;
-
             foreach (string projectPath in projectsPaths)
             {
-                await GetProjectMetadataAsync(projectPath, listPackageReportModel, msBuild, listPackageArgs);
+                await GetProjectMetadataAsync(projectPath, listPackageReportModel, listPackageArgs);
             }
 
             // if there is any error then return failure code.
@@ -90,12 +90,11 @@ public async Task<int> ExecuteCommandAsync(ListPackageArgs listPackageArgs)
         private async Task GetProjectMetadataAsync(
             string projectPath,
             ListPackageReportModel listPackageReportModel,
-            MSBuildAPIUtility msBuild,
             ListPackageArgs listPackageArgs)
         {
             //Open project to evaluate properties for the assets
             //file and the name of the project
-            Project project = MSBuildAPIUtility.GetProject(projectPath);
+            Project project = _msbuildUtility.GetProject(projectPath).Project;
             var projectName = project.GetPropertyValue(ProjectName);
             ListPackageProjectModel projectModel = listPackageReportModel.CreateProjectReportData(projectPath: projectPath, projectName);
 

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/RemovePackageReferenceCommand.cs

@@ -14,7 +14,8 @@ namespace NuGet.CommandLine.XPlat
     internal class RemovePackageReferenceCommand
     {
         public static void Register(CommandLineApplication app, Func<ILogger> getLogger,
-            Func<IPackageReferenceCommandRunner> getCommandRunner)
+            Func<IPackageReferenceCommandRunner> getCommandRunner,
+            Func<IVirtualProjectBuilder?>? getVirtualProjectBuilder = null)
         {
             app.Command("remove", removePkg =>
             {
@@ -43,16 +44,18 @@ public static void Register(CommandLineApplication app, Func<ILogger> getLogger,
 
                 removePkg.OnExecute(() =>
                 {
+                    var virtualProjectBuilder = getVirtualProjectBuilder?.Invoke();
+
                     ValidateArgument(id, removePkg.Name);
                     ValidateArgument(projectPath, removePkg.Name);
-                    ValidateProjectPath(projectPath, removePkg.Name);
+                    ValidateProjectPath(projectPath, removePkg.Name, virtualProjectBuilder);
                     var logger = getLogger();
                     var packageRefArgs = new PackageReferenceArgs(projectPath.Value(), logger)
                     {
                         Interactive = interactive.HasValue(),
                         PackageId = id.Value()
                     };
-                    var msBuild = new MSBuildAPIUtility(logger);
+                    var msBuild = new MSBuildAPIUtility(logger, virtualProjectBuilder);
                     var removePackageRefCommandRunner = getCommandRunner();
                     return removePackageRefCommandRunner.ExecuteCommand(packageRefArgs, msBuild);
                 });
@@ -69,9 +72,11 @@ private static void ValidateArgument(CommandOption arg, string commandName)
             }
         }
 
-        private static void ValidateProjectPath(CommandOption projectPath, string commandName)
+        private static void ValidateProjectPath(CommandOption projectPath, string commandName, IVirtualProjectBuilder? virtualProjectBuilder)
         {
-            if (!File.Exists(projectPath.Value()) || !projectPath.Value().EndsWith("proj", StringComparison.OrdinalIgnoreCase))
+            if (!File.Exists(projectPath.Value())
+                || (!projectPath.Value().EndsWith("proj", StringComparison.OrdinalIgnoreCase)
+                    && virtualProjectBuilder?.IsValidEntryPointPath(projectPath.Value()) != true))
             {
                 throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
                     Strings.Error_PkgMissingOrInvalidProjectFile,

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/Why/WhyCommand.cs

@@ -11,6 +11,7 @@
 using System.IO;
 using System.Threading.Tasks;
 using Microsoft.Extensions.CommandLineUtils;
+using NuGet.Common;
 using Spectre.Console;
 
 namespace NuGet.CommandLine.XPlat.Commands.Why
@@ -25,21 +26,34 @@ internal static void Register(CommandLineApplication app)
             });
         }
 
-        internal static void Register(Command rootCommand, Lazy<IAnsiConsole> console)
+        internal static void Register(Command rootCommand, Lazy<IAnsiConsole> console, IVirtualProjectBuilder? virtualProjectBuilder = null)
         {
-            Register(rootCommand, console, WhyCommandRunner.ExecuteCommand);
+            Register(rootCommand, console,
+                () => new WhyCommandRunner(new MSBuildAPIUtility(NullLogger.Instance, virtualProjectBuilder)));
         }
 
         /// <summary>
         /// This is a temporary API until NuGet migrates all our commands to System.CommandLine, at which time I suspect we'll have a NuGetParser.GetNuGetCommand for all the `dotnet nuget *` commands.
         /// For now, this allows the dotnet CLI to invoke why directly, instead of running NuGet.CommandLine.XPlat as a child process.
         /// </summary>
         /// <param name="rootCommand">The <c>dotnet nuget</c> command handler, to add <c>why</c> to.</param>
-        public static void GetWhyCommand(Command rootCommand)
+        /// <param name="virtualProjectBuilder">For handling file-based apps.</param>
+        public static void GetWhyCommand(Command rootCommand, IVirtualProjectBuilder? virtualProjectBuilder = null)
         {
             Register(rootCommand,
                 new Lazy<IAnsiConsole>(() => Spectre.Console.AnsiConsole.Console),
-                WhyCommandRunner.ExecuteCommand);
+                virtualProjectBuilder);
+        }
+
+        // For binary backcompat. To delete once the SDK starts using the other overload.
+        public static void GetWhyCommand(Command rootCommand)
+        {
+            GetWhyCommand(rootCommand, virtualProjectBuilder: null);
+        }
+
+        internal static void Register(Command rootCommand, Lazy<IAnsiConsole> console, Func<WhyCommandRunner> getCommandRunner)
+        {
+            Register(rootCommand, console, action: (args) => getCommandRunner().ExecuteCommand(args));
         }
 
         // console must be lazy, because Spectre.Console's AnsiConsole will send VT sequences to the output
@@ -48,7 +62,7 @@ internal static void Register(Command rootCommand, Lazy<IAnsiConsole> console, F
         {
             var whyCommand = new DocumentedCommand("why", Strings.WhyCommand_Description, "https://aka.ms/dotnet/nuget/why");
 
-            Argument<string> path = new Argument<string>("PROJECT|SOLUTION")
+            Argument<string> path = new Argument<string>("PROJECT|SOLUTION|FILE")
             {
                 Description = Strings.WhyCommand_PathArgument_Description,
                 // We really want this to be zero or one, however, because this is the first argument, it doesn't work.