fix: Fix dnx not being used for .NET 10+ target frameworks (#43)

Author: Copilot

dotnet-tools.json .config/dotnet-tools.jsondotnet-tools.json renamed to .config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "erikej.efcorepowertools.cli": {
-      "version": "10.1.1055",
+      "version": "10.1.1094",
       "commands": [
         "efcpt"
       ],

src/JD.Efcpt.Build.Tasks/RunEfcpt.cs

@@ -29,8 +29,8 @@ namespace JD.Efcpt.Build.Tasks;
 ///   </item>
 ///   <item>
 ///     <description>
-///       On .NET 10.0 or later, if dnx is available, the task runs <c>dnx &lt;ToolPackageId&gt;</c>
-///       to execute the tool without requiring installation.
+///       When the project targets .NET 10.0 or later, the .NET 10+ SDK is installed, and dnx is available,
+///       the task runs <c>dnx &lt;ToolPackageId&gt;</c> to execute the tool without requiring installation.
 ///     </description>
 ///   </item>
 ///   <item>
@@ -77,6 +77,11 @@ namespace JD.Efcpt.Build.Tasks;
 /// </remarks>
 public sealed class RunEfcpt : Task
 {
+    /// <summary>
+    /// Timeout in milliseconds for external process operations (SDK checks, dnx availability).
+    /// </summary>
+    private const int ProcessTimeoutMs = 5000;
+
     /// <summary>
     /// Controls how the efcpt dotnet tool is resolved.
     /// </summary>
@@ -119,9 +124,10 @@ public sealed class RunEfcpt : Task
     /// </value>
     /// <remarks>
     /// <para>
-    /// On .NET 10.0 or later, tool restoration is skipped even when this property is <c>true</c>
-    /// because the <c>dnx</c> command handles tool execution directly without requiring prior
-    /// installation. The tool is fetched and run on-demand by the dotnet SDK.
+    /// When the project targets .NET 10.0 or later and the .NET 10+ SDK is installed, tool restoration
+    /// is skipped even when this property is <c>true</c> because the <c>dnx</c> command handles tool
+    /// execution directly without requiring prior installation. The tool is fetched and run on-demand
+    /// by the dotnet SDK.
     /// </para>
     /// </remarks>
     public string ToolRestore { get; set; } = "true";
@@ -224,6 +230,15 @@ public sealed class RunEfcpt : Task
     /// </value>
     public string Provider { get; set; } = "mssql";
 
+    /// <summary>
+    /// Target framework of the project being built (e.g., "net8.0", "net9.0", "net10.0").
+    /// </summary>
+    /// <value>
+    /// Used to determine whether to use dnx for tool execution on .NET 10+ projects.
+    /// If empty or not specified, falls back to runtime version detection.
+    /// </value>
+    public string TargetFramework { get; set; } = "";
+
     private readonly record struct ToolResolutionContext(
         string ToolPath,
         string ToolMode,
@@ -234,6 +249,7 @@ private readonly record struct ToolResolutionContext(
         string ToolPackageId,
         string WorkingDir,
         string Args,
+        string TargetFramework,
         BuildLog Log
     );
 
@@ -255,6 +271,7 @@ private readonly record struct ToolRestoreContext(
         string ToolPath,
         string ToolPackageId,
         string ToolVersion,
+        string TargetFramework,
         BuildLog Log
     );
 
@@ -267,7 +284,7 @@ BuildLog Log
                     Args: ctx.Args,
                     Cwd: ctx.WorkingDir,
                     UseManifest: false))
-            .When((in ctx) => IsDotNet10OrLater() && IsDnxAvailable(ctx.DotNetExe))
+            .When((in ctx) => IsDotNet10OrLater(ctx.TargetFramework) && IsDotNet10SdkInstalled(ctx.DotNetExe) && IsDnxAvailable(ctx.DotNetExe))
             .Then((in ctx)
                 => new ToolInvocation(
                     Exe: ctx.DotNetExe,
@@ -297,29 +314,30 @@ private static bool ToolIsAutoOrManifest(ToolResolutionContext ctx) =>
     private static readonly Lazy<ActionStrategy<ToolRestoreContext>> ToolRestoreStrategy = new(() =>
         ActionStrategy<ToolRestoreContext>.Create()
             // Manifest restore: restore tools from local manifest
-            // Skip on .NET 10+ because dnx handles tool execution without installation
-            .When(static (in ctx) => ctx is { UseManifest: true, ShouldRestore: true } && !IsDotNet10OrLater())
+            // Skip when: dnx will be used OR no manifest directory exists
+            .When((in ctx) => ctx is { UseManifest: true, ShouldRestore: true, ManifestDir: not null } 
+                && !(IsDotNet10OrLater(ctx.TargetFramework) && IsDotNet10SdkInstalled(ctx.DotNetExe) && IsDnxAvailable(ctx.DotNetExe)))
             .Then((in ctx) =>
             {
                 var restoreCwd = ctx.ManifestDir ?? ctx.WorkingDir;
                 ProcessRunner.RunOrThrow(ctx.Log, ctx.DotNetExe, "tool restore", restoreCwd);
             })
             // Global restore: update global tool package
-            // Skip on .NET 10+ because dnx handles tool execution without installation
-            .When(static (in ctx)
+            // Skip only when dnx will be used (all three conditions: .NET 10+ target, SDK installed, dnx available)
+            .When((in ctx)
                 => ctx is
                 {
                     UseManifest: false,
                     ShouldRestore: true,
                     HasExplicitPath: false,
                     HasPackageId: true
-                } && !IsDotNet10OrLater())
+                } && !(IsDotNet10OrLater(ctx.TargetFramework) && IsDotNet10SdkInstalled(ctx.DotNetExe) && IsDnxAvailable(ctx.DotNetExe)))
             .Then((in ctx) =>
             {
                 var versionArg = string.IsNullOrWhiteSpace(ctx.ToolVersion) ? "" : $" --version \"{ctx.ToolVersion}\"";
                 ProcessRunner.RunOrThrow(ctx.Log, ctx.DotNetExe, $"tool update --global {ctx.ToolPackageId}{versionArg}", ctx.WorkingDir);
             })
-            // Default: no restoration needed (includes .NET 10+ with dnx)
+            // Default: no restoration needed (dnx will be used OR no manifest for manifest mode)
             .Default(static (in _) => { })
             .Build());
 
@@ -392,7 +410,7 @@ private bool ExecuteCore(TaskExecutionContext ctx)
         // Use the Strategy pattern to resolve tool invocation
         var context = new ToolResolutionContext(
             ToolPath, mode, manifestDir, forceManifestOnNonWindows,
-            DotNetExe, ToolCommand, ToolPackageId, workingDir, args, log);
+            DotNetExe, ToolCommand, ToolPackageId, workingDir, args, TargetFramework, log);
 
         var invocation = ToolResolutionStrategy.Value.Execute(in context);
 
@@ -418,6 +436,7 @@ private bool ExecuteCore(TaskExecutionContext ctx)
             ToolPath: ToolPath,
             ToolPackageId: ToolPackageId,
             ToolVersion: ToolVersion,
+            TargetFramework: TargetFramework,
             Log: log
         );
 
@@ -429,12 +448,106 @@ private bool ExecuteCore(TaskExecutionContext ctx)
     }
 
 
-    private static bool IsDotNet10OrLater()
+    /// <summary>
+    /// Checks if the target framework is .NET 10.0 or later.
+    /// </summary>
+    /// <param name="targetFramework">The target framework string (e.g., "net8.0", "net10.0").</param>
+    /// <returns>True if the target framework is .NET 10.0 or later; otherwise false.</returns>
+    private static bool IsDotNet10OrLater(string targetFramework)
+    {
+        if (string.IsNullOrWhiteSpace(targetFramework))
+            return false;
+
+        try
+        {
+            // Parse target framework to get major version (e.g., "net8.0" -> 8, "net10.0" -> 10)
+            if (!targetFramework.StartsWith("net", StringComparison.OrdinalIgnoreCase))
+                return false;
+
+            var versionPart = targetFramework[3..];
+
+            // Trim at the first '.' or '-' after "net" to handle formats like:
+            // - "net10.0"           -> "10"
+            // - "net10.0-windows"   -> "10"
+            // - "net10-windows"     -> "10"
+            var dotIndex = versionPart.IndexOf('.');
+            var hyphenIndex = versionPart.IndexOf('-');
+
+            var cutIndex = (dotIndex >= 0, hyphenIndex >= 0) switch
+            {
+                (true, true) => Math.Min(dotIndex, hyphenIndex),
+                (true, false) => dotIndex,
+                (false, true) => hyphenIndex,
+                _ => -1
+            };
+
+            if (cutIndex > 0)
+                versionPart = versionPart[..cutIndex];
+
+            if (int.TryParse(versionPart, out var version))
+                return version >= 10;
+
+            return false;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Checks if .NET SDK version 10 or later is installed.
+    /// </summary>
+    /// <param name="dotnetExe">Path to the dotnet executable.</param>
+    /// <returns>True if .NET 10+ SDK is installed; otherwise false.</returns>
+    private static bool IsDotNet10SdkInstalled(string dotnetExe)
     {
         try
         {
-            var version = Environment.Version;
-            return version.Major >= 10;
+            var psi = new ProcessStartInfo
+            {
+                FileName = dotnetExe,
+                Arguments = "--list-sdks",
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true
+            };
+
+            using var p = Process.Start(psi);
+            if (p is null) return false;
+
+            // Check if process completed within timeout
+            if (!p.WaitForExit(ProcessTimeoutMs))
+                return false;
+
+            if (p.ExitCode != 0)
+                return false;
+
+            var output = p.StandardOutput.ReadToEnd();
+
+            // Parse output like "10.0.100 [C:\Program Files\dotnet\sdk]"
+            // Check if any line starts with "10." or higher
+            foreach (var line in output.Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries))
+            {
+                var trimmed = line.Trim();
+                if (string.IsNullOrEmpty(trimmed))
+                    continue;
+
+                // Extract version number (first part before space or bracket)
+                var spaceIndex = trimmed.IndexOf(' ');
+                var versionStr = spaceIndex >= 0 ? trimmed.Substring(0, spaceIndex) : trimmed;
+
+                // Parse major version
+                var dotIndex = versionStr.IndexOf('.');
+                if (dotIndex > 0 && int.TryParse(versionStr.Substring(0, dotIndex), out var major))
+                {
+                    if (major >= 10)
+                        return true;
+                }
+            }
+
+            return false;
         }
         catch
         {
@@ -459,7 +572,9 @@ private static bool IsDnxAvailable(string dotnetExe)
             using var p = Process.Start(psi);
             if (p is null) return false;
 
-            p.WaitForExit(5000); // 5 second timeout
+            if (!p.WaitForExit(ProcessTimeoutMs))
+                return false;
+
             return p.ExitCode == 0;
         }
         catch

src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.targets

@@ -416,6 +416,7 @@
         RenamingPath="$(_EfcptStagedRenaming)"
         TemplateDir="$(_EfcptStagedTemplateDir)"
         OutputDir="$(EfcptGeneratedDir)"
+        TargetFramework="$(TargetFramework)"
         LogVerbosity="$(EfcptLogVerbosity)" />
     <RenameGeneratedFiles
         GeneratedDir="$(EfcptGeneratedDir)"

tests/JD.Efcpt.Build.Tests/RunEfcptTests.cs

@@ -382,4 +382,34 @@ await Given("inputs with tool manifest", SetupWithToolManifest)
             .Finally(r => r.Setup.Folder.Dispose())
             .AssertPassed();
     }
+
+    [Scenario("Accepts target framework parameter")]
+    [Fact]
+    public async Task Accepts_target_framework_parameter()
+    {
+        await Given("inputs for DACPAC mode", SetupForDacpacMode)
+            .When("task executes with target framework", s =>
+                ExecuteTaskWithFakeMode(s, t => t.TargetFramework = "net10.0"))
+            .Then("task succeeds", r => r.Success)
+            .Finally(r => r.Setup.Folder.Dispose())
+            .AssertPassed();
+    }
+
+    [Scenario("Handles various target framework formats")]
+    [Theory]
+    [InlineData("net8.0")]
+    [InlineData("net9.0")]
+    [InlineData("net10.0")]
+    [InlineData("net10.0-windows")]
+    [InlineData("net10-windows")]
+    [InlineData("")]
+    public async Task Handles_various_target_framework_formats(string targetFramework)
+    {
+        await Given("inputs for DACPAC mode", SetupForDacpacMode)
+            .When("task executes with target framework", s =>
+                ExecuteTaskWithFakeMode(s, t => t.TargetFramework = targetFramework))
+            .Then("task succeeds", r => r.Success)
+            .Finally(r => r.Setup.Folder.Dispose())
+            .AssertPassed();
+    }
 }

tests/JD.Efcpt.Sdk.IntegrationTests/TemplateTests.cs

@@ -154,6 +154,9 @@ public async Task Template_CreatedProjectBuildsSuccessfully()
 }}";
         await File.WriteAllTextAsync(Path.Combine(_testDirectory, "global.json"), globalJson);
 
+        // Create tool manifest and restore tools for tool-manifest mode support
+        await CreateToolManifestAndRestoreAsync(_testDirectory);
+
         // Act - Restore
         var restoreResult = await RunDotnetCommandAsync(_testDirectory, projectName, "restore");
         restoreResult.Success.Should().BeTrue($"Restore should succeed.\n{restoreResult}");
@@ -318,6 +321,13 @@ public async Task Template_FrameworkVariant_BuildsSuccessfully(string framework,
             await File.WriteAllTextAsync(globalJsonPath, globalJson);
         }
 
+        // Create tool manifest and restore tools for tool-manifest mode support
+        var toolManifestPath = Path.Combine(_testDirectory, ".config", "dotnet-tools.json");
+        if (!File.Exists(toolManifestPath))
+        {
+            await CreateToolManifestAndRestoreAsync(_testDirectory);
+        }
+
         // Act - Restore
         var restoreResult = await RunDotnetCommandAsync(_testDirectory, projectName, "restore");
         restoreResult.Success.Should().BeTrue($"Restore for {framework} should succeed.\n{restoreResult}");
@@ -398,6 +408,46 @@ private static void CopyDirectory(string sourceDir, string destDir)
         }
     }
 
+    /// <summary>
+    /// Creates a .config/dotnet-tools.json manifest and restores tools.
+    /// Required for tool-manifest mode to find the efcpt tool.
+    /// </summary>
+    private static async Task CreateToolManifestAndRestoreAsync(string testDirectory)
+    {
+        var configDir = Path.Combine(testDirectory, ".config");
+        Directory.CreateDirectory(configDir);
+
+        var toolManifest = @"{
+  ""version"": 1,
+  ""isRoot"": true,
+  ""tools"": {
+    ""erikej.efcorepowertools.cli"": {
+      ""version"": ""10.1.1055"",
+      ""commands"": [
+        ""efcpt""
+      ],
+      ""rollForward"": false
+    }
+  }
+}";
+        await File.WriteAllTextAsync(Path.Combine(configDir, "dotnet-tools.json"), toolManifest);
+
+        // Restore tools so they're available for both tool-manifest and dnx modes
+        var psi = new System.Diagnostics.ProcessStartInfo
+        {
+            FileName = "dotnet",
+            Arguments = "tool restore",
+            WorkingDirectory = testDirectory,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            CreateNoWindow = true
+        };
+
+        using var process = System.Diagnostics.Process.Start(psi)!;
+        await process.WaitForExitAsync();
+    }
+
     private static async Task<TestUtilities.CommandResult> RunDotnetCommandAsync(string workingDirectory, string projectName, string arguments)
     {
         var psi = new System.Diagnostics.ProcessStartInfo