Remove stable input and fix SemVer notation (#195)

ci(workflow): add 'npm' cache for actions/setup-node in .github/workflows

.gitattributes

@@ -0,0 +1 @@
+.licenses/** -diff linguist-generated=true

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a bug report
+title: ''
+labels: bug, needs triage
+assignees: ''
+
+---
+
+<!--- Please direct any generic questions related to actions to our support community forum at https://github.community/c/code-to-cloud/github-actions/41 --->
+<!--- Before opening up a new bug report, please make sure to check for similar existing issues -->
+
+**Description:**
+A clear and concise description of what the bug is.
+
+**Action version:**
+Specify the action version
+
+**Platform:**
+- [ ] Ubuntu
+- [ ] macOS
+- [ ] Windows
+
+**Runner type:**
+- [ ] Hosted
+- [ ] Self-hosted
+
+**Tools version:**
+<!--- Please specify go version -->
+
+**Repro steps:**  
+A description with steps to reproduce the issue. If your have a public example or repo to share, please provide the link.
+
+**Expected behavior:**
+A description of what you expected to happen.
+
+**Actual behavior:**
+A description of what is actually happening.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,18 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature request, needs triage
+assignees: ''
+---
+<!--- Please direct any generic questions related to actions to our support community forum at https://github.community/c/code-to-cloud/github-actions/41 --->
+<!--- Before opening up a new feature request, please make sure to check for similar existing issues and pull requests -->
+
+**Description:**
+Describe your proposal.
+
+**Justification:**
+Justification or a use case for your proposal.
+
+**Are you willing to submit a PR?**
+<!--- We accept contributions! -->

.github/pull_request_template.md

@@ -0,0 +1,9 @@
+**Description:**
+Describe your changes.
+
+**Related issue:**
+Add link to the related issue.
+
+**Check list:**
+- [ ] Mark if documentation changes are required.
+- [ ] Mark if tests were added or updated to cover the changes.

.github/workflows/check-dist.yml

@@ -0,0 +1,51 @@
+# `dist/index.js` is a special file in Actions.
+# When you reference an action with `uses:` in a workflow,
+# `index.js` is the code that will run.
+# For our project, we generate this file through a build process from other source files.
+# We need to make sure the checked-in `index.js` actually matches what we expect it to be.
+name: Check dist/
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  workflow_dispatch:
+
+jobs:
+  check-dist:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set Node.js 16.x
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16.x
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Rebuild the dist/ directory
+        run: npm run build
+
+      - name: Compare the expected and actual dist/ directories
+        run: |
+          if [ "$(git diff --ignore-space-at-eol dist/ | wc -l)" -gt "0" ]; then
+            echo "Detected uncommitted changes after build.  See status below:"
+            git diff
+            exit 1
+          fi
+        id: diff
+
+      # If index.js was different than expected, upload the expected version as an artifact
+      - uses: actions/upload-artifact@v2
+        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
+        with:
+          name: dist
+          path: dist/

.github/workflows/licensed.yml

@@ -0,0 +1,28 @@
+name: Licensed
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    name: Check licenses
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set Node.js 16.x
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16.x
+      - run: npm ci
+      - name: Install licensed
+        run: |
+          cd $RUNNER_TEMP
+          curl -Lfs -o licensed.tar.gz https://github.com/github/licensed/releases/download/3.4.4/licensed-3.4.4-linux-x64.tar.gz
+          sudo tar -xzf licensed.tar.gz
+          sudo mv licensed /usr/local/bin/licensed
+      - run: licensed status

.github/workflows/release-new-action-version.yml

@@ -0,0 +1,27 @@
+name: Release new action version
+on:
+  release:
+    types: [released]
+  workflow_dispatch:
+    inputs:
+      TAG_NAME:
+        description: 'Tag name that the major tag will point to'
+        required: true
+
+env:
+  TAG_NAME: ${{ github.event.inputs.TAG_NAME || github.event.release.tag_name }}
+permissions:
+  contents: write
+
+jobs:
+  update_tag:
+    name: Update the major tag to include the ${{ github.event.inputs.TAG_NAME || github.event.release.tag_name }} changes
+    environment:
+      name: releaseNewActionVersion
+    runs-on: ubuntu-latest
+    steps:
+      - name: Update the ${{ env.TAG_NAME }} tag
+        uses: actions/publish-action@v0.1.0
+        with:
+          source-tag: ${{ env.TAG_NAME }}
+          slack-webhook: ${{ secrets.SLACK_WEBHOOK }}

.github/workflows/versions.yml

@@ -1,51 +1,93 @@
-name: go-versions
+name: Validate 'setup-go'
 on:
-    push:
-      branches:
-        - master
-      paths-ignore:
-        - '**.md'
-    pull_request:
-      paths-ignore:
-        - '**.md'
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  schedule:
+    - cron: 0 0 * * *
+
 jobs:
-  run:
-    name: Go
-    runs-on: ${{ matrix.operating-system }}
+  local-cache:
+    name: Setup local-cache version
+    runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        operating-system: [ubuntu-latest, windows-latest, macos-latest]
+        os: [macos-latest, windows-latest, ubuntu-latest]
+        go: [1.12, 1.13, 1.14]
     steps:
-    - name: Checkout
-      uses: actions/checkout@v2
+      - name: Checkout
+        uses: actions/checkout@v2
 
-    - name: setup-go ^1.13.6
-      uses: ./
-      with:
-        go-version: ^1.13.6
+      - name: setup-go ${{ matrix.go }}
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
 
-    - name: validate version 
-      run: go version | grep "go1."
+      - name: verify go
+        run: __tests__/verify-go.sh ${{ matrix.go }}
+        shell: bash
 
-    - name: setup-go 1.13
-      uses: ./
-      with:
-        go-version: 1.13
+  check-latest:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        go-version: [1.16, 1.17]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Go and check latest
+        uses: ./
+        with:
+          go-version: ${{ matrix.go-version }}
+          check-latest: true
+      - name: Verify Go
+        run: go version
 
-    - name: validate version 
-      run: go version | grep "go1.13."      
+  setup-versions-from-manifest:
+    name: Setup ${{ matrix.go }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, windows-latest, ubuntu-latest]
+        go: [1.12.16, 1.13.11, 1.14.3]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      
+      - name: setup-go ${{ matrix.go }}
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
+      
+      - name: verify go
+        run: __tests__/verify-go.sh ${{ matrix.go }}
+        shell: bash
 
-    - name: setup-go 1.12.9
-      uses: ./
-      with:
-        go-version: 1.12.9
+  setup-versions-from-dist:
+    name: Setup ${{ matrix.go }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, windows-latest, ubuntu-latest]
+        go: [1.9, 1.8.6]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
 
-    - name: validate version 
-      run: go version | grep "go1.12.9"
+      - name: setup-go ${{ matrix.go }}
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
 
-    - name: dump env
-      shell: bash
-      run: |
-        echo $PATH
-        echo go versions in tool cache: 
-        echo $(ls $RUNNER_TOOL_CACHE/go)       
+      - name: verify go
+        run: __tests__/verify-go.sh ${{ matrix.go }}
+        shell: bash

.github/workflows/workflow.yml

@@ -2,7 +2,7 @@ name: build-test
 on:
   push:
     branches:
-      - master
+      - main
     paths-ignore:
       - '**.md'
   pull_request:
@@ -16,23 +16,24 @@ jobs:
       matrix:
         operating-system: [ubuntu-latest, windows-latest]
     steps:
-    - name: Checkout
-      uses: actions/checkout@v2
+      - name: Checkout
+        uses: actions/checkout@v2
 
-    - name: Setup node 12
-      uses: actions/setup-node@v1
-      with:
-        node-version: 12
+      - name: Setup node 16
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          cache: npm
 
-    - name: npm install
-      run: npm install
+      - name: npm ci
+        run: npm ci
 
-    - name: Lint
-      run: npm run format-check
+      - name: Lint
+        run: npm run format-check
 
-    - name: npm test
-      run: npm test
+      - name: npm test
+        run: npm test
 
-    - name: audit packages
-      run: npm audit --audit-level=high
-      if: matrix.operating-system == 'ubuntu-latest'
+      - name: audit packages
+        run: npm audit --audit-level=high
+        if: matrix.operating-system == 'ubuntu-latest'

.licensed.yml

@@ -0,0 +1,14 @@
+sources:
+  npm: true
+
+allowed:
+  - apache-2.0
+  - bsd-2-clause
+  - bsd-3-clause
+  - isc
+  - mit
+  - cc0-1.0
+  - unlicense
+
+reviewed:
+  npm:

CODEOWNERS

@@ -0,0 +1 @@
+* @actions/spark

README.md

@@ -11,66 +11,96 @@ This action sets up a go environment for use in actions by:
 - optionally downloading and caching a version of Go by version and adding to PATH
 - registering problem matchers for error output
 
-# V2 Beta
+# V2
 
-The V2 beta offers:
+The V2 offers:
+- Adds GOBIN to the PATH
 - Proxy Support
-- stable input 
+- `stable` input 
+- Check latest version
 - Bug Fixes (including issues around version matching and semver)
 
-Matching by semver spec:
+The action will first check the local cache for a version match. If a version is not found locally, it will pull it from the `main` branch of the [go-versions](https://github.com/actions/go-versions/blob/main/versions-manifest.json) repository. On miss or failure, it will fall back to downloading directly from [go dist](https://storage.googleapis.com/golang). To change the default behavior, please use the [check-latest input](#check-latest-version).
+
+Matching by [semver spec](https://github.com/npm/node-semver):
 ```yaml
 steps:
-- uses: actions/checkout@v2
-- uses: actions/setup-go@v2-beta
-  with:
-    go-version: '^1.13.1' # The Go version to download (if necessary) and use.
-- run: go version
+  - uses: actions/checkout@v2
+  - uses: actions/setup-go@v2
+    with:
+      go-version: '^1.13.1' # The Go version to download (if necessary) and use.
+  - run: go version
 ```
 
 Matching an unstable pre-release:
 ```yaml
 steps:
-- uses: actions/checkout@v2
-- uses: actions/setup-go@v2-beta
-  with:
-    stable: 'false'
-    go-version: '1.14.0-rc1' # The Go version to download (if necessary) and use.
-- run: go version
+  - uses: actions/checkout@v2
+  - uses: actions/setup-go@v2
+    with:
+      stable: 'false'
+      go-version: '1.14.0-rc1' # The Go version to download (if necessary) and use.
+  - run: go version
 ```
 
 # Usage
 
 See [action.yml](action.yml)
 
-Basic:
+## Basic:
 ```yaml
 steps:
-- uses: actions/checkout@master
-- uses: actions/setup-go@v1
-  with:
-    go-version: '1.9.3' # The Go version to download (if necessary) and use.
-- run: go run hello.go
+  - uses: actions/checkout@v2
+  - uses: actions/setup-go@v2
+    with:
+      go-version: '1.16.1' # The Go version to download (if necessary) and use.
+  - run: go run hello.go
 ```
 
-Matrix Testing:
+
+## Check latest version:  
+
+The `check-latest` flag defaults to `false`. Use the default or set `check-latest` to `false` if you prefer stability and if you want to ensure a specific Go version is always used.
+
+If `check-latest` is set to `true`, the action first checks if the cached version is the latest one. If the locally cached version is not the most up-to-date, a Go version will then be downloaded. Set `check-latest` to `true` if you want the most up-to-date Go version to always be used.
+
+> Setting `check-latest` to `true` has performance implications as downloading Go versions is slower than using cached versions.
+
+```yaml
+steps:
+  - uses: actions/checkout@v2
+  - uses: actions/setup-go@v2
+    with:
+      go-version: '1.14'
+      check-latest: true
+  - run: go run hello.go
+```
+
+## Matrix Testing:
 ```yaml
 jobs:
   build:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        go: [ '1.13', '1.12' ]
+        go: [ '1.14', '1.13' ]
     name: Go ${{ matrix.go }} sample
     steps:
       - uses: actions/checkout@v2
       - name: Setup go
-        uses: actions/setup-go@v1
+        uses: actions/setup-go@v2
         with:
           go-version: ${{ matrix.go }}
       - run: go run hello.go
 ```
 
+### Supported version syntax
+The `go-version` input supports the following syntax:
+
+Specific versions: `1.15`, `1.16.1`, `1.17.0-rc2`, `1.16.0-beta1`  
+SemVer's version range syntax: `^1.13.1`  
+For more information about semantic versioning please refer [semver](https://github.com/npm/node-semver) documentation
+
 # License
 
 The scripts and documentation in this project are released under the [MIT License](LICENSE)

__tests__/data/versions-manifest.json

@@ -0,0 +1,102 @@
+[
+    {
+      "version": "1.17.6",
+      "stable": true,
+      "release_url": "https://github.com/actions/go-versions/releases/tag/1.17.6-1668090892",
+      "files": [
+        {
+          "filename": "go-1.17.6-darwin-x64.tar.gz",
+          "arch": "x64",
+          "platform": "darwin",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.17.6-1668090892/go-1.17.6-darwin-x64.tar.gz"
+        },
+        {
+          "filename": "go-1.17.6-linux-x64.tar.gz",
+          "arch": "x64",
+          "platform": "linux",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.17.6-1668090892/go-1.17.6-linux-x64.tar.gz"
+        },
+        {
+          "filename": "go-1.17.6-win32-x64.zip",
+          "arch": "x64",
+          "platform": "win32",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.17.6-1668090892/go-1.17.6-win32-x64.zip"
+        }
+      ]
+    },
+    {
+      "version": "1.12.17",
+      "stable": true,
+      "release_url": "https://github.com/actions/go-versions/releases/tag/1.12.17-20200616.21",
+      "files": [
+        {
+          "filename": "go-1.12.17-darwin-x64.tar.gz",
+          "arch": "x64",
+          "platform": "darwin",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.12.17-20200616.21/go-1.12.17-darwin-x64.tar.gz"
+        },
+        {
+          "filename": "go-1.12.17-linux-x64.tar.gz",
+          "arch": "x64",
+          "platform": "linux",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.12.17-20200616.21/go-1.12.17-linux-x64.tar.gz"
+        },
+        {
+          "filename": "go-1.12.17-win32-x64.zip",
+          "arch": "x64",
+          "platform": "win32",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.12.17-20200616.21/go-1.12.17-win32-x64.zip"
+        }
+      ]
+    },
+    {
+      "version": "1.12.16",
+      "stable": true,
+      "release_url": "https://github.com/actions/go-versions/releases/tag/1.12.16-20200616.20",
+      "files": [
+        {
+          "filename": "go-1.12.16-darwin-x64.tar.gz",
+          "arch": "x64",
+          "platform": "darwin",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.12.16-20200616.20/go-1.12.16-darwin-x64.tar.gz"
+        },
+        {
+          "filename": "go-1.12.16-linux-x64.tar.gz",
+          "arch": "x64",
+          "platform": "linux",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.12.16-20200616.20/go-1.12.16-linux-x64.tar.gz"
+        },
+        {
+          "filename": "go-1.12.16-win32-x64.zip",
+          "arch": "x64",
+          "platform": "win32",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.12.16-20200616.20/go-1.12.16-win32-x64.zip"
+        }
+      ]
+    },
+    {
+      "version": "1.9.7",
+      "stable": true,
+      "release_url": "https://github.com/actions/go-versions/releases/tag/1.9.7-20200616.1",
+      "files": [
+        {
+          "filename": "go-1.9.7-darwin-x64.tar.gz",
+          "arch": "x64",
+          "platform": "darwin",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.9.7/go-1.9.7-darwin-x64.tar.gz"
+        },
+        {
+          "filename": "go-1.9.7-linux-x64.tar.gz",
+          "arch": "x64",
+          "platform": "linux",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.9.7/go-1.9.7-linux-x64.tar.gz"
+        },
+        {
+          "filename": "go-1.9.7-win32-x64.zip",
+          "arch": "x64",
+          "platform": "win32",
+          "download_url": "https://github.com/actions/go-versions/releases/download/1.9.7/go-1.9.7-win32-x64.zip"
+        }
+      ]
+    }
+  ]

__tests__/setup-go.test.ts

@@ -1,21 +1,25 @@
-import * as tc from '@actions/tool-cache';
 import * as core from '@actions/core';
-import fs = require('fs');
-import osm = require('os');
-import path = require('path');
-import {run} from '../src/main';
-import * as httpm from '@actions/http-client';
+import * as io from '@actions/io';
+import * as tc from '@actions/tool-cache';
+import fs from 'fs';
+import cp from 'child_process';
+import osm from 'os';
+import path from 'path';
+import * as main from '../src/main';
 import * as im from '../src/installer';
-import * as sys from '../src/system';
-import {ITypedResponse} from '@actions/http-client/interfaces';
 
 let goJsonData = require('./data/golang-dl.json');
+let matchers = require('../matchers.json');
+let goTestManifest = require('./data/versions-manifest.json');
+let matcherPattern = matchers.problemMatcher[0].pattern[0];
+let matcherRegExp = new RegExp(matcherPattern.regexp);
 
 describe('setup-go', () => {
   let inputs = {} as any;
   let os = {} as any;
 
   let inSpy: jest.SpyInstance;
+  let getBooleanInputSpy: jest.SpyInstance;
   let findSpy: jest.SpyInstance;
   let cnSpy: jest.SpyInstance;
   let logSpy: jest.SpyInstance;
@@ -25,69 +29,117 @@ describe('setup-go', () => {
   let dlSpy: jest.SpyInstance;
   let exSpy: jest.SpyInstance;
   let cacheSpy: jest.SpyInstance;
+  let dbgSpy: jest.SpyInstance;
+  let whichSpy: jest.SpyInstance;
+  let existsSpy: jest.SpyInstance;
+  let mkdirpSpy: jest.SpyInstance;
+  let execSpy: jest.SpyInstance;
+  let getManifestSpy: jest.SpyInstance;
+
+  beforeAll(async () => {
+    process.env['GITHUB_ENV'] = ''; // Stub out Environment file functionality so we can verify it writes to standard out (toolkit is backwards compatible)
+  }, 100000);
 
   beforeEach(() => {
+    process.env['GITHUB_PATH'] = ''; // Stub out ENV file functionality so we can verify it writes to standard out
+
     // @actions/core
     inputs = {};
     inSpy = jest.spyOn(core, 'getInput');
     inSpy.mockImplementation(name => inputs[name]);
+    getBooleanInputSpy = jest.spyOn(core, 'getBooleanInput');
+    getBooleanInputSpy.mockImplementation(name => inputs[name]);
 
-    // node 'os'
+    // node
     os = {};
     platSpy = jest.spyOn(osm, 'platform');
     platSpy.mockImplementation(() => os['platform']);
     archSpy = jest.spyOn(osm, 'arch');
     archSpy.mockImplementation(() => os['arch']);
+    execSpy = jest.spyOn(cp, 'execSync');
 
     // @actions/tool-cache
     findSpy = jest.spyOn(tc, 'find');
     dlSpy = jest.spyOn(tc, 'downloadTool');
     exSpy = jest.spyOn(tc, 'extractTar');
     cacheSpy = jest.spyOn(tc, 'cacheDir');
-    getSpy = jest.spyOn(im, 'getVersions');
+    getSpy = jest.spyOn(im, 'getVersionsDist');
+    getManifestSpy = jest.spyOn(tc, 'getManifestFromRepo');
+
+    // io
+    whichSpy = jest.spyOn(io, 'which');
+    existsSpy = jest.spyOn(fs, 'existsSync');
+    mkdirpSpy = jest.spyOn(io, 'mkdirP');
+
+    // gets
+    getManifestSpy.mockImplementation(() => <tc.IToolRelease[]>goTestManifest);
 
     // writes
     cnSpy = jest.spyOn(process.stdout, 'write');
-    logSpy = jest.spyOn(console, 'log');
-    getSpy.mockImplementation(() => <im.IGoVersion[]>goJsonData);
+    logSpy = jest.spyOn(core, 'info');
+    dbgSpy = jest.spyOn(core, 'debug');
+    getSpy.mockImplementation(() => <im.IGoVersion[] | null>goJsonData);
     cnSpy.mockImplementation(line => {
       // uncomment to debug
       // process.stderr.write('write:' + line + '\n');
     });
     logSpy.mockImplementation(line => {
       // uncomment to debug
-      // process.stderr.write('log:' + line + '\n');
+      process.stderr.write('log:' + line + '\n');
+    });
+    dbgSpy.mockImplementation(msg => {
+      // uncomment to see debug output
+      // process.stderr.write(msg + '\n');
     });
   });
 
   afterEach(() => {
     jest.resetAllMocks();
     jest.clearAllMocks();
+    //jest.restoreAllMocks();
   });
 
-  afterAll(async () => {}, 100000);
+  afterAll(async () => {
+    jest.restoreAllMocks();
+  }, 100000);
 
-  it('can query versions', async () => {
-    let versions: im.IGoVersion[] | null = await im.getVersions(
-      'https://non.existant.com/path'
+  it('can find 1.9.7 from manifest on osx', async () => {
+    os.platform = 'darwin';
+    os.arch = 'x64';
+
+    let match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
+    expect(match).toBeDefined();
+    expect(match!.resolvedVersion).toBe('1.9.7');
+    expect(match!.type).toBe('manifest');
+    expect(match!.downloadUrl).toBe(
+      'https://github.com/actions/go-versions/releases/download/1.9.7/go-1.9.7-darwin-x64.tar.gz'
     );
-    expect(versions).toBeDefined();
-    let l: number = versions ? versions.length : 0;
-    expect(l).toBe(91);
   });
 
-  it('finds stable match for exact version', async () => {
+  it('can find 1.9 from manifest on linux', async () => {
+    os.platform = 'linux';
+    os.arch = 'x64';
+
+    let match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
+    expect(match).toBeDefined();
+    expect(match!.resolvedVersion).toBe('1.9.7');
+    expect(match!.type).toBe('manifest');
+    expect(match!.downloadUrl).toBe(
+      'https://github.com/actions/go-versions/releases/download/1.9.7/go-1.9.7-linux-x64.tar.gz'
+    );
+  });
+
+  it('can find 1.9 from manifest on windows', async () => {
     os.platform = 'win32';
     os.arch = 'x64';
 
-    // get request is already mocked
-    // spec: 1.13.7 => 1.13.7 (exact)
-    let match: im.IGoVersion | undefined = await im.findMatch('1.13.7', true);
+    let match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
     expect(match).toBeDefined();
-    let version: string = match ? match.version : '';
-    expect(version).toBe('go1.13.7');
-    let fileName = match ? match.files[0].filename : '';
-    expect(fileName).toBe('go1.13.7.windows-amd64.zip');
+    expect(match!.resolvedVersion).toBe('1.9.7');
+    expect(match!.type).toBe('manifest');
+    expect(match!.downloadUrl).toBe(
+      'https://github.com/actions/go-versions/releases/download/1.9.7/go-1.9.7-win32-x64.zip'
+    );
   });
 
   it('finds stable match for exact dot zero version', async () => {
@@ -95,7 +147,7 @@ describe('setup-go', () => {
     os.arch = 'x64';
 
     // spec: 1.13.0 => 1.13
-    let match: im.IGoVersion | undefined = await im.findMatch('1.13.0', true);
+    let match: im.IGoVersion | undefined = await im.findMatch('1.13.0');
     expect(match).toBeDefined();
     let version: string = match ? match.version : '';
     expect(version).toBe('go1.13');
@@ -108,7 +160,7 @@ describe('setup-go', () => {
     os.arch = 'x64';
 
     // spec: 1.13 => 1.13.7 (latest)
-    let match: im.IGoVersion | undefined = await im.findMatch('1.13', true);
+    let match: im.IGoVersion | undefined = await im.findMatch('1.13');
     expect(match).toBeDefined();
     let version: string = match ? match.version : '';
     expect(version).toBe('go1.13.7');
@@ -121,7 +173,7 @@ describe('setup-go', () => {
     os.arch = 'x64';
 
     // spec: ^1.13.6 => 1.13.7
-    let match: im.IGoVersion | undefined = await im.findMatch('^1.13.6', true);
+    let match: im.IGoVersion | undefined = await im.findMatch('^1.13.6');
     expect(match).toBeDefined();
     let version: string = match ? match.version : '';
     expect(version).toBe('go1.13.7');
@@ -134,7 +186,7 @@ describe('setup-go', () => {
     os.arch = 'x32';
 
     // spec: 1 => 1.13.7 (latest)
-    let match: im.IGoVersion | undefined = await im.findMatch('1', true);
+    let match: im.IGoVersion | undefined = await im.findMatch('1');
     expect(match).toBeDefined();
     let version: string = match ? match.version : '';
     expect(version).toBe('go1.13.7');
@@ -147,10 +199,7 @@ describe('setup-go', () => {
     os.arch = 'x64';
 
     // spec: 1.14, stable=false => go1.14rc1
-    let match: im.IGoVersion | undefined = await im.findMatch(
-      '1.14.0-rc1',
-      false
-    );
+    let match: im.IGoVersion | undefined = await im.findMatch('1.14.0-rc.1');
     expect(match).toBeDefined();
     let version: string = match ? match.version : '';
     expect(version).toBe('go1.14rc1');
@@ -164,9 +213,9 @@ describe('setup-go', () => {
 
     let toolPath = path.normalize('/cache/go/1.13.0/x64');
     findSpy.mockImplementation(() => toolPath);
-    await run();
+    await main.run();
 
-    expect(logSpy).toHaveBeenCalledWith(`Setup go stable version spec 1.13.0`);
+    expect(logSpy).toHaveBeenCalledWith(`Setup go version spec 1.13.0`);
   });
 
   it('evaluates to stable with no input', async () => {
@@ -176,9 +225,9 @@ describe('setup-go', () => {
 
     let toolPath = path.normalize('/cache/go/1.13.0/x64');
     findSpy.mockImplementation(() => toolPath);
-    await run();
+    await main.run();
 
-    expect(logSpy).toHaveBeenCalledWith(`Setup go stable version spec 1.13.0`);
+    expect(logSpy).toHaveBeenCalledWith(`Setup go version spec 1.13.0`);
   });
 
   it('finds a version of go already in the cache', async () => {
@@ -186,16 +235,17 @@ describe('setup-go', () => {
 
     let toolPath = path.normalize('/cache/go/1.13.0/x64');
     findSpy.mockImplementation(() => toolPath);
-    await run();
+    await main.run();
 
     let expPath = path.join(toolPath, 'bin');
+    expect(logSpy).toHaveBeenCalledWith(`Found in cache @ ${toolPath}`);
   });
 
   it('finds a version in the cache and adds it to the path', async () => {
     inputs['go-version'] = '1.13.0';
     let toolPath = path.normalize('/cache/go/1.13.0/x64');
     findSpy.mockImplementation(() => toolPath);
-    await run();
+    await main.run();
 
     let expPath = path.join(toolPath, 'bin');
     expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
@@ -208,7 +258,7 @@ describe('setup-go', () => {
     findSpy.mockImplementation(() => {
       throw new Error(errMsg);
     });
-    await run();
+    await main.run();
     expect(cnSpy).toHaveBeenCalledWith('::error::' + errMsg + osm.EOL);
   });
 
@@ -223,7 +273,7 @@ describe('setup-go', () => {
     let toolPath = path.normalize('/cache/go/1.13.0/x64');
     exSpy.mockImplementation(() => '/some/other/temp/path');
     cacheSpy.mockImplementation(() => toolPath);
-    await run();
+    await main.run();
 
     let expPath = path.join(toolPath, 'bin');
 
@@ -239,13 +289,124 @@ describe('setup-go', () => {
     inputs['go-version'] = '9.99.9';
 
     findSpy.mockImplementation(() => '');
-    await run();
+    await main.run();
 
     expect(cnSpy).toHaveBeenCalledWith(
-      `::error::Could not find a version that satisfied version spec: 9.99.9${osm.EOL}`
+      `::error::Unable to find Go version '9.99.9' for platform linux and architecture x64.${osm.EOL}`
     );
   });
 
+  it('downloads a version from a manifest match', async () => {
+    os.platform = 'linux';
+    os.arch = 'x64';
+
+    let versionSpec = '1.12.16';
+
+    inputs['go-version'] = versionSpec;
+    inputs['token'] = 'faketoken';
+
+    let expectedUrl =
+      'https://github.com/actions/go-versions/releases/download/1.12.16-20200616.20/go-1.12.16-linux-x64.tar.gz';
+
+    // ... but not in the local cache
+    findSpy.mockImplementation(() => '');
+
+    dlSpy.mockImplementation(async () => '/some/temp/path');
+    let toolPath = path.normalize('/cache/go/1.12.16/x64');
+    exSpy.mockImplementation(async () => '/some/other/temp/path');
+    cacheSpy.mockImplementation(async () => toolPath);
+
+    await main.run();
+
+    let expPath = path.join(toolPath, 'bin');
+
+    expect(dlSpy).toHaveBeenCalled();
+    expect(exSpy).toHaveBeenCalled();
+    expect(logSpy).not.toHaveBeenCalledWith(
+      'Not found in manifest.  Falling back to download directly from Go'
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      `Acquiring 1.12.16 from ${expectedUrl}`
+    );
+
+    expect(logSpy).toHaveBeenCalledWith(`Added go to the path`);
+    expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
+  });
+
+  it('downloads a major and minor from a manifest match', async () => {
+    os.platform = 'linux';
+    os.arch = 'x64';
+
+    let versionSpec = '1.12';
+
+    inputs['go-version'] = versionSpec;
+    inputs['token'] = 'faketoken';
+
+    let expectedUrl =
+      'https://github.com/actions/go-versions/releases/download/1.12.17-20200616.21/go-1.12.17-linux-x64.tar.gz';
+
+    // ... but not in the local cache
+    findSpy.mockImplementation(() => '');
+
+    dlSpy.mockImplementation(async () => '/some/temp/path');
+    let toolPath = path.normalize('/cache/go/1.12.17/x64');
+    exSpy.mockImplementation(async () => '/some/other/temp/path');
+    cacheSpy.mockImplementation(async () => toolPath);
+
+    await main.run();
+
+    let expPath = path.join(toolPath, 'bin');
+
+    expect(dlSpy).toHaveBeenCalled();
+    expect(exSpy).toHaveBeenCalled();
+    expect(logSpy).not.toHaveBeenCalledWith(
+      'Not found in manifest.  Falling back to download directly from Go'
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      `Acquiring 1.12.17 from ${expectedUrl}`
+    );
+
+    expect(logSpy).toHaveBeenCalledWith(`Added go to the path`);
+    expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
+  });
+
+  it('falls back to a version from node dist', async () => {
+    os.platform = 'linux';
+    os.arch = 'x64';
+
+    let versionSpec = '1.12.14';
+
+    inputs['go-version'] = versionSpec;
+    inputs['token'] = 'faketoken';
+
+    let expectedUrl =
+      'https://github.com/actions/go-versions/releases/download/1.12.14-20200616.18/go-1.12.14-linux-x64.tar.gz';
+
+    // ... but not in the local cache
+    findSpy.mockImplementation(() => '');
+
+    dlSpy.mockImplementation(async () => '/some/temp/path');
+    let toolPath = path.normalize('/cache/go/1.12.14/x64');
+    exSpy.mockImplementation(async () => '/some/other/temp/path');
+    cacheSpy.mockImplementation(async () => toolPath);
+
+    await main.run();
+
+    let expPath = path.join(toolPath, 'bin');
+    expect(logSpy).toHaveBeenCalledWith('Setup go version spec 1.12.14');
+    expect(findSpy).toHaveBeenCalled();
+    expect(logSpy).toHaveBeenCalledWith('Attempting to download 1.12.14...');
+    expect(dlSpy).toHaveBeenCalled();
+    expect(logSpy).toHaveBeenCalledWith('matching 1.12.14...');
+    expect(exSpy).toHaveBeenCalled();
+    expect(logSpy).toHaveBeenCalledWith(
+      'Not found in manifest.  Falling back to download directly from Go'
+    );
+    expect(logSpy).toHaveBeenCalledWith(`Install from dist`);
+    expect(logSpy).toHaveBeenCalledWith(`Added go to the path`);
+    expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
+  });
+
   it('reports a failed download', async () => {
     let errMsg = 'unhandled download message';
     os.platform = 'linux';
@@ -257,36 +418,150 @@ describe('setup-go', () => {
     dlSpy.mockImplementation(() => {
       throw new Error(errMsg);
     });
-    await run();
+    await main.run();
 
     expect(cnSpy).toHaveBeenCalledWith(
       `::error::Failed to download version 1.13.1: Error: ${errMsg}${osm.EOL}`
     );
   });
 
-  it('reports empty query results', async () => {
-    let errMsg = 'unhandled download message';
-    os.platform = 'linux';
-    os.arch = 'x64';
+  it('does not add BIN if go is not in path', async () => {
+    whichSpy.mockImplementation(async () => {
+      return '';
+    });
+    let added = await main.addBinToPath();
+    expect(added).toBeFalsy();
+  });
 
-    inputs['go-version'] = '1.13.1';
+  it('adds bin if dir not exists', async () => {
+    whichSpy.mockImplementation(async () => {
+      return '/usr/local/go/bin/go';
+    });
 
-    findSpy.mockImplementation(() => '');
-    getSpy.mockImplementation(() => null);
-    await run();
+    execSpy.mockImplementation(() => {
+      return '/Users/testuser/go';
+    });
 
-    expect(cnSpy).toHaveBeenCalledWith(
-      `::error::Failed to download version 1.13.1: Error: golang download url did not return results${osm.EOL}`
-    );
+    mkdirpSpy.mockImplementation(async () => {});
+    existsSpy.mockImplementation(path => {
+      return false;
+    });
+
+    let added = await main.addBinToPath();
+    expect(added).toBeTruthy;
+  });
+
+  interface Annotation {
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+  }
+
+  //
+  // problem matcher regex pattern tests
+
+  function testMatch(line: string): Annotation {
+    let annotation = <Annotation>{};
+
+    let match = matcherRegExp.exec(line);
+    if (match) {
+      annotation.line = parseInt(match[matcherPattern.line], 10);
+      annotation.column = parseInt(match[matcherPattern.column], 10);
+      annotation.file = match[matcherPattern.file].trim();
+      annotation.message = match[matcherPattern.message].trim();
+    }
+
+    return annotation;
+  }
+
+  it('matches on relative unix path', async () => {
+    let line = './main.go:13:2: undefined: fmt.Printl';
+    let annotation = testMatch(line);
+    expect(annotation).toBeDefined();
+    expect(annotation.line).toBe(13);
+    expect(annotation.column).toBe(2);
+    expect(annotation.file).toBe('./main.go');
+    expect(annotation.message).toBe('undefined: fmt.Printl');
+  });
+
+  it('matches on unix path up the tree', async () => {
+    let line = '../main.go:13:2: undefined: fmt.Printl';
+    let annotation = testMatch(line);
+    expect(annotation).toBeDefined();
+    expect(annotation.line).toBe(13);
+    expect(annotation.column).toBe(2);
+    expect(annotation.file).toBe('../main.go');
+    expect(annotation.message).toBe('undefined: fmt.Printl');
+  });
+
+  it('matches on unix path down the tree', async () => {
+    let line = 'foo/main.go:13:2: undefined: fmt.Printl';
+    let annotation = testMatch(line);
+    expect(annotation).toBeDefined();
+    expect(annotation.line).toBe(13);
+    expect(annotation.column).toBe(2);
+    expect(annotation.file).toBe('foo/main.go');
+    expect(annotation.message).toBe('undefined: fmt.Printl');
+  });
+
+  it('matches on rooted unix path', async () => {
+    let line = '/assert.go:4:1: missing return at end of function';
+    let annotation = testMatch(line);
+    expect(annotation).toBeDefined();
+    expect(annotation.line).toBe(4);
+    expect(annotation.column).toBe(1);
+    expect(annotation.file).toBe('/assert.go');
+    expect(annotation.message).toBe('missing return at end of function');
+  });
+
+  it('matches on unix path with spaces', async () => {
+    let line = '   ./assert.go:5:2: missing return at end of function   ';
+    let annotation = testMatch(line);
+    expect(annotation).toBeDefined();
+    expect(annotation.line).toBe(5);
+    expect(annotation.column).toBe(2);
+    expect(annotation.file).toBe('./assert.go');
+    expect(annotation.message).toBe('missing return at end of function');
+  });
+
+  it('matches on unix path with tabs', async () => {
+    let line = '\t./assert.go:5:2: missing return at end of function   ';
+    let annotation = testMatch(line);
+    expect(annotation).toBeDefined();
+    expect(annotation.line).toBe(5);
+    expect(annotation.column).toBe(2);
+    expect(annotation.file).toBe('./assert.go');
+    expect(annotation.message).toBe('missing return at end of function');
+  });
+
+  it('matches on relative windows path', async () => {
+    let line = '.\\main.go:13:2: undefined: fmt.Printl';
+    let annotation = testMatch(line);
+    expect(annotation).toBeDefined();
+    expect(annotation.line).toBe(13);
+    expect(annotation.column).toBe(2);
+    expect(annotation.file).toBe('.\\main.go');
+    expect(annotation.message).toBe('undefined: fmt.Printl');
+  });
+
+  it('matches on windows path up the tree', async () => {
+    let line = '..\\main.go:13:2: undefined: fmt.Printl';
+    let annotation = testMatch(line);
+    expect(annotation).toBeDefined();
+    expect(annotation.line).toBe(13);
+    expect(annotation.column).toBe(2);
+    expect(annotation.file).toBe('..\\main.go');
+    expect(annotation.message).toBe('undefined: fmt.Printl');
   });
 
   // 1.13.1 => 1.13.1
   // 1.13 => 1.13.0
-  // 1.10beta1 => 1.10.0-beta1, 1.10rc1 => 1.10.0-rc1
-  // 1.8.5beta1 => 1.8.5-beta1, 1.8.5rc1 => 1.8.5-rc1
+  // 1.10beta1 => 1.10.0-beta.1, 1.10rc1 => 1.10.0-rc.1
+  // 1.8.5beta1 => 1.8.5-beta.1, 1.8.5rc1 => 1.8.5-rc.1
   it('converts prerelease versions', async () => {
-    expect(im.makeSemver('1.10beta1')).toBe('1.10.0-beta1');
-    expect(im.makeSemver('1.10rc1')).toBe('1.10.0-rc1');
+    expect(im.makeSemver('1.10beta1')).toBe('1.10.0-beta.1');
+    expect(im.makeSemver('1.10rc1')).toBe('1.10.0-rc.1');
   });
 
   it('converts dot zero versions', async () => {
@@ -296,4 +571,166 @@ describe('setup-go', () => {
   it('does not convert exact versions', async () => {
     expect(im.makeSemver('1.13.1')).toBe('1.13.1');
   });
+
+  describe('check-latest flag', () => {
+    it("use local version and don't check manifest if check-latest is not specified", async () => {
+      os.platform = 'linux';
+      os.arch = 'x64';
+
+      inputs['go-version'] = '1.16';
+      inputs['check-latest'] = false;
+
+      const toolPath = path.normalize('/cache/go/1.16.1/x64');
+      findSpy.mockReturnValue(toolPath);
+      await main.run();
+
+      expect(logSpy).toHaveBeenCalledWith(`Found in cache @ ${toolPath}`);
+      expect(logSpy).not.toHaveBeenCalledWith(
+        'Attempting to resolve the latest version from the manifest...'
+      );
+    });
+
+    it('check latest version and resolve it from local cache', async () => {
+      os.platform = 'linux';
+      os.arch = 'x64';
+
+      inputs['go-version'] = '1.16';
+      inputs['check-latest'] = true;
+
+      const toolPath = path.normalize('/cache/go/1.16.1/x64');
+      findSpy.mockReturnValue(toolPath);
+      dlSpy.mockImplementation(async () => '/some/temp/path');
+      exSpy.mockImplementation(async () => '/some/other/temp/path');
+      cacheSpy.mockImplementation(async () => toolPath);
+
+      await main.run();
+
+      expect(logSpy).toHaveBeenCalledWith('Setup go version spec 1.16');
+      expect(logSpy).toHaveBeenCalledWith(`Found in cache @ ${toolPath}`);
+    });
+
+    it('check latest version and install it from manifest', async () => {
+      os.platform = 'linux';
+      os.arch = 'x64';
+
+      const versionSpec = '1.17';
+      const patchVersion = '1.17.6';
+      inputs['go-version'] = versionSpec;
+      inputs['stable'] = 'true';
+      inputs['check-latest'] = true;
+
+      findSpy.mockImplementation(() => '');
+      dlSpy.mockImplementation(async () => '/some/temp/path');
+      const toolPath = path.normalize('/cache/go/1.17.5/x64');
+      exSpy.mockImplementation(async () => '/some/other/temp/path');
+      cacheSpy.mockImplementation(async () => toolPath);
+      const expectedUrl =
+        'https://github.com/actions/go-versions/releases/download/1.17.6-1668090892/go-1.17.6-darwin-x64.tar.gz';
+
+      await main.run();
+
+      expect(logSpy).toHaveBeenCalledWith(
+        `Setup go version spec ${versionSpec}`
+      );
+      expect(logSpy).toHaveBeenCalledWith(
+        'Attempting to resolve the latest version from the manifest...'
+      );
+      expect(logSpy).toHaveBeenCalledWith(`Resolved as '${patchVersion}'`);
+      expect(logSpy).toHaveBeenCalledWith(
+        `Attempting to download ${patchVersion}...`
+      );
+      expect(logSpy).toHaveBeenCalledWith('Extracting Go...');
+      expect(logSpy).toHaveBeenCalledWith('Adding to the cache ...');
+      expect(logSpy).toHaveBeenCalledWith('Added go to the path');
+      expect(logSpy).toHaveBeenCalledWith(
+        `Successfully setup go version ${versionSpec}`
+      );
+    });
+
+    it('fallback to dist if version is not found in manifest', async () => {
+      os.platform = 'linux';
+      os.arch = 'x64';
+
+      let versionSpec = '1.13';
+
+      inputs['go-version'] = versionSpec;
+      inputs['check-latest'] = true;
+      inputs['always-auth'] = false;
+      inputs['token'] = 'faketoken';
+
+      // ... but not in the local cache
+      findSpy.mockImplementation(() => '');
+
+      dlSpy.mockImplementation(async () => '/some/temp/path');
+      let toolPath = path.normalize('/cache/go/1.13.7/x64');
+      exSpy.mockImplementation(async () => '/some/other/temp/path');
+      cacheSpy.mockImplementation(async () => toolPath);
+
+      await main.run();
+
+      let expPath = path.join(toolPath, 'bin');
+
+      expect(dlSpy).toHaveBeenCalled();
+      expect(exSpy).toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledWith(
+        'Attempting to resolve the latest version from the manifest...'
+      );
+      expect(logSpy).toHaveBeenCalledWith(
+        `Failed to resolve version ${versionSpec} from manifest`
+      );
+      expect(logSpy).toHaveBeenCalledWith(
+        `Attempting to download ${versionSpec}...`
+      );
+      expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
+    });
+
+    it('fallback to dist if manifest is not available', async () => {
+      os.platform = 'linux';
+      os.arch = 'x64';
+
+      let versionSpec = '1.13';
+
+      process.env['GITHUB_PATH'] = '';
+
+      inputs['go-version'] = versionSpec;
+      inputs['check-latest'] = true;
+      inputs['always-auth'] = false;
+      inputs['token'] = 'faketoken';
+
+      // ... but not in the local cache
+      findSpy.mockImplementation(() => '');
+      getManifestSpy.mockImplementation(() => {
+        throw new Error('Unable to download manifest');
+      });
+
+      dlSpy.mockImplementation(async () => '/some/temp/path');
+      let toolPath = path.normalize('/cache/go/1.13.7/x64');
+      exSpy.mockImplementation(async () => '/some/other/temp/path');
+      cacheSpy.mockImplementation(async () => toolPath);
+
+      await main.run();
+
+      let expPath = path.join(toolPath, 'bin');
+
+      expect(logSpy).toHaveBeenCalledWith(
+        `Failed to resolve version ${versionSpec} from manifest`
+      );
+      expect(dlSpy).toHaveBeenCalled();
+      expect(exSpy).toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledWith(
+        'Attempting to resolve the latest version from the manifest...'
+      );
+      expect(logSpy).toHaveBeenCalledWith(
+        'Unable to resolve a version from the manifest...'
+      );
+      expect(logSpy).toHaveBeenCalledWith(
+        `Failed to resolve version ${versionSpec} from manifest`
+      );
+      expect(logSpy).toHaveBeenCalledWith(
+        `Attempting to download ${versionSpec}...`
+      );
+
+      expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
+    });
+  });
 });

__tests__/verify-go.sh

@@ -0,0 +1,14 @@
+  
+#!/bin/sh
+
+if [ -z "$1" ]; then
+  echo "Must supply go version argument"
+  exit 1
+fi
+
+go_version="$(go version)"
+echo "Found go version '$go_version'"
+if [ -z "$(echo $go_version | grep $1)" ]; then
+  echo "Unexpected version"
+  exit 1
+fi

action.yml

@@ -4,9 +4,12 @@ author: 'GitHub'
 inputs: 
   go-version:
     description: 'The Go version to download (if necessary) and use. Supports semver spec and ranges.'
-  stable:
-    description: 'Whether to download only stable versions'
-    default: 'true'
+  check-latest:
+    description: 'Set this option to true if you want the action to always check for the latest available version that satisfies the version spec'
+    default: false
+  token:
+    description: Used to pull node distributions from go-versions.  Since there's a default, this is typically not supplied by the user.
+    default: ${{ github.token }}
 runs:
-  using: 'node12'
+  using: 'node16'
   main: 'dist/index.js'

matchers.json

@@ -4,13 +4,13 @@
             "owner": "go",
             "pattern": [
                 {
-                    "regexp": "^([^:]*: )?((.:)?[^:]*):(\\d+)(:(\\d+))?: (.*)$",
-                    "file": 2,
-                    "line": 4,
-                    "column": 6,
-                    "message": 7
+                    "regexp": "^\\s*(.+\\.go):(?:(\\d+):(\\d+):)? (.*)",
+                    "file": 1,
+                    "line": 2,
+                    "column": 3,
+                    "message": 4
                 }
             ]
         }
     ]
-}
+}

package.json

@@ -23,22 +23,22 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.2.2",
+    "@actions/core": "^1.6.0",
     "@actions/http-client": "^1.0.6",
     "@actions/io": "^1.0.2",
-    "@actions/tool-cache": "^1.3.3",
+    "@actions/tool-cache": "^1.5.5",
     "semver": "^6.1.1"
   },
   "devDependencies": {
-    "@types/jest": "^24.0.13",
-    "@types/node": "^12.0.4",
+    "@types/jest": "^27.0.2",
+    "@types/node": "^16.11.25",
     "@types/semver": "^6.0.0",
     "@zeit/ncc": "^0.21.0",
-    "jest": "^25.2.1",
-    "jest-circus": "^24.7.1",
+    "jest": "^27.2.5",
+    "jest-circus": "^27.2.5",
     "nock": "^10.0.6",
     "prettier": "^1.17.1",
-    "ts-jest": "^24.0.2",
-    "typescript": "^3.5.1"
+    "ts-jest": "^27.0.5",
+    "typescript": "^3.8.3"
   }
 }

src/installer.ts

@@ -1,46 +1,12 @@
 import * as tc from '@actions/tool-cache';
+import * as core from '@actions/core';
 import * as path from 'path';
 import * as semver from 'semver';
 import * as httpm from '@actions/http-client';
 import * as sys from './system';
-import {debug} from '@actions/core';
+import os from 'os';
 
-export async function downloadGo(
-  versionSpec: string,
-  stable: boolean
-): Promise<string | undefined> {
-  let toolPath: string | undefined;
-
-  try {
-    let match: IGoVersion | undefined = await findMatch(versionSpec, stable);
-
-    if (match) {
-      // download
-      debug(`match ${match.version}`);
-      let downloadUrl: string = `https://storage.googleapis.com/golang/${match.files[0].filename}`;
-      console.log(`Downloading from ${downloadUrl}`);
-
-      let downloadPath: string = await tc.downloadTool(downloadUrl);
-      debug(`downloaded to ${downloadPath}`);
-
-      // extract
-      console.log('Extracting ...');
-      let extPath: string =
-        sys.getPlatform() == 'windows'
-          ? await tc.extractZip(downloadPath)
-          : await tc.extractTar(downloadPath);
-      debug(`extracted to ${extPath}`);
-
-      // extracts with a root folder that matches the fileName downloaded
-      const toolRoot = path.join(extPath, 'go');
-      toolPath = await tc.cacheDir(toolRoot, 'go', makeSemver(match.version));
-    }
-  } catch (error) {
-    throw new Error(`Failed to download version ${versionSpec}: ${error}`);
-  }
-
-  return toolPath;
-}
+type InstallationType = 'dist' | 'manifest';
 
 export interface IGoVersionFile {
   filename: string;
@@ -55,9 +21,195 @@ export interface IGoVersion {
   files: IGoVersionFile[];
 }
 
-export async function findMatch(
+export interface IGoVersionInfo {
+  type: InstallationType;
+  downloadUrl: string;
+  resolvedVersion: string;
+  fileName: string;
+}
+
+export async function getGo(
   versionSpec: string,
-  stable: boolean
+  checkLatest: boolean,
+  auth: string | undefined
+) {
+  let osPlat: string = os.platform();
+  let osArch: string = os.arch();
+
+  if (checkLatest) {
+    core.info('Attempting to resolve the latest version from the manifest...');
+    const resolvedVersion = await resolveVersionFromManifest(
+      versionSpec,
+      true,
+      auth
+    );
+    if (resolvedVersion) {
+      versionSpec = resolvedVersion;
+      core.info(`Resolved as '${versionSpec}'`);
+    } else {
+      core.info(`Failed to resolve version ${versionSpec} from manifest`);
+    }
+  }
+
+  // check cache
+  let toolPath: string;
+  toolPath = tc.find('go', versionSpec);
+  // If not found in cache, download
+  if (toolPath) {
+    core.info(`Found in cache @ ${toolPath}`);
+    return toolPath;
+  }
+  core.info(`Attempting to download ${versionSpec}...`);
+  let downloadPath = '';
+  let info: IGoVersionInfo | null = null;
+
+  //
+  // Try download from internal distribution (popular versions only)
+  //
+  try {
+    info = await getInfoFromManifest(versionSpec, true, auth);
+    if (info) {
+      downloadPath = await installGoVersion(info, auth);
+    } else {
+      core.info(
+        'Not found in manifest.  Falling back to download directly from Go'
+      );
+    }
+  } catch (err) {
+    if (
+      err instanceof tc.HTTPError &&
+      (err.httpStatusCode === 403 || err.httpStatusCode === 429)
+    ) {
+      core.info(
+        `Received HTTP status code ${err.httpStatusCode}.  This usually indicates the rate limit has been exceeded`
+      );
+    } else {
+      core.info(err.message);
+    }
+    core.debug(err.stack);
+    core.info('Falling back to download directly from Go');
+  }
+
+  //
+  // Download from storage.googleapis.com
+  //
+  if (!downloadPath) {
+    info = await getInfoFromDist(versionSpec);
+    if (!info) {
+      throw new Error(
+        `Unable to find Go version '${versionSpec}' for platform ${osPlat} and architecture ${osArch}.`
+      );
+    }
+
+    try {
+      core.info('Install from dist');
+      downloadPath = await installGoVersion(info, undefined);
+    } catch (err) {
+      throw new Error(`Failed to download version ${versionSpec}: ${err}`);
+    }
+  }
+
+  return downloadPath;
+}
+
+async function resolveVersionFromManifest(
+  versionSpec: string,
+  stable: boolean,
+  auth: string | undefined
+): Promise<string | undefined> {
+  try {
+    const info = await getInfoFromManifest(versionSpec, stable, auth);
+    return info?.resolvedVersion;
+  } catch (err) {
+    core.info('Unable to resolve a version from the manifest...');
+    core.debug(err.message);
+  }
+}
+
+async function installGoVersion(
+  info: IGoVersionInfo,
+  auth: string | undefined
+): Promise<string> {
+  core.info(`Acquiring ${info.resolvedVersion} from ${info.downloadUrl}`);
+  const downloadPath = await tc.downloadTool(info.downloadUrl, undefined, auth);
+
+  core.info('Extracting Go...');
+  let extPath = await extractGoArchive(downloadPath);
+  core.info(`Successfully extracted go to ${extPath}`);
+  if (info.type === 'dist') {
+    extPath = path.join(extPath, 'go');
+  }
+
+  core.info('Adding to the cache ...');
+  const cachedDir = await tc.cacheDir(
+    extPath,
+    'go',
+    makeSemver(info.resolvedVersion)
+  );
+  core.info(`Successfully cached go to ${cachedDir}`);
+  return cachedDir;
+}
+
+export async function extractGoArchive(archivePath: string): Promise<string> {
+  const platform = os.platform();
+  let extPath: string;
+
+  if (platform === 'win32') {
+    extPath = await tc.extractZip(archivePath);
+  } else {
+    extPath = await tc.extractTar(archivePath);
+  }
+
+  return extPath;
+}
+
+export async function getInfoFromManifest(
+  versionSpec: string,
+  stable: boolean,
+  auth: string | undefined
+): Promise<IGoVersionInfo | null> {
+  let info: IGoVersionInfo | null = null;
+  const releases = await tc.getManifestFromRepo(
+    'actions',
+    'go-versions',
+    auth,
+    'main'
+  );
+  core.info(`matching ${versionSpec}...`);
+  const rel = await tc.findFromManifest(versionSpec, stable, releases);
+
+  if (rel && rel.files.length > 0) {
+    info = <IGoVersionInfo>{};
+    info.type = 'manifest';
+    info.resolvedVersion = rel.version;
+    info.downloadUrl = rel.files[0].download_url;
+    info.fileName = rel.files[0].filename;
+  }
+
+  return info;
+}
+
+async function getInfoFromDist(
+  versionSpec: string
+): Promise<IGoVersionInfo | null> {
+  let version: IGoVersion | undefined;
+  version = await findMatch(versionSpec);
+  if (!version) {
+    return null;
+  }
+
+  let downloadUrl: string = `https://storage.googleapis.com/golang/${version.files[0].filename}`;
+
+  return <IGoVersionInfo>{
+    type: 'dist',
+    downloadUrl: downloadUrl,
+    resolvedVersion: version.version,
+    fileName: version.files[0].filename
+  };
+}
+
+export async function findMatch(
+  versionSpec: string
 ): Promise<IGoVersion | undefined> {
   let archFilter = sys.getArch();
   let platFilter = sys.getPlatform();
@@ -66,7 +218,9 @@ export async function findMatch(
   let match: IGoVersion | undefined;
 
   const dlUrl: string = 'https://golang.org/dl/?mode=json&include=all';
-  let candidates: IGoVersion[] | null = await module.exports.getVersions(dlUrl);
+  let candidates: IGoVersion[] | null = await module.exports.getVersionsDist(
+    dlUrl
+  );
   if (!candidates) {
     throw new Error(`golang download url did not return results`);
   }
@@ -76,25 +230,17 @@ export async function findMatch(
     let candidate: IGoVersion = candidates[i];
     let version = makeSemver(candidate.version);
 
-    // 1.13.0 is advertised as 1.13 preventing being able to match exactly 1.13.0
-    // since a semver of 1.13 would match latest 1.13
-    let parts: string[] = version.split('.');
-    if (parts.length == 2) {
-      version = version + '.0';
-    }
-
-    debug(`check ${version} satisfies ${versionSpec}`);
-    if (
-      semver.satisfies(version, versionSpec) &&
-      (!stable || candidate.stable === stable)
-    ) {
+    core.debug(`check ${version} satisfies ${versionSpec}`);
+    if (semver.satisfies(version, versionSpec)) {
       goFile = candidate.files.find(file => {
-        debug(`${file.arch}===${archFilter} && ${file.os}===${platFilter}`);
+        core.debug(
+          `${file.arch}===${archFilter} && ${file.os}===${platFilter}`
+        );
         return file.arch === archFilter && file.os === platFilter;
       });
 
       if (goFile) {
-        debug(`matched ${candidate.version}`);
+        core.debug(`matched ${candidate.version}`);
         match = candidate;
         break;
       }
@@ -110,9 +256,14 @@ export async function findMatch(
   return result;
 }
 
-export async function getVersions(dlUrl: string): Promise<IGoVersion[] | null> {
+export async function getVersionsDist(
+  dlUrl: string
+): Promise<IGoVersion[] | null> {
   // this returns versions descending so latest is first
-  let http: httpm.HttpClient = new httpm.HttpClient('setup-go');
+  let http: httpm.HttpClient = new httpm.HttpClient('setup-go', [], {
+    allowRedirects: true,
+    maxRedirects: 3
+  });
   return (await http.getJson<IGoVersion[]>(dlUrl)).result;
 }
 
@@ -120,20 +271,30 @@ export async function getVersions(dlUrl: string): Promise<IGoVersion[] | null> {
 // Convert the go version syntax into semver for semver matching
 // 1.13.1 => 1.13.1
 // 1.13 => 1.13.0
-// 1.10beta1 => 1.10.0-beta1, 1.10rc1 => 1.10.0-rc1
-// 1.8.5beta1 => 1.8.5-beta1, 1.8.5rc1 => 1.8.5-rc1
+// 1.10beta1 => 1.10.0-beta.1, 1.10rc1 => 1.10.0-rc.1
+// 1.8.5beta1 => 1.8.5-beta.1, 1.8.5rc1 => 1.8.5-rc.1
 export function makeSemver(version: string): string {
   version = version.replace('go', '');
-  version = version.replace('beta', '-beta').replace('rc', '-rc');
+  version = version.replace('beta', '-beta.').replace('rc', '-rc.');
   let parts = version.split('-');
 
-  let verPart: string = parts[0];
-  let prereleasePart = parts.length > 1 ? `-${parts[1]}` : '';
-
-  let verParts: string[] = verPart.split('.');
-  if (verParts.length == 2) {
-    verPart += '.0';
+  let semVersion = semver.coerce(parts[0])?.version;
+  if (!semVersion) {
+    throw new Error(
+      `The version: ${version} can't be changed to SemVer notation`
+    );
   }
 
-  return `${verPart}${prereleasePart}`;
+  if (!parts[1]) {
+    return semVersion;
+  }
+
+  const fullVersion = semver.valid(`${semVersion}-${parts[1]}`);
+
+  if (!fullVersion) {
+    throw new Error(
+      `The version: ${version} can't be changed to SemVer notation`
+    );
+  }
+  return fullVersion;
 }

src/main.ts

@@ -1,10 +1,10 @@
 import * as core from '@actions/core';
 import * as io from '@actions/io';
-import * as tc from '@actions/tool-cache';
 import * as installer from './installer';
-import * as path from 'path';
-import * as cp from 'child_process';
-import * as fs from 'fs';
+import path from 'path';
+import cp from 'child_process';
+import fs from 'fs';
+import {URL} from 'url';
 
 export async function run() {
   try {
@@ -14,48 +14,43 @@ export async function run() {
     //
     let versionSpec = core.getInput('go-version');
 
-    // stable will be true unless false is the exact input
-    // since getting unstable versions should be explicit
-    let stable = (core.getInput('stable') || 'true').toUpperCase() === 'TRUE';
-
-    console.log(
-      `Setup go ${stable ? 'stable' : ''} version spec ${versionSpec}`
-    );
+    core.info(`Setup go version spec ${versionSpec}`);
 
     if (versionSpec) {
-      let installDir: string | undefined = tc.find('go', versionSpec);
+      let token = core.getInput('token');
+      let auth = !token || isGhes() ? undefined : `token ${token}`;
 
-      if (!installDir) {
-        console.log(
-          `A version satisfying ${versionSpec} not found locally, attempting to download ...`
-        );
-        installDir = await installer.downloadGo(versionSpec, stable);
-        console.log('Installed');
-      }
+      const checkLatest = core.getBooleanInput('check-latest');
+      const installDir = await installer.getGo(versionSpec, checkLatest, auth);
 
-      if (installDir) {
-        core.exportVariable('GOROOT', installDir);
-        core.addPath(path.join(installDir, 'bin'));
-        console.log('Added go to the path');
+      core.exportVariable('GOROOT', installDir);
+      core.addPath(path.join(installDir, 'bin'));
+      core.info('Added go to the path');
 
-        let added = addBinToPath();
-        core.debug(`add bin ${added}`);
-      } else {
-        throw new Error(
-          `Could not find a version that satisfied version spec: ${versionSpec}`
-        );
-      }
+      let added = await addBinToPath();
+      core.debug(`add bin ${added}`);
+      core.info(`Successfully setup go version ${versionSpec}`);
     }
 
     // add problem matchers
     const matchersPath = path.join(__dirname, '..', 'matchers.json');
-    console.log(`##[add-matcher]${matchersPath}`);
+    core.info(`##[add-matcher]${matchersPath}`);
+
+    // output the version actually being used
+    let goPath = await io.which('go');
+    let goVersion = (cp.execSync(`${goPath} version`) || '').toString();
+    core.info(goVersion);
+
+    core.startGroup('go env');
+    let goEnv = (cp.execSync(`${goPath} env`) || '').toString();
+    core.info(goEnv);
+    core.endGroup();
   } catch (error) {
     core.setFailed(error.message);
   }
 }
 
-async function addBinToPath(): Promise<boolean> {
+export async function addBinToPath(): Promise<boolean> {
   let added = false;
   let g = await io.which('go');
   core.debug(`which go :${g}:`);
@@ -85,3 +80,10 @@ async function addBinToPath(): Promise<boolean> {
   }
   return added;
 }
+
+function isGhes(): boolean {
+  const ghUrl = new URL(
+    process.env['GITHUB_SERVER_URL'] || 'https://github.com'
+  );
+  return ghUrl.hostname.toUpperCase() !== 'GITHUB.COM';
+}

src/system.ts

@@ -1,4 +1,4 @@
-let os = require('os');
+const os = require('os');
 
 export function getPlatform(): string {
   // darwin and linux match already

tsconfig.json

@@ -4,9 +4,6 @@
     // "incremental": true,                   /* Enable incremental compilation */
     "target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */
     "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
-    "lib": [
-      "es6"
-    ],
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
     // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
@@ -48,7 +45,8 @@
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    "sourceMap": true,
     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
     // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */