[release/13.3] Honor configured channel in 'aspire update' (#16808)

* Honor configured channel in 'aspire update'

'aspire update' previously consulted only the explicit --channel/--quality
option and otherwise silently selected the implicit channel (or prompted only
if PR hives were present). The local and global 'channel' configuration values
were never read, so a user who ran 'aspire config set channel staging' (or had
it saved by 'aspire update --self') would still get the implicit/NuGet-config
based channel on subsequent 'aspire update' runs.

UpdateCommand.ExecuteAsync now resolves the channel using the documented
precedence:

  1. explicit --channel / hidden --quality
  2. local app config 'channel' (aspire.config.json / .aspire/settings.json)
  3. global config 'channel' (~/.aspire/settings.global.json)
  4. interactive channel prompt when PR hives are present
  5. implicit/default channel as the documented fallback

Local-vs-global precedence comes for free because RegisterSettingsFiles loads
the global settings file before the local one, so IConfiguration (and
IConfigurationService.GetConfigurationAsync) returns the local value when both
exist. A configured channel that does not match any available channel now
surfaces a ChannelNotFoundException instead of being silently ignored.

The existing UpdateCommand_WithoutHives_UsesImplicitChannelWithoutPrompting
test is preserved (no configured channel still falls back to the implicit
channel) and joined by new regression coverage:

  * UpdateCommand_LocalConfiguredChannel_IsUsed
  * UpdateCommand_GlobalConfiguredChannel_IsUsed
  * UpdateCommand_ExplicitChannelOverridesConfiguredChannel
  * UpdateCommand_LocalConfiguredChannel_OverridesGlobalConfiguredChannel
  * UpdateCommand_WithoutHives_ConfiguredChannel_TakesPrecedenceOverImplicitFallback
  * UpdateCommand_ConfiguredChannelNotInChannelList_ThrowsChannelNotFound

Fixes #16650

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Resolve `aspire update` channel config relative to AppHost project directory

Addresses Copilot reviewer feedback on PR #16716. The previous fix moved
channel resolution to read from `IConfiguration`, but `IConfiguration` is
rooted at `Environment.CurrentDirectory` at startup via
`ConfigurationHelper.RegisterSettingsFiles`. That means
`aspire update --apphost <path-to-other-app>/AppHost.csproj` ignored the
target app's local `aspire.config.json` and read config from the caller's
cwd tree instead, so the documented "local app-config in the project tree"
precedence was still broken for explicit `--apphost` updates.

Add `IConfigurationService.GetConfigurationFromDirectoryAsync(key, startDirectory)`
which walks up from a caller-supplied directory for the nearest
`aspire.config.json`, then falls back to the global settings file. The
process-wide IConfiguration is intentionally not consulted, so the lookup
is never anchored to the launch cwd.

`UpdateCommand` now passes `projectFile.Directory` to scope the channel
lookup to the resolved AppHost project's tree.

Three new tests cover:
- Project in another directory uses its own local config
- Project-local config wins over cwd config
- Project-local config without `channel` falls back to global

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Mitch Denny <mitch@mitchdenny.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 3 people

src/Aspire.Cli/Commands/UpdateCommand.cs

@@ -155,19 +155,41 @@ protected override async Task<int> ExecuteAsync(ParseResult parseResult, Cancell
             var project = _projectFactory.GetProject(projectFile);
             var isProjectReferenceMode = project.IsUsingProjectReferences(projectFile);
 
-            // Check if channel or quality option was provided (channel takes precedence)
+            // Resolve the channel using the documented precedence:
+            //   1. explicit --channel / hidden --quality
+            //   2. local app config "channel" (relative to the resolved AppHost project, NOT cwd)
+            //   3. global config "channel"
+            //   4. interactive channel prompt when appropriate (PR hives present)
+            //   5. implicit/default channel as the documented fallback
+            // The directory-scoped lookup is critical: `aspire update --apphost <elsewhere>`
+            // must consult the project's directory tree, not the user's launch cwd. The
+            // process-wide IConfiguration is rooted at the launch cwd at startup, so using
+            // it here would silently read the wrong app's local config (issue #16650).
             var channelName = parseResult.GetValue(_channelOption) ?? parseResult.GetValue(_qualityOption);
+            var channelFromConfig = false;
+            if (string.IsNullOrWhiteSpace(channelName))
+            {
+                var configLookupDirectory = projectFile.Directory ?? ExecutionContext.WorkingDirectory;
+                channelName = await _configurationService.GetConfigurationFromDirectoryAsync("channel", configLookupDirectory, cancellationToken);
+                channelFromConfig = !string.IsNullOrWhiteSpace(channelName);
+            }
+
             PackageChannel channel;
 
             var allChannels = await InteractionService.ShowStatusAsync(
                 UpdateCommandStrings.CheckingForUpdates,
                 async () => await _packagingService.GetChannelsAsync(cancellationToken));
 
-            if (!string.IsNullOrEmpty(channelName))
+            if (!string.IsNullOrWhiteSpace(channelName))
             {
                 // Try to find a channel matching the provided channel/quality
                 channel = allChannels.FirstOrDefault(c => string.Equals(c.Name, channelName, StringComparison.OrdinalIgnoreCase))
                     ?? throw new ChannelNotFoundException($"No channel found matching '{channelName}'. Valid options are: {string.Join(", ", allChannels.Select(c => c.Name))}");
+
+                if (channelFromConfig)
+                {
+                    _logger.LogDebug("Using channel '{ChannelName}' from configuration.", channel.Name);
+                }
             }
             else if (isProjectReferenceMode)
             {

src/Aspire.Cli/Configuration/ConfigurationService.cs

@@ -1,7 +1,10 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Globalization;
+using System.Text.Json;
 using System.Text.Json.Nodes;
+using Aspire.Cli.Resources;
 using Aspire.Cli.Utils;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
@@ -353,4 +356,91 @@ private static void FlattenJsonObject(JsonObject obj, Dictionary<string, string>
         var configKey = key.Replace('.', ':');
         return Task.FromResult(configuration[configKey]);
     }
+
+    public Task<string?> GetConfigurationFromDirectoryAsync(string key, DirectoryInfo startDirectory, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(startDirectory);
+
+        var configKey = key.Replace('.', ':');
+
+        // 1. Project-relative local settings: walk up from startDirectory.
+        //    Intentionally bypasses the process-wide IConfiguration (which is rooted at the
+        //    CLI's launch cwd via ConfigurationHelper.RegisterSettingsFiles) so that commands
+        //    that operate on a path other than cwd (e.g. `aspire update --apphost <elsewhere>`)
+        //    consult the project's own aspire.config.json instead of the caller's cwd.
+        var localConfigPath = ConfigurationHelper.FindNearestConfigFilePath(startDirectory);
+        if (localConfigPath is not null)
+        {
+            var localConfig = LoadSettingsFileForReading(localConfigPath);
+            var localValue = localConfig[configKey];
+            if (!string.IsNullOrWhiteSpace(localValue))
+            {
+                return Task.FromResult<string?>(localValue);
+            }
+        }
+
+        // 2. Global settings file fallback (lower precedence).
+        if (File.Exists(globalSettingsFile.FullName))
+        {
+            var globalConfig = LoadSettingsFileForReading(globalSettingsFile.FullName);
+            var globalValue = globalConfig[configKey];
+            if (!string.IsNullOrWhiteSpace(globalValue))
+            {
+                return Task.FromResult<string?>(globalValue);
+            }
+        }
+
+        return Task.FromResult<string?>(null);
+    }
+
+    /// <summary>
+    /// Loads a single settings file into an isolated <see cref="IConfigurationRoot"/> for
+    /// directory-scoped lookups, mirroring <c>ConfigurationHelper.AddSettingsFile</c>'s
+    /// JSON-with-comments parsing and "throw on invalid JSON" behavior so directory-scoped
+    /// reads fail loudly the same way startup-time loads do.
+    /// </summary>
+    private static IConfigurationRoot LoadSettingsFileForReading(string filePath)
+    {
+        string content;
+        try
+        {
+            content = File.ReadAllText(filePath);
+        }
+        catch (IOException)
+        {
+            return new ConfigurationBuilder().Build();
+        }
+        catch (UnauthorizedAccessException)
+        {
+            return new ConfigurationBuilder().Build();
+        }
+
+        if (string.IsNullOrWhiteSpace(content))
+        {
+            return new ConfigurationBuilder().Build();
+        }
+
+        JsonNode? node;
+        try
+        {
+            node = JsonNode.Parse(content, documentOptions: ConfigurationHelper.ParseOptions);
+        }
+        catch (JsonException ex)
+        {
+            throw new InvalidOperationException(
+                string.Format(CultureInfo.CurrentCulture, ErrorStrings.InvalidJsonInConfigFile, filePath, ex.Message),
+                ex);
+        }
+
+        if (node is not JsonObject)
+        {
+            return new ConfigurationBuilder().Build();
+        }
+
+        var cleanJson = node.ToJsonString();
+        var bytes = System.Text.Encoding.UTF8.GetBytes(cleanJson);
+        return new ConfigurationBuilder()
+            .AddJsonStream(new MemoryStream(bytes))
+            .Build();
+    }
 }

src/Aspire.Cli/Configuration/IConfigurationService.cs

@@ -11,5 +11,22 @@ internal interface IConfigurationService
     Task<Dictionary<string, string>> GetLocalConfigurationAsync(CancellationToken cancellationToken = default);
     Task<Dictionary<string, string>> GetGlobalConfigurationAsync(CancellationToken cancellationToken = default);
     Task<string?> GetConfigurationAsync(string key, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Reads a configuration value scoped to a specific directory rather than the
+    /// process-wide working directory. The lookup walks upward from
+    /// <paramref name="startDirectory"/> for the nearest <c>aspire.config.json</c>
+    /// (or legacy <c>.aspire/settings.json</c>); if the key is not present in that file,
+    /// falls back to the global settings file. The process-wide
+    /// <see cref="Microsoft.Extensions.Configuration.IConfiguration"/> (which is rooted at
+    /// the working directory the CLI was launched from) is intentionally NOT consulted,
+    /// so commands like <c>aspire update --apphost &lt;path&gt;</c> can resolve config
+    /// from the project's directory tree instead of the caller's cwd.
+    /// </summary>
+    /// <remarks>
+    /// Throws <see cref="System.InvalidOperationException"/> if a settings file is found
+    /// but cannot be parsed as JSON, matching the behavior of startup-time settings load.
+    /// </remarks>
+    Task<string?> GetConfigurationFromDirectoryAsync(string key, DirectoryInfo startDirectory, CancellationToken cancellationToken = default);
     string GetSettingsFilePath(bool isGlobal);
 }

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

@@ -934,6 +934,11 @@ public Task<Dictionary<string, string>> GetGlobalConfigurationAsync(Cancellation
         return Task.FromResult<string?>(key);
     }
 
+    public Task<string?> GetConfigurationFromDirectoryAsync(string key, DirectoryInfo startDirectory, CancellationToken cancellationToken = default)
+    {
+        return GetConfigurationAsync(key, cancellationToken);
+    }
+
     public string GetSettingsFilePath(bool isGlobal)
     {
         return string.Empty;

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

@@ -710,6 +710,9 @@ private sealed class FakeConfigurationServiceWithChannel(string channelValue) :
         public Task<string?> GetConfigurationAsync(string key, CancellationToken cancellationToken = default)
             => Task.FromResult<string?>(string.Equals(key, "channel", StringComparison.Ordinal) ? channelValue : null);
 
+        public Task<string?> GetConfigurationFromDirectoryAsync(string key, DirectoryInfo startDirectory, CancellationToken cancellationToken = default)
+            => GetConfigurationAsync(key, cancellationToken);
+
         public Task SetConfigurationAsync(string key, string value, bool isGlobal = false, CancellationToken cancellationToken = default)
             => Task.CompletedTask;