Add command result support for resource commands

playground/Stress/Stress.AppHost/Program.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Text.Json;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
 
@@ -124,7 +125,33 @@
                await ExecuteCommandForAllResourcesAsync(c.ServiceProvider, KnownResourceCommands.StartCommand, c.CancellationToken);
                return CommandResults.Success();
            },
-           commandOptions: new() { IconName = "Play", IconVariant = IconVariant.Filled });
+           commandOptions: new() { IconName = "Play", IconVariant = IconVariant.Filled })
+       .WithCommand(
+           name: "generate-token",
+           displayName: "Generate Token",
+           executeCommand: (c) =>
+           {
+               var token = new
+               {
+                   accessToken = Convert.ToBase64String(Guid.NewGuid().ToByteArray()) + Convert.ToBase64String(Guid.NewGuid().ToByteArray()),
+                   tokenType = "Bearer",
+                   expiresIn = 3600,
+                   scope = "api.read api.write",
+                   issuedAt = DateTime.UtcNow
+               };
+               var json = JsonSerializer.Serialize(token, new JsonSerializerOptions { WriteIndented = true });
+               return Task.FromResult(CommandResults.Success(json, CommandResultFormat.Json));
+           },
+           commandOptions: new() { IconName = "Key", Description = "Generate a temporary access token" })
+       .WithCommand(
+           name: "get-connection-string",
+           displayName: "Get Connection String",
+           executeCommand: (c) =>
+           {
+               var connectionString = $"Server=localhost,1433;Database=StressDb;User Id=sa;Password={Guid.NewGuid():N};TrustServerCertificate=true";
+               return Task.FromResult(CommandResults.Success(connectionString, CommandResultFormat.Text));
+           },
+           commandOptions: new() { IconName = "LinkMultiple", Description = "Get the connection string for this resource" });
 
 #if !SKIP_DASHBOARD_REFERENCE
 // This project is only added in playground projects to support development/debugging

src/Aspire.Cli/Commands/ResourceCommandHelper.cs

@@ -59,13 +59,22 @@ public static async Task<int> ExecuteGenericCommandAsync(
     {
         logger.LogDebug("Executing command '{CommandName}' on resource '{ResourceName}'", commandName, resourceName);
 
+        // Route status messages to stderr so command results can be piped (e.g., | jq)
+        interactionService.Console = ConsoleOutput.Error;
+
         var response = await interactionService.ShowStatusAsync(
             $"Executing command '{commandName}' on resource '{resourceName}'...",
             async () => await connection.ExecuteResourceCommandAsync(resourceName, commandName, cancellationToken));
 
         if (response.Success)
         {
             interactionService.DisplaySuccess($"Command '{commandName}' executed successfully on resource '{resourceName}'.");
+
+            if (response.Result is not null)
+            {
+                interactionService.DisplayRawText(response.Result, ConsoleOutput.Standard);
+            }
+
             return ExitCodeConstants.Success;
         }
         else if (response.Canceled)

src/Aspire.Cli/Mcp/Tools/ExecuteResourceCommandTool.cs

@@ -74,9 +74,19 @@ public override async ValueTask<CallToolResult> CallToolAsync(CallToolContext co
 
             if (response.Success)
             {
+                var content = new List<TextContentBlock>
+                {
+                    new() { Text = $"Command '{commandName}' executed successfully on resource '{resourceName}'." }
+                };
+
+                if (response.Result is not null)
+                {
+                    content.Add(new TextContentBlock { Text = response.Result });
+                }
+
                 return new CallToolResult
                 {
-                    Content = [new TextContentBlock { Text = $"Command '{commandName}' executed successfully on resource '{resourceName}'." }]
+                    Content = [.. content]
                 };
             }
             else if (response.Canceled)

src/Aspire.Dashboard/Model/DashboardCommandExecutor.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Globalization;
+using Aspire.Dashboard.Components.Dialogs;
 using Aspire.Dashboard.Telemetry;
 using Aspire.Dashboard.Utils;
 using Microsoft.AspNetCore.Components;
@@ -13,7 +14,7 @@ namespace Aspire.Dashboard.Model;
 
 public sealed class DashboardCommandExecutor(
     IDashboardClient dashboardClient,
-    IDialogService dialogService,
+    IServiceProvider serviceProvider,
     IToastService toastService,
     IStringLocalizer<Dashboard.Resources.Resources> loc,
     NavigationManager navigationManager,
@@ -86,7 +87,7 @@ public async Task ExecuteAsyncCore(ResourceViewModel resource, CommandViewModel
     {
         if (!string.IsNullOrWhiteSpace(command.ConfirmationMessage))
         {
-            var dialogReference = await dialogService.ShowConfirmationAsync(command.ConfirmationMessage).ConfigureAwait(false);
+            var dialogReference = await serviceProvider.GetRequiredService<DashboardDialogService>().ShowConfirmationAsync(command.ConfirmationMessage).ConfigureAwait(false);
             var result = await dialogReference.Result.ConfigureAwait(false);
             if (result.Cancelled)
             {
@@ -148,6 +149,18 @@ public async Task ExecuteAsyncCore(ResourceViewModel resource, CommandViewModel
             toastParameters.Title = string.Format(CultureInfo.InvariantCulture, loc[nameof(Dashboard.Resources.Resources.ResourceCommandSuccess)], messageResourceName, command.GetDisplayName());
             toastParameters.Intent = ToastIntent.Success;
             toastParameters.Icon = GetIntentIcon(ToastIntent.Success);
+
+            if (response.Result is not null)
+            {
+                var fixedFormat = response.ResultFormat == CommandResultFormat.Json ? DashboardUIHelpers.JsonFormat : null;
+                await TextVisualizerDialog.OpenDialogAsync(new OpenTextVisualizerDialogOptions
+                {
+                    DialogService = serviceProvider.GetRequiredService<DashboardDialogService>(),
+                    ValueDescription = command.GetDisplayName(),
+                    Value = response.Result,
+                    FixedFormat = fixedFormat
+                }).ConfigureAwait(false);
+            }
         }
         else if (response.Kind == ResourceCommandResponseKind.Cancelled)
         {

src/Aspire.Dashboard/Model/ResourceCommandResponseViewModel.cs

@@ -7,6 +7,8 @@ public class ResourceCommandResponseViewModel
 {
     public required ResourceCommandResponseKind Kind { get; init; }
     public string? ErrorMessage { get; init; }
+    public string? Result { get; init; }
+    public CommandResultFormat ResultFormat { get; init; }
 }
 
 // Must be kept in sync with ResourceCommandResponseKind in the resource_service.proto file
@@ -17,3 +19,24 @@ public enum ResourceCommandResponseKind
     Failed = 2,
     Cancelled = 3
 }
+
+/// <summary>
+/// Specifies the format of a command result.
+/// </summary>
+public enum CommandResultFormat
+{
+    /// <summary>
+    /// No result data.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    /// Plain text result.
+    /// </summary>
+    Text = 1,
+
+    /// <summary>
+    /// JSON result.
+    /// </summary>
+    Json = 2
+}

src/Aspire.Dashboard/ServiceClient/Partials.cs

@@ -199,7 +199,9 @@ public ResourceCommandResponseViewModel ToViewModel()
         return new ResourceCommandResponseViewModel()
         {
             ErrorMessage = ErrorMessage,
-            Kind = (Dashboard.Model.ResourceCommandResponseKind)Kind
+            Kind = (Dashboard.Model.ResourceCommandResponseKind)Kind,
+            Result = HasResult ? Result : null,
+            ResultFormat = (Dashboard.Model.CommandResultFormat)ResultFormat
         };
     }
 }

src/Aspire.Hosting/ApplicationModel/ResourceCommandAnnotation.cs

@@ -114,6 +114,27 @@ public enum IconVariant
     Filled
 }
 
+/// <summary>
+/// Specifies the format of a command result.
+/// </summary>
+public enum CommandResultFormat
+{
+    /// <summary>
+    /// No result data.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    /// Plain text result.
+    /// </summary>
+    Text = 1,
+
+    /// <summary>
+    /// JSON result.
+    /// </summary>
+    Json = 2
+}
+
 /// <summary>
 /// A factory for <see cref="ExecuteCommandResult"/>.
 /// </summary>
@@ -124,6 +145,13 @@ public static class CommandResults
     /// </summary>
     public static ExecuteCommandResult Success() => new() { Success = true };
 
+    /// <summary>
+    /// Produces a success result with result data.
+    /// </summary>
+    /// <param name="result">The result data.</param>
+    /// <param name="resultFormat">The format of the result data. Defaults to <see cref="CommandResultFormat.Text"/>.</param>
+    public static ExecuteCommandResult Success(string result, CommandResultFormat resultFormat = CommandResultFormat.Text) => new() { Success = true, Result = result, ResultFormat = resultFormat };
+
     /// <summary>
     /// Produces an unsuccessful result with an error message.
     /// </summary>
@@ -162,6 +190,16 @@ public sealed class ExecuteCommandResult
     /// An optional error message that can be set when the command is unsuccessful.
     /// </summary>
     public string? ErrorMessage { get; init; }
+
+    /// <summary>
+    /// An optional result value produced by the command.
+    /// </summary>
+    public string? Result { get; init; }
+
+    /// <summary>
+    /// The format of the <see cref="Result"/> value.
+    /// </summary>
+    public CommandResultFormat ResultFormat { get; init; }
 }
 
 /// <summary>

src/Aspire.Hosting/ApplicationModel/ResourceCommandService.cs

@@ -106,7 +106,13 @@ public async Task<ExecuteCommandResult> ExecuteCommandAsync(IResource resource,
 
         if (failures.Count == 0 && cancellations.Count == 0)
         {
-            return new ExecuteCommandResult { Success = true };
+            var successWithResult = results.FirstOrDefault(r => r.Result is not null);
+            return new ExecuteCommandResult
+            {
+                Success = true,
+                Result = successWithResult?.Result,
+                ResultFormat = successWithResult?.ResultFormat ?? CommandResultFormat.None
+            };
         }
         else if (failures.Count == 0 && cancellations.Count > 0)
         {

src/Aspire.Hosting/Backchannel/AuxiliaryBackchannelRpcTarget.cs

@@ -218,7 +218,9 @@ public async Task<ExecuteResourceCommandResponse> ExecuteResourceCommandAsync(Ex
         {
             Success = result.Success,
             Canceled = result.Canceled,
-            ErrorMessage = result.ErrorMessage
+            ErrorMessage = result.ErrorMessage,
+            Result = result.Result,
+            ResultFormat = result.ResultFormat.ToString().ToLowerInvariant()
         };
     }
 

src/Aspire.Hosting/Backchannel/BackchannelDataTypes.cs

@@ -285,6 +285,16 @@ internal sealed class ExecuteResourceCommandResponse
     /// Gets the error message if the command failed.
     /// </summary>
     public string? ErrorMessage { get; init; }
+
+    /// <summary>
+    /// Gets the result data produced by the command.
+    /// </summary>
+    public string? Result { get; init; }
+
+    /// <summary>
+    /// Gets the format of the result data (e.g. "none", "text", "json").
+    /// </summary>
+    public string? ResultFormat { get; init; }
 }
 
 #endregion

src/Aspire.Hosting/Dashboard/DashboardService.cs

@@ -360,7 +360,7 @@ async Task WatchResourceConsoleLogsInternal(bool suppressFollow, CancellationTok
 
     public override async Task<ResourceCommandResponse> ExecuteResourceCommand(ResourceCommandRequest request, ServerCallContext context)
     {
-        var (result, errorMessage) = await serviceData.ExecuteCommandAsync(request.ResourceName, request.CommandName, context.CancellationToken).ConfigureAwait(false);
+        var (result, errorMessage, commandResult, resultFormat) = await serviceData.ExecuteCommandAsync(request.ResourceName, request.CommandName, context.CancellationToken).ConfigureAwait(false);
         var responseKind = result switch
         {
             ExecuteCommandResultType.Success => ResourceCommandResponseKind.Succeeded,
@@ -369,11 +369,19 @@ public override async Task<ResourceCommandResponse> ExecuteResourceCommand(Resou
             _ => ResourceCommandResponseKind.Undefined
         };
 
-        return new ResourceCommandResponse
+        var response = new ResourceCommandResponse
         {
             Kind = responseKind,
-            ErrorMessage = errorMessage ?? string.Empty
+            ErrorMessage = errorMessage ?? string.Empty,
+            ResultFormat = (Aspire.DashboardService.Proto.V1.CommandResultFormat)resultFormat
         };
+
+        if (commandResult is not null)
+        {
+            response.Result = commandResult;
+        }
+
+        return response;
     }
 
     private async Task ExecuteAsync(Func<CancellationToken, Task> execute, ServerCallContext serverCallContext)

src/Aspire.Hosting/Dashboard/DashboardServiceData.cs

@@ -94,21 +94,21 @@ public void Dispose()
         _cts.Dispose();
     }
 
-    internal async Task<(ExecuteCommandResultType result, string? errorMessage)> ExecuteCommandAsync(string resourceId, string type, CancellationToken cancellationToken)
+    internal async Task<(ExecuteCommandResultType result, string? errorMessage, string? commandResult, ApplicationModel.CommandResultFormat resultFormat)> ExecuteCommandAsync(string resourceId, string type, CancellationToken cancellationToken)
     {
         try
         {
             var result = await _resourceCommandService.ExecuteCommandAsync(resourceId, type, cancellationToken).ConfigureAwait(false);
             if (result.Canceled)
             {
-                return (ExecuteCommandResultType.Canceled, result.ErrorMessage);
+                return (ExecuteCommandResultType.Canceled, result.ErrorMessage, null, ApplicationModel.CommandResultFormat.None);
             }
-            return (result.Success ? ExecuteCommandResultType.Success : ExecuteCommandResultType.Failure, result.ErrorMessage);
+            return (result.Success ? ExecuteCommandResultType.Success : ExecuteCommandResultType.Failure, result.ErrorMessage, result.Result, result.ResultFormat);
         }
         catch
         {
             // Note: Exception is already logged in the command executor.
-            return (ExecuteCommandResultType.Failure, "Unhandled exception thrown while executing command.");
+            return (ExecuteCommandResultType.Failure, "Unhandled exception thrown while executing command.", null, ApplicationModel.CommandResultFormat.None);
         }
     }
 

src/Aspire.Hosting/Dashboard/proto/dashboard_service.proto

@@ -92,6 +92,14 @@ enum ResourceCommandResponseKind {
 message ResourceCommandResponse {
     ResourceCommandResponseKind kind = 1;
     optional string error_message = 2;
+    optional string result = 3;
+    CommandResultFormat result_format = 4;
+}
+
+enum CommandResultFormat {
+    COMMAND_RESULT_FORMAT_NONE = 0;
+    COMMAND_RESULT_FORMAT_TEXT = 1;
+    COMMAND_RESULT_FORMAT_JSON = 2;
 }
 
 ////////////////////////////////////////////