.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
+# `dist/index.js` is a special file in Actions.
-# an action with the `uses:` property, `dist/index.js` is the code that will be
+# When you reference an action with `uses:` in a workflow,
-# run. For this project, the `dist/index.js` file is transpiled from other
+# `index.js` is the code that will run.
-# source files. This workflow ensures the `dist/` directory contains the
+# For our project, we generate this file through a build process from other source files.
-# expected transpiled code.
+# We need to make sure the checked-in `index.js` actually matches what we expect it to be.
-#
+name: Check dist/
-# 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
 
 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
+      - uses: actions/checkout@v3
-        id: checkout
-        uses: actions/checkout@v4
 
-      - name: Setup Node.js
+      - name: Set Node.js 16.x
-        id: setup-node
+        uses: actions/setup-node@v3
-        uses: actions/setup-node@v4
         with:
-          node-version-file: .node-version
+          node-version: 16.x
           cache: npm
 
-      - name: Install Dependencies
+      - name: Install dependencies
-        id: install
         run: npm ci
 
-      - name: Build dist/ Directory
+      - name: Rebuild the dist/ directory
-        id: build
+        run: npm run build
-        run: npm run bundle
 
-      # This will fail the workflow if the `dist/` directory is different than
+      - name: Compare the expected and actual dist/ directories
-      # expected.
-      - name: Compare Directories
-        id: diff
         run: |
-          if [ ! -d dist/ ]; then
+          if [ "$(git diff --ignore-space-at-eol dist/ | wc -l)" -gt "0" ]; 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/
+            git diff
             exit 1
           fi
+        id: diff
 
-      # If `dist/` was different than expected, upload the expected version as a
+      # If index.js was different than expected, upload the expected version as an artifact
-      # workflow artifact.
+      - uses: actions/upload-artifact@v3
-      - if: ${{ failure() && steps.diff.outcome == 'failure' }}
+        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
-        name: Upload Artifact
-        id: upload
-        uses: actions/upload-artifact@v4
         with:
           name: dist
           path: dist/

.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: Continuous Integration
+name: 'build-test'
 
 on:
   push:
@@ -8,89 +8,41 @@ on:
     paths-ignore:
       - '**.md'
   workflow_dispatch:
-
 permissions:
   contents: read
 
 jobs:
-  test-typescript:
+  build: # make sure build/ci work properly
-    name: TypeScript Tests
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout
+      - uses: actions/checkout@v3
-        uses: actions/checkout@v4
+      - run: |
-      - name: Setup Node.js
+          npm install
-        uses: actions/setup-node@v4
+      - run: |
-        with:
+          npm run all
-          node-version-file: .node-version
+  test:
-          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']
+        java-version: ['17', '20', 'dev']
         distribution: ['graalvm', 'graalvm-community']
-        os: [
+        os: [macos-latest, windows-latest, ubuntu-latest]
-            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'
+          - java-version: '17.0.7'
-            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
+      - uses: actions/checkout@v3
       - 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"
@@ -103,17 +55,15 @@ jobs:
           java --version
           java --version | grep "GraalVM" || exit 34
           native-image --version
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' && runner.os != 'Windows' }}
+        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: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' && runner.os == 'Windows' }}
+  test-ce: # make sure the action works on a clean machine without building
-
+    needs: test  
-  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:
@@ -131,15 +81,11 @@ jobs:
           - version: '22.2.0' # for update notifications
             java-version: '17'
             components: 'native-image'
-            os: ubuntu-22.04
+            os: ubuntu-20.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
+            java-version: '11' # for JDK11 notification
             components: 'native-image'
-            os: macos-13
+            os: macos-11
           - version: '22.3.1'
             java-version: '17'
             components: 'native-image'
@@ -149,7 +95,7 @@ jobs:
             components: 'native-image'
             os: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Run setup-graalvm action
         uses: ./
         with:
@@ -160,53 +106,47 @@ jobs:
       - name: Check environment
         run: |
           echo "GRAALVM_HOME: $GRAALVM_HOME"
-          if [[ "${{ matrix.version }}" == "dev" ]] && [[ "${{ matrix.java-version }}" == "dev" ]]; then
+          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
-          java -version 2>&1 | grep "GraalVM" || exit 34
+          java --version | grep "GraalVM" || exit 34
           native-image --version
-          if [[ "${{ matrix.java-version }}" != "dev" ]]; then
           gu list
-          fi
+        if: runner.os != 'Windows'
-        if: ${{ runner.os != 'Windows' }}
       - name: Check Windows environment
         run: |
           echo "GRAALVM_HOME: $env:GRAALVM_HOME"
           echo "JAVA_HOME: $env:JAVA_HOME"
-          java -version
+          java --version
           native-image --version
           gu.cmd remove native-image
-        if: ${{ runner.os == 'Windows' }}
+        if: runner.os == 'Windows'
-
+  test-ee:
-  test-action-ee:
+    needs: test
-    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']
+        java-version: ['19']
         components: ['native-image']
         os: [macos-latest, windows-latest, ubuntu-latest]
         include:
-          - version: '22.3.3'
+          - version: '22.3.0'
             java-version: '11'
             components: 'native-image'
             os: ubuntu-latest
-          - version: '22.3.3'
+          - version: '22.3.0'
             java-version: '17'
             components: 'native-image'
             os: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Run setup-graalvm action
         uses: ./
         with:
@@ -215,17 +155,16 @@ jobs:
           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
+          java --version | grep "GraalVM EE" || exit 23
           native-image --version
           gu list
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' && runner.os != 'Windows' }}
+        if: runner.os != 'Windows'
       - name: Check Windows environment
         run: |
           echo "GRAALVM_HOME: $env:GRAALVM_HOME"
@@ -233,15 +172,14 @@ jobs:
           java --version
           native-image --version
           gu.cmd remove native-image
-        if: ${{ env.PASSES_GDS_TOKEN_CHECK == 'true' && runner.os == 'Windows' }}
+        if: runner.os == 'Windows'
-
+  test-mandrel:
-  test-action-mandrel:
+    needs: test
-    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']
+        version: ['mandrel-22.2.0.0-Final', 'mandrel-latest']
         java-version: ['17']
         distribution: ['mandrel']
         os: [windows-latest, ubuntu-latest]
@@ -250,12 +188,12 @@ jobs:
             java-version: '17'
             distribution: '' # test empty distribution for backward compatibility
             os: ubuntu-latest
-          - version: '' # test with no version
+        exclude: # temporarily disable Mandrel latest builds on Windows due to unavailability
-            java-version: '21'
+          - version: 'mandrel-latest'
-            distribution: 'mandrel'
+            java-version: '17'
-            os: ubuntu-latest
+            os: windows-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Run setup-graalvm action
         uses: ./
         with:
@@ -269,68 +207,23 @@ jobs:
           [[ "$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' }}
+        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' }}
+        if: runner.os == 'Windows'
-
+  test-native-image-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
+      - uses: actions/checkout@v3
       - name: Run setup-graalvm action
         uses: ./
         with:
@@ -345,15 +238,14 @@ jobs:
           javac HelloWorld.java
           native-image HelloWorld
           ./helloworld
-
+  test-native-image-windows-msvc:
-  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
+      - uses: actions/checkout@v3
       - name: Run setup-graalvm action
         uses: ./
         with:
@@ -368,15 +260,14 @@ jobs:
           javac HelloWorld.java
           native-image HelloWorld
           ./helloworld
-
+  test-native-image-musl:
-  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
+      - uses: actions/checkout@v3
       - name: Run setup-graalvm action
         uses: ./
         with:
@@ -392,19 +283,18 @@ jobs:
           javac HelloWorld.java
           native-image --static --libc=musl HelloWorld
           ./helloworld
-
+  test-extensive:
-  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
+      - uses: actions/checkout@v3
       - name: Run setup-graalvm action
         uses: ./
         with:
-          java-version: '17.0.8'
+          java-version: '17'
           distribution: 'graalvm'
           components: 'espresso,llvm-toolchain,native-image,nodejs,python,ruby,wasm'
           set-java-home: 'false'
@@ -435,53 +325,16 @@ jobs:
           javac HelloWorld.java
           native-image -g HelloWorld
           ./helloworld
-      # - name: Build Ruby-FFI with TruffleRuby
+      - name: Build Ruby-FFI with TruffleRuby
-      #   run: |
+        run: |
-      #     [[ $(which bundle) == *"graalvm"* ]] || exit 57
+          [[ $(which bundle) == *"graalvm"* ]] || exit 57
-      #     git clone --depth 1 https://github.com/ffi/ffi.git
+          git clone --depth 1 https://github.com/ffi/ffi.git
-      #     pushd ffi > /dev/null
+          pushd ffi > /dev/null
-      #     # https://github.com/ffi/ffi/blob/447845cb3030194c79700c86fb388a12e6f81386/.github/workflows/ci.yml#L58-L62
+          # https://github.com/ffi/ffi/blob/447845cb3030194c79700c86fb388a12e6f81386/.github/workflows/ci.yml#L58-L62
-      #     bundle install
+          bundle install
-      #     bundle exec rake libffi
+          bundle exec rake libffi
-      #     bundle exec rake compile
+          bundle exec rake compile
-      #     bundle exec rake test
+          bundle exec rake test
-      #     popd > /dev/null
+          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' }}

.gitignore

@@ -97,6 +97,3 @@ Thumbs.db
 # Ignore built ts files
 __tests__/runner/*
 lib/**/*
-
-# Ignore target directory in __tests__
-__tests__/**/target

.node-version

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

.prettierignore

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

.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,20 +1,48 @@
-# 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)
+# 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 [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].
+This GitHub action sets up [Oracle GraalVM][graalvm-medium], GraalVM [Community Edition (CE)][repo], [Enterprise Edition (EE)][graalvm-ee], or [Mandrel][mandrel], as well as [Native Image][native-image] and GraalVM components such as [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))
+- supports Oracle GraalVM [releases][graalvm-dl], 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))
 - 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 `x64` and `aarch64` (selected automatically, `aarch64` requires a [self-hosted runner][gha-self-hosted-runners])
 - supports dependency caching for Apache Maven, Gradle, and sbt (see [`cache` option](#options))
 - sets up Windows environments with build tools using [vcvarsall.bat][vcvarsall]
 - has built-in support for GraalVM components and the [GraalVM Updater][gu]
 
 
+## Migrating from GraalVM 22.3 or Earlier to the New GraalVM for JDK 17 and Later
+
+The new [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.7' # for a specific JDK 17; or '17' for the latest JDK 17
+    distribution: 'graalvm' # New 'distribution' option
+    # ...
+```
+
+
 ## Templates
 
 ### Quickstart Template
@@ -26,11 +54,11 @@ 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
+          java-version: '17.0.7'
-          distribution: 'graalvm' # See 'Supported distributions' for available options
+          distribution: 'graalvm' # See 'Options' for all available distributions
           github-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Example step
         run: |
@@ -57,11 +85,11 @@ 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'
+          java-version: '17.0.7'
           distribution: 'graalvm'
           github-token: ${{ secrets.GITHUB_TOKEN }}
           native-image-job-reports: 'true'
@@ -74,72 +102,31 @@ 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
+<details>
+<summary><h4>Template for older GraalVM releases</h4></summary>
 
 ```yml
-name: Oracle GraalVM Early Access build
+name: GraalVM 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: '24-ea' # or 'latest-ea' for the latest Java version available
+          version: '22.3.2' # GraalVM version
-          distribution: 'graalvm'
+          java-version: '17'
+          components: 'native-image'
           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>
@@ -150,16 +137,16 @@ jobs:
 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
+```yml
-    name: GraalVM Enterprise Edition build
+name: GraalVM Enterprise Edition build
-    on: [push, pull_request]
+on: [push, pull_request]
-    jobs:
+jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-          - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - uses: graalvm/setup-graalvm@v1
         with:
           version: '22.3.0'
@@ -171,32 +158,16 @@ jobs:
         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/) |
-
-
 ## 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> |
+| `java-version`<br>*(required)* | n/a | `'17.0.7'` or `'20.0.1'` for a specific Java version, `'dev'` for a dev build with the latest Java version available.<br>(`'8'`, `'11'`, `'16'`, `'19'` are supported for older GraalVM releases.) |
-| `distribution`  | `'graalvm'` | GraalVM distribution (see [supported distributions](#supported-distributions)) |
+| `distribution`  | `''` | GraalVM distribution (`graalvm` for Oracle GraalVM, `graalvm-community` for GraalVM Community Edition, `mandrel` for Mandrel). |
-| `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. |
 | `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]. |
@@ -204,55 +175,13 @@ This actions can be configured with the following options:
 | `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-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. |
+| `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` (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 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. |
+| `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](#template-for-graalvm-enterprise-edition)). |
 
 **) 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,8 +191,6 @@ 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
@@ -273,7 +200,6 @@ Only pull requests from committers that can be verified as having signed the OCA
 [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 {mkdtempSync} from 'fs'
-import { tmpdir } from 'os'
+import {tmpdir} from 'os'
-import { join } from 'path'
+import {join} from 'path'
-import { restore, save } from '../src/features/cache'
+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(spyCacheRestore).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith('maven cache is not found')
+        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(spyCacheRestore).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith('gradle cache is not found')
+        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(spyCacheRestore).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith('gradle cache is not found')
+        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(spyCacheRestore).toBeCalled()
-      expect(spyWarning).not.toHaveBeenCalled()
+      expect(spyWarning).not.toBeCalled()
-      expect(spyInfo).toHaveBeenCalledWith('gradle cache is not found')
+      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(spyCacheRestore).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith('sbt cache is not found')
+        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(spyCacheSave).toBeCalled()
-      expect(spyWarning).not.toHaveBeenCalled()
+      expect(spyWarning).not.toBeCalled()
-      expect(spyInfo).toHaveBeenCalled()
+      expect(spyInfo).toBeCalled()
-      expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+      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(spyCacheSave).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        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(spyCacheSave).not.toBeCalled()
-        expect(spyWarning).toHaveBeenCalledWith('Error retrieving key from state.')
+        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(spyCacheSave).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        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(spyCacheSave).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        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(spyCacheSave).not.toBeCalled()
-        expect(spyWarning).toHaveBeenCalledWith('Error retrieving key from state.')
+        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(spyCacheSave).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        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(spyCacheSave).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        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(spyCacheSave).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        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(spyCacheSave).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        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(spyCacheSave).not.toBeCalled()
-        expect(spyWarning).toHaveBeenCalledWith('Error retrieving key from state.')
+        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(spyCacheSave).toBeCalled()
-        expect(spyWarning).not.toHaveBeenCalled()
+        expect(spyWarning).not.toBeCalled()
-        expect(spyInfo).toHaveBeenCalledWith(expect.stringMatching(/^Cache saved with the key:.*/))
+        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 () => {
+  it('does not fail nor warn even when the save provess throws a ReserveCacheError', async () => {
-    spyCacheSave.mockImplementation((_paths: string[], _key: string) =>
+    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(spyCacheSave).toBeCalled()
-    expect(spyWarning).not.toHaveBeenCalled()
+    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,46 @@
 import * as path from 'path'
-import { downloadGraalVM, downloadGraalVMEELegacy, fetchArtifact, fetchArtifactEE } from '../src/gds'
+import {downloadGraalVMEELegacy, fetchArtifact} from '../src/gds'
-import { expect, test } from '@jest/globals'
+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')
+  let artifact = await fetchArtifact(
-  expect(artifact.id).toBe('1C351E8F41BB8E9EE0631518000AE5F2')
+    TEST_USER_AGENT,
-  expect(artifact.checksum).toBe('b6f3dace24cf1960ec790216f4c86f00d4f43df64e4e8b548f6382f04894713f')
+    'isBase:True',
-  artifact = await fetchArtifact(TEST_USER_AGENT, 'isBase:True', '17')
+    '22.1.0',
-  expect(artifact.checksum).toHaveLength('b6f3dace24cf1960ec790216f4c86f00d4f43df64e4e8b548f6382f04894713f'.length)
+    '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(
+  await expect(
-    'The provided "gds-token" was rejected (reason: "Invalid download token", opc-request-id: '
+    downloadGraalVMEELegacy('invalid', '22.1.0', '11')
-  )
+  ).rejects.toThrow(
-  await expect(downloadGraalVM('invalid', '1')).rejects.toThrow('Unable to find GraalVM for JDK 1')
+    'The provided "gds-token" was rejected (reason: "Invalid download token", opc-request-id: /'
-})
-
-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(
-    '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(
-    'Unable to find JDK1-based GraalVM EE 22.1.0'
   )
+  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('Unable to find JDK1-based GraalVM EE 22.1.0')
 })

__tests__/graalvm.test.ts

@@ -1,15 +1,15 @@
 import * as path from 'path'
 import * as graalvm from '../src/graalvm'
-import { expect, test } from '@jest/globals'
+import {expect, test} from '@jest/globals'
-import { getTaggedRelease } from '../src/utils'
+import {getTaggedRelease} from '../src/utils'
-import { findGraalVMVersion, findHighestJavaVersion, findLatestEABuildDownloadUrl } from '../src/graalvm'
+import {findGraalVMVersion, findHighestJavaVersion} from '../src/graalvm'
-import { GRAALVM_GH_USER, GRAALVM_RELEASES_REPO } from '../src/constants'
+import {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 [
+  for (var combination of [
     ['22.3.0', '7'],
     ['22.3', '17'],
     ['22.3', '7']
@@ -19,7 +19,7 @@ test('request invalid version/javaVersion', async () => {
       await graalvm.setUpGraalVMRelease('', combination[0], combination[1])
     } catch (err) {
       if (!(err instanceof Error)) {
-        throw new Error(`Unexpected non-Error: ${err}`)
+        fail(`Unexpected non-Error: ${err}`)
       }
       error = err
     }
@@ -32,23 +32,26 @@ test('request invalid version/javaVersion', async () => {
 
 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']) {
+  for (var 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')
+    fail('Should not find Java version for 11')
   } catch (err) {
     if (!(err instanceof Error)) {
-      throw new Error(`Unexpected non-Error: ${err}`)
+      fail(`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 latestRelease = await getTaggedRelease(
+    GRAALVM_RELEASES_REPO,
+    'vm-22.3.1'
+  )
   const latestVersion = findGraalVMVersion(latestRelease)
   expect(latestVersion).not.toBe('')
   const latestJavaVersion = findHighestJavaVersion(latestRelease, latestVersion)
@@ -56,11 +59,11 @@ test('find version/javaVersion', async () => {
 
   error = new Error('unexpected')
   try {
-    const invalidRelease = { ...latestRelease, tag_name: 'invalid' }
+    const invalidRelease = {...latestRelease, tag_name: 'invalid'}
     findGraalVMVersion(invalidRelease)
   } catch (err) {
     if (!(err instanceof Error)) {
-      throw new Error(`Unexpected non-Error: ${err}`)
+      fail(`Unexpected non-Error: ${err}`)
     }
     error = err
   }
@@ -70,27 +73,9 @@ test('find version/javaVersion', async () => {
     findHighestJavaVersion(latestRelease, 'invalid')
   } catch (err) {
     if (!(err instanceof Error)) {
-      throw new Error(`Unexpected non-Error: ${err}`)
+      fail(`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

@@ -8,10 +8,6 @@ inputs:
   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
@@ -22,8 +18,7 @@ inputs:
     default: ''
   github-token:
     required: false
-    description:
+    description: 'Set it to secrets.GITHUB_TOKEN to increase rate limits when accessing the GitHub API. Defaults to github.token.'
-      'Set it to secrets.GITHUB_TOKEN to increase rate limits when accessing the GitHub API. Defaults to github.token.'
     default: ${{ github.token }}
   set-java-home:
     required: false
@@ -48,30 +43,18 @@ 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:
+    description: 'Download token for the GraalVM Download Service. If provided, the action will set up GraalVM Enterprise Edition.'
-      '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,10 +1,5 @@
 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: {

package.json

@@ -1,75 +1,59 @@
 {
   "name": "setup-graalvm",
-  "author": "GraalVM Community",
+  "version": "1.1.1",
-  "description": "GitHub Action for GraalVM",
-  "version": "1.3.3",
   "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-but-test": "npm run build && npm run format && npm run lint && npm run package",
+    "all": "npm run all-but-test && 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": {
+  "author": "GraalVM Community",
-    "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"
-  },
   "license": "UPL",
   "dependencies": {
-    "@actions/cache": "^4.0.3",
+    "@actions/cache": "^3.0.4",
-    "@actions/core": "^1.11.1",
+    "@actions/core": "^1.10.0",
-    "@actions/exec": "^1.1.1",
+    "@actions/exec": "^1.1.0",
-    "@actions/github": "^6.0.0",
+    "@actions/github": "^5.1.1",
-    "@actions/glob": "^0.5.0",
+    "@actions/glob": "^0.3.0",
-    "@actions/http-client": "^2.2.3",
+    "@actions/http-client": "^1.0.11",
-    "@actions/io": "^1.1.3",
+    "@actions/io": "^1.1.1",
-    "@actions/tool-cache": "^2.0.2",
+    "@actions/tool-cache": "^1.7.1",
-    "@octokit/core": "^5.2.0",
+    "@octokit/core": "^3.5.1",
-    "@octokit/types": "^13.10.0",
+    "@octokit/types": "^6.34.0",
-    "@github/dependency-submission-toolkit": "^2.0.5",
+    "semver": "^7.3.8",
-    "semver": "^7.7.1",
+    "uuid": "^8.3.2"
-    "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.2.8",
+    "@types/jest": "^27.5.2",
-    "@types/jest": "^29.5.14",
+    "@types/node": "^18.15.11",
-    "@types/node": "^20.17.30",
+    "@types/semver": "^7.3.13",
-    "@types/semver": "^7.7.0",
+    "@types/uuid": "^8.3.4",
-    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/parser": "^5.8.1",
-    "@typescript-eslint/eslint-plugin": "^8.29.0",
+    "@vercel/ncc": "^0.33.4",
-    "@typescript-eslint/parser": "^8.29.0",
+    "eslint": "^8.6.0",
-    "@vercel/ncc": "^0.38.3",
+    "eslint-plugin-github": "^4.3.5",
-    "eslint": "^9.23.0",
+    "eslint-plugin-jest": "^25.3.4",
-    "eslint-config-prettier": "^10.1.1",
+    "jest": "^29.5.0",
-    "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",
     "js-yaml": "^4.1.0",
-    "prettier": "^3.5.3",
+    "prettier": "2.5.1",
-    "prettier-eslint": "^16.3.0",
+    "ts-jest": "^29.1.0",
-    "ts-jest": "^29.3.1",
+    "typescript": "^5.0.4"
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.2"
   }
 }

src/cleanup.ts

@@ -26,9 +26,8 @@
 
 import * as core from '@actions/core'
 import * as constants from './constants'
-import { save } from './features/cache'
+import {save} from './features/cache'
-import { generateReports } from './features/reports'
+import {generateReports} from './features/reports'
-import { processSBOM } from './features/sbom'
 
 /**
  * Check given input and run a save process for the specified package manager
@@ -46,9 +45,10 @@ async function saveCache(): Promise<void> {
  * @returns Promise that will ignore error reported by the given promise
  */
 async function ignoreErrors(promise: Promise<void>): Promise<unknown> {
-  return new Promise((resolve) => {
+  /* eslint-disable github/no-then */
+  return new Promise(resolve => {
     promise
-      .catch((error) => {
+      .catch(error => {
         core.warning(error)
         resolve(void 0)
       })
@@ -58,8 +58,12 @@ async function ignoreErrors(promise: Promise<void>): Promise<unknown> {
 
 export async function run(): Promise<void> {
   await ignoreErrors(generateReports())
-  await ignoreErrors(processSBOM())
   await ignoreErrors(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,11 +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'
@@ -14,18 +11,13 @@ 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'
@@ -48,31 +40,14 @@ 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 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 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) {

src/dependencies.ts

@@ -1,6 +1,6 @@
 import * as core from '@actions/core'
-import { GRAALVM_PLATFORM } from './constants'
+import {GRAALVM_PLATFORM} from './constants'
-import { exec } from './utils'
+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,7 +158,9 @@ 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 {
@@ -173,8 +190,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 {
+function isProbablyGradleDaemonProblem(
-  if (packageManager.id !== 'gradle' || process.env['RUNNER_OS'] !== 'Windows') {
+  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,14 +1,14 @@
 import * as core from '@actions/core'
 
-export function checkForUpdates(graalVMVersion: string, javaVersion: string): void {
+export async function checkForUpdates(
-  if (javaVersion === '20') {
+  graalVMVersion: string,
-    core.notice(
+  javaVersion: string
-      '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'
+): Promise<void> {
-    )
+  if (
-    return
+    graalVMVersion.length > 0 &&
-  }
+    (javaVersion === '17' || javaVersion === '19')
-  if (graalVMVersion.length > 0 && (javaVersion === '17' || javaVersion === '19')) {
+  ) {
-    const recommendedJDK = javaVersion === '17' ? '17' : '21'
+    const recommendedJDK = javaVersion === '17' ? '17' : '20'
     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`
     )

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 {exec} from '../utils'
-import { join } from 'path'
+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 {join} from 'path'
-import {
+import {tmpdir} from 'os'
-  createPRComment,
+import {createPRComment, isPREvent, toSemVer} from '../utils'
-  findExistingPRCommentId,
+import {gte} from 'semver'
-  isPREvent,
-  toSemVer,
-  updatePRComment,
-  tmpfile,
-  setNativeImageOption
-} from '../utils'
 
-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 NATIVE_IMAGE_CONFIG_FILE = join(
-const PR_COMMENT_TITLE = '## GraalVM Native Image Build Report'
+  tmpdir(),
+  'native-image-options.properties'
+)
+const NATIVE_IMAGE_CONFIG_FILE_ENV = 'NATIVE_IMAGE_CONFIG_FILE'
 
 interface AnalysisResult {
   total: number
@@ -93,7 +91,6 @@ interface BuildOutput {
 
 export async function setUpNativeImageBuildReports(
   isGraalVMforJDK17OrLater: boolean,
-  javaVersionOrDev: string,
   graalVMVersion: string
 ): Promise<void> {
   const isRequired = areJobReportsEnabled() || arePRReportsEnabled()
@@ -104,14 +101,17 @@ export async function setUpNativeImageBuildReports(
     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> {
@@ -122,22 +122,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()) {
+      createPRComment(report)
-        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'`)
     }
   }
 }
@@ -150,8 +144,22 @@ function arePRReportsEnabled(): boolean {
   return isPREvent() && core.getInput(INPUT_NI_PR_REPORTS) === 'true'
 }
 
-function arePRReportsUpdateEnabled(): boolean {
+function getNativeImageOptionsFile(): string {
-  return isPREvent() && core.getInput(INPUT_NI_PR_REPORTS_UPDATE) === 'true'
+  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 {
@@ -165,7 +173,11 @@ function createReport(data: BuildOutput): string {
     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 = `
@@ -197,7 +209,8 @@ function createReport(data: BuildOutput): string {
   let graalLine
   if (info.graal_compiler) {
     let pgoSuffix = ''
-    const isOracleGraalVM = info.vendor_version && info.vendor_version.includes('Oracle GraalVM')
+    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'
@@ -219,10 +232,13 @@ function createReport(data: BuildOutput): string {
   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)`
+    gcTotalTimeRatio = ` (${toPercent(
+      resources.garbage_collection.total_secs,
+      resources.total_secs
+    )} of total time)`
   }
 
-  return `${PR_COMMENT_TITLE}
+  return `## GraalVM Native Image Build Report
 
 \`${info.name}\` generated${totalTime} as part of the '${
     context.job
@@ -261,29 +277,56 @@ function createReport(data: BuildOutput): string {
     <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">${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">${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">${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">${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">${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">${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">${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">${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">${toPercent(
+        analysis.methods.jni,
+        analysis.methods.total
+      )}</td>
     </tr>
     <tr>
       <td align="left"><a href="${DOCS_BASE}#glossary-reachability" target="_blank">Loaded</a></td>
@@ -312,13 +355,19 @@ 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="right">${toPercent(
+        details.code_area.bytes,
+        details.total_bytes
+      )}</td>
       <td align="left">${details.code_area.compilation_units.toLocaleString()} 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="right">${toPercent(
+        details.image_heap.bytes,
+        details.total_bytes
+      )}</td>
       <td align="left">${objectCount}${bytesToHuman(
     details.image_heap.resources.bytes
   )} for ${details.image_heap.resources.count.toLocaleString()} resources</td>
@@ -331,7 +380,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>
@@ -350,7 +401,9 @@ function createReport(data: BuildOutput): string {
     </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(
+      <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>

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 {IHeaders} from '@actions/http-client/interfaces'
-import { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http'
+import {IncomingHttpHeaders} from 'http'
-import { RetryHelper } from '@actions/tool-cache/lib/retry-helper'
+import {RetryHelper} from '@actions/tool-cache/lib/retry-helper'
-import { calculateSHA256 } from './utils'
+import {calculateSHA256} from './utils'
-import { ok } from 'assert'
+import {ok} from 'assert'
-import { v4 as uuidv4 } from 'uuid'
+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> {
+export async function downloadGraalVMEELegacy(
-  const userAgent = `GraalVMGitHubAction/${c.ACTION_VERSION} (arch:${c.GRAALVM_ARCH}; os:${c.GRAALVM_PLATFORM}; java:${javaVersion})`
+  gdsToken: string,
-  const baseArtifact = await fetchArtifact(userAgent, 'isBase:True', javaVersion)
+  version: string,
+  javaVersion: string
+): Promise<string> {
+  const userAgent = `GraalVMGitHubAction/1.1.1 (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> {
+export async function fetchArtifact(
-  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(
   userAgent: string,
   metadata: string,
   version: string,
@@ -94,11 +60,15 @@ 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}`)
+    throw new Error(
+      `Unable to find JDK${javaVersion}-based GraalVM EE ${version}`
+    )
   }
-  const artifactResponse = JSON.parse(await response.readBody()) as GDSArtifactsResponse
+  const artifactResponse = JSON.parse(
+    await response.readBody()
+  ) as GDSArtifactsResponse
   if (artifactResponse.items.length !== 1) {
     throw new Error(
       artifactResponse.items.length > 1
@@ -109,13 +79,21 @@ export async function fetchArtifactEE(
   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, {
+    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 +106,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 +129,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 +150,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 +169,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 +182,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 errorResponse = JSON.parse(
-    const err = new HTTPError(response.message.statusCode, errorResponse, response.message.headers)
+      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,111 +1,46 @@
 import * as c from './constants'
-import * as core from '@actions/core'
-import * as semver from 'semver'
 import {
   downloadAndExtractJDK,
   downloadExtractAndCacheJDK,
-  getContents,
   getLatestRelease,
   getMatchingTags,
   getTaggedRelease
 } from './utils'
-import { downloadGraalVM, downloadGraalVMEELegacy } from './gds'
+import {downloadGraalVMEELegacy} from './gds'
-import { downloadTool } from '@actions/tool-cache'
+import {downloadTool} from '@actions/tool-cache'
-import { basename } from 'path'
+import {basename} from 'path'
+import {gt as semverGt, valid as semverValid} from 'semver'
 
 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_REPO_DEV_BUILDS = 'graalvm-ce-dev-builds'
 const GRAALVM_JDK_TAG_PREFIX = 'jdk-'
 const GRAALVM_TAG_PREFIX = 'vm-'
 
 // Support for GraalVM for JDK 17 and later
 
-export async function setUpGraalVMJDK(javaVersionOrDev: string, gdsToken: string): Promise<string> {
+export async function setUpGraalVMJDK(
+  javaVersionOrDev: string
+): Promise<string> {
   if (javaVersionOrDev === c.VERSION_DEV) {
     return setUpGraalVMJDKDevBuild()
   }
-  const isTokenProvided = gdsToken.length > 0
+  const javaVersion = javaVersionOrDev
-  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')) {
+  if (javaVersion.includes('.')) {
-    downloadUrl = await findLatestEABuildDownloadUrl(javaVersion)
+    const majorJavaVersion = javaVersion.split('.')[0]
-    const filename = basename(downloadUrl)
+    downloadUrl = `${GRAALVM_DL_BASE}/${majorJavaVersion}/archive/${toolName}${c.GRAALVM_FILE_EXTENSION}`
-    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(
+    downloadUrl = `${GRAALVM_DL_BASE}/${javaVersion}/latest/${toolName}${c.GRAALVM_FILE_EXTENSION}`
-        `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> {
+export async function setUpGraalVMJDKCE(
-  const filePath = `versions/${javaEaVersion}.json`
+  javaVersionOrDev: string
-  let response
+): Promise<string> {
-  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()
   }
@@ -124,10 +59,10 @@ export async function setUpGraalVMJDKCE(javaVersionOrDev: string): Promise<strin
   return downloadExtractAndCacheJDK(downloader, toolName, javaVersion)
 }
 
-export async function findLatestGraalVMJDKCEJavaVersion(majorJavaVersion: string): Promise<string> {
+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'
@@ -135,7 +70,10 @@ export async function findLatestGraalVMJDKCEJavaVersion(majorJavaVersion: string
   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)) {
+    if (
+      semverValid(currentVersion) &&
+      semverGt(currentVersion, highestVersion)
+    ) {
       highestVersion = currentVersion
     }
   }
@@ -148,20 +86,29 @@ export async function findLatestGraalVMJDKCEJavaVersion(majorJavaVersion: string
 }
 
 function determineToolName(javaVersion: string, isCommunity: boolean) {
-  return `graalvm${isCommunity ? '-community' : ''}-jdk-${javaVersion}_${c.JDK_PLATFORM}-${c.JDK_ARCH}_bin`
+  return `graalvm${isCommunity ? '-community' : ''}-jdk-${javaVersion}_${
+    c.JDK_PLATFORM
+  }-${c.JDK_ARCH}_bin`
 }
 
-async function downloadGraalVMJDK(downloadUrl: string, javaVersion: string): Promise<string> {
+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?`
+        `Failed to download ${basename(
+          downloadUrl
+        )}. Are you sure java-version: '${javaVersion}' is correct?`
       )
     }
-    throw new Error(`Failed to download ${basename(downloadUrl)} (error: ${error}).`)
+    throw new Error(
+      `Failed to download ${basename(downloadUrl)} (error: ${error}).`
+    )
   }
 }
 
@@ -169,15 +116,28 @@ async function downloadGraalVMJDK(downloadUrl: string, javaVersion: string): Pro
 
 export async function setUpGraalVMJDKDevBuild(): Promise<string> {
   const latestDevBuild = await getLatestRelease(GRAALVM_REPO_DEV_BUILDS)
-  const resolvedJavaVersion = findHighestJavaVersion(latestDevBuild, c.VERSION_DEV)
+  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 {
+export function findHighestJavaVersion(
-  const graalVMIdentifierPattern = determineGraalVMLegacyIdentifier(false, version, '(\\d+)')
+  release: c.LatestReleaseResponse['data'],
+  version: string
+): string {
+  const graalVMIdentifierPattern = determineGraalVMLegacyIdentifier(
+    false,
+    version,
+    '(\\d+)'
+  )
   const expectedFileNameRegExp = new RegExp(
-    `^${graalVMIdentifierPattern}${c.GRAALVM_FILE_EXTENSION.replace(/\./g, '\\.')}$`
+    `^${graalVMIdentifierPattern}${c.GRAALVM_FILE_EXTENSION.replace(
+      /\./g,
+      '\\.'
+    )}$`
   )
   let highestJavaVersion = 0
   for (const asset of release.assets) {
@@ -200,13 +160,15 @@ export function findHighestJavaVersion(release: c.LatestReleaseResponse['data'],
 
 // Support for GraalVM 22.X releases and earlier
 
-export async function setUpGraalVMLatest_22_X(gdsToken: string, javaVersion: string): Promise<string> {
+export async function setUpGraalVMLatest_22_X(
-  const lockedVersion = javaVersion === '19' ? '22.3.1' : '22.3.3'
+  gdsToken: string,
+  javaVersion: string
+): Promise<string> {
+  const lockedVersion = javaVersion === '19' ? '22.3.1' : '22.3.2'
   if (gdsToken.length > 0) {
     return setUpGraalVMRelease(gdsToken, lockedVersion, javaVersion)
   }
   const latestRelease = await getTaggedRelease(
-    c.GRAALVM_GH_USER,
     c.GRAALVM_RELEASES_REPO,
     GRAALVM_TAG_PREFIX + lockedVersion
   )
@@ -222,20 +184,32 @@ export function findGraalVMVersion(release: c.LatestReleaseResponse['data']) {
   return tag_name.substring(GRAALVM_TAG_PREFIX.length, tag_name.length)
 }
 
-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)
   let downloader: () => Promise<string>
   if (isEE) {
-    downloader = async () => downloadGraalVMEELegacy(gdsToken, version, javaVersion)
+    downloader = async () =>
+      downloadGraalVMEELegacy(gdsToken, version, javaVersion)
   } else {
     downloader = async () => downloadGraalVMCELegacy(version, javaVersion)
   }
   return downloadExtractAndCacheJDK(downloader, toolName, version)
 }
 
-function findDownloadUrl(release: c.LatestReleaseResponse['data'], javaVersion: string): string {
+function findDownloadUrl(
-  const graalVMIdentifier = determineGraalVMLegacyIdentifier(false, c.VERSION_DEV, javaVersion)
+  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) {
@@ -247,17 +221,34 @@ function findDownloadUrl(release: c.LatestReleaseResponse['data'], javaVersion:
   )
 }
 
-function determineGraalVMLegacyIdentifier(isEE: boolean, version: string, javaVersion: string): string {
+function determineGraalVMLegacyIdentifier(
-  return `${determineLegacyToolName(isEE, version, javaVersion)}-${c.GRAALVM_ARCH}-${version}`
+  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 {
+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> {
+async function downloadGraalVMCELegacy(
-  const graalVMIdentifier = determineGraalVMLegacyIdentifier(false, version, javaVersion)
+  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)
@@ -268,6 +259,8 @@ async function downloadGraalVMCELegacy(version: string, javaVersion: string): Pr
         `Failed to download ${graalVMIdentifier}. Are you sure version: '${version}' and java-version: '${javaVersion}' are correct?`
       )
     }
-    throw new Error(`Failed to download ${graalVMIdentifier} (error: ${error}).`)
+    throw new Error(
+      `Failed to download ${graalVMIdentifier} (error: ${error}).`
+    )
   }
 }

src/gu.ts

@@ -1,9 +1,6 @@
-import * as c from './constants'
+import {GRAALVM_PLATFORM} from './constants'
-import * as core from '@actions/core'
+import {exec} from './utils'
-import * as semver from 'semver'
+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,
+  gdsToken: string,
-  graalVMVersion: string,
   graalVMHome: string,
-  components: string[],
+  components: string[]
-  gdsToken: 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,38 +1,37 @@
 import * as c from './constants'
 import * as core from '@actions/core'
 import * as graalvm from './graalvm'
-import * as semver from 'semver'
+import {gte as semverGte, valid as semverValid} from 'semver'
-import { isFeatureAvailable as isCacheAvailable } from '@actions/cache'
+import {isFeatureAvailable as isCacheAvailable} from '@actions/cache'
-import { basename, join } from 'path'
+import {join} from 'path'
-import { restore } from './features/cache'
+import {restore} from './features/cache'
-import { setUpDependencies } from './dependencies'
+import {setUpDependencies} from './dependencies'
-import { setUpGUComponents } from './gu'
+import {setUpGUComponents} from './gu'
-import { setUpMandrel } from './mandrel'
+import {setUpMandrel} from './mandrel'
-import { setUpLiberica } from './liberica'
+import {checkForUpdates} from './features/check-for-updates'
-import { checkForUpdates } from './features/check-for-updates'
+import {setUpNativeImageMusl} from './features/musl'
-import { setUpNativeImageMusl } from './features/musl'
+import {setUpWindowsEnvironment} from './msvc'
-import { setUpWindowsEnvironment } from './msvc'
+import {setUpNativeImageBuildReports} from './features/reports'
-import { setUpNativeImageBuildReports } from './features/reports'
-import { exec } from '@actions/exec'
-import { setUpSBOMSupport } from './features/sbom'
 
 async function run(): Promise<void> {
   try {
-    const javaVersion = core.getInput(c.INPUT_JAVA_VERSION, { required: true })
+    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)
     const gdsToken = core.getInput(c.INPUT_GDS_TOKEN)
     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(',').map(x => x.trim())
+        : []
     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(graalvmVersion)
     }
     await setUpDependencies(components)
     if (enableNativeImageMusl) {
@@ -40,27 +39,25 @@ async function run(): Promise<void> {
     }
 
     // Download GraalVM JDK
+    const isGraalVMforJDK17OrLater =
+      distribution.length > 0 || graalvmVersion.length == 0
     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)
+          graalVMHome = await graalvm.setUpGraalVMJDK(javaVersion)
           break
         case c.DISTRIBUTION_GRAALVM_COMMUNITY:
           graalVMHome = await graalvm.setUpGraalVMJDKCE(javaVersion)
           break
         case c.DISTRIBUTION_MANDREL:
-          graalVMHome = await setUpMandrel(graalVMVersion, javaVersion)
+          if (graalvmVersion.startsWith(c.MANDREL_NAMESPACE)) {
-          break
+            graalVMHome = await setUpMandrel(graalvmVersion, javaVersion)
-        case c.DISTRIBUTION_LIBERICA:
+          } else {
-          graalVMHome = await setUpLiberica(javaVersion, javaPackage)
+            throw new Error(
-          break
+              `Mandrel requires the 'version' option (see https://github.com/graalvm/setup-graalvm/tree/main#options).`
+            )
+          }
         case '':
           if (javaVersion === c.VERSION_DEV) {
             core.info(
@@ -71,49 +68,50 @@ async function run(): Promise<void> {
             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)
+            graalVMHome = await graalvm.setUpGraalVMJDK(javaVersion)
           }
           break
         default:
           throw new Error(`Unsupported distribution: ${distribution}`)
       }
     } else {
-      const coercedJavaVersion = semver.coerce(javaVersion)
+      switch (graalvmVersion) {
-      switch (graalVMVersion) {
         case c.VERSION_LATEST:
           if (
             javaVersion.startsWith('17') ||
-            (coercedJavaVersion !== null && semver.gte(coercedJavaVersion, '20.0.0'))
+            (semverValid(javaVersion) && semverGte(javaVersion, '20'))
           ) {
             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)
+            graalVMHome = await graalvm.setUpGraalVMJDK(javaVersion)
           } else {
-            graalVMHome = await graalvm.setUpGraalVMLatest_22_X(gdsToken, javaVersion)
+            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')
+            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()
           }
+          graalVMHome = await graalvm.setUpGraalVMJDKDevBuild()
           break
         default:
-          if (graalVMVersion.startsWith(c.MANDREL_NAMESPACE)) {
+          if (graalvmVersion.startsWith(c.MANDREL_NAMESPACE)) {
-            graalVMHome = await setUpMandrel(graalVMVersion, javaVersion)
+            graalVMHome = await setUpMandrel(graalvmVersion, javaVersion)
           } else {
             if (enableCheckForUpdates) {
-              checkForUpdates(graalVMVersion, javaVersion)
+              await checkForUpdates(graalvmVersion, javaVersion)
             }
-            graalVMHome = await graalvm.setUpGraalVMRelease(gdsToken, graalVMVersion, javaVersion)
+            graalVMHome = await graalvm.setUpGraalVMRelease(
+              gdsToken,
+              graalvmVersion,
+              javaVersion
+            )
           }
           break
       }
@@ -126,19 +124,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)
+    setUpNativeImageBuildReports(isGraalVMforJDK17OrLater, 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()
   } 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, getLatestRelease} from './utils'
-import { downloadExtractAndCacheJDK } from './utils'
+import {downloadTool} from '@actions/tool-cache'
-import { downloadTool } from '@actions/tool-cache'
-import { basename } from 'path'
 
-export const MANDREL_REPO = 'mandrel'
+const MANDREL_REPO = 'mandrel'
-export const MANDREL_TAG_PREFIX = c.MANDREL_NAMESPACE
+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 {
+export async function setUpMandrel(
-  message: string
+  graalvmVersion: string,
-  /* eslint-disable @typescript-eslint/no-explicit-any */
+  javaVersion: string
-  result: any
+): Promise<string> {
-  /* eslint-enable @typescript-eslint/no-explicit-any */
+  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) {
+  switch (mandrelVersion) {
-    case '':
-      // fetch latest if no version is specified
-      mandrelHome = await setUpMandrelLatest(javaVersion)
-      break
     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 latestRelease = await getLatestRelease(MANDREL_REPO)
-  const version_tag = getTagFromURI(latest_release_url)
+  const tag_name = latestRelease.tag_name
-  const version = stripMandrelNamespace(version_tag)
+  if (tag_name.startsWith(MANDREL_TAG_PREFIX)) {
-
+    const latestVersion = tag_name.substring(
-  const toolName = determineToolName(javaVersion)
+      MANDREL_TAG_PREFIX.length,
-  return downloadExtractAndCacheJDK(async () => downloadTool(latest_release_url), toolName, version)
+      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>
+async function setUpMandrelRelease(
-function getTagFromURI(uri: string): string {
+  version: string,
-  const parts = uri.split('/')
+  javaVersion: string
-  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
 ): 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 {
+  const toolName = determineToolName(javaVersion)
-    return await downloadTool(downloadUrl)
+  return downloadExtractAndCacheJDK(
-  } catch (error) {
+    async () => downloadTool(downloadUrl),
-    if (error instanceof Error && error.message.includes('404')) {
+    toolName,
-      // Not Found
+    version
-      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}).`)
-  }
 }
 
-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,7 +1,7 @@
 import * as core from '@actions/core'
-import { execSync } from 'child_process'
+import {execSync} from 'child_process'
-import { existsSync } from 'fs'
+import {existsSync} from 'fs'
-import { VERSION_DEV } from './constants'
+import {VERSION_DEV} from './constants'
 
 // Keep in sync with https://github.com/actions/virtual-environments
 const KNOWN_VISUAL_STUDIO_INSTALLATIONS = [
@@ -11,7 +11,9 @@ const KNOWN_VISUAL_STUDIO_INSTALLATIONS = [
 ]
 if (process.env['VSINSTALLDIR']) {
   // if VSINSTALLDIR is set, make it the first known installation
-  KNOWN_VISUAL_STUDIO_INSTALLATIONS.unshift(process.env['VSINSTALLDIR'].replace(/\\$/, ''))
+  KNOWN_VISUAL_STUDIO_INSTALLATIONS.unshift(
+    process.env['VSINSTALLDIR'].replace(/\\$/, '')
+  )
 }
 const VCVARSALL_SUBPATH = 'VC\\Auxiliary\\Build\\vcvarsall.bat'
 
@@ -25,35 +27,19 @@ function findVcvarsallPath(): string {
   throw new Error('Failed to find vcvarsall.bat')
 }
 
-export function needsWindowsEnvironmentSetup(
+export function setUpWindowsEnvironment(graalVMVersion: string): void {
-  javaVersion: string,
+  if (graalVMVersion === VERSION_DEV) {
-  graalVMVersion: string,
+    return // no longer required in dev builds
-  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
   }
 
   core.startGroup('Updating Windows environment...')
 
   const vcvarsallPath = findVcvarsallPath()
   core.debug(`Calling "${vcvarsallPath}"...`)
-  const [originalEnv, vcvarsallOutput, updatedEnv] = execSync(`set && cls && "${vcvarsallPath}" x64 && cls && set`, {
+  const [originalEnv, vcvarsallOutput, updatedEnv] = execSync(
-    shell: 'cmd'
+    `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,15 +2,12 @@ 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 { ExecOptions, exec as e } from '@actions/exec'
+import {readFileSync, readdirSync} from 'fs'
-import { readFileSync, readdirSync } from 'fs'
+import {Octokit} from '@octokit/core'
-import { Octokit } from '@octokit/core'
+import {createHash} from 'crypto'
-import { createHash } from 'crypto'
+import {join} from 'path'
-import { join } from 'path'
-import { tmpdir } from 'os'
 
 // 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'
@@ -21,16 +18,26 @@ const GitHubDotCom = Octokit.defaults({
   }
 })
 
-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 options = githubToken.length > 0 ? {auth: githubToken} : {}
   const octokit = new GitHubDotCom(options)
   return (
     await octokit.request('GET /repos/{owner}/{repo}/releases/latest', {
@@ -40,30 +47,16 @@ 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 options = githubToken.length > 0 ? {auth: githubToken} : {}
   const octokit = new GitHubDotCom(options)
   return (
     await octokit.request('GET /repos/{owner}/{repo}/releases/tags/{tag}', {
-      owner,
+      owner: c.GRAALVM_GH_USER,
       repo,
       tag
     })
@@ -71,24 +64,29 @@ export async function getTaggedRelease(
 }
 
 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 options = githubToken.length > 0 ? {auth: githubToken} : {}
   const octokit = new GitHubDotCom(options)
   return (
-    await octokit.request('GET /repos/{owner}/{repo}/git/matching-refs/tags/{tagPrefix}', {
+    await octokit.request(
-      owner,
+      'GET /repos/{owner}/{repo}/git/matching-refs/tags/{tagPrefix}',
-      repo,
+      {
+        owner: c.GRAALVM_GH_USER,
+        repo: c.GRAALVM_RELEASES_REPO,
         tagPrefix
-    })
+      }
+    )
   ).data
 }
 
-export async function downloadAndExtractJDK(downloadUrl: string): Promise<string> {
+export async function downloadAndExtractJDK(
-  return findJavaHomeInSubfolder(await extract(await tc.downloadTool(downloadUrl)))
+  downloadUrl: string
+): Promise<string> {
+  return findJavaHomeInSubfolder(
+    await extract(await tc.downloadTool(downloadUrl))
+  )
 }
 
 export async function downloadExtractAndCacheJDK(
@@ -120,7 +118,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 +129,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) {
+  const major = parts[0]
-    /**
+  const minor = parts.length > 1 ? parts[1] : '0'
-     * Turn legacy GraalVM version numbers (e.g., `22.0.0.2`) into valid
+  const patch = parts.length > 2 ? parts.slice(2).join('-') : '0'
-     * semver.org versions (e.g., `22.0.0-2`).
+  return `${major}.${minor}.${patch}`
-     */
-    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
 }
 
 export function isPREvent(): boolean {
@@ -160,47 +156,6 @@ 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.')
@@ -218,43 +173,3 @@ export async function createPRComment(content: string): Promise<void> {
     )
   }
 }
-
-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
-}

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",
+    "target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */
-    "moduleResolution": "NodeNext",
+    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
-    "outDir": "./dist"
+    "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"],
+  "exclude": ["node_modules", "**/*.test.ts"]
-  "include": ["src"]
 }