Fix for malformed table output in aspire run command

Co-authored-by: mitchdenny <[email protected]>

Author: Copilot

src/Aspire.Cli/Commands/RunCommand.cs

@@ -166,15 +166,19 @@ protected override async Task<int> ExecuteAsync(ParseResult parseResult, Cancell
 
                 var table = new Table().Border(TableBorder.Rounded);
                 var message = new Markup("Press [bold]Ctrl+C[/] to stop the app host and exit.");
+                var noResourcesMessage = new Markup("No resources are present.");
 
-                var rows = new Rows(new List<IRenderable> {
-                    table,
+                // Start with noResourcesMessage as the default
+                var renderables = new List<IRenderable> {
+                    noResourcesMessage,
                     message
-                });
+                };
+                var rows = new Rows(renderables);
 
                 await _ansiConsole.Live(rows).StartAsync(async context =>
                 {
                     var knownResources = new SortedDictionary<string, RpcResourceState>();
+                    var hasResources = false;
 
                     table.AddColumn("Resource");
                     table.AddColumn("Type");
@@ -188,6 +192,14 @@ await _ansiConsole.Live(rows).StartAsync(async context =>
                     {
                         await foreach (var resourceState in resourceStates)
                         {
+                            if (!hasResources)
+                            {
+                                // First resource found, switch from message to table
+                                hasResources = true;
+                                renderables[0] = table;
+                                context.Refresh();
+                            }
+
                             knownResources[resourceState.Resource] = resourceState;
 
                             table.Rows.Clear();

tests/Aspire.Cli.Tests/Commands/RunCommandTests.cs

@@ -203,4 +203,60 @@ public async Task RunCommand_CompletesSuccessfully()
         var exitCode = await pendingRun.WaitAsync(CliTestConstants.DefaultTimeout);
         Assert.Equal(ExitCodeConstants.Success, exitCode);
     }
+
+    [Fact]
+    public async Task RunCommand_WithNoResources_CompletesSuccessfully()
+    {
+        var getResourceStatesAsyncCalled = new TaskCompletionSource();
+        var backchannelFactory = (IServiceProvider sp) => {
+            var backchannel = new TestAppHostBackchannel();
+            backchannel.GetResourceStatesAsyncCalled = getResourceStatesAsyncCalled;
+            
+            // Return empty resources using an empty enumerable
+            backchannel.GetResourceStatesAsyncCallback = _ => EmptyAsyncEnumerable<RpcResourceState>.Instance;
+            
+            return backchannel;
+        };
+
+        var runnerFactory = (IServiceProvider sp) => {
+            var runner = new TestDotNetCliRunner();
+            runner.CheckHttpCertificateAsyncCallback = (options, ct) => 0;
+            runner.BuildAsyncCallback = (projectFile, options, ct) => 0;
+            runner.GetAppHostInformationAsyncCallback = (projectFile, options, ct) => (0, true, VersionHelper.GetDefaultTemplateVersion());
+            
+            runner.RunAsyncCallback = async (projectFile, watch, noBuild, args, env, backchannelCompletionSource, options, ct) =>
+            {
+                var backchannel = sp.GetRequiredService<IAppHostBackchannel>();
+                backchannelCompletionSource!.SetResult(backchannel);
+                await Task.Delay(Timeout.InfiniteTimeSpan, ct);
+                return 0;
+            };
+
+            return runner;
+        };
+
+        var projectLocatorFactory = (IServiceProvider sp) => new TestProjectLocator();
+        
+        var services = CliTestHelper.CreateServiceCollection(outputHelper, options =>
+        {
+            options.ProjectLocatorFactory = projectLocatorFactory;
+            options.AppHostBackchannelFactory = backchannelFactory;
+            options.DotNetCliRunnerFactory = runnerFactory;
+        });
+
+        var provider = services.BuildServiceProvider();
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("run");
+
+        using var cts = new CancellationTokenSource();
+        var pendingRun = result.InvokeAsync(cts.Token);
+
+        await getResourceStatesAsyncCalled.Task.WaitAsync(CliTestConstants.DefaultTimeout);
+
+        // Simulate CTRL-C.
+        cts.Cancel();
+
+        var exitCode = await pendingRun.WaitAsync(CliTestConstants.DefaultTimeout);
+        Assert.Equal(ExitCodeConstants.Success, exitCode);
+    }
 }

tests/Aspire.Cli.Tests/Utils/EmptyAsyncEnumerable.cs

@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Aspire.Cli.Tests.Utils;
+
+/// <summary>
+/// A utility class that provides an empty IAsyncEnumerable&lt;T&gt;.
+/// </summary>
+/// <typeparam name="T">The type of the elements in the empty enumerable.</typeparam>
+internal sealed class EmptyAsyncEnumerable<T>
+{
+    /// <summary>
+    /// Gets a singleton instance of an empty <see cref="IAsyncEnumerable{T}"/>.
+    /// </summary>
+    public static readonly IAsyncEnumerable<T> Instance = new EmptyAsyncEnumerableImpl();
+
+    private sealed class EmptyAsyncEnumerableImpl : IAsyncEnumerable<T>
+    {
+        public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new EmptyAsyncEnumerator();
+        }
+
+        private sealed class EmptyAsyncEnumerator : IAsyncEnumerator<T>
+        {
+            public T Current => default!;
+
+            public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+
+            public ValueTask<bool> MoveNextAsync() => new ValueTask<bool>(Task.FromResult(false));
+        }
+    }
+}