Updating coretools to detect unsupported inproc6 sdk scenario

src/Azure.Functions.Cli/Actions/HostActions/StartHostAction.cs

@@ -494,8 +494,14 @@ private async Task<bool> ShouldExitAfterDeterminingHostRuntime(bool isVerbose)
 
                 if (!string.Equals(HostRuntime, "default", StringComparison.OrdinalIgnoreCase))
                 {
+                    if (Utilities.IsMinifiedVersion())
+                    {
+                        ThrowForInProc();
+                    }
+
                     var isNet8InProcSpecified = string.Equals(HostRuntime, DotnetConstants.InProc8HostRuntime, StringComparison.OrdinalIgnoreCase);
                     StartHostAsChildProcess(isNet8InProcSpecified);
+
                     return true;
                 }
             }
@@ -514,7 +520,13 @@ private async Task<bool> ShouldExitAfterDeterminingHostRuntime(bool isVerbose)
                     PrintVerboseForHostSelection(isVerbose, DotnetConstants.InProc6HostRuntime);
                 }
 
+                if (Utilities.IsMinifiedVersion())
+                {
+                    ThrowForInProc();
+                }
+
                 StartHostAsChildProcess(shouldNet8InProcBeLaunched);
+
                 return true;
 
             }
@@ -571,6 +583,10 @@ private async Task ValidateHostRuntime(bool isInProc, bool isVerbose)
             throw new CliException($"Invalid host runtime '{HostRuntime}'. Valid values are 'default', '{DotnetConstants.InProc8HostRuntime}', '{DotnetConstants.InProc6HostRuntime}'.");
         }
 
+        private void ThrowForInProc()
+        {
+            throw new CliException($"This version of the Azure Functions Core Tools requires your project to reference version {DotnetConstants.InProcFunctionsMinSdkVersion} or later of {DotnetConstants.InProcFunctionsSdk}. Please update to the latest version. For more information, see: {DotnetConstants.InProcFunctionsDocsLink}");
+        }
         private void PrintVerboseForHostSelection(bool isVerbose, string hostRuntime)
         {
             if (isVerbose)

src/Azure.Functions.Cli/Common/Constants.cs

@@ -26,6 +26,8 @@ internal static class Constants
         public const string HostJsonFileName = "host.json";
         public const string PackageJsonFileName = "package.json";
         public const string ProxiesJsonFileName = "proxies.json";
+        public const string ArtifactsConfigFileName = "artifactsconfig.json";
+        public const string MinifiedVersionConfigSectionName = "minifiedVersion";
         public const string ExtensionsCsProjFile = "extensions.csproj";
         public const string DefaultVEnvName = "worker_env";
         public const string ExternalPythonPackages = ".python_packages";

src/Azure.Functions.Cli/Common/DotnetConstants.cs

@@ -14,5 +14,8 @@ internal static class DotnetConstants
         public const string InProc6DirectoryName = "in-proc6";
         public const string InProc8HostRuntime = "inproc8";
         public const string InProc6HostRuntime = "inproc6";
+        public const string InProcFunctionsSdk = "Microsoft.NET.Sdk.Functions";
+        public const string InProcFunctionsMinSdkVersion = "4.5.0";
+        public const string InProcFunctionsDocsLink = "https://aka.ms/functions-core-tools-in-proc-sdk-requirement";
     }
 }

src/Azure.Functions.Cli/Common/Utilities.cs

@@ -263,5 +263,25 @@ internal static IConfigurationRoot BuildHostJsonConfigutation(ScriptApplicationH
             var configuration = builder.Build();
             return configuration;
         }
+
+        internal static bool IsMinifiedVersion()
+        {
+            IConfigurationBuilder builder = new ConfigurationBuilder();
+            builder.AddJsonFile(Constants.ArtifactsConfigFileName, optional: true);
+            var config = builder.Build();
+
+            try
+            {
+                var section = config.GetSection(Constants.MinifiedVersionConfigSectionName);
+
+                if (section.Exists())
+                {
+                    string value = section.Value;
+                    return bool.TryParse(value, out bool isValue) && isValue;
+                }
+            }
+            catch { }
+            return false;
+        }
     }
 }

test/Azure.Functions.Cli.Tests/E2E/StartTests.cs

@@ -677,31 +677,6 @@ await CliTester.Run(new RunConfiguration
             }, _output);
         }
 
-        [Fact]
-        public async Task start_dotnet_isolated_inproc_with_specifying_runtime()
-        {
-            await CliTester.Run(new RunConfiguration
-            {
-                Commands = new[]
-                {
-                    "init . --worker-runtime dotnet --target-framework net6.0",
-                    "new --template Httptrigger --name HttpTrigger",
-                    "start --port 7073 --verbose --runtime inproc6"
-                },
-                ExpectExit = false,
-                ErrorContains = ["Failed to locate the inproc6 model host at"],
-                Test = async (workingDir, p) =>
-                {
-                    using (var client = new HttpClient() { BaseAddress = new Uri("http://localhost:7073") })
-                    {
-                        await Task.Delay(TimeSpan.FromSeconds(2));
-                    }
-                },
-                CommandTimeout = TimeSpan.FromSeconds(100),
-            }, _output);
-        }
-
-
         [Fact]
         public async Task start_dotnet_isolated_csharp_with_oop_host_with_runtime_specified()
         {

test/Azure.Functions.Cli.Tests/UtilitiesTests.cs

@@ -2,6 +2,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using System.Collections.Generic;
+using System.IO;
 using Xunit;
 
 namespace Azure.Functions.Cli.Tests
@@ -60,5 +61,20 @@ public void IsSystemLogCategory_Test(string inputCategory, bool expected)
         {
             Assert.Equal(expected, Utilities.IsSystemLogCategory(inputCategory));
         }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void Test_IsMinifiedVersion(bool expected)
+        {
+            var filePath = Path.Combine("artifactsconfig.json");
+            string artifactsJsonContent = "{\"minifiedVersion\": " + expected.ToString().ToLower() + "}";
+            File.WriteAllTextAsync(filePath, artifactsJsonContent).GetAwaiter().GetResult();
+
+            bool output = Utilities.IsMinifiedVersion();
+
+            File.Delete(filePath);
+            Assert.Equal(expected, output);
+        }
     }
 }