Add production dependencies & build

* Make the devdocs more complete and self-contained

* Rename devdocs/misc-notes-from-contributors.md to devdocs/misc/misc_notes_for_committers.md

* Document the dependencies of the build script

* No need to manually make multiple commits

---------

Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>

.gitattributes

@@ -0,0 +1,2 @@
+# Hide generated JS code from diffs and language stats
+lib/*.js linguist-generated=true

.github/CODEOWNERS

@@ -0,0 +1 @@
+*       @julia-actions/reviewers

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,28 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG] "
+labels: bug
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Workflow file to reproduce the behavior:
+
+```yaml
+
+```
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots/Build logs**
+If applicable, add screenshots to help explain your problem.
+
+If possible, set the repo secret `ACTIONS_STEP_DEBUG` to `true` to [enable debug logs](https://github.com/actions/toolkit/blob/master/docs/action-debugging.md#how-to-access-step-debug-logs) and run the build again for more detailled logs.
+
+**Additional context**
+Add any other context about the problem here.

.github/dependabot.yml

@@ -0,0 +1,19 @@
+version: 2
+updates:
+- package-ecosystem: gitsubmodule
+  directory: "/"
+  schedule:
+    interval: monthly
+  open-pull-requests-limit: 99
+
+- package-ecosystem: 'github-actions'
+  directory: '/'
+  schedule:
+    interval: 'monthly'
+  open-pull-requests-limit: 99
+    
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: monthly
+  open-pull-requests-limit: 99

.github/scripts/common-tests.jl

@@ -0,0 +1,11 @@
+if !occursin("hostedtoolcache", Sys.BINDIR)
+    error("the wrong julia is being used: $(Sys.BINDIR)")
+end
+if VERSION >= v"1.7.0" # pkgdir was introduced here, and before then mtime wasn't a problem so just skip
+    using Pkg
+    src = pkgdir(Pkg, "src", "Pkg.jl")
+    # mtime is when it's compressed, ctime is when the file is extracted
+    if mtime(src) >= ctime(src)
+        error("source mtime ($(mtime(src))) is not earlier than ctime ($(ctime(src)))")
+    end
+end

.github/workflows/checkin.yml

@@ -1,11 +1,22 @@
 name: "PR Checks"
 on: [pull_request, push]
 
+concurrency:
+  # Skip intermediate builds: all builds except for builds on the `master`, `main`, or `release-*` branches
+  # Cancel intermediate builds: only pull request builds
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.ref != 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release-') || github.run_number }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
 jobs:
   check_pr:
     runs-on: ubuntu-latest
+    timeout-minutes: 60
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
+
+    - uses: actions/setup-node@v4
+      with:
+        node-version-file: '.tool-versions'
 
     - name: "npm ci"
       run: npm ci

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,74 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+concurrency:
+  # Skip intermediate builds: all builds except for builds on the `master`, `main`, or `release-*` branches
+  # Cancel intermediate builds: only pull request builds
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.ref != 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release-') || github.run_number }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+on:
+  push:
+    branches: [ master, releases/* ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '32 22 * * 6'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v3
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3

.github/workflows/example-builds-defaultarch.yml

@@ -0,0 +1,48 @@
+name: Example builds (default arch)
+
+concurrency:
+  # Skip intermediate builds: all builds except for builds on the `master`, `main`, or `release-*` branches
+  # Cancel intermediate builds: only pull request builds
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.ref != 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release-') || github.run_number }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+on:
+  push:
+    branches: ['main', 'master', 'releases/*']
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        julia-version: ['1']
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        with:
+          node-version-file: '.tool-versions'
+
+      - name: "Install dependencies"
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        run: |
+          npm install
+          npm run build
+          npm run pack
+
+      - name: "Set up Julia"
+        id: setup-julia
+        uses: ./
+        with:
+          version: ${{ matrix.julia-version }}
+      - run: julia --version
+      - run: julia --compile=min -O0 -e 'import InteractiveUtils; InteractiveUtils.versioninfo()'
+      - name: "Check that the correct julia is used and that archive mtimes are maintained"
+        run: julia --startup-file=no --color=yes ./.github/scripts/common-tests.jl

.github/workflows/example-builds-nightly-defaultarch.yml

@@ -0,0 +1,53 @@
+name: Example builds (nightly, default arch)
+
+concurrency:
+  # Skip intermediate builds: all builds except for builds on the `master`, `main`, or `release-*` branches
+  # Cancel intermediate builds: only pull request builds
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.ref != 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release-') || github.run_number }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+on:
+  push:
+    branches: ['main', 'master', 'releases/*']
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        julia-version: [nightly, 1.10-nightly]
+        os:
+          - ubuntu-latest
+          - windows-latest
+          # - macos-11 # Intel
+          - macos-12 # Intel
+          - macos-13 # Intel
+          - macos-14 # Apple Silicon
+          - macos-latest # Currently Intel, but will probably point to Apple Silicon in the future
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        with:
+          node-version-file: '.tool-versions'
+
+      - name: "Install dependencies"
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        run: |
+          npm install
+          npm run build
+          npm run pack
+
+      - name: "Set up Julia (${{ matrix.julia-version }})"
+        uses: ./
+        with:
+          version: ${{ matrix.julia-version }}
+      - run: julia --version
+      - run: julia --compile=min -O0 -e 'import InteractiveUtils; InteractiveUtils.versioninfo()'
+      - name: "Check that the correct julia is used and that archive mtimes are maintained"
+        run: julia --startup-file=no --color=yes ./.github/scripts/common-tests.jl

.github/workflows/example-builds-nightly.yml

@@ -0,0 +1,54 @@
+name: Example builds (nightly)
+
+concurrency:
+  # Skip intermediate builds: all builds except for builds on the `master`, `main`, or `release-*` branches
+  # Cancel intermediate builds: only pull request builds
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.ref != 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release-') || github.run_number }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+on:
+  push:
+    branches: ['main', 'master', 'releases/*']
+  pull_request:
+  schedule:
+    - cron: '37 17 * * *'
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        julia-version: [nightly, 1.10-nightly]
+        julia-arch: [x64, x86]
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+        # 32-bit Julia binaries are not available on macOS
+        exclude:
+          - os: macOS-latest
+            julia-arch: x86
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        with:
+          node-version-file: '.tool-versions'
+
+      - name: "Install dependencies"
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        run: |
+          npm install
+          npm run build
+          npm run pack
+
+      - name: "Set up Julia (${{ matrix.julia-version }})"
+        uses: ./
+        with:
+          version: ${{ matrix.julia-version }}
+          arch: ${{ matrix.julia-arch }}
+      - run: julia --version
+      - run: julia --compile=min -O0 -e 'import InteractiveUtils; InteractiveUtils.versioninfo()'
+      - name: "Check that the correct julia is used and that archive mtimes are maintained"
+        run: julia --startup-file=no --color=yes ./.github/scripts/common-tests.jl

.github/workflows/example-builds.yml

@@ -0,0 +1,54 @@
+name: Example builds
+
+concurrency:
+  # Skip intermediate builds: all builds except for builds on the `master`, `main`, or `release-*` branches
+  # Cancel intermediate builds: only pull request builds
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.ref != 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release-') || github.run_number }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+on:
+  push:
+    branches: ['main', 'master', 'releases/*']
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        julia-version: ['1.0.5', '1.2', '^1.5.0-beta1', '1', 'lts', 'pre']
+        julia-arch: [x64, x86]
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+        # 32-bit Julia binaries are not available on macOS
+        exclude:
+          - os: macOS-latest
+            julia-arch: x86
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        with:
+          node-version-file: '.tool-versions'
+
+      - name: "Install dependencies"
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        run: |
+          npm install
+          npm run build
+          npm run pack
+
+      - name: "Set up Julia"
+        id: setup-julia
+        uses: ./
+        with:
+          version: ${{ matrix.julia-version }}
+          arch: ${{ matrix.julia-arch }}
+      - run: julia --version
+      - run: julia --compile=min -O0 -e 'import InteractiveUtils; InteractiveUtils.versioninfo()'
+      - name: "Check that the correct julia is used and that archive mtimes are maintained"
+        run: julia --startup-file=no --color=yes ./.github/scripts/common-tests.jl

.gitignore

@@ -1,2 +1,3 @@
 node_modules/
 __tests__/runner/*
+!dist/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "bin"]
+	path = bin
+	url = git@github.com:julia-actions/bin.git

.tool-versions

@@ -0,0 +1 @@
+nodejs 20.11.1

CONTRIBUTING.md

@@ -0,0 +1,3 @@
+# Contributing
+
+Please see the README in the [`devdocs/`](devdocs/) folder.

README.md

@@ -1,25 +1,155 @@
 # setup-julia Action
 
-This action sets up a Julia environment for use in actions by download a specified version of Julia and adding it to PATH.
+[![CodeQL](https://github.com/julia-actions/setup-julia/workflows/CodeQL/badge.svg)](https://securitylab.github.com/tools/codeql)
+
+This action sets up a Julia environment for use in actions by downloading a specified version of Julia and adding it to PATH.
+
+## Table of Contents
+- [Table of Contents](#table-of-contents)
+- [Usage](#usage)
+  - [Inputs](#inputs)
+  - [Outputs](#outputs)
+  - [Basic](#basic)
+  - [Julia Versions](#julia-versions)
+  - [Matrix Testing](#matrix-testing)
+  - [versioninfo](#versioninfo)
+- [Versioning](#versioning)
+- [Debug logs](#debug-logs)
+- [Third party information](#third-party-information)
 
 ## Usage
 
-See [action.yml](action.yml).
+### Inputs
 
-Take a look at [github.com/exercism/julia](https://github.com/exercism/julia/pull/153) for an example, non-package Julia project making use of this action.
+```yaml
+- uses: julia-actions/setup-julia@v2
+  with:
+    # The Julia version that will be installed and added as `julia` to the PATH.
+    # See "Julia Versions" below for a list of valid values.
+    #
+    # Warning: It is strongly recommended to wrap this value in quotes.
+    #          Otherwise, the YAML parser used by GitHub Actions parses certain
+    #          versions as numbers which causes the wrong version to be selected.
+    #          For example, `1.0` may be parsed as `1`.
+    #
+    # Default: '1'
+    version: ''
 
-### Basic:
+    # The architecture of the Julia binaries.
+    #
+    # Please note that installing aarch64 binaries only makes sense on self-hosted aarch64 runners.
+    # We currently don't run test builds on that architecture, so we cannot guarantee that the input won't break randomly,
+    # although there is no reason why it would.
+    #
+    # Supported values: x64 | x86 | aarch64 (untested)
+    #
+    # Note: you can use X64, X86, and ARM64 as synonyms for x64, x86, and aarch64, respectively.
+    #
+    # Defaults to the architecture of the runner executing the job.
+    arch: ''
+
+    # Set the display setting for printing InteractiveUtils.versioninfo() after installing.
+    #
+    # Starting Julia and running InteractiveUtils.versioninfo() takes a significant amount of time (1s or ~10% of the total build time in testing),
+    # so you may not want to run it in every build, in particular on paid runners, as this cost will add up quickly.
+    #
+    # See "versioninfo" below for example usage and further explanations.
+    #
+    # Supported values: true | false | never
+    #
+    # true: Always print versioninfo
+    # false: Only print versioninfo for nightly Julia
+    # never: Never print versioninfo
+    #
+    # Default: false
+    show-versioninfo: ''
+```
+
+### Outputs
+
+```yaml
+outputs:
+  # The installed Julia version.
+  # May vary from the version input if a version range was given as input.
+  #
+  # Example output: '1.5.3'
+
+  julia-version: ''
+  # Path to the directory containing the Julia executable.
+  # Equivalent to JULIA_BINDIR: https://docs.julialang.org/en/v1/manual/environment-variables/#JULIA_BINDIR
+  #
+  # Example output: '/opt/hostedtoolcache/julia/1.5.3/x64/bin'
+  julia-bindir: ''
+```
+
+### Basic
 
 ```yaml
 steps:
-- uses: actions/checkout@v1.0.0
-- uses: julia-actions/setup-julia@v0.1.0
+- uses: actions/checkout@v4
+- uses: julia-actions/setup-julia@v2
   with:
-    version: 1.0.4
+    version: '1.10'
 - run: julia -e 'println("Hello, World!")'
 ```
 
-### Matrix Testing:
+### Julia Versions
+
+You can either specify specific Julia versions or version ranges. If you specify a version range, the **highest** available Julia version that matches the range will be selected.
+
+> **Warning**
+>
+> It is strongly recommended to wrap versions in quotes. Otherwise, the YAML parser used by GitHub Actions parses certain versions as numbers which causes the wrong version to be selected. For example, `1.0` may be parsed as `1`.
+
+#### Examples
+
+- `'1.2.0'` is a valid semver version. The action will try to download exactly this version. If it's not available, the build step will fail.
+- `'1.0'` is a version range that will match the highest available Julia version that starts with `1.0`, e.g. `1.0.5`, excluding pre-releases.
+- `'^1.3.0-rc1'` is a **caret** version range that includes pre-releases of `1.3.0` starting at `rc1`. It matches all versions `≥ 1.3.0-rc1` and `< 2.0.0`.
+- `'~1.3.0-rc1'` is a **tilde** version range that includes pre-releases of `1.3.0` starting at `rc1`. It matches all versions `≥ 1.3.0-rc1` and `< 1.4.0`.
+- `'^1.3.0-0'` is a **caret** version range that includes _all_ pre-releases of `1.3.0`. It matches all versions `≥ 1.3.0-` and `< 2.0.0`.
+- `'~1.3.0-0'` is a **tilde** version range that includes _all_ pre-releases of `1.3.0`. It matches all versions `≥ 1.3.0-` and `< 1.4.0`.
+- `'lts'` will install the latest LTS build.
+- `'pre'` will install the latest prerelease build.
+- `'nightly'` will install the latest nightly build.
+- `'1.7-nightly'` will install the latest nightly build for the upcoming 1.7 release. This version will only be available during certain phases of the Julia release cycle.
+
+Internally the action uses node's semver package to resolve version ranges. Its [documentation](https://github.com/npm/node-semver#advanced-range-syntax) contains more details on the version range syntax. You can test what version will be selected for a given input in this JavaScript [REPL](https://repl.it/@SaschaMann/setup-julia-version-logic).
+
+#### Prereleases
+
+There are two methods of including pre-releases in version matching:
+
+1. Including the pre-release tag in the version itself, e.g. `'^1.3.0-rc1'`.
+2. Setting the input `include-all-prereleases` to `true`.
+
+These behave slightly differently.
+
+1. If the version `a.b.c` contains pre-release tag, all pre-releases of version `a.b.c` will be included in the version matching.
+For example, `^1.3.0-rc1` would match `1.3.0-rc2` but would **not** match `1.4.0-rc1` once released.
+2. If `include-preleases` is set to true, **all** pre-releases of all versions will be included in the version matching. In this case, `^1.3.0-rc1` would match `1.4.0-rc1` once released.
+
+**Example:** Without `include-all-prereleases: true`, the version `^1.3.0-rc1` would match `1.3.0-rc1`, `1.3.0-rc2`, `1.3.0`, `1.4.0` once they are released.
+With `include-all-prereleases: true`, it would match `1.3.0-rc1`, `1.3.0-rc2`, `1.3.0`, `1.4.0-rc1`, `1.4.0`.
+
+If you want to run tests against the latest tagged version, no matter what version that is, you can use
+
+```yaml
+- uses: julia-actions/setup-julia@v2
+  with:
+    version: '1'
+    include-all-prereleases: true
+```
+
+#### Recently released versions
+
+The available Julia versions are pulled from [`versions.json`](https://julialang-s3.julialang.org/bin/versions.json).
+
+### Matrix Testing
+
+`bash` is chosen as shell to enforce consistent behaviour across operating systems. [Other shells](https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions#using-a-specific-shell) are available but you may have to escape quotation marks or otherwise adjust the syntax.
+
+#### 64-bit Julia only
 
 ```yaml
 jobs:
@@ -27,47 +157,135 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        julia-version: [1.0.4, 1.1.1, 1.2.0-rc3, 1.3.0-alpha]
+        julia-version: ['1.0', '1.2.0', '^1.3.0-rc1']
         os: [ubuntu-latest, windows-latest, macOS-latest]
-    
+
     steps:
-      - uses: actions/checkout@v1.0.0
+      - uses: actions/checkout@v4
       - name: "Set up Julia"
-        uses: julia-actions/setup-julia@v0.1.0
+        uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.julia-version }}
       - run: julia -e 'println("Hello, World!")'
+        shell: bash
 ```
 
-## Future plans & ideas
+#### 32-bit Julia
 
-In no particular order:
+```yaml
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: ['1.0', '1.2.0', '^1.3.0-rc1']
+        julia-arch: [x64, x86]
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        # 32-bit Julia binaries are not available on macOS
+        exclude:
+          - os: macOS-latest
+            julia-arch: x86
 
-### `setup-julia`:
-* Check if a cached version of Julia is available instead of installing it everytime CI runs.
-* Add version shortcuts like `1.x`, `1.1.x`, `latest` and `lts`.
-* Add support for nightly Julia builds.
-* Support 32-bit Julia on 64-bit windows.
-* Write some unit tests for the action.
-* Figure out the best way to handle versioning.
-* Hash and signature checks.
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Set up Julia"
+        uses: julia-actions/setup-julia@v2
+        with:
+          version: ${{ matrix.julia-version }}
+          arch: ${{ matrix.julia-arch }}
+      - run: julia -e 'println("Hello, World!")'
+        shell: bash
+```
 
-### Other Julia-related actions:
+Alternatively, you can include specific version and OS combinations that will use 32-bit Julia:
 
-These would be nice to have but I make no promises of ever creating them myself.
+```yaml
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: ['1.0', '1.2.0', '^1.3.0-rc1']
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        # Additionally create a job using 32-bit Julia 1.0.4 on windows-latest
+        include:
+          - os: windows-latest
+            julia-version: ['1.0.4']
+            julia-arch: x86
 
-* Default build script for packages, similar to how Travis CI works if you don't specify a script.
-* Find out if it's possible to cache packages using [`@actions/tool-cache`](https://github.com/actions/toolkit/tree/master/packages/tool-cache).
-* Actions for standard tools like Documenter, Coverage reporting and so on
-* Actions for registering and tagging package releases instead of relying on external apps.
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Set up Julia"
+        uses: julia-actions/setup-julia@v2
+        with:
+          version: ${{ matrix.julia-version }}
+      - run: julia -e 'println("Hello, World!")'
+        shell: bash
+```
 
-## Words of caution
+### versioninfo
 
-This action will likely be updated quite frequently in the near future. I'm sharing it now so that others who want to try out Julia on GitHub actions can do so without relying on Docker.
+By default, only the output of `julia --version` is printed as verification that Julia has been installed for stable versions of Julia.
+`InteractiveUtils.versioninfo()` is run by default for nightly builds.
 
-**DO NOT USE THIS AS YOUR ONLY FORM OF CI** (yet).
+Starting Julia and printing the full versioninfo takes a significant amount of time (1s or ~10% of the total build time in testing), so you may not want to run it in every build, in particular on paid runners as this cost will add up quickly.
+However, `julia --version` does not provide sufficient information to know which commit a nightly binary was built from, therefore it is useful to show the full versioninfo on nightly builds regardless.
 
-Unfortunately, because non-container actions must use JavaScript/TypeScript as scripting language, `npm` is involved. The dependencies are vendored but this action relies 100% on GitHub to audit the dependencies they add to their action toolkit.
+You can override this behaviour by changing the input to `never` if you never want to run `InteractiveUtils.versioninfo()` or to `true` if you always want to run `InteractiveUtils.versioninfo()`, even on stable Julia builds.
 
-## Licence info
-Parts of this software have been derived from the `setup-go` [action](https://github.com/actions/setup-go) and the [JavaScript Action Template](https://github.com/actions/javascript-template), both released by GitHub under the MIT licence.
+## Versioning
+
+This action follows [GitHub's advice](https://help.github.com/en/articles/about-actions#versioning-your-action) on versioning actions, with an additional `latest` tag.
+
+If you don't want to deal with updating the version of the action, similiarly to how Travis CI handles it, use `latest` or major version branches. [Dependabot](https://dependabot.com/) can also be used to automatically create Pull Requests to update actions used in your workflows.
+
+It's unlikely, but not impossible, that there will be breaking changes post-v2.0.0 unless a new major version of Julia is introduced.
+
+You can specify commits, branches or tags in your workflows as follows:
+
+```yaml
+steps:
+  - uses: julia-actions/setup-julia@f2258781c657ad9b4b88072c5eeaf9ec8c370874 # commit SHA of the tagged 2.0.0 commit
+  - uses: julia-actions/setup-julia@latest  # latest version tag (may break existing workflows)
+  - uses: julia-actions/setup-julia@v2      # major version tag
+  - uses: julia-actions/setup-julia@v2.0    # minor version tag
+  - uses: julia-actions/setup-julia@v2.0.0  # specific version tag
+```
+
+If your workflow requires access to secrets, you should always pin it to a commit SHA instead of a tag.
+This will protect you in case a bad actor gains access to the setup-julia repo.
+You can find more information in [GitHub's security hardening guide](https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/security-hardening-for-github-actions#using-third-party-actions).
+
+## Using Dependabot version updates to keep your GitHub Actions up to date
+
+We highly recommend that you set up Dependabot version updates on your repo to keep your GitHub Actions up to date.
+
+To set up Dependabot version updates, create a file named `.github/dependabot.yml` in your repo with the following contents:
+
+```yaml
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    open-pull-requests-limit: 99
+    labels:
+      - "dependencies"
+      - "github-actions"
+```
+
+For more details on Dependabot version updates, see the [GitHub Dependabot documentation](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates).
+
+## Debug logs
+
+You can enable [Step Debug Logs](https://github.com/actions/toolkit/blob/main/docs/action-debugging.md#step-debug-logs) for more detailed logs.
+Note that when debug logs are enabled, a request will be sent to `https://httpbin.julialang.org/ip` and the runner's IP will be printed to the debug logs.
+
+## Third party information
+Parts of this software have been derived from other open source software.
+See [THIRD_PARTY_NOTICE.md](THIRD_PARTY_NOTICE.md) for details.
+
+## Contributing to this repo
+
+Please see the README in the [`devdocs/`](devdocs/) folder.

THIRD_PARTY_NOTICE.md

@@ -0,0 +1,55 @@
+# Third Party Notices and Information
+
+Parts of this software have been derived from other open source software.
+Find their full licence information below.
+
+- [`setup-go` action](#setup-go-action)
+- [TypeScript Action Template](#typescript-action-template)
+
+## [`setup-go` action](https://github.com/actions/setup-go)
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2018 GitHub, Inc. and contributors
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+## [TypeScript Action Template](https://github.com/actions/typescript-action)
+
+> The MIT License (MIT)
+>
+> Copyright (c) 2018 GitHub, Inc. and contributors
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.

__tests__/installer.test.ts

@@ -0,0 +1,132 @@
+// The testing setup has been derived from the actions/setup-go@bc6edb5 action.
+// Check README.md for licence information.
+
+import * as path from 'path'
+
+import * as io from '@actions/io'
+import * as semver from 'semver'
+
+import nock = require('nock')
+
+const testVersions = [
+    '0.1.2',
+    '0.2.0', '0.2.1',
+    '0.3.0', '0.3.1', '0.3.10', '0.3.11', '0.3.12', '0.3.2', '0.3.3', '0.3.4', '0.3.5', '0.3.6', '0.3.7', '0.3.8', '0.3.9',
+    '0.4.0', '0.4.0-rc1', '0.4.0-rc2', '0.4.0-rc3', '0.4.0-rc4', '0.4.1', '0.4.2', '0.4.3', '0.4.4', '0.4.5', '0.4.6', '0.4.7',
+    '0.5.0', '0.5.0-rc0', '0.5.0-rc1', '0.5.0-rc2', '0.5.0-rc3', '0.5.0-rc4', '0.5.1', '0.5.2',
+    '0.6.0', '0.6.0-pre.alpha', '0.6.0-pre.beta', '0.6.0-rc1', '0.6.0-rc2', '0.6.0-rc3', '0.6.1', '0.6.2', '0.6.3', '0.6.4',
+    '0.7.0', '0.7.0-alpha', '0.7.0-beta', '0.7.0-beta2', '0.7.0-rc1', '0.7.0-rc2', '0.7.0-rc3',
+    '1.0.0', '1.0.0-rc1', '1.0.1', '1.0.2', '1.0.3', '1.0.4', '1.0.5',
+    '1.1.0', '1.1.0-rc1', '1.1.0-rc2', '1.1.1',
+    '1.2.0', '1.2.0-rc1', '1.2.0-rc2', '1.2.0-rc3',
+    '1.3.0', '1.3.0-alpha', '1.3.0-rc1', '1.3.0-rc2', '1.3.0-rc3', '1.3.0-rc4', '1.3.0-rc5', '1.3.1',
+    '1.4.0', '1.4.0-rc1', '1.4.0-rc2', '1.4.1', '1.4.2',
+    '1.5.0', '1.5.0-beta1', '1.5.0-rc1', '1.5.0-rc2', '1.5.1', '1.5.2', '1.5.3', '1.5.4',
+    '1.6.0', '1.6.0-beta1', '1.6.0-rc1', '1.6.0-rc2', '1.6.0-rc3', '1.6.1', '1.6.2', '1.6.3', '1.6.4', '1.6.5', '1.6.6', '1.6.7',
+    '1.7.0', '1.7.0-beta1', '1.7.0-beta2', '1.7.0-beta3', '1.7.0-beta4', '1.7.0-rc1', '1.7.0-rc2', '1.7.0-rc3', '1.7.1', '1.7.2', '1.7.3',
+    '1.8.0', '1.8.0-beta1', '1.8.0-beta2', '1.8.0-beta3', '1.8.0-rc1', '1.8.0-rc2', '1.8.0-rc3', '1.8.0-rc4', '1.8.1', '1.8.2', '1.8.3', '1.8.4', '1.8.5',
+    '1.9.0', '1.9.0-alpha1', '1.9.0-beta1', '1.9.0-beta2', '1.9.0-beta3', '1.9.0-beta4', '1.9.0-rc1', '1.9.0-rc2', '1.9.0-rc3', '1.9.1', '1.9.2', '1.9.3', '1.9.4',
+    '1.10.0', '1.10.0-alpha1', '1.10.0-beta1', '1.10.0-beta2', '1.10.0-beta3', '1.10.0-rc1', '1.10.0-rc2', '1.10.0-rc3', '1.10.1', '1.10.2',
+    '1.11.0-alpha1', '1.11.0-alpha2', '1.11.0-beta1'
+]
+
+const toolDir = path.join(__dirname, 'runner', 'tools')
+const tempDir = path.join(__dirname, 'runner', 'temp')
+const fixtureDir = path.join(__dirname, 'fixtures')
+
+process.env['RUNNER_TOOL_CACHE'] = toolDir
+process.env['RUNNER_TEMP'] = tempDir
+
+import * as installer from '../src/installer'
+
+describe('version matching tests', () => {
+    describe('specific versions', () => {
+        it('Doesn\'t change the version when given a valid semver version', () => {
+            expect(installer.getJuliaVersion([], '1.0.5')).toEqual('1.0.5')
+            expect(installer.getJuliaVersion(['v1.0.5', 'v1.0.6'], '1.0.5')).toEqual('1.0.5')
+            expect(installer.getJuliaVersion(['v1.0.4', 'v1.0.5'], '1.0.5')).toEqual('1.0.5')
+            expect(installer.getJuliaVersion(['v1.0.4'], '1.0.5')).toEqual('1.0.5')
+            expect(installer.getJuliaVersion([], '1.3.0-alpha')).toEqual('1.3.0-alpha')
+            expect(installer.getJuliaVersion(['v1.2.0', 'v1.3.0-alpha', 'v1.3.0-rc1', 'v1.3.0'], '1.3.0-alpha')).toEqual('1.3.0-alpha')
+            expect(installer.getJuliaVersion([], '1.3.0-rc2')).toEqual('1.3.0-rc2')
+        })
+
+        it('Doesn\'t change the version when given `nightly`', () => {
+            expect(installer.getJuliaVersion([], 'nightly')).toEqual('nightly')
+            expect(installer.getJuliaVersion(testVersions, 'nightly')).toEqual('nightly')
+        })
+
+        it('LTS', () => {
+            // Update test when LTS is updated
+            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual(installer.getJuliaVersion(testVersions, '1.6'))
+            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual('1.6.7')
+        })
+
+        it('pre', () => {
+            expect(installer.getJuliaVersion(testVersions, 'pre')).toEqual('1.11.0-beta1')
+        })
+    })
+
+    describe('version ranges', () => {
+        it('Chooses the highest available version that matches the input', () => {
+            expect(installer.getJuliaVersion(testVersions, '1')).toEqual('1.10.2')
+            expect(installer.getJuliaVersion(testVersions, '1.0')).toEqual('1.0.5')
+            expect(installer.getJuliaVersion(testVersions, '^1.3.0-rc1')).toEqual('1.10.2')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-rc1')).toEqual('1.10.2')
+            expect(installer.getJuliaVersion(testVersions, '^1.10.0-rc1')).toEqual('1.10.2')
+        })
+    })
+
+    describe('include-prereleases', () => {
+        it('Chooses the highest available version that matches the input including prereleases', () => {
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', true)).toEqual('1.11.0-beta1')
+            expect(installer.getJuliaVersion(testVersions, '1', true)).toEqual('1.11.0-beta1')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', false)).toEqual('1.10.2')
+        })
+    })
+
+    describe('node-semver behaviour', () => {
+        describe('Windows installer change', () => {
+            it('Correctly understands >1.4.0', () => {
+                expect(semver.gtr('1.4.0-rc1', '1.3', {includePrerelease: true})).toBeTruthy()
+                expect(semver.gtr('1.4.0-DEV', '1.3', {includePrerelease: true})).toBeTruthy()
+                expect(semver.gtr('1.3.1', '1.3', {includePrerelease: true})).toBeFalsy()
+                expect(semver.gtr('1.3.2-rc1', '1.3', {includePrerelease: true})).toBeFalsy()
+            })
+        })
+    })
+})
+
+describe('installer tests', () => {
+    beforeAll(async () => {
+        await io.rmRF(toolDir)
+        await io.rmRF(tempDir)
+    }, 100000)
+
+    afterAll(async () => {
+        try {
+            await io.rmRF(toolDir)
+            await io.rmRF(tempDir)
+        } catch {
+            console.log('Failed to remove test directories')
+        }
+    }, 100000)
+
+    describe('versions.json parsing', () => {
+        // Instead of downloading versions.json, use fixtures/versions.json
+        beforeEach(() => {
+            nock('https://julialang-s3.julialang.org').persist()
+                .get('/bin/versions.json')
+                .replyWithFile(200, path.join(fixtureDir, 'versions.json'))
+        })
+
+        afterEach(() => {
+            nock.cleanAll()
+            nock.enableNetConnect()
+        })
+
+        it('Extracts the list of available versions', async () => {
+            expect(await (await installer.getJuliaVersions(await installer.getJuliaVersionInfo())).sort()).toEqual(testVersions.sort())
+        })
+    })
+})

__tests__/main.test.ts

@@ -1,3 +0,0 @@
-describe('TODO - Add a test suite', () => {
-    it('TODO - Add a test', async () => {})
-})

action.yml

@@ -4,10 +4,27 @@ author: 'Sascha Mann'
 inputs: 
   version:
     description: 'The Julia version to download (if necessary) and use. Example: 1.0.4'
-    default: '1.0.4'
+    default: '1'
+  include-all-prereleases:
+    description: 'Include prereleases when matching the Julia version to available versions.'
+    required: false
+    default: 'false'
+  arch:
+    description: 'Architecture of the Julia binaries. Defaults to the architecture of the runner executing the job.'
+    required: false
+    default: '${{ runner.arch }}'
+  show-versioninfo:
+    description: 'Display InteractiveUtils.versioninfo() after installing'
+    required: false
+    default: 'false'
+outputs:
+  julia-version:
+    description: 'The installed Julia version. May vary from the version input if a version range was given as input.'
+  julia-bindir:
+    description: 'Path to the directory containing the Julia executable. Equivalent to JULIA_BINDIR: https://docs.julialang.org/en/v1/manual/environment-variables/#JULIA_BINDIR'
 runs:
-  using: 'node12'
-  main: 'lib/setup-julia.js'
+  using: 'node20'
+  main: 'dist/index.js'
 branding:
   icon: 'download'
   color: 'green'

devdocs/README.md

@@ -0,0 +1,7 @@
+# Devdocs for the `setup-julia` repo
+
+If you want to make a pull request to this repo, please read the following:
+1. [Local development](local_setup.md)
+
+If you have commit access to this repo, you may be interested in the following:
+1. [Making a new release of this action](making_a_new_release.md)

devdocs/local_setup.md

@@ -0,0 +1,47 @@
+# Local development
+
+## 1. Clone the repo
+
+```bash
+git clone git@github.com:julia-actions/setup-julia.git
+cd setup-julia
+```
+
+## 2. Install NodeJS
+
+### Unix, using `asdf` (recommended, but not required)
+
+First, make sure that you have installed [`asdf`](https://asdf-vm.com/) on your local machine.
+
+Then, `cd` to your clone of the repo and run the following commands:
+
+```bash
+asdf plugin add nodejs
+asdf install
+```
+
+This will use `asdf` to install the correct version of NodeJS.
+
+### Unix, but not using `asdf`
+
+Instead of using `asdf`, you can instead choose to install NodeJS manually.
+
+First, check the `.tool-versions` file in this repo, and see what version of NodeJS you need. Then, install that same version of NodejS on your local machine.
+
+### Windows
+
+`asdf` does not (currently) support Windows. So on Windows, you have to install NodeJS manually.
+
+First, check the `.tool-versions` file in this repo, and see what version of NodeJS you need. Then, install that same version of NodejS on your local machine.
+
+## 3. Working locally
+
+First, `cd` to your clone of the repo. Now you can run the following commands:
+
+```bash
+npm ci
+
+npm run build
+```
+
+When you are ready, you can commit your changes and push them to your PR.

devdocs/making_a_new_release.md

@@ -0,0 +1,128 @@
+# Making a new release of this action (requires commit access)
+
+If you have commit access to this repo, you can make a new release.
+
+Here are the instructions.
+
+## Step 1: Clone a fresh copy of the repo
+
+We intentionally work in a brand-new copy of the repo.
+
+```bash
+git clone git@github.com:julia-actions/setup-julia.git
+cd setup-julia
+git checkout master
+git submodule init
+git submodule update
+```
+
+## Step 2: Make sure you have the right version of NodeJS
+
+If you use [`asdf`](https://asdf-vm.com/), this is as simple as:
+
+```bash
+asdf plugin add nodejs
+asdf install
+```
+
+If you don't use `asdf`, then you need to:
+1. Open the `./tool-versions` file in the root of the repo.
+2. Make note of the NodeJS version listed in the `.tool-versions` file.
+3. Install that same version of NodeJS on your machine.
+4. Make sure that you are currently using that version of NodeJS (i.e. it is at the front of your PATH).
+
+## Step 3: Edit the `version` field in `package.json`
+
+```bash
+vim package.json
+
+# Edit the `version` number (should be line 2)
+# Save your changes in Vim. Then exit Vim.
+
+# For the remaining of this guide, let MAJOR.MINOR.PATCH refer
+# to the new version number that you set.
+
+git add package.json
+
+# No need to commit yet.
+# The release script will run `git commit`.
+```
+
+## Step 4: Remove the `dist/` line from the `.gitignore` file
+
+```bash
+vim .gitignore
+# Delete the line that says `dist/` (it should be line 3)
+# Save your changes in Vim. Then exit Vim.
+
+git add .gitignore
+
+# No need to commit yet.
+# The release script will run `git commit`.
+```
+
+## Step 5: Make sure you have the necessary dependencies
+
+The `build-release.sh` script requires the following dependencies:
+
+1. Bash
+2. `curl`
+3. `git`
+4. `jq`
+5. `sed`
+
+## Step 6: Run the `build-release.sh` script
+
+```bash
+ls -l bin/build-release.sh
+chmod +x bin/build-release.sh
+ls -l bin/build-release.sh
+
+./bin/build-release.sh julia-actions/setup-julia
+```
+
+Wait a minute or two. The script will build everything and will create a new release branch named `releases/vMAJOR.MINOR.PATCH`.
+
+## Step 7: Push ONLY the `releases/vMAJOR.MINOR.PATCH` branch
+
+Only push the `releases/` branch. Do NOT push any tags yet.
+
+```bash
+git push origin releases/vMAJOR.MINOR.PATCH
+```
+
+Now you need to go to https://github.com/julia-actions/setup-julia/tree/releases/vMAJOR.MINOR.PATCH and wait for CI to finish running.
+
+Do NOT proceed to the next step until CI is all green on the `releases/vMAJOR.MINOR.PATCH` branch.
+
+## Step 8: Push the tags (only after CI is all green)
+
+Once CI is all green on the `releases/vMAJOR.MINOR.PATCH` branch, you can push the tags.
+
+You need to force-push.
+
+```bash
+git push --tags --force
+```
+
+## Step 9: Use the GitHub web UI to create a new GitHub Release
+
+Go to https://github.com/julia-actions/setup-julia/releases  and create a new release for the now-existant `vMAJOR.MINOR.PATCH` tag using the GitHub web interface.
+
+## Step 10: Clean up your local repo
+
+```bash
+git submodule deinit --force .
+git submodule update --init
+git fetch --all --prune
+git checkout master
+git reset --hard origin/master
+```
+
+## Step 11: Delete your local repo
+
+```bash
+cd ..
+ls setup-julia
+rm -rf setup-julia
+```

devdocs/misc/misc_notes_for_committers.md

@@ -1,4 +1,4 @@
-# Contributors
+# Misc notes for contributors
 
 ### Checkin
 
@@ -19,4 +19,4 @@ git commit -m "Informative commit message"  # Commit. This will run Husky
 ```
 
 During the commit step, Husky will take care of formatting all files with [Prettier](https://github.com/prettier/prettier) as well as pruning out devDependencies using `npm prune --production`.
-It will also make sure these changes are appropriately included in your commit (no further work is needed)
+It will also make sure these changes are appropriately included in your commit (no further work is needed)

lib/installer.js

@@ -0,0 +1,361 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showVersionInfo = exports.installJulia = exports.getDownloadURL = exports.getFileInfo = exports.getJuliaVersion = exports.getJuliaVersions = exports.getJuliaVersionInfo = void 0;
+const core = __importStar(require("@actions/core"));
+const exec = __importStar(require("@actions/exec"));
+const tc = __importStar(require("@actions/tool-cache"));
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const retry = require("async-retry");
+const semver = __importStar(require("semver"));
+const LTS_VERSION = '1.6';
+const MAJOR_VERSION = '1'; // Could be deduced from versions.json
+// Translations between actions input and Julia arch names
+const osMap = {
+    'win32': 'winnt',
+    'darwin': 'mac',
+    'linux': 'linux'
+};
+const archMap = {
+    'x86': 'i686',
+    'x64': 'x86_64',
+    'aarch64': 'aarch64'
+};
+// Store information about the environment
+const osPlat = os.platform(); // possible values: win32 (Windows), linux (Linux), darwin (macOS)
+core.debug(`platform: ${osPlat}`);
+/**
+ * @returns The SHA256 checksum of a given file.
+ */
+function calculateChecksum(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const hash = crypto.createHash('sha256');
+        const input = fs.createReadStream(file);
+        return new Promise((resolve, reject) => {
+            input.on('data', (chunk) => {
+                hash.update(chunk);
+            });
+            input.on('end', () => {
+                const digest = hash.digest('hex');
+                digest ? resolve(digest) : reject(new Error(`Could not calculate checksum of file ${file}: digest was empty.`));
+            });
+        });
+    });
+}
+/**
+ * @returns The content of the downloaded versions.json file as object.
+ */
+function getJuliaVersionInfo() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Occasionally the connection is reset for unknown reasons
+        // In those cases, retry the download
+        const versionsFile = yield retry((bail) => __awaiter(this, void 0, void 0, function* () {
+            return yield tc.downloadTool('https://julialang-s3.julialang.org/bin/versions.json');
+        }), {
+            retries: 5,
+            onRetry: (err) => {
+                core.info(`Download of versions.json failed, trying again. Error: ${err}`);
+            }
+        });
+        return JSON.parse(fs.readFileSync(versionsFile).toString());
+    });
+}
+exports.getJuliaVersionInfo = getJuliaVersionInfo;
+/**
+ * @returns An array of all Julia versions available for download
+ */
+function getJuliaVersions(versionInfo) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let versions = [];
+        for (let version in versionInfo) {
+            versions.push(version);
+        }
+        return versions;
+    });
+}
+exports.getJuliaVersions = getJuliaVersions;
+function getJuliaVersion(availableReleases, versionInput, includePrerelease = false) {
+    if (semver.valid(versionInput) == versionInput || versionInput.endsWith('nightly')) {
+        // versionInput is a valid version or a nightly version, use it directly
+        return versionInput;
+    }
+    if (versionInput == 'lts') {
+        return getJuliaVersion(availableReleases, LTS_VERSION, false);
+    }
+    if (versionInput == 'pre') {
+        return getJuliaVersion(availableReleases, MAJOR_VERSION, true);
+    }
+    // Use the highest available version that matches versionInput
+    let version = semver.maxSatisfying(availableReleases, versionInput, { includePrerelease });
+    if (version == null) {
+        throw new Error(`Could not find a Julia version that matches ${versionInput}`);
+    }
+    // GitHub tags start with v, remove it
+    version = version.replace(/^v/, '');
+    return version;
+}
+exports.getJuliaVersion = getJuliaVersion;
+function getDesiredFileExts() {
+    let fileExt1;
+    let hasFileExt2;
+    let fileExt2;
+    if (osPlat == 'win32') {
+        fileExt1 = 'tar.gz';
+        hasFileExt2 = true;
+        fileExt2 = 'exe';
+    }
+    else if (osPlat == 'darwin') {
+        fileExt1 = 'tar.gz';
+        hasFileExt2 = true;
+        fileExt2 = 'dmg';
+    }
+    else if (osPlat === 'linux') {
+        fileExt1 = 'tar.gz';
+        hasFileExt2 = false;
+        fileExt2 = '';
+    }
+    else {
+        throw new Error(`Platform ${osPlat} is not supported`);
+    }
+    return [fileExt1, hasFileExt2, fileExt2];
+}
+function getNightlyFileName(arch) {
+    let versionExt;
+    let fileExt1;
+    [fileExt1, ,] = getDesiredFileExts();
+    if (osPlat == 'win32') {
+        if (arch == 'x86') {
+            versionExt = '-win32';
+        }
+        else if (arch == 'aarch64') {
+            throw new Error('Aarch64 Julia is not available on Windows');
+        }
+        else if (arch == 'x64') {
+            versionExt = '-win64';
+        }
+        else {
+            throw new Error(`Architecture ${arch} is not supported on Windows`);
+        }
+    }
+    else if (osPlat == 'darwin') {
+        if (arch == 'x86') {
+            throw new Error('32-bit (x86) Julia is not available on macOS');
+        }
+        else if (arch == 'aarch64') {
+            versionExt = '-macaarch64';
+        }
+        else if (arch == 'x64') {
+            versionExt = '-mac64';
+        }
+        else {
+            throw new Error(`Architecture ${arch} is not supported on macOS`);
+        }
+    }
+    else if (osPlat === 'linux') {
+        if (arch == 'x86') {
+            versionExt = '-linux32';
+        }
+        else if (arch == 'aarch64') {
+            versionExt = '-linux-aarch64';
+        }
+        else if (arch == 'x64') {
+            versionExt = '-linux64';
+        }
+        else {
+            throw new Error(`Architecture ${arch} is not supported on Linux`);
+        }
+    }
+    else {
+        throw new Error(`Platform ${osPlat} is not supported`);
+    }
+    return `julia-latest${versionExt}.${fileExt1}`;
+}
+function getFileInfo(versionInfo, version, arch) {
+    const err = `Could not find ${archMap[arch]}/${version} binaries`;
+    let fileExt1;
+    let hasFileExt2;
+    let fileExt2;
+    [fileExt1, hasFileExt2, fileExt2] = getDesiredFileExts();
+    if (version.endsWith('nightly')) {
+        return null;
+    }
+    if (!versionInfo[version]) {
+        throw err;
+    }
+    for (let file of versionInfo[version].files) {
+        if (file.os == osMap[osPlat] && file.arch == archMap[arch]) {
+            if (file.extension == fileExt1) {
+                return file;
+            }
+        }
+    }
+    if (hasFileExt2) {
+        core.debug(`Could not find ${fileExt1}; trying to find ${fileExt2} instead`);
+        for (let file of versionInfo[version].files) {
+            if (file.os == osMap[osPlat] && file.arch == archMap[arch]) {
+                if (file.extension == fileExt2) {
+                    return file;
+                }
+            }
+        }
+    }
+    throw err;
+}
+exports.getFileInfo = getFileInfo;
+function getDownloadURL(fileInfo, version, arch) {
+    const baseURL = `https://julialangnightlies-s3.julialang.org/bin/${osMap[osPlat]}/${arch}`;
+    // release branch nightlies, e.g. 1.6-nightlies should return .../bin/linux/x64/1.6/julia-latest-linux64.tar.gz
+    const majorMinorMatches = /^(\d*.\d*)-nightly/.exec(version);
+    if (majorMinorMatches) {
+        return `${baseURL}/${majorMinorMatches[1]}/${getNightlyFileName(arch)}`;
+    }
+    // nightlies
+    if (version == 'nightly') {
+        return `${baseURL}/${getNightlyFileName(arch)}`;
+    }
+    // Verify that fileInfo.url points at the official Julia download servers
+    if (!fileInfo.url.startsWith('https://julialang-s3.julialang.org/')) {
+        throw new Error(`versions.json points at a download location outside of Julia's download server: ${fileInfo.url}. Aborting for security reasons.`);
+    }
+    return fileInfo.url;
+}
+exports.getDownloadURL = getDownloadURL;
+function installJulia(dest, versionInfo, version, arch) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Download Julia
+        const fileInfo = getFileInfo(versionInfo, version, arch);
+        const downloadURL = getDownloadURL(fileInfo, version, arch);
+        core.debug(`downloading Julia from ${downloadURL}`);
+        // Occasionally the connection is reset for unknown reasons
+        // In those cases, retry the download
+        const juliaDownloadPath = yield retry((bail) => __awaiter(this, void 0, void 0, function* () {
+            return yield tc.downloadTool(downloadURL);
+        }), {
+            retries: 5,
+            onRetry: (err) => {
+                core.info(`Download of ${downloadURL} failed, trying again. Error: ${err}`);
+            }
+        });
+        // Verify checksum
+        if (!version.endsWith('nightly')) {
+            const checkSum = yield calculateChecksum(juliaDownloadPath);
+            if (fileInfo.sha256 != checkSum) {
+                throw new Error(`Checksum of downloaded file does not match the expected checksum from versions.json.\nExpected: ${fileInfo.sha256}\nGot: ${checkSum}`);
+            }
+            core.debug(`Checksum of downloaded file matches expected checksum: ${checkSum}`);
+        }
+        else {
+            core.debug('Skipping checksum check for nightly binaries.');
+        }
+        // Install it
+        switch (osPlat) {
+            case 'linux':
+                // tc.extractTar doesn't support stripping components, so we have to call tar manually
+                yield exec.exec('tar', ['xf', juliaDownloadPath, '--strip-components=1', '-C', dest]);
+                return dest;
+            case 'win32':
+                if (fileInfo !== null && fileInfo.extension == 'exe') {
+                    if (version.endsWith('nightly') || semver.gtr(version, '1.3', { includePrerelease: true })) {
+                        // The installer changed in 1.4: https://github.com/JuliaLang/julia/blob/ef0c9108b12f3ae177c51037934351ffa703b0b5/NEWS.md#build-system-changes
+                        yield exec.exec('powershell', ['-Command', `Start-Process -FilePath ${juliaDownloadPath} -ArgumentList "/SILENT /dir=${path.join(process.cwd(), dest)}" -NoNewWindow -Wait`]);
+                    }
+                    else {
+                        yield exec.exec('powershell', ['-Command', `Start-Process -FilePath ${juliaDownloadPath} -ArgumentList "/S /D=${path.join(process.cwd(), dest)}" -NoNewWindow -Wait`]);
+                    }
+                }
+                else {
+                    // This is the more common path. Using .tar.gz is much faster
+                    // don't use the Git bash provided tar. Issue #205
+                    // https://github.com/julia-actions/setup-julia/issues/205
+                    yield exec.exec('powershell', ['-Command', `& "$env:WINDIR/System32/tar" xf ${juliaDownloadPath} --strip-components=1 -C ${dest}`]);
+                }
+                return dest;
+            case 'darwin':
+                if (fileInfo !== null && fileInfo.extension == 'dmg') {
+                    core.debug(`Support for .dmg files is deprecated and may be removed in a future release`);
+                    yield exec.exec('hdiutil', ['attach', juliaDownloadPath]);
+                    yield exec.exec('/bin/bash', ['-c', `cp -a /Volumes/Julia-*/Julia-*.app/Contents/Resources/julia ${dest}`]);
+                    return path.join(dest, 'julia');
+                }
+                else {
+                    // tc.extractTar doesn't support stripping components, so we have to call tar manually
+                    yield exec.exec('tar', ['xf', juliaDownloadPath, '--strip-components=1', '-C', dest]);
+                    return dest;
+                }
+            default:
+                throw new Error(`Platform ${osPlat} is not supported`);
+        }
+    });
+}
+exports.installJulia = installJulia;
+/**
+ * Test if Julia has been installed and print the version.
+ *
+ * true => always show versioninfo
+ * false => only show on nightlies
+ * never => never show it anywhere
+ *
+ * @param showVersionInfoInput
+ */
+function showVersionInfo(showVersionInfoInput, version) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // --compile=min -O0 reduces the time from ~1.8-1.9s to ~0.8-0.9s
+        let exitCode;
+        switch (showVersionInfoInput) {
+            case 'true':
+                exitCode = yield exec.exec('julia', ['--compile=min', '-O0', '-e', 'using InteractiveUtils; versioninfo()']);
+                break;
+            case 'false':
+                if (version.endsWith('nightly')) {
+                    exitCode = yield exec.exec('julia', ['--compile=min', '-O0', '-e', 'using InteractiveUtils; versioninfo()']);
+                }
+                else {
+                    exitCode = yield exec.exec('julia', ['--version']);
+                }
+                break;
+            case 'never':
+                exitCode = yield exec.exec('julia', ['--version']);
+                break;
+            default:
+                throw new Error(`${showVersionInfoInput} is not a valid value for show-versioninfo. Supported values: true | false | never`);
+        }
+        if (exitCode !== 0) {
+            throw new Error(`Julia could not be installed properly. Exit code: ${exitCode}`);
+        }
+    });
+}
+exports.showVersionInfo = showVersionInfo;

lib/setup-julia.js

@@ -1,101 +1,119 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const core = __importStar(require("@actions/core"));
-const exec = __importStar(require("@actions/exec"));
 const tc = __importStar(require("@actions/tool-cache"));
-const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const https = __importStar(require("https"));
 const path = __importStar(require("path"));
-// Store information about the environment
-const osPlat = os.platform(); // possible values: win32 (Windows), linux (Linux), darwin (macOS)
-core.debug(`platform: ${osPlat}`);
-function getMajorMinorVersion(version) {
-    return version.split('.').slice(0, 2).join('.');
-}
-function getDownloadURL(version) {
-    const baseURL = 'https://julialang-s3.julialang.org/bin';
-    let platform, arch;
-    const versionDir = getMajorMinorVersion(version);
-    if (osPlat === 'win32') { // Windows
-        platform = 'winnt';
-        arch = 'x64';
-    }
-    else if (osPlat === 'darwin') { // macOS
-        platform = 'mac';
-        arch = 'x64';
-    }
-    else if (osPlat === 'linux') { // Linux
-        platform = 'linux';
-        arch = 'x64';
-    }
-    else {
-        throw `Platform ${osPlat} is not supported`;
-    }
-    return `${baseURL}/${platform}/${arch}/${versionDir}/${getFileName(version)}`;
-}
-function getFileName(version) {
-    let versionExt, ext;
-    if (osPlat === 'win32') { // Windows
-        versionExt = '-win64';
-        ext = 'exe';
-    }
-    else if (osPlat === 'darwin') { // macOS
-        versionExt = '-mac64';
-        ext = 'dmg';
-    }
-    else if (osPlat === 'linux') { // Linux
-        versionExt = '-linux-x86_64';
-        ext = 'tar.gz';
-    }
-    else {
-        throw `Platform ${osPlat} is not supported`;
-    }
-    return `julia-${version}${versionExt}.${ext}`;
-}
+const installer = __importStar(require("./installer"));
+const archSynonyms = {
+    'x86': 'x86',
+    'X86': 'x86',
+    'x64': 'x64',
+    'X64': 'x64',
+    'aarch64': 'aarch64',
+    'ARM64': 'aarch64',
+    'arm64': 'aarch64'
+};
 function run() {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const version = core.getInput('version');
-            core.debug(`selected Julia version: ${version}`);
-            // Download Julia
-            const downloadURL = getDownloadURL(version);
-            core.debug(`download Julia from ${downloadURL}`);
-            const juliaDownloadPath = yield tc.downloadTool(downloadURL);
-            // Install Julia
-            if (osPlat === 'linux') { // Linux
-                const juliaExtractedFolder = yield tc.extractTar(juliaDownloadPath);
-                const juliaCachedPath = yield tc.cacheDir(juliaExtractedFolder, 'julia', version);
-                const juliaPath = path.join(juliaCachedPath, `julia-${version}`);
-                core.addPath(path.join(juliaPath, 'bin'));
+            // Debugging info
+            if (core.isDebug()) {
+                // Log Runner IP Address
+                https.get('https://httpbin.julialang.org/ip', resp => {
+                    let data = '';
+                    resp.on('data', chunk => {
+                        data += chunk;
+                    });
+                    resp.on('end', () => {
+                        core.debug(`Runner IP address: ${JSON.parse(data).origin}`);
+                    });
+                }).on('error', err => {
+                    core.debug(`ERROR: Could not retrieve runner IP: ${err}`);
+                });
             }
-            else if (osPlat === 'win32') { // Windows
-                // Install Julia in C:\Julia
-                const juliaInstallationPath = path.join('C:', 'Julia');
-                yield exec.exec('powershell', ['-Command', `Start-Process -FilePath ${juliaDownloadPath} -ArgumentList "/S /D=${juliaInstallationPath}" -NoNewWindow -Wait`]);
-                const juliaCachedPath = yield tc.cacheDir(juliaInstallationPath, 'julia', version);
-                core.addPath(path.join(juliaCachedPath, 'bin'));
+            // Inputs
+            const versionInput = core.getInput('version');
+            const includePrereleases = core.getInput('include-all-prereleases') == 'true';
+            const originalArchInput = core.getInput('arch');
+            // It can easily happen that, for example, a workflow file contains an input `version: ${{ matrix.julia-version }}`
+            // while the strategy matrix only contains a key `${{ matrix.version }}`.
+            // In that case, we want the action to fail, rather than trying to download julia from an URL that's missing parts and 404ing.
+            // We _could_ fall back to the default but that means that builds silently do things differently than they're meant to, which
+            // is worse than failing the build.
+            if (!versionInput) {
+                throw new Error('Version input must not be null');
             }
-            else if (osPlat === 'darwin') { // macOS
-                yield exec.exec('hdiutil', ['attach', juliaDownloadPath]);
-                const juliaCachedPath = yield tc.cacheDir(`/Volumes/Julia-${version}/Julia-${getMajorMinorVersion(version)}.app/Contents/Resources/julia`, 'julia', version);
-                core.addPath(path.join(juliaCachedPath, 'bin'));
+            if (!originalArchInput) {
+                throw new Error(`Arch input must not be null`);
             }
-            // Test if Julia has been installed by showing versioninfo()
-            yield exec.exec('julia', ['-e', 'using InteractiveUtils; versioninfo()']);
+            const arch = archSynonyms[originalArchInput];
+            const versionInfo = yield installer.getJuliaVersionInfo();
+            const availableReleases = yield installer.getJuliaVersions(versionInfo);
+            const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases);
+            core.debug(`selected Julia version: ${arch}/${version}`);
+            core.setOutput('julia-version', version);
+            // Search in cache
+            let juliaPath;
+            juliaPath = tc.find('julia', version, arch);
+            if (!juliaPath) {
+                core.debug(`could not find Julia ${arch}/${version} in cache`);
+                // https://github.com/julia-actions/setup-julia/pull/196
+                // we want julia to be installed with unmodified file mtimes
+                // but `tc.cacheDir` uses `cp` internally which destroys mtime
+                // and `tc` provides no API to get the tool directory alone
+                // so hack it by installing a empty directory then use the path it returns
+                // and extract the archives directly to that location
+                const emptyDir = fs.mkdtempSync('empty');
+                juliaPath = yield tc.cacheDir(emptyDir, 'julia', version, arch);
+                yield installer.installJulia(juliaPath, versionInfo, version, arch);
+                core.debug(`added Julia to cache: ${juliaPath}`);
+                // Remove empty dir
+                fs.rmdirSync(emptyDir);
+            }
+            else {
+                core.debug(`using cached version of Julia: ${juliaPath}`);
+            }
+            // Add it to PATH
+            core.addPath(path.join(juliaPath, 'bin'));
+            // Set output
+            core.setOutput('julia-bindir', path.join(juliaPath, 'bin'));
+            // Test if Julia has been installed and print the version
+            const showVersionInfoInput = core.getInput('show-versioninfo');
+            yield installer.showVersionInfo(showVersionInfoInput, version);
         }
         catch (error) {
             core.setFailed(error.message);

package.json

@@ -1,13 +1,12 @@
 {
   "name": "setup-julia",
-  "version": "0.1.0",
+  "version": "2.2.0",
   "private": true,
   "description": "setup Julia action",
   "main": "lib/setup-julia.js",
   "scripts": {
     "build": "tsc",
-    "format": "prettier --single-quote --print-width 120 --tab-width 4 --no-semi --write **/*.ts",
-    "format-check": "prettier  --single-quote --print-width 120 --tab-width 4 --no-semi --check **/*.ts",
+    "pack": "ncc build",
     "test": "jest"
   },
   "repository": {
@@ -22,21 +21,25 @@
   "author": "Sascha Mann <git@mail.saschamann.eu>",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.0.0",
-    "@actions/io": "^1.0.0",
-    "@actions/exec": "^1.0.0",
-    "@actions/github": "^1.0.0",
-    "@actions/tool-cache": "^1.0.0",
-    "semver": "^6.1.1"
+    "@actions/core": "^1.10.1",
+    "@actions/exec": "^1.1.1",
+    "@actions/io": "^1.1.3",
+    "@actions/tool-cache": "^2.0.1",
+    "async-retry": "^1.3.3",
+    "semver": "^7.6.2"
   },
   "devDependencies": {
-    "@types/jest": "^24.0.13",
-    "@types/node": "^12.0.4",
-    "@types/semver": "^6.0.0",
-    "jest": "^24.8.0",
-    "jest-circus": "^24.7.1",
-    "prettier": "^1.17.1",
-    "ts-jest": "^24.0.2",
-    "typescript": "^3.5.1"
+    "@types/async-retry": "^1.4.8",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.14.6",
+    "@types/retry": "^0.12.5",
+    "@types/semver": "^7.5.8",
+    "@vercel/ncc": "^0.38.1",
+    "jest": "^29.7.0",
+    "jest-circus": "^29.7.0",
+    "nock": "^13.5.4",
+    "prettier": "^3.3.2",
+    "ts-jest": "^29.1.5",
+    "typescript": "^5.4.5"
   }
 }

src/installer.ts

@@ -0,0 +1,335 @@
+import * as core from '@actions/core'
+import * as exec from '@actions/exec'
+import * as tc from '@actions/tool-cache'
+
+import * as crypto from 'crypto'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import retry = require('async-retry')
+
+import * as semver from 'semver'
+
+const LTS_VERSION = '1.6'
+const MAJOR_VERSION = '1' // Could be deduced from versions.json
+
+// Translations between actions input and Julia arch names
+const osMap = {
+    'win32': 'winnt',
+    'darwin': 'mac',
+    'linux': 'linux'
+}
+const archMap = {
+    'x86': 'i686',
+    'x64': 'x86_64',
+    'aarch64': 'aarch64'
+}
+
+// Store information about the environment
+const osPlat = os.platform() // possible values: win32 (Windows), linux (Linux), darwin (macOS)
+core.debug(`platform: ${osPlat}`)
+
+/**
+ * @returns The SHA256 checksum of a given file.
+ */
+async function calculateChecksum(file: string): Promise<string> {
+    const hash = crypto.createHash('sha256')
+    const input = fs.createReadStream(file)
+
+    return new Promise((resolve, reject) => {
+        input.on('data', (chunk) => {
+            hash.update(chunk)
+        })
+
+        input.on('end', () => {
+            const digest = hash.digest('hex')
+            digest ? resolve(digest) : reject(new Error(`Could not calculate checksum of file ${file}: digest was empty.`))
+        })
+    })
+}
+
+/**
+ * @returns The content of the downloaded versions.json file as object.
+ */
+export async function getJuliaVersionInfo(): Promise<object> {
+    // Occasionally the connection is reset for unknown reasons
+    // In those cases, retry the download
+    const versionsFile = await retry(async (bail: Function) => {
+        return await tc.downloadTool('https://julialang-s3.julialang.org/bin/versions.json')
+    }, {
+        retries: 5,
+        onRetry: (err: Error) => {
+            core.info(`Download of versions.json failed, trying again. Error: ${err}`)
+        }
+    })
+
+    return JSON.parse(fs.readFileSync(versionsFile).toString())
+}
+
+/**
+ * @returns An array of all Julia versions available for download
+ */
+export async function getJuliaVersions(versionInfo): Promise<string[]> {
+    let versions: string[] = []
+
+    for (let version in versionInfo) {
+        versions.push(version)
+    }
+
+    return versions
+}
+
+export function getJuliaVersion(availableReleases: string[], versionInput: string, includePrerelease: boolean = false): string {
+    if (semver.valid(versionInput) == versionInput || versionInput.endsWith('nightly')) {
+        // versionInput is a valid version or a nightly version, use it directly
+        return versionInput
+    }
+
+    if (versionInput == 'lts') {
+        return getJuliaVersion(availableReleases, LTS_VERSION, false)
+    }
+
+    if (versionInput == 'pre') {
+        return getJuliaVersion(availableReleases, MAJOR_VERSION, true)
+    }
+
+    // Use the highest available version that matches versionInput
+    let version = semver.maxSatisfying(availableReleases, versionInput, {includePrerelease})
+    if (version == null) {
+        throw new Error(`Could not find a Julia version that matches ${versionInput}`)
+    }
+
+    // GitHub tags start with v, remove it
+    version = version.replace(/^v/, '')
+
+    return version
+}
+
+function getDesiredFileExts(): [string, boolean, string] {
+    let fileExt1: string
+    let hasFileExt2: boolean
+    let fileExt2: string
+
+    if (osPlat == 'win32') {
+        fileExt1 = 'tar.gz'
+        hasFileExt2 = true
+        fileExt2 = 'exe'
+    } else if (osPlat == 'darwin') {
+        fileExt1 = 'tar.gz'
+        hasFileExt2 = true
+        fileExt2 = 'dmg'
+    } else if (osPlat === 'linux') {
+        fileExt1 = 'tar.gz'
+        hasFileExt2 = false
+        fileExt2 = ''
+    } else {
+        throw new Error(`Platform ${osPlat} is not supported`)
+    }
+
+    return [fileExt1, hasFileExt2, fileExt2]
+}
+
+function getNightlyFileName(arch: string): string {
+    let versionExt: string
+    let fileExt1: string
+    [fileExt1, , ] = getDesiredFileExts()
+
+    if (osPlat == 'win32') {
+        if (arch == 'x86') {
+            versionExt = '-win32'
+        } else if (arch == 'aarch64') {
+            throw new Error('Aarch64 Julia is not available on Windows')
+        } else if (arch == 'x64') {
+            versionExt = '-win64'
+        } else {
+            throw new Error(`Architecture ${arch} is not supported on Windows`)
+        }
+    } else if (osPlat == 'darwin') {
+        if (arch == 'x86') {
+            throw new Error('32-bit (x86) Julia is not available on macOS')
+        } else if (arch == 'aarch64') {
+            versionExt = '-macaarch64'
+        } else if (arch == 'x64') {
+            versionExt = '-mac64'
+        } else {
+            throw new Error(`Architecture ${arch} is not supported on macOS`)
+        }
+    } else if (osPlat === 'linux') {
+        if (arch == 'x86') {
+            versionExt = '-linux32'
+        } else if (arch == 'aarch64') {
+            versionExt = '-linux-aarch64'
+        } else if (arch == 'x64') {
+            versionExt = '-linux64'
+        } else {
+            throw new Error(`Architecture ${arch} is not supported on Linux`)
+        }
+    } else {
+        throw new Error(`Platform ${osPlat} is not supported`)
+    }
+
+    return `julia-latest${versionExt}.${fileExt1}`
+}
+
+export function getFileInfo(versionInfo, version: string, arch: string) {
+    const err = `Could not find ${archMap[arch]}/${version} binaries`
+
+    let fileExt1: string
+    let hasFileExt2: boolean
+    let fileExt2: string
+    [fileExt1, hasFileExt2, fileExt2] = getDesiredFileExts()
+
+    if (version.endsWith('nightly')) {
+        return null
+    }
+
+    if (!versionInfo[version]) {
+       throw err
+    }
+
+    for (let file of versionInfo[version].files) {
+        if (file.os == osMap[osPlat] && file.arch == archMap[arch]) {
+            if (file.extension == fileExt1) {
+                return file
+            }
+        }
+    }
+
+    if (hasFileExt2) {
+        core.debug(`Could not find ${fileExt1}; trying to find ${fileExt2} instead`)
+        for (let file of versionInfo[version].files) {
+            if (file.os == osMap[osPlat] && file.arch == archMap[arch]) {
+                if (file.extension == fileExt2) {
+                    return file
+                }
+            }
+        }
+    }
+
+    throw err
+}
+
+export function getDownloadURL(fileInfo, version: string, arch: string): string {
+    const baseURL = `https://julialangnightlies-s3.julialang.org/bin/${osMap[osPlat]}/${arch}`
+
+    // release branch nightlies, e.g. 1.6-nightlies should return .../bin/linux/x64/1.6/julia-latest-linux64.tar.gz
+    const majorMinorMatches = /^(\d*.\d*)-nightly/.exec(version)
+    if (majorMinorMatches) {
+        return `${baseURL}/${majorMinorMatches[1]}/${getNightlyFileName(arch)}`
+    }
+
+    // nightlies
+    if (version == 'nightly') {
+        return `${baseURL}/${getNightlyFileName(arch)}`
+    }
+
+    // Verify that fileInfo.url points at the official Julia download servers
+    if (!fileInfo.url.startsWith('https://julialang-s3.julialang.org/')) {
+        throw new Error(`versions.json points at a download location outside of Julia's download server: ${fileInfo.url}. Aborting for security reasons.`)
+    }
+    return fileInfo.url
+}
+
+export async function installJulia(dest: string, versionInfo, version: string, arch: string): Promise<string> {
+    // Download Julia
+    const fileInfo = getFileInfo(versionInfo, version, arch)
+    const downloadURL = getDownloadURL(fileInfo, version, arch)
+    core.debug(`downloading Julia from ${downloadURL}`)
+
+    // Occasionally the connection is reset for unknown reasons
+    // In those cases, retry the download
+    const juliaDownloadPath = await retry(async (bail: Function) => {
+        return await tc.downloadTool(downloadURL)
+    }, {
+        retries: 5,
+        onRetry: (err: Error) => {
+            core.info(`Download of ${downloadURL} failed, trying again. Error: ${err}`)
+        }
+    })
+
+    // Verify checksum
+    if (!version.endsWith('nightly')) {
+        const checkSum = await calculateChecksum(juliaDownloadPath)
+        if (fileInfo.sha256 != checkSum) {
+            throw new Error(`Checksum of downloaded file does not match the expected checksum from versions.json.\nExpected: ${fileInfo.sha256}\nGot: ${checkSum}`)
+        }
+        core.debug(`Checksum of downloaded file matches expected checksum: ${checkSum}`)
+    } else {
+        core.debug('Skipping checksum check for nightly binaries.')
+    }
+
+    // Install it
+    switch (osPlat) {
+        case 'linux':
+            // tc.extractTar doesn't support stripping components, so we have to call tar manually
+            await exec.exec('tar', ['xf', juliaDownloadPath, '--strip-components=1', '-C', dest])
+            return dest
+        case 'win32':
+            if (fileInfo !== null && fileInfo.extension == 'exe') {
+                if (version.endsWith('nightly') || semver.gtr(version, '1.3', {includePrerelease: true})) {
+                    // The installer changed in 1.4: https://github.com/JuliaLang/julia/blob/ef0c9108b12f3ae177c51037934351ffa703b0b5/NEWS.md#build-system-changes
+                    await exec.exec('powershell', ['-Command', `Start-Process -FilePath ${juliaDownloadPath} -ArgumentList "/SILENT /dir=${path.join(process.cwd(), dest)}" -NoNewWindow -Wait`])
+                } else {
+                    await exec.exec('powershell', ['-Command', `Start-Process -FilePath ${juliaDownloadPath} -ArgumentList "/S /D=${path.join(process.cwd(), dest)}" -NoNewWindow -Wait`])
+                }
+            } else {
+                // This is the more common path. Using .tar.gz is much faster
+                // don't use the Git bash provided tar. Issue #205
+                // https://github.com/julia-actions/setup-julia/issues/205
+                await exec.exec('powershell', ['-Command', `& "$env:WINDIR/System32/tar" xf ${juliaDownloadPath} --strip-components=1 -C ${dest}`])
+            }
+            return dest
+        case 'darwin':
+            if (fileInfo !== null && fileInfo.extension == 'dmg') {
+                core.debug(`Support for .dmg files is deprecated and may be removed in a future release`)
+                await exec.exec('hdiutil', ['attach', juliaDownloadPath])
+                await exec.exec('/bin/bash', ['-c', `cp -a /Volumes/Julia-*/Julia-*.app/Contents/Resources/julia ${dest}`])
+                return path.join(dest, 'julia')
+            } else {
+                // tc.extractTar doesn't support stripping components, so we have to call tar manually
+                await exec.exec('tar', ['xf', juliaDownloadPath, '--strip-components=1', '-C', dest])
+                return dest
+            }
+        default:
+            throw new Error(`Platform ${osPlat} is not supported`)
+    }
+}
+
+/**
+ * Test if Julia has been installed and print the version.
+ *
+ * true => always show versioninfo
+ * false => only show on nightlies
+ * never => never show it anywhere
+ *
+ * @param showVersionInfoInput
+ */
+export async function showVersionInfo(showVersionInfoInput: string, version: string): Promise<void> {
+    // --compile=min -O0 reduces the time from ~1.8-1.9s to ~0.8-0.9s
+    let exitCode: number
+
+    switch (showVersionInfoInput) {
+        case 'true':
+            exitCode = await exec.exec('julia', ['--compile=min', '-O0', '-e', 'using InteractiveUtils; versioninfo()'])
+            break
+
+        case 'false':
+            if (version.endsWith('nightly')) {
+                exitCode = await exec.exec('julia', ['--compile=min', '-O0', '-e', 'using InteractiveUtils; versioninfo()'])
+            } else {
+                exitCode = await exec.exec('julia', ['--version'])
+            }
+            break
+
+        case 'never':
+            exitCode = await exec.exec('julia', ['--version'])
+            break
+
+        default:
+            throw new Error(`${showVersionInfoInput} is not a valid value for show-versioninfo. Supported values: true | false | never`)
+    }
+
+    if (exitCode !== 0) {
+        throw new Error(`Julia could not be installed properly. Exit code: ${exitCode}`)
+    }
+}

src/setup-julia.ts

@@ -1,92 +1,103 @@
 import * as core from '@actions/core'
-import * as exec from '@actions/exec'
 import * as tc from '@actions/tool-cache'
 
-import * as os from 'os'
+import * as fs from 'fs'
+import * as https from 'https'
 import * as path from 'path'
 
-// Store information about the environment
-const osPlat = os.platform() // possible values: win32 (Windows), linux (Linux), darwin (macOS)
-core.debug(`platform: ${osPlat}`)
+import * as installer from './installer'
 
-function getMajorMinorVersion(version: string): string {
-    return version.split('.').slice(0, 2).join('.')
-}
-
-function getDownloadURL(version: string): string {
-    const baseURL = 'https://julialang-s3.julialang.org/bin'
-    let platform: string, arch: string
-    const versionDir = getMajorMinorVersion(version)
-
-    if (osPlat === 'win32') { // Windows
-        platform = 'winnt'
-        arch = 'x64'
-    } else if (osPlat === 'darwin') { // macOS
-        platform = 'mac'
-        arch = 'x64'
-    } else if (osPlat === 'linux') { // Linux
-        platform = 'linux'
-        arch = 'x64'
-    } else {
-        throw `Platform ${osPlat} is not supported`
-    }
-
-    return `${baseURL}/${platform}/${arch}/${versionDir}/${getFileName(version)}`
-}
-
-function getFileName(version: string): string {
-    let versionExt: string, ext: string
-
-    if (osPlat === 'win32') { // Windows
-        versionExt = '-win64'
-        ext = 'exe'
-    } else if (osPlat === 'darwin') { // macOS
-        versionExt = '-mac64'
-        ext = 'dmg'
-    } else if (osPlat === 'linux') { // Linux
-        versionExt = '-linux-x86_64'
-        ext = 'tar.gz'
-    } else {
-        throw `Platform ${osPlat} is not supported`
-    }
-
-    return `julia-${version}${versionExt}.${ext}`
+const archSynonyms = {
+    'x86': 'x86',
+    'X86': 'x86',
+    'x64': 'x64',
+    'X64': 'x64',
+    'aarch64': 'aarch64',
+    'ARM64': 'aarch64',
+    'arm64': 'aarch64'
 }
 
 async function run() {
     try {
-        const version = core.getInput('version')
-        core.debug(`selected Julia version: ${version}`)
+        // Debugging info
+        if (core.isDebug()) {
+            // Log Runner IP Address
+            https.get('https://httpbin.julialang.org/ip', resp => {
+                let data = ''
 
-        // Download Julia
-        const downloadURL = getDownloadURL(version)
-        core.debug(`download Julia from ${downloadURL}`)
-        const juliaDownloadPath = await tc.downloadTool(downloadURL)
+                resp.on('data', chunk => {
+                    data += chunk
+                })
 
-        // Install Julia
-        if (osPlat === 'linux') { // Linux
-            const juliaExtractedFolder = await tc.extractTar(juliaDownloadPath)
-            const juliaCachedPath = await tc.cacheDir(juliaExtractedFolder, 'julia', version)
-            const juliaPath = path.join(juliaCachedPath, `julia-${version}`)
-            core.addPath(path.join(juliaPath, 'bin'))
-        
-        } else if (osPlat === 'win32') { // Windows
-            // Install Julia in C:\Julia
-            const juliaInstallationPath = path.join('C:', 'Julia')
-            await exec.exec('powershell', ['-Command', `Start-Process -FilePath ${juliaDownloadPath} -ArgumentList "/S /D=${juliaInstallationPath}" -NoNewWindow -Wait`])
-            const juliaCachedPath = await tc.cacheDir(juliaInstallationPath, 'julia', version)
-            core.addPath(path.join(juliaCachedPath, 'bin'))
-        
-        } else if (osPlat === 'darwin') { // macOS
-            await exec.exec('hdiutil', ['attach', juliaDownloadPath])
-            const juliaCachedPath = await tc.cacheDir(`/Volumes/Julia-${version}/Julia-${getMajorMinorVersion(version)}.app/Contents/Resources/julia`, 'julia', version)
-            core.addPath(path.join(juliaCachedPath, 'bin'))
+                resp.on('end', () => {
+                    core.debug(`Runner IP address: ${JSON.parse(data).origin}`)
+                })
+            }).on('error', err => {
+                core.debug(`ERROR: Could not retrieve runner IP: ${err}`)
+            })
         }
 
-        // Test if Julia has been installed by showing versioninfo()
-        await exec.exec('julia', ['-e', 'using InteractiveUtils; versioninfo()'])
+        // Inputs
+        const versionInput = core.getInput('version')
+        const includePrereleases = core.getInput('include-all-prereleases') == 'true'
+        const originalArchInput = core.getInput('arch')
+
+        // It can easily happen that, for example, a workflow file contains an input `version: ${{ matrix.julia-version }}`
+        // while the strategy matrix only contains a key `${{ matrix.version }}`.
+        // In that case, we want the action to fail, rather than trying to download julia from an URL that's missing parts and 404ing.
+        // We _could_ fall back to the default but that means that builds silently do things differently than they're meant to, which
+        // is worse than failing the build.
+        if (!versionInput) {
+            throw new Error('Version input must not be null')
+        }
+        if (!originalArchInput) {
+            throw new Error(`Arch input must not be null`)
+        }
+
+        const arch = archSynonyms[originalArchInput]
+
+        const versionInfo = await installer.getJuliaVersionInfo()
+        const availableReleases = await installer.getJuliaVersions(versionInfo)
+        const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases)
+        core.debug(`selected Julia version: ${arch}/${version}`)
+        core.setOutput('julia-version', version)
+
+        // Search in cache
+        let juliaPath: string;
+        juliaPath = tc.find('julia', version, arch)
+
+        if (!juliaPath) {
+            core.debug(`could not find Julia ${arch}/${version} in cache`)
+
+            // https://github.com/julia-actions/setup-julia/pull/196
+            // we want julia to be installed with unmodified file mtimes
+            // but `tc.cacheDir` uses `cp` internally which destroys mtime
+            // and `tc` provides no API to get the tool directory alone
+            // so hack it by installing a empty directory then use the path it returns
+            // and extract the archives directly to that location
+            const emptyDir = fs.mkdtempSync('empty')
+            juliaPath = await tc.cacheDir(emptyDir, 'julia', version, arch)
+            await installer.installJulia(juliaPath, versionInfo, version, arch)
+
+            core.debug(`added Julia to cache: ${juliaPath}`)
+
+            // Remove empty dir
+            fs.rmdirSync(emptyDir)
+        } else {
+            core.debug(`using cached version of Julia: ${juliaPath}`)
+        }
+
+        // Add it to PATH
+        core.addPath(path.join(juliaPath, 'bin'))
+
+        // Set output
+        core.setOutput('julia-bindir', path.join(juliaPath, 'bin'))
+
+        // Test if Julia has been installed and print the version
+        const showVersionInfoInput = core.getInput('show-versioninfo')
+        await installer.showVersionInfo(showVersionInfoInput, version)
     } catch (error) {
-        core.setFailed(error.message)
+        core.setFailed((error as Error).message)
     }
 }