Address PR feedback & cleanup logging

liliankasem · liliankasem · commit 279bae9cd2e3 · 2025-10-15T16:03:56.000-07:00
diff --git a/release_notes.md b/release_notes.md
@@ -9,3 +9,4 @@
 
 - <entry>
 - Add Dockerfile for python 3.13 local build environment (#4611)
+- Implement preview feature to apply host configuration profiles on 'func init' command (#4675)
diff --git a/src/Cli/func/Actions/LocalActions/InitAction.cs b/src/Cli/func/Actions/LocalActions/InitAction.cs
@@ -11,6 +11,7 @@
 using Azure.Functions.Cli.StacksApi;
 using Colors.Net;
 using Fclp;
+using Microsoft.Azure.WebJobs.Host.Config;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using static Azure.Functions.Cli.Common.OutputTheme;
@@ -125,13 +126,6 @@ public override ICommandLineParserResult ParseArgs(string[] args)
                 .WithDescription($"Initialize a project with the given target framework moniker. Currently supported only when --worker-runtime set to dotnet-isolated or dotnet. Options are - {string.Join(", ", TargetFrameworkHelper.GetSupportedTargetFrameworks())}")
                 .Callback(tf => TargetFramework = tf);
 
-            Parser
-                .Setup<string>("configurationProfile")
-                .SetDefault(null)
-                .WithDescription("Initialize the project with a configuration profile." +
-                "Note that the Functions project will not be initialized and only the relevant configuration profile will be set. Currently supported: mcp-custom-handler (preview)")
-                .Callback(cp => ConfigurationProfile = cp);
-
             Parser
                 .Setup<bool>("managed-dependencies")
                 .WithDescription("Installs managed dependencies. Currently, only the PowerShell worker runtime supports this functionality.")
@@ -156,6 +150,13 @@ public override ICommandLineParserResult ParseArgs(string[] args)
                 .WithDescription("Do not create getting started documentation file. Currently supported when --worker-runtime set to python.")
                 .Callback(d => GeneratePythonDocumentation = !d);
 
+            Parser
+                .Setup<string>("configuration-profile")
+                .SetDefault(null)
+                .WithDescription(WarningColor("[preview]").ToString() + " Initialize a project with a host configuration profile. Currently supported: 'mcp-custom-handler'. "
+                    + WarningColor("Using a configuration profile may skip all other initialization steps.").ToString())
+                .Callback(cp => ConfigurationProfile = cp);
+
             if (args.Any() && !args.First().StartsWith("-"))
             {
                 FolderName = args.First();
@@ -218,22 +219,9 @@ private async Task InitFunctionAppProject()
                 }
             }
 
-            // Validate configuration profile if provided and ensure provider exists=
-            if (!string.IsNullOrEmpty(ConfigurationProfile))
+            // If a configuration profile is provided, apply it and return
+            if (await ApplyConfigurationProfileIfProvided())
             {
-                IConfigurationProfile selectedProvider = _configurationProfile.FirstOrDefault(p => p.Name == ConfigurationProfile);
-                if (selectedProvider == null)
-                {
-                    var allProfiles = _configurationProfile.Select(p => p.Name);
-                    var supportedProfileNames = string.Join(", ", allProfiles.Where(p => p != null));
-                    var supportedMessage = allProfiles.Any()
-                        ? $"Supported values: {supportedProfileNames}."
-                        : "No configuration profiles are currently registered.";
-                    throw new CliArgumentsException($"configurationProfile '{ConfigurationProfile}' is not supported. {supportedMessage}");
-                }
-
-                // Apply the configuration profile and return
-                await selectedProvider.ApplyAsync(ResolvedWorkerRuntime, Force);
                 return;
             }
 
@@ -678,5 +666,32 @@ private async Task ShowEolMessage()
                 // ignore. Failure to show the EOL message should not fail the init command.
             }
         }
+
+        private async Task<bool> ApplyConfigurationProfileIfProvided()
+        {
+            if (string.IsNullOrEmpty(ConfigurationProfile))
+            {
+                return false;
+            }
+
+            IConfigurationProfile configurationProfile = _configurationProfile.FirstOrDefault(p => p.Name == ConfigurationProfile);
+            if (configurationProfile == null)
+            {
+                var allProfiles = _configurationProfile.Select(p => p.Name);
+                var supportedProfileNames = string.Join(", ", allProfiles.Where(p => p != null));
+                var supportedMessage = allProfiles.Any()
+                    ? $"Supported values: {supportedProfileNames}."
+                    : "No configuration profiles are currently registered.";
+
+                ColoredConsole.WriteLine(WarningColor($"Configuration profile '{ConfigurationProfile}' is not supported. {supportedMessage}"));
+                return true;
+            }
+
+            // Apply the configuration profile and return
+            ColoredConsole.WriteLine(WarningColor($"You are using a preview feature. Configuration profiles may change in future releases."));
+            SetupProgressLogger.Section($"Applying configuration profile: {configurationProfile.Name}");
+            await configurationProfile.ApplyAsync(ResolvedWorkerRuntime, Force);
+            return true;
+        }
     }
 }
diff --git a/src/Cli/func/Common/SecretsManager.cs b/src/Cli/func/Common/SecretsManager.cs
@@ -5,7 +5,7 @@
 using Azure.Functions.Cli.Interfaces;
 using Colors.Net;
 using Microsoft.Azure.WebJobs.Script;
-using Microsoft.Build.Logging;
+using static Colors.Net.StringStaticMethods;
 
 namespace Azure.Functions.Cli.Common
 {
@@ -27,7 +27,7 @@ public static string AppSettingsFilePath
                 });
                 var secretsFilePath = Path.Combine(rootPath, secretsFile);
 
-                ColoredConsole.WriteLine($"{secretsFile} found in root directory ({rootPath}).");
+                ColoredConsole.WriteLine(DarkGray($"'{secretsFile}' found in root directory ({rootPath})."));
                 return secretsFilePath;
             }
         }
diff --git a/src/Cli/func/ConfigurationProfiles/IConfigurationProfile.cs b/src/Cli/func/ConfigurationProfiles/IConfigurationProfile.cs
@@ -8,9 +8,9 @@ namespace Azure.Functions.Cli.ConfigurationProfiles
     internal interface IConfigurationProfile
     {
         /// <summary>
-        /// Gets or sets the name of the profile.
+        /// Gets the name of the profile.
         /// </summary>
-        internal string Name { get; set; }
+        internal string Name { get; }
 
         /// <summary>
         /// Applies the profile by generating necessary configuration artifacts.
diff --git a/src/Cli/func/ConfigurationProfiles/McpCustomHandlerConfigurationProfile.cs b/src/Cli/func/ConfigurationProfiles/McpCustomHandlerConfigurationProfile.cs
@@ -3,71 +3,55 @@
 
 using Azure.Functions.Cli.Common;
 using Azure.Functions.Cli.Helpers;
-using Colors.Net;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace Azure.Functions.Cli.ConfigurationProfiles
 {
     internal class McpCustomHandlerConfigurationProfile : IConfigurationProfile
     {
-        private static readonly WorkerRuntime[] _supportedRuntimes = new[]
-        {
-            WorkerRuntime.DotnetIsolated,
-            WorkerRuntime.Python,
-            WorkerRuntime.Node
-        };
+        // This feature flag enables MCP (Multi-Container Platform) support for custom handlers
+        // This flag is not required locally, but is required when deploying to Azure environments.
+        private const string McpFeatureFlag = "EnableMcpCustomHandlerPreview";
 
-        public string Name { get; set; } = "mcp-custom-handler";
+        public string Name { get; } = "mcp-custom-handler";
 
         public async Task ApplyAsync(WorkerRuntime workerRuntime, bool shouldForce = false)
         {
-            ValidateWorkerRuntime(workerRuntime);
             await ApplyHostJsonAsync(shouldForce);
             await ApplyLocalSettingsAsync(workerRuntime, shouldForce);
         }
 
-        private static void ValidateWorkerRuntime(WorkerRuntime workerRuntime)
+        public async Task ApplyHostJsonAsync(bool force)
         {
-            if (!_supportedRuntimes.Contains(workerRuntime))
-            {
-                var supportedRuntimesList = string.Join(", ", _supportedRuntimes.Select(r => WorkerRuntimeLanguageHelper.GetRuntimeMoniker(r)));
-                throw new CliException($"The MCP custom handler configuration profile only supports the following runtimes: {supportedRuntimesList}. " +
-                    $"The current runtime '{WorkerRuntimeLanguageHelper.GetRuntimeMoniker(workerRuntime)}' is not supported.");
-            }
-        }
+            bool changed = false;
+            string baseHostJson;
 
-        public async Task ApplyHostJsonAsync(bool shouldForce)
-        {
             // Check if host.json exists and read it, otherwise use the default template
-            var hostJsonPath = Path.Combine(Environment.CurrentDirectory, Constants.HostJsonFileName);
-            var hostExists = FileSystemHelpers.FileExists(hostJsonPath);
-            string baseHostJson;
+            string hostJsonPath = Path.Combine(Environment.CurrentDirectory, Constants.HostJsonFileName);
 
-            JObject hostJsonObj;
-            if (hostExists)
+            if (FileSystemHelpers.FileExists(hostJsonPath))
             {
-                ColoredConsole.WriteLine($"Applying MCP custom handler configuration profile to existing {hostJsonPath}...");
+                SetupProgressLogger.FileFound("host.json", hostJsonPath);
                 baseHostJson = await FileSystemHelpers.ReadAllTextFromFileAsync(hostJsonPath);
             }
             else
             {
+                SetupProgressLogger.FileCreated("host.json", hostJsonPath);
                 baseHostJson = await StaticResources.HostJson;
             }
 
-            hostJsonObj = JsonConvert.DeserializeObject<JObject>(baseHostJson);
-
-            var changed = false;
+            JObject hostJsonObj = JsonConvert.DeserializeObject<JObject>(baseHostJson);
 
-            // Add configurationProfile if missing or if shouldForce is true
-            if (!hostJsonObj.TryGetValue("configurationProfile", StringComparison.OrdinalIgnoreCase, out _) || shouldForce)
+            // Add configurationProfile if missing or if force is true
+            if (!hostJsonObj.TryGetValue("configurationProfile", StringComparison.OrdinalIgnoreCase, out _) || force)
             {
-                hostJsonObj["configurationProfile"] = "mcp-custom-handler";
+                hostJsonObj["configurationProfile"] = Name;
                 changed = true;
             }
 
-            // Add customHandler section if missing or if shouldForce is true
-            if (!hostJsonObj.TryGetValue("customHandler", StringComparison.OrdinalIgnoreCase, out _) || shouldForce)
+            // Add customHandler section if missing or if force is true
+            if (!hostJsonObj.TryGetValue("customHandler", StringComparison.OrdinalIgnoreCase, out _) || force)
             {
                 hostJsonObj["customHandler"] = new JObject
                 {
@@ -82,58 +66,55 @@ public async Task ApplyHostJsonAsync(bool shouldForce)
 
             if (changed)
             {
-                var hostJsonContent = JsonConvert.SerializeObject(hostJsonObj, Formatting.Indented);
+                string hostJsonContent = JsonConvert.SerializeObject(hostJsonObj, Formatting.Indented);
                 await FileSystemHelpers.WriteAllTextToFileAsync(hostJsonPath, hostJsonContent);
+                SetupProgressLogger.Ok("host.json", "Updated with MCP configuration profile");
+            }
+            else
+            {
+                SetupProgressLogger.Warn("host.json", "Already configured (use --force to overwrite)");
             }
-
-            ColoredConsole.WriteLine(changed
-                ? "Updated host.json with MCP configuration profile."
-                : "host.json already contains MCP configuration profile. Please pass in `--force` to overwrite.\n");
         }
 
-        public async Task ApplyLocalSettingsAsync(WorkerRuntime workerRuntime, bool shouldForce)
+        public async Task ApplyLocalSettingsAsync(WorkerRuntime workerRuntime, bool force)
         {
-            // Check if local.settings.json exists and read it, otherwise use the default template
-            var localSettingsPath = Path.Combine(Environment.CurrentDirectory, "local.settings.json");
-            var localExists = FileSystemHelpers.FileExists(localSettingsPath);
+            bool changed = false;
             string baseLocalSettings;
 
-            JObject localObj;
-            if (localExists)
+            // Check if local.settings.json exists and read it, otherwise use the default template
+            string localSettingsPath = Path.Combine(Environment.CurrentDirectory, "local.settings.json");
+
+            if (FileSystemHelpers.FileExists(localSettingsPath))
             {
-                ColoredConsole.WriteLine($"Applying MCP custom handler configuration profile to existing {localSettingsPath}...");
+                SetupProgressLogger.FileFound("local.settings.json", localSettingsPath);
                 baseLocalSettings = await FileSystemHelpers.ReadAllTextFromFileAsync(localSettingsPath);
             }
             else
             {
+                SetupProgressLogger.FileCreated("local.settings.json", localSettingsPath);
                 baseLocalSettings = await StaticResources.LocalSettingsJson;
 
                 // Replace placeholders in the template
                 baseLocalSettings = baseLocalSettings.Replace($"{{{Constants.FunctionsWorkerRuntime}}}", WorkerRuntimeLanguageHelper.GetRuntimeMoniker(workerRuntime));
                 baseLocalSettings = baseLocalSettings.Replace($"{{{Constants.AzureWebJobsStorage}}}", Constants.StorageEmulatorConnectionString);
             }
 
-            localObj = JsonConvert.DeserializeObject<JObject>(baseLocalSettings);
-
-            var changed = false;
-            var values = localObj["Values"] as JObject ?? new JObject();
-            var runtimeKey = Constants.FunctionsWorkerRuntime;
+            JObject localObj = JsonConvert.DeserializeObject<JObject>(baseLocalSettings);
+            JObject values = localObj["Values"] as JObject ?? [];
 
-            // Determine moniker for default; if existing runtime present, do not overwrite unless shouldForce is true
-            if (!values.TryGetValue(runtimeKey, StringComparison.OrdinalIgnoreCase, out _) || shouldForce)
+            // Determine moniker for default; if existing runtime present, do not overwrite unless force is true
+            if (!values.TryGetValue(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase, out _) || force)
             {
-                var runtimeMoniker = WorkerRuntimeLanguageHelper.GetRuntimeMoniker(workerRuntime);
-
-                values[runtimeKey] = runtimeMoniker;
+                string runtimeMoniker = WorkerRuntimeLanguageHelper.GetRuntimeMoniker(workerRuntime);
+                values[Constants.FunctionsWorkerRuntime] = runtimeMoniker;
                 changed = true;
             }
 
-            // Handle AzureWebJobsFeatureFlags - append if exists and shouldForce is enabled, create if not
-            const string mcpFeatureFlag = "EnableMcpCustomHandlerPreview";
-            var azureWebJobsFeatureFlagsExists = values.TryGetValue("AzureWebJobsFeatureFlags", StringComparison.OrdinalIgnoreCase, out var existingFlagsToken);
-            if (azureWebJobsFeatureFlagsExists && shouldForce)
+            // Handle AzureWebJobsFeatureFlags - append if exists and force is enabled, create if not
+            bool azureWebJobsFeatureFlagsExists = values.TryGetValue(Constants.AzureWebJobsFeatureFlags, StringComparison.OrdinalIgnoreCase, out var existingFlagsToken);
+            if (azureWebJobsFeatureFlagsExists && force)
             {
-                var existingFlags = existingFlagsToken?.ToString() ?? string.Empty;
+                string existingFlags = existingFlagsToken?.ToString() ?? string.Empty;
 
                 // Split by comma and trim whitespace
                 var flagsList = existingFlags
@@ -143,9 +124,9 @@ public async Task ApplyLocalSettingsAsync(WorkerRuntime workerRuntime, bool shou
                     .ToList();
 
                 // Add the MCP feature flag if it's not already present
-                if (!flagsList.Contains(mcpFeatureFlag, StringComparer.OrdinalIgnoreCase))
+                if (!flagsList.Contains(McpFeatureFlag, StringComparer.OrdinalIgnoreCase))
                 {
-                    flagsList.Add(mcpFeatureFlag);
+                    flagsList.Add(McpFeatureFlag);
 
                     // Rejoin with comma and space
                     values["AzureWebJobsFeatureFlags"] = string.Join(",", flagsList);
@@ -155,20 +136,22 @@ public async Task ApplyLocalSettingsAsync(WorkerRuntime workerRuntime, bool shou
             else if (!azureWebJobsFeatureFlagsExists)
             {
                 // No existing feature flags, create with just our flag
-                values["AzureWebJobsFeatureFlags"] = mcpFeatureFlag;
+                values["AzureWebJobsFeatureFlags"] = McpFeatureFlag;
                 changed = true;
+                SetupProgressLogger.Warn("local.settings.json", $"Added feature flag '{McpFeatureFlag}'");
             }
 
             if (changed)
             {
                 localObj["Values"] = values;
-                var localContent = JsonConvert.SerializeObject(localObj, Formatting.Indented);
+                string localContent = JsonConvert.SerializeObject(localObj, Formatting.Indented);
                 await FileSystemHelpers.WriteAllTextToFileAsync(localSettingsPath, localContent);
+                SetupProgressLogger.Ok("local.settings.json", "Updated settings");
+            }
+            else
+            {
+                SetupProgressLogger.Warn("local.settings.json", "Already configured (use --force to overwrite)");
             }
-
-            ColoredConsole.WriteLine(changed
-                ? "Updated local.settings.json with MCP configuration profile."
-                : "local.settings.json already contains MCP configuration profile. Please pass in `--force` to overwrite.\n");
         }
     }
 }
diff --git a/src/Cli/func/Helpers/SetupProgressLogger.cs b/src/Cli/func/Helpers/SetupProgressLogger.cs
@@ -0,0 +1,53 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System.Text;
+using Colors.Net;
+using static Colors.Net.StringStaticMethods;
+
+namespace Azure.Functions.Cli.Helpers
+{
+    internal static class SetupProgressLogger
+    {
+        static SetupProgressLogger()
+        {
+            try
+            {
+                Console.OutputEncoding = Encoding.UTF8;
+            }
+            catch
+            {
+                 /* ignore */
+            }
+        }
+
+        private static string Rel(string path)
+        {
+            string cwd = Environment.CurrentDirectory.TrimEnd(Path.DirectorySeparatorChar);
+            return path.StartsWith(cwd, StringComparison.OrdinalIgnoreCase)
+                ? string.Concat(".", path.AsSpan(cwd.Length))
+                : path;
+        }
+
+        public static void Section(string text) =>
+            ColoredConsole.WriteLine($"\n{DarkGray($"▸ {text}")}");
+
+        public static void Step(string scope, string text) =>
+            ColoredConsole.WriteLine($"{Gray($"[{scope}]")} {text}");
+
+        public static void Ok(string scope, string text) =>
+            ColoredConsole.WriteLine($"{Gray($"[{scope}]")} {Green($"✓ {text}")}");
+
+        public static void Info(string scope, string text) =>
+            ColoredConsole.WriteLine($"{Gray($"[{scope}]")} {text}");
+
+        public static void Warn(string scope, string text) =>
+            ColoredConsole.WriteLine($"{Gray($"[{scope}]")} {Yellow($"⚠ {text}")}");
+
+        public static void FileFound(string scope, string path) =>
+            Step(scope, $"Found at {Rel(path)}");
+
+        public static void FileCreated(string scope, string path) =>
+            Step(scope, $"Creating new at {Rel(path)}");
+    }
+}
diff --git a/test/Cli/Func.UnitTests/ConfigurationProfileTests/McpCustomHandlerConfigurationProfileTests.cs b/test/Cli/Func.UnitTests/ConfigurationProfileTests/McpCustomHandlerConfigurationProfileTests.cs

Original file line number	Diff line number	Diff line change
`@@ -9,3 +9,4 @@`
`9`	`9`
`10`	`10`	`- <entry>`
`11`	`11`	`- Add Dockerfile for python 3.13 local build environment (#4611)`
	`12`	`+- Implement preview feature to apply host configuration profiles on 'func init' command (#4675)`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`using Azure.Functions.Cli.Interfaces;`
`6`	`6`	`using Colors.Net;`
`7`	`7`	`using Microsoft.Azure.WebJobs.Script;`
`8`		`-using Microsoft.Build.Logging;`
	`8`	`+using static Colors.Net.StringStaticMethods;`
`9`	`9`
`10`	`10`	`namespace Azure.Functions.Cli.Common`
`11`	`11`	`{`
`@@ -27,7 +27,7 @@ public static string AppSettingsFilePath`
`27`	`27`	`});`
`28`	`28`	`var secretsFilePath = Path.Combine(rootPath, secretsFile);`
`29`	`29`
`30`		`- ColoredConsole.WriteLine($"{secretsFile} found in root directory ({rootPath}).");`
	`30`	`+ ColoredConsole.WriteLine(DarkGray($"'{secretsFile}' found in root directory ({rootPath})."));`
`31`	`31`	`return secretsFilePath;`
`32`	`32`	`}`
`33`	`33`	`}`