.eslintignore

@@ -0,0 +1,4 @@
+dist/
+lib/
+node_modules/
+jest.config.js

.eslintrc.json

@@ -0,0 +1,55 @@
+{
+    "plugins": ["jest", "@typescript-eslint"],
+    "extends": ["plugin:github/recommended"],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+      "ecmaVersion": 9,
+      "sourceType": "module",
+      "project": "./tsconfig.json"
+    },
+    "rules": {
+      "i18n-text/no-en": "off",
+      "eslint-comments/no-use": "off",
+      "import/no-namespace": "off",
+      "no-unused-vars": "off",
+      "@typescript-eslint/no-unused-vars": "error",
+      "@typescript-eslint/explicit-member-accessibility": ["error", {"accessibility": "no-public"}],
+      "@typescript-eslint/no-require-imports": "error",
+      "@typescript-eslint/array-type": "error",
+      "@typescript-eslint/await-thenable": "error",
+      "@typescript-eslint/ban-ts-comment": "error",
+      "camelcase": "off",
+      "@typescript-eslint/consistent-type-assertions": "error",
+      "@typescript-eslint/explicit-function-return-type": ["error", {"allowExpressions": true}],
+      "@typescript-eslint/func-call-spacing": ["error", "never"],
+      "@typescript-eslint/no-array-constructor": "error",
+      "@typescript-eslint/no-empty-interface": "error",
+      "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/no-extraneous-class": "error",
+      "@typescript-eslint/no-for-in-array": "error",
+      "@typescript-eslint/no-inferrable-types": "error",
+      "@typescript-eslint/no-misused-new": "error",
+      "@typescript-eslint/no-namespace": "error",
+      "@typescript-eslint/no-non-null-assertion": "warn",
+      "@typescript-eslint/no-unnecessary-qualifier": "error",
+      "@typescript-eslint/no-unnecessary-type-assertion": "error",
+      "@typescript-eslint/no-useless-constructor": "error",
+      "@typescript-eslint/no-var-requires": "error",
+      "@typescript-eslint/prefer-for-of": "warn",
+      "@typescript-eslint/prefer-function-type": "warn",
+      "@typescript-eslint/prefer-includes": "error",
+      "@typescript-eslint/prefer-string-starts-ends-with": "error",
+      "@typescript-eslint/promise-function-async": "error",
+      "@typescript-eslint/require-array-sort-compare": "error",
+      "@typescript-eslint/restrict-plus-operands": "error",
+      "semi": "off",
+      "@typescript-eslint/semi": ["error", "never"],
+      "@typescript-eslint/type-annotation-spacing": "error",
+      "@typescript-eslint/unbound-method": "error"
+    },
+    "env": {
+      "node": true,
+      "es6": true,
+      "jest/globals": true
+    }
+  }

.github/dependabot.yml

@@ -1,30 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: /
-    schedule:
-      interval: monthly
-    groups:
-      actions-minor:
-        update-types:
-          - minor
-          - patch
-
-  - package-ecosystem: npm
-    directory: /
-    schedule:
-      interval: monthly
-    ignore:
-      - dependency-name: '@types/node'
-        update-types:
-          - 'version-update:semver-major'
-    groups:
-      npm-development:
-        dependency-type: development
-        update-types:
-          - minor
-          - patch
-      npm-production:
-        dependency-type: production
-        update-types:
-          - patch

.github/workflows/check-dist.yml

@@ -1,13 +1,9 @@
-# In TypeScript actions, `dist/` is a special directory. When you reference
-# an action with the `uses:` property, `dist/index.js` is the code that will be
-# run. For this project, the `dist/index.js` file is transpiled from other
-# source files. This workflow ensures the `dist/` directory contains the
-# expected transpiled code.
-#
-# If this workflow is run from a feature branch, it will act as an additional CI
-# check and fail if the checked-in `dist/` directory does not match what is
-# expected from the build.
-name: Check Transpiled JavaScript
+# `dist/index.js` is a special file in Actions.
+# When you reference an action with `uses:` in a workflow,
+# `index.js` is the code that will run.
+# For our project, we generate this file through a build process from other source files.
+# We need to make sure the checked-in `index.js` actually matches what we expect it to be.
+name: Check dist/
 
 on:
   push:
@@ -20,57 +16,40 @@ on:
     paths-ignore:
       - '**.md'
   workflow_dispatch:
-
 permissions:
   contents: read
 
 jobs:
   check-dist:
-    name: Check dist/
     runs-on: ubuntu-latest
 
     steps:
-      - name: Checkout
-        id: checkout
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v3
 
-      - name: Setup Node.js
-        id: setup-node
-        uses: actions/setup-node@v4
+      - name: Set Node.js 16.x
+        uses: actions/setup-node@v3
         with:
-          node-version-file: .node-version
+          node-version: 16.x
           cache: npm
 
-      - name: Install Dependencies
-        id: install
+      - name: Install dependencies
         run: npm ci
 
-      - name: Build dist/ Directory
-        id: build
-        run: npm run bundle
+      - name: Rebuild the dist/ directory
+        run: npm run build
 
-      # This will fail the workflow if the `dist/` directory is different than
-      # expected.
-      - name: Compare Directories
-        id: diff
+      - name: Compare the expected and actual dist/ directories
         run: |
-          if [ ! -d dist/ ]; then
-            echo "Expected dist/ directory does not exist.  See status below:"
-            ls -la ./
-            exit 1
-          fi
-          if [ "$(git diff --ignore-space-at-eol --text dist/ | wc -l)" -gt "0" ]; then
-            echo "Detected uncommitted changes after build. See status below:"
-            git diff --ignore-space-at-eol --text dist/
+          if [ "$(git diff --ignore-space-at-eol dist/ | wc -l)" -gt "0" ]; then
+            echo "Detected uncommitted changes after build.  See status below:"
+            git diff
             exit 1
           fi
+        id: diff
 
-      # If `dist/` was different than expected, upload the expected version as a
-      # workflow artifact.
-      - if: ${{ failure() && steps.diff.outcome == 'failure' }}
-        name: Upload Artifact
-        id: upload
-        uses: actions/upload-artifact@v4
+      # If index.js was different than expected, upload the expected version as an artifact
+      - uses: actions/upload-artifact@v3
+        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
         with:
           name: dist
           path: dist/

.github/workflows/ci.yml

@@ -1,487 +0,0 @@
-name: Continuous Integration
-
-on:
-  push:
-    paths-ignore:
-      - '**.md'
-  pull_request:
-    paths-ignore:
-      - '**.md'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  test-typescript:
-    name: TypeScript Tests
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: .node-version
-          cache: npm
-      - name: Install Dependencies
-        run: npm clean-install
-      - name: Check Format
-        run: npm run format:check
-      - name: Lint
-        run: npm run lint
-      - name: Test
-        run: npm run test
-
-  test-action:
-    name: GraalVM
-    runs-on: ${{ matrix.os }}
-    env:
-      # Skip builds that require a GDS token but have no access to one (e.g., secrets are unavailable in PR runs)
-      PASSES_GDS_TOKEN_CHECK: ${{ !matrix.set-gds-token || secrets.GDS_TOKEN != '' }}
-    strategy:
-      matrix:
-        java-version: ['24', '21', '17', '20', 'dev']
-        distribution: ['graalvm', 'graalvm-community']
-        os: [
-            ubuntu-latest, # Linux on Intel
-            ubuntu-22.04-arm, # Linux on arm64
-            macos-latest, # macOS on Apple silicon
-            macos-13, # macOS on Intel
-            windows-latest
-          ]
-        set-gds-token: [false]
-        components: ['']
-        include:
-          - java-version: 'latest-ea'
-            distribution: 'graalvm'
-            os: ubuntu-latest
-          - java-version: '25-ea'
-            distribution: 'graalvm'
-            os: ubuntu-latest
-          - java-version: '21'
-            distribution: ''
-            os: ubuntu-latest
-          - java-version: 'dev'
-            distribution: ''
-            os: windows-latest
-          - java-version: '21'
-            distribution: 'graalvm-community'
-            os: ubuntu-latest
-            components: 'native-image' # should print a warning but not fail
-          - java-version: '21.0.0' # test for GA version (see #63)
-            distribution: 'graalvm'
-            os: ubuntu-latest
-          - java-version: '17'
-            distribution: 'graalvm'
-            os: ubuntu-latest
-            set-gds-token: true
-          - java-version: '17.0.13'
-            distribution: 'graalvm'
-            os: ubuntu-latest
-            set-gds-token: true
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          java-version: ${{ matrix.java-version }}
-          distribution: ${{ matrix.distribution }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          components: ${{ matrix.components }}
-          gds-token: ${{ matrix.set-gds-token && secrets.GDS_TOKEN || '' }}
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' }}
-      - name: Check environment
-        run: |
-          echo "GRAALVM_HOME: $GRAALVM_HOME"
-          if [[ "${{ matrix.java-version }}" == "dev" ]]; then
-            [[ "$GRAALVM_HOME" == *"$RUNNER_TEMP"* ]] || exit 12
-          else
-            [[ "$GRAALVM_HOME" == *"$RUNNER_TOOL_CACHE"* ]] || exit 23
-          fi
-          echo "JAVA_HOME: $JAVA_HOME"
-          java --version
-          java --version | grep "GraalVM" || exit 34
-          native-image --version
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' && runner.os != 'Windows' }}
-      - name: Check Windows environment
-        run: |
-          echo "GRAALVM_HOME: $env:GRAALVM_HOME"
-          echo "JAVA_HOME: $env:JAVA_HOME"
-          java --version
-          native-image --version
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' && runner.os == 'Windows' }}
-
-  test-action-ce: # make sure the action works on a clean machine without building
-    needs: test-action
-    name: CE ${{ matrix.version }} + JDK${{ matrix.java-version }} on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        version: ['latest', 'dev']
-        java-version: ['17', '20']
-        components: ['native-image']
-        os: [macos-latest, windows-latest, ubuntu-latest]
-        exclude:
-          - version: 'latest'
-            java-version: '20'
-          - version: 'dev'
-            java-version: '19'
-        include:
-          - version: '22.2.0' # for update notifications
-            java-version: '17'
-            components: 'native-image'
-            os: ubuntu-22.04
-          - version: '21.2.0'
-            java-version: '8' # for JDK 8 notification
-            components: 'native-image'
-            os: ubuntu-latest
-          - version: '22.3.1'
-            java-version: '11' # for JDK 11 notification
-            components: 'native-image'
-            os: macos-13
-          - version: '22.3.1'
-            java-version: '17'
-            components: 'native-image'
-            os: windows-2022
-          - version: 'dev'
-            java-version: 'dev'
-            components: 'native-image'
-            os: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          version: ${{ matrix.version }}
-          java-version: ${{ matrix.java-version }}
-          components: ${{ matrix.components }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Check environment
-        run: |
-          echo "GRAALVM_HOME: $GRAALVM_HOME"
-          if [[ "${{ matrix.version }}" == "dev" ]] && [[ "${{ matrix.java-version }}" == "dev" ]]; then
-            [[ "$GRAALVM_HOME" == *"$RUNNER_TEMP"* ]] || exit 12
-          else
-            [[ "$GRAALVM_HOME" == *"$RUNNER_TOOL_CACHE"* ]] || exit 23
-          fi
-          echo "JAVA_HOME: $JAVA_HOME"
-          java -version
-          java -version 2>&1 | grep "GraalVM" || exit 34
-          native-image --version
-          if [[ "${{ matrix.java-version }}" != "dev" ]]; then
-            gu list
-          fi
-        if: ${{ runner.os != 'Windows' }}
-      - name: Check Windows environment
-        run: |
-          echo "GRAALVM_HOME: $env:GRAALVM_HOME"
-          echo "JAVA_HOME: $env:JAVA_HOME"
-          java -version
-          native-image --version
-          gu.cmd remove native-image
-        if: ${{ runner.os == 'Windows' }}
-
-  test-action-ee:
-    needs: test-action
-    name: EE ${{ matrix.version }} + JDK${{ matrix.java-version }} on ${{ matrix.os }}
-    if: github.event_name != 'pull_request'
-    runs-on: ${{ matrix.os }}
-    env:
-      # Skip builds that require a GDS token but have no access to one (e.g., secrets are unavailable in PR runs)
-      PASSES_GDS_TOKEN_CHECK: ${{ secrets.GDS_TOKEN != '' }}
-    strategy:
-      matrix:
-        version: ['latest']
-        java-version: ['17']
-        components: ['native-image']
-        os: [macos-latest, windows-latest, ubuntu-latest]
-        include:
-          - version: '22.3.3'
-            java-version: '11'
-            components: 'native-image'
-            os: ubuntu-latest
-          - version: '22.3.3'
-            java-version: '17'
-            components: 'native-image'
-            os: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          version: ${{ matrix.version }}
-          gds-token: ${{ secrets.GDS_TOKEN }}
-          java-version: ${{ matrix.java-version }}
-          components: ${{ matrix.components }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' }}
-      - name: Check environment
-        run: |
-          echo "GRAALVM_HOME: $GRAALVM_HOME"
-          [[ "$GRAALVM_HOME" == *"$RUNNER_TOOL_CACHE"* ]] || exit 12
-          echo "JAVA_HOME: $JAVA_HOME"
-          java --version
-          java --version | grep -e "GraalVM EE" -e "Oracle GraalVM" || exit 23
-          native-image --version
-          gu list
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' && runner.os != 'Windows' }}
-      - name: Check Windows environment
-        run: |
-          echo "GRAALVM_HOME: $env:GRAALVM_HOME"
-          echo "JAVA_HOME: $env:JAVA_HOME"
-          java --version
-          native-image --version
-          gu.cmd remove native-image
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' && runner.os == 'Windows' }}
-
-  test-action-mandrel:
-    needs: test-action
-    name: ${{ matrix.version }} + JDK${{ matrix.java-version }} on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        version: ['mandrel-22.2.0.0-Final', '23.0.1.2-Final', 'mandrel-latest']
-        java-version: ['17']
-        distribution: ['mandrel']
-        os: [windows-latest, ubuntu-latest]
-        include:
-          - version: 'mandrel-latest'
-            java-version: '17'
-            distribution: '' # test empty distribution for backward compatibility
-            os: ubuntu-latest
-          - version: '' # test with no version
-            java-version: '21'
-            distribution: 'mandrel'
-            os: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          version: ${{ matrix.version }}
-          distribution: ${{ matrix.distribution }}
-          java-version: ${{ matrix.java-version }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Check environment
-        run: |
-          echo "GRAALVM_HOME: $GRAALVM_HOME"
-          [[ "$GRAALVM_HOME" == *"$RUNNER_TOOL_CACHE"* ]] || exit 12
-          echo "JAVA_HOME: $JAVA_HOME"
-          java --version
-          java --version | grep "Temurin" || exit 23
-          native-image --version
-        if: ${{ runner.os != 'Windows' }}
-      - name: Check Windows environment
-        run: |
-          echo "GRAALVM_HOME: $env:GRAALVM_HOME"
-          echo "JAVA_HOME: $env:JAVA_HOME"
-          java --version
-          native-image --version
-        if: ${{ runner.os == 'Windows' }}
-
-  test-action-liberica:
-    needs: test-action
-    name: Liberica (${{ matrix.java-version }}, '${{ matrix.java-package }}', ${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        java-version: ['17', '21.0.2']
-        java-package: ['', 'jdk', 'jdk+fx']
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          distribution: liberica
-          java-version: ${{ matrix.java-version }}
-          java-package: ${{ matrix.java-package }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Check environment
-        run: |
-          echo "GRAALVM_HOME: $GRAALVM_HOME"
-          [[ "$GRAALVM_HOME" == *"$RUNNER_TOOL_CACHE"* ]] || exit 12
-          echo "JAVA_HOME: $JAVA_HOME"
-          java --version
-          java --version | fgrep -qw ${{ matrix.java-version }} || exit 23
-          native-image --version
-          native-image --version | fgrep -qw ${{ matrix.java-version }} || exit 24
-        if: ${{ runner.os != 'Windows' }}
-      - name: Check Windows environment
-        shell: pwsh
-        run: |
-          echo "GRAALVM_HOME: $env:GRAALVM_HOME"
-          echo "JAVA_HOME: $env:JAVA_HOME"
-          java --version
-          if (!(java --version | findstr \<${{ matrix.java-version }}\>)) {
-            exit 23
-          }
-          native-image --version
-          if (!(native-image --version | findstr \<${{ matrix.java-version }}\>)) {
-            exit 24
-          }
-        if: ${{ runner.os == 'Windows' }}
-
-  test-action-native-image-windows:
-    name: native-image on windows-latest
-    runs-on: windows-latest
-    permissions:
-      contents: read
-      pull-requests: write # for `native-image-pr-reports` option
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          java-version: 'dev'
-          distribution: 'graalvm-community'
-          native-image-job-reports: 'true'
-          native-image-pr-reports: 'true'
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build HelloWorld executable with GraalVM Native Image on Windows
-        run: |
-          echo 'public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }' > HelloWorld.java
-          javac HelloWorld.java
-          native-image HelloWorld
-          ./helloworld
-
-  test-action-native-image-windows-msvc:
-    name: native-image on windows-2022
-    runs-on: windows-2022
-    permissions:
-      contents: read
-      pull-requests: write # for `native-image-pr-reports` option
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          java-version: '17'
-          distribution: 'graalvm'
-          native-image-job-reports: 'true'
-          native-image-pr-reports: 'true'
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build HelloWorld executable with GraalVM Native Image on Windows
-        run: |
-          echo 'public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }' > HelloWorld.java
-          javac HelloWorld.java
-          native-image HelloWorld
-          ./helloworld
-
-  test-action-native-image-musl:
-    name: native-image-musl on ubuntu-latest
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: write # for `native-image-pr-reports` option
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          java-version: 'dev'
-          distribution: 'graalvm-community'
-          native-image-musl: 'true'
-          native-image-job-reports: 'true'
-          native-image-pr-reports: 'true'
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build static HelloWorld executable with GraalVM Native Image and musl
-        run: |
-          echo 'public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }' > HelloWorld.java
-          javac HelloWorld.java
-          native-image --static --libc=musl HelloWorld
-          ./helloworld
-
-  test-action-extensive:
-    name: extensive tests on ubuntu-latest
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: write # for `native-image-pr-reports` option
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          java-version: '17.0.8'
-          distribution: 'graalvm'
-          components: 'espresso,llvm-toolchain,native-image,nodejs,python,ruby,wasm'
-          set-java-home: 'false'
-          native-image-job-reports: 'true'
-          native-image-pr-reports: 'true'
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Check environment
-        run: |
-          echo "GRAALVM_HOME: $GRAALVM_HOME"
-          echo "JAVA_HOME: $JAVA_HOME"
-          [[ "$GRAALVM_HOME" != "$JAVA_HOME" ]] || exit 12
-          [[ $(which java) == *"graalvm"* ]] || exit 23
-          java --version
-          java -truffle --version
-          gu --version
-          gu list
-          [[ $(which lli) == *"graalvm"* ]] || exit 34
-          lli --version
-          native-image --version
-          [[ $(which node) == *"graalvm"* ]] || exit 45
-          node --version
-          graalpy --version
-          truffleruby --version
-          wasm --version
-      - name: Build HelloWorld.java with GraalVM Native Image
-        run: |
-          echo 'public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }' > HelloWorld.java
-          javac HelloWorld.java
-          native-image -g HelloWorld
-          ./helloworld
-      # - name: Build Ruby-FFI with TruffleRuby
-      #   run: |
-      #     [[ $(which bundle) == *"graalvm"* ]] || exit 57
-      #     git clone --depth 1 https://github.com/ffi/ffi.git
-      #     pushd ffi > /dev/null
-      #     # https://github.com/ffi/ffi/blob/447845cb3030194c79700c86fb388a12e6f81386/.github/workflows/ci.yml#L58-L62
-      #     bundle install
-      #     bundle exec rake libffi
-      #     bundle exec rake compile
-      #     bundle exec rake test
-      #     popd > /dev/null
-      - name: Remove components
-        run: gu remove espresso llvm-toolchain nodejs python ruby wasm
-
-  test-action-sbom:
-    name: test 'native-image-enable-sbom' option
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: write
-    strategy:
-      matrix:
-        java-version: ['24-ea', 'latest-ea']
-        distribution: ['graalvm']
-        os: [macos-latest, windows-latest, ubuntu-latest, ubuntu-22.04-arm]
-        components: ['']
-    steps:
-      - uses: actions/checkout@v4
-      - name: Run setup-graalvm action
-        uses: ./
-        with:
-          java-version: ${{ matrix.java-version }}
-          distribution: ${{ matrix.distribution }}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          components: ${{ matrix.components }}
-          native-image-enable-sbom: 'true'
-          cache: 'maven'
-      - name: Build Maven project and verify that SBOM was generated and its contents
-        run: |
-          cd __tests__/sbom/main-test-app
-          mvn --no-transfer-progress -Pnative package
-          bash verify-sbom.sh
-        shell: bash
-        if: ${{ runner.os != 'Windows' }}
-      - name: Build Maven project and verify that SBOM was generated and its contents (Windows)
-        run: |
-          cd __tests__\sbom\main-test-app
-          mvn --no-transfer-progress -Pnative package
-          cmd /c verify-sbom.cmd
-        shell: cmd
-        if: ${{ runner.os == 'Windows' }}

.github/workflows/test.yml

@@ -0,0 +1,242 @@
+name: 'build-test'
+
+on:
+  push:
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  workflow_dispatch:
+permissions:
+  contents: read
+
+jobs:
+  build: # make sure build/ci work properly
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - run: |
+          npm install
+      - run: |
+          npm run all
+  test-ce: # make sure the action works on a clean machine without building
+    name: CE ${{ matrix.version }} + JDK${{ matrix.java-version }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        version: [latest, dev]
+        java-version: ['17', '19']
+        components: ['native-image']
+        os: [macos-latest, windows-latest, ubuntu-latest]
+        include:
+          - version: '22.2.0' # for update notifications
+            java-version: '17'
+            components: 'native-image'
+            os: ubuntu-18.04
+          - version: '22.3.0'
+            java-version: '11' # for JDK11 notification
+            components: 'native-image'
+            os: macos-11
+          - version: '22.3.0'
+            java-version: '17'
+            components: 'native-image'
+            os: windows-2022
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run setup-graalvm action
+        uses: ./
+        with:
+          version: ${{ matrix.version }}
+          java-version: ${{ matrix.java-version }}
+          components: ${{ matrix.components }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Check environment
+        run: |
+          echo "GRAALVM_HOME: $GRAALVM_HOME"
+          if [[ "${{ matrix.version }}" == "dev" ]]; then
+            [[ "$GRAALVM_HOME" == *"$RUNNER_TEMP"* ]] || exit 12
+          else
+            [[ "$GRAALVM_HOME" == *"$RUNNER_TOOL_CACHE"* ]] || exit 23
+          fi
+          echo "JAVA_HOME: $JAVA_HOME"
+          java --version
+          java --version | grep "GraalVM CE" || exit 34
+          native-image --version
+        if: runner.os != 'Windows'
+      - name: Check Windows environment
+        run: |
+          echo "GRAALVM_HOME: $env:GRAALVM_HOME"
+          echo "JAVA_HOME: $env:JAVA_HOME"
+          java --version
+          native-image --version
+        if: runner.os == 'Windows'
+  test-ee:
+    name: EE ${{ matrix.version }} + JDK${{ matrix.java-version }} on ${{ matrix.os }}
+    if: github.event_name != 'pull_request'
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        version: ['22.3.0', 'latest']
+        java-version: ['11', '17', '19']
+        components: ['native-image']
+        os: [macos-latest, windows-latest, ubuntu-latest]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run setup-graalvm action
+        uses: ./
+        with:
+          version: ${{ matrix.version }}
+          gds-token: ${{ secrets.GDS_TOKEN }}
+          java-version: ${{ matrix.java-version }}
+          components: ${{ matrix.components }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Check environment
+        run: |
+          echo "GRAALVM_HOME: $GRAALVM_HOME"
+          [[ "$GRAALVM_HOME" == *"$RUNNER_TOOL_CACHE"* ]] || exit 12
+          echo "JAVA_HOME: $JAVA_HOME"
+          java --version
+          java --version | grep "GraalVM EE" || exit 23
+          native-image --version
+        if: runner.os != 'Windows'
+      - name: Check Windows environment
+        run: |
+          echo "GRAALVM_HOME: $env:GRAALVM_HOME"
+          echo "JAVA_HOME: $env:JAVA_HOME"
+          java --version
+          native-image --version
+        if: runner.os == 'Windows'
+  test-mandrel:
+    name: ${{ matrix.version }} + JDK${{ matrix.java-version }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        version: ['mandrel-22.2.0.0-Final', 'mandrel-latest']
+        java-version: ['17']
+        os: [windows-latest, ubuntu-latest]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run setup-graalvm action
+        uses: ./
+        with:
+          version: ${{ matrix.version }}
+          java-version: ${{ matrix.java-version }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Check environment
+        run: |
+          echo "GRAALVM_HOME: $GRAALVM_HOME"
+          [[ "$GRAALVM_HOME" == *"$RUNNER_TOOL_CACHE"* ]] || exit 12
+          echo "JAVA_HOME: $JAVA_HOME"
+          java --version
+          native-image --version
+        if: runner.os != 'Windows'
+      - name: Check Windows environment
+        run: |
+          echo "GRAALVM_HOME: $env:GRAALVM_HOME"
+          echo "JAVA_HOME: $env:JAVA_HOME"
+          java --version
+          native-image --version
+        if: runner.os == 'Windows'
+  test-native-image-msvc:
+    name: native-image on windows-latest
+    runs-on: windows-latest
+    permissions:
+      contents: read
+      pull-requests: write # for `native-image-pr-reports` option
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run setup-graalvm action
+        uses: ./
+        with:
+          version: 'latest'
+          java-version: '17'
+          components: 'native-image'
+          native-image-job-reports: 'true'
+          native-image-pr-reports: 'true'
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build HelloWorld executable with GraalVM Native Image on Windows
+        run: |
+          echo 'public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }' > HelloWorld.java
+          javac HelloWorld.java
+          native-image HelloWorld
+          ./helloworld
+  test-native-image-musl:
+    name: native-image-musl on ubuntu-latest
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write # for `native-image-pr-reports` option
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run setup-graalvm action
+        uses: ./
+        with:
+          version: 'latest'
+          java-version: '19'
+          components: 'native-image'
+          native-image-musl: 'true'
+          native-image-job-reports: 'true'
+          native-image-pr-reports: 'true'
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build static HelloWorld executable with GraalVM Native Image and musl
+        run: |
+          echo 'public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }' > HelloWorld.java
+          javac HelloWorld.java
+          native-image --static --libc=musl HelloWorld
+          ./helloworld
+  test-extensive:
+    name: extensive tests on ubuntu-latest
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write # for `native-image-pr-reports` option
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run setup-graalvm action
+        uses: ./
+        with:
+          version: 'dev'
+          java-version: '17'
+          components: 'espresso,llvm-toolchain,native-image,nodejs,python,R,ruby,wasm'
+          set-java-home: 'false'
+          native-image-job-reports: 'true'
+          native-image-pr-reports: 'true'
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Check environment
+        run: |
+          echo "GRAALVM_HOME: $GRAALVM_HOME"
+          echo "JAVA_HOME: $JAVA_HOME"
+          [[ "$GRAALVM_HOME" != "$JAVA_HOME" ]] || exit 12
+          [[ $(which java) == *"graalvm"* ]] || exit 23
+          java --version
+          java -truffle --version
+          gu --version
+          gu list
+          [[ $(which lli) == *"graalvm"* ]] || exit 34
+          lli --version
+          native-image --version
+          [[ $(which node) == *"graalvm"* ]] || exit 45
+          node --version
+          graalpy --version
+          [[ $(which R) == *"graalvm"* ]] || exit 56
+          R --version
+          truffleruby --version
+          wasm --version
+      - name: Build HelloWorld.java with GraalVM Native Image
+        run: |
+          echo 'public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } }' > HelloWorld.java
+          javac HelloWorld.java
+          native-image -g HelloWorld
+          ./helloworld
+      - name: Build Ruby-FFI with TruffleRuby
+        run: |
+          [[ $(which bundle) == *"graalvm"* ]] || exit 57
+          git clone --depth 1 https://github.com/ffi/ffi.git
+          pushd ffi > /dev/null
+          # https://github.com/ffi/ffi/blob/447845cb3030194c79700c86fb388a12e6f81386/.github/workflows/ci.yml#L58-L62
+          bundle install
+          bundle exec rake libffi
+          bundle exec rake compile
+          bundle exec rake test
+          popd > /dev/null

.gitignore

@@ -96,7 +96,4 @@ Thumbs.db
 
 # Ignore built ts files
 __tests__/runner/*
-lib/**/*
-
-# Ignore target directory in __tests__
-__tests__/**/target
+lib/**/*

.node-version

@@ -1 +0,0 @@
-20.9.0

.prettierignore

@@ -1,3 +1,3 @@
 dist/
-node_modules/
-README.md
+lib/
+node_modules/

.prettierrc.json

@@ -0,0 +1,10 @@
+{
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "bracketSpacing": false,
+  "arrowParens": "avoid"
+}

.prettierrc.yml

@@ -1,16 +0,0 @@
-# See: https://prettier.io/docs/en/configuration
-
-printWidth: 120
-tabWidth: 2
-useTabs: false
-semi: false
-singleQuote: true
-quoteProps: as-needed
-jsxSingleQuote: false
-trailingComma: none
-bracketSpacing: true
-bracketSameLine: true
-arrowParens: always
-proseWrap: always
-htmlWhitespaceSensitivity: css
-endOfLine: lf

README.md

@@ -1,18 +1,18 @@
-# GitHub Action for GraalVM [![CI](https://github.com/graalvm/setup-graalvm/actions/workflows/ci.yml/badge.svg)](https://github.com/graalvm/setup-graalvm/actions/workflows/ci.yml)
-This GitHub action sets up [Oracle GraalVM][graalvm-medium], GraalVM [Community Edition (CE)][repo], [Enterprise Edition (EE)][graalvm-ee], [Mandrel][mandrel], or [Liberica Native Image Kit][liberica] as well as [Native Image][native-image] and GraalVM components such as [Truffle languages][truffle-languages].
+# GitHub Action for GraalVM [![build-test](https://github.com/graalvm/setup-graalvm/actions/workflows/test.yml/badge.svg)](https://github.com/graalvm/setup-graalvm/actions/workflows/test.yml)
+This GitHub action sets up GraalVM [Community Edition (CE)][repo] or [Enterprise Edition (EE)][graalvm-ee] as well as GraalVM components such as [Native Image][native-image] and [Truffle languages][truffle-languages].
 
 ## Key Features
 
 This action:
 
-- supports Oracle GraalVM [releases][graalvm-dl], [EA builds][ea-builds], GraalVM Community Edition (CE) [releases], [dev builds][dev-builds], GraalVM Enterprise Edition (EE) [releases][graalvm-ee] (set [`gds-token`](#options)) 22.1.0 and later, [Mandrel][mandrel], and [Liberica Native Image Kit][liberica] (see [Options](#options))
-- exports a `$GRAALVM_HOME` environment variable
-- adds `$GRAALVM_HOME/bin` to the `$PATH` environment variable<br>(Native Image, Truffle languages, and tools can be invoked directly)
-- sets `$JAVA_HOME` to `$GRAALVM_HOME` by default<br>(can be disabled via `set-java-home: 'false'`, see [Options](#options))
-- supports `x64` and `aarch64/arm64` (see how to use [Linux arm64 runners](https://github.blog/changelog/2025-01-16-linux-arm64-hosted-runners-now-available-for-free-in-public-repositories-public-preview/))
-- supports dependency caching for Apache Maven, Gradle, and sbt (see [`cache` option](#options))
-- sets up Windows environments with build tools using [vcvarsall.bat][vcvarsall]
+- supports GraalVM Community Edition (CE) [releases], [dev builds][dev-builds], GraalVM Enterprise Edition (EE) [releases][graalvm-ee] (set [`gds-token`](#options)) 22.1.0 and later, and [Mandrel][mandrel] (see [options](#options))
 - has built-in support for GraalVM components and the [GraalVM Updater][gu]
+- exports a `$GRAALVM_HOME` environment variable
+- adds `$GRAALVM_HOME/bin` to the `$PATH` environment variable<br>(Truffle languages and tools can be invoked directly)
+- sets `$JAVA_HOME` to `$GRAALVM_HOME` by default<br>(can be disabled via `set-java-home: 'false'`, see [options](#options))
+- supports `amd64` and `aarch64` (selected automatically, `aarch64` requires a [self-hosted runner][gha-self-hosted-runners])
+- sets up Windows environments with build tools using [vcvarsall.bat][vcvarsall]
+- supports dependency caching for Apache Maven, Gradle, and sbt (see [`cache` option](#options))
 
 
 ## Templates
@@ -20,28 +20,26 @@ This action:
 ### Quickstart Template
 
 ```yml
-name: GraalVM build
+name: GraalVM Community Edition build
 on: [push, pull_request]
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - uses: graalvm/setup-graalvm@v1
         with:
-          java-version: '21'      # See 'Options' for more details
-          distribution: 'graalvm' # See 'Supported distributions' for available options
+          version: 'latest'
+          java-version: '17'
+          components: 'native-image'
           github-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Example step
         run: |
           echo "GRAALVM_HOME: $GRAALVM_HOME"
           echo "JAVA_HOME: $JAVA_HOME"
           java --version
+          gu --version
           native-image --version
-      - name: Example step using Maven plugin  # https://graalvm.github.io/native-build-tools/latest/maven-plugin.html
-        run: mvn -Pnative package
-      - name: Example step using Gradle plugin # https://graalvm.github.io/native-build-tools/latest/gradle-plugin.html
-        run: gradlew nativeCompile
 ```
 
 ### Building a HelloWorld with GraalVM Native Image on Different Platforms
@@ -57,12 +55,13 @@ jobs:
       matrix:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
 
       - uses: graalvm/setup-graalvm@v1
         with:
-          java-version: '21'
-          distribution: 'graalvm'
+          version: '22.3.0'
+          java-version: '11'
+          components: 'native-image'
           github-token: ${{ secrets.GITHUB_TOKEN }}
           native-image-job-reports: 'true'
 
@@ -74,185 +73,62 @@ jobs:
           ./helloworld
       
       - name: Upload binary
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         with:
           name: helloworld-${{ matrix.os }}
           path: helloworld*
 ```
 
-### Template for Oracle GraalVM Early Access (EA) builds
-
-```yml
-name: Oracle GraalVM Early Access build
-on: [push, pull_request]
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: graalvm/setup-graalvm@v1
-        with:
-          java-version: '24-ea' # or 'latest-ea' for the latest Java version available
-          distribution: 'graalvm'
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-```
-
-<details>
-<summary><h4>Template for Oracle GraalVM via GraalVM Download Service</h4></summary>
-
-#### Prerequisites
-
-1. Obtain a token for the GraalVM Download Service. For this, replace `your@email.com` with your email address and run the following `curl` command:
-
-    ```bash
-    curl -sS -X POST "https://gds.oracle.com/api/20220101/licenseAcceptance" \
-      -H "Content-Type: application/json" \
-      -d "{ \"email\": \"your@email.com\", \"licenseId\": \"D53FA58D12817B3CE0530F15000A74CA\", \"type\": \"GENERATE_TOKEN_AND_ACCEPT_LICENSE\"}"
-    ```
-
-    The response should look like this:
-
-    ```json
-    {"token":"<your-token>","status":"UNVERIFIED"}
-    ```
-
-2. Store the value of `<your-token>` as a [GitHub Action secret][gha-secrets]. For the following template, we use the name `GDS_TOKEN`.
-3. Check your emails and accept the license to activate the token.
-4. Use `java-version: '17'` (or a specific version such as `17.0.13`) and provide the `GDS_TOKEN` as shown in the following template:
-
-    ```yml
-    name: Build with Oracle GraalVM for JDK 17 via GDS
-    on: [push, pull_request]
-    jobs:
-      build:
-        runs-on: ubuntu-latest
-        steps:
-          - uses: actions/checkout@v4
-          - uses: graalvm/setup-graalvm@v1
-            with:
-              distribution: 'graalvm'
-              java-version: '17'
-              gds-token: ${{ secrets.GDS_TOKEN }}
-              github-token: ${{ secrets.GITHUB_TOKEN }}
-          - name: Example step
-            run: |
-              java --version
-              native-image --version
-    ```
-
-</details>
-
-<details>
-<summary><h4>Template for GraalVM Enterprise Edition</h4></summary>
+### Basic GraalVM Enterprise Edition Template
 
 #### Prerequisites
 
 1. Download the version of [GraalVM Enterprise Edition (EE)][graalvm-ee] you want to run on GitHub Actions.
 2. Use the [GraalVM Updater][gu] to install the GraalVM components you need on GitHub Actions and accept the corresponding licenses.
 3. Run `$GRAALVM_HOME/bin/gu --show-ee-token` to display your token for the GraalVM Download Service.
-4. Store this token as a [GitHub Action secret][gha-secrets]. In the following template, we use the name `GDS_TOKEN`:
+4. Store this token as a [GitHub Action secret][gha-secrets]. For this template, we use the name `GDS_TOKEN`.
 
-    ```yml
-    name: GraalVM Enterprise Edition build
-    on: [push, pull_request]
-    jobs:
-      build:
-        runs-on: ubuntu-latest
-        steps:
-          - uses: actions/checkout@v4
-          - uses: graalvm/setup-graalvm@v1
-            with:
-              version: '22.3.0'
-              gds-token: ${{ secrets.GDS_TOKEN }}
-              java-version: '17'
-              components: 'native-image'
-              github-token: ${{ secrets.GITHUB_TOKEN }}
-          - name: Example step
-            run: |
-              java --version
-              native-image --version
-    ```
-
-</details>
-
-
-## Supported distributions
-
-Currently, the following distributions are supported:
-
-| Keyword | Distribution | Official site | License |
-|-|-|-|-|
-| `graalvm` | Oracle GraalVM | [Link](https://www.graalvm.org/) | [Link](https://www.oracle.com/downloads/licenses/graal-free-license.html) |
-| `graalvm-community` | GraalVM Community Edition | [Link](https://www.graalvm.org/) | [Link](https://github.com/oracle/graal/blob/master/LICENSE) |
-| `mandrel` | Mandrel | [Link](https://github.com/graalvm/mandrel) | [Link](https://github.com/graalvm/mandrel/blob/default/LICENSE) |
-| `liberica` | Liberica NIK | [Link](https://bell-sw.com/liberica-native-image-kit/) | [Link](https://bell-sw.com/liberica_nik_eula/) |
+```yml
+name: GraalVM Enterprise Edition build
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: graalvm/setup-graalvm@v1
+        with:
+          version: '22.3.0'
+          gds-token: ${{ secrets.GDS_TOKEN }}
+          java-version: '11'
+          components: 'native-image'
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Example step
+        run: |
+          java --version
+          native-image --version
+```
 
 
 ## Options
 
-This actions can be configured with the following options:
-
 | Name            | Default  | Description |
 |-----------------|:--------:|-------------|
-| `java-version`<br>*(required)* | n/a | Java version <ul><li>major versions: `'23'`, `'21'`, `'17'`, `'11'`, `'8'`</li><li>specific versions: `'21.0.3'`, `'17.0.11'`</li><li>early access (EA) builds: `'24-ea'` *(requires `distribution: 'graalvm'`)*</li><li>latest EA build: `'latest-ea'` *(requires `distribution: 'graalvm'`)*</li><li>dev builds: `'dev'`</li></ul> |
-| `distribution`  | `'graalvm'` | GraalVM distribution (see [supported distributions](#supported-distributions)) |
-| `java-package`  | `'jdk'` | The package type (`'jdk'` or `'jdk+fx'`). Currently applies to Liberica only. |
-| `github-token`  | `'${{ github.token }}'` | Token for communication with the GitHub API. Please set this to `${{ secrets.GITHUB_TOKEN }}` (see [templates](#templates)) to allow the action to authenticate with the GitHub API, which helps reduce rate-limiting issues. |
+| `version`<br>*(required)* | n/a | `X.Y.Z` (e.g., `21.3.0`) for a specific [GraalVM release][releases]<br>`latest` for [latest stable release][stable],<br>`dev` for [latest dev build][dev-build],<br>`mandrel-X.Y.Z` (e.g., `mandrel-21.3.0.0-Final`) for a specific [Mandrel release][mandrel-releases],<br>`mandrel-latest` for [latest Mandrel stable release][mandrel-stable]. |
+| `gds-token`     | `''`     | Download token for the GraalVM Download Service. If a non-empty token is provided, the action will set up GraalVM Enterprise Edition (see [GraalVM EE template](#basic-graalvm-enterprise-edition-template)). |
+| `java-version`<br>*(required)* | n/a | `'11'` or `'17'` for a specific Java version.<br>(`'8'` and `'16'` are supported for GraalVM 21.2 and earlier.) |
+| `components`    | `''`     | Comma-spearated list of GraalVM components (e.g., `native-image` or `ruby,nodejs`) that will be installed by the [GraalVM Updater][gu]. |
+| `github-token`  | `''`     | Token for communication with the GitHub API. Please set to `${{ secrets.GITHUB_TOKEN }}` (see [templates](#templates)) to allow the action to authenticate with the GitHub API, which helps to reduce rate limiting issues. |
 | `set-java-home` | `'true'` | If set to `'true'`, instructs the action to set `$JAVA_HOME` to the path of the GraalVM installation. Overrides any previous action or command that sets `$JAVA_HOME`. |
-| `cache`         | `''`     | Name of the build platform to cache dependencies. Turned off by default (`''`). It can also be `'maven'`, `'gradle'`, or `'sbt'` and works the same way as described in [actions/setup-java][setup-java-caching]. |
-| `check-for-updates` | `'true'`  | [Annotate jobs][gha-annotations] with update notifications, for example when a new GraalVM release is available. |
-| `native-image-musl` | `'false'` | If set to `'true'`, sets up [musl] to build [static binaries][native-image-static] with GraalVM Native Image *(Linux only)*. [Example usage][native-image-musl-build] (be sure to replace `uses: ./` with `uses: graalvm/setup-graalvm@v1`). |
+| `cache`         | `''`     | Name of the build platform to cache dependencies. It can be `'maven'`, `'gradle'`, or `'sbt'` and works the same way as described in [actions/setup-java][setup-java-caching]. |
+| `check-for-updates` | `'true'`  | [Annotate jobs][gha-annotations] with update notifications, for example, when a new GraalVM release is available. |
 | `native-image-job-reports` *) | `'false'` | If set to `'true'`, post a job summary containing a Native Image build report. |
-| `native-image-pr-reports`  *) | `'false'` | If set to `'true'`, post a comment containing a Native Image build report on pull requests. Requires `write` permissions for the [`pull-requests` scope][gha-permissions]. |
-| `native-image-pr-reports-update-existing` *) | `'false'` | Instead of posting another comment, update an existing PR comment with the latest Native Image build report. Requires `native-image-pr-reports` to be `true`. |
-| `native-image-enable-sbom` | `'false'` | If set to `'true'`, generate a minimal SBOM based on the Native Image static analysis and submit it to GitHub's dependency submission API. This enables the [dependency graph feature](https://docs.github.com/en/code-security/supply-chain-security/understanding-your-software-supply-chain/about-the-dependency-graph) for dependency tracking and vulnerability analysis. Requires `write` permissions for the [`contents` scope][gha-permissions] and the dependency graph to be actived (on by default for public repositories - see [how to activate](https://docs.github.com/en/code-security/supply-chain-security/understanding-your-software-supply-chain/configuring-the-dependency-graph#enabling-and-disabling-the-dependency-graph-for-a-private-repository)). Only available in Oracle GraalVM for JDK 24 or later. |
-| `components`    | `''`     | Comma-separated list of GraalVM components (e.g., `native-image` or `ruby,nodejs`) that will be installed by the [GraalVM Updater][gu]. |
-| `version` | `''` | `X.Y.Z` (e.g., `22.3.0`) for a specific [GraalVM release][releases] up to `22.3.2`<br>`mandrel-X.Y.Z.W` or `X.Y.Z.W-Final` (e.g., `mandrel-21.3.0.0-Final` or `21.3.0.0-Final`) for a specific [Mandrel release][mandrel-releases],<br>`mandrel-latest` or `latest` for the latest Mandrel stable release. |
-| `gds-token`     | `''`     Download token for the GraalVM Download Service. If a non-empty token is provided, the action will set up Oracle GraalVM (see [Oracle GraalVM via GDS template](#template-for-oracle-graalvm-via-graalvm-download-service)) or GraalVM Enterprise Edition (see [GraalVM EE template](#template-for-graalvm-enterprise-edition)) via GDS. |
+| `native-image-musl` | `'false'` | If set to `'true'`, sets up [musl] to build [static binaries][native-image-static] with GraalVM Native Image *(Linux only)*. [Example usage][native-image-musl-build] (be sure to replace `uses: ./` with `uses: graalvm/setup-graalvm@v1`). |
+| `native-image-pr-reports` *) | `'false'` | If set to `'true'`, post a comment containing a Native Image build report on pull requests. Requires `write` permissions for the [`pull-requests` scope][gha-permissions]. |
 
 **) Make sure that Native Image is used only once per build job. Otherwise, the report is only generated for the last Native Image build.*
 
 
-## Notes on Oracle GraalVM for JDK 17
-
-GraalVM for JDK 17.0.12 is the [last release of Oracle GraalVM for JDK 17 under the GFTC](https://blogs.oracle.com/java/post/jdk-17-approaches-endofpermissive-license).
-Updates after September 2024 will be licensed under the [GraalVM OTN License Including License for Early Adopter Versions](https://www.oracle.com/downloads/licenses/graalvm-otn-license.html) (GOTN) and production use beyond the limited free grants of the GraalVM OTN license will require a fee.
-
-As a user of `setup-graalvm`, you have the following options:
-
-- *Recommended*: Upgrade to Oracle GraalVM for JDK 21 or later to receive new updates.
-- *Not recommended*: Instead of `java-version: '17'`, use `java-version: '17.0.12'` in your workflow to keep using the last release under GFTC. This will also disable the warning. Note that switching to GraalVM Community Edition or other GraalVM distributions might provide you with even older releases of GraalVM.
-- Provide a `gds-token` to access Oracle GraalVM for JDK 17 under GOTN (see [Oracle GraalVM via GDS template](#template-for-oracle-graalvm-via-graalvm-download-service)).
-
-
-## Migrating from GraalVM 22.3 or Earlier to the New GraalVM for JDK 17 and Later
-
-The [GraalVM for JDK 17 and JDK 20 release](https://medium.com/graalvm/a-new-graalvm-release-and-new-free-license-4aab483692f5) aligns the GraalVM version scheme with OpenJDK.
-As a result, this action no longer requires the `version` option to select a specific GraalVM version.
-At the same time, it introduces a new `distribution` option to select a specific GraalVM distribution (`graalvm`, `graalvm-community`, or `mandrel`).
-Therefore, to migrate your workflow to use the latest GraalVM release, replace the `version` with the `distribution` option in the workflow `yml` config, for example:
-
-```yml
-# ...
-- uses: graalvm/setup-graalvm@v1
-  with:
-    java-version: '17'
-    version: '22.3.2' # Old 'version' option for the GraalVM version
-    # ...
-```
-
-can be replaced with:
-
-```yml
-# ...
-- uses: graalvm/setup-graalvm@v1
-  with:
-    java-version: '17.0.12' # for a specific JDK 17; or '17' for the latest JDK 17
-    distribution: 'graalvm' # New 'distribution' option
-    # ...
-```
-
-
 ## Contributing
 
 We welcome code contributions. To get started, you will need to sign the [Oracle Contributor Agreement][oca] (OCA).
@@ -262,18 +138,12 @@ Only pull requests from committers that can be verified as having signed the OCA
 
 [dev-build]: https://github.com/graalvm/graalvm-ce-dev-builds/releases/latest
 [dev-builds]: https://github.com/graalvm/graalvm-ce-dev-builds
-[ea-builds]: https://github.com/graalvm/oracle-graalvm-ea-builds
-[gftc]: https://www.oracle.com/downloads/licenses/graal-free-license.html
 [gha-annotations]: https://github.com/actions/toolkit/tree/main/packages/core#annotations
 [gha-permissions]: https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#permissions
 [gha-secrets]: https://docs.github.com/en/actions/security-guides/encrypted-secrets#creating-encrypted-secrets-for-a-repository
 [gha-self-hosted-runners]: https://docs.github.com/en/actions/hosting-your-own-runners/about-self-hosted-runners
 [gu]: https://www.graalvm.org/reference-manual/graalvm-updater/
-[graalvm]: https://www.graalvm.org/
-[graalvm-dl]: https://www.oracle.com/java/technologies/downloads/
-[graalvm-medium]: https://medium.com/graalvm/a-new-graalvm-release-and-new-free-license-4aab483692f5
 [graalvm-ee]: https://www.oracle.com/downloads/graalvm-downloads.html
-[liberica]: https://bell-sw.com/liberica-native-image-kit/
 [mandrel]: https://github.com/graalvm/mandrel
 [mandrel-releases]: https://github.com/graalvm/mandrel/releases
 [mandrel-stable]: https://github.com/graalvm/mandrel/releases/latest

__tests__/cache.test.ts

@@ -24,10 +24,10 @@
  * Forked from https://github.com/actions/setup-java/blob/5b36705a13905facb447b6812d613a06a07e371d/__tests__/cache.test.ts
  */
 
-import { mkdtempSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { restore, save } from '../src/features/cache'
+import {mkdtempSync} from 'fs'
+import {tmpdir} from 'os'
+import {join} from 'path'
+import {restore, save} from '../src/features/cache'
 import * as fs from 'fs'
 import * as os from 'os'
 import * as core from '@actions/core'
@@ -86,22 +86,29 @@ describe('dependency cache', () => {
   })
 
   describe('restore', () => {
-    let spyCacheRestore: jest.SpyInstance<ReturnType<typeof cache.restoreCache>, Parameters<typeof cache.restoreCache>>
+    let spyCacheRestore: jest.SpyInstance<
+      ReturnType<typeof cache.restoreCache>,
+      Parameters<typeof cache.restoreCache>
+    >
 
     beforeEach(() => {
       spyCacheRestore = jest
         .spyOn(cache, 'restoreCache')
-        .mockImplementation((_paths: string[], _primaryKey: string) => Promise.resolve(undefined))
+        .mockImplementation((paths: string[], primaryKey: string) =>
+          Promise.resolve(undefined)
+        )
       spyWarning.mockImplementation(() => null)
     })
 
     it('throws error if unsupported package manager specified', () => {
-      return expect(restore('ant')).rejects.toThrow('unknown package manager specified: ant')
+      return expect(restore('ant')).rejects.toThrowError(
+        'unknown package manager specified: ant'
+      )
     })
 
     describe('for maven', () => {
       it('throws error if no pom.xml found', async () => {
-        await expect(restore('maven')).rejects.toThrow(
+        await expect(restore('maven')).rejects.toThrowError(
           `No file in ${projectRoot(
             workspace
           )} matched to [**/pom.xml], make sure you have checked out the target repository`
@@ -111,14 +118,14 @@ describe('dependency cache', () => {
         createFile(join(workspace, 'pom.xml'))
 
         await restore('maven')
-        expect(spyCacheRestore).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith('maven cache is not found')
+        expect(spyCacheRestore).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith('maven cache is not found')
       })
     })
     describe('for gradle', () => {
       it('throws error if no build.gradle found', async () => {
-        await expect(restore('gradle')).rejects.toThrow(
+        await expect(restore('gradle')).rejects.toThrowError(
           `No file in ${projectRoot(
             workspace
           )} matched to [**/*.gradle*,**/gradle-wrapper.properties,buildSrc/**/Versions.kt,buildSrc/**/Dependencies.kt], make sure you have checked out the target repository`
@@ -128,17 +135,17 @@ describe('dependency cache', () => {
         createFile(join(workspace, 'build.gradle'))
 
         await restore('gradle')
-        expect(spyCacheRestore).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith('gradle cache is not found')
+        expect(spyCacheRestore).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith('gradle cache is not found')
       })
       it('downloads cache based on build.gradle.kts', async () => {
         createFile(join(workspace, 'build.gradle.kts'))
 
         await restore('gradle')
-        expect(spyCacheRestore).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith('gradle cache is not found')
+        expect(spyCacheRestore).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith('gradle cache is not found')
       })
     })
     it('downloads cache based on buildSrc/Versions.kt', async () => {
@@ -146,13 +153,13 @@ describe('dependency cache', () => {
       createFile(join(workspace, 'buildSrc', 'Versions.kt'))
 
       await restore('gradle')
-      expect(spyCacheRestore).toHaveBeenCalled()
-      expect(spyWarning).not.toHaveBeenCalled()
-      expect(spyInfo).toHaveBeenCalledWith('gradle cache is not found')
+      expect(spyCacheRestore).toBeCalled()
+      expect(spyWarning).not.toBeCalled()
+      expect(spyInfo).toBeCalledWith('gradle cache is not found')
     })
     describe('for sbt', () => {
       it('throws error if no build.sbt found', async () => {
-        await expect(restore('sbt')).rejects.toThrow(
+        await expect(restore('sbt')).rejects.toThrowError(
           `No file in ${projectRoot(
             workspace
           )} matched to [**/*.sbt,**/project/build.properties,**/project/**.{scala,sbt}], make sure you have checked out the target repository`
@@ -162,24 +169,31 @@ describe('dependency cache', () => {
         createFile(join(workspace, 'build.sbt'))
 
         await restore('sbt')
-        expect(spyCacheRestore).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith('sbt cache is not found')
+        expect(spyCacheRestore).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith('sbt cache is not found')
       })
     })
   })
   describe('save', () => {
-    let spyCacheSave: jest.SpyInstance<ReturnType<typeof cache.saveCache>, Parameters<typeof cache.saveCache>>
+    let spyCacheSave: jest.SpyInstance<
+      ReturnType<typeof cache.saveCache>,
+      Parameters<typeof cache.saveCache>
+    >
 
     beforeEach(() => {
       spyCacheSave = jest
         .spyOn(cache, 'saveCache')
-        .mockImplementation((_paths: string[], _key: string) => Promise.resolve(0))
+        .mockImplementation((paths: string[], key: string) =>
+          Promise.resolve(0)
+        )
       spyWarning.mockImplementation(() => null)
     })
 
     it('throws error if unsupported package manager specified', () => {
-      return expect(save('ant')).rejects.toThrow('unknown package manager specified: ant')
+      return expect(save('ant')).rejects.toThrowError(
+        'unknown package manager specified: ant'
+      )
     })
 
     it('save with -1 cacheId , should not fail workflow', async () => {
@@ -187,42 +201,50 @@ describe('dependency cache', () => {
       createStateForMissingBuildFile()
 
       await save('maven')
-      expect(spyCacheSave).toHaveBeenCalled()
-      expect(spyWarning).not.toHaveBeenCalled()
-      expect(spyInfo).toHaveBeenCalled()
-      expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+      expect(spyCacheSave).toBeCalled()
+      expect(spyWarning).not.toBeCalled()
+      expect(spyInfo).toBeCalled()
+      expect(spyInfo).toBeCalledWith(
+        expect.stringMatching(/^Cache saved with the key:.*/)
+      )
     })
 
     it('saves with error from toolkit, should fail workflow', async () => {
-      spyCacheSave.mockImplementation(() => Promise.reject(new cache.ValidationError('Validation failed')))
+      spyCacheSave.mockImplementation(() =>
+        Promise.reject(new cache.ValidationError('Validation failed'))
+      )
       createStateForMissingBuildFile()
 
       expect.assertions(1)
-      await expect(save('maven')).rejects.toEqual(new cache.ValidationError('Validation failed'))
+      await expect(save('maven')).rejects.toEqual(
+        new cache.ValidationError('Validation failed')
+      )
     })
 
     describe('for maven', () => {
       it('uploads cache even if no pom.xml found', async () => {
         createStateForMissingBuildFile()
         await save('maven')
-        expect(spyCacheSave).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
       })
       it('does not upload cache if no restore run before', async () => {
         createFile(join(workspace, 'pom.xml'))
 
         await save('maven')
-        expect(spyCacheSave).not.toHaveBeenCalled()
-        expect(spyWarning).toHaveBeenCalledWith('Error retrieving key from state.')
+        expect(spyCacheSave).not.toBeCalled()
+        expect(spyWarning).toBeCalledWith('Error retrieving key from state.')
       })
       it('uploads cache', async () => {
         createFile(join(workspace, 'pom.xml'))
         createStateForSuccessfulRestore()
 
         await save('maven')
-        expect(spyCacheSave).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
       })
     })
     describe('for gradle', () => {
@@ -230,33 +252,37 @@ describe('dependency cache', () => {
         createStateForMissingBuildFile()
 
         await save('gradle')
-        expect(spyCacheSave).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
       })
       it('does not upload cache if no restore run before', async () => {
         createFile(join(workspace, 'build.gradle'))
 
         await save('gradle')
-        expect(spyCacheSave).not.toHaveBeenCalled()
-        expect(spyWarning).toHaveBeenCalledWith('Error retrieving key from state.')
+        expect(spyCacheSave).not.toBeCalled()
+        expect(spyWarning).toBeCalledWith('Error retrieving key from state.')
       })
       it('uploads cache based on build.gradle', async () => {
         createFile(join(workspace, 'build.gradle'))
         createStateForSuccessfulRestore()
 
         await save('gradle')
-        expect(spyCacheSave).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
       })
       it('uploads cache based on build.gradle.kts', async () => {
         createFile(join(workspace, 'build.gradle.kts'))
         createStateForSuccessfulRestore()
 
         await save('gradle')
-        expect(spyCacheSave).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
       })
       it('uploads cache based on buildSrc/Versions.kt', async () => {
         createDirectory(join(workspace, 'buildSrc'))
@@ -264,33 +290,37 @@ describe('dependency cache', () => {
         createStateForSuccessfulRestore()
 
         await save('gradle')
-        expect(spyCacheSave).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
       })
     })
     describe('for sbt', () => {
       it('uploads cache even if no build.sbt found', async () => {
         createStateForMissingBuildFile()
         await save('sbt')
-        expect(spyCacheSave).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
       })
       it('does not upload cache if no restore run before', async () => {
         createFile(join(workspace, 'build.sbt'))
 
         await save('sbt')
-        expect(spyCacheSave).not.toHaveBeenCalled()
-        expect(spyWarning).toHaveBeenCalledWith('Error retrieving key from state.')
+        expect(spyCacheSave).not.toBeCalled()
+        expect(spyWarning).toBeCalledWith('Error retrieving key from state.')
       })
       it('uploads cache', async () => {
         createFile(join(workspace, 'build.sbt'))
         createStateForSuccessfulRestore()
 
         await save('sbt')
-        expect(spyCacheSave).toHaveBeenCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
       })
     })
   })
@@ -304,7 +334,7 @@ function resetState() {
  * Create states to emulate a restore process without build file.
  */
 function createStateForMissingBuildFile() {
-  jest.spyOn(core, 'getState').mockImplementation((name) => {
+  jest.spyOn(core, 'getState').mockImplementation(name => {
     switch (name) {
       case 'cache-primary-key':
         return 'setup-graalvm-cache-'
@@ -318,7 +348,7 @@ function createStateForMissingBuildFile() {
  * Create states to emulate a successful restore process.
  */
 function createStateForSuccessfulRestore() {
-  jest.spyOn(core, 'getState').mockImplementation((name) => {
+  jest.spyOn(core, 'getState').mockImplementation(name => {
     switch (name) {
       case 'cache-primary-key':
         return 'setup-graalvm-cache-primary-key'

__tests__/cleanup.test.ts

@@ -24,14 +24,19 @@
  * Forked from https://github.com/actions/setup-java/blob/5b36705a13905facb447b6812d613a06a07e371d/__tests__/cleanup-java.test.ts
  */
 
-import { run as cleanup } from '../src/cleanup'
+import {run as cleanup} from '../src/cleanup'
 import * as core from '@actions/core'
 import * as cache from '@actions/cache'
+import * as util from '../src/utils'
 
 describe('cleanup', () => {
   let spyWarning: jest.SpyInstance<void, Parameters<typeof core.warning>>
   let spyInfo: jest.SpyInstance<void, Parameters<typeof core.info>>
-  let spyCacheSave: jest.SpyInstance<ReturnType<typeof cache.saveCache>, Parameters<typeof cache.saveCache>>
+  let spyCacheSave: jest.SpyInstance<
+    ReturnType<typeof cache.saveCache>,
+    Parameters<typeof cache.saveCache>
+  >
+  let spyJobStatusSuccess: jest.SpyInstance
 
   beforeEach(() => {
     spyWarning = jest.spyOn(core, 'warning')
@@ -45,27 +50,31 @@ describe('cleanup', () => {
     resetState()
   })
 
-  it('does not fail nor warn even when the save process throws a ReserveCacheError', async () => {
-    spyCacheSave.mockImplementation((_paths: string[], _key: string) =>
+  it('does not fail nor warn even when the save provess throws a ReserveCacheError', async () => {
+    spyCacheSave.mockImplementation((paths: string[], key: string) =>
       Promise.reject(
-        new cache.ReserveCacheError('Unable to reserve cache with key, another job may be creating this cache.')
+        new cache.ReserveCacheError(
+          'Unable to reserve cache with key, another job may be creating this cache.'
+        )
       )
     )
     jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
       return name === 'cache' ? 'gradle' : ''
     })
     await cleanup()
-    expect(spyCacheSave).toHaveBeenCalled()
-    expect(spyWarning).not.toHaveBeenCalled()
+    expect(spyCacheSave).toBeCalled()
+    expect(spyWarning).not.toBeCalled()
   })
 
   it('does not fail even though the save process throws error', async () => {
-    spyCacheSave.mockImplementation((_paths: string[], _key: string) => Promise.reject(new Error('Unexpected error')))
+    spyCacheSave.mockImplementation((paths: string[], key: string) =>
+      Promise.reject(new Error('Unexpected error'))
+    )
     jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
       return name === 'cache' ? 'gradle' : ''
     })
     await cleanup()
-    expect(spyCacheSave).toHaveBeenCalled()
+    expect(spyCacheSave).toBeCalled()
   })
 })
 
@@ -77,7 +86,7 @@ function resetState() {
  * Create states to emulate a successful restore process.
  */
 function createStateForSuccessfulRestore() {
-  jest.spyOn(core, 'getState').mockImplementation((name) => {
+  jest.spyOn(core, 'getState').mockImplementation(name => {
     switch (name) {
       case 'cache-primary-key':
         return 'setup-java-cache-primary-key'

__tests__/gds.test.ts

@@ -1,50 +1,44 @@
 import * as path from 'path'
-import { downloadGraalVM, downloadGraalVMEELegacy, fetchArtifact, fetchArtifactEE } from '../src/gds'
-import { expect, test } from '@jest/globals'
+import {downloadGraalVMEE, fetchArtifact} from '../src/gds'
+import {expect, test} from '@jest/globals'
 
 const TEST_USER_AGENT = 'GraalVMGitHubActionTest/1.0.4'
 
 process.env['RUNNER_TEMP'] = path.join(__dirname, 'TEMP')
 
 test('fetch artifacts', async () => {
-  let artifact = await fetchArtifact(TEST_USER_AGENT, 'isBase:True', '17.0.12')
-  expect(artifact.id).toBe('1C351E8F41BB8E9EE0631518000AE5F2')
-  expect(artifact.checksum).toBe('b6f3dace24cf1960ec790216f4c86f00d4f43df64e4e8b548f6382f04894713f')
-  artifact = await fetchArtifact(TEST_USER_AGENT, 'isBase:True', '17')
-  expect(artifact.checksum).toHaveLength('b6f3dace24cf1960ec790216f4c86f00d4f43df64e4e8b548f6382f04894713f'.length)
+  let artifact = await fetchArtifact(
+    TEST_USER_AGENT,
+    'isBase:True',
+    '22.1.0',
+    '11'
+  )
+  expect(artifact.id).toBe('DCECD1C1B0B5B8DBE0536E16000A5C74')
+  expect(artifact.checksum).toBe(
+    '4280782f6c7fcabe0ba707e8389cbfaf7bbe6b0cf634d309e6efcd1b172e3ce6'
+  )
+  artifact = await fetchArtifact(TEST_USER_AGENT, 'isBase:True', '22.1.0', '17')
+  expect(artifact.id).toBe('DCECD2068882A0E9E0536E16000A9504')
+  expect(artifact.checksum).toBe(
+    'e897add7d94bc456a61e6f927e831dff759efa3392a4b69c720dd3debc8f947d'
+  )
+
+  await expect(
+    fetchArtifact(TEST_USER_AGENT, 'isBase:False', '22.1.0', '11')
+  ).rejects.toThrow('Found more than one GDS artifact')
+  await expect(
+    fetchArtifact(TEST_USER_AGENT, 'isBase:True', '1.0.0', '11')
+  ).rejects.toThrow('Unable to find JDK11-based GraalVM EE 1.0.0')
 })
 
 test('errors when downloading artifacts', async () => {
-  await expect(downloadGraalVM('invalid', '17')).rejects.toThrow(
-    'The provided "gds-token" was rejected (reason: "Invalid download token", opc-request-id: '
+  await expect(downloadGraalVMEE('invalid', '22.1.0', '11')).rejects.toThrow(
+    'The provided "gds-token" was rejected (reason: "Invalid download token", opc-request-id: /'
   )
-  await expect(downloadGraalVM('invalid', '1')).rejects.toThrow('Unable to find GraalVM for JDK 1')
-})
-
-test('fetch legacy artifacts', async () => {
-  let artifact = await fetchArtifactEE(TEST_USER_AGENT, 'isBase:True', '22.1.0', '11')
-  expect(artifact.id).toBe('DCECD1C1B0B5B8DBE0536E16000A5C74')
-  expect(artifact.checksum).toBe('4280782f6c7fcabe0ba707e8389cbfaf7bbe6b0cf634d309e6efcd1b172e3ce6')
-  artifact = await fetchArtifactEE(TEST_USER_AGENT, 'isBase:True', '22.1.0', '17')
-  expect(artifact.id).toBe('DCECD2068882A0E9E0536E16000A9504')
-  expect(artifact.checksum).toBe('e897add7d94bc456a61e6f927e831dff759efa3392a4b69c720dd3debc8f947d')
-
-  await expect(fetchArtifactEE(TEST_USER_AGENT, 'isBase:False', '22.1.0', '11')).rejects.toThrow(
-    'Found more than one GDS artifact'
-  )
-  await expect(fetchArtifactEE(TEST_USER_AGENT, 'isBase:True', '1.0.0', '11')).rejects.toThrow(
+  await expect(downloadGraalVMEE('invalid', '1.0.0', '11')).rejects.toThrow(
     'Unable to find JDK11-based GraalVM EE 1.0.0'
   )
-})
-
-test('errors when downloading legacy artifacts', async () => {
-  await expect(downloadGraalVMEELegacy('invalid', '22.1.0', '11')).rejects.toThrow(
-    'The provided "gds-token" was rejected (reason: "Invalid download token", opc-request-id: '
-  )
-  await expect(downloadGraalVMEELegacy('invalid', '1.0.0', '11')).rejects.toThrow(
-    'Unable to find JDK11-based GraalVM EE 1.0.0'
-  )
-  await expect(downloadGraalVMEELegacy('invalid', '22.1.0', '1')).rejects.toThrow(
+  await expect(downloadGraalVMEE('invalid', '22.1.0', '1')).rejects.toThrow(
     'Unable to find JDK1-based GraalVM EE 22.1.0'
   )
 })

__tests__/graalvm.test.ts

@@ -1,96 +0,0 @@
-import * as path from 'path'
-import * as graalvm from '../src/graalvm'
-import { expect, test } from '@jest/globals'
-import { getTaggedRelease } from '../src/utils'
-import { findGraalVMVersion, findHighestJavaVersion, findLatestEABuildDownloadUrl } from '../src/graalvm'
-import { GRAALVM_GH_USER, GRAALVM_RELEASES_REPO } from '../src/constants'
-
-process.env['RUNNER_TOOL_CACHE'] = path.join(__dirname, 'TOOL_CACHE')
-process.env['RUNNER_TEMP'] = path.join(__dirname, 'TEMP')
-
-test('request invalid version/javaVersion', async () => {
-  for (const combination of [
-    ['22.3.0', '7'],
-    ['22.3', '17'],
-    ['22.3', '7']
-  ]) {
-    let error = new Error('unexpected')
-    try {
-      await graalvm.setUpGraalVMRelease('', combination[0], combination[1])
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw new Error(`Unexpected non-Error: ${err}`)
-      }
-      error = err
-    }
-
-    expect(error).not.toBeUndefined()
-    expect(error.message).toContain('Failed to download')
-    expect(error.message).toContain('Are you sure version')
-  }
-})
-
-test('find version/javaVersion', async () => {
-  // Make sure the action can find the latest Java version for known major versions
-  for (const majorJavaVersion of ['17', '20']) {
-    await graalvm.findLatestGraalVMJDKCEJavaVersion(majorJavaVersion)
-  }
-
-  let error = new Error('unexpected')
-  try {
-    await graalvm.findLatestGraalVMJDKCEJavaVersion('11')
-    throw new Error('Should not find Java version for 11')
-  } catch (err) {
-    if (!(err instanceof Error)) {
-      throw new Error(`Unexpected non-Error: ${err}`)
-    }
-    error = err
-  }
-  expect(error.message).toContain('Unable to find the latest Java version for')
-
-  const latestRelease = await getTaggedRelease(GRAALVM_GH_USER, GRAALVM_RELEASES_REPO, 'vm-22.3.1')
-  const latestVersion = findGraalVMVersion(latestRelease)
-  expect(latestVersion).not.toBe('')
-  const latestJavaVersion = findHighestJavaVersion(latestRelease, latestVersion)
-  expect(latestJavaVersion).not.toBe('')
-
-  error = new Error('unexpected')
-  try {
-    const invalidRelease = { ...latestRelease, tag_name: 'invalid' }
-    findGraalVMVersion(invalidRelease)
-  } catch (err) {
-    if (!(err instanceof Error)) {
-      throw new Error(`Unexpected non-Error: ${err}`)
-    }
-    error = err
-  }
-  expect(error.message).toContain('Could not find latest GraalVM release:')
-
-  try {
-    findHighestJavaVersion(latestRelease, 'invalid')
-  } catch (err) {
-    if (!(err instanceof Error)) {
-      throw new Error(`Unexpected non-Error: ${err}`)
-    }
-    error = err
-  }
-  expect(error.message).toContain('Could not find highest Java version.')
-})
-
-test('find EA version/javaVersion', async () => {
-  const url22EA = await findLatestEABuildDownloadUrl('22-ea')
-  expect(url22EA).not.toBe('')
-  const urlLatestEA = await findLatestEABuildDownloadUrl('latest-ea')
-  expect(urlLatestEA).not.toBe('')
-
-  let error = new Error('unexpected')
-  try {
-    await findLatestEABuildDownloadUrl('8-ea')
-  } catch (err) {
-    if (!(err instanceof Error)) {
-      throw new Error(`Unexpected non-Error: ${err}`)
-    }
-    error = err
-  }
-  expect(error.message).toContain('Unable to resolve download URL for')
-})

__tests__/liberica.test.ts

@@ -1,108 +0,0 @@
-import * as liberica from '../src/liberica'
-import * as c from '../src/constants'
-import * as path from 'path'
-import * as semver from 'semver'
-import { expect, test } from '@jest/globals'
-
-process.env['RUNNER_TOOL_CACHE'] = path.join(__dirname, 'TOOL_CACHE')
-process.env['RUNNER_TEMP'] = path.join(__dirname, 'TEMP')
-
-/* eslint jest/expect-expect: ["error", { "assertFunctionNames": ["expect", "expectLatestToBe", "expectURL"] }] */
-
-test('find latest JDK version', async () => {
-  // Make sure the action can find the latest Java version for known major versions
-  await expectLatestToBe('11', atLeast('11.0.22+12'))
-  await expectLatestToBe('11.0.22', upToBuild('11.0.22+12'))
-  await expectLatestToBe('11.0.22+12', exactly('11.0.22+12'))
-
-  await expectLatestToBe('17', atLeast('17.0.10+13'))
-  await expectLatestToBe('17.0.10', upToBuild('17.0.10+13'))
-  await expectLatestToBe('17.0.10+13', exactly('17.0.10+13'))
-
-  await expectLatestToBe('21', atLeast('21.0.2+14'))
-  await expectLatestToBe('21.0.2', upToBuild('21.0.2+14'))
-  await expectLatestToBe('21.0.2+14', exactly('21.0.2+14'))
-
-  // Outdated major version
-  await expectLatestToFail('20')
-
-  // Outdated CPU versions
-  await expectLatestToFail('11.0.2') // should not resolve to 11.0.22
-  await expectLatestToFail('17.0.1') // should not resolve to 17.0.10
-  await expectLatestToFail('17.0.7+11')
-  await expectLatestToFail('21.0.0+8')
-  await expectLatestToFail('21.0.1')
-
-  // Incorrect build number
-  await expectLatestToFail('17.0.10+10')
-}, 30000)
-
-test('find asset URL', async () => {
-  await expectURL('11.0.22+12', '', 'bellsoft-liberica-vm-openjdk11.0.22')
-  await expectURL('17.0.10+13', 'jdk', 'bellsoft-liberica-vm-openjdk17.0.10')
-
-  if (!c.IS_LINUX) {
-    // This check can fail on Linux because there's no `jdk+fx` package for aarch64 and/or musl
-    await expectURL('21.0.2+14', 'jdk+fx', 'bellsoft-liberica-vm-full-openjdk21.0.2')
-  }
-}, 10000)
-
-type verifier = (version: string, major: number, minor: number, patch: number) => void
-
-function atLeast(expectedMinVersion: string): verifier {
-  const expectedMajor = semver.major(expectedMinVersion)
-  return function (version: string, major: number, _minor: number, _patch: number) {
-    expect(major).toBe(expectedMajor)
-    if (semver.compareBuild(version, expectedMinVersion) < 0) {
-      throw new Error(`Version ${version} is older than ${expectedMinVersion}`)
-    }
-  }
-}
-
-function upToBuild(expectedMinVersion: string): verifier {
-  const expectedMinor = semver.minor(expectedMinVersion)
-  const expectedPatch = semver.patch(expectedMinVersion)
-  const atLeastVerifier = atLeast(expectedMinVersion)
-  return function (version: string, major: number, minor: number, patch: number) {
-    atLeastVerifier(version, major, minor, patch)
-    expect(minor).toBe(expectedMinor)
-    expect(patch).toBe(expectedPatch)
-  }
-}
-
-function exactly(expectedVersion: string): verifier {
-  return function (version: string, _major: number, _minor: number, _patch: number) {
-    if (semver.compareBuild(version, expectedVersion) != 0) {
-      throw new Error(`Expected version ${expectedVersion} but got ${version}`)
-    }
-  }
-}
-
-async function expectLatestToBe(pattern: string, verify: verifier) {
-  const result = await liberica.findLatestLibericaJavaVersion(pattern)
-  expect(semver.valid(result)).toBeDefined()
-  const major = semver.major(result)
-  const minor = semver.minor(result)
-  const patch = semver.patch(result)
-  verify(result, major, minor, patch)
-}
-
-async function expectLatestToFail(pattern: string) {
-  try {
-    const result = await liberica.findLatestLibericaJavaVersion(pattern)
-    throw new Error(`findLatest(${pattern}) should have failed but returned ${result}`)
-  } catch (err) {
-    if (!(err instanceof Error)) {
-      throw new Error(`Unexpected non-Error: ${err}`)
-    }
-    expect(err.message).toContain(`Unable to find the latest version for JDK${pattern}`)
-  }
-}
-
-async function expectURL(javaVersion: string, javaPackage: string, expectedPrefix: string) {
-  const url = await liberica.findLibericaURL(javaVersion, javaPackage)
-  expect(url).toBeDefined()
-  const parts = url.split('/')
-  const file = parts[parts.length - 1]
-  expect(file.startsWith(expectedPrefix)).toBe(true)
-}

__tests__/mandrel.test.ts

@@ -1,75 +0,0 @@
-import * as path from 'path'
-import * as mandrel from '../src/mandrel'
-import { expect, test } from '@jest/globals'
-import { getLatestRelease } from '../src/utils'
-
-process.env['RUNNER_TOOL_CACHE'] = path.join(__dirname, 'TOOL_CACHE')
-process.env['RUNNER_TEMP'] = path.join(__dirname, 'TEMP')
-
-test('request invalid version/javaVersion combination', async () => {
-  for (const combination of [
-    ['mandrel-23.1.1.0-Final', '17'],
-    ['mandrel-23.0.2.1-Final', '21']
-  ]) {
-    let error = new Error('unexpected')
-    try {
-      await mandrel.setUpMandrel(combination[0], combination[1])
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw new Error(`Unexpected non-Error: ${err}`)
-      }
-      error = err
-    }
-
-    expect(error).not.toBeUndefined()
-    expect(error.message).toContain('Failed to download')
-    expect(error.message).toContain('Are you sure version')
-  }
-})
-test('request invalid version', async () => {
-  for (const combination of [
-    ['mandrel-23.1.1.0', '21'],
-    ['mandrel-23.0.2.1', '17']
-  ]) {
-    let error = new Error('unexpected')
-    try {
-      await mandrel.setUpMandrel(combination[0], combination[1])
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw new Error(`Unexpected non-Error: ${err}`)
-      }
-      error = err
-    }
-
-    expect(error).not.toBeUndefined()
-    expect(error.message).toContain('Failed to download')
-    expect(error.message).toContain('Are you sure version')
-  }
-})
-
-test('find latest', async () => {
-  // Make sure the action can find the latest Mandrel release
-  const latestRelease = await getLatestRelease(mandrel.MANDREL_REPO)
-  const tag_name = latestRelease.tag_name
-  expect(tag_name).toContain(mandrel.MANDREL_TAG_PREFIX)
-})
-
-test('get known latest Mandrel for specific JDK', async () => {
-  // Test deprecated versions that won't get updates anymore
-  for (const combination of [
-    ['11', '22.2.0.0-Final'],
-    ['20', '23.0.1.2-Final']
-  ]) {
-    const latest = await mandrel.getLatestMandrelReleaseUrl(combination[0])
-    expect(latest).toContain(`mandrel-java${combination[0]}`)
-    expect(latest).toContain(combination[1])
-  }
-})
-
-test('get latest Mandrel for specific JDK', async () => {
-  // Test supported versions
-  for (const javaVersion of ['17', '21']) {
-    const latest = await mandrel.getLatestMandrelReleaseUrl(javaVersion)
-    expect(latest).toContain(`mandrel-java${javaVersion}`)
-  }
-})

__tests__/msvc.test.ts

@@ -1,25 +0,0 @@
-import * as path from 'path'
-import { expect, test } from '@jest/globals'
-import { needsWindowsEnvironmentSetup } from '../src/msvc'
-import { VERSION_DEV, VERSION_LATEST } from '../src/constants'
-
-process.env['RUNNER_TOOL_CACHE'] = path.join(__dirname, 'TOOL_CACHE')
-process.env['RUNNER_TEMP'] = path.join(__dirname, 'TEMP')
-
-test('decide whether Window env must be set up for GraalVM for JDK', async () => {
-  for (const javaVersion of ['17', '17.0.8', '17.0', '21', '22', '22-ea', '23-ea', VERSION_DEV]) {
-    expect(needsWindowsEnvironmentSetup(javaVersion, '', true)).toBe(false)
-  }
-})
-
-test('decide whether Window env must be set up for legacy GraalVM', async () => {
-  for (const combination of [
-    ['7', '22.3.0'],
-    ['17', '22.3'],
-    ['7', '22.3'],
-    ['7', VERSION_DEV],
-    ['17', VERSION_LATEST]
-  ]) {
-    expect(needsWindowsEnvironmentSetup(combination[0], combination[1], false)).toBe(combination[1] !== VERSION_DEV)
-  }
-})

__tests__/sbom.test.ts

@@ -1,294 +0,0 @@
-import * as c from '../src/constants'
-import { setUpSBOMSupport, processSBOM } from '../src/features/sbom'
-import * as core from '@actions/core'
-import * as github from '@actions/github'
-import * as glob from '@actions/glob'
-import { join } from 'path'
-import { tmpdir } from 'os'
-import { mkdtempSync, writeFileSync, rmSync } from 'fs'
-
-jest.mock('@actions/glob')
-jest.mock('@actions/github', () => ({
-  getOctokit: jest.fn(() => ({
-    request: jest.fn().mockResolvedValue(undefined)
-  })),
-  context: {
-    repo: {
-      owner: 'test-owner',
-      repo: 'test-repo'
-    },
-    sha: 'test-sha',
-    ref: 'test-ref',
-    workflow: 'test-workflow',
-    job: 'test-job',
-    runId: '12345'
-  }
-}))
-
-function mockFindSBOM(files: string[]) {
-  const mockCreate = jest.fn().mockResolvedValue({
-    glob: jest.fn().mockResolvedValue(files)
-  })
-  ;(glob.create as jest.Mock).mockImplementation(mockCreate)
-}
-
-// Mocks the GitHub dependency submission API return value
-// 'undefined' is treated as a successful request
-function mockGithubAPIReturnValue(returnValue: Error | undefined = undefined) {
-  const mockOctokit = {
-    request:
-      returnValue === undefined ? jest.fn().mockResolvedValue(returnValue) : jest.fn().mockRejectedValue(returnValue)
-  }
-  ;(github.getOctokit as jest.Mock).mockReturnValue(mockOctokit)
-  return mockOctokit
-}
-
-describe('sbom feature', () => {
-  let spyInfo: jest.SpyInstance<void, Parameters<typeof core.info>>
-  let spyWarning: jest.SpyInstance<void, Parameters<typeof core.warning>>
-  let spyExportVariable: jest.SpyInstance<void, Parameters<typeof core.exportVariable>>
-  let workspace: string
-  let originalEnv: NodeJS.ProcessEnv
-  const javaVersion = '24.0.0'
-  const distribution = c.DISTRIBUTION_GRAALVM
-
-  beforeEach(() => {
-    originalEnv = process.env
-
-    process.env = {
-      ...process.env,
-      GITHUB_REPOSITORY: 'test-owner/test-repo',
-      GITHUB_TOKEN: 'fake-token'
-    }
-
-    workspace = mkdtempSync(join(tmpdir(), 'setup-graalvm-sbom-'))
-    mockGithubAPIReturnValue()
-
-    spyInfo = jest.spyOn(core, 'info').mockImplementation(() => null)
-    spyWarning = jest.spyOn(core, 'warning').mockImplementation(() => null)
-    spyExportVariable = jest.spyOn(core, 'exportVariable').mockImplementation(() => null)
-    jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
-      if (name === 'native-image-enable-sbom') {
-        return 'true'
-      }
-      if (name === 'github-token') {
-        return 'fake-token'
-      }
-      return ''
-    })
-  })
-
-  afterEach(() => {
-    process.env = originalEnv
-    jest.clearAllMocks()
-    spyInfo.mockRestore()
-    spyWarning.mockRestore()
-    spyExportVariable.mockRestore()
-    rmSync(workspace, { recursive: true, force: true })
-  })
-
-  describe('setup', () => {
-    it('should throw an error when the distribution is not Oracle GraalVM', () => {
-      const not_supported_distributions = [
-        c.DISTRIBUTION_GRAALVM_COMMUNITY,
-        c.DISTRIBUTION_MANDREL,
-        c.DISTRIBUTION_LIBERICA,
-        ''
-      ]
-      for (const distribution of not_supported_distributions) {
-        expect(() => setUpSBOMSupport(javaVersion, distribution)).toThrow()
-      }
-    })
-
-    it('should throw an error when the java-version is not supported', () => {
-      const not_supported_versions = ['23', '23-ea', '21.0.3', 'dev', '17', '']
-      for (const version of not_supported_versions) {
-        expect(() => setUpSBOMSupport(version, distribution)).toThrow()
-      }
-    })
-
-    it('should not throw an error when the java-version is supported', () => {
-      const supported_versions = ['24', '24-ea', '24.0.2', 'latest-ea']
-      for (const version of supported_versions) {
-        expect(() => setUpSBOMSupport(version, distribution)).not.toThrow()
-      }
-    })
-
-    it('should set the SBOM option when activated', () => {
-      setUpSBOMSupport(javaVersion, distribution)
-
-      expect(spyExportVariable).toHaveBeenCalledWith(
-        c.NATIVE_IMAGE_OPTIONS_ENV,
-        expect.stringContaining('--enable-sbom=export')
-      )
-      expect(spyInfo).toHaveBeenCalledWith('Enabled SBOM generation for Native Image build')
-      expect(spyWarning).not.toHaveBeenCalled()
-    })
-
-    it('should not set the SBOM option when not activated', () => {
-      jest.spyOn(core, 'getInput').mockReturnValue('false')
-      setUpSBOMSupport(javaVersion, distribution)
-
-      expect(spyExportVariable).not.toHaveBeenCalled()
-      expect(spyInfo).not.toHaveBeenCalled()
-      expect(spyWarning).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('process', () => {
-    async function setUpAndProcessSBOM(sbom: object): Promise<void> {
-      setUpSBOMSupport(javaVersion, distribution)
-      spyInfo.mockClear()
-
-      // Mock 'native-image' invocation by creating the SBOM file
-      const sbomPath = join(workspace, 'test.sbom.json')
-      writeFileSync(sbomPath, JSON.stringify(sbom, null, 2))
-
-      mockFindSBOM([sbomPath])
-      jest.spyOn(core, 'getState').mockReturnValue(javaVersion)
-
-      await processSBOM()
-    }
-
-    const sampleSBOM = {
-      bomFormat: 'CycloneDX',
-      specVersion: '1.5',
-      version: 1,
-      serialNumber: 'urn:uuid:52c977f8-6d04-3c07-8826-597a036d61a6',
-      components: [
-        {
-          type: 'library',
-          group: 'org.json',
-          name: 'json',
-          version: '20241224',
-          purl: 'pkg:maven/org.json/json@20241224',
-          'bom-ref': 'pkg:maven/org.json/json@20241224',
-          properties: [
-            {
-              name: 'syft:cpe23',
-              value: 'cpe:2.3:a:json:json:20241224:*:*:*:*:*:*:*'
-            }
-          ]
-        },
-        {
-          type: 'library',
-          group: 'com.oracle',
-          name: 'main-test-app',
-          version: '1.0-SNAPSHOT',
-          purl: 'pkg:maven/com.oracle/main-test-app@1.0-SNAPSHOT',
-          'bom-ref': 'pkg:maven/com.oracle/main-test-app@1.0-SNAPSHOT'
-        }
-      ],
-      dependencies: [
-        {
-          ref: 'pkg:maven/com.oracle/main-test-app@1.0-SNAPSHOT',
-          dependsOn: ['pkg:maven/org.json/json@20241224']
-        },
-        {
-          ref: 'pkg:maven/org.json/json@20241224',
-          dependsOn: []
-        }
-      ]
-    }
-
-    it('should throw an error if setUpSBOMSupport was not called before processSBOM', async () => {
-      await expect(processSBOM()).rejects.toThrow('setUpSBOMSupport must be called before processSBOM')
-    })
-
-    it('should process SBOM and display components', async () => {
-      await setUpAndProcessSBOM(sampleSBOM)
-
-      expect(spyInfo).toHaveBeenCalledWith('Found SBOM: ' + join(workspace, 'test.sbom.json'))
-      expect(spyInfo).toHaveBeenCalledWith('=== SBOM Content ===')
-      expect(spyInfo).toHaveBeenCalledWith('- pkg:maven/org.json/json@20241224')
-      expect(spyInfo).toHaveBeenCalledWith('- pkg:maven/com.oracle/main-test-app@1.0-SNAPSHOT')
-      expect(spyInfo).toHaveBeenCalledWith('   depends on: pkg:maven/org.json/json@20241224')
-      expect(spyWarning).not.toHaveBeenCalled()
-    })
-
-    it('should handle components without purl', async () => {
-      const sbomWithoutPurl = {
-        ...sampleSBOM,
-        components: [
-          {
-            type: 'library',
-            name: 'no-purl-package',
-            version: '1.0.0',
-            'bom-ref': 'no-purl-package@1.0.0'
-          }
-        ]
-      }
-      await setUpAndProcessSBOM(sbomWithoutPurl)
-
-      expect(spyInfo).toHaveBeenCalledWith('=== SBOM Content ===')
-      expect(spyInfo).toHaveBeenCalledWith('- no-purl-package@1.0.0')
-      expect(spyWarning).not.toHaveBeenCalled()
-    })
-
-    it('should handle missing SBOM file', async () => {
-      setUpSBOMSupport(javaVersion, distribution)
-      spyInfo.mockClear()
-
-      mockFindSBOM([])
-
-      await expect(processSBOM()).rejects.toBeInstanceOf(Error)
-    })
-
-    it('should throw when JSON contains an invalid SBOM', async () => {
-      const invalidSBOM = {
-        'out-of-spec-field': {}
-      }
-      let error
-      try {
-        await setUpAndProcessSBOM(invalidSBOM)
-        throw new Error('Expected an error since invalid JSON was passed')
-      } catch (e) {
-        error = e
-      } finally {
-        expect(error).toBeInstanceOf(Error)
-      }
-    })
-
-    it('should submit dependencies when processing valid SBOM', async () => {
-      const mockOctokit = mockGithubAPIReturnValue(undefined)
-      await setUpAndProcessSBOM(sampleSBOM)
-
-      expect(mockOctokit.request).toHaveBeenCalledWith(
-        'POST /repos/{owner}/{repo}/dependency-graph/snapshots',
-        expect.objectContaining({
-          owner: 'test-owner',
-          repo: 'test-repo',
-          version: expect.any(Number),
-          sha: 'test-sha',
-          ref: 'test-ref',
-          job: expect.objectContaining({
-            correlator: 'test-workflow_test-job',
-            id: '12345'
-          }),
-          manifests: expect.objectContaining({
-            'test.sbom.json': expect.objectContaining({
-              name: 'test.sbom.json',
-              resolved: expect.objectContaining({
-                json: expect.objectContaining({
-                  package_url: 'pkg:maven/org.json/json@20241224',
-                  dependencies: []
-                }),
-                'main-test-app': expect.objectContaining({
-                  package_url: 'pkg:maven/com.oracle/main-test-app@1.0-SNAPSHOT',
-                  dependencies: ['pkg:maven/org.json/json@20241224']
-                })
-              })
-            })
-          })
-        })
-      )
-      expect(spyInfo).toHaveBeenCalledWith('Dependency snapshot submitted successfully.')
-    })
-
-    it('should handle GitHub API submission errors gracefully', async () => {
-      mockGithubAPIReturnValue(new Error('API submission failed'))
-
-      await expect(setUpAndProcessSBOM(sampleSBOM)).rejects.toBeInstanceOf(Error)
-    })
-  })
-})

__tests__/sbom/main-test-app/pom.xml

@@ -1,54 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>com.oracle</groupId>
-    <artifactId>main-test-app</artifactId>
-    <version>1.0.0</version>
-
-    <properties>
-        <maven.compiler.source>17</maven.compiler.source>
-        <maven.compiler.target>17</maven.compiler.target>
-    </properties>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.json</groupId>
-            <artifactId>json</artifactId>
-            <version>20241224</version>
-        </dependency>
-    </dependencies>
-
-    <profiles>
-        <profile>
-            <id>native</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.graalvm.buildtools</groupId>
-                        <artifactId>native-maven-plugin</artifactId>
-                        <version>0.10.3</version>
-                        <executions>
-                            <execution>
-                                <goals>
-                                    <goal>compile-no-fork</goal>
-                                </goals>
-                                <phase>package</phase>
-                            </execution>
-                        </executions>
-                        <configuration>
-                            <mainClass>com.oracle.sbom.SBOMTestApplication</mainClass>
-                            <buildArgs>
-                                <buildArg>-Ob</buildArg>
-                                <buildArg>--no-fallback</buildArg>
-                                <buildArg>-H:+ReportExceptionStackTraces</buildArg>
-                            </buildArgs>
-                        </configuration>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-    </profiles>
-</project>

__tests__/sbom/main-test-app/src/main/java/com/oracle/sbom/SBOMTestApplication.java

@@ -1,12 +0,0 @@
-package com.oracle.sbom;
-
-import org.json.JSONObject;
-
-public class SBOMTestApplication {
-    public static void main(String argv[]) {
-        JSONObject jo = new JSONObject();
-        jo.put("lorem", "ipsum");
-        jo.put("dolor", "sit amet");
-        System.out.println(jo);
-    }
-}

__tests__/sbom/main-test-app/verify-sbom.cmd

@@ -1,14 +0,0 @@
-@echo off
-set "SCRIPT_DIR=%~dp0"
-
-for %%p in (
-    "\"pkg:maven/org.json/json@20241224\""
-    "\"main-test-app\""
-    "\"svm\""
-    "\"nativeimage\""
-) do (
-    echo Checking for %%p
-    findstr /c:%%p "%SCRIPT_DIR%target\main-test-app.sbom.json" || exit /b 1
-)
-
-echo SBOM was successfully generated and contained the expected components

__tests__/sbom/main-test-app/verify-sbom.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-required_patterns=(
-    '"pkg:maven/org.json/json@20241224"'
-    '"main-test-app"'
-    '"svm"'
-    '"nativeimage"'
-)
-
-for pattern in "${required_patterns[@]}"; do
-    echo "Checking for $pattern"
-    if ! grep -q "$pattern" "$script_dir/target/main-test-app.sbom.json"; then
-        echo "Pattern not found: $pattern"
-        exit 1
-    fi
-done
-
-echo "SBOM was successfully generated and contained the expected components"

__tests__/utils.test.ts

@@ -1,33 +0,0 @@
-import { expect, test } from '@jest/globals'
-import { toSemVer } from '../src/utils'
-
-test('convert version', async () => {
-  for (const inputAndExpectedOutput of [
-    ['22', '22.0.0'],
-    ['22.0', '22.0.0'],
-    ['22.0.0', '22.0.0'],
-    ['22.0.0.2', '22.0.0-2'],
-    ['22-ea', '22.0.0-ea'],
-    ['22.0-ea', '22.0.0-ea'],
-    ['22.0.0-ea', '22.0.0-ea']
-  ]) {
-    expect(toSemVer(inputAndExpectedOutput[0])).toBe(inputAndExpectedOutput[1])
-  }
-})
-
-test('convert invalid version', async () => {
-  for (const input of ['dev', 'abc', 'a.b.c']) {
-    let error = new Error('unexpected')
-    try {
-      toSemVer(input)
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw new Error(`Unexpected non-Error: ${err}`)
-      }
-      error = err
-    }
-
-    expect(error).not.toBeUndefined()
-    expect(error.message).toContain('Unable to convert')
-  }
-})

action.yml

@@ -1,30 +1,27 @@
 name: 'GitHub Action for GraalVM'
-description: 'Set up a specific version of the GraalVM JDK and add the command-line tools to the PATH'
+description: 'Set up a specific version of GraalVM Community Edition (CE) or Enterprise Edition (EE)'
 author: 'GraalVM Community'
 branding:
-  icon: 'terminal'
+  icon: 'terminal'  
   color: 'blue'
 inputs:
+  version:
+    required: true
+    description: 'GraalVM version (release, latest, dev).'
+  gds-token:
+    required: false
+    description: 'Download token for the GraalVM Download Service. If provided, the action will set up GraalVM Enterprise Edition.'
   java-version:
     required: true
-    description: 'Java version. See examples of supported syntax in the README file.'
-  java-package:
-    description: 'The package type (jdk or jdk+fx). Currently applies to Liberica only.'
-    required: false
-    default: 'jdk'
-  distribution:
-    description: 'GraalVM distribution. See the list of available distributions in the README file.'
-    required: false
-    default: ''
+    description: 'Java version (11 or 17, 8 or 16 for older releases).'
   components:
     required: false
     description: 'Comma-separated list of GraalVM components to be installed.'
     default: ''
   github-token:
     required: false
-    description:
-      'Set it to secrets.GITHUB_TOKEN to increase rate limits when accessing the GitHub API. Defaults to github.token.'
-    default: ${{ github.token }}
+    description: 'Set it to secrets.GITHUB_TOKEN to increase rate limits when accessing the GitHub API.'
+    default: ''
   set-java-home:
     required: false
     description: 'Set $JAVA_HOME to the GraalVM installation. Default: true.'
@@ -48,30 +45,8 @@ inputs:
     required: false
     description: 'Post a comment containing a Native Image build report on pull requests.'
     default: 'false'
-  native-image-pr-reports-update-existing:
-    required: false
-    description:
-      'Instead of posting another comment, update an existing PR comment with the latest Native Image build report.'
-    default: 'false'
-  native-image-enable-sbom:
-    required: false
-    description:
-      'Automatically generate an SBOM and submit it to the GitHub dependency submission API for vulnerability and
-      dependency tracking.'
-    default: 'false'
-  version:
-    required: false
-    description: 'GraalVM version (release, latest, dev).'
-    default: ''
-  gds-token:
-    required: false
-    description:
-      'Download token for the GraalVM Download Service. If provided, the action will set up GraalVM Enterprise Edition.'
-outputs:
-  cache-hit:
-    description: 'A boolean value to indicate an exact match was found for the primary key'
 runs:
-  using: 'node20'
+  using: 'node16'
   main: 'dist/main/index.js'
   post: 'dist/cleanup/index.js'
   post-if: 'success()'

eslint.config.mjs

@@ -1,82 +0,0 @@
-// See: https://eslint.org/docs/latest/use/configure/configuration-files
-
-import { fixupPluginRules } from '@eslint/compat'
-import { FlatCompat } from '@eslint/eslintrc'
-import js from '@eslint/js'
-import typescriptEslint from '@typescript-eslint/eslint-plugin'
-import tsParser from '@typescript-eslint/parser'
-import _import from 'eslint-plugin-import'
-import jest from 'eslint-plugin-jest'
-import prettier from 'eslint-plugin-prettier'
-import globals from 'globals'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all
-})
-
-export default [
-  {
-    ignores: ['**/coverage', '**/dist', '**/linter', '**/node_modules']
-  },
-  ...compat.extends(
-    'eslint:recommended',
-    'plugin:@typescript-eslint/eslint-recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:jest/recommended',
-    'plugin:prettier/recommended'
-  ),
-  {
-    plugins: {
-      import: fixupPluginRules(_import),
-      jest,
-      prettier,
-      '@typescript-eslint': typescriptEslint
-    },
-
-    languageOptions: {
-      globals: {
-        ...globals.node,
-        ...globals.jest,
-        Atomics: 'readonly',
-        SharedArrayBuffer: 'readonly'
-      },
-
-      parser: tsParser,
-      ecmaVersion: 2023,
-      sourceType: 'module',
-
-      parserOptions: {
-        project: ['tsconfig.eslint.json'],
-        tsconfigRootDir: '.'
-      }
-    },
-
-    settings: {
-      'import/resolver': {
-        typescript: {
-          alwaysTryTypes: true,
-          project: 'tsconfig.eslint.json'
-        }
-      }
-    },
-
-    rules: {
-      camelcase: 'off',
-      'eslint-comments/no-use': 'off',
-      'eslint-comments/no-unused-disable': 'off',
-      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
-      'i18n-text/no-en': 'off',
-      'import/no-namespace': 'off',
-      'no-console': 'off',
-      'no-shadow': 'off',
-      'no-unused-vars': 'off',
-      'prettier/prettier': 'error'
-    }
-  }
-]

jest.config.js

@@ -1,14 +1,9 @@
 module.exports = {
   clearMocks: true,
-  collectCoverage: true,
-  collectCoverageFrom: ['./src/**'],
-  coverageDirectory: './coverage',
-  coveragePathIgnorePatterns: ['/node_modules/', '/dist/'],
-  coverageReporters: ['json-summary', 'text', 'lcov'],
   moduleFileExtensions: ['js', 'ts'],
   testMatch: ['**/*.test.ts'],
   transform: {
     '^.+\\.ts$': 'ts-jest'
   },
   verbose: true
-}
+}

package.json

@@ -1,75 +1,58 @@
 {
   "name": "setup-graalvm",
-  "author": "GraalVM Community",
-  "description": "GitHub Action for GraalVM",
-  "version": "1.3.3",
+  "version": "1.0.9",
   "private": true,
+  "description": "GitHub Action for GraalVM",
+  "main": "lib/main.js",
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write '**/*.ts'",
+    "format-check": "prettier --check '**/*.ts'",
+    "lint": "eslint src/**/*.ts",
+    "package": "ncc build -o dist/main src/main.ts && ncc build -o dist/cleanup src/cleanup.ts",
+    "test": "jest",
+    "all": "npm run build && npm run format && npm run lint && npm run package && npm test"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/graalvm/setup-graalvm.git"
   },
-  "bugs": {
-    "url": "https://github.com/graalvm/setup-graalvm/issues"
-  },
   "keywords": [
     "graalvm",
     "native image",
     "actions",
     "setup"
   ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "bundle": "npm run format:write && npm run package",
-    "format:write": "npx prettier --write .",
-    "format:check": "npx prettier --check .",
-    "lint": "npx eslint .",
-    "package": "npm run package:main && npm run package:cleanup",
-    "package:main": "npx ncc build src/main.ts -o dist/main",
-    "package:cleanup": "npx ncc build src/cleanup.ts -o dist/cleanup",
-    "test": "npx jest",
-    "all": "npm run format:write && npm run lint && npm run test && npm run package"
-  },
+  "author": "GraalVM Community",
   "license": "UPL",
   "dependencies": {
-    "@actions/cache": "^4.0.3",
-    "@actions/core": "^1.11.1",
-    "@actions/exec": "^1.1.1",
-    "@actions/github": "^6.0.0",
-    "@actions/glob": "^0.5.0",
-    "@actions/http-client": "^2.2.3",
-    "@actions/io": "^1.1.3",
-    "@actions/tool-cache": "^2.0.2",
-    "@octokit/core": "^5.2.0",
-    "@octokit/types": "^13.10.0",
-    "@github/dependency-submission-toolkit": "^2.0.5",
-    "semver": "^7.7.1",
-    "uuid": "^11.1.0"
+    "@actions/cache": "^3.0.4",
+    "@actions/core": "^1.10.0",
+    "@actions/exec": "^1.1.0",
+    "@actions/github": "^5.1.1",
+    "@actions/glob": "^0.3.0",
+    "@actions/http-client": "^1.0.11",
+    "@actions/io": "^1.1.1",
+    "@actions/tool-cache": "^1.7.1",
+    "@octokit/core": "^3.5.1",
+    "@octokit/types": "^6.34.0",
+    "semver": "^7.3.8",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.2.8",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^20.17.30",
-    "@types/semver": "^7.7.0",
-    "@types/uuid": "^10.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.29.0",
-    "@typescript-eslint/parser": "^8.29.0",
-    "@vercel/ncc": "^0.38.3",
-    "eslint": "^9.23.0",
-    "eslint-config-prettier": "^10.1.1",
-    "eslint-import-resolver-typescript": "^4.3.1",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-jest": "^28.10.0",
-    "eslint-plugin-jsonc": "^2.20.0",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^5.2.5",
-    "jest": "^29.7.0",
+    "@types/jest": "^27.5.2",
+    "@types/node": "^17.0.6",
+    "@types/semver": "^7.3.13",
+    "@types/uuid": "^8.3.4",
+    "@typescript-eslint/parser": "^5.8.1",
+    "@vercel/ncc": "^0.33.4",
+    "eslint": "^8.6.0",
+    "eslint-plugin-github": "^4.3.5",
+    "eslint-plugin-jest": "^25.3.4",
+    "jest": "^27.4.5",
     "js-yaml": "^4.1.0",
-    "prettier": "^3.5.3",
-    "prettier-eslint": "^16.3.0",
-    "ts-jest": "^29.3.1",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.2"
+    "prettier": "2.5.1",
+    "ts-jest": "^27.1.2",
+    "typescript": "^4.2.3"
   }
 }

src/cleanup.ts

@@ -26,9 +26,8 @@
 
 import * as core from '@actions/core'
 import * as constants from './constants'
-import { save } from './features/cache'
-import { generateReports } from './features/reports'
-import { processSBOM } from './features/sbom'
+import {save} from './features/cache'
+import {generateReports} from './features/reports'
 
 /**
  * Check given input and run a save process for the specified package manager
@@ -45,10 +44,11 @@ async function saveCache(): Promise<void> {
  * @param promise the promise to ignore error from
  * @returns Promise that will ignore error reported by the given promise
  */
-async function ignoreErrors(promise: Promise<void>): Promise<unknown> {
-  return new Promise((resolve) => {
+async function ignoreError(promise: Promise<void>): Promise<unknown> {
+  /* eslint-disable github/no-then */
+  return new Promise(resolve => {
     promise
-      .catch((error) => {
+      .catch(error => {
         core.warning(error)
         resolve(void 0)
       })
@@ -57,9 +57,13 @@ async function ignoreErrors(promise: Promise<void>): Promise<unknown> {
 }
 
 export async function run(): Promise<void> {
-  await ignoreErrors(generateReports())
-  await ignoreErrors(processSBOM())
-  await ignoreErrors(saveCache())
+  generateReports()
+  await ignoreError(saveCache())
 }
 
-run()
+if (require.main === module) {
+  run()
+} else {
+  // https://nodejs.org/api/modules.html#modules_accessing_the_main_module
+  core.info('the script is loaded as a module, so skipping the execution')
+}

src/constants.ts

@@ -1,12 +1,8 @@
 import * as otypes from '@octokit/types'
 
-export const ACTION_VERSION = '1.3.3'
-
 export const INPUT_VERSION = 'version'
 export const INPUT_GDS_TOKEN = 'gds-token'
 export const INPUT_JAVA_VERSION = 'java-version'
-export const INPUT_JAVA_PACKAGE = 'java-package'
-export const INPUT_DISTRIBUTION = 'distribution'
 export const INPUT_COMPONENTS = 'components'
 export const INPUT_GITHUB_TOKEN = 'github-token'
 export const INPUT_SET_JAVA_HOME = 'set-java-home'
@@ -14,31 +10,18 @@ export const INPUT_CACHE = 'cache'
 export const INPUT_CHECK_FOR_UPDATES = 'check-for-updates'
 export const INPUT_NI_MUSL = 'native-image-musl'
 
-export const NATIVE_IMAGE_OPTIONS_ENV = 'NATIVE_IMAGE_OPTIONS'
-
 export const IS_LINUX = process.platform === 'linux'
 export const IS_MACOS = process.platform === 'darwin'
 export const IS_WINDOWS = process.platform === 'win32'
 
-export const EXECUTABLE_SUFFIX = IS_WINDOWS ? '.exe' : ''
-
-export const DISTRIBUTION_GRAALVM = 'graalvm'
-export const DISTRIBUTION_GRAALVM_COMMUNITY = 'graalvm-community'
-export const DISTRIBUTION_MANDREL = 'mandrel'
-export const DISTRIBUTION_LIBERICA = 'liberica'
-
 export const VERSION_DEV = 'dev'
 export const VERSION_LATEST = 'latest'
 
-export const JDK_ARCH = determineJDKArchitecture()
-export const JDK_PLATFORM = determineJDKPlatform()
-export const JDK_HOME_SUFFIX = IS_MACOS ? '/Contents/Home' : ''
-
 export const GRAALVM_ARCH = determineGraalVMArchitecture()
 export const GRAALVM_FILE_EXTENSION = IS_WINDOWS ? '.zip' : '.tar.gz'
 export const GRAALVM_GH_USER = 'graalvm'
 export const GRAALVM_PLATFORM = IS_WINDOWS ? 'windows' : process.platform
-export const GRAALVM_RELEASES_REPO = 'graalvm-ce-builds'
+export const JDK_HOME_SUFFIX = IS_MACOS ? '/Contents/Home' : ''
 
 export const MANDREL_NAMESPACE = 'mandrel-'
 
@@ -48,62 +31,8 @@ export const GDS_GRAALVM_PRODUCT_ID = 'D53FAE8052773FFAE0530F15000AA6C6'
 export const ENV_GITHUB_EVENT_NAME = 'GITHUB_EVENT_NAME'
 export const EVENT_NAME_PULL_REQUEST = 'pull_request'
 
-export const ERROR_REQUEST = 'Please file an issue at: https://github.com/graalvm/setup-graalvm/issues.'
-
-export const ERROR_HINT =
-  'If you think this is a mistake, please file an issue at: https://github.com/graalvm/setup-graalvm/issues.'
-
-export type LatestReleaseResponse = otypes.Endpoints['GET /repos/{owner}/{repo}/releases/latest']['response']
-
-export type MatchingRefsResponse = otypes.Endpoints['GET /repos/{owner}/{repo}/git/matching-refs/{ref}']['response']
-
-export type ReleasesResponse = otypes.Endpoints['GET /repos/{owner}/{repo}/releases']['response']
-
-export type ContentsResponse = otypes.Endpoints['GET /repos/{owner}/{repo}/contents/{path}']['response']
-
-export interface OracleGraalVMEAFile {
-  filename: string
-  arch: 'aarch64' | 'x64'
-  platform: 'darwin' | 'linux' | 'windows'
-}
-
-export interface OracleGraalVMEAVersion {
-  version: string
-  latest?: boolean
-  download_base_url: string
-  files: OracleGraalVMEAFile[]
-}
-
-function determineJDKArchitecture(): string {
-  switch (process.arch) {
-    case 'x64': {
-      return 'x64'
-    }
-    case 'arm64': {
-      return 'aarch64'
-    }
-    default: {
-      throw new Error(`Unsupported architecture: ${process.arch}`)
-    }
-  }
-}
-
-function determineJDKPlatform(): string {
-  switch (process.platform) {
-    case 'linux': {
-      return 'linux'
-    }
-    case 'darwin': {
-      return 'macos'
-    }
-    case 'win32': {
-      return 'windows'
-    }
-    default: {
-      throw new Error(`Unsupported platform: ${process.platform}`)
-    }
-  }
-}
+export type LatestReleaseResponse =
+  otypes.Endpoints['GET /repos/{owner}/{repo}/releases/latest']['response']
 
 function determineGraalVMArchitecture(): string {
   switch (process.arch) {

src/dependencies.ts

@@ -1,6 +1,6 @@
 import * as core from '@actions/core'
-import { GRAALVM_PLATFORM } from './constants'
-import { exec } from './utils'
+import {GRAALVM_PLATFORM} from './constants'
+import {exec} from './utils'
 
 const APT_GET_INSTALL_BASE = 'sudo apt-get -y --no-upgrade install'
 const COMPONENT_TO_DEPS = new Map<string, Map<string, string>>([
@@ -9,7 +9,10 @@ const COMPONENT_TO_DEPS = new Map<string, Map<string, string>>([
     new Map<string, string>([
       ['nodejs', `${APT_GET_INSTALL_BASE} g++ make`],
       ['ruby', `${APT_GET_INSTALL_BASE} make gcc libssl-dev libz-dev`],
-      ['R', `${APT_GET_INSTALL_BASE} libgomp1 build-essential gfortran libxml2 libc++-dev`]
+      [
+        'R',
+        `${APT_GET_INSTALL_BASE} libgomp1 build-essential gfortran libxml2 libc++-dev`
+      ]
     ])
   ],
   ['darwin', new Map<string, string>([['ruby', 'brew install openssl']])]

src/features/cache.ts

@@ -26,7 +26,7 @@
  * @fileoverview this file provides methods handling dependency cache
  */
 
-import { join } from 'path'
+import {join} from 'path'
 import os from 'os'
 import * as cache from '@actions/cache'
 import * as core from '@actions/core'
@@ -53,9 +53,17 @@ const supportedPackageManager: PackageManager[] = [
   },
   {
     id: 'gradle',
-    path: [join(os.homedir(), '.gradle', 'caches'), join(os.homedir(), '.gradle', 'wrapper')],
+    path: [
+      join(os.homedir(), '.gradle', 'caches'),
+      join(os.homedir(), '.gradle', 'wrapper')
+    ],
     // https://github.com/actions/cache/blob/0638051e9af2c23d10bb70fa9beffcad6cff9ce3/examples.md#java---gradle
-    pattern: ['**/*.gradle*', '**/gradle-wrapper.properties', 'buildSrc/**/Versions.kt', 'buildSrc/**/Dependencies.kt']
+    pattern: [
+      '**/*.gradle*',
+      '**/gradle-wrapper.properties',
+      'buildSrc/**/Versions.kt',
+      'buildSrc/**/Dependencies.kt'
+    ]
   },
   {
     id: 'sbt',
@@ -68,18 +76,23 @@ const supportedPackageManager: PackageManager[] = [
       `!${join(os.homedir(), '.sbt', '*.lock')}`,
       `!${join(os.homedir(), '**', 'ivydata-*.properties')}`
     ],
-    pattern: ['**/*.sbt', '**/project/build.properties', '**/project/**.{scala,sbt}']
+    pattern: [
+      '**/*.sbt',
+      '**/project/build.properties',
+      '**/project/**.{scala,sbt}'
+    ]
   }
 ]
 
 function getCoursierCachePath(): string {
   if (os.type() === 'Linux') return join(os.homedir(), '.cache', 'coursier')
-  if (os.type() === 'Darwin') return join(os.homedir(), 'Library', 'Caches', 'Coursier')
+  if (os.type() === 'Darwin')
+    return join(os.homedir(), 'Library', 'Caches', 'Coursier')
   return join(os.homedir(), 'AppData', 'Local', 'Coursier', 'Cache')
 }
 
 function findPackageManager(id: string): PackageManager {
-  const packageManager = supportedPackageManager.find((pm) => pm.id === id)
+  const packageManager = supportedPackageManager.find(pm => pm.id === id)
   if (packageManager === undefined) {
     throw new Error(`unknown package manager specified: ${id}`)
   }
@@ -92,7 +105,9 @@ function findPackageManager(id: string): PackageManager {
  * If there is no file matched to {@link PackageManager.path}, the generated key ends with a dash (-).
  * @see {@link https://docs.github.com/en/actions/guides/caching-dependencies-to-speed-up-workflows#matching-a-cache-key|spec of cache key}
  */
-async function computeCacheKey(packageManager: PackageManager): Promise<string> {
+async function computeCacheKey(
+  packageManager: PackageManager
+): Promise<string> {
   const hash = await glob.hashFiles(packageManager.pattern.join('\n'))
   return `${CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-${packageManager.id}-${hash}`
 }
@@ -143,17 +158,15 @@ export async function save(id: string): Promise<void> {
     return
   } else if (matchedKey === primaryKey) {
     // no change in target directories
-    core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`)
+    core.info(
+      `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
+    )
     return
   }
   try {
     await cache.saveCache(packageManager.path, primaryKey)
     core.info(`Cache saved with the key: ${primaryKey}`)
   } catch (error) {
-    if (!(error instanceof Error)) {
-      core.info(`Not an Error: ${error}`)
-      throw error
-    }
     if (error.name === cache.ReserveCacheError.name) {
       core.info(error.message)
     } else {
@@ -173,8 +186,14 @@ export async function save(id: string): Promise<void> {
  * @returns true if the given error seems related to the {@link https://github.com/actions/cache/issues/454|running Gradle Daemon issue}.
  * @see {@link https://github.com/actions/cache/issues/454#issuecomment-840493935|why --no-daemon is necessary}
  */
-function isProbablyGradleDaemonProblem(packageManager: PackageManager, error: Error): boolean {
-  if (packageManager.id !== 'gradle' || process.env['RUNNER_OS'] !== 'Windows') {
+function isProbablyGradleDaemonProblem(
+  packageManager: PackageManager,
+  error: Error
+): boolean {
+  if (
+    packageManager.id !== 'gradle' ||
+    process.env['RUNNER_OS'] !== 'Windows'
+  ) {
     return false
   }
   const message = error.message || ''

src/features/check-for-updates.ts

@@ -1,25 +1,30 @@
 import * as core from '@actions/core'
+import {toSemVer} from '../utils'
+import {lt, major, minor, valid} from 'semver'
+import {getLatestReleaseVersion} from '../graalvm'
 
-export function checkForUpdates(graalVMVersion: string, javaVersion: string): void {
-  if (javaVersion === '20') {
+export async function checkForUpdates(
+  graalVMVersion: string,
+  javaVersion: string
+): Promise<void> {
+  if (graalVMVersion === '22.3.0' && javaVersion === '11') {
     core.notice(
-      'A new GraalVM release is available! Please consider upgrading to GraalVM for JDK 21: https://medium.com/graalvm/graalvm-for-jdk-21-is-here-ee01177dd12d'
+      'Please consider upgrading your project to Java 17+. The GraalVM 22.3.0 release is the last to support JDK11: https://github.com/oracle/graal/issues/5063'
     )
     return
   }
-  if (graalVMVersion.length > 0 && (javaVersion === '17' || javaVersion === '19')) {
-    const recommendedJDK = javaVersion === '17' ? '17' : '21'
+  const latestGraalVMVersion = await getLatestReleaseVersion()
+  const selectedVersion = toSemVer(graalVMVersion)
+  const latestVersion = toSemVer(latestGraalVMVersion)
+  if (
+    valid(selectedVersion) &&
+    valid(latestVersion) &&
+    lt(selectedVersion, latestVersion)
+  ) {
     core.notice(
-      `A new GraalVM release is available! Please consider upgrading to GraalVM for JDK ${recommendedJDK}. Instructions: https://github.com/graalvm/setup-graalvm#migrating-from-graalvm-223-or-earlier-to-the-new-graalvm-for-jdk-17-and-later`
+      `A new GraalVM release is available! Please consider upgrading to GraalVM ${latestGraalVMVersion}. Release notes: https://www.graalvm.org/release-notes/${major(
+        latestVersion
+      )}_${minor(latestVersion)}/`
     )
-    return
   }
-
-  if (graalVMVersion.startsWith('22.3.') && javaVersion === '11') {
-    core.notice(
-      'Please consider upgrading your project to Java 17+. GraalVM 22.3.X releases are the last to support JDK11: https://github.com/oracle/graal/issues/5063'
-    )
-    return
-  }
-  // TODO: add support for JDK-specific update checks (e.g., 17.0.X)
 }

src/features/musl.ts

@@ -1,8 +1,8 @@
 import * as c from '../constants'
 import * as core from '@actions/core'
 import * as tc from '@actions/tool-cache'
-import { exec } from '../utils'
-import { join } from 'path'
+import {exec} from '../utils'
+import {join} from 'path'
 
 const MUSL_NAME = 'x86_64-linux-musl-native'
 const MUSL_VERSION = '10.2.1'
@@ -24,7 +24,9 @@ export async function setUpNativeImageMusl(): Promise<void> {
     const muslPath = join(muslExtractPath, MUSL_NAME)
 
     const zlibCommit = 'ec3df00224d4b396e2ac6586ab5d25f673caa4c2'
-    const zlibDownloadPath = await tc.downloadTool(`https://github.com/madler/zlib/archive/${zlibCommit}.tar.gz`)
+    const zlibDownloadPath = await tc.downloadTool(
+      `https://github.com/madler/zlib/archive/${zlibCommit}.tar.gz`
+    )
     const zlibExtractPath = await tc.extractTar(zlibDownloadPath)
     const zlibPath = join(zlibExtractPath, `zlib-${zlibCommit}`)
     const zlibBuildOptions = {
@@ -34,9 +36,13 @@ export async function setUpNativeImageMusl(): Promise<void> {
         CC: join(muslPath, 'bin', 'gcc')
       }
     }
-    await exec('./configure', [`--prefix=${muslPath}`, '--static'], zlibBuildOptions)
+    await exec(
+      './configure',
+      [`--prefix=${muslPath}`, '--static'],
+      zlibBuildOptions
+    )
     await exec('make', [], zlibBuildOptions)
-    await exec('make', ['install'], { cwd: zlibPath })
+    await exec('make', ['install'], {cwd: zlibPath})
 
     core.info(`Adding ${MUSL_NAME} ${MUSL_VERSION} to tool-cache ...`)
     toolPath = await tc.cacheDir(muslPath, MUSL_NAME, MUSL_VERSION)

src/features/reports.ts

@@ -2,26 +2,24 @@ import * as c from '../constants'
 import * as core from '@actions/core'
 import * as fs from 'fs'
 import * as github from '@actions/github'
-import * as semver from 'semver'
-import {
-  createPRComment,
-  findExistingPRCommentId,
-  isPREvent,
-  toSemVer,
-  updatePRComment,
-  tmpfile,
-  setNativeImageOption
-} from '../utils'
+import {join} from 'path'
+import {tmpdir} from 'os'
+import {createPRComment, isPREvent, toSemVer} from '../utils'
+import {gte} from 'semver'
 
-const BUILD_OUTPUT_JSON_PATH = tmpfile('native-image-build-output.json')
+const BUILD_OUTPUT_JSON_PATH = join(tmpdir(), 'native-image-build-output.json')
 const BYTES_TO_KiB = 1024
 const BYTES_TO_MiB = 1024 * 1024
 const BYTES_TO_GiB = 1024 * 1024 * 1024
-const DOCS_BASE = 'https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/BuildOutput.md'
+const DOCS_BASE =
+  'https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/BuildOutput.md'
 const INPUT_NI_JOB_REPORTS = 'native-image-job-reports'
 const INPUT_NI_PR_REPORTS = 'native-image-pr-reports'
-const INPUT_NI_PR_REPORTS_UPDATE = 'native-image-pr-reports-update-existing'
-const PR_COMMENT_TITLE = '## GraalVM Native Image Build Report'
+const NATIVE_IMAGE_CONFIG_FILE = join(
+  tmpdir(),
+  'native-image-options.properties'
+)
+const NATIVE_IMAGE_CONFIG_FILE_ENV = 'NATIVE_IMAGE_CONFIG_FILE'
 
 interface AnalysisResult {
   total: number
@@ -35,18 +33,11 @@ interface BuildOutput {
     name: string
     graalvm_version: string
     java_version: string | null
-    vendor_version?: string
     c_compiler: string | null
     garbage_collector: string
-    graal_compiler?: {
-      optimization_level: string
-      march: string
-      pgo?: string[]
-    }
   }
   analysis_results: {
     classes: AnalysisResult
-    types?: AnalysisResult
     fields: AnalysisResult
     methods: AnalysisResult
   }
@@ -58,9 +49,6 @@ interface BuildOutput {
     }
     image_heap: {
       bytes: number
-      objects?: {
-        count: number
-      }
       resources: {
         count: number
         bytes: number
@@ -87,13 +75,10 @@ interface BuildOutput {
       system_total: number
       peak_rss_bytes: number
     }
-    total_secs?: number
   }
 }
 
 export async function setUpNativeImageBuildReports(
-  isGraalVMforJDK17OrLater: boolean,
-  javaVersionOrDev: string,
   graalVMVersion: string
 ): Promise<void> {
   const isRequired = areJobReportsEnabled() || arePRReportsEnabled()
@@ -101,20 +86,22 @@ export async function setUpNativeImageBuildReports(
     return
   }
   const isSupported =
-    isGraalVMforJDK17OrLater ||
     graalVMVersion === c.VERSION_LATEST ||
     graalVMVersion === c.VERSION_DEV ||
-    (!graalVMVersion.startsWith(c.MANDREL_NAMESPACE) && semver.gte(toSemVer(graalVMVersion), '22.2.0'))
+    (!graalVMVersion.startsWith(c.MANDREL_NAMESPACE) &&
+      gte(toSemVer(graalVMVersion), '22.2.0'))
   if (!isSupported) {
     core.warning(
       `Build reports for PRs and job summaries are only available in GraalVM 22.2.0 or later. This build job uses GraalVM ${graalVMVersion}.`
     )
     return
   }
-  setNativeImageOption(javaVersionOrDev, `-H:BuildOutputJSONFile=${BUILD_OUTPUT_JSON_PATH.replace(/\\/g, '\\\\')}`) // Escape backslashes for Windows
+  setNativeImageOption(
+    `-H:BuildOutputJSONFile=${BUILD_OUTPUT_JSON_PATH.replace(/\\/g, '\\\\')}`
+  ) // Escape backslashes for Windows
 }
 
-export async function generateReports(): Promise<void> {
+export function generateReports(): void {
   if (areJobReportsEnabled() || arePRReportsEnabled()) {
     if (!fs.existsSync(BUILD_OUTPUT_JSON_PATH)) {
       core.warning(
@@ -122,22 +109,16 @@ export async function generateReports(): Promise<void> {
       )
       return
     }
-    const buildOutput: BuildOutput = JSON.parse(fs.readFileSync(BUILD_OUTPUT_JSON_PATH, 'utf8'))
+    const buildOutput: BuildOutput = JSON.parse(
+      fs.readFileSync(BUILD_OUTPUT_JSON_PATH, 'utf8')
+    )
     const report = createReport(buildOutput)
     if (areJobReportsEnabled()) {
       core.summary.addRaw(report)
       core.summary.write()
     }
     if (arePRReportsEnabled()) {
-      if (arePRReportsUpdateEnabled()) {
-        const commentId = await findExistingPRCommentId(PR_COMMENT_TITLE)
-        if (commentId) {
-          return updatePRComment(report, commentId)
-        }
-      }
-      return createPRComment(report)
-    } else if (arePRReportsUpdateEnabled()) {
-      throw new Error(`'${INPUT_NI_PR_REPORTS_UPDATE}' option requires '${INPUT_NI_PR_REPORTS}' to be set 'true'`)
+      createPRComment(report)
     }
   }
 }
@@ -150,22 +131,35 @@ function arePRReportsEnabled(): boolean {
   return isPREvent() && core.getInput(INPUT_NI_PR_REPORTS) === 'true'
 }
 
-function arePRReportsUpdateEnabled(): boolean {
-  return isPREvent() && core.getInput(INPUT_NI_PR_REPORTS_UPDATE) === 'true'
+function getNativeImageOptionsFile(): string {
+  let optionsFile = process.env[NATIVE_IMAGE_CONFIG_FILE_ENV]
+  if (optionsFile === undefined) {
+    optionsFile = NATIVE_IMAGE_CONFIG_FILE
+    core.exportVariable(NATIVE_IMAGE_CONFIG_FILE_ENV, optionsFile)
+  }
+  return optionsFile
+}
+
+function setNativeImageOption(value: string): void {
+  const optionsFile = getNativeImageOptionsFile()
+  if (fs.existsSync(optionsFile)) {
+    fs.appendFileSync(optionsFile, ` ${value}`)
+  } else {
+    fs.writeFileSync(optionsFile, `NativeImageArgs = ${value}`)
+  }
 }
 
 function createReport(data: BuildOutput): string {
   const context = github.context
   const info = data.general_info
   const analysis = data.analysis_results
-  const analysisTypes = analysis.types ? analysis.types : analysis.classes
   const details = data.image_details
-  let objectCount = ''
-  if (details.image_heap.objects) {
-    objectCount = `${details.image_heap.objects.count.toLocaleString()} objects, `
-  }
   const debugInfoBytes = details.debug_info ? details.debug_info.bytes : 0
-  const otherBytes = details.total_bytes - details.code_area.bytes - details.image_heap.bytes - debugInfoBytes
+  const otherBytes =
+    details.total_bytes -
+    details.code_area.bytes -
+    details.image_heap.bytes -
+    debugInfoBytes
   let debugInfoLine = ''
   if (details.debug_info) {
     debugInfoLine = `
@@ -176,55 +170,12 @@ function createReport(data: BuildOutput): string {
       <td align="left"></td>
     </tr>`
   }
-  let versionLine
-  if (info.vendor_version) {
-    versionLine = `
-    <tr>
-      <td><a href="${DOCS_BASE}#glossary-java-info" target="_blank">Java version</a></td>
-      <td>${info.java_version}</td>
-      <td><a href="${DOCS_BASE}#glossary-java-info" target="_blank">Vendor version</a></td>
-      <td>${info.vendor_version}</td>
-    </tr>`
-  } else {
-    versionLine = `
-    <tr>
-      <td><a href="${DOCS_BASE}#glossary-version-info" target="_blank">GraalVM version</a></td>
-      <td>${info.graalvm_version}</td>
-      <td><a href="${DOCS_BASE}#glossary-java-version-info" target="_blank">Java version</a></td>
-      <td>${info.java_version}</td>
-    </tr>`
-  }
-  let graalLine
-  if (info.graal_compiler) {
-    let pgoSuffix = ''
-    const isOracleGraalVM = info.vendor_version && info.vendor_version.includes('Oracle GraalVM')
-    if (isOracleGraalVM) {
-      const pgo = info.graal_compiler.pgo
-      const pgoText = pgo ? pgo.join('+') : 'off'
-      pgoSuffix = `, <a href="${DOCS_BASE}#recommendation-pgo" target="_blank">PGO</a>: ${pgoText}`
-    }
-    graalLine = `
-    <tr>
-      <td align="left"><a href="${DOCS_BASE}#glossary-graal-compiler" target="_blank">Graal compiler</a></td>
-      <td colspan="3">
-        optimization level: ${info.graal_compiler.optimization_level},
-        target machine: ${info.graal_compiler.march}${pgoSuffix}
-      </td>
-    </tr>`
-  }
 
   const resources = data.resource_usage
 
-  let totalTime = ''
-  let gcTotalTimeRatio = ''
-  if (resources.total_secs) {
-    totalTime = ` in ${secondsToHuman(resources.total_secs)}`
-    gcTotalTimeRatio = ` (${toPercent(resources.garbage_collection.total_secs, resources.total_secs)} of total time)`
-  }
+  return `## GraalVM Native Image Build Report
 
-  return `${PR_COMMENT_TITLE}
-
-\`${info.name}\` generated${totalTime} as part of the '${
+\`${info.name}\` generated as part of the '${
     context.job
   }' job in run <a href="${context.serverUrl}/${context.repo.owner}/${
     context.repo.repo
@@ -232,14 +183,18 @@ function createReport(data: BuildOutput): string {
 
 #### Environment
 
-<table>${versionLine}${graalLine}
+<table>
   <tr>
+    <td><a href="${DOCS_BASE}#glossary-version-info" target="_blank">GraalVM version</a></td>
+    <td>${info.graalvm_version}</td>
     <td><a href="${DOCS_BASE}#glossary-ccompiler" target="_blank">C compiler</a></td>
-    <td colspan="3">${info.c_compiler}</td>
+    <td>${info.c_compiler}</td>
   </tr>
   <tr>
+    <td><a href="${DOCS_BASE}#glossary-java-version-info" target="_blank">Java version</a></td>
+    <td>${info.java_version}</td>
     <td><a href="${DOCS_BASE}#glossary-gc" target="_blank">Garbage collector</a></td>
-    <td colspan="3">${info.garbage_collector}</td>
+    <td>${info.garbage_collector}</td>
   </tr>
 </table>
 
@@ -260,38 +215,65 @@ function createReport(data: BuildOutput): string {
   <tbody>
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-reachability" target="_blank">Reachable</a></td>
-      <td align="right">${analysisTypes.reachable.toLocaleString()}</td>
-      <td align="right">${toPercent(analysisTypes.reachable, analysisTypes.total)}</td>
-      <td align="right">${analysis.fields.reachable.toLocaleString()}</td>
-      <td align="right">${toPercent(analysis.fields.reachable, analysis.fields.total)}</td>
-      <td align="right">${analysis.methods.reachable.toLocaleString()}</td>
-      <td align="right">${toPercent(analysis.methods.reachable, analysis.methods.total)}</td>
+      <td align="right">${analysis.classes.reachable}</td>
+      <td align="right">${toPercent(
+        analysis.classes.reachable,
+        analysis.classes.total
+      )}</td>
+      <td align="right">${analysis.fields.reachable}</td>
+      <td align="right">${toPercent(
+        analysis.fields.reachable,
+        analysis.fields.total
+      )}</td>
+      <td align="right">${analysis.methods.reachable}</td>
+      <td align="right">${toPercent(
+        analysis.methods.reachable,
+        analysis.methods.total
+      )}</td>
     </tr>
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-reflection-registrations" target="_blank">Reflection</a></td>
-      <td align="right">${analysisTypes.reflection.toLocaleString()}</td>
-      <td align="right">${toPercent(analysisTypes.reflection, analysisTypes.total)}</td>
-      <td align="right">${analysis.fields.reflection.toLocaleString()}</td>
-      <td align="right">${toPercent(analysis.fields.reflection, analysis.fields.total)}</td>
-      <td align="right">${analysis.methods.reflection.toLocaleString()}</td>
-      <td align="right">${toPercent(analysis.methods.reflection, analysis.methods.total)}</td>
+      <td align="right">${analysis.classes.reflection}</td>
+      <td align="right">${toPercent(
+        analysis.classes.reflection,
+        analysis.classes.total
+      )}</td>
+      <td align="right">${analysis.fields.reflection}</td>
+      <td align="right">${toPercent(
+        analysis.fields.reflection,
+        analysis.fields.total
+      )}</td>
+      <td align="right">${analysis.methods.reflection}</td>
+      <td align="right">${toPercent(
+        analysis.methods.reflection,
+        analysis.methods.total
+      )}</td>
     </tr>
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-jni-access-registrations" target="_blank">JNI</a></td>
-      <td align="right">${analysisTypes.jni.toLocaleString()}</td>
-      <td align="right">${toPercent(analysisTypes.jni, analysisTypes.total)}</td>
-      <td align="right">${analysis.fields.jni.toLocaleString()}</td>
-      <td align="right">${toPercent(analysis.fields.jni, analysis.fields.total)}</td>
-      <td align="right">${analysis.methods.jni.toLocaleString()}</td>
-      <td align="right">${toPercent(analysis.methods.jni, analysis.methods.total)}</td>
+      <td align="right">${analysis.classes.jni}</td>
+      <td align="right">${toPercent(
+        analysis.classes.jni,
+        analysis.classes.total
+      )}</td>
+      <td align="right">${analysis.fields.jni}</td>
+      <td align="right">${toPercent(
+        analysis.fields.jni,
+        analysis.fields.total
+      )}</td>
+      <td align="right">${analysis.methods.jni}</td>
+      <td align="right">${toPercent(
+        analysis.methods.jni,
+        analysis.methods.total
+      )}</td>
     </tr>
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-reachability" target="_blank">Loaded</a></td>
-      <td align="right">${analysisTypes.total.toLocaleString()}</td>
+      <td align="right">${analysis.classes.total}</td>
       <td align="right">100.000%</td>
-      <td align="right">${analysis.fields.total.toLocaleString()}</td>
+      <td align="right">${analysis.fields.total}</td>
       <td align="right">100.000%</td>
-      <td align="right">${analysis.methods.total.toLocaleString()}</td>
+      <td align="right">${analysis.methods.total}</td>
       <td align="right">100.000%</td>
     </tr>
   </tbody>
@@ -312,16 +294,24 @@ function createReport(data: BuildOutput): string {
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-code-area" target="_blank">Code area</a></td>
       <td align="right">${bytesToHuman(details.code_area.bytes)}</td>
-      <td align="right">${toPercent(details.code_area.bytes, details.total_bytes)}</td>
-      <td align="left">${details.code_area.compilation_units.toLocaleString()} compilation units</td>
+      <td align="right">${toPercent(
+        details.code_area.bytes,
+        details.total_bytes
+      )}</td>
+      <td align="left">${
+        details.code_area.compilation_units
+      } compilation units</td>
     </tr>
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-image-heap" target="_blank">Image heap</a></td>
       <td align="right">${bytesToHuman(details.image_heap.bytes)}</td>
-      <td align="right">${toPercent(details.image_heap.bytes, details.total_bytes)}</td>
-      <td align="left">${objectCount}${bytesToHuman(
+      <td align="right">${toPercent(
+        details.image_heap.bytes,
+        details.total_bytes
+      )}</td>
+      <td align="left">${bytesToHuman(
         details.image_heap.resources.bytes
-      )} for ${details.image_heap.resources.count.toLocaleString()} resources</td>
+      )} for ${details.image_heap.resources.count} resources</td>
     </tr>${debugInfoLine}
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-other-data" target="_blank">Other data</a></td>
@@ -331,7 +321,9 @@ function createReport(data: BuildOutput): string {
     </tr>
     <tr>
       <td align="left">Total</td>
-      <td align="right"><strong>${bytesToHuman(details.total_bytes)}</strong></td>
+      <td align="right"><strong>${bytesToHuman(
+        details.total_bytes
+      )}</strong></td>
       <td align="right">100.000%</td>
       <td align="left"></td>
     </tr>
@@ -346,21 +338,23 @@ function createReport(data: BuildOutput): string {
       <td align="left"><a href="${DOCS_BASE}#glossary-garbage-collections" target="_blank">Garbage collection</a></td>
       <td align="left">${resources.garbage_collection.total_secs.toFixed(
         2
-      )}s${gcTotalTimeRatio} in ${resources.garbage_collection.count} GCs</td>
+      )}s in ${resources.garbage_collection.count} GCs</td>
     </tr>
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-peak-rss" target="_blank">Peak RSS</a></td>
-      <td align="left">${bytesToHuman(resources.memory.peak_rss_bytes)} (${toPercent(
-        resources.memory.peak_rss_bytes,
-        resources.memory.system_total
-      )} of ${bytesToHuman(resources.memory.system_total)} system memory)</td>
+      <td align="left">${bytesToHuman(
+        resources.memory.peak_rss_bytes
+      )} (${toPercent(
+    resources.memory.peak_rss_bytes,
+    resources.memory.system_total
+  )} of ${bytesToHuman(resources.memory.system_total)} system memory)</td>
     </tr>
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-cpu-load" target="_blank">CPU load</a></td>
       <td align="left">${resources.cpu.load.toFixed(3)} (${toPercent(
-        resources.cpu.load,
-        resources.cpu.total_cores
-      )} of ${resources.cpu.total_cores} CPU cores)</td>
+    resources.cpu.load,
+    resources.cpu.total_cores
+  )} of ${resources.cpu.total_cores} CPU cores)</td>
     </tr>
   </tbody>
 </table>
@@ -383,11 +377,3 @@ function bytesToHuman(bytes: number): string {
     return `${(bytes / BYTES_TO_GiB).toFixed(2)}GB`
   }
 }
-
-function secondsToHuman(seconds: number): string {
-  if (seconds < 60) {
-    return `${seconds.toFixed(1)}s`
-  } else {
-    return `${Math.trunc(seconds / 60)}m ${Math.trunc(seconds % 60)}s`
-  }
-}

src/features/sbom.ts

@@ -1,271 +0,0 @@
-import * as c from '../constants'
-import * as core from '@actions/core'
-import * as fs from 'fs'
-import * as github from '@actions/github'
-import * as glob from '@actions/glob'
-import { basename } from 'path'
-import * as semver from 'semver'
-import { setNativeImageOption } from '../utils'
-
-const INPUT_NI_SBOM = 'native-image-enable-sbom'
-const SBOM_FILE_SUFFIX = '.sbom.json'
-const MIN_JAVA_VERSION = '24.0.0'
-const javaVersionKey = 'javaVersionKey'
-
-interface SBOM {
-  components: Component[]
-  dependencies: Dependency[]
-}
-
-interface Component {
-  name: string
-  version?: string
-  purl?: string
-  dependencies?: string[]
-  'bom-ref': string
-}
-
-interface Dependency {
-  ref: string
-  dependsOn: string[]
-}
-
-interface DependencySnapshot {
-  version: number
-  sha: string
-  ref: string
-  job: {
-    correlator: string
-    id: string
-    html_url?: string
-  }
-  detector: {
-    name: string
-    version: string
-    url: string
-  }
-  scanned: string
-  manifests: Record<
-    string,
-    {
-      name: string
-      metadata?: Record<string, string>
-      // Not including the 'file' property because we cannot specify any reasonable value for 'source_location'
-      // since the SBOM will not necessarily be saved in the repository of the user.
-      // GitHub docs: https://docs.github.com/en/rest/dependency-graph/dependency-submission?apiVersion=2022-11-28#create-a-snapshot-of-dependencies-for-a-repository
-      resolved: Record<
-        string,
-        {
-          package_url: string
-          relationship?: 'direct'
-          scope?: 'runtime'
-          dependencies?: string[]
-        }
-      >
-    }
-  >
-}
-
-export function setUpSBOMSupport(javaVersion: string, distribution: string): void {
-  if (!isFeatureEnabled()) {
-    return
-  }
-
-  validateJavaVersionAndDistribution(javaVersion, distribution)
-  core.saveState(javaVersionKey, javaVersion)
-  setNativeImageOption(javaVersion, '--enable-sbom=export')
-  core.info('Enabled SBOM generation for Native Image build')
-}
-
-function validateJavaVersionAndDistribution(javaVersion: string, distribution: string): void {
-  if (distribution !== c.DISTRIBUTION_GRAALVM) {
-    throw new Error(
-      `The '${INPUT_NI_SBOM}' option is only supported for Oracle GraalVM (distribution '${c.DISTRIBUTION_GRAALVM}'), but found distribution '${distribution}'.`
-    )
-  }
-
-  if (javaVersion === 'dev') {
-    throw new Error(`The '${INPUT_NI_SBOM}' option is not supported for java-version 'dev'.`)
-  }
-
-  if (javaVersion === 'latest-ea') {
-    return
-  }
-
-  const coercedJavaVersion = semver.coerce(javaVersion)
-  if (!coercedJavaVersion || semver.gt(MIN_JAVA_VERSION, coercedJavaVersion)) {
-    throw new Error(
-      `The '${INPUT_NI_SBOM}' option is only supported for GraalVM for JDK ${MIN_JAVA_VERSION} or later, but found java-version '${javaVersion}'.`
-    )
-  }
-}
-
-export async function processSBOM(): Promise<void> {
-  if (!isFeatureEnabled()) {
-    return
-  }
-
-  const javaVersion = core.getState(javaVersionKey)
-  if (!javaVersion) {
-    throw new Error('setUpSBOMSupport must be called before processSBOM')
-  }
-
-  const sbomPath = await findSBOMFilePath()
-  try {
-    const sbomContent = fs.readFileSync(sbomPath, 'utf8')
-    const sbomData = parseSBOM(sbomContent)
-    const components = mapToComponentsWithDependencies(sbomData)
-    printSBOMContent(components)
-    const snapshot = convertSBOMToSnapshot(javaVersion, sbomPath, components)
-    await submitDependencySnapshot(snapshot)
-  } catch (error) {
-    throw new Error(
-      `Failed to process and submit SBOM to the GitHub dependency submission API: ${error instanceof Error ? error.message : String(error)}`
-    )
-  }
-}
-
-function isFeatureEnabled(): boolean {
-  return core.getInput(INPUT_NI_SBOM) === 'true'
-}
-
-async function findSBOMFilePath(): Promise<string> {
-  const globber = await glob.create(`**/*${SBOM_FILE_SUFFIX}`)
-  const sbomFiles = await globber.glob()
-
-  if (sbomFiles.length === 0) {
-    throw new Error('No SBOM found. Make sure native-image build completed successfully.')
-  }
-
-  if (sbomFiles.length > 1) {
-    throw new Error(`Expected one SBOM but found multiple: ${sbomFiles.join(', ')}.`)
-  }
-
-  core.info(`Found SBOM: ${sbomFiles[0]}`)
-  return sbomFiles[0]
-}
-
-function parseSBOM(jsonString: string): SBOM {
-  try {
-    const sbomData: SBOM = JSON.parse(jsonString)
-    return sbomData
-  } catch (error) {
-    throw new Error(`Failed to parse SBOM JSON: ${error instanceof Error ? error.message : String(error)}`)
-  }
-}
-
-// Maps the SBOM to a list of components with their dependencies
-function mapToComponentsWithDependencies(sbom: SBOM): Component[] {
-  if (!sbom || sbom.components.length === 0) {
-    throw new Error('Invalid SBOM data or no components found.')
-  }
-
-  return sbom.components.map((component: Component) => {
-    const dependencies = sbom.dependencies?.find((dep: Dependency) => dep.ref === component['bom-ref'])?.dependsOn || []
-
-    return {
-      name: component.name,
-      version: component.version,
-      purl: component.purl,
-      dependencies,
-      'bom-ref': component['bom-ref']
-    }
-  })
-}
-
-function printSBOMContent(components: Component[]): void {
-  core.info('=== SBOM Content ===')
-  for (const component of components) {
-    core.info(`- ${component['bom-ref']}`)
-    if (component.dependencies && component.dependencies.length > 0) {
-      core.info(`   depends on: ${component.dependencies.join(', ')}`)
-    }
-  }
-  core.info('==================')
-}
-
-function convertSBOMToSnapshot(javaVersion: string, sbomPath: string, components: Component[]): DependencySnapshot {
-  const context = github.context
-  const sbomFileName = basename(sbomPath)
-
-  if (!sbomFileName.endsWith(SBOM_FILE_SUFFIX)) {
-    throw new Error(`Invalid SBOM file name: ${sbomFileName}. Expected a file ending with ${SBOM_FILE_SUFFIX}.`)
-  }
-
-  return {
-    version: 0,
-    sha: context.sha,
-    ref: context.ref,
-    job: {
-      correlator: `${context.workflow}_${context.job}`,
-      id: context.runId.toString(),
-      html_url: `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`
-    },
-    detector: {
-      name: 'Oracle GraalVM',
-      version: javaVersion,
-      url: 'https://www.graalvm.org/'
-    },
-    scanned: new Date().toISOString(),
-    manifests: {
-      [sbomFileName]: {
-        name: sbomFileName,
-        resolved: mapComponentsToGithubAPIFormat(components),
-        metadata: {
-          generated_by: 'SBOM generated by GraalVM Native Image',
-          action_version: c.ACTION_VERSION
-        }
-      }
-    }
-  }
-}
-
-function mapComponentsToGithubAPIFormat(
-  components: Component[]
-): Record<string, { package_url: string; dependencies?: string[] }> {
-  return Object.fromEntries(
-    components
-      .filter((component) => {
-        if (!component.purl) {
-          core.info(`Component ${component.name} does not have a valid package URL (purl). Skipping.`)
-        }
-        return component.purl
-      })
-      .map((component) => [
-        component.name,
-        {
-          package_url: component.purl as string,
-          dependencies: component.dependencies || []
-        }
-      ])
-  )
-}
-
-async function submitDependencySnapshot(snapshotData: DependencySnapshot): Promise<void> {
-  const token = core.getInput(c.INPUT_GITHUB_TOKEN, { required: true })
-  const octokit = github.getOctokit(token)
-  const context = github.context
-
-  try {
-    await octokit.request('POST /repos/{owner}/{repo}/dependency-graph/snapshots', {
-      owner: context.repo.owner,
-      repo: context.repo.repo,
-      version: snapshotData.version,
-      sha: snapshotData.sha,
-      ref: snapshotData.ref,
-      job: snapshotData.job,
-      detector: snapshotData.detector,
-      metadata: {},
-      scanned: snapshotData.scanned,
-      manifests: snapshotData.manifests,
-      headers: {
-        'X-GitHub-Api-Version': '2022-11-28'
-      }
-    })
-    core.info('Dependency snapshot submitted successfully.')
-  } catch (error) {
-    throw new Error(
-      `Failed to submit dependency snapshot for SBOM: ${error instanceof Error ? error.message : String(error)}`
-    )
-  }
-}

src/gds.ts

@@ -6,12 +6,12 @@ import * as io from '@actions/io'
 import * as path from 'path'
 import * as stream from 'stream'
 import * as util from 'util'
-import * as semver from 'semver'
-import { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http'
-import { RetryHelper } from '@actions/tool-cache/lib/retry-helper'
-import { calculateSHA256 } from './utils'
-import { ok } from 'assert'
-import { v4 as uuidv4 } from 'uuid'
+import {IHeaders} from '@actions/http-client/interfaces'
+import {IncomingHttpHeaders} from 'http'
+import {RetryHelper} from '@actions/tool-cache/lib/retry-helper'
+import {calculateSHA256} from './utils'
+import {ok} from 'assert'
+import {v4 as uuidv4} from 'uuid'
 
 interface GDSArtifactsResponse {
   readonly items: GDSArtifact[]
@@ -27,56 +27,22 @@ interface GDSErrorResponse {
   readonly message: string
 }
 
-export async function downloadGraalVM(gdsToken: string, javaVersion: string): Promise<string> {
-  const userAgent = `GraalVMGitHubAction/${c.ACTION_VERSION} (arch:${c.GRAALVM_ARCH}; os:${c.GRAALVM_PLATFORM}; java:${javaVersion})`
-  const baseArtifact = await fetchArtifact(userAgent, 'isBase:True', javaVersion)
+export async function downloadGraalVMEE(
+  gdsToken: string,
+  version: string,
+  javaVersion: string
+): Promise<string> {
+  const userAgent = `GraalVMGitHubAction/1.0.9 (arch:${c.GRAALVM_ARCH}; os:${c.GRAALVM_PLATFORM}; java:${javaVersion})`
+  const baseArtifact = await fetchArtifact(
+    userAgent,
+    'isBase:True',
+    version,
+    javaVersion
+  )
   return downloadArtifact(gdsToken, userAgent, baseArtifact)
 }
 
-export async function downloadGraalVMEELegacy(gdsToken: string, version: string, javaVersion: string): Promise<string> {
-  const userAgent = `GraalVMGitHubAction/${c.ACTION_VERSION} (arch:${c.GRAALVM_ARCH}; os:${c.GRAALVM_PLATFORM}; java:${javaVersion})`
-  const baseArtifact = await fetchArtifactEE(userAgent, 'isBase:True', version, javaVersion)
-  return downloadArtifact(gdsToken, userAgent, baseArtifact)
-}
-
-export async function fetchArtifact(userAgent: string, metadata: string, javaVersion: string): Promise<GDSArtifact> {
-  const http = new httpClient.HttpClient(userAgent)
-
-  let filter
-  if (javaVersion.includes('.')) {
-    filter = `metadata=version:${javaVersion}`
-  } else {
-    filter = `sortBy=timeCreated&sortOrder=DESC&limit=1` // latest and only one item
-  }
-
-  let majorJavaVersion
-  if (semver.valid(javaVersion)) {
-    majorJavaVersion = semver.major(javaVersion)
-  } else {
-    majorJavaVersion = javaVersion
-  }
-
-  const catalogOS = c.IS_MACOS ? 'macos' : c.GRAALVM_PLATFORM
-  const requestUrl = `${c.GDS_BASE}/artifacts?productId=${c.GDS_GRAALVM_PRODUCT_ID}&displayName=Oracle%20GraalVM&${filter}&metadata=java:jdk${majorJavaVersion}&metadata=os:${catalogOS}&metadata=arch:${c.GRAALVM_ARCH}&metadata=${metadata}&status=PUBLISHED&responseFields=id&responseFields=checksum`
-  core.debug(`Requesting ${requestUrl}`)
-  const response = await http.get(requestUrl, { accept: 'application/json' })
-  if (response.message.statusCode !== 200) {
-    throw new Error(
-      `Unable to find GraalVM for JDK ${javaVersion}. Are you sure java-version: '${javaVersion}' is correct?`
-    )
-  }
-  const artifactResponse = JSON.parse(await response.readBody()) as GDSArtifactsResponse
-  if (artifactResponse.items.length !== 1) {
-    throw new Error(
-      artifactResponse.items.length > 1
-        ? `Found more than one GDS artifact. ${c.ERROR_HINT}`
-        : `Unable to find GDS artifact. Are you sure java-version: '${javaVersion}' is correct?`
-    )
-  }
-  return artifactResponse.items[0]
-}
-
-export async function fetchArtifactEE(
+export async function fetchArtifact(
   userAgent: string,
   metadata: string,
   version: string,
@@ -94,28 +60,36 @@ export async function fetchArtifactEE(
   const catalogOS = c.IS_MACOS ? 'macos' : c.GRAALVM_PLATFORM
   const requestUrl = `${c.GDS_BASE}/artifacts?productId=${c.GDS_GRAALVM_PRODUCT_ID}&${filter}&metadata=java:jdk${javaVersion}&metadata=os:${catalogOS}&metadata=arch:${c.GRAALVM_ARCH}&metadata=${metadata}&status=PUBLISHED&responseFields=id&responseFields=checksum`
   core.debug(`Requesting ${requestUrl}`)
-  const response = await http.get(requestUrl, { accept: 'application/json' })
+  const response = await http.get(requestUrl, {accept: 'application/json'})
   if (response.message.statusCode !== 200) {
-    throw new Error(`Unable to find JDK${javaVersion}-based GraalVM EE ${version}`)
-  }
-  const artifactResponse = JSON.parse(await response.readBody()) as GDSArtifactsResponse
-  if (artifactResponse.items.length !== 1) {
     throw new Error(
-      artifactResponse.items.length > 1
-        ? `Found more than one GDS artifact. ${c.ERROR_HINT}`
-        : `Unable to find GDS artifact. Are you sure version: '${version}' is correct?`
+      `Unable to find JDK${javaVersion}-based GraalVM EE ${version}`
     )
   }
+  const artifactResponse = JSON.parse(
+    await response.readBody()
+  ) as GDSArtifactsResponse
+  if (artifactResponse.items.length !== 1) {
+    throw new Error(`Found more than one GDS artifact`)
+  }
   return artifactResponse.items[0]
 }
 
-async function downloadArtifact(gdsToken: string, userAgent: string, artifact: GDSArtifact): Promise<string> {
+async function downloadArtifact(
+  gdsToken: string,
+  userAgent: string,
+  artifact: GDSArtifact
+): Promise<string> {
   let downloadPath
   try {
-    downloadPath = await downloadTool(`${c.GDS_BASE}/artifacts/${artifact.id}/content`, userAgent, {
-      accept: 'application/x-yaml',
-      'x-download-token': gdsToken
-    })
+    downloadPath = await downloadTool(
+      `${c.GDS_BASE}/artifacts/${artifact.id}/content`,
+      userAgent,
+      {
+        accept: 'application/x-yaml',
+        'x-download-token': gdsToken
+      }
+    )
   } catch (err) {
     if (err instanceof HTTPError && err.httpStatusCode) {
       if (err.httpStatusCode === 401) {
@@ -128,7 +102,9 @@ async function downloadArtifact(gdsToken: string, userAgent: string, artifact: G
   }
   const sha256 = calculateSHA256(downloadPath)
   if (sha256.toLowerCase() !== artifact.checksum.toLowerCase()) {
-    throw new Error(`Checksum does not match (expected: "${artifact.checksum}", got: "${sha256}")`)
+    throw new Error(
+      `Checksum does not match (expected: "${artifact.checksum}", got: "${sha256}")`
+    )
   }
   return downloadPath
 }
@@ -149,7 +125,11 @@ class HTTPError extends Error {
   }
 }
 
-async function downloadTool(url: string, userAgent: string, headers?: OutgoingHttpHeaders): Promise<string> {
+async function downloadTool(
+  url: string,
+  userAgent: string,
+  headers?: IHeaders
+): Promise<string> {
   const dest = path.join(getTempDirectory(), uuidv4())
   await io.mkdirP(path.dirname(dest))
   core.debug(`Downloading ${url}`)
@@ -166,7 +146,11 @@ async function downloadTool(url: string, userAgent: string, headers?: OutgoingHt
     (err: Error) => {
       if (err instanceof HTTPError && err.httpStatusCode) {
         // Don't retry anything less than 500, except 408 Request Timeout and 429 Too Many Requests
-        if (err.httpStatusCode < 500 && err.httpStatusCode !== 408 && err.httpStatusCode !== 429) {
+        if (
+          err.httpStatusCode < 500 &&
+          err.httpStatusCode !== 408 &&
+          err.httpStatusCode !== 429
+        ) {
           return false
         }
       }
@@ -181,7 +165,7 @@ async function downloadToolAttempt(
   url: string,
   userAgent: string,
   dest: string,
-  headers?: OutgoingHttpHeaders
+  headers?: IHeaders
 ): Promise<string> {
   if (fs.existsSync(dest)) {
     throw new Error(`Destination file path ${dest} already exists`)
@@ -194,8 +178,14 @@ async function downloadToolAttempt(
 
   const response: httpClient.HttpClientResponse = await http.get(url, headers)
   if (response.message.statusCode !== 200) {
-    const errorResponse = JSON.parse(await response.readBody()) as GDSErrorResponse
-    const err = new HTTPError(response.message.statusCode, errorResponse, response.message.headers)
+    const errorResponse = JSON.parse(
+      await response.readBody()
+    ) as GDSErrorResponse
+    const err = new HTTPError(
+      response.message.statusCode,
+      errorResponse,
+      response.message.headers
+    )
     core.debug(
       `Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`
     )

src/graalvm.ts

@@ -1,273 +1,94 @@
 import * as c from './constants'
-import * as core from '@actions/core'
-import * as semver from 'semver'
 import {
   downloadAndExtractJDK,
   downloadExtractAndCacheJDK,
-  getContents,
-  getLatestRelease,
-  getMatchingTags,
-  getTaggedRelease
+  getLatestRelease
 } from './utils'
-import { downloadGraalVM, downloadGraalVMEELegacy } from './gds'
-import { downloadTool } from '@actions/tool-cache'
-import { basename } from 'path'
+import {downloadGraalVMEE} from './gds'
+import {downloadTool} from '@actions/tool-cache'
 
-const GRAALVM_DL_BASE = 'https://download.oracle.com/graalvm'
-const GRAALVM_CE_DL_BASE = `https://github.com/graalvm/${c.GRAALVM_RELEASES_REPO}/releases/download`
-const ORACLE_GRAALVM_REPO_EA_BUILDS = 'oracle-graalvm-ea-builds'
-const ORACLE_GRAALVM_REPO_EA_BUILDS_LATEST_SYMBOL = 'latest-ea'
+const GRAALVM_CE_DL_BASE =
+  'https://github.com/graalvm/graalvm-ce-builds/releases/download'
 const GRAALVM_REPO_DEV_BUILDS = 'graalvm-ce-dev-builds'
-const GRAALVM_JDK_TAG_PREFIX = 'jdk-'
+const GRAALVM_REPO_RELEASES = 'graalvm-ce-builds'
 const GRAALVM_TAG_PREFIX = 'vm-'
 
-// Support for GraalVM for JDK 17 and later
-
-export async function setUpGraalVMJDK(javaVersionOrDev: string, gdsToken: string): Promise<string> {
-  if (javaVersionOrDev === c.VERSION_DEV) {
-    return setUpGraalVMJDKDevBuild()
-  }
-  const isTokenProvided = gdsToken.length > 0
-  let javaVersion = javaVersionOrDev
-  const toolName = determineToolName(javaVersion, false)
-  if (javaVersionOrDev === '17' && !isTokenProvided) {
-    core.warning(
-      'This build uses the last update of Oracle GraalVM for JDK 17 under the GFTC. More details: https://github.com/marketplace/actions/github-action-for-graalvm#notes-on-oracle-graalvm-for-jdk-17'
-    )
-    return setUpGraalVMJDK('17.0.12', gdsToken)
-  }
-  if (isTokenProvided) {
-    // Download from GDS
-    const downloader = async () => downloadGraalVM(gdsToken, javaVersion)
-    return downloadExtractAndCacheJDK(downloader, toolName, javaVersion)
-  }
-  // Download from oracle.com
-  let downloadName = toolName
-  let downloadUrl: string
-  if (javaVersion.endsWith('-ea')) {
-    downloadUrl = await findLatestEABuildDownloadUrl(javaVersion)
-    const filename = basename(downloadUrl)
-    const resolvedVersion = semver.valid(semver.coerce(filename))
-    if (!resolvedVersion) {
-      throw new Error(`Unable to determine resolved version based on '${filename}'. ${c.ERROR_REQUEST}`)
-    }
-    javaVersion = resolvedVersion
-  } else if (javaVersion.includes('.')) {
-    if (semver.valid(javaVersion)) {
-      const majorJavaVersion = semver.major(javaVersion)
-      const minorJavaVersion = semver.minor(javaVersion)
-      const patchJavaVersion = semver.patch(javaVersion)
-      const isGARelease = minorJavaVersion === 0 && patchJavaVersion === 0
-      if (isGARelease) {
-        // For GA versions of JDKs, /archive/ does not use minor and patch version (see https://www.oracle.com/java/technologies/jdk-script-friendly-urls/)
-        downloadName = determineToolName(majorJavaVersion.toString(), false)
-      }
-      downloadUrl = `${GRAALVM_DL_BASE}/${majorJavaVersion}/archive/${downloadName}${c.GRAALVM_FILE_EXTENSION}`
-    } else {
-      throw new Error(
-        `java-version set to '${javaVersion}'. Please make sure the java-version is set correctly. ${c.ERROR_HINT}`
-      )
-    }
-  } else {
-    downloadUrl = `${GRAALVM_DL_BASE}/${javaVersion}/latest/${downloadName}${c.GRAALVM_FILE_EXTENSION}`
-  }
-  const downloader = async () => downloadGraalVMJDK(downloadUrl, javaVersion)
-  return downloadExtractAndCacheJDK(downloader, toolName, javaVersion)
-}
-
-export async function findLatestEABuildDownloadUrl(javaEaVersion: string): Promise<string> {
-  const filePath = `versions/${javaEaVersion}.json`
-  let response
-  try {
-    response = await getContents(ORACLE_GRAALVM_REPO_EA_BUILDS, filePath)
-  } catch (error) {
-    throw new Error(
-      `Unable to resolve download URL for '${javaEaVersion}' (reason: ${error}). Please make sure the java-version is set correctly. ${c.ERROR_HINT}`
-    )
-  }
-  if (Array.isArray(response) || response.type !== 'file' || !response.content) {
-    throw new Error(`Unexpected response when resolving download URL for '${javaEaVersion}'. ${c.ERROR_REQUEST}`)
-  }
-  const versionData = JSON.parse(Buffer.from(response.content, 'base64').toString('utf-8'))
-  let latestVersion
-  if (javaEaVersion === ORACLE_GRAALVM_REPO_EA_BUILDS_LATEST_SYMBOL) {
-    latestVersion = versionData as c.OracleGraalVMEAVersion
-  } else {
-    latestVersion = (versionData as c.OracleGraalVMEAVersion[]).find((v) => v.latest)
-    if (!latestVersion) {
-      throw new Error(`Unable to find latest version for '${javaEaVersion}'. ${c.ERROR_REQUEST}`)
-    }
-  }
-  const file = latestVersion.files.find((f) => f.arch === c.JDK_ARCH && f.platform === c.GRAALVM_PLATFORM)
-  if (!file || !file.filename.startsWith('graalvm-jdk-')) {
-    throw new Error(`Unable to find file metadata for '${javaEaVersion}'. ${c.ERROR_REQUEST}`)
-  }
-  return `${latestVersion.download_base_url}${file.filename}`
-}
-
-export async function setUpGraalVMJDKCE(javaVersionOrDev: string): Promise<string> {
-  if (javaVersionOrDev === c.VERSION_DEV) {
-    return setUpGraalVMJDKDevBuild()
-  }
-  let javaVersion = javaVersionOrDev
-  if (!javaVersion.includes('.')) {
-    javaVersion = await findLatestGraalVMJDKCEJavaVersion(javaVersion)
-  }
-  if (javaVersion.split('.').length != 3) {
-    throw new Error(
-      `java-version set to '${javaVersionOrDev}', which was resolved to '${javaVersion}'. Please make sure the java-version is set correctly. ${c.ERROR_HINT}`
-    )
-  }
-  const toolName = determineToolName(javaVersion, true)
-  const downloadUrl = `${GRAALVM_CE_DL_BASE}/jdk-${javaVersion}/${toolName}${c.GRAALVM_FILE_EXTENSION}`
-  const downloader = async () => downloadGraalVMJDK(downloadUrl, javaVersion)
-  return downloadExtractAndCacheJDK(downloader, toolName, javaVersion)
-}
-
-export async function findLatestGraalVMJDKCEJavaVersion(majorJavaVersion: string): Promise<string> {
-  const matchingRefs = await getMatchingTags(
-    c.GRAALVM_GH_USER,
-    c.GRAALVM_RELEASES_REPO,
-    `${GRAALVM_JDK_TAG_PREFIX}${majorJavaVersion}`
-  )
-  const lowestNonExistingVersion = '0.0.1'
-  let highestVersion = lowestNonExistingVersion
-  const versionNumberStartIndex = `refs/tags/${GRAALVM_JDK_TAG_PREFIX}`.length
-  for (const matchingRef of matchingRefs) {
-    const currentVersion = matchingRef.ref.substring(versionNumberStartIndex)
-    if (semver.valid(currentVersion) && semver.gt(currentVersion, highestVersion)) {
-      highestVersion = currentVersion
-    }
-  }
-  if (highestVersion === lowestNonExistingVersion) {
-    throw new Error(
-      `Unable to find the latest Java version for '${majorJavaVersion}'. Please make sure the java-version is set correctly. ${c.ERROR_HINT}`
-    )
-  }
-  return highestVersion
-}
-
-function determineToolName(javaVersion: string, isCommunity: boolean) {
-  return `graalvm${isCommunity ? '-community' : ''}-jdk-${javaVersion}_${c.JDK_PLATFORM}-${c.JDK_ARCH}_bin`
-}
-
-async function downloadGraalVMJDK(downloadUrl: string, javaVersion: string): Promise<string> {
-  try {
-    return await downloadTool(downloadUrl)
-  } catch (error) {
-    if (error instanceof Error && error.message.includes('404')) {
-      // Not Found
-      throw new Error(
-        `Failed to download ${basename(downloadUrl)}. Are you sure java-version: '${javaVersion}' is correct?`
-      )
-    }
-    throw new Error(`Failed to download ${basename(downloadUrl)} (error: ${error}).`)
-  }
-}
-
-// Support for GraalVM dev builds
-
-export async function setUpGraalVMJDKDevBuild(): Promise<string> {
-  const latestDevBuild = await getLatestRelease(GRAALVM_REPO_DEV_BUILDS)
-  const resolvedJavaVersion = findHighestJavaVersion(latestDevBuild, c.VERSION_DEV)
-  const downloadUrl = findDownloadUrl(latestDevBuild, resolvedJavaVersion)
-  return downloadAndExtractJDK(downloadUrl)
-}
-
-export function findHighestJavaVersion(release: c.LatestReleaseResponse['data'], version: string): string {
-  const graalVMIdentifierPattern = determineGraalVMLegacyIdentifier(false, version, '(\\d+)')
-  const expectedFileNameRegExp = new RegExp(
-    `^${graalVMIdentifierPattern}${c.GRAALVM_FILE_EXTENSION.replace(/\./g, '\\.')}$`
-  )
-  let highestJavaVersion = 0
-  for (const asset of release.assets) {
-    const matches = asset.name.match(expectedFileNameRegExp)
-    if (matches) {
-      const javaVersion = +matches[1]
-      if (javaVersion > highestJavaVersion) {
-        highestJavaVersion = javaVersion
-      }
-    }
-  }
-  if (highestJavaVersion > 0) {
-    return String(highestJavaVersion)
-  } else {
-    throw new Error(
-      'Could not find highest Java version. Please file an issue at: https://github.com/graalvm/setup-graalvm/issues.'
-    )
-  }
-}
-
-// Support for GraalVM 22.X releases and earlier
-
-export async function setUpGraalVMLatest_22_X(gdsToken: string, javaVersion: string): Promise<string> {
-  const lockedVersion = javaVersion === '19' ? '22.3.1' : '22.3.3'
+export async function setUpGraalVMLatest(
+  gdsToken: string,
+  javaVersion: string
+): Promise<string> {
   if (gdsToken.length > 0) {
-    return setUpGraalVMRelease(gdsToken, lockedVersion, javaVersion)
+    return setUpGraalVMRelease(gdsToken, c.VERSION_LATEST, javaVersion)
   }
-  const latestRelease = await getTaggedRelease(
-    c.GRAALVM_GH_USER,
-    c.GRAALVM_RELEASES_REPO,
-    GRAALVM_TAG_PREFIX + lockedVersion
+  const latestReleaseVersion = await getLatestReleaseVersion()
+  return setUpGraalVMRelease(gdsToken, latestReleaseVersion, javaVersion)
+}
+
+export async function getLatestReleaseVersion(): Promise<string> {
+  const latestRelease = await getLatestRelease(GRAALVM_REPO_RELEASES)
+  const tag_name = latestRelease.tag_name
+  if (tag_name.startsWith(GRAALVM_TAG_PREFIX)) {
+    return tag_name.substring(GRAALVM_TAG_PREFIX.length, tag_name.length)
+  }
+  throw new Error(`Could not find latest GraalVM release: ${tag_name}`)
+}
+
+export async function setUpGraalVMDevBuild(
+  gdsToken: string,
+  javaVersion: string
+): Promise<string> {
+  if (gdsToken.length > 0) {
+    throw new Error('Downloading GraalVM EE dev builds is not supported')
+  }
+  const latestDevBuild = await getLatestRelease(GRAALVM_REPO_DEV_BUILDS)
+  const graalVMIdentifier = determineGraalVMIdentifier(
+    false,
+    'dev',
+    javaVersion
   )
-  const version = findGraalVMVersion(latestRelease)
-  return setUpGraalVMRelease(gdsToken, version, javaVersion)
-}
-
-export function findGraalVMVersion(release: c.LatestReleaseResponse['data']) {
-  const tag_name = release.tag_name
-  if (!tag_name.startsWith(GRAALVM_TAG_PREFIX)) {
-    throw new Error(`Could not find latest GraalVM release: ${tag_name}`)
+  const expectedFileName = `${graalVMIdentifier}${c.GRAALVM_FILE_EXTENSION}`
+  for (const asset of latestDevBuild.assets) {
+    if (asset.name === expectedFileName) {
+      return downloadAndExtractJDK(asset.browser_download_url)
+    }
   }
-  return tag_name.substring(GRAALVM_TAG_PREFIX.length, tag_name.length)
+  throw new Error('Could not find GraalVM dev build')
 }
 
-export async function setUpGraalVMRelease(gdsToken: string, version: string, javaVersion: string): Promise<string> {
+export async function setUpGraalVMRelease(
+  gdsToken: string,
+  version: string,
+  javaVersion: string
+): Promise<string> {
   const isEE = gdsToken.length > 0
-  const toolName = determineLegacyToolName(isEE, version, javaVersion)
+  const graalVMIdentifier = determineGraalVMIdentifier(
+    isEE,
+    version,
+    javaVersion
+  )
+  const toolName = determineToolName(isEE, javaVersion)
   let downloader: () => Promise<string>
   if (isEE) {
-    downloader = async () => downloadGraalVMEELegacy(gdsToken, version, javaVersion)
+    downloader = async () => downloadGraalVMEE(gdsToken, version, javaVersion)
   } else {
-    downloader = async () => downloadGraalVMCELegacy(version, javaVersion)
+    const downloadUrl = `${GRAALVM_CE_DL_BASE}/${GRAALVM_TAG_PREFIX}${version}/${graalVMIdentifier}${c.GRAALVM_FILE_EXTENSION}`
+    downloader = async () => downloadTool(downloadUrl)
   }
   return downloadExtractAndCacheJDK(downloader, toolName, version)
 }
 
-function findDownloadUrl(release: c.LatestReleaseResponse['data'], javaVersion: string): string {
-  const graalVMIdentifier = determineGraalVMLegacyIdentifier(false, c.VERSION_DEV, javaVersion)
-  const expectedFileName = `${graalVMIdentifier}${c.GRAALVM_FILE_EXTENSION}`
-  for (const asset of release.assets) {
-    if (asset.name === expectedFileName) {
-      return asset.browser_download_url
-    }
-  }
-  throw new Error(
-    `Could not find GraalVM dev build for Java ${javaVersion}. It may no longer be available, so please consider upgrading the Java version. ${c.ERROR_HINT}`
-  )
+function determineGraalVMIdentifier(
+  isEE: boolean,
+  version: string,
+  javaVersion: string
+): string {
+  return `graalvm-${isEE ? 'ee' : 'ce'}-java${javaVersion}-${
+    c.GRAALVM_PLATFORM
+  }-${c.GRAALVM_ARCH}-${version}`
 }
 
-function determineGraalVMLegacyIdentifier(isEE: boolean, version: string, javaVersion: string): string {
-  return `${determineLegacyToolName(isEE, version, javaVersion)}-${c.GRAALVM_ARCH}-${version}`
-}
-
-function determineLegacyToolName(isEE: boolean, version: string, javaVersion: string): string {
-  const infix = isEE ? 'ee' : version === c.VERSION_DEV ? 'community' : 'ce'
-  return `graalvm-${infix}-java${javaVersion}-${c.GRAALVM_PLATFORM}`
-}
-
-async function downloadGraalVMCELegacy(version: string, javaVersion: string): Promise<string> {
-  const graalVMIdentifier = determineGraalVMLegacyIdentifier(false, version, javaVersion)
-  const downloadUrl = `${GRAALVM_CE_DL_BASE}/${GRAALVM_TAG_PREFIX}${version}/${graalVMIdentifier}${c.GRAALVM_FILE_EXTENSION}`
-  try {
-    return await downloadTool(downloadUrl)
-  } catch (error) {
-    if (error instanceof Error && error.message.includes('404')) {
-      // Not Found
-      throw new Error(
-        `Failed to download ${graalVMIdentifier}. Are you sure version: '${version}' and java-version: '${javaVersion}' are correct?`
-      )
-    }
-    throw new Error(`Failed to download ${graalVMIdentifier} (error: ${error}).`)
-  }
+function determineToolName(isEE: boolean, javaVersion: string): string {
+  return `graalvm-${isEE ? 'ee' : 'ce'}-java${javaVersion}-${
+    c.GRAALVM_PLATFORM
+  }`
 }

src/gu.ts

@@ -1,9 +1,6 @@
-import * as c from './constants'
-import * as core from '@actions/core'
-import * as semver from 'semver'
-import { GRAALVM_PLATFORM } from './constants'
-import { exec } from './utils'
-import { join } from 'path'
+import {GRAALVM_PLATFORM} from './constants'
+import {exec} from './utils'
+import {join} from 'path'
 
 const BASE_FLAGS = ['--non-interactive', 'install', '--no-progress']
 const COMPONENT_TO_POST_INSTALL_HOOK = new Map<string, Map<string, string>>([
@@ -25,40 +22,10 @@ const COMPONENT_TO_POST_INSTALL_HOOK = new Map<string, Map<string, string>>([
 ])
 
 export async function setUpGUComponents(
-  javaVersion: string,
-  graalVMVersion: string,
+  gdsToken: string,
   graalVMHome: string,
-  components: string[],
-  gdsToken: string
+  components: string[]
 ): Promise<void> {
-  if (components.length == 0) {
-    return // nothing to do
-  }
-  const coercedJavaVersion = semver.coerce(javaVersion)
-  if (
-    graalVMVersion === c.VERSION_DEV ||
-    javaVersion === c.VERSION_DEV ||
-    (coercedJavaVersion != null && semver.gte(coercedJavaVersion, '21.0.0'))
-  ) {
-    if (components.length == 1 && components[0] === 'native-image') {
-      core.warning(
-        `Please remove "components: 'native-image'" from your workflow file. It is automatically included since GraalVM for JDK 17: https://github.com/oracle/graal/pull/5995`
-      )
-    } else {
-      core.warning(
-        `Unable to install component(s): '${components.join(
-          ','
-        )}'. The latest GraalVM dev builds and the upcoming GraalVM for JDK 21 no longer include the GraalVM Updater: https://github.com/oracle/graal/issues/6855`
-      )
-    }
-  } else if (graalVMVersion.startsWith(c.MANDREL_NAMESPACE)) {
-    core.warning(`Mandrel does not support GraalVM component(s): '${components.join(',')}'`)
-  } else {
-    await installGUComponents(gdsToken, graalVMHome, components)
-  }
-}
-
-async function installGUComponents(gdsToken: string, graalVMHome: string, components: string[]): Promise<void> {
   await exec('gu', BASE_FLAGS.concat(components), {
     env: {
       ...process.env,

src/liberica.ts

@@ -1,97 +0,0 @@
-import * as c from './constants'
-import * as semver from 'semver'
-import { downloadExtractAndCacheJDK, getTaggedRelease, getMatchingTags } from './utils'
-import { downloadTool } from '@actions/tool-cache'
-import { spawnSync } from 'child_process'
-
-const LIBERICA_GH_USER = 'bell-sw'
-const LIBERICA_RELEASES_REPO = 'LibericaNIK'
-const LIBERICA_JDK_TAG_PREFIX = 'jdk-'
-const LIBERICA_VM_PREFIX = 'bellsoft-liberica-vm-'
-
-export async function setUpLiberica(javaVersion: string, javaPackage: string): Promise<string> {
-  const resolvedJavaVersion = await findLatestLibericaJavaVersion(javaVersion)
-  const downloadUrl = await findLibericaURL(resolvedJavaVersion, javaPackage)
-  const toolName = determineToolName(javaVersion, javaPackage)
-  return downloadExtractAndCacheJDK(async () => downloadTool(downloadUrl), toolName, javaVersion)
-}
-
-export async function findLatestLibericaJavaVersion(javaVersion: string): Promise<string> {
-  const matchingRefs = await getMatchingTags(
-    LIBERICA_GH_USER,
-    LIBERICA_RELEASES_REPO,
-    `${LIBERICA_JDK_TAG_PREFIX}${javaVersion}`
-  )
-  const noMatch = '0.0.1'
-  let bestMatch = noMatch
-  const prefixLength = `refs/tags/${LIBERICA_JDK_TAG_PREFIX}`.length
-  const patternLength = javaVersion.length
-  for (const matchingRef of matchingRefs) {
-    const version = matchingRef.ref.substring(prefixLength)
-    if (
-      semver.valid(version) &&
-      // pattern '17.0.1' should match '17.0.1+12' but not '17.0.10'
-      (version.length <= patternLength || !isDigit(version.charAt(patternLength))) &&
-      semver.compareBuild(version, bestMatch) == 1
-    ) {
-      bestMatch = version
-    }
-  }
-  if (bestMatch === noMatch) {
-    throw new Error(
-      `Unable to find the latest version for JDK${javaVersion}. Please make sure the java-version is set correctly. ${c.ERROR_HINT}`
-    )
-  }
-  return bestMatch
-}
-
-export async function findLibericaURL(javaVersion: string, javaPackage: string): Promise<string> {
-  const release = await getTaggedRelease(
-    LIBERICA_GH_USER,
-    LIBERICA_RELEASES_REPO,
-    LIBERICA_JDK_TAG_PREFIX + javaVersion
-  )
-  const platform = determinePlatformPart()
-  const assetPrefix = `${LIBERICA_VM_PREFIX}${determineVariantPart(javaPackage)}openjdk${javaVersion}`
-  const assetSuffix = `-${platform}${c.GRAALVM_FILE_EXTENSION}`
-  for (const asset of release.assets) {
-    if (asset.name.startsWith(assetPrefix) && asset.name.endsWith(assetSuffix)) {
-      return asset.browser_download_url
-    }
-  }
-  throw new Error(
-    `Unable to find asset for java-version: ${javaVersion}, java-package: ${javaPackage}, platform: ${platform}. ${c.ERROR_REQUEST}`
-  )
-}
-
-function determineToolName(javaVersion: string, javaPackage: string) {
-  const variant = determineVariantPart(javaPackage)
-  const platform = determinePlatformPart()
-  return `${LIBERICA_VM_PREFIX}${variant}${platform}`
-}
-
-function determineVariantPart(javaPackage: string) {
-  return javaPackage !== null && javaPackage.includes('+fx') ? 'full-' : ''
-}
-
-function determinePlatformPart() {
-  if (isMuslBasedLinux()) {
-    return `linux-${c.JDK_ARCH}-musl`
-  } else {
-    return `${c.JDK_PLATFORM}-${c.GRAALVM_ARCH}`
-  }
-}
-
-function isMuslBasedLinux() {
-  if (c.IS_LINUX) {
-    const output = spawnSync('ldd', ['--version']).stderr.toString('utf8')
-    if (output.includes('musl')) {
-      return true
-    }
-  }
-  return false
-}
-
-function isDigit(c: string) {
-  return c.charAt(0) >= '0' && c.charAt(0) <= '9'
-}

src/main.ts

@@ -1,122 +1,62 @@
 import * as c from './constants'
 import * as core from '@actions/core'
 import * as graalvm from './graalvm'
-import * as semver from 'semver'
-import { isFeatureAvailable as isCacheAvailable } from '@actions/cache'
-import { basename, join } from 'path'
-import { restore } from './features/cache'
-import { setUpDependencies } from './dependencies'
-import { setUpGUComponents } from './gu'
-import { setUpMandrel } from './mandrel'
-import { setUpLiberica } from './liberica'
-import { checkForUpdates } from './features/check-for-updates'
-import { setUpNativeImageMusl } from './features/musl'
-import { setUpWindowsEnvironment } from './msvc'
-import { setUpNativeImageBuildReports } from './features/reports'
-import { exec } from '@actions/exec'
-import { setUpSBOMSupport } from './features/sbom'
+import {isFeatureAvailable as isCacheAvailable} from '@actions/cache'
+import {join} from 'path'
+import {restore} from './features/cache'
+import {setUpDependencies} from './dependencies'
+import {setUpGUComponents} from './gu'
+import {setUpMandrel} from './mandrel'
+import {checkForUpdates} from './features/check-for-updates'
+import {setUpNativeImageMusl} from './features/musl'
+import {setUpWindowsEnvironment} from './msvc'
+import {setUpNativeImageBuildReports} from './features/reports'
 
 async function run(): Promise<void> {
   try {
-    const javaVersion = core.getInput(c.INPUT_JAVA_VERSION, { required: true })
-    const javaPackage = core.getInput(c.INPUT_JAVA_PACKAGE)
-    const distribution = core.getInput(c.INPUT_DISTRIBUTION)
-    const graalVMVersion = core.getInput(c.INPUT_VERSION)
+    const graalvmVersion = core.getInput(c.INPUT_VERSION, {required: true})
     const gdsToken = core.getInput(c.INPUT_GDS_TOKEN)
+    const javaVersion = core.getInput(c.INPUT_JAVA_VERSION, {required: true})
     const componentsString: string = core.getInput(c.INPUT_COMPONENTS)
-    const components: string[] = componentsString.length > 0 ? componentsString.split(',').map((x) => x.trim()) : []
+    const components: string[] =
+      componentsString.length > 0 ? componentsString.split(',') : []
     const setJavaHome = core.getInput(c.INPUT_SET_JAVA_HOME) === 'true'
     const cache = core.getInput(c.INPUT_CACHE)
-    const enableCheckForUpdates = core.getInput(c.INPUT_CHECK_FOR_UPDATES) === 'true'
+    const enableCheckForUpdates =
+      core.getInput(c.INPUT_CHECK_FOR_UPDATES) === 'true'
     const enableNativeImageMusl = core.getInput(c.INPUT_NI_MUSL) === 'true'
-    const isGraalVMforJDK17OrLater = distribution.length > 0 || graalVMVersion.length == 0
 
     if (c.IS_WINDOWS) {
-      setUpWindowsEnvironment(javaVersion, graalVMVersion, isGraalVMforJDK17OrLater)
+      setUpWindowsEnvironment()
     }
     await setUpDependencies(components)
     if (enableNativeImageMusl) {
       await setUpNativeImageMusl()
     }
 
-    // Download GraalVM JDK
+    // Download or build GraalVM
     let graalVMHome
-    if (isGraalVMforJDK17OrLater) {
-      if (
-        enableCheckForUpdates &&
-        (distribution === c.DISTRIBUTION_GRAALVM || distribution === c.DISTRIBUTION_GRAALVM_COMMUNITY)
-      ) {
-        checkForUpdates(graalVMVersion, javaVersion)
-      }
-      switch (distribution) {
-        case c.DISTRIBUTION_GRAALVM:
-          graalVMHome = await graalvm.setUpGraalVMJDK(javaVersion, gdsToken)
-          break
-        case c.DISTRIBUTION_GRAALVM_COMMUNITY:
-          graalVMHome = await graalvm.setUpGraalVMJDKCE(javaVersion)
-          break
-        case c.DISTRIBUTION_MANDREL:
-          graalVMHome = await setUpMandrel(graalVMVersion, javaVersion)
-          break
-        case c.DISTRIBUTION_LIBERICA:
-          graalVMHome = await setUpLiberica(javaVersion, javaPackage)
-          break
-        case '':
-          if (javaVersion === c.VERSION_DEV) {
-            core.info(
-              `This build is using GraalVM Community Edition. To select a specific distribution, use the 'distribution' option (see https://github.com/graalvm/setup-graalvm/tree/main#options).`
-            )
-            graalVMHome = await graalvm.setUpGraalVMJDKDevBuild()
-          } else {
-            core.info(
-              `This build is using the new Oracle GraalVM. To select a specific distribution, use the 'distribution' option (see https://github.com/graalvm/setup-graalvm/tree/main#options).`
-            )
-            graalVMHome = await graalvm.setUpGraalVMJDK(javaVersion, gdsToken)
+    switch (graalvmVersion) {
+      case c.VERSION_LATEST:
+        graalVMHome = await graalvm.setUpGraalVMLatest(gdsToken, javaVersion)
+        break
+      case c.VERSION_DEV:
+        graalVMHome = await graalvm.setUpGraalVMDevBuild(gdsToken, javaVersion)
+        break
+      default:
+        if (graalvmVersion.startsWith(c.MANDREL_NAMESPACE)) {
+          graalVMHome = await setUpMandrel(graalvmVersion, javaVersion)
+        } else {
+          if (enableCheckForUpdates) {
+            await checkForUpdates(graalvmVersion, javaVersion)
           }
-          break
-        default:
-          throw new Error(`Unsupported distribution: ${distribution}`)
-      }
-    } else {
-      const coercedJavaVersion = semver.coerce(javaVersion)
-      switch (graalVMVersion) {
-        case c.VERSION_LATEST:
-          if (
-            javaVersion.startsWith('17') ||
-            (coercedJavaVersion !== null && semver.gte(coercedJavaVersion, '20.0.0'))
-          ) {
-            core.info(
-              `This build is using the new Oracle GraalVM. To select a specific distribution, use the 'distribution' option (see https://github.com/graalvm/setup-graalvm/tree/main#options).`
-            )
-            graalVMHome = await graalvm.setUpGraalVMJDK(javaVersion, gdsToken)
-          } else {
-            graalVMHome = await graalvm.setUpGraalVMLatest_22_X(gdsToken, javaVersion)
-          }
-          break
-        case c.VERSION_DEV:
-          if (gdsToken.length > 0) {
-            throw new Error('Downloading GraalVM EE dev builds is not supported')
-          }
-          if (coercedJavaVersion !== null && !semver.gte(coercedJavaVersion, '21.0.0')) {
-            core.warning(
-              `GraalVM dev builds are only available for JDK 21. This build is now using a stable release of GraalVM for JDK ${javaVersion}.`
-            )
-            graalVMHome = await graalvm.setUpGraalVMJDK(javaVersion, gdsToken)
-          } else {
-            graalVMHome = await graalvm.setUpGraalVMJDKDevBuild()
-          }
-          break
-        default:
-          if (graalVMVersion.startsWith(c.MANDREL_NAMESPACE)) {
-            graalVMHome = await setUpMandrel(graalVMVersion, javaVersion)
-          } else {
-            if (enableCheckForUpdates) {
-              checkForUpdates(graalVMVersion, javaVersion)
-            }
-            graalVMHome = await graalvm.setUpGraalVMRelease(gdsToken, graalVMVersion, javaVersion)
-          }
-          break
-      }
+          graalVMHome = await graalvm.setUpGraalVMRelease(
+            gdsToken,
+            graalvmVersion,
+            javaVersion
+          )
+        }
+        break
     }
 
     // Activate GraalVM
@@ -126,19 +66,22 @@ async function run(): Promise<void> {
     if (setJavaHome) {
       core.exportVariable('JAVA_HOME', graalVMHome)
     }
-    await setUpGUComponents(javaVersion, graalVMVersion, graalVMHome, components, gdsToken)
+
+    // Set up GraalVM components (if any)
+    if (components.length > 0) {
+      if (graalvmVersion.startsWith(c.MANDREL_NAMESPACE)) {
+        core.warning(
+          `Mandrel does not support GraalVM components: ${componentsString}`
+        )
+      } else {
+        await setUpGUComponents(gdsToken, graalVMHome, components)
+      }
+    }
 
     if (cache && isCacheAvailable()) {
       await restore(cache)
     }
-    setUpNativeImageBuildReports(isGraalVMforJDK17OrLater, javaVersion, graalVMVersion)
-    setUpSBOMSupport(javaVersion, distribution)
-
-    core.startGroup(`Successfully set up '${basename(graalVMHome)}'`)
-    await exec(join(graalVMHome, 'bin', `java${c.EXECUTABLE_SUFFIX}`), [
-      javaVersion.startsWith('8') ? '-version' : '--version'
-    ])
-    core.endGroup()
+    setUpNativeImageBuildReports(graalvmVersion)
   } catch (error) {
     if (error instanceof Error) core.setFailed(error.message)
   }

src/mandrel.ts

@@ -1,34 +1,27 @@
 import * as c from './constants'
-import * as httpClient from '@actions/http-client'
-import { downloadExtractAndCacheJDK } from './utils'
-import { downloadTool } from '@actions/tool-cache'
-import { basename } from 'path'
+import {downloadExtractAndCacheJDK, getLatestRelease} from './utils'
+import {downloadTool} from '@actions/tool-cache'
 
-export const MANDREL_REPO = 'mandrel'
-export const MANDREL_TAG_PREFIX = c.MANDREL_NAMESPACE
+const MANDREL_REPO = 'mandrel'
+const MANDREL_TAG_PREFIX = c.MANDREL_NAMESPACE
 const MANDREL_DL_BASE = 'https://github.com/graalvm/mandrel/releases/download'
-const DISCO_API_BASE = 'https://api.foojay.io/disco/v3.0/packages/jdks'
 
-interface JdkData {
-  message: string
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  result: any
-  /* eslint-enable @typescript-eslint/no-explicit-any */
-}
+export async function setUpMandrel(
+  graalvmVersion: string,
+  javaVersion: string
+): Promise<string> {
+  const mandrelVersion = graalvmVersion.substring(
+    c.MANDREL_NAMESPACE.length,
+    graalvmVersion.length
+  )
 
-export async function setUpMandrel(mandrelVersion: string, javaVersion: string): Promise<string> {
-  const version = stripMandrelNamespace(mandrelVersion)
   let mandrelHome
-  switch (version) {
-    case '':
-      // fetch latest if no version is specified
-      mandrelHome = await setUpMandrelLatest(javaVersion)
-      break
+  switch (mandrelVersion) {
     case 'latest':
       mandrelHome = await setUpMandrelLatest(javaVersion)
       break
     default:
-      mandrelHome = await setUpMandrelRelease(version, javaVersion)
+      mandrelHome = await setUpMandrelRelease(mandrelVersion, javaVersion)
       break
   }
 
@@ -36,96 +29,39 @@ export async function setUpMandrel(mandrelVersion: string, javaVersion: string):
 }
 
 async function setUpMandrelLatest(javaVersion: string): Promise<string> {
-  const latest_release_url = await getLatestMandrelReleaseUrl(javaVersion)
-  const version_tag = getTagFromURI(latest_release_url)
-  const version = stripMandrelNamespace(version_tag)
-
-  const toolName = determineToolName(javaVersion)
-  return downloadExtractAndCacheJDK(async () => downloadTool(latest_release_url), toolName, version)
+  const latestRelease = await getLatestRelease(MANDREL_REPO)
+  const tag_name = latestRelease.tag_name
+  if (tag_name.startsWith(MANDREL_TAG_PREFIX)) {
+    const latestVersion = tag_name.substring(
+      MANDREL_TAG_PREFIX.length,
+      tag_name.length
+    )
+    return setUpMandrelRelease(latestVersion, javaVersion)
+  }
+  throw new Error(`Could not find latest Mandrel release: ${tag_name}`)
 }
 
-// Download URIs are of the form https://github.com/graalvm/mandrel/releases/download/<tag>/<archive-name>
-function getTagFromURI(uri: string): string {
-  const parts = uri.split('/')
-  try {
-    return parts[parts.length - 2]
-  } catch (error) {
-    throw new Error(`Failed to extract tag from URI ${uri}: ${error}`)
-  }
-}
-
-export async function getLatestMandrelReleaseUrl(javaVersion: string): Promise<string> {
-  const url = `${DISCO_API_BASE}?jdk_version=${javaVersion}&distribution=${c.DISTRIBUTION_MANDREL}&architecture=${c.JDK_ARCH}&operating_system=${c.JDK_PLATFORM}&latest=per_distro`
-  const _http = new httpClient.HttpClient()
-  const response = await _http.getJson<JdkData>(url)
-  if (response.statusCode !== 200) {
-    throw new Error(`Failed to fetch latest Mandrel release for Java ${javaVersion} from DISCO API: ${response.result}`)
-  }
-  const result = response.result?.result[0]
-  try {
-    const pkg_info_uri = result.links.pkg_info_uri
-    return await getLatestMandrelReleaseUrlHelper(_http, javaVersion, pkg_info_uri)
-  } catch (error) {
-    throw new Error(`Failed to get latest Mandrel release for Java ${javaVersion} from DISCO API: ${error}`)
-  }
-}
-
-async function getLatestMandrelReleaseUrlHelper(
-  _http: httpClient.HttpClient,
-  java_version: string,
-  pkg_info_uri: string
+async function setUpMandrelRelease(
+  version: string,
+  javaVersion: string
 ): Promise<string> {
-  const response = await _http.getJson<JdkData>(pkg_info_uri)
-  if (response.statusCode !== 200) {
-    throw new Error(
-      `Failed to fetch package info of latest Mandrel release for Java ${java_version} from DISCO API: ${response.result}`
-    )
-  }
-  const result = response.result?.result[0]
-  try {
-    return result.direct_download_uri
-  } catch (error) {
-    throw new Error(
-      `Failed to get download URI of latest Mandrel release for Java ${java_version} from DISCO API: ${error}`
-    )
-  }
-}
-
-async function setUpMandrelRelease(version: string, javaVersion: string): Promise<string> {
-  const toolName = determineToolName(javaVersion)
-  return downloadExtractAndCacheJDK(async () => downloadMandrelJDK(version, javaVersion), toolName, version)
-}
-
-async function downloadMandrelJDK(version: string, javaVersion: string): Promise<string> {
   const identifier = determineMandrelIdentifier(version, javaVersion)
   const downloadUrl = `${MANDREL_DL_BASE}/${MANDREL_TAG_PREFIX}${version}/${identifier}${c.GRAALVM_FILE_EXTENSION}`
-  try {
-    return await downloadTool(downloadUrl)
-  } catch (error) {
-    if (error instanceof Error && error.message.includes('404')) {
-      // Not Found
-      throw new Error(
-        `Failed to download ${basename(
-          downloadUrl
-        )}. Are you sure version: '${version}' and java-version: '${javaVersion}' are correct?`
-      )
-    }
-    throw new Error(`Failed to download ${basename(downloadUrl)} (error: ${error}).`)
-  }
+  const toolName = determineToolName(javaVersion)
+  return downloadExtractAndCacheJDK(
+    async () => downloadTool(downloadUrl),
+    toolName,
+    version
+  )
 }
 
-function determineMandrelIdentifier(version: string, javaVersion: string): string {
+function determineMandrelIdentifier(
+  version: string,
+  javaVersion: string
+): string {
   return `mandrel-java${javaVersion}-${c.GRAALVM_PLATFORM}-${c.GRAALVM_ARCH}-${version}`
 }
 
 function determineToolName(javaVersion: string): string {
   return `mandrel-java${javaVersion}-${c.GRAALVM_PLATFORM}`
 }
-
-export function stripMandrelNamespace(graalVMVersion: string) {
-  if (graalVMVersion.startsWith(c.MANDREL_NAMESPACE)) {
-    return graalVMVersion.substring(c.MANDREL_NAMESPACE.length, graalVMVersion.length)
-  } else {
-    return graalVMVersion
-  }
-}

src/msvc.ts

@@ -1,23 +1,18 @@
 import * as core from '@actions/core'
-import { execSync } from 'child_process'
-import { existsSync } from 'fs'
-import { VERSION_DEV } from './constants'
+import {execSync} from 'child_process'
+import {existsSync} from 'fs'
 
 // Keep in sync with https://github.com/actions/virtual-environments
 const KNOWN_VISUAL_STUDIO_INSTALLATIONS = [
-  'C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise', // 'windows-2022' and 'windows-latest'
-  'C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise', // 'windows-2019'
-  'C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Enterprise' // 'windows-2016' (deprecated and removed)
+  'C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Enterprise', // 'windows-2016'
+  'C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise', // 'windows-2019' and 'windows-latest'
+  'C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise' // 'windows-2022'
 ]
-if (process.env['VSINSTALLDIR']) {
-  // if VSINSTALLDIR is set, make it the first known installation
-  KNOWN_VISUAL_STUDIO_INSTALLATIONS.unshift(process.env['VSINSTALLDIR'].replace(/\\$/, ''))
-}
-const VCVARSALL_SUBPATH = 'VC\\Auxiliary\\Build\\vcvarsall.bat'
+const VCVARSALL_SUBPATH = '\\VC\\Auxiliary\\Build\\vcvarsall.bat'
 
 function findVcvarsallPath(): string {
   for (const installation of KNOWN_VISUAL_STUDIO_INSTALLATIONS) {
-    const candidate = `${installation}\\${VCVARSALL_SUBPATH}`
+    const candidate = `${installation}${VCVARSALL_SUBPATH}`
     if (existsSync(candidate)) {
       return candidate
     }
@@ -25,35 +20,15 @@ function findVcvarsallPath(): string {
   throw new Error('Failed to find vcvarsall.bat')
 }
 
-export function needsWindowsEnvironmentSetup(
-  javaVersion: string,
-  graalVMVersion: string,
-  isGraalVMforJDK17OrLater: boolean
-): boolean {
-  if (javaVersion === VERSION_DEV || graalVMVersion === VERSION_DEV) {
-    return false // no longer required in dev builds
-  } else if (isGraalVMforJDK17OrLater) {
-    return false // no longer required in GraalVM for JDK 17 and later.
-  }
-  return true
-}
-
-export function setUpWindowsEnvironment(
-  javaVersion: string,
-  graalVMVersion: string,
-  isGraalVMforJDK17OrLater: boolean
-): void {
-  if (!needsWindowsEnvironmentSetup(javaVersion, graalVMVersion, isGraalVMforJDK17OrLater)) {
-    return
-  }
-
+export function setUpWindowsEnvironment(): void {
   core.startGroup('Updating Windows environment...')
 
   const vcvarsallPath = findVcvarsallPath()
   core.debug(`Calling "${vcvarsallPath}"...`)
-  const [originalEnv, vcvarsallOutput, updatedEnv] = execSync(`set && cls && "${vcvarsallPath}" x64 && cls && set`, {
-    shell: 'cmd'
-  })
+  const [originalEnv, vcvarsallOutput, updatedEnv] = execSync(
+    `set && cls && "${vcvarsallPath}" x64 && cls && set`,
+    {shell: 'cmd'}
+  )
     .toString()
     .split('\f') // form feed page break (printed by `cls`)
   core.debug(vcvarsallOutput)

src/utils.ts

@@ -2,36 +2,43 @@ import * as c from './constants'
 import * as core from '@actions/core'
 import * as github from '@actions/github'
 import * as httpClient from '@actions/http-client'
-import * as semver from 'semver'
 import * as tc from '@actions/tool-cache'
-import * as fs from 'fs'
-import { ExecOptions, exec as e } from '@actions/exec'
-import { readFileSync, readdirSync } from 'fs'
-import { Octokit } from '@octokit/core'
-import { createHash } from 'crypto'
-import { join } from 'path'
-import { tmpdir } from 'os'
+import {ExecOptions, exec as e} from '@actions/exec'
+import {readFileSync, readdirSync} from 'fs'
+import {Octokit} from '@octokit/core'
+import {createHash} from 'crypto'
+import {join} from 'path'
 
-// Set up Octokit for github.com only and in the same way as @actions/github (see https://git.io/Jy9YP)
-const baseUrl = 'https://api.github.com'
-const GitHubDotCom = Octokit.defaults({
+// Set up Octokit in the same way as @actions/github (see https://git.io/Jy9YP)
+const baseUrl = process.env['GITHUB_API_URL'] || 'https://api.github.com'
+const GitHub = Octokit.defaults({
   baseUrl,
   request: {
     agent: new httpClient.HttpClient().getAgent(baseUrl)
   }
 })
 
-export async function exec(commandLine: string, args?: string[], options?: ExecOptions | undefined): Promise<void> {
+export async function exec(
+  commandLine: string,
+  args?: string[],
+  options?: ExecOptions | undefined
+): Promise<void> {
   const exitCode = await e(commandLine, args, options)
   if (exitCode !== 0) {
-    throw new Error(`'${[commandLine].concat(args || []).join(' ')}' exited with a non-zero code: ${exitCode}`)
+    throw new Error(
+      `'${[commandLine]
+        .concat(args || [])
+        .join(' ')}' exited with a non-zero code: ${exitCode}`
+    )
   }
 }
 
-export async function getLatestRelease(repo: string): Promise<c.LatestReleaseResponse['data']> {
+export async function getLatestRelease(
+  repo: string
+): Promise<c.LatestReleaseResponse['data']> {
   const githubToken = getGitHubToken()
-  const options = githubToken.length > 0 ? { auth: githubToken } : {}
-  const octokit = new GitHubDotCom(options)
+  const options = githubToken.length > 0 ? {auth: githubToken} : {}
+  const octokit = new GitHub(options)
   return (
     await octokit.request('GET /repos/{owner}/{repo}/releases/latest', {
       owner: c.GRAALVM_GH_USER,
@@ -40,55 +47,12 @@ export async function getLatestRelease(repo: string): Promise<c.LatestReleaseRes
   ).data
 }
 
-export async function getContents(repo: string, path: string): Promise<c.ContentsResponse['data']> {
-  const githubToken = getGitHubToken()
-  const options = githubToken.length > 0 ? { auth: githubToken } : {}
-  const octokit = new GitHubDotCom(options)
-  return (
-    await octokit.request('GET /repos/{owner}/{repo}/contents/{path}', {
-      owner: c.GRAALVM_GH_USER,
-      repo,
-      path
-    })
-  ).data
-}
-
-export async function getTaggedRelease(
-  owner: string,
-  repo: string,
-  tag: string
-): Promise<c.LatestReleaseResponse['data']> {
-  const githubToken = getGitHubToken()
-  const options = githubToken.length > 0 ? { auth: githubToken } : {}
-  const octokit = new GitHubDotCom(options)
-  return (
-    await octokit.request('GET /repos/{owner}/{repo}/releases/tags/{tag}', {
-      owner,
-      repo,
-      tag
-    })
-  ).data
-}
-
-export async function getMatchingTags(
-  owner: string,
-  repo: string,
-  tagPrefix: string
-): Promise<c.MatchingRefsResponse['data']> {
-  const githubToken = getGitHubToken()
-  const options = githubToken.length > 0 ? { auth: githubToken } : {}
-  const octokit = new GitHubDotCom(options)
-  return (
-    await octokit.request('GET /repos/{owner}/{repo}/git/matching-refs/tags/{tagPrefix}', {
-      owner,
-      repo,
-      tagPrefix
-    })
-  ).data
-}
-
-export async function downloadAndExtractJDK(downloadUrl: string): Promise<string> {
-  return findJavaHomeInSubfolder(await extract(await tc.downloadTool(downloadUrl)))
+export async function downloadAndExtractJDK(
+  downloadUrl: string
+): Promise<string> {
+  return findJavaHomeInSubfolder(
+    await extract(await tc.downloadTool(downloadUrl))
+  )
 }
 
 export async function downloadExtractAndCacheJDK(
@@ -120,7 +84,9 @@ async function extract(downloadPath: string): Promise<string> {
   } else if (c.GRAALVM_FILE_EXTENSION === '.zip') {
     return await tc.extractZip(downloadPath)
   } else {
-    throw new Error(`Unexpected filetype downloaded: ${c.GRAALVM_FILE_EXTENSION}`)
+    throw new Error(
+      `Unexpected filetype downloaded: ${c.GRAALVM_FILE_EXTENSION}`
+    )
   }
 }
 
@@ -129,27 +95,23 @@ function findJavaHomeInSubfolder(searchPath: string): string {
   if (baseContents.length === 1) {
     return join(searchPath, baseContents[0], c.JDK_HOME_SUFFIX)
   } else {
-    throw new Error(`Unexpected amount of directory items found: ${baseContents.length}`)
+    throw new Error(
+      `Unexpected amount of directory items found: ${baseContents.length}`
+    )
   }
 }
 
+/**
+ * This helper turns GraalVM version numbers (e.g., `22.0.0.2`) into valid
+ * semver.org versions (e.g., `22.0.0-2`), which is needed because
+ * @actions/tool-cache uses `semver` to validate versions.
+ */
 export function toSemVer(version: string): string {
   const parts = version.split('.')
-  if (parts.length === 4) {
-    /**
-     * Turn legacy GraalVM version numbers (e.g., `22.0.0.2`) into valid
-     * semver.org versions (e.g., `22.0.0-2`).
-     */
-    return `${parts[0]}.${parts[1]}.${parts.slice(2).join('-')}`
-  }
-
-  const versionParts = version.split('-', 2)
-  const suffix = versionParts.length === 2 ? '-' + versionParts[1] : ''
-  const validVersion = semver.valid(semver.coerce(versionParts[0]) + suffix)
-  if (!validVersion) {
-    throw new Error(`Unable to convert '${version}' to semantic version. ${c.ERROR_HINT}`)
-  }
-  return validVersion
+  const major = parts[0]
+  const minor = parts.length > 1 ? parts[1] : '0'
+  const patch = parts.length > 2 ? parts.slice(2).join('-') : '0'
+  return `${major}.${minor}.${patch}`
 }
 
 export function isPREvent(): boolean {
@@ -160,101 +122,14 @@ function getGitHubToken(): string {
   return core.getInput(c.INPUT_GITHUB_TOKEN)
 }
 
-export async function findExistingPRCommentId(bodyStartsWith: string): Promise<number | undefined> {
-  if (!isPREvent()) {
-    throw new Error('Not a PR event.')
-  }
-
-  const context = github.context
-  const octokit = github.getOctokit(getGitHubToken())
-  try {
-    const comments = await octokit.paginate(octokit.rest.issues.listComments, {
-      ...context.repo,
-      issue_number: context.payload.pull_request?.number as number
-    })
-    const matchingComment = comments.reverse().find((comment) => {
-      return comment.body && comment.body.startsWith(bodyStartsWith)
-    })
-    return matchingComment ? matchingComment.id : undefined
-  } catch (err) {
-    core.error(
-      `Failed to list pull request comments. Please make sure this job has 'write' permissions for the 'pull-requests' scope (see https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#permissions)? Internal error: ${err}`
-    )
-  }
-}
-
-export async function updatePRComment(content: string, commentId: number): Promise<void> {
-  if (!isPREvent()) {
-    throw new Error('Not a PR event.')
-  }
-
-  try {
-    await github.getOctokit(getGitHubToken()).rest.issues.updateComment({
-      ...github.context.repo,
-      comment_id: commentId,
-      body: content
-    })
-  } catch (err) {
-    core.error(
-      `Failed to update pull request comment. Please make sure this job has 'write' permissions for the 'pull-requests' scope (see https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#permissions)? Internal error: ${err}`
-    )
-  }
-}
-
 export async function createPRComment(content: string): Promise<void> {
   if (!isPREvent()) {
     throw new Error('Not a PR event.')
   }
   const context = github.context
-  try {
-    await github.getOctokit(getGitHubToken()).rest.issues.createComment({
-      ...context.repo,
-      issue_number: context.payload.pull_request?.number as number,
-      body: content
-    })
-  } catch (err) {
-    core.error(
-      `Failed to create pull request comment. Please make sure this job has 'write' permissions for the 'pull-requests' scope (see https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#permissions)? Internal error: ${err}`
-    )
-  }
-}
-
-export function tmpfile(fileName: string) {
-  return join(tmpdir(), fileName)
-}
-
-export function setNativeImageOption(javaVersionOrDev: string, optionValue: string): void {
-  const coercedJavaVersionOrDev = semver.coerce(javaVersionOrDev)
-  if (
-    (coercedJavaVersionOrDev && semver.gte(coercedJavaVersionOrDev, '22.0.0')) ||
-    javaVersionOrDev === c.VERSION_DEV ||
-    javaVersionOrDev.endsWith('-ea')
-  ) {
-    /* NATIVE_IMAGE_OPTIONS was introduced in GraalVM for JDK 22 (so were EA builds). */
-    let newOptionValue = optionValue
-    const existingOptions = process.env[c.NATIVE_IMAGE_OPTIONS_ENV]
-    if (existingOptions) {
-      newOptionValue = `${existingOptions} ${newOptionValue}`
-    }
-    core.exportVariable(c.NATIVE_IMAGE_OPTIONS_ENV, newOptionValue)
-  } else {
-    const optionsFile = getNativeImageOptionsFile()
-    if (fs.existsSync(optionsFile)) {
-      fs.appendFileSync(optionsFile, ` ${optionValue}`)
-    } else {
-      fs.writeFileSync(optionsFile, `NativeImageArgs = ${optionValue}`)
-    }
-  }
-}
-
-const NATIVE_IMAGE_CONFIG_FILE = tmpfile('native-image-options.properties')
-const NATIVE_IMAGE_CONFIG_FILE_ENV = 'NATIVE_IMAGE_CONFIG_FILE'
-
-function getNativeImageOptionsFile(): string {
-  let optionsFile = process.env[NATIVE_IMAGE_CONFIG_FILE_ENV]
-  if (optionsFile === undefined) {
-    optionsFile = NATIVE_IMAGE_CONFIG_FILE
-    core.exportVariable(NATIVE_IMAGE_CONFIG_FILE_ENV, optionsFile)
-  }
-  return optionsFile
+  await github.getOctokit(getGitHubToken()).rest.issues.createComment({
+    ...context.repo,
+    issue_number: context.payload.pull_request?.number as number,
+    body: content
+  })
 }

tsconfig.base.json

@@ -1,23 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "compilerOptions": {
-    "allowSyntheticDefaultImports": true,
-    "declaration": false,
-    "declarationMap": false,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "lib": ["ES2022"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "newLine": "lf",
-    "noImplicitAny": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": false,
-    "pretty": true,
-    "resolveJsonModule": true,
-    "sourceMap": true,
-    "strict": true,
-    "strictNullChecks": true,
-    "target": "ES2022"
-  }
-}

tsconfig.eslint.json

@@ -1,10 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "allowJs": true,
-    "noEmit": true
-  },
-  "exclude": ["dist", "node_modules"],
-  "include": ["__tests__", "src", "eslint.config.mjs", "jest.config.js"]
-}

tsconfig.json

@@ -1,11 +1,12 @@
 {
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.base.json",
   "compilerOptions": {
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist"
+    "target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */
+    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
+    "outDir": "./lib",                        /* Redirect output structure to the directory. */
+    "rootDir": "./src",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    "strict": true,                           /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                    /* Raise error on expressions and declarations with an implied 'any' type. */
+    "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
   },
-  "exclude": ["__fixtures__", "__tests__", "coverage", "dist", "node_modules"],
-  "include": ["src"]
+  "exclude": ["node_modules", "**/*.test.ts"]
 }