Fix non-interactive self-update channel selection (#17512)

Co-authored-by: James Newton-King <james@newtonking.com>

Author: alirezafzali

src/Aspire.Cli/Commands/UpdateCommand.cs

@@ -510,13 +510,41 @@ private async Task<CommandResult> ExecuteSelfUpdateAsync(ParseResult parseResult
             var channels = isStagingEnabled
                 ? new[] { PackageChannelNames.Stable, PackageChannelNames.Staging, PackageChannelNames.Daily }
                 : new[] { PackageChannelNames.Stable, PackageChannelNames.Daily };
-            var channelBinding = PromptBinding.Create(parseResult, _channelOption);
-            channel = await InteractionService.PromptForSelectionAsync(
-                "Select the channel to update to:",
-                channels,
-                q => q,
-                binding: channelBinding,
-                cancellationToken: cancellationToken);
+
+            // In non-interactive mode, avoid prompting. Prefer the CLI identity channel when it
+            // maps to an update channel; use stable for local dev builds; otherwise require --channel.
+            var nonInteractive = parseResult.GetValue(RootCommand.NonInteractiveOption);
+            if (nonInteractive)
+            {
+                var identityChannel = ExecutionContext.IdentityChannel;
+                if (!string.IsNullOrWhiteSpace(identityChannel)
+                    && !string.Equals(identityChannel, PackageChannelNames.Local, StringComparisons.ChannelName)
+                    && channels.FirstOrDefault(c => string.Equals(c, identityChannel, StringComparisons.ChannelName)) is { } matchedChannel)
+                {
+                    channel = matchedChannel;
+                }
+                else if (string.Equals(identityChannel, PackageChannelNames.Local, StringComparisons.ChannelName))
+                {
+                    channel = PackageChannelNames.Stable;
+                }
+                else
+                {
+                    var channelOptionDisplayName = $"'{_channelOption.Name}'";
+                    InteractionService.DisplayError(
+                        string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.NonInteractiveOptionRequired, channelOptionDisplayName));
+                    throw new NonInteractiveException(channelOptionDisplayName);
+                }
+            }
+            else
+            {
+                var channelBinding = PromptBinding.Create(parseResult, _channelOption);
+                channel = await InteractionService.PromptForSelectionAsync(
+                    "Select the channel to update to:",
+                    channels,
+                    q => q,
+                    binding: channelBinding,
+                    cancellationToken: cancellationToken);
+            }
         }
 
         try

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

@@ -2632,6 +2632,121 @@ public async Task UpdateCommand_NonInteractive_WithYesAndChannel_SucceedsWithout
         Assert.NotNull(capturedContext);
     }
 
+    [Theory]
+    [InlineData("daily", "daily")]
+    [InlineData("stable", "stable")]
+    [InlineData("DAILY", "daily")] // case-insensitive match; canonical name from channels
+    public async Task UpdateCommand_SelfUpdate_NonInteractive_WhenIdentityChannelMatchesKnownChannel_UsesItWithoutPrompting(string identityChannel, string expectedChannel)
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+
+        var (_, capturedChannel, promptInvoked, _) = await RunNonInteractiveSelfUpdateAsync(
+            workspace, identityChannel: identityChannel);
+
+        Assert.False(promptInvoked, "Identity-channel match should bypass the channel prompt.");
+        Assert.Equal(expectedChannel, capturedChannel);
+    }
+
+    [Fact]
+    public async Task UpdateCommand_SelfUpdate_NonInteractive_WhenIdentityChannelIsLocal_DefaultsToStable()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+
+        var (_, capturedChannel, promptInvoked, _) = await RunNonInteractiveSelfUpdateAsync(
+            workspace, identityChannel: PackageChannelNames.Local);
+
+        Assert.False(promptInvoked, "Non-interactive mode should not prompt; should default to stable.");
+        Assert.Equal(PackageChannelNames.Stable, capturedChannel);
+    }
+
+    [Fact]
+    public async Task UpdateCommand_SelfUpdate_NonInteractive_WhenIdentityChannelIsStalePr_RequiresExplicitChannel()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+
+        var (exitCode, capturedChannel, promptInvoked, interactionService) = await RunNonInteractiveSelfUpdateAsync(
+            workspace, identityChannel: "pr-99999");
+
+        Assert.Equal(CliExitCodes.MissingRequiredArgument, exitCode);
+        Assert.False(promptInvoked, "Non-interactive mode should not prompt when channel cannot be resolved.");
+        Assert.Null(capturedChannel);
+        Assert.Contains(
+            interactionService.DisplayedErrors,
+            e => e.Contains("--channel", StringComparison.Ordinal) && e.Contains("non-interactive", StringComparison.OrdinalIgnoreCase));
+    }
+
+    [Fact]
+    public async Task UpdateCommand_SelfUpdate_ExplicitChannelOverridesIdentityChannel()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+
+        var (_, capturedChannel, promptInvoked, _) = await RunNonInteractiveSelfUpdateAsync(
+            workspace, identityChannel: PackageChannelNames.Daily, updateArgs: "update --self --non-interactive --channel stable -y");
+
+        Assert.False(promptInvoked, "Explicit --channel should bypass the prompt.");
+        Assert.Equal(PackageChannelNames.Stable, capturedChannel);
+    }
+
+    [Fact]
+    public async Task UpdateCommand_SelfUpdate_NonInteractive_WhenIdentityChannelIsStalePr_ExplicitChannelSucceeds()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+
+        var (_, capturedChannel, promptInvoked, _) = await RunNonInteractiveSelfUpdateAsync(
+            workspace, identityChannel: "pr-99999", updateArgs: "update --self --non-interactive --channel daily -y");
+
+        Assert.False(promptInvoked, "Explicit --channel should bypass the prompt even with stale identity.");
+        Assert.Equal(PackageChannelNames.Daily, capturedChannel);
+    }
+
+    private async Task<(int ExitCode, string? CapturedChannel, bool PromptInvoked, TestInteractionService InteractionService)> RunNonInteractiveSelfUpdateAsync(
+        TemporaryWorkspace workspace,
+        string identityChannel,
+        string updateArgs = "update --self --non-interactive -y")
+    {
+        var promptForSelectionInvoked = false;
+        string? capturedChannel = null;
+        TestInteractionService? interactionService = null;
+
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.CliExecutionContextFactory = _ => workspace.CreateExecutionContext(identityChannel: identityChannel);
+
+            options.InteractionServiceFactory = _ =>
+            {
+                interactionService = new TestInteractionService()
+                {
+                    PromptForSelectionCallback = (prompt, choices, formatter, ct) =>
+                    {
+                        promptForSelectionInvoked = true;
+                        return PackageChannelNames.Stable;
+                    }
+                };
+                return interactionService;
+            };
+
+            options.CliDownloaderFactory = _ => new TestCliDownloader(workspace.WorkspaceRoot)
+            {
+                DownloadLatestCliAsyncCallback = (channel, ct) =>
+                {
+                    capturedChannel = channel;
+                    var archivePath = Path.Combine(workspace.WorkspaceRoot.FullName, "test-cli.tar.gz");
+                    File.WriteAllText(archivePath, "fake archive");
+                    return Task.FromResult(archivePath);
+                }
+            };
+        });
+
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse(updateArgs);
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        return (exitCode, capturedChannel, promptForSelectionInvoked, interactionService!);
+    }
+
     private static string CreateCustomToolPathInstall(string toolPath)
     {
         var processPath = Path.Combine(toolPath, GetAspireExecutableName());