Add Node.js version selection strategy framework with EOL policy support

src/Agent.Sdk/Knob/AgentKnobs.cs

@@ -568,6 +568,13 @@ public class AgentKnobs
             new EnvironmentKnobSource("AGENT_DISABLE_NODE6_TASKS"),
             new BuiltInDefaultKnobSource("false"));
 
+        public static readonly Knob EnableEOLNodeVersionPolicy = new Knob(
+            nameof(EnableEOLNodeVersionPolicy),
+            "When enabled, automatically upgrades tasks using end-of-life Node.js versions (6, 10, 16) to supported versions (Node 20.1 or Node 24). Throws error if no supported versions are available on the agent.",
+            new PipelineFeatureSource("AGENT_RESTRICT_EOL_NODE_VERSIONS"),
+            new EnvironmentKnobSource("AGENT_RESTRICT_EOL_NODE_VERSIONS"),
+            new BuiltInDefaultKnobSource("false"));
+
         public static readonly Knob DisableTeePluginRemoval = new Knob(
             nameof(DisableTeePluginRemoval),
             "Disables removing TEE plugin after using it during checkout.",

src/Agent.Worker/NodeVersionStrategies/INodeVersionStrategy.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+
+namespace Microsoft.VisualStudio.Services.Agent.Worker.NodeVersionStrategies
+{
+    /// <summary>
+    /// Strategy interface for both host and container node selection.
+    /// </summary>
+    public interface INodeVersionStrategy
+    {
+        /// <summary>
+        /// Human-readable name of this strategy for logging and debugging.
+        /// Examples: "Node24", "Node20", "Node16", "CustomNode"
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// Checks if this strategy can handle the given context.
+        /// Includes handler type, knob checks, EOL policy, and glibc compatibility.
+        /// </summary>
+        /// <param name="context">Context with environment, task, and glibc information</param>
+        /// <returns>True if this strategy can handle the context, false otherwise</returns>
+        bool CanHandle(NodeContext context);
+
+        /// <summary>
+        /// Gets the Node path for the given context.
+        /// Works for both host and container (path translation handled internally).
+        /// May throw NotSupportedException if EOL policy is violated.
+        /// </summary>
+        /// <param name="context">Context with environment, task, and glibc information</param>
+        /// <returns>NodeRunnerInfo with path, version, reason, and optional warning</returns>
+        /// <exception cref="NotSupportedException">If EOL policy prevents using this version</exception>
+        NodeRunnerInfo GetNodePath(NodeContext context);
+    }
+}

src/Agent.Worker/NodeVersionStrategies/Node10Strategy.cs

@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using Agent.Sdk.Knob;
+using Microsoft.TeamFoundation.DistributedTask.WebApi;
+using Microsoft.VisualStudio.Services.Agent.Util;
+using Microsoft.VisualStudio.Services.Agent.Worker;
+
+namespace Microsoft.VisualStudio.Services.Agent.Worker.NodeVersionStrategies
+{
+    public sealed class Node10Strategy : INodeVersionStrategy
+    {
+        public string Name => "Node10";
+
+        public bool CanHandle(NodeContext context)
+        {
+            bool hasNode10Handler = context.HandlerData is Node10HandlerData;
+            bool eolPolicyEnabled = AgentKnobs.EnableEOLNodeVersionPolicy.GetValue(context.ExecutionContext).AsBoolean();
+
+            if (hasNode10Handler)
+            {
+                return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Selected for Node10 task handler");
+            }
+
+            bool isAlpine = context.IsAlpine;
+            if (isAlpine)
+            {
+                context.ExecutionContext.Warning(
+                    "Using Node10 on Alpine Linux because Node6 is not compatible. " +
+                    "Node10 has reached End-of-Life. Please upgrade to Node20 or Node24 for continued support.");
+
+                return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Selected for Alpine Linux compatibility (Node6 incompatible)");
+            }
+
+            return false;
+        }
+
+        private bool DetermineNodeVersionAndSetContext(NodeContext context, bool eolPolicyEnabled, string baseReason)
+        {
+            if (eolPolicyEnabled)
+            {
+                throw new NotSupportedException(StringUtil.Loc("NodeEOLPolicyBlocked", "Node10"));
+            }
+
+            context.SelectedNodeVersion = "node10";
+            context.SelectionReason = baseReason;
+            context.SelectionWarning = StringUtil.Loc("NodeEOLWarning", "Node10");
+            return true;
+        }
+
+        public NodeRunnerInfo GetNodePath(NodeContext context)
+        {
+            string externalsPath = context.HostContext.GetDirectory(WellKnownDirectory.Externals);
+            string hostPath = Path.Combine(externalsPath, context.SelectedNodeVersion, "bin", $"node{IOUtil.ExeExtension}");
+            string finalPath = context.IsContainer && context.Container != null ? 
+                              context.Container.TranslateToContainerPath(hostPath) : hostPath;
+
+            return new NodeRunnerInfo
+            {
+                NodePath = finalPath,
+                NodeVersion = context.SelectedNodeVersion,
+                Reason = context.SelectionReason,
+                Warning = context.SelectionWarning
+            };
+        }
+    }
+}

src/Agent.Worker/NodeVersionStrategies/Node16Strategy.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using Agent.Sdk.Knob;
+using Microsoft.TeamFoundation.DistributedTask.WebApi;
+using Microsoft.VisualStudio.Services.Agent.Util;
+using Microsoft.VisualStudio.Services.Agent.Worker;
+
+namespace Microsoft.VisualStudio.Services.Agent.Worker.NodeVersionStrategies
+{
+    public sealed class Node16Strategy : INodeVersionStrategy
+    {
+        public string Name => "Node16";
+
+        public bool CanHandle(NodeContext context)
+        {
+            bool hasNode16Handler = context.HandlerData is Node16HandlerData;
+            bool eolPolicyEnabled = AgentKnobs.EnableEOLNodeVersionPolicy.GetValue(context.ExecutionContext).AsBoolean();
+
+            if (hasNode16Handler)
+            {
+                return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Selected for Node16 task handler");
+            }
+
+            return false;
+        }
+
+        private bool DetermineNodeVersionAndSetContext(NodeContext context, bool eolPolicyEnabled, string baseReason)
+        {
+            if (eolPolicyEnabled)
+            {
+                throw new NotSupportedException(StringUtil.Loc("NodeEOLPolicyBlocked", "Node16"));
+            }
+
+            context.SelectedNodeVersion = "node16";
+            context.SelectionReason = baseReason;
+            context.SelectionWarning = StringUtil.Loc("NodeEOLWarning", "Node16");
+            return true;
+        }
+
+        public NodeRunnerInfo GetNodePath(NodeContext context)
+        {
+            string externalsPath = context.HostContext.GetDirectory(WellKnownDirectory.Externals);
+            string hostPath = Path.Combine(externalsPath, context.SelectedNodeVersion, "bin", $"node{IOUtil.ExeExtension}");
+            string finalPath = context.IsContainer && context.Container != null ? 
+                              context.Container.TranslateToContainerPath(hostPath) : hostPath;
+
+            return new NodeRunnerInfo
+            {
+                NodePath = finalPath,
+                NodeVersion = context.SelectedNodeVersion,
+                Reason = context.SelectionReason,
+                Warning = context.SelectionWarning
+            };
+        }
+    }
+}

src/Agent.Worker/NodeVersionStrategies/Node20Strategy.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using Agent.Sdk.Knob;
+using Microsoft.TeamFoundation.DistributedTask.WebApi;
+using Microsoft.VisualStudio.Services.Agent.Util;
+using Microsoft.VisualStudio.Services.Agent.Worker;
+
+namespace Microsoft.VisualStudio.Services.Agent.Worker.NodeVersionStrategies
+{
+    public sealed class Node20Strategy : INodeVersionStrategy
+    {
+        public string Name => "Node20";
+
+        public bool CanHandle(NodeContext context)
+        {
+            bool useNode20Globally = AgentKnobs.UseNode20_1.GetValue(context.ExecutionContext).AsBoolean();
+            bool hasNode20Handler = context.HandlerData is Node20_1HandlerData;
+            bool eolPolicyEnabled = AgentKnobs.EnableEOLNodeVersionPolicy.GetValue(context.ExecutionContext).AsBoolean();
+
+            if (useNode20Globally)
+            {
+                return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Selected via global AGENT_USE_NODE20_1 override");
+            }
+
+            if (hasNode20Handler)
+            {
+                return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Selected for Node20 task handler");
+            }
+
+            if (eolPolicyEnabled)
+            {
+                return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Upgraded from end-of-life Node version due to EOL policy");
+            }
+
+            return false;
+        }
+
+        private bool DetermineNodeVersionAndSetContext(NodeContext context, bool eolPolicyEnabled, string baseReason)
+        {
+            if (!context.Node20HasGlibcError)
+            {
+                context.SelectedNodeVersion = "node20_1";
+                context.SelectionReason = baseReason;
+                context.SelectionWarning = null;
+                return true;
+            }
+
+            if (eolPolicyEnabled)
+            {
+                throw new NotSupportedException(StringUtil.Loc("NodeEOLFallbackBlocked", "Node20", "Node16"));
+            }
+
+            string systemType = context.IsContainer ? "container" : "agent";
+            context.SelectedNodeVersion = "node16";
+            context.SelectionReason = $"{baseReason}, fallback to Node16 due to Node20 glibc compatibility issue";
+            context.SelectionWarning = StringUtil.Loc("NodeGlibcFallbackWarning", systemType, "Node20", "Node16");
+            return true;
+        }
+
+        public NodeRunnerInfo GetNodePath(NodeContext context)
+        {
+            string externalsPath = context.HostContext.GetDirectory(WellKnownDirectory.Externals);
+            string hostPath = Path.Combine(externalsPath, context.SelectedNodeVersion, "bin", $"node{IOUtil.ExeExtension}");
+            string finalPath = context.IsContainer && context.Container != null ? 
+                              context.Container.TranslateToContainerPath(hostPath) : hostPath;
+
+            return new NodeRunnerInfo
+            {
+                NodePath = finalPath,
+                NodeVersion = context.SelectedNodeVersion,
+                Reason = context.SelectionReason,
+                Warning = context.SelectionWarning
+            };
+        }
+    }
+}

src/Agent.Worker/NodeVersionStrategies/Node24Strategy.cs

@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.IO;
+using Agent.Sdk.Knob;
+using Microsoft.TeamFoundation.DistributedTask.WebApi;
+using Microsoft.VisualStudio.Services.Agent.Util;
+using Microsoft.VisualStudio.Services.Agent.Worker;
+
+namespace Microsoft.VisualStudio.Services.Agent.Worker.NodeVersionStrategies
+{
+    public sealed class Node24Strategy : INodeVersionStrategy
+    {
+        public string Name => "Node24";
+
+        public bool CanHandle(NodeContext context)
+        {
+            bool useNode24Globally = AgentKnobs.UseNode24.GetValue(context.ExecutionContext).AsBoolean();
+            bool hasNode24Handler = context.HandlerData is Node24HandlerData;
+            bool useNode24WithHandlerData = AgentKnobs.UseNode24withHandlerData.GetValue(context.ExecutionContext).AsBoolean();
+            bool eolPolicyEnabled = AgentKnobs.EnableEOLNodeVersionPolicy.GetValue(context.ExecutionContext).AsBoolean();
+
+            if (useNode24Globally)
+            {
+                context.ExecutionContext.Debug("[Node24Strategy] AGENT_USE_NODE24=true → Global override");
+                return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Selected via global AGENT_USE_NODE24 override");
+            }
+
+            if (hasNode24Handler)
+            {
+                if (useNode24WithHandlerData)
+                {
+                    return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Selected for Node24 task with handler knob enabled");
+                }
+                else
+                {
+                    context.SelectedNodeVersion = "node20_1";
+                    context.SelectionReason = "Node24 task detected but handler knob disabled, falling back to Node20";
+                    context.SelectionWarning = null;
+                    return true;
+                }
+            }
+
+            if (eolPolicyEnabled)
+            {
+                return DetermineNodeVersionAndSetContext(context, eolPolicyEnabled, "Upgraded from end-of-life Node version due to EOL policy");
+            }
+
+            return false;
+        }
+
+        private bool DetermineNodeVersionAndSetContext(NodeContext context, bool eolPolicyEnabled, string baseReason)
+        {
+            string systemType = context.IsContainer ? "container" : "agent";
+
+            if (!context.Node24HasGlibcError)
+            {
+                context.SelectedNodeVersion = "node24";
+                context.SelectionReason = baseReason;
+                context.SelectionWarning = null;
+                return true;
+            }
+
+            if (!context.Node20HasGlibcError)
+            {
+                context.SelectedNodeVersion = "node20_1";
+                context.SelectionReason = $"{baseReason}, fallback to Node20 due to Node24 glibc compatibility issue";
+                context.SelectionWarning = StringUtil.Loc("NodeGlibcFallbackWarning", systemType, "Node24", "Node20");
+                return true;
+            }
+
+            if (eolPolicyEnabled)
+            {
+                context.ExecutionContext.Debug("[Node24Strategy] Would need Node16 but EOL policy being enabled this is not supported");
+                string handlerType = context.HandlerData != null ? context.HandlerData.GetType().Name : "UnknownHandlerData";
+                throw new NotSupportedException($"No compatible Node.js version available for host execution. Handler type: {handlerType}. This may occur if all available versions are blocked by EOL policy. Please update your pipeline to use Node20 or Node24 tasks. To temporarily disable EOL policy: Set AGENT_ENABLE_EOL_NODE_VERSION_POLICY=false");
+            }
+
+            context.SelectedNodeVersion = "node16";
+            context.SelectionReason = $"{baseReason}, fallback to Node16 due to both Node24 and Node20 glibc compatibility issues";
+            context.SelectionWarning = StringUtil.Loc("NodeGlibcFallbackWarning", systemType, "Node24 or Node20", "Node16");
+            return true;
+        }
+
+        public NodeRunnerInfo GetNodePath(NodeContext context)
+        {
+            string externalsPath = context.HostContext.GetDirectory(WellKnownDirectory.Externals);
+            string hostPath = Path.Combine(externalsPath, context.SelectedNodeVersion, "bin", $"node{IOUtil.ExeExtension}");
+            string finalPath = context.IsContainer && context.Container != null ? 
+                              context.Container.TranslateToContainerPath(hostPath) : hostPath;
+
+            return new NodeRunnerInfo
+            {
+                NodePath = finalPath,
+                NodeVersion = context.SelectedNodeVersion,
+                Reason = context.SelectionReason,
+                Warning = context.SelectionWarning
+            };
+        }
+    }
+}