Runner Support for executing Node24 Actions

docs/checks/nodejs.md

@@ -4,9 +4,9 @@
 
 Make sure the built-in node.js has access to GitHub.com or GitHub Enterprise Server.
 
-The runner carries its own copy of node.js executable under `<runner_root>/externals/node20/`.
+The runner carries its own copies of node.js executables under `<runner_root>/externals/node20/` and `<runner_root>/externals/node24/`.
 
-All javascript base Actions will get executed by the built-in `node` at `<runner_root>/externals/node20/`.
+All javascript base Actions will get executed by the built-in `node` at either `<runner_root>/externals/node20/` or `<runner_root>/externals/node24/` depending on the version specified in the action's metadata.
 
 > Not the `node` from `$PATH`
 

src/Misc/externals.sh

@@ -7,6 +7,7 @@ NODE_ALPINE_URL=https://github.com/actions/alpine_nodejs/releases/download
 # When you update Node versions you must also create a new release of alpine_nodejs at that updated version.
 # Follow the instructions here: https://github.com/actions/alpine_nodejs?tab=readme-ov-file#getting-started
 NODE20_VERSION="20.19.3"
+NODE24_VERSION="24.4.0"
 
 get_abs_path() {
  # exploits the fact that pwd will print abs path when no args
@@ -139,6 +140,8 @@ function acquireExternalTool() {
 if [[ "$PACKAGERUNTIME" == "win-x64" || "$PACKAGERUNTIME" == "win-x86" ]]; then
  acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/$PACKAGERUNTIME/node.exe" node20/bin
  acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/$PACKAGERUNTIME/node.lib" node20/bin
+ acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/$PACKAGERUNTIME/node.exe" node24/bin
+ acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/$PACKAGERUNTIME/node.lib" node24/bin
  if [[ "$PRECACHE" != "" ]]; then
  acquireExternalTool "https://github.com/microsoft/vswhere/releases/download/2.6.7/vswhere.exe" vswhere
  fi
@@ -149,6 +152,8 @@ if [[ "$PACKAGERUNTIME" == "win-arm64" ]]; then
  # todo: replace these with official release when available
  acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/$PACKAGERUNTIME/node.exe" node20/bin
  acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/$PACKAGERUNTIME/node.lib" node20/bin
+ acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/$PACKAGERUNTIME/node.exe" node24/bin
+ acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/$PACKAGERUNTIME/node.lib" node24/bin
  if [[ "$PRECACHE" != "" ]]; then
  acquireExternalTool "https://github.com/microsoft/vswhere/releases/download/2.6.7/vswhere.exe" vswhere
  fi
@@ -157,21 +162,26 @@ fi
 # Download the external tools only for OSX.
 if [[ "$PACKAGERUNTIME" == "osx-x64" ]]; then
  acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-darwin-x64.tar.gz" node20 fix_nested_dir
+ acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-darwin-x64.tar.gz" node24 fix_nested_dir
 fi
 
 if [[ "$PACKAGERUNTIME" == "osx-arm64" ]]; then
  # node.js v12 doesn't support macOS on arm64.
  acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-darwin-arm64.tar.gz" node20 fix_nested_dir
+ acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-darwin-arm64.tar.gz" node24 fix_nested_dir
 fi
 
 # Download the external tools for Linux PACKAGERUNTIMEs.
 if [[ "$PACKAGERUNTIME" == "linux-x64" ]]; then
  acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-linux-x64.tar.gz" node20 fix_nested_dir
  acquireExternalTool "$NODE_ALPINE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-alpine-x64.tar.gz" node20_alpine
+ acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-linux-x64.tar.gz" node24 fix_nested_dir
+ acquireExternalTool "$NODE_ALPINE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-alpine-x64.tar.gz" node24_alpine
 fi
 
 if [[ "$PACKAGERUNTIME" == "linux-arm64" ]]; then
  acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-linux-arm64.tar.gz" node20 fix_nested_dir
+ acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-linux-arm64.tar.gz" node24 fix_nested_dir
 fi
 
 if [[ "$PACKAGERUNTIME" == "linux-arm" ]]; then

src/Misc/layoutbin/update.sh.template

@@ -135,12 +135,17 @@ if [[ "$currentplatform" == 'darwin' && restartinteractiverunner -eq 0 ]]; then
  then
  # inspect the open file handles to find the node process
  # we can't actually inspect the process using ps because it uses relative paths and doesn't follow symlinks
- nodever="node20"
+ # Try finding node24 first, then fallback to earlier versions if needed
+ nodever="node24"
  path=$(lsof -a -g "$procgroup" -F n | grep $nodever/bin/node | grep externals | tail -1 | cut -c2-)
- if [[ $? -ne 0 || -z "$path" ]] # Fallback if RunnerService.js was started with node16
+ if [[ $? -ne 0 || -z "$path" ]] # Fallback if RunnerService.js was started with node20
  then
- nodever="node16"
+ nodever="node20"
  path=$(lsof -a -g "$procgroup" -F n | grep $nodever/bin/node | grep externals | tail -1 | cut -c2-)
+ if [[ $? -ne 0 || -z "$path" ]] # Fallback if RunnerService.js was started with node16
+ then
+ nodever="node16"
+ path=$(lsof -a -g "$procgroup" -F n | grep $nodever/bin/node | grep externals | tail -1 | cut -c2-)
  if [[ $? -ne 0 || -z "$path" ]] # Fallback if RunnerService.js was started with node12
  then
  nodever="node12"

src/Runner.Common/Util/NodeUtil.cs

@@ -18,5 +18,22 @@ public static string GetInternalNodeVersion()
  }
  return _defaultNodeVersion;
  }
+
+ /// <summary>
+ /// Checks if Node24 is requested but running on ARM32 Linux, and determines if fallback is needed.
+ /// </summary>
+ /// <param name="preferredVersion">The preferred Node version</param>
+ /// <returns>A tuple containing the adjusted node version and an optional warning message</returns>
+ public static (string nodeVersion, string warningMessage) CheckNodeVersionForLinuxArm32(string preferredVersion)
+ {
+ if (string.Equals(preferredVersion, "node24", StringComparison.OrdinalIgnoreCase) &&
+ Constants.Runner.PlatformArchitecture.Equals(Constants.Architecture.Arm) &&
+ Constants.Runner.Platform.Equals(Constants.OSPlatform.Linux))
+ {
+ return ("node20", "Node 24 is not supported on Linux ARM32 platforms. Falling back to Node 20.");
+ }
+
+ return (preferredVersion, null);
+ }
  }
 }

src/Runner.Worker/ActionManifestManager.cs

@@ -450,7 +450,8 @@ private ActionExecutionData ConvertRuns(
  }
  else if (string.Equals(usingToken.Value, "node12", StringComparison.OrdinalIgnoreCase) ||
  string.Equals(usingToken.Value, "node16", StringComparison.OrdinalIgnoreCase) ||
- string.Equals(usingToken.Value, "node20", StringComparison.OrdinalIgnoreCase))
+ string.Equals(usingToken.Value, "node20", StringComparison.OrdinalIgnoreCase) ||
+ string.Equals(usingToken.Value, "node24", StringComparison.OrdinalIgnoreCase))
  {
  if (string.IsNullOrEmpty(mainToken?.Value))
  {
@@ -490,7 +491,7 @@ private ActionExecutionData ConvertRuns(
  }
  else
  {
- throw new ArgumentOutOfRangeException($"'using: {usingToken.Value}' is not supported, use 'docker', 'node12', 'node16'or 'node20' instead.");
+ throw new ArgumentOutOfRangeException($"'using: {usingToken.Value}' is not supported, use 'docker', 'node12', 'node16', 'node20' or 'node24' instead.");
  }
  }
  else if (pluginToken != null)
@@ -501,7 +502,7 @@ private ActionExecutionData ConvertRuns(
  };
  }
 
- throw new NotSupportedException("Missing 'using' value. 'using' requires 'composite', 'docker', 'node12', 'node16'or 'node20'.");
+ throw new NotSupportedException("Missing 'using' value. 'using' requires 'composite', 'docker', 'node12', 'node16', 'node20' or 'node24'.");
  }
 
  private void ConvertInputs(

src/Runner.Worker/Handlers/StepHost.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using GitHub.DistributedTask.Pipelines.ContextData;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,7 +8,6 @@
 using GitHub.Runner.Sdk;
 using System.Linq;
 using GitHub.Runner.Worker.Container.ContainerHooks;
-using System.IO;
 using System.Threading.Channels;
 
 namespace GitHub.Runner.Worker.Handlers
@@ -60,7 +58,14 @@ public string ResolvePathForStepHost(IExecutionContext executionContext, string
 
  public Task<string> DetermineNodeRuntimeVersion(IExecutionContext executionContext, string preferredVersion)
  {
- return Task.FromResult<string>(preferredVersion);
+ // Use NodeUtil to check if Node24 is requested but we're on ARM32 Linux
+ var (nodeVersion, warningMessage) = Common.Util.NodeUtil.CheckNodeVersionForLinuxArm32(preferredVersion);
+ if (!string.IsNullOrEmpty(warningMessage))
+ {
+ executionContext.Warning(warningMessage);
+ }
+
+ return Task.FromResult(nodeVersion);
  }
 
  public async Task<int> ExecuteAsync(IExecutionContext context,
@@ -137,8 +142,12 @@ public string ResolvePathForStepHost(IExecutionContext executionContext, string
 
  public async Task<string> DetermineNodeRuntimeVersion(IExecutionContext executionContext, string preferredVersion)
  {
- // Optimistically use the default
- string nodeExternal = preferredVersion;
+ // Use NodeUtil to check if Node24 is requested but we're on ARM32 Linux
+ var (nodeExternal, warningMessage) = Common.Util.NodeUtil.CheckNodeVersionForLinuxArm32(preferredVersion);
+ if (!string.IsNullOrEmpty(warningMessage))
+ {
+ executionContext.Warning(warningMessage);
+ }
 
  if (FeatureManager.IsContainerHooksEnabled(executionContext.Global.Variables))
  {
@@ -264,7 +273,14 @@ await containerHookManager.RunScriptStepAsync(context,
 
  private string CheckPlatformForAlpineContainer(IExecutionContext executionContext, string preferredVersion)
  {
- string nodeExternal = preferredVersion;
+ // Use NodeUtil to check if Node24 is requested but we're on ARM32 Linux
+ var (nodeExternal, warningMessage) = Common.Util.NodeUtil.CheckNodeVersionForLinuxArm32(preferredVersion);
+ if (!string.IsNullOrEmpty(warningMessage))
+ {
+ executionContext.Warning(warningMessage);
+ }
+
+ // Check for Alpine container compatibility
  if (!Constants.Runner.PlatformArchitecture.Equals(Constants.Architecture.X64))
  {
  var os = Constants.Runner.Platform.ToString();

src/Test/L0/Worker/ActionManagerL0.cs

@@ -1659,6 +1659,76 @@ public void LoadsNode20ActionDefinition()
  Teardown();
  }
  }
+
+ [Fact]
+ [Trait("Level", "L0")]
+ [Trait("Category", "Worker")]
+ public void LoadsNode24ActionDefinition()
+ {
+ try
+ {
+ // Arrange.
+ Setup();
+ const string Content = @"
+# Container action
+name: 'Hello World'
+description: 'Greet the world and record the time'
+author: 'GitHub'
+inputs:
+ greeting: # id of input
+ description: 'The greeting we choose - will print ""{greeting}, World!"" on stdout'
+ required: true
+ default: 'Hello'
+ entryPoint: # id of input
+ description: 'optional docker entrypoint overwrite.'
+ required: false
+outputs:
+ time: # id of output
+ description: 'The time we did the greeting'
+icon: 'hello.svg' # vector art to display in the GitHub Marketplace
+color: 'green' # optional, decorates the entry in the GitHub Marketplace
+runs:
+ using: 'node24'
+ main: 'task.js'
+";
+ Pipelines.ActionStep instance;
+ string directory;
+ CreateAction(yamlContent: Content, instance: out instance, directory: out directory);
+
+ // Act.
+ Definition definition = _actionManager.LoadAction(_ec.Object, instance);
+
+ // Assert.
+ Assert.NotNull(definition);
+ Assert.Equal(directory, definition.Directory);
+ Assert.NotNull(definition.Data);
+ Assert.NotNull(definition.Data.Inputs); // inputs
+ Dictionary<string, string> inputDefaults = new(StringComparer.OrdinalIgnoreCase);
+ foreach (var input in definition.Data.Inputs)
+ {
+ var name = input.Key.AssertString("key").Value;
+ var value = input.Value.AssertScalar("value").ToString();
+
+ _hc.GetTrace().Info($"Default: {name} = {value}");
+ inputDefaults[name] = value;
+ }
+
+ Assert.Equal(2, inputDefaults.Count);
+ Assert.True(inputDefaults.ContainsKey("greeting"));
+ Assert.Equal("Hello", inputDefaults["greeting"]);
+ Assert.True(string.IsNullOrEmpty(inputDefaults["entryPoint"]));
+ Assert.NotNull(definition.Data.Execution); // execution
+
+ Assert.NotNull(definition.Data.Execution as NodeJSActionExecutionData);
+ Assert.Equal("task.js", (definition.Data.Execution as NodeJSActionExecutionData).Script);
+ Assert.Equal("node24", (definition.Data.Execution as NodeJSActionExecutionData).NodeVersion);
+ }
+ finally
+ {
+ Teardown();
+ }
+ }
+
  [Fact]
  [Trait("Level", "L0")]
  [Trait("Category", "Worker")]

src/Test/L0/Worker/ActionManifestManagerL0.cs

@@ -502,6 +502,49 @@ public void Load_Node20Action()
  }
  }
 
+ [Fact]
+ [Trait("Level", "L0")]
+ [Trait("Category", "Worker")]
+ public void Load_Node24Action()
+ {
+ try
+ {
+ //Arrange
+ Setup();
+
+ var actionManifest = new ActionManifestManager();
+ actionManifest.Initialize(_hc);
+
+ //Act
+ var result = actionManifest.Load(_ec.Object, Path.Combine(TestUtil.GetTestDataPath(), "node24action.yml"));
+
+ //Assert
+ Assert.Equal("Hello World", result.Name);
+ Assert.Equal("Greet the world and record the time", result.Description);
+ Assert.Equal(2, result.Inputs.Count);
+ Assert.Equal("greeting", result.Inputs[0].Key.AssertString("key").Value);
+ Assert.Equal("Hello", result.Inputs[0].Value.AssertString("value").Value);
+ Assert.Equal("entryPoint", result.Inputs[1].Key.AssertString("key").Value);
+ Assert.Equal("", result.Inputs[1].Value.AssertString("value").Value);
+ Assert.Equal(1, result.Deprecated.Count);
+
+ Assert.True(result.Deprecated.ContainsKey("greeting"));
+ result.Deprecated.TryGetValue("greeting", out string value);
+ Assert.Equal("This property has been deprecated", value);
+
+ Assert.Equal(ActionExecutionType.NodeJS, result.Execution.ExecutionType);
+
+ var nodeAction = result.Execution as NodeJSActionExecutionData;
+
+ Assert.Equal("main.js", nodeAction.Script);
+ Assert.Equal("node24", nodeAction.NodeVersion);
+ }
+ finally
+ {
+ Teardown();
+ }
+ }
+
  [Fact]
  [Trait("Level", "L0")]
  [Trait("Category", "Worker")]
@@ -758,7 +801,7 @@ public void Load_CompositeActionNoUsing()
  //Assert
  var err = Assert.Throws<ArgumentException>(() => actionManifest.Load(_ec.Object, action_path));
  Assert.Contains($"Failed to load {action_path}", err.Message);
- _ec.Verify(x => x.AddIssue(It.Is<Issue>(s => s.Message.Contains("Missing 'using' value. 'using' requires 'composite', 'docker', 'node12', 'node16'or 'node20'.")), It.IsAny<ExecutionContextLogOptions>()), Times.Once);
+ _ec.Verify(x => x.AddIssue(It.Is<Issue>(s => s.Message.Contains("Missing 'using' value. 'using' requires 'composite', 'docker', 'node12', 'node16', 'node20' or 'node24'.")), It.IsAny<ExecutionContextLogOptions>()), Times.Once);
  }
  finally
  {