aspire new bootstrap (#7899)

* CLI runner.

* Fix duplicate project template in list.
* Apply suggestions from code review

---------

Co-authored-by: David Fowler <[email protected]>

Author: mitchdenny

src/Aspire.Cli/AppHostRunner.cs

@@ -1,49 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Diagnostics;
-using System.Globalization;
-
 namespace Aspire.Cli;
 
-internal sealed class AppHostRunner
+internal sealed class AppHostRunner(DotNetCliRunner cli)
 {
-    internal Func<int> GetCurrentProcessId { get; set; } = () => Environment.ProcessId;
-
     public async Task<int> RunAppHostAsync(FileInfo appHostProjectFile, string[] args, CancellationToken cancellationToken)
     {
-        var startInfo = new ProcessStartInfo("dotnet", $"run --project \"{appHostProjectFile.FullName}\"")
-        {
-            UseShellExecute = false,
-            CreateNoWindow = true
-        };
-
-        if (args.Length > 0)
-        {
-            startInfo.Arguments += " -- " + string.Join(" ", args);
-        }
-
-        // The AppHost uses this environment variable to signal to the CliOrphanDetector which process
-        // it should monitor in order to know when to stop the CLI. As long as the process still exists
-        // the orphan detector will allow the CLI to keep running. If the environment variable does
-        // not exist the orphan detector will exit.
-        startInfo.EnvironmentVariables["ASPIRE_CLI_PID"] = GetCurrentProcessId().ToString(CultureInfo.InvariantCulture);
-
-        using var process = new Process { StartInfo = startInfo };
-        var started = process.Start();
-
-        if (!started)
-        {
-            return ExitCodeConstants.FailedToDotnetRunAppHost;
-        }
-
-        await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
-
-        if (!process.HasExited)
-        {
-            process.Kill(false); // DCP should clean everything else up.
-        }
-
-        return process.ExitCode;
+        return await cli.RunAsync(appHostProjectFile, args, cancellationToken).ConfigureAwait(false);
     }
 }

src/Aspire.Cli/DotNetCliRunner.cs

@@ -0,0 +1,68 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Globalization;
+
+namespace Aspire.Cli;
+
+internal sealed class DotNetCliRunner
+{
+    internal Func<int> GetCurrentProcessId { get; set; } = () => Environment.ProcessId;
+
+    public async Task<int> RunAsync(FileInfo projectFile, string[] args, CancellationToken cancellationToken)
+    {
+        string[] cliArgs = ["run", "--project", projectFile.FullName, "--", ..args];
+        return await ExecuteAsync(cliArgs, cancellationToken).ConfigureAwait(false);
+    }
+
+    public async Task<int> InstallTemplateAsync(string packageName, string version, bool force, CancellationToken cancellationToken)
+    {
+        string[] forceArgs = force ? ["--force"] : [];
+        string[] cliArgs = ["new", "install", $"{packageName}::{version}", ..forceArgs];
+        return await ExecuteAsync(cliArgs, cancellationToken).ConfigureAwait(false);
+    }
+
+    public async Task<int> NewProjectAsync(string templateName, string name, string outputPath, CancellationToken cancellationToken)
+    {
+        string[] cliArgs = ["new", templateName, "--name", name, "--output", outputPath];
+        return await ExecuteAsync(cliArgs, cancellationToken).ConfigureAwait(false);
+    }
+
+    public async Task<int> ExecuteAsync(string[] args, CancellationToken cancellationToken)
+    {
+        var startInfo = new ProcessStartInfo("dotnet")
+        {
+            UseShellExecute = false,
+            CreateNoWindow = true
+        };
+
+        foreach (var a in args)
+        {
+            startInfo.ArgumentList.Add(a);
+        }
+
+        // The AppHost uses this environment variable to signal to the CliOrphanDetector which process
+        // it should monitor in order to know when to stop the CLI. As long as the process still exists
+        // the orphan detector will allow the CLI to keep running. If the environment variable does
+        // not exist the orphan detector will exit.
+        startInfo.EnvironmentVariables["ASPIRE_CLI_PID"] = GetCurrentProcessId().ToString(CultureInfo.InvariantCulture);
+
+        using var process = new Process { StartInfo = startInfo };
+        var started = process.Start();
+
+        if (!started)
+        {
+            return ExitCodeConstants.FailedToDotnetRunAppHost;
+        }
+
+        await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
+
+        if (!process.HasExited)
+        {
+            process.Kill(false);
+        }
+
+        return process.ExitCode;
+    }
+}

src/Aspire.Cli/ExitCodeConstants.cs

@@ -8,4 +8,6 @@ internal static class ExitCodeConstants
     public const int Success = 0;
     public const int InvalidCommand = 1;
     public const int FailedToDotnetRunAppHost = 2;
+    public const int FailedToInstallTemplates = 3;
+    public const int FailedToCreateNewProject = 4;
 }

src/Aspire.Cli/Program.cs

@@ -5,24 +5,38 @@
 using System.CommandLine.Parsing;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 
 namespace Aspire.Cli;
 
 public class Program
 {
-    private static IHost BuildApplication()
+    private static IHost BuildApplication(ParseResult parseResult)
     {
         var builder = Host.CreateApplicationBuilder();
+
+        var debugOption = parseResult.GetValue<bool>("--debug");
+
+        if (!debugOption)
+        {
+            builder.Logging.ClearProviders();
+        }
+
         builder.Services.AddTransient<AppHostRunner>();
+        builder.Services.AddTransient<DotNetCliRunner>();
         var app = builder.Build();
         return app;
     }
 
     private static RootCommand GetRootCommand()
     {
         var rootCommand = new RootCommand(".NET Aspire CLI");
+        var debugOption = new Option<bool>("--debug", "-d");
+        debugOption.Recursive = true;
+        rootCommand.Options.Add(debugOption);
         ConfigureDevCommand(rootCommand);
         ConfigurePackCommand(rootCommand);
+        ConfigureNewCommand(rootCommand);
         return rootCommand;
     }
 
@@ -73,7 +87,7 @@ private static void ConfigureDevCommand(Command parentCommand)
         command.Options.Add(projectOption);
 
         command.SetAction(async (parseResult, ct) => {
-            using var app = BuildApplication();
+            using var app = BuildApplication(parseResult);
             _ = app.RunAsync(ct).ConfigureAwait(false);
 
             var runner = app.Services.GetRequiredService<AppHostRunner>();
@@ -116,7 +130,7 @@ private static void ConfigurePackCommand(Command parentCommand)
         command.Options.Add(outputPath);
 
         command.SetAction(async (parseResult, ct) => {
-            using var app = BuildApplication();
+            using var app = BuildApplication(parseResult);
             _ = app.RunAsync(ct).ConfigureAwait(false);
 
             var runner = app.Services.GetRequiredService<AppHostRunner>();
@@ -133,6 +147,103 @@ private static void ConfigurePackCommand(Command parentCommand)
         parentCommand.Subcommands.Add(command);
     }
 
+    private static void ValidateProjectTemplate(ArgumentResult result)
+    {
+        // TODO: We need to integrate with the template engine to interrogate
+        //       the list of available templates. For now we will just hard-code
+        //       the acceptable options.
+        //
+        //       Once we integrate with template engine we will also be able to
+        //       interrogate the various options and add them. For now we will 
+        //       keep it simple.
+        string[] validTemplates = [
+            "aspire-starter",
+            "aspire",
+            "aspire-apphost",
+            "aspire-servicedefaults",
+            "aspire-mstest",
+            "aspire-nunit",
+            "aspire-xunit"
+            ];
+
+        var value = result.GetValueOrDefault<string>();
+
+        if (value is null)
+        {
+            // This is OK, for now we will use the default
+            // template of aspire-starter, but we might
+            // be able to do more intelligent selection in the
+            // future based on what is already in the working directory.
+            return;
+        }
+
+        if (value is { } templateName && !validTemplates.Contains(templateName))
+        {
+            result.AddError($"The specified template '{templateName}' is not valid. Valid templates are [{string.Join(", ", validTemplates)}].");
+            return;
+        }
+    }
+
+    private static void ConfigureNewCommand(Command parentCommand)
+    {
+        var command = new Command("new", "Create a new .NET Aspire-related project.");
+        var templateArgument = new Argument<string>("template");
+        templateArgument.Validators.Add(ValidateProjectTemplate);
+        templateArgument.Arity = ArgumentArity.ZeroOrOne;
+        command.Arguments.Add(templateArgument);
+
+        var nameOption = new Option<string>("--name", "-n");
+        command.Options.Add(nameOption);
+
+        var outputOption = new Option<string?>("--output", "-o");
+        command.Options.Add(outputOption);
+
+        command.SetAction(async (parseResult, ct) => {
+            using var app = BuildApplication(parseResult);
+            _ = app.RunAsync(ct).ConfigureAwait(false);
+
+            var cliRunner = app.Services.GetRequiredService<DotNetCliRunner>();
+            var templateInstallExitCode = await cliRunner.InstallTemplateAsync("Aspire.ProjectTemplates", "*-*", true, ct).ConfigureAwait(false);
+
+            if (templateInstallExitCode != 0)
+            {
+                return ExitCodeConstants.FailedToInstallTemplates;
+            }
+
+            var templateName = parseResult.GetValue<string>("template") ?? "aspire-starter";
+
+            if (parseResult.GetValue<string>("--output") is not { } outputPath)
+            {
+                outputPath = Environment.CurrentDirectory;
+            }
+            else
+            {
+                outputPath = Path.GetFullPath(outputPath);
+            }
+
+            if (parseResult.GetValue<string>("--name") is not { } name)
+            {
+                var outputPathDirectoryInfo = new DirectoryInfo(outputPath);
+                name = outputPathDirectoryInfo.Name;
+            }
+
+            var newProjectExitCode = await cliRunner.NewProjectAsync(
+                templateName,
+                name,
+                outputPath,
+                ct).ConfigureAwait(false);
+
+            if (newProjectExitCode != 0)
+            {
+                return ExitCodeConstants.FailedToCreateNewProject;
+            }
+
+            return 0;
+        });
+
+        parentCommand.Subcommands.Add(command);
+    }
+
     public static async Task<int> Main(string[] args)
     {
         var rootCommand = GetRootCommand();