Add production dependencies & build

* fix aarch64 urls for nightly

* rebuild js for aarch64 nightly

* test nightly on apple m1 (aarch64)

* Run on more macOS versions, and add a few comments

---------

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>

.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/backup.yml

@@ -9,10 +9,11 @@ on:
 jobs:
   backup:
     runs-on: ubuntu-20.04
+    timeout-minutes: 60
 
     steps:
       - name: Configure cache
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         with:
           path: |
             ${{ env.GITHUB_WORKSPACE }}
@@ -20,7 +21,7 @@ jobs:
           key: ${{ runner.os }}
 
       - name: Install the correct Python version
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: '3.x'
 

.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: 16
 
     - name: "npm ci"
       run: npm ci

.github/workflows/codeql-analysis.yml

@@ -11,6 +11,12 @@
 #
 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/* ]
@@ -24,6 +30,7 @@ jobs:
   analyze:
     name: Analyze
     runs-on: ubuntu-latest
+    timeout-minutes: 60
 
     strategy:
       fail-fast: false
@@ -35,11 +42,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      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.
@@ -50,7 +57,7 @@ jobs:
     # 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@v1
+      uses: github/codeql-action/autobuild@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -64,4 +71,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      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: 16
+
+      - 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: 16
+
+      - 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

@@ -1,7 +1,14 @@
 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 * * *'
@@ -9,29 +16,39 @@ on:
 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@v1.0.0
-      
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        with:
+          node-version: 16
+
       - name: "Install dependencies"
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
         run: |
           npm install
           npm run build
           npm run pack
 
-      - name: "Set up Julia (nightly)"
+      - name: "Set up Julia (${{ matrix.julia-version }})"
         uses: ./
         with:
-          version: nightly
+          version: ${{ matrix.julia-version }}
           arch: ${{ matrix.julia-arch }}
-          show-versioninfo: 'true'
       - 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

@@ -1,25 +1,42 @@
 name: Example builds
 
-on: [push, pull_request]
+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', '^1.5.0-beta1']
+        julia-version: ['1.0.5', '1.2', '^1.5.0-beta1', '1']
         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@v1.0.0
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
+        with:
+          node-version: 16
 
       - name: "Install dependencies"
+        if: ${{ ! startsWith(github.ref, 'refs/heads/releases') }}
         run: |
           npm install
           npm run build
@@ -31,5 +48,7 @@ jobs:
         with:
           version: ${{ matrix.julia-version }}
           arch: ${{ matrix.julia-arch }}
-          show-versioninfo: 'true'
       - 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,3 +1,3 @@
 node_modules/
 __tests__/runner/*
-!dist/
+# dist/

README.md

@@ -1,7 +1,6 @@
 # setup-julia Action
 
 [![CodeQL](https://github.com/julia-actions/setup-julia/workflows/CodeQL/badge.svg)](https://securitylab.github.com/tools/codeql)
-[![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=julia-actions/setup-julia)](https://dependabot.com)
 
 This action sets up a Julia environment for use in actions by downloading a specified version of Julia and adding it to PATH.
 
@@ -38,13 +37,29 @@ This action sets up a Julia environment for use in actions by downloading a spec
 
     # The architecture of the Julia binaries.
     #
-    # Supported values: x64 | x86
+    # 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.
     #
-    # Default: x64
+    # 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: ''
 
-    # If true, display the output of InteractiveUtils.versioninfo() after installing.
-    # See "versioninfo" below for example usage.
+    # 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: ''
@@ -74,7 +89,7 @@ steps:
 - uses: actions/checkout@v1.0.0
 - uses: julia-actions/setup-julia@v1
   with:
-    version: 1.0.4
+    version: '1.10'
 - run: julia -e 'println("Hello, World!")'
 ```
 
@@ -82,21 +97,51 @@ steps:
 
 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`.
+> **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 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 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. 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. It matches all versions `≥ 1.3.0-` and `< 1.4.0`.
-- `nightly` will install the latest nightly build.
+- `'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`.
+- `'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).
 
-The available Julia versions are pulled from [`versions.json`](https://julialang-s3.julialang.org/bin/versions.json). This file is automatically updated once a day. Therefore it may take up to 24 hours until a newly released Julia version is available in the action.
+#### 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@v1
+  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
 
@@ -112,7 +157,7 @@ jobs:
       matrix:
         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
       - name: "Set up Julia"
@@ -138,7 +183,7 @@ jobs:
         exclude:
           - os: macOS-latest
             julia-arch: x86
-    
+
     steps:
       - uses: actions/checkout@v1.0.0
       - name: "Set up Julia"
@@ -165,7 +210,7 @@ jobs:
           - os: windows-latest
             julia-version: ['1.0.4']
             julia-arch: x86
-    
+
     steps:
       - uses: actions/checkout@v1.0.0
       - name: "Set up Julia"
@@ -178,18 +223,13 @@ jobs:
 
 ### versioninfo
 
-By default, only a brief version identifier is printed in the run log. You can display the full `versioninfo` by adding `show-versioninfo`.
-Here's an example that prints this information just for `nightly`:
+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.
 
-```yaml
-    - uses: julia-actions/setup-julia@v1
-      with:
-        version: ${{ matrix.version }}
-        arch: ${{ matrix.arch }}
-        show-versioninfo: ${{ matrix.version == 'nightly' }}
- ```
- 
-You use `'true'` if you want it printed for all Julia versions.
+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.
+
+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.
 
 ## Versioning
 

__tests__/installer.test.ts

@@ -66,6 +66,14 @@ describe('version matching tests', () => {
         })
     })
 
+    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.3.0-rc4')
+            expect(installer.getJuliaVersion(testVersions, '1', true)).toEqual('1.3.0-rc4')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', false)).toEqual('1.2.0')
+        })
+    })
+
     describe('node-semver behaviour', () => {
         describe('Windows installer change', () => {
             it('Correctly understands >1.4.0', () => {

action.yml

@@ -5,10 +5,14 @@ inputs:
   version:
     description: 'The Julia version to download (if necessary) and use. Example: 1.0.4'
     default: '1'
-  arch:
-    description: 'Architecture of the Julia binaries. Defaults to x64.'
+  include-all-prereleases:
+    description: 'Include prereleases when matching the Julia version to available versions.'
     required: false
-    default: 'x64'
+    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
@@ -19,7 +23,7 @@ outputs:
   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'
+  using: 'node16'
   main: 'dist/index.js'
 branding:
   icon: 'download'

lib/installer.js

@@ -1,20 +1,38 @@
 "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 });
+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"));
@@ -22,6 +40,7 @@ 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"));
 // Translations between actions input and Julia arch names
 const osMap = {
@@ -31,7 +50,8 @@ const osMap = {
 };
 const archMap = {
     'x86': 'i686',
-    'x64': 'x86_64'
+    'x64': 'x86_64',
+    'aarch64': 'aarch64'
 };
 // Store information about the environment
 const osPlat = os.platform(); // possible values: win32 (Windows), linux (Linux), darwin (macOS)
@@ -59,7 +79,16 @@ function calculateChecksum(file) {
  */
 function getJuliaVersionInfo() {
     return __awaiter(this, void 0, void 0, function* () {
-        const versionsFile = yield tc.downloadTool('https://julialang-s3.julialang.org/bin/versions.json');
+        // 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());
     });
 }
@@ -77,17 +106,13 @@ function getJuliaVersions(versionInfo) {
     });
 }
 exports.getJuliaVersions = getJuliaVersions;
-function getJuliaVersion(availableReleases, versionInput) {
-    if (semver.valid(versionInput) == versionInput) {
-        // versionInput is a valid version, use it directly
+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;
     }
-    // nightlies
-    if (versionInput == 'nightly') {
-        return 'nightly';
-    }
     // Use the highest available version that matches versionInput
-    let version = semver.maxSatisfying(availableReleases, versionInput);
+    let version = semver.maxSatisfying(availableReleases, versionInput, { includePrerelease });
     if (version == null) {
         throw new Error(`Could not find a Julia version that matches ${versionInput}`);
     }
@@ -96,58 +121,132 @@ function getJuliaVersion(availableReleases, versionInput) {
     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, ext;
+    let versionExt;
+    let fileExt1;
+    [fileExt1, ,] = getDesiredFileExts();
     if (osPlat == 'win32') {
         versionExt = arch == 'x64' ? '-win64' : '-win32';
-        ext = 'exe';
     }
     else if (osPlat == 'darwin') {
         if (arch == 'x86') {
             throw new Error('32-bit Julia is not available on macOS');
         }
-        versionExt = '-mac64';
-        ext = 'dmg';
+        else if (arch == 'aarch64') {
+            versionExt = '-macaarch64';
+        }
+        else {
+            versionExt = '-mac64';
+        }
     }
     else if (osPlat === 'linux') {
-        versionExt = arch == 'x64' ? '-linux64' : '-linux32';
-        ext = 'tar.gz';
+        if (arch == 'x86') {
+            versionExt = '-linux32';
+        }
+        else if (arch == 'aarch64') {
+            versionExt = '-linux-aarch64';
+        }
+        else {
+            versionExt = '-linux64';
+        }
     }
     else {
         throw new Error(`Platform ${osPlat} is not supported`);
     }
-    return `julia-latest${versionExt}.${ext}`;
+    return `julia-latest${versionExt}.${fileExt1}`;
 }
 function getFileInfo(versionInfo, version, arch) {
-    if (version == 'nightly') {
+    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]) {
-            return file;
+            if (file.extension == fileExt1) {
+                return file;
+            }
         }
     }
-    throw `Could not find ${archMap[arch]}/${version} binaries`;
+    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') {
-        const baseURL = 'https://julialangnightlies-s3.julialang.org/bin';
-        return `${baseURL}/${osMap[osPlat]}/${arch}/${getNightlyFileName(arch)}`;
+        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(versionInfo, version, arch) {
+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}`);
-        const juliaDownloadPath = yield tc.downloadTool(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 != 'nightly') {
+        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}`);
@@ -157,29 +256,79 @@ function installJulia(versionInfo, version, arch) {
         else {
             core.debug('Skipping checksum check for nightly binaries.');
         }
-        const tempInstallDir = fs.mkdtempSync(`julia-${arch}-${version}-`);
         // 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', tempInstallDir]);
-                return tempInstallDir;
+                yield exec.exec('tar', ['xf', juliaDownloadPath, '--strip-components=1', '-C', dest]);
+                return dest;
             case 'win32':
-                if (version == '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(), tempInstallDir)}" -NoNewWindow -Wait`]);
+                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 {
-                    yield exec.exec('powershell', ['-Command', `Start-Process -FilePath ${juliaDownloadPath} -ArgumentList "/S /D=${path.join(process.cwd(), tempInstallDir)}" -NoNewWindow -Wait`]);
+                    // This is the more common path. Using .tar.gz is much faster
+                    yield exec.exec('powershell', ['-Command', `tar xf ${juliaDownloadPath} --strip-components=1 -C ${dest}`]);
                 }
-                return tempInstallDir;
+                return dest;
             case 'darwin':
-                yield exec.exec('hdiutil', ['attach', juliaDownloadPath]);
-                yield exec.exec('/bin/bash', ['-c', `cp -a /Volumes/Julia-*/Julia-*.app/Contents/Resources/julia ${tempInstallDir}`]);
-                return path.join(tempInstallDir, 'julia');
+                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,27 +1,52 @@
 "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 fs = __importStar(require("fs"));
 const https = __importStar(require("https"));
 const path = __importStar(require("path"));
 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 {
@@ -42,7 +67,8 @@ function run() {
             }
             // Inputs
             const versionInput = core.getInput('version');
-            const arch = core.getInput('arch');
+            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.
@@ -51,12 +77,13 @@ function run() {
             if (!versionInput) {
                 throw new Error('Version input must not be null');
             }
-            if (!arch) {
+            if (!originalArchInput) {
                 throw new Error(`Arch input must not be null`);
             }
+            const arch = archSynonyms[originalArchInput];
             const versionInfo = yield installer.getJuliaVersionInfo();
             const availableReleases = yield installer.getJuliaVersions(versionInfo);
-            const version = installer.getJuliaVersion(availableReleases, versionInput);
+            const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases);
             core.debug(`selected Julia version: ${arch}/${version}`);
             core.setOutput('julia-version', version);
             // Search in cache
@@ -64,12 +91,18 @@ function run() {
             juliaPath = tc.find('julia', version, arch);
             if (!juliaPath) {
                 core.debug(`could not find Julia ${arch}/${version} in cache`);
-                const juliaInstallationPath = yield installer.installJulia(versionInfo, version, arch);
-                // Add it to cache
-                juliaPath = yield tc.cacheDir(juliaInstallationPath, 'julia', version, arch);
+                // 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 temporary dir
-                fs.rmdirSync(juliaInstallationPath, { recursive: true });
+                // Remove empty dir
+                fs.rmdirSync(emptyDir);
             }
             else {
                 core.debug(`using cached version of Julia: ${juliaPath}`);
@@ -79,15 +112,8 @@ function run() {
             // Set output
             core.setOutput('julia-bindir', path.join(juliaPath, 'bin'));
             // Test if Julia has been installed and print the version
-            if (core.getInput('show-versioninfo') == 'true') {
-                // If enabled, show the full version info
-                // --compile=min -O0 reduces the time from ~1.8-1.9s to ~0.8-0.9s
-                exec.exec('julia', ['--compile=min', '-O0', '-e', 'using InteractiveUtils; versioninfo()']);
-            }
-            else {
-                // Otherwise only print julia --version to save time
-                exec.exec('julia', ['--version']);
-            }
+            const showVersionInfoInput = core.getInput('show-versioninfo');
+            yield installer.showVersionInfo(showVersionInfoInput, version);
         }
         catch (error) {
             core.setFailed(error.message);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "setup-julia",
-  "version": "1.5.1",
+  "version": "1.9.6",
   "private": true,
   "description": "setup Julia action",
   "main": "lib/setup-julia.js",
@@ -21,22 +21,25 @@
   "author": "Sascha Mann <git@mail.saschamann.eu>",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.2.6",
-    "@actions/exec": "^1.0.0",
-    "@actions/io": "^1.0.0",
-    "@actions/tool-cache": "^1.0.0",
-    "semver": "^6.3.0"
+    "@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.0"
   },
   "devDependencies": {
-    "@types/jest": "^24.0.13",
-    "@types/node": "^12.12.7",
-    "@types/semver": "^6.0.0",
-    "@zeit/ncc": "^0.22.0",
-    "jest": "^24.8.0",
-    "jest-circus": "^24.7.1",
-    "nock": "^11.7.2",
-    "prettier": "^1.17.1",
-    "ts-jest": "^26.0.0",
-    "typescript": "^3.5.1"
+    "@types/async-retry": "^1.4.8",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.16",
+    "@types/retry": "^0.12.5",
+    "@types/semver": "^7.5.6",
+    "@vercel/ncc": "^0.38.1",
+    "jest": "^29.7.0",
+    "jest-circus": "^29.7.0",
+    "nock": "^13.5.1",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
   }
 }

src/installer.ts

@@ -6,6 +6,7 @@ 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'
 
@@ -17,7 +18,8 @@ const osMap = {
 }
 const archMap = {
     'x86': 'i686',
-    'x64': 'x86_64'
+    'x64': 'x86_64',
+    'aarch64': 'aarch64'
 }
 
 // Store information about the environment
@@ -47,7 +49,16 @@ async function calculateChecksum(file: string): Promise<string> {
  * @returns The content of the downloaded versions.json file as object.
  */
 export async function getJuliaVersionInfo(): Promise<object> {
-    const versionsFile = await tc.downloadTool('https://julialang-s3.julialang.org/bin/versions.json')
+    // 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())
 }
@@ -65,19 +76,14 @@ export async function getJuliaVersions(versionInfo): Promise<string[]> {
     return versions
 }
 
-export function getJuliaVersion(availableReleases: string[], versionInput: string): string {
-    if (semver.valid(versionInput) == versionInput) {
-        // versionInput is a valid version, use it directly
+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
     }
 
-    // nightlies
-    if (versionInput == 'nightly') {
-        return 'nightly'
-    }
-
     // Use the highest available version that matches versionInput
-    let version = semver.maxSatisfying(availableReleases, versionInput)
+    let version = semver.maxSatisfying(availableReleases, versionInput, {includePrerelease})
     if (version == null) {
         throw new Error(`Could not find a Julia version that matches ${versionInput}`)
     }
@@ -88,61 +94,138 @@ export function getJuliaVersion(availableReleases: string[], versionInput: strin
     return version
 }
 
-function getNightlyFileName(arch: string): string {
-    let versionExt: string, ext: string
+function getDesiredFileExts(): [string, boolean, string] {
+    let fileExt1: string
+    let hasFileExt2: boolean
+    let fileExt2: string
 
     if (osPlat == 'win32') {
-        versionExt = arch == 'x64' ? '-win64' : '-win32'
-        ext = 'exe'
+        fileExt1 = 'tar.gz'
+        hasFileExt2 = true
+        fileExt2 = 'exe'
     } else if (osPlat == 'darwin') {
-        if (arch == 'x86') {
-            throw new Error('32-bit Julia is not available on macOS')
-        }
-        versionExt = '-mac64'
-        ext = 'dmg'
+        fileExt1 = 'tar.gz'
+        hasFileExt2 = true
+        fileExt2 = 'dmg'
     } else if (osPlat === 'linux') {
-        versionExt = arch == 'x64' ? '-linux64' : '-linux32'
-        ext = 'tar.gz'
+        fileExt1 = 'tar.gz'
+        hasFileExt2 = false
+        fileExt2 = ''
     } else {
         throw new Error(`Platform ${osPlat} is not supported`)
     }
 
-    return `julia-latest${versionExt}.${ext}`
+    return [fileExt1, hasFileExt2, fileExt2]
+}
+
+function getNightlyFileName(arch: string): string {
+    let versionExt: string
+    let fileExt1: string
+    [fileExt1, , ] = getDesiredFileExts()
+
+    if (osPlat == 'win32') {
+        versionExt = arch == 'x64' ? '-win64' : '-win32'
+    } else if (osPlat == 'darwin') {
+        if (arch == 'x86') {
+            throw new Error('32-bit Julia is not available on macOS')
+        } else if (arch == 'aarch64') {
+            versionExt = '-macaarch64'
+        } else {
+            versionExt = '-mac64'
+        }
+    } else if (osPlat === 'linux') {
+        if (arch == 'x86') {
+            versionExt = '-linux32'
+        } else if (arch == 'aarch64') {
+            versionExt = '-linux-aarch64'
+        } else {
+            versionExt = '-linux64'
+        }
+    } else {
+        throw new Error(`Platform ${osPlat} is not supported`)
+    }
+
+    return `julia-latest${versionExt}.${fileExt1}`
 }
 
 export function getFileInfo(versionInfo, version: string, arch: string) {
-    if (version == 'nightly') {
+    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]) {
-            return file
+            if (file.extension == fileExt1) {
+                return file
+            }
         }
     }
 
-    throw `Could not find ${archMap[arch]}/${version} binaries`
+    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 {
-    // nightlies
-    if (version == 'nightly') {
-        const baseURL = 'https://julialangnightlies-s3.julialang.org/bin'
-        return `${baseURL}/${osMap[osPlat]}/${arch}/${getNightlyFileName(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
 }
 
-export async function installJulia(versionInfo, version: string, arch: string): Promise<string> {
+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}`)
-    const juliaDownloadPath = await tc.downloadTool(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 != 'nightly') {
+    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}`)
@@ -152,27 +235,76 @@ export async function installJulia(versionInfo, version: string, arch: string):
         core.debug('Skipping checksum check for nightly binaries.')
     }
 
-    const tempInstallDir = fs.mkdtempSync(`julia-${arch}-${version}-`)
-
     // 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', tempInstallDir])
-            return tempInstallDir
+            await exec.exec('tar', ['xf', juliaDownloadPath, '--strip-components=1', '-C', dest])
+            return dest
         case 'win32':
-            if (version == '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(), tempInstallDir)}" -NoNewWindow -Wait`])
+            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 {
-                await exec.exec('powershell', ['-Command', `Start-Process -FilePath ${juliaDownloadPath} -ArgumentList "/S /D=${path.join(process.cwd(), tempInstallDir)}" -NoNewWindow -Wait`])
+                // This is the more common path. Using .tar.gz is much faster
+                await exec.exec('powershell', ['-Command', `tar xf ${juliaDownloadPath} --strip-components=1 -C ${dest}`])
             }
-            return tempInstallDir
+            return dest
         case 'darwin':
-            await exec.exec('hdiutil', ['attach', juliaDownloadPath])
-            await exec.exec('/bin/bash', ['-c', `cp -a /Volumes/Julia-*/Julia-*.app/Contents/Resources/julia ${tempInstallDir}`])
-            return path.join(tempInstallDir, 'julia')
+            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

@@ -8,6 +8,16 @@ import * as path from 'path'
 
 import * as installer from './installer'
 
+const archSynonyms = {
+    'x86': 'x86',
+    'X86': 'x86',
+    'x64': 'x64',
+    'X64': 'x64',
+    'aarch64': 'aarch64',
+    'ARM64': 'aarch64',
+    'arm64': 'aarch64'
+}
+
 async function run() {
     try {
         // Debugging info
@@ -30,7 +40,8 @@ async function run() {
 
         // Inputs
         const versionInput = core.getInput('version')
-        const arch = core.getInput('arch')
+        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 }}`.
@@ -40,13 +51,15 @@ async function run() {
         if (!versionInput) {
             throw new Error('Version input must not be null')
         }
-        if (!arch) {
+        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)
+        const version = installer.getJuliaVersion(availableReleases, versionInput, includePrereleases)
         core.debug(`selected Julia version: ${arch}/${version}`)
         core.setOutput('julia-version', version)
 
@@ -56,14 +69,21 @@ async function run() {
 
         if (!juliaPath) {
             core.debug(`could not find Julia ${arch}/${version} in cache`)
-            const juliaInstallationPath = await installer.installJulia(versionInfo, version, arch)
 
-            // Add it to cache
-            juliaPath = await tc.cacheDir(juliaInstallationPath, 'julia', version, arch)
+            // 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 temporary dir
-            fs.rmdirSync(juliaInstallationPath, {recursive: true})
+            // Remove empty dir
+            fs.rmdirSync(emptyDir)
         } else {
             core.debug(`using cached version of Julia: ${juliaPath}`)
         }
@@ -75,16 +95,10 @@ async function run() {
         core.setOutput('julia-bindir', path.join(juliaPath, 'bin'))
 
         // Test if Julia has been installed and print the version
-        if (core.getInput('show-versioninfo') == 'true') {
-            // If enabled, show the full version info
-            // --compile=min -O0 reduces the time from ~1.8-1.9s to ~0.8-0.9s
-            exec.exec('julia', ['--compile=min', '-O0', '-e', 'using InteractiveUtils; versioninfo()'])
-        } else {
-            // Otherwise only print julia --version to save time
-            exec.exec('julia', ['--version'])
-        }
+        const showVersionInfoInput = core.getInput('show-versioninfo')
+        await installer.showVersionInfo(showVersionInfoInput, version)
     } catch (error) {
-        core.setFailed(error.message)
+        core.setFailed((error as Error).message)
     }
 }